https://github.com/kuilpd created https://github.com/llvm/llvm-project/pull/173240
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 >From b4601e92b39c62dcceddc15d2b7231493040e894 Mon Sep 17 00:00:00 2001 From: Ilia Kuklin <[email protected]> Date: Fri, 19 Dec 2025 21:53:28 +0500 Subject: [PATCH] [lldb][NFC] Assert ASTNodeUPs and pass ASTNodes by reference in DIL --- lldb/include/lldb/ValueObject/DILAST.h | 74 ++++++------ lldb/include/lldb/ValueObject/DILEval.h | 24 ++-- lldb/source/Target/StackFrame.cpp | 2 +- lldb/source/ValueObject/DILAST.cpp | 18 +-- lldb/source/ValueObject/DILEval.cpp | 148 ++++++++++++------------ lldb/source/ValueObject/DILParser.cpp | 15 ++- 6 files changed, 143 insertions(+), 138 deletions(-) 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::Visit(const MemberOfNode *node) { } CompilerType base_type = base->GetCompilerType(); - if (node->GetIsArrow() && base->IsPointerType()) + if (node.GetIsArrow() && base->IsPointerType()) base_type = base_type.GetPointeeType(); 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()); } llvm::Expected<lldb::ValueObjectSP> -Interpreter::Visit(const ArraySubscriptNode *node) { - auto idx_or_err = EvaluateAndDereference(node->GetIndex()); +Interpreter::Visit(const ArraySubscriptNode &node) { + auto idx_or_err = EvaluateAndDereference(node.GetIndex()); if (!idx_or_err) return idx_or_err; lldb::ValueObjectSP idx = *idx_or_err; if (!idx->GetCompilerType().IsIntegerOrUnscopedEnumerationType()) { return llvm::make_error<DILDiagnosticError>( - m_expr, "array subscript is not an integer", node->GetLocation()); + m_expr, "array subscript is not an integer", node.GetLocation()); } StreamString var_expr_path_strm; uint64_t child_idx = idx->GetValueAsUnsigned(0); lldb::ValueObjectSP child_valobj_sp; - auto base_or_err = Evaluate(node->GetBase()); + auto base_or_err = Evaluate(node.GetBase()); if (!base_or_err) return base_or_err; lldb::ValueObjectSP base = *base_or_err; @@ -529,7 +529,7 @@ Interpreter::Visit(const ArraySubscriptNode *node) { base->GetTypeName().AsCString("<invalid type>"), var_expr_path_strm.GetData()); return llvm::make_error<DILDiagnosticError>(m_expr, std::move(err_msg), - node->GetLocation()); + node.GetLocation()); } if (is_objc_pointer) { lldb::ValueObjectSP synthetic = base->GetSyntheticValue(); @@ -539,7 +539,7 @@ Interpreter::Visit(const ArraySubscriptNode *node) { base->GetTypeName().AsCString("<invalid type>"), var_expr_path_strm.GetData()); return llvm::make_error<DILDiagnosticError>(m_expr, std::move(err_msg), - node->GetLocation()); + node.GetLocation()); } if (static_cast<uint32_t>(child_idx) >= synthetic->GetNumChildrenIgnoringErrors()) { @@ -548,7 +548,7 @@ Interpreter::Visit(const ArraySubscriptNode *node) { base->GetTypeName().AsCString("<invalid type>"), var_expr_path_strm.GetData()); return llvm::make_error<DILDiagnosticError>(m_expr, std::move(err_msg), - node->GetLocation()); + node.GetLocation()); } child_valobj_sp = synthetic->GetChildAtIndex(child_idx); if (!child_valobj_sp) { @@ -557,7 +557,7 @@ Interpreter::Visit(const ArraySubscriptNode *node) { base->GetTypeName().AsCString("<invalid type>"), var_expr_path_strm.GetData()); return llvm::make_error<DILDiagnosticError>(m_expr, std::move(err_msg), - node->GetLocation()); + node.GetLocation()); } if (m_use_dynamic != lldb::eNoDynamicValues) { if (auto dynamic_sp = child_valobj_sp->GetDynamicValue(m_use_dynamic)) @@ -576,7 +576,7 @@ Interpreter::Visit(const ArraySubscriptNode *node) { if (base_type.IsPointerToVoid()) err_msg = "subscript of pointer to incomplete type 'void'"; return llvm::make_error<DILDiagnosticError>(m_expr, std::move(err_msg), - node->GetLocation()); + node.GetLocation()); } } else if (base_type.IsArrayType(nullptr, nullptr, &is_incomplete_array)) { child_valobj_sp = base->GetChildAtIndex(child_idx); @@ -588,7 +588,7 @@ Interpreter::Visit(const ArraySubscriptNode *node) { base->GetTypeName().AsCString("<invalid type>"), var_expr_path_strm.GetData()); return llvm::make_error<DILDiagnosticError>(m_expr, std::move(err_msg), - node->GetLocation()); + node.GetLocation()); } } else if (base_type.IsScalarType()) { child_valobj_sp = @@ -599,7 +599,7 @@ Interpreter::Visit(const ArraySubscriptNode *node) { child_idx, base->GetTypeName().AsCString("<invalid type>"), var_expr_path_strm.GetData()); return llvm::make_error<DILDiagnosticError>(m_expr, std::move(err_msg), - node->GetLocation(), 1); + node.GetLocation(), 1); } } else { lldb::ValueObjectSP synthetic = base->GetSyntheticValue(); @@ -608,7 +608,7 @@ Interpreter::Visit(const ArraySubscriptNode *node) { llvm::formatv("\"{0}\" is not an array type", base->GetTypeName().AsCString("<invalid type>")); return llvm::make_error<DILDiagnosticError>(m_expr, std::move(err_msg), - node->GetLocation(), 1); + node.GetLocation(), 1); } if (static_cast<uint32_t>(child_idx) >= synthetic->GetNumChildrenIgnoringErrors(child_idx + 1)) { @@ -617,7 +617,7 @@ Interpreter::Visit(const ArraySubscriptNode *node) { base->GetTypeName().AsCString("<invalid type>"), var_expr_path_strm.GetData()); return llvm::make_error<DILDiagnosticError>(m_expr, std::move(err_msg), - node->GetLocation(), 1); + node.GetLocation(), 1); } child_valobj_sp = synthetic->GetChildAtIndex(child_idx); if (!child_valobj_sp) { @@ -626,7 +626,7 @@ Interpreter::Visit(const ArraySubscriptNode *node) { base->GetTypeName().AsCString("<invalid type>"), var_expr_path_strm.GetData()); return llvm::make_error<DILDiagnosticError>(m_expr, std::move(err_msg), - node->GetLocation(), 1); + node.GetLocation(), 1); } } @@ -643,17 +643,17 @@ Interpreter::Visit(const ArraySubscriptNode *node) { if (!success) return llvm::make_error<DILDiagnosticError>( m_expr, "could not get the index as an integer", - node->GetIndex()->GetLocation()); + node.GetIndex().GetLocation()); return base->GetSyntheticArrayMember(signed_child_idx, true); } llvm::Expected<lldb::ValueObjectSP> -Interpreter::Visit(const BitFieldExtractionNode *node) { - auto first_idx_or_err = EvaluateAndDereference(node->GetFirstIndex()); +Interpreter::Visit(const BitFieldExtractionNode &node) { + auto first_idx_or_err = EvaluateAndDereference(node.GetFirstIndex()); if (!first_idx_or_err) return first_idx_or_err; lldb::ValueObjectSP first_idx = *first_idx_or_err; - auto last_idx_or_err = EvaluateAndDereference(node->GetLastIndex()); + auto last_idx_or_err = EvaluateAndDereference(node.GetLastIndex()); if (!last_idx_or_err) return last_idx_or_err; lldb::ValueObjectSP last_idx = *last_idx_or_err; @@ -661,7 +661,7 @@ Interpreter::Visit(const BitFieldExtractionNode *node) { if (!first_idx->GetCompilerType().IsIntegerOrUnscopedEnumerationType() || !last_idx->GetCompilerType().IsIntegerOrUnscopedEnumerationType()) { return llvm::make_error<DILDiagnosticError>( - m_expr, "bit index is not an integer", node->GetLocation()); + m_expr, "bit index is not an integer", node.GetLocation()); } bool success_first, success_last; @@ -669,13 +669,13 @@ Interpreter::Visit(const BitFieldExtractionNode *node) { int64_t last_index = last_idx->GetValueAsSigned(0, &success_last); if (!success_first || !success_last) return llvm::make_error<DILDiagnosticError>( - m_expr, "could not get the index as an integer", node->GetLocation()); + m_expr, "could not get the index as an integer", node.GetLocation()); // if the format given is [high-low], swap range if (first_index > last_index) std::swap(first_index, last_index); - auto base_or_err = EvaluateAndDereference(node->GetBase()); + auto base_or_err = EvaluateAndDereference(node.GetBase()); if (!base_or_err) return base_or_err; lldb::ValueObjectSP base = *base_or_err; @@ -687,7 +687,7 @@ Interpreter::Visit(const BitFieldExtractionNode *node) { last_index, base->GetTypeName().AsCString("<invalid type>"), base->GetName().AsCString()); return llvm::make_error<DILDiagnosticError>(m_expr, message, - node->GetLocation()); + node.GetLocation()); } return child_valobj_sp; } @@ -695,18 +695,18 @@ Interpreter::Visit(const BitFieldExtractionNode *node) { llvm::Expected<CompilerType> Interpreter::PickIntegerType(lldb::TypeSystemSP type_system, std::shared_ptr<ExecutionContextScope> ctx, - const IntegerLiteralNode *literal) { + const IntegerLiteralNode &literal) { // Binary, Octal, Hexadecimal and literals with a U suffix are allowed to be // an unsigned integer. - bool unsigned_is_allowed = literal->IsUnsigned() || literal->GetRadix() != 10; - llvm::APInt apint = literal->GetValue(); + bool unsigned_is_allowed = literal.IsUnsigned() || literal.GetRadix() != 10; + llvm::APInt apint = literal.GetValue(); llvm::SmallVector<std::pair<lldb::BasicType, lldb::BasicType>, 3> candidates; - if (literal->GetTypeSuffix() <= IntegerTypeSuffix::None) + if (literal.GetTypeSuffix() <= IntegerTypeSuffix::None) candidates.emplace_back(lldb::eBasicTypeInt, unsigned_is_allowed ? lldb::eBasicTypeUnsignedInt : lldb::eBasicTypeInvalid); - if (literal->GetTypeSuffix() <= IntegerTypeSuffix::Long) + if (literal.GetTypeSuffix() <= IntegerTypeSuffix::Long) candidates.emplace_back(lldb::eBasicTypeLong, unsigned_is_allowed ? lldb::eBasicTypeUnsignedLong : lldb::eBasicTypeInvalid); @@ -719,7 +719,7 @@ Interpreter::PickIntegerType(lldb::TypeSystemSP type_system, llvm::Expected<uint64_t> size = signed_type.GetBitSize(ctx.get()); if (!size) return size.takeError(); - if (!literal->IsUnsigned() && apint.isIntN(*size - 1)) + if (!literal.IsUnsigned() && apint.isIntN(*size - 1)) return signed_type; if (unsigned_ != lldb::eBasicTypeInvalid && apint.isIntN(*size)) return type_system->GetBasicTypeFromAST(unsigned_); @@ -728,11 +728,11 @@ Interpreter::PickIntegerType(lldb::TypeSystemSP type_system, return llvm::make_error<DILDiagnosticError>( m_expr, "integer literal is too large to be represented in any integer type", - literal->GetLocation()); + literal.GetLocation()); } llvm::Expected<lldb::ValueObjectSP> -Interpreter::Visit(const IntegerLiteralNode *node) { +Interpreter::Visit(const IntegerLiteralNode &node) { llvm::Expected<lldb::TypeSystemSP> type_system = GetTypeSystemFromCU(m_exe_ctx_scope); if (!type_system) @@ -743,7 +743,7 @@ Interpreter::Visit(const IntegerLiteralNode *node) { if (!type) return type.takeError(); - Scalar scalar = node->GetValue(); + Scalar scalar = node.GetValue(); // APInt from StringRef::getAsInteger comes with just enough bitwidth to // hold the value. This adjusts APInt bitwidth to match the compiler type. llvm::Expected<uint64_t> type_bitsize = @@ -756,35 +756,35 @@ Interpreter::Visit(const IntegerLiteralNode *node) { } llvm::Expected<lldb::ValueObjectSP> -Interpreter::Visit(const FloatLiteralNode *node) { +Interpreter::Visit(const FloatLiteralNode &node) { llvm::Expected<lldb::TypeSystemSP> type_system = GetTypeSystemFromCU(m_exe_ctx_scope); if (!type_system) return type_system.takeError(); bool isFloat = - &node->GetValue().getSemantics() == &llvm::APFloat::IEEEsingle(); + &node.GetValue().getSemantics() == &llvm::APFloat::IEEEsingle(); lldb::BasicType basic_type = isFloat ? lldb::eBasicTypeFloat : lldb::eBasicTypeDouble; CompilerType type = GetBasicType(*type_system, basic_type); if (!type) return llvm::make_error<DILDiagnosticError>( - m_expr, "unable to create a const literal", node->GetLocation()); + m_expr, "unable to create a const literal", node.GetLocation()); - Scalar scalar = node->GetValue(); + Scalar scalar = node.GetValue(); return ValueObject::CreateValueObjectFromScalar(m_target, scalar, type, "result"); } llvm::Expected<lldb::ValueObjectSP> -Interpreter::Visit(const BooleanLiteralNode *node) { - bool value = node->GetValue(); +Interpreter::Visit(const BooleanLiteralNode &node) { + bool value = node.GetValue(); return ValueObject::CreateValueObjectFromBool(m_target, value, "result"); } -llvm::Expected<lldb::ValueObjectSP> Interpreter::Visit(const CastNode *node) { - auto operand_or_err = Evaluate(node->GetOperand()); +llvm::Expected<lldb::ValueObjectSP> Interpreter::Visit(const CastNode &node) { + auto operand_or_err = Evaluate(node.GetOperand()); if (!operand_or_err) return operand_or_err; @@ -792,7 +792,7 @@ llvm::Expected<lldb::ValueObjectSP> Interpreter::Visit(const CastNode *node) { // Don't actually do the cast for now -- that code will be added later. // For now just return an error message. return llvm::make_error<DILDiagnosticError>( - m_expr, "Type casting is not supported here.", node->GetLocation()); + m_expr, "Type casting is not supported here.", node.GetLocation()); } } // namespace lldb_private::dil diff --git a/lldb/source/ValueObject/DILParser.cpp b/lldb/source/ValueObject/DILParser.cpp index 7758556f7001f..f3027a3d82fa2 100644 --- a/lldb/source/ValueObject/DILParser.cpp +++ b/lldb/source/ValueObject/DILParser.cpp @@ -54,6 +54,7 @@ DILParser::Parse(llvm::StringRef dil_input_expr, DILLexer lexer, fragile_ivar, check_ptr_vs_member, error); ASTNodeUP node_up = parser.Run(); + assert(node_up && "ASTNodeUP must not contain a nullptr"); if (error) return error; @@ -122,7 +123,7 @@ ASTNodeUP DILParser::ParseCastExpression() { Expect(Token::r_paren); m_dil_lexer.Advance(); auto rhs = ParseCastExpression(); - + assert(rhs && "ASTNodeUP must not contain a nullptr"); return std::make_unique<CastNode>(loc, type_id.value(), std::move(rhs), CastKind::eNone); } @@ -153,6 +154,7 @@ ASTNodeUP DILParser::ParseUnaryExpression() { uint32_t loc = token.GetLocation(); m_dil_lexer.Advance(); auto rhs = ParseCastExpression(); + assert(rhs && "ASTNodeUP must not contain a nullptr"); switch (token.GetKind()) { case Token::star: return std::make_unique<UnaryOpNode>(loc, UnaryOpKind::Deref, @@ -184,6 +186,7 @@ ASTNodeUP DILParser::ParseUnaryExpression() { // ASTNodeUP DILParser::ParsePostfixExpression() { ASTNodeUP lhs = ParsePrimaryExpression(); + assert(lhs && "ASTNodeUP must not contain a nullptr"); while (CurToken().IsOneOf({Token::l_square, Token::period, Token::arrow})) { uint32_t loc = CurToken().GetLocation(); Token token = CurToken(); @@ -191,9 +194,11 @@ ASTNodeUP DILParser::ParsePostfixExpression() { case Token::l_square: { m_dil_lexer.Advance(); ASTNodeUP index = ParseExpression(); + assert(index && "ASTNodeUP must not contain a nullptr"); if (CurToken().GetKind() == Token::minus) { m_dil_lexer.Advance(); ASTNodeUP last_index = ParseExpression(); + assert(last_index && "ASTNodeUP must not contain a nullptr"); lhs = std::make_unique<BitFieldExtractionNode>( loc, std::move(lhs), std::move(index), std::move(last_index)); } else { @@ -533,11 +538,11 @@ ASTNodeUP DILParser::ParseNumericLiteral() { numeric_constant = ParseIntegerLiteral(); else numeric_constant = ParseFloatingPointLiteral(); - if (!numeric_constant) { + if (numeric_constant->GetKind() == NodeKind::eErrorNode) { BailOut(llvm::formatv("Failed to parse token as numeric-constant: {0}", CurToken()), CurToken().GetLocation(), CurToken().GetSpelling().length()); - return std::make_unique<ErrorNode>(); + return numeric_constant; } m_dil_lexer.Advance(); return numeric_constant; @@ -565,7 +570,7 @@ ASTNodeUP DILParser::ParseIntegerLiteral() { if (!spelling_ref.getAsInteger(radix, raw_value)) return std::make_unique<IntegerLiteralNode>(token.GetLocation(), raw_value, radix, is_unsigned, type); - return nullptr; + return std::make_unique<ErrorNode>(); } ASTNodeUP DILParser::ParseFloatingPointLiteral() { @@ -581,7 +586,7 @@ ASTNodeUP DILParser::ParseFloatingPointLiteral() { spelling_ref, llvm::APFloat::rmNearestTiesToEven); if (!errorToBool(StatusOrErr.takeError())) return std::make_unique<FloatLiteralNode>(token.GetLocation(), raw_float); - return nullptr; + return std::make_unique<ErrorNode>(); } void DILParser::Expect(Token::Kind kind) { _______________________________________________ lldb-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
