https://github.com/cmtice updated https://github.com/llvm/llvm-project/pull/165199
>From 44cf7ad579403456a169ea47608c0e2553076bcc Mon Sep 17 00:00:00 2001 From: Caroline Tice <[email protected]> Date: Sun, 26 Oct 2025 21:14:38 -0700 Subject: [PATCH 1/3] [LLDB] Add type casting to DIL, part 1 of 3. This is an alternative to PR 159500, breaking that PR down into three separate PRs, to make it easier to review. This first PR of the three adds the basic framework for doing type casing to the DIL code, but it does not actually do any casting: In this PR the DIL parser only recognizes builtin type names, and the DIL interpreter does not do anything except return the original operand (no casting). The second and third PRs will add most of the type parsing, and do the actual type casting, respectively. --- lldb/docs/dil-expr-lang.ebnf | 28 +++- lldb/include/lldb/ValueObject/DILAST.h | 34 +++++ lldb/include/lldb/ValueObject/DILEval.h | 2 + lldb/include/lldb/ValueObject/DILParser.h | 6 + lldb/source/ValueObject/DILAST.cpp | 4 + lldb/source/ValueObject/DILEval.cpp | 12 ++ lldb/source/ValueObject/DILParser.cpp | 166 +++++++++++++++++++++- 7 files changed, 245 insertions(+), 7 deletions(-) diff --git a/lldb/docs/dil-expr-lang.ebnf b/lldb/docs/dil-expr-lang.ebnf index 70eda3bf40650..660a69ea51e7f 100644 --- a/lldb/docs/dil-expr-lang.ebnf +++ b/lldb/docs/dil-expr-lang.ebnf @@ -3,10 +3,13 @@ (* This is currently a subset of the final DIL Language, matching the current DIL implementation. *) -expression = unary_expression ; +expression = cast_expression; + +cast_expression = unary_expression + | "(" type_id ")" cast_expression; unary_expression = postfix_expression - | unary_operator expression ; + | unary_operator cast_expression ; unary_operator = "*" | "&" ; @@ -44,10 +47,28 @@ nested_name_specifier = type_name "::" | namespace_name '::' | nested_name_specifier identifier "::" ; +type_id = type_specifier_seq [abstract_declarator] ; + +type_specifier_seq = type_specifier [type_specifier]; + +type_specifier = ["::"] [nested_name_specifier] type_name + | builtin_typename ; + +nested_name_specifier = type_name "::" + | namespace_name "::" + | nested_name_specifier identifier "::" ; + +abstract_declarator = ptr_operator [abstract_declarator] ; + +ptr_operator = "*" + | "&"; + type_name = class_name | enum_name | typedef_name; +builtin_typename = identifier_seq; + class_name = identifier ; enum_name = identifier ; @@ -56,6 +77,7 @@ typedef_name = identifier ; namespace_name = identifier ; - +identifier_seq = identifier + | identifier identifier_seq; diff --git a/lldb/include/lldb/ValueObject/DILAST.h b/lldb/include/lldb/ValueObject/DILAST.h index 0f05d753f1b56..fa0368de0c5bf 100644 --- a/lldb/include/lldb/ValueObject/DILAST.h +++ b/lldb/include/lldb/ValueObject/DILAST.h @@ -21,6 +21,7 @@ enum class NodeKind { eArraySubscriptNode, eBitExtractionNode, eBooleanLiteralNode, + eCStyleCastNode, eErrorNode, eFloatLiteralNode, eIdentifierNode, @@ -35,6 +36,14 @@ enum class UnaryOpKind { Deref, // "*" }; +/// The C-Style casts allowed by DIL. +enum class CStyleCastKind { + eEnumeration, + eNullptr, + eReference, + eNone, +}; + /// Forward declaration, for use in DIL AST nodes. Definition is at the very /// end of this file. class Visitor; @@ -244,6 +253,29 @@ class BooleanLiteralNode : public ASTNode { bool m_value; }; +class CStyleCastNode : public ASTNode { +public: + CStyleCastNode(uint32_t location, CompilerType type, ASTNodeUP operand, + CStyleCastKind kind) + : ASTNode(location, NodeKind::eCStyleCastNode), m_type(type), + m_operand(std::move(operand)), m_cast_kind(kind) {} + + llvm::Expected<lldb::ValueObjectSP> Accept(Visitor *v) const override; + + CompilerType GetType() const { return m_type; } + ASTNode *GetOperand() const { return m_operand.get(); } + CStyleCastKind GetCastKind() const { return m_cast_kind; } + + static bool classof(const ASTNode *node) { + return node->GetKind() == NodeKind::eCStyleCastNode; + } + +private: + CompilerType m_type; + ASTNodeUP m_operand; + CStyleCastKind m_cast_kind; +}; + /// This class contains one Visit method for each specialized type of /// DIL AST node. The Visit methods are used to dispatch a DIL AST node to /// the correct function in the DIL expression evaluator for evaluating that @@ -267,6 +299,8 @@ class Visitor { Visit(const FloatLiteralNode *node) = 0; virtual llvm::Expected<lldb::ValueObjectSP> Visit(const BooleanLiteralNode *node) = 0; + virtual llvm::Expected<lldb::ValueObjectSP> + Visit(const CStyleCastNode *node) = 0; }; } // namespace lldb_private::dil diff --git a/lldb/include/lldb/ValueObject/DILEval.h b/lldb/include/lldb/ValueObject/DILEval.h index eab3218ff828f..a7fe3d3fe7461 100644 --- a/lldb/include/lldb/ValueObject/DILEval.h +++ b/lldb/include/lldb/ValueObject/DILEval.h @@ -60,6 +60,8 @@ class Interpreter : Visitor { Visit(const FloatLiteralNode *node) override; llvm::Expected<lldb::ValueObjectSP> Visit(const BooleanLiteralNode *node) override; + llvm::Expected<lldb::ValueObjectSP> + Visit(const CStyleCastNode *node) override; llvm::Expected<CompilerType> PickIntegerType(lldb::TypeSystemSP type_system, diff --git a/lldb/include/lldb/ValueObject/DILParser.h b/lldb/include/lldb/ValueObject/DILParser.h index d17ed66d9b3ee..2db23749168d4 100644 --- a/lldb/include/lldb/ValueObject/DILParser.h +++ b/lldb/include/lldb/ValueObject/DILParser.h @@ -101,6 +101,12 @@ class DILParser { ASTNodeUP ParseFloatingPointLiteral(); ASTNodeUP ParseBooleanLiteral(); + ASTNodeUP ParseCastExpression(); + std::optional<CompilerType> ParseBuiltinType(); + std::optional<CompilerType> ParseTypeId(); + CompilerType ResolveTypeDeclarators(CompilerType type, + const std::vector<Token> &ptr_operators); + void BailOut(const std::string &error, uint32_t loc, uint16_t err_len); void Expect(Token::Kind kind); diff --git a/lldb/source/ValueObject/DILAST.cpp b/lldb/source/ValueObject/DILAST.cpp index 7ed34db6e20df..5922999baaa52 100644 --- a/lldb/source/ValueObject/DILAST.cpp +++ b/lldb/source/ValueObject/DILAST.cpp @@ -51,4 +51,8 @@ BooleanLiteralNode::Accept(Visitor *v) const { return v->Visit(this); } +llvm::Expected<lldb::ValueObjectSP> CStyleCastNode::Accept(Visitor *v) const { + return v->Visit(this); +} + } // namespace lldb_private::dil diff --git a/lldb/source/ValueObject/DILEval.cpp b/lldb/source/ValueObject/DILEval.cpp index a9dbfad298d05..968394e95ab67 100644 --- a/lldb/source/ValueObject/DILEval.cpp +++ b/lldb/source/ValueObject/DILEval.cpp @@ -608,4 +608,16 @@ Interpreter::Visit(const BooleanLiteralNode *node) { return ValueObject::CreateValueObjectFromBool(m_target, value, "result"); } +llvm::Expected<lldb::ValueObjectSP> +Interpreter::Visit(const CStyleCastNode *node) { + auto operand_or_err = Evaluate(node->GetOperand()); + if (!operand_or_err) + return operand_or_err; + + lldb::ValueObjectSP operand = *operand_or_err; + // Don't actually do the cast for now -- that code will be added later. + // For now just return the original operand, unchanged. + return operand; +} + } // namespace lldb_private::dil diff --git a/lldb/source/ValueObject/DILParser.cpp b/lldb/source/ValueObject/DILParser.cpp index 566bcaf81094a..9c4a0cd576b5c 100644 --- a/lldb/source/ValueObject/DILParser.cpp +++ b/lldb/source/ValueObject/DILParser.cpp @@ -12,7 +12,9 @@ //===----------------------------------------------------------------------===// #include "lldb/ValueObject/DILParser.h" +#include "lldb/Symbol/CompileUnit.h" #include "lldb/Target/ExecutionContextScope.h" +#include "lldb/Target/LanguageRuntime.h" #include "lldb/Utility/DiagnosticsRendering.h" #include "lldb/ValueObject/DILAST.h" #include "lldb/ValueObject/DILEval.h" @@ -80,15 +82,62 @@ ASTNodeUP DILParser::Run() { // Parse an expression. // // expression: -// unary_expression +// cast_expression // -ASTNodeUP DILParser::ParseExpression() { return ParseUnaryExpression(); } +ASTNodeUP DILParser::ParseExpression() { return ParseCastExpression(); } + +// Parse a cast_expression. +// +// cast_expression: +// unary_expression +// "(" type_id ")" cast_expression + +ASTNodeUP DILParser::ParseCastExpression() { + // This can be a C-style cast, try parsing the contents as a type declaration. + if (CurToken().Is(Token::l_paren)) { + Token token = CurToken(); + uint32_t loc = token.GetLocation(); + + // Enable lexer backtracking, so that we can rollback in case it's not + // actually a type declaration. + + // Start tentative parsing (save token location/idx, for possible rollback). + uint32_t save_token_idx = m_dil_lexer.GetCurrentTokenIdx(); + + // Consume the token only after enabling the backtracking. + m_dil_lexer.Advance(); + + // Try parsing the type declaration. If the returned value is not valid, + // then we should rollback and try parsing the expression. + auto type_id = ParseTypeId(); + if (type_id) { + // Successfully parsed the type declaration. Commit the backtracked + // tokens and parse the cast_expression. + + if (!type_id.value().IsValid()) + return std::make_unique<ErrorNode>(); + + Expect(Token::r_paren); + m_dil_lexer.Advance(); + auto rhs = ParseCastExpression(); + + return std::make_unique<CStyleCastNode>( + loc, type_id.value(), std::move(rhs), CStyleCastKind::eNone); + } + + // Failed to parse the contents of the parentheses as a type declaration. + // Rollback the lexer and try parsing it as unary_expression. + TentativeParsingRollback(save_token_idx); + } + + return ParseUnaryExpression(); +} // Parse an unary_expression. // // unary_expression: // postfix_expression -// unary_operator expression +// unary_operator cast_expression // // unary_operator: // "&" @@ -99,7 +148,7 @@ ASTNodeUP DILParser::ParseUnaryExpression() { Token token = CurToken(); uint32_t loc = token.GetLocation(); m_dil_lexer.Advance(); - auto rhs = ParseExpression(); + auto rhs = ParseCastExpression(); switch (token.GetKind()) { case Token::star: return std::make_unique<UnaryOpNode>(loc, UnaryOpKind::Deref, @@ -274,6 +323,81 @@ std::string DILParser::ParseNestedNameSpecifier() { } } +// Parse a type_id. +// +// type_id: +// type_specifier_seq [abstract_declarator] +// +// type_specifier_seq: +// type_specifier [type_specifier] +// +// type_specifier: +// ["::"] [nested_name_specifier] type_name // not handled for now! +// builtin_typename +// +std::optional<CompilerType> DILParser::ParseTypeId() { + CompilerType type; + // For now only allow builtin types -- will expand add to this later. + auto maybe_builtin_type = ParseBuiltinType(); + if (maybe_builtin_type) { + type = *maybe_builtin_type; + } else + return {}; + + // + // abstract_declarator: + // ptr_operator [abstract_declarator] + // + std::vector<Token> ptr_operators; + while (CurToken().IsOneOf({Token::star, Token::amp})) { + Token tok = CurToken(); + ptr_operators.push_back(std::move(tok)); + m_dil_lexer.Advance(); + } + type = ResolveTypeDeclarators(type, ptr_operators); + + return type; +} + +// Parse a built-in type +// +// builtin_typename: +// identifer_seq +// +// identifier_seq +// identifer [identifier_seq] +// +// A built-in type can be a single identifier or a space-separated +// list of identifiers (e.g. "short" or "long long"). +std::optional<CompilerType> DILParser::ParseBuiltinType() { + std::string type_name = ""; + uint32_t save_token_idx = m_dil_lexer.GetCurrentTokenIdx(); + bool first_word = true; + while (CurToken().GetKind() == Token::identifier) { + if (CurToken().GetSpelling() == "const" || + CurToken().GetSpelling() == "volatile") + continue; + if (!first_word) + type_name.push_back(' '); + else + first_word = false; + type_name.append(CurToken().GetSpelling()); + m_dil_lexer.Advance(); + } + + if (type_name.size() > 0) { + lldb::TargetSP target_sp = m_ctx_scope->CalculateTarget(); + ConstString const_type_name(type_name.c_str()); + for (auto type_system_sp : target_sp->GetScratchTypeSystems()) + if (auto compiler_type = + type_system_sp->GetBuiltinTypeByName(const_type_name)) + return compiler_type; + } + + TentativeParsingRollback(save_token_idx); + return {}; +} + // Parse an id_expression. // // id_expression: @@ -339,6 +463,40 @@ std::string DILParser::ParseUnqualifiedId() { return identifier; } +CompilerType +DILParser::ResolveTypeDeclarators(CompilerType type, + const std::vector<Token> &ptr_operators) { + CompilerType bad_type; + // Resolve pointers/references. + for (Token tk : ptr_operators) { + uint32_t loc = tk.GetLocation(); + if (tk.GetKind() == Token::star) { + // Pointers to reference types are forbidden. + if (type.IsReferenceType()) { + BailOut(llvm::formatv("'type name' declared as a pointer to a " + "reference of type {0}", + type.TypeDescription()), + loc, CurToken().GetSpelling().length()); + return bad_type; + } + // Get pointer type for the base type: e.g. int* -> int**. + type = type.GetPointerType(); + + } else if (tk.GetKind() == Token::amp) { + // References to references are forbidden. + if (type.IsReferenceType()) { + BailOut("type name declared as a reference to a reference", loc, + CurToken().GetSpelling().length()); + return bad_type; + } + // Get reference type for the base type: e.g. int -> int&. + type = type.GetLValueReferenceType(); + } + } + + return type; +} + // Parse an boolean_literal. // // boolean_literal: >From 3e53e254f4794c473196e77a9b1e498d5c0de8ea Mon Sep 17 00:00:00 2001 From: Caroline Tice <[email protected]> Date: Thu, 30 Oct 2025 16:21:50 -0700 Subject: [PATCH 2/3] Address reviewer comments: - change references to C-style casting to just casting - add comments to cast enumeration types - use early-return --- lldb/include/lldb/ValueObject/DILAST.h | 30 +++++++------- lldb/include/lldb/ValueObject/DILEval.h | 2 +- lldb/source/ValueObject/DILAST.cpp | 2 +- lldb/source/ValueObject/DILEval.cpp | 2 +- lldb/source/ValueObject/DILParser.cpp | 55 +++++++++++++------------ 5 files changed, 46 insertions(+), 45 deletions(-) diff --git a/lldb/include/lldb/ValueObject/DILAST.h b/lldb/include/lldb/ValueObject/DILAST.h index fa0368de0c5bf..919294f33508b 100644 --- a/lldb/include/lldb/ValueObject/DILAST.h +++ b/lldb/include/lldb/ValueObject/DILAST.h @@ -21,7 +21,7 @@ enum class NodeKind { eArraySubscriptNode, eBitExtractionNode, eBooleanLiteralNode, - eCStyleCastNode, + eCastNode, eErrorNode, eFloatLiteralNode, eIdentifierNode, @@ -36,12 +36,12 @@ enum class UnaryOpKind { Deref, // "*" }; -/// The C-Style casts allowed by DIL. -enum class CStyleCastKind { - eEnumeration, - eNullptr, - eReference, - eNone, +/// The type casts allowed by DIL. +enum class CastKind { + eEnumeration, /// Casting from a scalar to an enumeration type + eNullptr, /// Casting to a nullptr type + eReference, /// Casting to a reference type + eNone, /// Type promotion casting }; /// Forward declaration, for use in DIL AST nodes. Definition is at the very @@ -253,27 +253,27 @@ class BooleanLiteralNode : public ASTNode { bool m_value; }; -class CStyleCastNode : public ASTNode { +class CastNode : public ASTNode { public: - CStyleCastNode(uint32_t location, CompilerType type, ASTNodeUP operand, - CStyleCastKind kind) - : ASTNode(location, NodeKind::eCStyleCastNode), m_type(type), + CastNode(uint32_t location, CompilerType type, ASTNodeUP operand, + CastKind kind) + : ASTNode(location, NodeKind::eCastNode), m_type(type), m_operand(std::move(operand)), m_cast_kind(kind) {} llvm::Expected<lldb::ValueObjectSP> Accept(Visitor *v) const override; CompilerType GetType() const { return m_type; } ASTNode *GetOperand() const { return m_operand.get(); } - CStyleCastKind GetCastKind() const { return m_cast_kind; } + CastKind GetCastKind() const { return m_cast_kind; } static bool classof(const ASTNode *node) { - return node->GetKind() == NodeKind::eCStyleCastNode; + return node->GetKind() == NodeKind::eCastNode; } private: CompilerType m_type; ASTNodeUP m_operand; - CStyleCastKind m_cast_kind; + CastKind m_cast_kind; }; /// This class contains one Visit method for each specialized type of @@ -300,7 +300,7 @@ class Visitor { virtual llvm::Expected<lldb::ValueObjectSP> Visit(const BooleanLiteralNode *node) = 0; virtual llvm::Expected<lldb::ValueObjectSP> - Visit(const CStyleCastNode *node) = 0; + 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 a7fe3d3fe7461..d61430c8b10fd 100644 --- a/lldb/include/lldb/ValueObject/DILEval.h +++ b/lldb/include/lldb/ValueObject/DILEval.h @@ -61,7 +61,7 @@ class Interpreter : Visitor { llvm::Expected<lldb::ValueObjectSP> Visit(const BooleanLiteralNode *node) override; llvm::Expected<lldb::ValueObjectSP> - Visit(const CStyleCastNode *node) override; + Visit(const CastNode *node) override; llvm::Expected<CompilerType> PickIntegerType(lldb::TypeSystemSP type_system, diff --git a/lldb/source/ValueObject/DILAST.cpp b/lldb/source/ValueObject/DILAST.cpp index 5922999baaa52..0b9e1f4d48ac8 100644 --- a/lldb/source/ValueObject/DILAST.cpp +++ b/lldb/source/ValueObject/DILAST.cpp @@ -51,7 +51,7 @@ BooleanLiteralNode::Accept(Visitor *v) const { return v->Visit(this); } -llvm::Expected<lldb::ValueObjectSP> CStyleCastNode::Accept(Visitor *v) const { +llvm::Expected<lldb::ValueObjectSP> CastNode::Accept(Visitor *v) const { return v->Visit(this); } diff --git a/lldb/source/ValueObject/DILEval.cpp b/lldb/source/ValueObject/DILEval.cpp index 968394e95ab67..bfaef0c892e02 100644 --- a/lldb/source/ValueObject/DILEval.cpp +++ b/lldb/source/ValueObject/DILEval.cpp @@ -609,7 +609,7 @@ Interpreter::Visit(const BooleanLiteralNode *node) { } llvm::Expected<lldb::ValueObjectSP> -Interpreter::Visit(const CStyleCastNode *node) { +Interpreter::Visit(const CastNode *node) { auto operand_or_err = Evaluate(node->GetOperand()); if (!operand_or_err) return operand_or_err; diff --git a/lldb/source/ValueObject/DILParser.cpp b/lldb/source/ValueObject/DILParser.cpp index 9c4a0cd576b5c..7ac9c06846dc1 100644 --- a/lldb/source/ValueObject/DILParser.cpp +++ b/lldb/source/ValueObject/DILParser.cpp @@ -93,43 +93,44 @@ ASTNodeUP DILParser::ParseExpression() { return ParseCastExpression(); } // "(" type_id ")" cast_expression ASTNodeUP DILParser::ParseCastExpression() { - // This can be a C-style cast, try parsing the contents as a type declaration. - if (CurToken().Is(Token::l_paren)) { - Token token = CurToken(); - uint32_t loc = token.GetLocation(); + if (!CurToken().Is(Token::l_paren)) + return ParseUnaryExpression(); - // Enable lexer backtracking, so that we can rollback in case it's not - // actually a type declaration. + // This could be a type cast, try parsing the contents as a type declaration. + Token token = CurToken(); + uint32_t loc = token.GetLocation(); - // Start tentative parsing (save token location/idx, for possible rollback). - uint32_t save_token_idx = m_dil_lexer.GetCurrentTokenIdx(); + // Enable lexer backtracking, so that we can rollback in case it's not + // actually a type declaration. - // Consume the token only after enabling the backtracking. - m_dil_lexer.Advance(); + // Start tentative parsing (save token location/idx, for possible rollback). + uint32_t save_token_idx = m_dil_lexer.GetCurrentTokenIdx(); - // Try parsing the type declaration. If the returned value is not valid, - // then we should rollback and try parsing the expression. - auto type_id = ParseTypeId(); - if (type_id) { - // Successfully parsed the type declaration. Commit the backtracked - // tokens and parse the cast_expression. + // Consume the token only after enabling the backtracking. + m_dil_lexer.Advance(); - if (!type_id.value().IsValid()) - return std::make_unique<ErrorNode>(); + // Try parsing the type declaration. If the returned value is not valid, + // then we should rollback and try parsing the expression. + auto type_id = ParseTypeId(); + if (type_id) { + // Successfully parsed the type declaration. Commit the backtracked + // tokens and parse the cast_expression. - Expect(Token::r_paren); - m_dil_lexer.Advance(); - auto rhs = ParseCastExpression(); + if (!type_id.value().IsValid()) + return std::make_unique<ErrorNode>(); - return std::make_unique<CStyleCastNode>( - loc, type_id.value(), std::move(rhs), CStyleCastKind::eNone); - } + Expect(Token::r_paren); + m_dil_lexer.Advance(); + auto rhs = ParseCastExpression(); - // Failed to parse the contents of the parentheses as a type declaration. - // Rollback the lexer and try parsing it as unary_expression. - TentativeParsingRollback(save_token_idx); + return std::make_unique<CastNode>( + loc, type_id.value(), std::move(rhs), CastKind::eNone); } + // Failed to parse the contents of the parentheses as a type declaration. + // Rollback the lexer and try parsing it as unary_expression. + TentativeParsingRollback(save_token_idx); + return ParseUnaryExpression(); } >From 9b3d26148c9661f4edbe8eebcf64c1eced0292b6 Mon Sep 17 00:00:00 2001 From: Caroline Tice <[email protected]> Date: Wed, 19 Nov 2025 10:43:15 -0800 Subject: [PATCH 3/3] Rmove unnecessary 'bad_type'; add FIXME comment. --- lldb/source/ValueObject/DILParser.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/lldb/source/ValueObject/DILParser.cpp b/lldb/source/ValueObject/DILParser.cpp index 7ac9c06846dc1..c42c986d279e4 100644 --- a/lldb/source/ValueObject/DILParser.cpp +++ b/lldb/source/ValueObject/DILParser.cpp @@ -467,7 +467,6 @@ std::string DILParser::ParseUnqualifiedId() { CompilerType DILParser::ResolveTypeDeclarators(CompilerType type, const std::vector<Token> &ptr_operators) { - CompilerType bad_type; // Resolve pointers/references. for (Token tk : ptr_operators) { uint32_t loc = tk.GetLocation(); @@ -478,17 +477,18 @@ DILParser::ResolveTypeDeclarators(CompilerType type, "reference of type {0}", type.TypeDescription()), loc, CurToken().GetSpelling().length()); - return bad_type; + return {}; } // Get pointer type for the base type: e.g. int* -> int**. type = type.GetPointerType(); } else if (tk.GetKind() == Token::amp) { // References to references are forbidden. + // FIXME: In future we may want to allow rvalue references (i.e. &&). if (type.IsReferenceType()) { BailOut("type name declared as a reference to a reference", loc, CurToken().GetSpelling().length()); - return bad_type; + return {}; } // Get reference type for the base type: e.g. int -> int&. type = type.GetLValueReferenceType(); _______________________________________________ lldb-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
