bf9a77305f
This moves the following classes from Core -> Utility. ConstString Error RegularExpression Stream StreamString The goal here is to get lldbUtility into a state where it has no dependendencies except on itself and LLVM, so it can be the starting point at which to start untangling LLDB's dependencies. These are all low level and very widely used classes, and previously lldbUtility had dependencies up to lldbCore in order to use these classes. So moving then down to lldbUtility makes sense from both the short term and long term perspective in solving this problem. Differential Revision: https://reviews.llvm.org/D29427 llvm-svn: 293941
241 lines
8.9 KiB
C++
241 lines
8.9 KiB
C++
//===-- ClangExpressionVariable.h -------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef liblldb_ClangExpressionVariable_h_
|
|
#define liblldb_ClangExpressionVariable_h_
|
|
|
|
// C Includes
|
|
#include <signal.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
|
|
// C++ Includes
|
|
#include <map>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
// Other libraries and framework includes
|
|
#include "llvm/Support/Casting.h"
|
|
|
|
// Project includes
|
|
#include "lldb/Core/ClangForward.h"
|
|
#include "lldb/Core/Value.h"
|
|
#include "lldb/Expression/ExpressionVariable.h"
|
|
#include "lldb/Symbol/TaggedASTType.h"
|
|
#include "lldb/Utility/ConstString.h"
|
|
#include "lldb/lldb-public.h"
|
|
|
|
namespace llvm {
|
|
class Value;
|
|
}
|
|
|
|
namespace lldb_private {
|
|
|
|
class ValueObjectConstResult;
|
|
|
|
//----------------------------------------------------------------------
|
|
/// @class ClangExpressionVariable ClangExpressionVariable.h
|
|
/// "lldb/Expression/ClangExpressionVariable.h"
|
|
/// @brief Encapsulates one variable for the expression parser.
|
|
///
|
|
/// The expression parser uses variables in three different contexts:
|
|
///
|
|
/// First, it stores persistent variables along with the process for use
|
|
/// in expressions. These persistent variables contain their own data
|
|
/// and are typed.
|
|
///
|
|
/// Second, in an interpreted expression, it stores the local variables
|
|
/// for the expression along with the expression. These variables
|
|
/// contain their own data and are typed.
|
|
///
|
|
/// Third, in a JIT-compiled expression, it stores the variables that
|
|
/// the expression needs to have materialized and dematerialized at each
|
|
/// execution. These do not contain their own data but are named and
|
|
/// typed.
|
|
///
|
|
/// This class supports all of these use cases using simple type
|
|
/// polymorphism, and provides necessary support methods. Its interface
|
|
/// is RTTI-neutral.
|
|
//----------------------------------------------------------------------
|
|
class ClangExpressionVariable : public ExpressionVariable {
|
|
public:
|
|
ClangExpressionVariable(ExecutionContextScope *exe_scope,
|
|
lldb::ByteOrder byte_order, uint32_t addr_byte_size);
|
|
|
|
ClangExpressionVariable(ExecutionContextScope *exe_scope, Value &value,
|
|
const ConstString &name, uint16_t flags = EVNone);
|
|
|
|
ClangExpressionVariable(const lldb::ValueObjectSP &valobj_sp);
|
|
|
|
ClangExpressionVariable(ExecutionContextScope *exe_scope,
|
|
const ConstString &name,
|
|
const TypeFromUser &user_type,
|
|
lldb::ByteOrder byte_order, uint32_t addr_byte_size);
|
|
|
|
//----------------------------------------------------------------------
|
|
/// Utility functions for dealing with ExpressionVariableLists in
|
|
/// Clang-specific ways
|
|
//----------------------------------------------------------------------
|
|
|
|
//----------------------------------------------------------------------
|
|
/// Finds a variable by NamedDecl in the list.
|
|
///
|
|
/// @param[in] name
|
|
/// The name of the requested variable.
|
|
///
|
|
/// @return
|
|
/// The variable requested, or NULL if that variable is not in the list.
|
|
//----------------------------------------------------------------------
|
|
static ClangExpressionVariable *
|
|
FindVariableInList(ExpressionVariableList &list, const clang::NamedDecl *decl,
|
|
uint64_t parser_id) {
|
|
lldb::ExpressionVariableSP var_sp;
|
|
for (size_t index = 0, size = list.GetSize(); index < size; ++index) {
|
|
var_sp = list.GetVariableAtIndex(index);
|
|
|
|
if (ClangExpressionVariable *clang_var =
|
|
llvm::dyn_cast<ClangExpressionVariable>(var_sp.get())) {
|
|
ClangExpressionVariable::ParserVars *parser_vars =
|
|
clang_var->GetParserVars(parser_id);
|
|
|
|
if (parser_vars && parser_vars->m_named_decl == decl)
|
|
return clang_var;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
/// If the variable contains its own data, make a Value point at it.
|
|
/// If \a exe_ctx in not NULL, the value will be resolved in with
|
|
/// that execution context.
|
|
///
|
|
/// @param[in] value
|
|
/// The value to point at the data.
|
|
///
|
|
/// @param[in] exe_ctx
|
|
/// The execution context to use to resolve \a value.
|
|
///
|
|
/// @return
|
|
/// True on success; false otherwise (in particular, if this variable
|
|
/// does not contain its own data).
|
|
//----------------------------------------------------------------------
|
|
bool PointValueAtData(Value &value, ExecutionContext *exe_ctx);
|
|
|
|
//----------------------------------------------------------------------
|
|
/// The following values should not live beyond parsing
|
|
//----------------------------------------------------------------------
|
|
class ParserVars {
|
|
public:
|
|
ParserVars()
|
|
: m_parser_type(), m_named_decl(NULL), m_llvm_value(NULL),
|
|
m_lldb_value(), m_lldb_var(), m_lldb_sym(NULL) {}
|
|
|
|
TypeFromParser
|
|
m_parser_type; ///< The type of the variable according to the parser
|
|
const clang::NamedDecl
|
|
*m_named_decl; ///< The Decl corresponding to this variable
|
|
llvm::Value *m_llvm_value; ///< The IR value corresponding to this variable;
|
|
///usually a GlobalValue
|
|
lldb_private::Value
|
|
m_lldb_value; ///< The value found in LLDB for this variable
|
|
lldb::VariableSP m_lldb_var; ///< The original variable for this variable
|
|
const lldb_private::Symbol *m_lldb_sym; ///< The original symbol for this
|
|
///variable, if it was a symbol
|
|
};
|
|
|
|
private:
|
|
typedef std::map<uint64_t, ParserVars> ParserVarMap;
|
|
ParserVarMap m_parser_vars;
|
|
|
|
public:
|
|
//----------------------------------------------------------------------
|
|
/// Make this variable usable by the parser by allocating space for
|
|
/// parser-specific variables
|
|
//----------------------------------------------------------------------
|
|
void EnableParserVars(uint64_t parser_id) {
|
|
m_parser_vars.insert(std::make_pair(parser_id, ParserVars()));
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
/// Deallocate parser-specific variables
|
|
//----------------------------------------------------------------------
|
|
void DisableParserVars(uint64_t parser_id) { m_parser_vars.erase(parser_id); }
|
|
|
|
//----------------------------------------------------------------------
|
|
/// Access parser-specific variables
|
|
//----------------------------------------------------------------------
|
|
ParserVars *GetParserVars(uint64_t parser_id) {
|
|
ParserVarMap::iterator i = m_parser_vars.find(parser_id);
|
|
|
|
if (i == m_parser_vars.end())
|
|
return NULL;
|
|
else
|
|
return &i->second;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
/// The following values are valid if the variable is used by JIT code
|
|
//----------------------------------------------------------------------
|
|
struct JITVars {
|
|
JITVars() : m_alignment(0), m_size(0), m_offset(0) {}
|
|
|
|
lldb::offset_t
|
|
m_alignment; ///< The required alignment of the variable, in bytes
|
|
size_t m_size; ///< The space required for the variable, in bytes
|
|
lldb::offset_t
|
|
m_offset; ///< The offset of the variable in the struct, in bytes
|
|
};
|
|
|
|
private:
|
|
typedef std::map<uint64_t, JITVars> JITVarMap;
|
|
JITVarMap m_jit_vars;
|
|
|
|
public:
|
|
//----------------------------------------------------------------------
|
|
/// Make this variable usable for materializing for the JIT by allocating
|
|
/// space for JIT-specific variables
|
|
//----------------------------------------------------------------------
|
|
void EnableJITVars(uint64_t parser_id) {
|
|
m_jit_vars.insert(std::make_pair(parser_id, JITVars()));
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
/// Deallocate JIT-specific variables
|
|
//----------------------------------------------------------------------
|
|
void DisableJITVars(uint64_t parser_id) { m_jit_vars.erase(parser_id); }
|
|
|
|
JITVars *GetJITVars(uint64_t parser_id) {
|
|
JITVarMap::iterator i = m_jit_vars.find(parser_id);
|
|
|
|
if (i == m_jit_vars.end())
|
|
return NULL;
|
|
else
|
|
return &i->second;
|
|
}
|
|
|
|
TypeFromUser GetTypeFromUser();
|
|
|
|
//------------------------------------------------------------------
|
|
// llvm casting support
|
|
//------------------------------------------------------------------
|
|
static bool classof(const ExpressionVariable *ev) {
|
|
return ev->getKind() == ExpressionVariable::eKindClang;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
/// Members
|
|
//----------------------------------------------------------------------
|
|
DISALLOW_COPY_AND_ASSIGN(ClangExpressionVariable);
|
|
};
|
|
|
|
} // namespace lldb_private
|
|
|
|
#endif // liblldb_ClangExpressionVariable_h_
|