47e7ecdd7d
Right now we have one large AST for all types in LLDB. All ODR violations in types we reconstruct are resolved by just letting the ASTImporter handle the conflicts (either by merging types or somehow trying to introduce a duplicated declaration in the AST). This works ok for the normal types we build from debug information as most of them are just simple CXXRecordDecls or empty template declarations. However, with a loaded `std` C++ module we have alternative versions of pretty much all declarations in the `std` namespace that are much more fleshed out than the debug information declarations. They have all the information that is lost when converting to DWARF, such as default arguments, template default arguments, the actual uninstantiated template declarations and so on. When we merge these C++ module types into the big scratch AST (that might already contain debug information types) we give the ASTImporter the tricky task of somehow creating a consistent AST out of all these declarations. Usually this ends in a messy AST that contains a mostly broken mix of both module and debug info declarations. The ASTImporter in LLDB is also importing types with the MinimalImport setting, which usually means the only information we have when merging two types is often just the name of the declaration and the information that it contains some child declarations. This makes it pretty much impossible to even implement a better merging logic (as the names of C++ module declarations and debug info declarations are identical). This patch works around this whole merging problem by separating C++ module types from debug information types. This is done by splitting up the single scratch AST into two: One default AST for debug information and a dedicated AST for C++ module types. The C++ module AST is implemented as a 'specialised AST' that lives within the default ScratchTypeSystemClang. When we select the scratch AST we can explicitly request that we want such a isolated sub-AST of the scratch AST. I kept the infrastructure more general as we probably can use the same mechanism for other features that introduce conflicting types (such as programs that are compiled with a custom -wchar-size= option). There are just two places where we explicitly have request the C++ module AST: When we export persistent declarations (`$mytype`) and when we create our persistent result variable (`$0`, `$1`, ...). There are a few formatters that were previously assuming that there is only one scratch AST which I cleaned up in a preparation revision here (D92757). Reviewed By: aprantl Differential Revision: https://reviews.llvm.org/D92759
635 lines
24 KiB
C++
635 lines
24 KiB
C++
//===-- ClangExpressionDeclMap.h --------------------------------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXPRESSIONDECLMAP_H
|
|
#define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXPRESSIONDECLMAP_H
|
|
|
|
#include <signal.h>
|
|
#include <stdint.h>
|
|
|
|
#include <vector>
|
|
|
|
#include "ClangASTSource.h"
|
|
#include "ClangExpressionVariable.h"
|
|
|
|
#include "lldb/Core/Value.h"
|
|
#include "lldb/Expression/Materializer.h"
|
|
#include "lldb/Symbol/SymbolContext.h"
|
|
#include "lldb/Symbol/TaggedASTType.h"
|
|
#include "lldb/Target/ExecutionContext.h"
|
|
#include "lldb/lldb-public.h"
|
|
#include "clang/AST/Decl.h"
|
|
#include "llvm/ADT/DenseMap.h"
|
|
|
|
namespace lldb_private {
|
|
|
|
class ClangPersistentVariables;
|
|
|
|
/// \class ClangExpressionDeclMap ClangExpressionDeclMap.h
|
|
/// "lldb/Expression/ClangExpressionDeclMap.h" Manages named entities that are
|
|
/// defined in LLDB's debug information.
|
|
///
|
|
/// The Clang parser uses the ClangASTSource as an interface to request named
|
|
/// entities from outside an expression. The ClangASTSource reports back,
|
|
/// listing all possible objects corresponding to a particular name. But it
|
|
/// in turn relies on ClangExpressionDeclMap, which performs several important
|
|
/// functions.
|
|
///
|
|
/// First, it records what variables and functions were looked up and what
|
|
/// Decls were returned for them.
|
|
///
|
|
/// Second, it constructs a struct on behalf of IRForTarget, recording which
|
|
/// variables should be placed where and relaying this information back so
|
|
/// that IRForTarget can generate context-independent code.
|
|
///
|
|
/// Third, it "materializes" this struct on behalf of the expression command,
|
|
/// finding the current values of each variable and placing them into the
|
|
/// struct so that it can be passed to the JITted version of the IR.
|
|
///
|
|
/// Fourth and finally, it "dematerializes" the struct after the JITted code
|
|
/// has has executed, placing the new values back where it found the old ones.
|
|
class ClangExpressionDeclMap : public ClangASTSource {
|
|
public:
|
|
/// Constructor
|
|
///
|
|
/// Initializes class variables.
|
|
///
|
|
/// \param[in] keep_result_in_memory
|
|
/// If true, inhibits the normal deallocation of the memory for
|
|
/// the result persistent variable, and instead marks the variable
|
|
/// as persisting.
|
|
///
|
|
/// \param[in] result_delegate
|
|
/// If non-NULL, use this delegate to report result values. This
|
|
/// allows the client ClangUserExpression to report a result.
|
|
///
|
|
/// \param[in] target
|
|
/// The target to use when parsing.
|
|
///
|
|
/// \param[in] importer
|
|
/// The ClangASTImporter to use when parsing.
|
|
///
|
|
/// \param[in] ctx_obj
|
|
/// If not empty, then expression is evaluated in context of this object.
|
|
/// See the comment to `UserExpression::Evaluate` for details.
|
|
ClangExpressionDeclMap(
|
|
bool keep_result_in_memory,
|
|
Materializer::PersistentVariableDelegate *result_delegate,
|
|
const lldb::TargetSP &target,
|
|
const std::shared_ptr<ClangASTImporter> &importer, ValueObject *ctx_obj);
|
|
|
|
/// Destructor
|
|
~ClangExpressionDeclMap() override;
|
|
|
|
/// Enable the state needed for parsing and IR transformation.
|
|
///
|
|
/// \param[in] exe_ctx
|
|
/// The execution context to use when finding types for variables.
|
|
/// Also used to find a "scratch" AST context to store result types.
|
|
///
|
|
/// \param[in] materializer
|
|
/// If non-NULL, the materializer to populate with information about
|
|
/// the variables to use
|
|
///
|
|
/// \return
|
|
/// True if parsing is possible; false if it is unsafe to continue.
|
|
bool WillParse(ExecutionContext &exe_ctx, Materializer *materializer);
|
|
|
|
void InstallCodeGenerator(clang::ASTConsumer *code_gen);
|
|
|
|
void InstallDiagnosticManager(DiagnosticManager &diag_manager);
|
|
|
|
/// Disable the state needed for parsing and IR transformation.
|
|
void DidParse();
|
|
|
|
/// [Used by IRForTarget] Add a variable to the list of persistent
|
|
/// variables for the process.
|
|
///
|
|
/// \param[in] decl
|
|
/// The Clang declaration for the persistent variable, used for
|
|
/// lookup during parsing.
|
|
///
|
|
/// \param[in] name
|
|
/// The name of the persistent variable, usually $something.
|
|
///
|
|
/// \param[in] type
|
|
/// The type of the variable, in the Clang parser's context.
|
|
///
|
|
/// \return
|
|
/// True on success; false otherwise.
|
|
bool AddPersistentVariable(const clang::NamedDecl *decl,
|
|
ConstString name, TypeFromParser type,
|
|
bool is_result, bool is_lvalue);
|
|
|
|
/// [Used by IRForTarget] Add a variable to the struct that needs to
|
|
/// be materialized each time the expression runs.
|
|
///
|
|
/// \param[in] decl
|
|
/// The Clang declaration for the variable.
|
|
///
|
|
/// \param[in] name
|
|
/// The name of the variable.
|
|
///
|
|
/// \param[in] value
|
|
/// The LLVM IR value for this variable.
|
|
///
|
|
/// \param[in] size
|
|
/// The size of the variable in bytes.
|
|
///
|
|
/// \param[in] alignment
|
|
/// The required alignment of the variable in bytes.
|
|
///
|
|
/// \return
|
|
/// True on success; false otherwise.
|
|
bool AddValueToStruct(const clang::NamedDecl *decl, ConstString name,
|
|
llvm::Value *value, size_t size,
|
|
lldb::offset_t alignment);
|
|
|
|
/// [Used by IRForTarget] Finalize the struct, laying out the position of
|
|
/// each object in it.
|
|
///
|
|
/// \return
|
|
/// True on success; false otherwise.
|
|
bool DoStructLayout();
|
|
|
|
/// [Used by IRForTarget] Get general information about the laid-out struct
|
|
/// after DoStructLayout() has been called.
|
|
///
|
|
/// \param[out] num_elements
|
|
/// The number of elements in the struct.
|
|
///
|
|
/// \param[out] size
|
|
/// The size of the struct, in bytes.
|
|
///
|
|
/// \param[out] alignment
|
|
/// The alignment of the struct, in bytes.
|
|
///
|
|
/// \return
|
|
/// True if the information could be retrieved; false otherwise.
|
|
bool GetStructInfo(uint32_t &num_elements, size_t &size,
|
|
lldb::offset_t &alignment);
|
|
|
|
/// [Used by IRForTarget] Get specific information about one field of the
|
|
/// laid-out struct after DoStructLayout() has been called.
|
|
///
|
|
/// \param[out] decl
|
|
/// The parsed Decl for the field, as generated by ClangASTSource
|
|
/// on ClangExpressionDeclMap's behalf. In the case of the result
|
|
/// value, this will have the name $__lldb_result even if the
|
|
/// result value ends up having the name $1. This is an
|
|
/// implementation detail of IRForTarget.
|
|
///
|
|
/// \param[out] value
|
|
/// The IR value for the field (usually a GlobalVariable). In
|
|
/// the case of the result value, this will have the correct
|
|
/// name ($1, for instance). This is an implementation detail
|
|
/// of IRForTarget.
|
|
///
|
|
/// \param[out] offset
|
|
/// The offset of the field from the beginning of the struct.
|
|
/// As long as the struct is aligned according to its required
|
|
/// alignment, this offset will align the field correctly.
|
|
///
|
|
/// \param[out] name
|
|
/// The name of the field as used in materialization.
|
|
///
|
|
/// \param[in] index
|
|
/// The index of the field about which information is requested.
|
|
///
|
|
/// \return
|
|
/// True if the information could be retrieved; false otherwise.
|
|
bool GetStructElement(const clang::NamedDecl *&decl, llvm::Value *&value,
|
|
lldb::offset_t &offset, ConstString &name,
|
|
uint32_t index);
|
|
|
|
/// [Used by IRForTarget] Get information about a function given its Decl.
|
|
///
|
|
/// \param[in] decl
|
|
/// The parsed Decl for the Function, as generated by ClangASTSource
|
|
/// on ClangExpressionDeclMap's behalf.
|
|
///
|
|
/// \param[out] ptr
|
|
/// The absolute address of the function in the target.
|
|
///
|
|
/// \return
|
|
/// True if the information could be retrieved; false otherwise.
|
|
bool GetFunctionInfo(const clang::NamedDecl *decl, uint64_t &ptr);
|
|
|
|
/// [Used by IRForTarget] Get the address of a symbol given nothing but its
|
|
/// name.
|
|
///
|
|
/// \param[in] target
|
|
/// The target to find the symbol in. If not provided,
|
|
/// then the current parsing context's Target.
|
|
///
|
|
/// \param[in] process
|
|
/// The process to use. For Objective-C symbols, the process's
|
|
/// Objective-C language runtime may be queried if the process
|
|
/// is non-NULL.
|
|
///
|
|
/// \param[in] name
|
|
/// The name of the symbol.
|
|
///
|
|
/// \param[in] module
|
|
/// The module to limit the search to. This can be NULL
|
|
///
|
|
/// \return
|
|
/// Valid load address for the symbol
|
|
lldb::addr_t GetSymbolAddress(Target &target, Process *process,
|
|
ConstString name, lldb::SymbolType symbol_type,
|
|
Module *module = nullptr);
|
|
|
|
lldb::addr_t GetSymbolAddress(ConstString name,
|
|
lldb::SymbolType symbol_type);
|
|
|
|
struct TargetInfo {
|
|
lldb::ByteOrder byte_order;
|
|
size_t address_byte_size;
|
|
|
|
TargetInfo() : byte_order(lldb::eByteOrderInvalid), address_byte_size(0) {}
|
|
|
|
bool IsValid() {
|
|
return (byte_order != lldb::eByteOrderInvalid && address_byte_size != 0);
|
|
}
|
|
};
|
|
TargetInfo GetTargetInfo();
|
|
|
|
/// [Used by ClangASTSource] Find all entities matching a given name, using
|
|
/// a NameSearchContext to make Decls for them.
|
|
///
|
|
/// \param[in] context
|
|
/// The NameSearchContext that can construct Decls for this name.
|
|
void FindExternalVisibleDecls(NameSearchContext &context) override;
|
|
|
|
/// Find all entities matching a given name in a given module/namespace,
|
|
/// using a NameSearchContext to make Decls for them.
|
|
///
|
|
/// \param[in] context
|
|
/// The NameSearchContext that can construct Decls for this name.
|
|
///
|
|
/// \param[in] module
|
|
/// If non-NULL, the module to query.
|
|
///
|
|
/// \param[in] namespace_decl
|
|
/// If valid and module is non-NULL, the parent namespace.
|
|
void FindExternalVisibleDecls(NameSearchContext &context,
|
|
lldb::ModuleSP module,
|
|
const CompilerDeclContext &namespace_decl);
|
|
|
|
protected:
|
|
/// Retrieves the declaration with the given name from the storage of
|
|
/// persistent declarations.
|
|
///
|
|
/// \return
|
|
/// A persistent decl with the given name or a nullptr.
|
|
virtual clang::NamedDecl *GetPersistentDecl(ConstString name);
|
|
|
|
private:
|
|
ExpressionVariableList
|
|
m_found_entities; ///< All entities that were looked up for the parser.
|
|
ExpressionVariableList
|
|
m_struct_members; ///< All entities that need to be placed in the struct.
|
|
bool m_keep_result_in_memory; ///< True if result persistent variables
|
|
///generated by this expression should stay in
|
|
///memory.
|
|
Materializer::PersistentVariableDelegate
|
|
*m_result_delegate; ///< If non-NULL, used to report expression results to
|
|
///ClangUserExpression.
|
|
ValueObject *m_ctx_obj; ///< If not empty, then expression is
|
|
///evaluated in context of this object.
|
|
///For details see the comment to
|
|
///`UserExpression::Evaluate`.
|
|
|
|
/// The following values should not live beyond parsing
|
|
class ParserVars {
|
|
public:
|
|
ParserVars() {}
|
|
|
|
Target *GetTarget() {
|
|
if (m_exe_ctx.GetTargetPtr())
|
|
return m_exe_ctx.GetTargetPtr();
|
|
else if (m_sym_ctx.target_sp)
|
|
return m_sym_ctx.target_sp.get();
|
|
return nullptr;
|
|
}
|
|
|
|
ExecutionContext m_exe_ctx; ///< The execution context to use when parsing.
|
|
SymbolContext m_sym_ctx; ///< The symbol context to use in finding variables
|
|
///and types.
|
|
ClangPersistentVariables *m_persistent_vars =
|
|
nullptr; ///< The persistent variables for the process.
|
|
bool m_enable_lookups = false; ///< Set to true during parsing if we have
|
|
///found the first "$__lldb" name.
|
|
TargetInfo m_target_info; ///< Basic information about the target.
|
|
Materializer *m_materializer = nullptr; ///< If non-NULL, the materializer
|
|
///to use when reporting used
|
|
///variables.
|
|
clang::ASTConsumer *m_code_gen = nullptr; ///< If non-NULL, a code generator
|
|
///that receives new top-level
|
|
///functions.
|
|
DiagnosticManager *m_diagnostics = nullptr;
|
|
|
|
private:
|
|
ParserVars(const ParserVars &) = delete;
|
|
const ParserVars &operator=(const ParserVars &) = delete;
|
|
};
|
|
|
|
std::unique_ptr<ParserVars> m_parser_vars;
|
|
|
|
/// Activate parser-specific variables
|
|
void EnableParserVars() {
|
|
if (!m_parser_vars.get())
|
|
m_parser_vars = std::make_unique<ParserVars>();
|
|
}
|
|
|
|
/// Deallocate parser-specific variables
|
|
void DisableParserVars() { m_parser_vars.reset(); }
|
|
|
|
/// The following values contain layout information for the materialized
|
|
/// struct, but are not specific to a single materialization
|
|
struct StructVars {
|
|
StructVars()
|
|
: m_struct_alignment(0), m_struct_size(0), m_struct_laid_out(false),
|
|
m_result_name(), m_object_pointer_type(nullptr, nullptr) {}
|
|
|
|
lldb::offset_t
|
|
m_struct_alignment; ///< The alignment of the struct in bytes.
|
|
size_t m_struct_size; ///< The size of the struct in bytes.
|
|
bool m_struct_laid_out; ///< True if the struct has been laid out and the
|
|
///layout is valid (that is, no new fields have been
|
|
///added since).
|
|
ConstString
|
|
m_result_name; ///< The name of the result variable ($1, for example)
|
|
TypeFromUser m_object_pointer_type; ///< The type of the "this" variable, if
|
|
///one exists
|
|
};
|
|
|
|
std::unique_ptr<StructVars> m_struct_vars;
|
|
|
|
/// Activate struct variables
|
|
void EnableStructVars() {
|
|
if (!m_struct_vars.get())
|
|
m_struct_vars.reset(new struct StructVars);
|
|
}
|
|
|
|
/// Deallocate struct variables
|
|
void DisableStructVars() { m_struct_vars.reset(); }
|
|
|
|
TypeSystemClang *GetScratchContext(Target &target) {
|
|
return ScratchTypeSystemClang::GetForTarget(target,
|
|
m_ast_context->getLangOpts());
|
|
}
|
|
|
|
/// Get this parser's ID for use in extracting parser- and JIT-specific data
|
|
/// from persistent variables.
|
|
uint64_t GetParserID() { return (uint64_t) this; }
|
|
|
|
/// Should be called on all copied functions.
|
|
void MaybeRegisterFunctionBody(clang::FunctionDecl *copied_function_decl);
|
|
|
|
/// Searches the persistent decls of the target for entities with the
|
|
/// given name.
|
|
///
|
|
/// \param[in] context
|
|
/// The NameSearchContext that can construct Decls for this name.
|
|
///
|
|
/// \param[in] name
|
|
/// The name of the entities that need to be found.
|
|
void SearchPersistenDecls(NameSearchContext &context, const ConstString name);
|
|
|
|
/// Handles looking up $__lldb_class which requires special treatment.
|
|
///
|
|
/// \param[in] context
|
|
/// The NameSearchContext that can construct Decls for this name.
|
|
void LookUpLldbClass(NameSearchContext &context);
|
|
|
|
/// Handles looking up $__lldb_objc_class which requires special treatment.
|
|
///
|
|
/// \param[in] context
|
|
/// The NameSearchContext that can construct Decls for this name.
|
|
void LookUpLldbObjCClass(NameSearchContext &context);
|
|
|
|
/// Handles looking up the synthetic namespace that contains our local
|
|
/// variables for the current frame.
|
|
///
|
|
/// \param[in] sym_ctx
|
|
/// The current SymbolContext of this frame.
|
|
///
|
|
/// \param[in] name_context
|
|
/// The NameSearchContext that can construct Decls for this name.
|
|
void LookupLocalVarNamespace(SymbolContext &sym_ctx,
|
|
NameSearchContext &name_context);
|
|
|
|
/// Lookup entities in the ClangModulesDeclVendor.
|
|
/// \param[in] context
|
|
/// The NameSearchContext that can construct Decls for this name.
|
|
///
|
|
/// \param[in] name
|
|
/// The name of the entities that need to be found.
|
|
void LookupInModulesDeclVendor(NameSearchContext &context, ConstString name);
|
|
|
|
/// Looks up a local variable.
|
|
///
|
|
/// \param[in] context
|
|
/// The NameSearchContext that can construct Decls for this name.
|
|
///
|
|
/// \param[in] name
|
|
/// The name of the entities that need to be found.
|
|
///
|
|
/// \param[in] sym_ctx
|
|
/// The current SymbolContext of this frame.
|
|
///
|
|
/// \param[in] namespace_decl
|
|
/// The parent namespace if there is one.
|
|
///
|
|
/// \return
|
|
/// True iff a local variable was found.
|
|
bool LookupLocalVariable(NameSearchContext &context, ConstString name,
|
|
SymbolContext &sym_ctx,
|
|
const CompilerDeclContext &namespace_decl);
|
|
|
|
/// Searches for functions in the given SymbolContextList.
|
|
///
|
|
/// \param[in] sc_list
|
|
/// The SymbolContextList to search.
|
|
///
|
|
/// \param[in] frame_decl_context
|
|
/// The current DeclContext of the current frame.
|
|
///
|
|
/// \return
|
|
/// A SymbolContextList with any found functions in the front and
|
|
/// any unknown SymbolContexts which are not functions in the back.
|
|
/// The SymbolContexts for the functions are ordered by how close they are
|
|
/// to the DeclContext for the given frame DeclContext.
|
|
SymbolContextList SearchFunctionsInSymbolContexts(
|
|
const SymbolContextList &sc_list,
|
|
const CompilerDeclContext &frame_decl_context);
|
|
|
|
/// Looks up a function.
|
|
///
|
|
/// \param[in] context
|
|
/// The NameSearchContext that can construct Decls for this name.
|
|
///
|
|
/// \param[in] module_sp
|
|
/// If non-NULL, the module to query.
|
|
///
|
|
/// \param[in] name
|
|
/// The name of the function that should be find.
|
|
///
|
|
/// \param[in] namespace_decl
|
|
/// If valid and module is non-NULL, the parent namespace.
|
|
void LookupFunction(NameSearchContext &context, lldb::ModuleSP module_sp,
|
|
ConstString name,
|
|
const CompilerDeclContext &namespace_decl);
|
|
|
|
/// Given a target, find a variable that matches the given name and type.
|
|
///
|
|
/// \param[in] target
|
|
/// The target to use as a basis for finding the variable.
|
|
///
|
|
/// \param[in] module
|
|
/// If non-NULL, the module to search.
|
|
///
|
|
/// \param[in] name
|
|
/// The name as a plain C string.
|
|
///
|
|
/// \param[in] namespace_decl
|
|
/// If non-NULL and module is non-NULL, the parent namespace.
|
|
///
|
|
/// \return
|
|
/// The LLDB Variable found, or NULL if none was found.
|
|
lldb::VariableSP
|
|
FindGlobalVariable(Target &target, lldb::ModuleSP &module, ConstString name,
|
|
const CompilerDeclContext &namespace_decl);
|
|
|
|
/// Get the value of a variable in a given execution context and return the
|
|
/// associated Types if needed.
|
|
///
|
|
/// \param[in] var
|
|
/// The variable to evaluate.
|
|
///
|
|
/// \param[out] var_location
|
|
/// The variable location value to fill in
|
|
///
|
|
/// \param[out] found_type
|
|
/// The type of the found value, as it was found in the user process.
|
|
/// This is only useful when the variable is being inspected on behalf
|
|
/// of the parser, hence the default.
|
|
///
|
|
/// \param[out] parser_type
|
|
/// The type of the found value, as it was copied into the parser's
|
|
/// AST context. This is only useful when the variable is being
|
|
/// inspected on behalf of the parser, hence the default.
|
|
///
|
|
/// \return
|
|
/// Return true if the value was successfully filled in.
|
|
bool GetVariableValue(lldb::VariableSP &var,
|
|
lldb_private::Value &var_location,
|
|
TypeFromUser *found_type = nullptr,
|
|
TypeFromParser *parser_type = nullptr);
|
|
|
|
/// Use the NameSearchContext to generate a Decl for the given LLDB
|
|
/// Variable, and put it in the Tuple list.
|
|
///
|
|
/// \param[in] context
|
|
/// The NameSearchContext to use when constructing the Decl.
|
|
///
|
|
/// \param[in] var
|
|
/// The LLDB Variable that needs a Decl.
|
|
///
|
|
/// \param[in] valobj
|
|
/// The LLDB ValueObject for that variable.
|
|
void AddOneVariable(NameSearchContext &context, lldb::VariableSP var,
|
|
lldb::ValueObjectSP valobj);
|
|
|
|
/// Use the NameSearchContext to generate a Decl for the given persistent
|
|
/// variable, and put it in the list of found entities.
|
|
///
|
|
/// \param[in] context
|
|
/// The NameSearchContext to use when constructing the Decl.
|
|
///
|
|
/// \param[in] pvar_sp
|
|
/// The persistent variable that needs a Decl.
|
|
void AddOneVariable(NameSearchContext &context,
|
|
lldb::ExpressionVariableSP &pvar_sp);
|
|
|
|
/// Use the NameSearchContext to generate a Decl for the given LLDB symbol
|
|
/// (treated as a variable), and put it in the list of found entities.
|
|
void AddOneGenericVariable(NameSearchContext &context, const Symbol &symbol);
|
|
|
|
/// Use the NameSearchContext to generate a Decl for the given function.
|
|
/// (Functions are not placed in the Tuple list.) Can handle both fully
|
|
/// typed functions and generic functions.
|
|
///
|
|
/// \param[in] context
|
|
/// The NameSearchContext to use when constructing the Decl.
|
|
///
|
|
/// \param[in] fun
|
|
/// The Function that needs to be created. If non-NULL, this is
|
|
/// a fully-typed function.
|
|
///
|
|
/// \param[in] sym
|
|
/// The Symbol that corresponds to a function that needs to be
|
|
/// created with generic type (unitptr_t foo(...)).
|
|
void AddOneFunction(NameSearchContext &context, Function *fun, Symbol *sym);
|
|
|
|
/// Use the NameSearchContext to generate a Decl for the given register.
|
|
///
|
|
/// \param[in] context
|
|
/// The NameSearchContext to use when constructing the Decl.
|
|
///
|
|
/// \param[in] reg_info
|
|
/// The information corresponding to that register.
|
|
void AddOneRegister(NameSearchContext &context, const RegisterInfo *reg_info);
|
|
|
|
/// Use the NameSearchContext to generate a Decl for the given type. (Types
|
|
/// are not placed in the Tuple list.)
|
|
///
|
|
/// \param[in] context
|
|
/// The NameSearchContext to use when constructing the Decl.
|
|
///
|
|
/// \param[in] type
|
|
/// The type that needs to be created.
|
|
void AddOneType(NameSearchContext &context, const TypeFromUser &type);
|
|
|
|
/// Adds the class in which the expression is evaluated to the lookup and
|
|
/// prepares the class to be used as a context for expression evaluation (for
|
|
/// example, it creates a fake member function that will contain the
|
|
/// expression LLDB is trying to evaluate).
|
|
///
|
|
/// \param[in] context
|
|
/// The NameSearchContext to which the class should be added as a lookup
|
|
/// result.
|
|
///
|
|
/// \param[in] type
|
|
/// The type of the class that serves as the evaluation context.
|
|
void AddContextClassType(NameSearchContext &context,
|
|
const TypeFromUser &type);
|
|
|
|
/// Move a type out of the current ASTContext into another, but make sure to
|
|
/// export all components of the type also.
|
|
///
|
|
/// \param[in] target
|
|
/// The TypeSystemClang to move to.
|
|
/// \param[in] source
|
|
/// The TypeSystemClang to move from. This is assumed to be going away.
|
|
/// \param[in] parser_type
|
|
/// The type as it appears in the source context.
|
|
///
|
|
/// \return
|
|
/// Returns the moved type, or an empty type if there was a problem.
|
|
TypeFromUser DeportType(TypeSystemClang &target, TypeSystemClang &source,
|
|
TypeFromParser parser_type);
|
|
|
|
TypeSystemClang *GetTypeSystemClang();
|
|
};
|
|
|
|
} // namespace lldb_private
|
|
|
|
#endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXPRESSIONDECLMAP_H
|