llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-lldb Author: Ilia Kuklin (kuilpd) <details> <summary>Changes</summary> 1. Every `ASTNodeUP` is asserted before being used in creating another `ASTNodeUP` 2. Removed returning `nullptr` in `ParseIntegerLiteral` and `ParseFloatingPointLiteral` to avoid confusion 3. All `ASTNodes` are now passed by reference instead of pointer --- Patch is 37.62 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/173240.diff 6 Files Affected: - (modified) lldb/include/lldb/ValueObject/DILAST.h (+37-37) - (modified) lldb/include/lldb/ValueObject/DILEval.h (+12-12) - (modified) lldb/source/Target/StackFrame.cpp (+1-1) - (modified) lldb/source/ValueObject/DILAST.cpp (+9-9) - (modified) lldb/source/ValueObject/DILEval.cpp (+74-74) - (modified) lldb/source/ValueObject/DILParser.cpp (+10-5) ``````````diff diff --git a/lldb/include/lldb/ValueObject/DILAST.h b/lldb/include/lldb/ValueObject/DILAST.h index bf7d83ef3e3e1..247ea392727ff 100644 --- a/lldb/include/lldb/ValueObject/DILAST.h +++ b/lldb/include/lldb/ValueObject/DILAST.h @@ -83,8 +83,8 @@ class ErrorNode : public ASTNode { ErrorNode() : ASTNode(0, NodeKind::eErrorNode) {} llvm::Expected<lldb::ValueObjectSP> Accept(Visitor *v) const override; - static bool classof(const ASTNode *node) { - return node->GetKind() == NodeKind::eErrorNode; + static bool classof(const ASTNode &node) { + return node.GetKind() == NodeKind::eErrorNode; } }; @@ -97,8 +97,8 @@ class IdentifierNode : public ASTNode { std::string GetName() const { return m_name; } - static bool classof(const ASTNode *node) { - return node->GetKind() == NodeKind::eIdentifierNode; + static bool classof(const ASTNode &node) { + return node.GetKind() == NodeKind::eIdentifierNode; } private: @@ -114,12 +114,12 @@ class MemberOfNode : public ASTNode { llvm::Expected<lldb::ValueObjectSP> Accept(Visitor *v) const override; - ASTNode *GetBase() const { return m_base.get(); } + ASTNode &GetBase() const { return *m_base; } bool GetIsArrow() const { return m_is_arrow; } llvm::StringRef GetFieldName() const { return llvm::StringRef(m_field_name); } - static bool classof(const ASTNode *node) { - return node->GetKind() == NodeKind::eMemberOfNode; + static bool classof(const ASTNode &node) { + return node.GetKind() == NodeKind::eMemberOfNode; } private: @@ -137,10 +137,10 @@ class UnaryOpNode : public ASTNode { llvm::Expected<lldb::ValueObjectSP> Accept(Visitor *v) const override; UnaryOpKind GetKind() const { return m_kind; } - ASTNode *GetOperand() const { return m_operand.get(); } + ASTNode &GetOperand() const { return *m_operand; } - static bool classof(const ASTNode *node) { - return node->GetKind() == NodeKind::eUnaryOpNode; + static bool classof(const ASTNode &node) { + return node.GetKind() == NodeKind::eUnaryOpNode; } private: @@ -156,11 +156,11 @@ class ArraySubscriptNode : public ASTNode { llvm::Expected<lldb::ValueObjectSP> Accept(Visitor *v) const override; - ASTNode *GetBase() const { return m_base.get(); } - ASTNode *GetIndex() const { return m_index.get(); } + ASTNode &GetBase() const { return *m_base; } + ASTNode &GetIndex() const { return *m_index; } - static bool classof(const ASTNode *node) { - return node->GetKind() == NodeKind::eArraySubscriptNode; + static bool classof(const ASTNode &node) { + return node.GetKind() == NodeKind::eArraySubscriptNode; } private: @@ -178,12 +178,12 @@ class BitFieldExtractionNode : public ASTNode { llvm::Expected<lldb::ValueObjectSP> Accept(Visitor *v) const override; - ASTNode *GetBase() const { return m_base.get(); } - ASTNode *GetFirstIndex() const { return m_first_index.get(); } - ASTNode *GetLastIndex() const { return m_last_index.get(); } + ASTNode &GetBase() const { return *m_base; } + ASTNode &GetFirstIndex() const { return *m_first_index; } + ASTNode &GetLastIndex() const { return *m_last_index; } - static bool classof(const ASTNode *node) { - return node->GetKind() == NodeKind::eBitExtractionNode; + static bool classof(const ASTNode &node) { + return node.GetKind() == NodeKind::eBitExtractionNode; } private: @@ -209,8 +209,8 @@ class IntegerLiteralNode : public ASTNode { bool IsUnsigned() const { return m_is_unsigned; } IntegerTypeSuffix GetTypeSuffix() const { return m_type; } - static bool classof(const ASTNode *node) { - return node->GetKind() == NodeKind::eIntegerLiteralNode; + static bool classof(const ASTNode &node) { + return node.GetKind() == NodeKind::eIntegerLiteralNode; } private: @@ -230,8 +230,8 @@ class FloatLiteralNode : public ASTNode { const llvm::APFloat &GetValue() const { return m_value; } - static bool classof(const ASTNode *node) { - return node->GetKind() == NodeKind::eFloatLiteralNode; + static bool classof(const ASTNode &node) { + return node.GetKind() == NodeKind::eFloatLiteralNode; } private: @@ -247,8 +247,8 @@ class BooleanLiteralNode : public ASTNode { bool GetValue() const & { return m_value; } - static bool classof(const ASTNode *node) { - return node->GetKind() == NodeKind::eBooleanLiteralNode; + static bool classof(const ASTNode &node) { + return node.GetKind() == NodeKind::eBooleanLiteralNode; } private: @@ -265,11 +265,11 @@ class CastNode : public ASTNode { llvm::Expected<lldb::ValueObjectSP> Accept(Visitor *v) const override; CompilerType GetType() const { return m_type; } - ASTNode *GetOperand() const { return m_operand.get(); } + ASTNode &GetOperand() const { return *m_operand; } CastKind GetCastKind() const { return m_cast_kind; } - static bool classof(const ASTNode *node) { - return node->GetKind() == NodeKind::eCastNode; + static bool classof(const ASTNode &node) { + return node.GetKind() == NodeKind::eCastNode; } private: @@ -286,22 +286,22 @@ class Visitor { public: virtual ~Visitor() = default; virtual llvm::Expected<lldb::ValueObjectSP> - Visit(const IdentifierNode *node) = 0; + Visit(const IdentifierNode &node) = 0; virtual llvm::Expected<lldb::ValueObjectSP> - Visit(const MemberOfNode *node) = 0; + Visit(const MemberOfNode &node) = 0; virtual llvm::Expected<lldb::ValueObjectSP> - Visit(const UnaryOpNode *node) = 0; + Visit(const UnaryOpNode &node) = 0; virtual llvm::Expected<lldb::ValueObjectSP> - Visit(const ArraySubscriptNode *node) = 0; + Visit(const ArraySubscriptNode &node) = 0; virtual llvm::Expected<lldb::ValueObjectSP> - Visit(const BitFieldExtractionNode *node) = 0; + Visit(const BitFieldExtractionNode &node) = 0; virtual llvm::Expected<lldb::ValueObjectSP> - Visit(const IntegerLiteralNode *node) = 0; + Visit(const IntegerLiteralNode &node) = 0; virtual llvm::Expected<lldb::ValueObjectSP> - Visit(const FloatLiteralNode *node) = 0; + Visit(const FloatLiteralNode &node) = 0; virtual llvm::Expected<lldb::ValueObjectSP> - Visit(const BooleanLiteralNode *node) = 0; - virtual llvm::Expected<lldb::ValueObjectSP> Visit(const CastNode *node) = 0; + Visit(const BooleanLiteralNode &node) = 0; + virtual llvm::Expected<lldb::ValueObjectSP> Visit(const CastNode &node) = 0; }; } // namespace lldb_private::dil diff --git a/lldb/include/lldb/ValueObject/DILEval.h b/lldb/include/lldb/ValueObject/DILEval.h index fc4b8e1817e66..d73e1182ab01b 100644 --- a/lldb/include/lldb/ValueObject/DILEval.h +++ b/lldb/include/lldb/ValueObject/DILEval.h @@ -45,29 +45,29 @@ class Interpreter : Visitor { /// Evaluate an ASTNode. /// \returns A non-null lldb::ValueObjectSP or an Error. - llvm::Expected<lldb::ValueObjectSP> Evaluate(const ASTNode *node); + llvm::Expected<lldb::ValueObjectSP> Evaluate(const ASTNode &node); private: /// Evaluate an ASTNode. If the result is a reference, it is also /// dereferenced using ValueObject::Dereference. /// \returns A non-null lldb::ValueObjectSP or an Error. llvm::Expected<lldb::ValueObjectSP> - EvaluateAndDereference(const ASTNode *node); + EvaluateAndDereference(const ASTNode &node); llvm::Expected<lldb::ValueObjectSP> - Visit(const IdentifierNode *node) override; - llvm::Expected<lldb::ValueObjectSP> Visit(const MemberOfNode *node) override; - llvm::Expected<lldb::ValueObjectSP> Visit(const UnaryOpNode *node) override; + Visit(const IdentifierNode &node) override; + llvm::Expected<lldb::ValueObjectSP> Visit(const MemberOfNode &node) override; + llvm::Expected<lldb::ValueObjectSP> Visit(const UnaryOpNode &node) override; llvm::Expected<lldb::ValueObjectSP> - Visit(const ArraySubscriptNode *node) override; + Visit(const ArraySubscriptNode &node) override; llvm::Expected<lldb::ValueObjectSP> - Visit(const BitFieldExtractionNode *node) override; + Visit(const BitFieldExtractionNode &node) override; llvm::Expected<lldb::ValueObjectSP> - Visit(const IntegerLiteralNode *node) override; + Visit(const IntegerLiteralNode &node) override; llvm::Expected<lldb::ValueObjectSP> - Visit(const FloatLiteralNode *node) override; + Visit(const FloatLiteralNode &node) override; llvm::Expected<lldb::ValueObjectSP> - Visit(const BooleanLiteralNode *node) override; - llvm::Expected<lldb::ValueObjectSP> Visit(const CastNode *node) override; + Visit(const BooleanLiteralNode &node) override; + llvm::Expected<lldb::ValueObjectSP> Visit(const CastNode &node) override; /// Perform usual unary conversions on a value. At the moment this /// includes array-to-pointer and integral promotion for eligible types. @@ -76,7 +76,7 @@ class Interpreter : Visitor { llvm::Expected<CompilerType> PickIntegerType(lldb::TypeSystemSP type_system, std::shared_ptr<ExecutionContextScope> ctx, - const IntegerLiteralNode *literal); + const IntegerLiteralNode &literal); // Used by the interpreter to create objects, perform casts, etc. lldb::TargetSP m_target; diff --git a/lldb/source/Target/StackFrame.cpp b/lldb/source/Target/StackFrame.cpp index 3bbb851b88007..92d0099be972a 100644 --- a/lldb/source/Target/StackFrame.cpp +++ b/lldb/source/Target/StackFrame.cpp @@ -569,7 +569,7 @@ ValueObjectSP StackFrame::DILGetValueForVariableExpressionPath( use_dynamic, !no_synth_child, !no_fragile_ivar, check_ptr_vs_member); - auto valobj_or_error = interpreter.Evaluate((*tree_or_error).get()); + auto valobj_or_error = interpreter.Evaluate(**tree_or_error); if (!valobj_or_error) { error = Status::FromError(valobj_or_error.takeError()); return ValueObjectConstResult::Create(nullptr, std::move(error)); diff --git a/lldb/source/ValueObject/DILAST.cpp b/lldb/source/ValueObject/DILAST.cpp index 0b9e1f4d48ac8..d8a714d33712d 100644 --- a/lldb/source/ValueObject/DILAST.cpp +++ b/lldb/source/ValueObject/DILAST.cpp @@ -16,43 +16,43 @@ llvm::Expected<lldb::ValueObjectSP> ErrorNode::Accept(Visitor *v) const { } llvm::Expected<lldb::ValueObjectSP> IdentifierNode::Accept(Visitor *v) const { - return v->Visit(this); + return v->Visit(*this); } llvm::Expected<lldb::ValueObjectSP> MemberOfNode::Accept(Visitor *v) const { - return v->Visit(this); + return v->Visit(*this); } llvm::Expected<lldb::ValueObjectSP> UnaryOpNode::Accept(Visitor *v) const { - return v->Visit(this); + return v->Visit(*this); } llvm::Expected<lldb::ValueObjectSP> ArraySubscriptNode::Accept(Visitor *v) const { - return v->Visit(this); + return v->Visit(*this); } llvm::Expected<lldb::ValueObjectSP> BitFieldExtractionNode::Accept(Visitor *v) const { - return v->Visit(this); + return v->Visit(*this); } llvm::Expected<lldb::ValueObjectSP> IntegerLiteralNode::Accept(Visitor *v) const { - return v->Visit(this); + return v->Visit(*this); } llvm::Expected<lldb::ValueObjectSP> FloatLiteralNode::Accept(Visitor *v) const { - return v->Visit(this); + return v->Visit(*this); } llvm::Expected<lldb::ValueObjectSP> BooleanLiteralNode::Accept(Visitor *v) const { - return v->Visit(this); + return v->Visit(*this); } llvm::Expected<lldb::ValueObjectSP> CastNode::Accept(Visitor *v) const { - return v->Visit(this); + return v->Visit(*this); } } // namespace lldb_private::dil diff --git a/lldb/source/ValueObject/DILEval.cpp b/lldb/source/ValueObject/DILEval.cpp index 53413aeb35ccd..445c949b581b6 100644 --- a/lldb/source/ValueObject/DILEval.cpp +++ b/lldb/source/ValueObject/DILEval.cpp @@ -239,20 +239,20 @@ Interpreter::Interpreter(lldb::TargetSP target, llvm::StringRef expr, m_fragile_ivar(fragile_ivar), m_check_ptr_vs_member(check_ptr_vs_member) { } -llvm::Expected<lldb::ValueObjectSP> Interpreter::Evaluate(const ASTNode *node) { +llvm::Expected<lldb::ValueObjectSP> Interpreter::Evaluate(const ASTNode &node) { // Evaluate an AST. - auto value_or_error = node->Accept(this); + auto value_or_error = node.Accept(this); // Convert SP with a nullptr to an error. if (value_or_error && !*value_or_error) return llvm::make_error<DILDiagnosticError>(m_expr, "invalid value object", - node->GetLocation()); + node.GetLocation()); // Return the computed value-or-error. The caller is responsible for // checking if an error occured during the evaluation. return value_or_error; } llvm::Expected<lldb::ValueObjectSP> -Interpreter::EvaluateAndDereference(const ASTNode *node) { +Interpreter::EvaluateAndDereference(const ASTNode &node) { auto valobj_or_err = Evaluate(node); if (!valobj_or_err) return valobj_or_err; @@ -268,35 +268,35 @@ Interpreter::EvaluateAndDereference(const ASTNode *node) { } llvm::Expected<lldb::ValueObjectSP> -Interpreter::Visit(const IdentifierNode *node) { +Interpreter::Visit(const IdentifierNode &node) { lldb::DynamicValueType use_dynamic = m_use_dynamic; lldb::ValueObjectSP identifier = - LookupIdentifier(node->GetName(), m_exe_ctx_scope, use_dynamic); + LookupIdentifier(node.GetName(), m_exe_ctx_scope, use_dynamic); if (!identifier) - identifier = LookupGlobalIdentifier(node->GetName(), m_exe_ctx_scope, + identifier = LookupGlobalIdentifier(node.GetName(), m_exe_ctx_scope, m_target, use_dynamic); if (!identifier) { std::string errMsg = - llvm::formatv("use of undeclared identifier '{0}'", node->GetName()); + llvm::formatv("use of undeclared identifier '{0}'", node.GetName()); return llvm::make_error<DILDiagnosticError>( - m_expr, errMsg, node->GetLocation(), node->GetName().size()); + m_expr, errMsg, node.GetLocation(), node.GetName().size()); } return identifier; } llvm::Expected<lldb::ValueObjectSP> -Interpreter::Visit(const UnaryOpNode *node) { +Interpreter::Visit(const UnaryOpNode &node) { Status error; - auto op_or_err = Evaluate(node->GetOperand()); + auto op_or_err = Evaluate(node.GetOperand()); if (!op_or_err) return op_or_err; lldb::ValueObjectSP operand = *op_or_err; - switch (node->GetKind()) { + switch (node.GetKind()) { case UnaryOpKind::Deref: { lldb::ValueObjectSP dynamic_op = operand->GetDynamicValue(m_use_dynamic); if (dynamic_op) @@ -311,7 +311,7 @@ Interpreter::Visit(const UnaryOpNode *node) { } if (error.Fail()) return llvm::make_error<DILDiagnosticError>(m_expr, error.AsCString(), - node->GetLocation()); + node.GetLocation()); return child_sp; } @@ -320,7 +320,7 @@ Interpreter::Visit(const UnaryOpNode *node) { lldb::ValueObjectSP value = operand->AddressOf(error); if (error.Fail()) return llvm::make_error<DILDiagnosticError>(m_expr, error.AsCString(), - node->GetLocation()); + node.GetLocation()); return value; } @@ -331,7 +331,7 @@ Interpreter::Visit(const UnaryOpNode *node) { return error.ToError(); } llvm::Expected<lldb::ValueObjectSP> conv_op = - UnaryConversion(operand, node->GetOperand()->GetLocation()); + UnaryConversion(operand, node.GetOperand().GetLocation()); if (!conv_op) return conv_op; operand = *conv_op; @@ -341,7 +341,7 @@ Interpreter::Visit(const UnaryOpNode *node) { llvm::formatv("invalid argument type '{0}' to unary expression", operand_type.GetTypeName()); return llvm::make_error<DILDiagnosticError>(m_expr, errMsg, - node->GetLocation()); + node.GetLocation()); } Scalar scalar; bool resolved = operand->ResolveValue(scalar); @@ -361,7 +361,7 @@ Interpreter::Visit(const UnaryOpNode *node) { return error.ToError(); } llvm::Expected<lldb::ValueObjectSP> conv_op = - UnaryConversion(operand, node->GetOperand()->GetLocation()); + UnaryConversion(operand, node.GetOperand().GetLocation()); if (!conv_op) return conv_op; operand = *conv_op; @@ -373,25 +373,25 @@ Interpreter::Visit(const UnaryOpNode *node) { llvm::formatv("invalid argument type '{0}' to unary expression", operand_type.GetTypeName()); return llvm::make_error<DILDiagnosticError>(m_expr, errMsg, - node->GetLocation()); + node.GetLocation()); } return operand; } } return llvm::make_error<DILDiagnosticError>(m_expr, "invalid unary operation", - node->GetLocation()); + node.GetLocation()); } llvm::Expected<lldb::ValueObjectSP> -Interpreter::Visit(const MemberOfNode *node) { - auto base_or_err = Evaluate(node->GetBase()); +Interpreter::Visit(const MemberOfNode &node) { + auto base_or_err = Evaluate(node.GetBase()); if (!base_or_err) return base_or_err; - bool expr_is_ptr = node->GetIsArrow(); + bool expr_is_ptr = node.GetIsArrow(); lldb::ValueObjectSP base = *base_or_err; // Perform some basic type & correctness checking. - if (node->GetIsArrow()) { + if (node.GetIsArrow()) { if (!m_fragile_ivar) { // Make sure we aren't trying to deref an objective // C ivar if this is not allowed @@ -418,14 +418,14 @@ Interpreter::Visit(const MemberOfNode *node) { std::string errMsg = llvm::formatv( "Failed to dereference synthetic value: {0}", deref_error); return llvm::make_error<DILDiagnosticError>( - m_expr, errMsg, node->GetLocation(), node->GetFieldName().size()); + m_expr, errMsg, node.GetLocation(), node.GetFieldName().size()); } // Some synthetic plug-ins fail to set the error in Dereference if (!base) { std::string errMsg = "Failed to dereference synthetic value"; return llvm::make_error<DILDiagnosticError>( - m_expr, errMsg, node->GetLocation(), node->GetFieldName().size()); + m_expr, errMsg, node.GetLocation(), node.GetFieldName().size()); } expr_is_ptr = false; } @@ -441,33 +441,33 @@ Interpreter::Visit(const MemberOfNode *node) { "did you mean to use '->'?", base->GetCompilerType().TypeDescription()); return llvm::make_error<DILDiagnosticError>( - m_expr, errMsg, node->GetLocation(), node->GetFieldName().size()); + m_expr, errMsg, node.GetLocation(), node.GetFieldName().size()); } else { std::string errMsg = llvm::formatv("member reference type {0} is not a pointer; " "did you mean to use '.'?", base->GetCompilerType().TypeDescription()); return llvm::make_error<DILDiagnosticError>( - m_expr, errMsg, node->GetLocation(), node->GetFieldName().size()); + m_expr, errMsg, node.GetLocation(), node.GetFieldName().size()); } } } lldb::ValueObjectSP field_obj = - base->GetChildMemberWithName(node->GetFieldName()); + base->GetChildMemberWithName(node.GetFieldName()); if (!field_obj) { if (m_use_synthetic) { field_obj = base->GetSyntheticValue(); if (field_obj) - field_obj = field_obj->GetChildMemberWithName(node->GetFieldName()); + field_obj = field_obj->GetChildMemberWithName(node.GetFieldName()); } if (!m_use_synthetic || !field_obj) { std::string errMsg = llvm::formatv( - "\"{0}\" is not a member of \"({1}) {2}\"", node->GetFieldName(), + "\"{0}\" is not a member of \"({1}) {2}\"", node.GetFieldName(), base->GetTypeName().AsCString("<invalid type>"), base->GetName()); return llvm::make_error<DILDiagnosticError>( - m_expr, errMsg, node->GetLocation(), node->GetFieldName().size()); + m_expr, errMsg, node.GetLocation(), node.GetFieldName().size()); } } @@ -482,32 +482,32 @@ Interpreter::Vis... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/173240 _______________________________________________ lldb-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
