Update prebuilt Clang to r416183b from Android.
https://android.googlesource.com/platform/prebuilts/clang/host/
linux-x86/+/06a71ddac05c22edb2d10b590e1769b3f8619bef
clang 12.0.5 (based on r416183b) from build 7284624.
Change-Id: I277a316abcf47307562d8b748b84870f31a72866
Signed-off-by: Olivier Deprez <olivier.deprez@arm.com>
diff --git a/linux-x64/clang/include/lldb/Expression/DWARFExpression.h b/linux-x64/clang/include/lldb/Expression/DWARFExpression.h
index 21830a5..c7d4e4b 100644
--- a/linux-x64/clang/include/lldb/Expression/DWARFExpression.h
+++ b/linux-x64/clang/include/lldb/Expression/DWARFExpression.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef liblldb_DWARFExpression_h_
-#define liblldb_DWARFExpression_h_
+#ifndef LLDB_EXPRESSION_DWARFEXPRESSION_H
+#define LLDB_EXPRESSION_DWARFEXPRESSION_H
#include "lldb/Core/Address.h"
#include "lldb/Core/Disassembler.h"
@@ -34,15 +34,6 @@
/// location expression or a location list and interprets it.
class DWARFExpression {
public:
- enum LocationListFormat : uint8_t {
- NonLocationList, // Not a location list
- RegularLocationList, // Location list format used in non-split dwarf files
- SplitDwarfLocationList, // Location list format used in pre-DWARF v5 split
- // dwarf files (.debug_loc.dwo)
- LocLists, // Location list format used in DWARF v5
- // (.debug_loclists/.debug_loclists.dwo).
- };
-
DWARFExpression();
/// Constructor
@@ -50,15 +41,8 @@
/// \param[in] data
/// A data extractor configured to read the DWARF location expression's
/// bytecode.
- ///
- /// \param[in] data_offset
- /// The offset of the location expression in the extractor.
- ///
- /// \param[in] data_length
- /// The byte length of the location expression.
DWARFExpression(lldb::ModuleSP module, const DataExtractor &data,
- const DWARFUnit *dwarf_cu, lldb::offset_t data_offset,
- lldb::offset_t data_length);
+ const DWARFUnit *dwarf_cu);
/// Destructor
virtual ~DWARFExpression();
@@ -92,8 +76,8 @@
/// Search for a load address in the location list
///
- /// \param[in] process
- /// The process to use when resolving the load address
+ /// \param[in] func_load_addr
+ /// The actual address of the function containing this location list.
///
/// \param[in] addr
/// The address to resolve
@@ -105,7 +89,7 @@
// LocationListContainsLoadAddress (Process* process, const Address &addr)
// const;
//
- bool LocationListContainsAddress(lldb::addr_t loclist_base_addr,
+ bool LocationListContainsAddress(lldb::addr_t func_load_addr,
lldb::addr_t addr) const;
/// If a location is not a location list, return true if the location
@@ -145,13 +129,15 @@
/// Tells the expression that it refers to a location list.
///
- /// \param[in] slide
- /// This value should be a slide that is applied to any values
- /// in the location list data so the values become zero based
- /// offsets into the object that owns the location list. We need
- /// to make location lists relative to the objects that own them
- /// so we can relink addresses on the fly.
- void SetLocationListSlide(lldb::addr_t slide);
+ /// \param[in] cu_file_addr
+ /// The base address to use for interpreting relative location list
+ /// entries.
+ /// \param[in] func_file_addr
+ /// The file address of the function containing this location list. This
+ /// address will be used to relocate the location list on the fly (in
+ /// conjuction with the func_load_addr arguments).
+ void SetLocationListAddresses(lldb::addr_t cu_file_addr,
+ lldb::addr_t func_file_addr);
/// Return the call-frame-info style register kind
int GetRegisterKind();
@@ -165,8 +151,7 @@
/// Wrapper for the static evaluate function that accepts an
/// ExecutionContextScope instead of an ExecutionContext and uses member
/// variables to populate many operands
- bool Evaluate(ExecutionContextScope *exe_scope,
- lldb::addr_t loclist_base_load_addr,
+ bool Evaluate(ExecutionContextScope *exe_scope, lldb::addr_t func_load_addr,
const Value *initial_value_ptr, const Value *object_address_ptr,
Value &result, Status *error_ptr) const;
@@ -191,19 +176,6 @@
/// This is a static method so the opcodes need to be provided
/// explicitly.
///
- /// \param[in] expr_locals
- /// If the location expression was produced by the expression parser,
- /// the list of local variables referenced by the DWARF expression.
- /// This list should already have been populated during parsing;
- /// the DWARF expression refers to variables by index. Can be NULL if
- /// the location expression uses no locals.
- ///
- /// \param[in] decl_map
- /// If the location expression was produced by the expression parser,
- /// the list of external variables referenced by the location
- /// expression. Can be NULL if the location expression uses no
- /// external variables.
- ///
/// \param[in] reg_ctx
/// An optional parameter which provides a RegisterContext for use
/// when evaluating the expression (i.e. for fetching register values).
@@ -211,12 +183,6 @@
/// in the case where an expression needs to be evaluated while building
/// the stack frame list, this short-cut is available.
///
- /// \param[in] offset
- /// The offset of the location expression in the data extractor.
- ///
- /// \param[in] length
- /// The length in bytes of the location expression.
- ///
/// \param[in] reg_set
/// The call-frame-info style register kind.
///
@@ -236,8 +202,7 @@
/// details of the failure are provided through it.
static bool Evaluate(ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
lldb::ModuleSP opcode_ctx, const DataExtractor &opcodes,
- const DWARFUnit *dwarf_cu, const lldb::offset_t offset,
- const lldb::offset_t length,
+ const DWARFUnit *dwarf_cu,
const lldb::RegisterKind reg_set,
const Value *initial_value_ptr,
const Value *object_address_ptr, Value &result,
@@ -249,34 +214,23 @@
}
bool DumpLocationForAddress(Stream *s, lldb::DescriptionLevel level,
- lldb::addr_t loclist_base_load_addr,
- lldb::addr_t address, ABI *abi);
-
- static size_t LocationListSize(const DWARFUnit *dwarf_cu,
- const DataExtractor &debug_loc_data,
- lldb::offset_t offset);
-
- static bool PrintDWARFExpression(Stream &s, const DataExtractor &data,
- int address_size, int dwarf_ref_size,
- bool location_expression);
-
- static void PrintDWARFLocationList(Stream &s, const DWARFUnit *cu,
- const DataExtractor &debug_loc_data,
- lldb::offset_t offset);
+ lldb::addr_t func_load_addr, lldb::addr_t address,
+ ABI *abi);
bool MatchesOperand(StackFrame &frame, const Instruction::Operand &op);
+ llvm::Optional<DataExtractor>
+ GetLocationExpression(lldb::addr_t load_function_start,
+ lldb::addr_t addr) const;
+
private:
/// Pretty-prints the location expression to a stream
///
- /// \param[in] stream
+ /// \param[in] s
/// The stream to use for pretty-printing.
///
- /// \param[in] offset
- /// The offset into the data buffer of the opcodes to be printed.
- ///
- /// \param[in] length
- /// The length in bytes of the opcodes to be printed.
+ /// \param[in] data
+ /// The data extractor.
///
/// \param[in] level
/// The level of detail to use in pretty-printing.
@@ -284,19 +238,9 @@
/// \param[in] abi
/// An optional ABI plug-in that can be used to resolve register
/// names.
- void DumpLocation(Stream *s, lldb::offset_t offset, lldb::offset_t length,
+ void DumpLocation(Stream *s, const DataExtractor &data,
lldb::DescriptionLevel level, ABI *abi) const;
- bool GetLocation(lldb::addr_t base_addr, lldb::addr_t pc,
- lldb::offset_t &offset, lldb::offset_t &len);
-
- static bool AddressRangeForLocationListEntry(
- const DWARFUnit *dwarf_cu, const DataExtractor &debug_loc_data,
- lldb::offset_t *offset_ptr, lldb::addr_t &low_pc, lldb::addr_t &high_pc);
-
- bool GetOpAndEndOffsets(StackFrame &frame, lldb::offset_t &op_offset,
- lldb::offset_t &end_offset);
-
/// Module which defined this expression.
lldb::ModuleWP m_module_wp;
@@ -311,12 +255,13 @@
/// One of the defines that starts with LLDB_REGKIND_
lldb::RegisterKind m_reg_kind;
- /// A value used to slide the location list offsets so that m_c they are
- /// relative to the object that owns the location list (the function for
- /// frame base and variable location lists)
- lldb::addr_t m_loclist_slide;
+ struct LoclistAddresses {
+ lldb::addr_t cu_file_addr;
+ lldb::addr_t func_file_addr;
+ };
+ llvm::Optional<LoclistAddresses> m_loclist_addresses;
};
} // namespace lldb_private
-#endif // liblldb_DWARFExpression_h_
+#endif // LLDB_EXPRESSION_DWARFEXPRESSION_H
diff --git a/linux-x64/clang/include/lldb/Expression/DiagnosticManager.h b/linux-x64/clang/include/lldb/Expression/DiagnosticManager.h
index 7e3e2bb..c0271c9 100644
--- a/linux-x64/clang/include/lldb/Expression/DiagnosticManager.h
+++ b/linux-x64/clang/include/lldb/Expression/DiagnosticManager.h
@@ -6,12 +6,13 @@
//
//===----------------------------------------------------------------------===//
-#ifndef lldb_DiagnosticManager_h
-#define lldb_DiagnosticManager_h
+#ifndef LLDB_EXPRESSION_DIAGNOSTICMANAGER_H
+#define LLDB_EXPRESSION_DIAGNOSTICMANAGER_H
#include "lldb/lldb-defines.h"
#include "lldb/lldb-types.h"
+#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringRef.h"
#include <string>
@@ -23,7 +24,6 @@
eDiagnosticOriginUnknown = 0,
eDiagnosticOriginLLDB,
eDiagnosticOriginClang,
- eDiagnosticOriginGo,
eDiagnosticOriginSwift,
eDiagnosticOriginLLVM
};
@@ -47,7 +47,6 @@
switch (kind) {
case eDiagnosticOriginUnknown:
case eDiagnosticOriginLLDB:
- case eDiagnosticOriginGo:
case eDiagnosticOriginLLVM:
return true;
case eDiagnosticOriginClang:
@@ -79,7 +78,7 @@
bool precede_with_newline = true) {
if (precede_with_newline)
m_message.push_back('\n');
- m_message.append(message);
+ m_message += message;
}
protected:
@@ -89,7 +88,7 @@
uint32_t m_compiler_id; // Compiler-specific diagnostic ID
};
-typedef std::vector<Diagnostic *> DiagnosticList;
+typedef std::vector<std::unique_ptr<Diagnostic>> DiagnosticList;
class DiagnosticManager {
public:
@@ -98,45 +97,33 @@
m_fixed_expression.clear();
}
- // The diagnostic manager holds a list of diagnostics, which are owned by the
- // manager.
const DiagnosticList &Diagnostics() { return m_diagnostics; }
- ~DiagnosticManager() {
- for (Diagnostic *diag : m_diagnostics) {
- delete diag;
- }
- }
-
- bool HasFixIts() {
- for (Diagnostic *diag : m_diagnostics) {
- if (diag->HasFixIts())
- return true;
- }
- return false;
+ bool HasFixIts() const {
+ return llvm::any_of(m_diagnostics,
+ [](const std::unique_ptr<Diagnostic> &diag) {
+ return diag->HasFixIts();
+ });
}
void AddDiagnostic(llvm::StringRef message, DiagnosticSeverity severity,
DiagnosticOrigin origin,
uint32_t compiler_id = LLDB_INVALID_COMPILER_ID) {
- m_diagnostics.push_back(
- new Diagnostic(message, severity, origin, compiler_id));
+ m_diagnostics.emplace_back(
+ std::make_unique<Diagnostic>(message, severity, origin, compiler_id));
}
- void AddDiagnostic(Diagnostic *diagnostic) {
- m_diagnostics.push_back(diagnostic);
+ void AddDiagnostic(std::unique_ptr<Diagnostic> diagnostic) {
+ m_diagnostics.push_back(std::move(diagnostic));
}
- void CopyDiagnostics(DiagnosticManager &otherDiagnostics);
-
size_t Printf(DiagnosticSeverity severity, const char *format, ...)
__attribute__((format(printf, 3, 4)));
- size_t PutString(DiagnosticSeverity severity, llvm::StringRef str);
+ void PutString(DiagnosticSeverity severity, llvm::StringRef str);
void AppendMessageToDiagnostic(llvm::StringRef str) {
- if (!m_diagnostics.empty()) {
+ if (!m_diagnostics.empty())
m_diagnostics.back()->AppendMessage(str);
- }
}
// Returns a string containing errors in this format:
@@ -153,7 +140,6 @@
// Moves fixed_expression to the internal storage.
void SetFixedExpression(std::string fixed_expression) {
m_fixed_expression = std::move(fixed_expression);
- fixed_expression.clear();
}
protected:
@@ -162,4 +148,4 @@
};
}
-#endif /* lldb_DiagnosticManager_h */
+#endif // LLDB_EXPRESSION_DIAGNOSTICMANAGER_H
diff --git a/linux-x64/clang/include/lldb/Expression/DynamicCheckerFunctions.h b/linux-x64/clang/include/lldb/Expression/DynamicCheckerFunctions.h
new file mode 100644
index 0000000..02bce5a
--- /dev/null
+++ b/linux-x64/clang/include/lldb/Expression/DynamicCheckerFunctions.h
@@ -0,0 +1,62 @@
+//===-- DynamicCheckerFunctions.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_EXPRESSION_DYNAMICCHECKERFUNCTIONS_H
+#define LLDB_EXPRESSION_DYNAMICCHECKERFUNCTIONS_H
+
+#include "lldb/lldb-types.h"
+
+namespace lldb_private {
+
+class DiagnosticManager;
+class ExecutionContext;
+
+/// Encapsulates dynamic check functions used by expressions.
+///
+/// Each of the utility functions encapsulated in this class is responsible
+/// for validating some data that an expression is about to use. Examples
+/// are:
+///
+/// a = *b; // check that b is a valid pointer
+/// [b init]; // check that b is a valid object to send "init" to
+///
+/// The class installs each checker function into the target process and makes
+/// it available to IRDynamicChecks to use.
+class DynamicCheckerFunctions {
+public:
+ enum DynamicCheckerFunctionsKind {
+ DCF_Clang,
+ };
+
+ DynamicCheckerFunctions(DynamicCheckerFunctionsKind kind) : m_kind(kind) {}
+ virtual ~DynamicCheckerFunctions() = default;
+
+ /// Install the utility functions into a process. This binds the instance
+ /// of DynamicCheckerFunctions to that process.
+ ///
+ /// \param[in] diagnostic_manager
+ /// A diagnostic manager to report errors to.
+ ///
+ /// \param[in] exe_ctx
+ /// The execution context to install the functions into.
+ ///
+ /// \return
+ /// True on success; false on failure, or if the functions have
+ /// already been installed.
+ virtual bool Install(DiagnosticManager &diagnostic_manager,
+ ExecutionContext &exe_ctx) = 0;
+ virtual bool DoCheckersExplainStop(lldb::addr_t addr, Stream &message) = 0;
+
+ DynamicCheckerFunctionsKind GetKind() const { return m_kind; }
+
+private:
+ const DynamicCheckerFunctionsKind m_kind;
+};
+} // namespace lldb_private
+
+#endif // LLDB_EXPRESSION_DYNAMICCHECKERFUNCTIONS_H
diff --git a/linux-x64/clang/include/lldb/Expression/Expression.h b/linux-x64/clang/include/lldb/Expression/Expression.h
index 2f0183c..aaac889 100644
--- a/linux-x64/clang/include/lldb/Expression/Expression.h
+++ b/linux-x64/clang/include/lldb/Expression/Expression.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef liblldb_Expression_h_
-#define liblldb_Expression_h_
+#ifndef LLDB_EXPRESSION_EXPRESSION_H
+#define LLDB_EXPRESSION_EXPRESSION_H
#include <map>
#include <string>
@@ -32,22 +32,11 @@
/// LLVM IR from the expression.
class Expression {
public:
- /// Discriminator for LLVM-style RTTI (dyn_cast<> et al.)
- enum ExpressionKind {
- eKindFunctionCaller,
- eKindClangFunctionCaller,
- eKindUserExpression,
- eKindLLVMUserExpression,
- eKindClangUserExpression,
- eKindUtilityFunction,
- eKindClangUtilityFunction,
- };
-
enum ResultType { eResultTypeAny, eResultTypeId };
- Expression(Target &target, ExpressionKind kind);
+ Expression(Target &target);
- Expression(ExecutionContextScope &exe_scope, ExpressionKind kind);
+ Expression(ExecutionContextScope &exe_scope);
/// Destructor
virtual ~Expression() {}
@@ -62,7 +51,13 @@
/// Return the language that should be used when parsing. To use the
/// default, return eLanguageTypeUnknown.
- virtual lldb::LanguageType Language() { return lldb::eLanguageTypeUnknown; }
+ virtual lldb::LanguageType Language() const {
+ return lldb::eLanguageTypeUnknown;
+ }
+
+ /// Return the Materializer that the parser should use when registering
+ /// external values.
+ virtual Materializer *GetMaterializer() { return nullptr; }
/// Return the desired result type of the function, or eResultTypeAny if
/// indifferent.
@@ -90,12 +85,9 @@
virtual ExpressionTypeSystemHelper *GetTypeSystemHelper() { return nullptr; }
- /// LLVM-style RTTI support.
- ExpressionKind getKind() const { return m_kind; }
-
-private:
- /// LLVM-style RTTI support.
- const ExpressionKind m_kind;
+ // LLVM RTTI support
+ virtual bool isA(const void *ClassID) const = 0;
+
protected:
lldb::TargetWP m_target_wp; /// Expression's always have to have a target...
lldb::ProcessWP m_jit_process_wp; /// An expression might have a process, but
@@ -111,4 +103,4 @@
} // namespace lldb_private
-#endif // liblldb_Expression_h_
+#endif // LLDB_EXPRESSION_EXPRESSION_H
diff --git a/linux-x64/clang/include/lldb/Expression/ExpressionParser.h b/linux-x64/clang/include/lldb/Expression/ExpressionParser.h
index 59f7c15..71d2410 100644
--- a/linux-x64/clang/include/lldb/Expression/ExpressionParser.h
+++ b/linux-x64/clang/include/lldb/Expression/ExpressionParser.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef liblldb_ExpressionParser_h_
-#define liblldb_ExpressionParser_h_
+#ifndef LLDB_EXPRESSION_EXPRESSIONPARSER_H
+#define LLDB_EXPRESSION_EXPRESSIONPARSER_H
#include "lldb/Utility/CompletionRequest.h"
#include "lldb/Utility/Status.h"
@@ -29,7 +29,7 @@
///
/// Initializes class variables.
///
- /// \param[in] exe_scope,
+ /// \param[in] exe_scope
/// If non-NULL, an execution context scope that can help to
/// correctly create an expression with a valid process for
/// optional tuning Objective-C runtime support. Can be NULL.
@@ -76,17 +76,6 @@
virtual bool Complete(CompletionRequest &request, unsigned line, unsigned pos,
unsigned typed_pos) = 0;
- /// Parse a single expression and convert it to IR using Clang. Don't wrap
- /// the expression in anything at all.
- ///
- /// \param[in] diagnostic_manager
- /// The diagnostic manager in which to store the errors and warnings.
- ///
- /// \return
- /// The number of errors encountered during parsing. 0 means
- /// success.
- virtual unsigned Parse(DiagnosticManager &diagnostic_manager) = 0;
-
/// Try to use the FixIts in the diagnostic_manager to rewrite the
/// expression. If successful, the rewritten expression is stored in the
/// diagnostic_manager, get it out with GetFixedExpression.
@@ -144,4 +133,4 @@
};
}
-#endif // liblldb_ExpressionParser_h_
+#endif // LLDB_EXPRESSION_EXPRESSIONPARSER_H
diff --git a/linux-x64/clang/include/lldb/Expression/ExpressionSourceCode.h b/linux-x64/clang/include/lldb/Expression/ExpressionSourceCode.h
index d0d01b5..a3be739 100644
--- a/linux-x64/clang/include/lldb/Expression/ExpressionSourceCode.h
+++ b/linux-x64/clang/include/lldb/Expression/ExpressionSourceCode.h
@@ -6,31 +6,39 @@
//
//===----------------------------------------------------------------------===//
-#ifndef liblldb_ExpressionSourceCode_h
-#define liblldb_ExpressionSourceCode_h
+#ifndef LLDB_EXPRESSION_EXPRESSIONSOURCECODE_H
+#define LLDB_EXPRESSION_EXPRESSIONSOURCECODE_H
#include "lldb/lldb-enumerations.h"
#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
#include <string>
namespace lldb_private {
class ExpressionSourceCode {
+protected:
+ enum Wrapping : bool {
+ Wrap = true,
+ NoWrap = false,
+ };
+
public:
- bool NeedsWrapping() const { return m_wrap; }
+ bool NeedsWrapping() const { return m_wrap == Wrap; }
const char *GetName() const { return m_name.c_str(); }
protected:
- ExpressionSourceCode(const char *name, const char *prefix, const char *body,
- bool wrap)
- : m_name(name), m_prefix(prefix), m_body(body), m_wrap(wrap) {}
+ ExpressionSourceCode(llvm::StringRef name, llvm::StringRef prefix,
+ llvm::StringRef body, Wrapping wrap)
+ : m_name(name.str()), m_prefix(prefix.str()), m_body(body.str()),
+ m_wrap(wrap) {}
std::string m_name;
std::string m_prefix;
std::string m_body;
- bool m_wrap;
+ Wrapping m_wrap;
};
} // namespace lldb_private
diff --git a/linux-x64/clang/include/lldb/Expression/ExpressionTypeSystemHelper.h b/linux-x64/clang/include/lldb/Expression/ExpressionTypeSystemHelper.h
index 9c64553..1bba30a 100644
--- a/linux-x64/clang/include/lldb/Expression/ExpressionTypeSystemHelper.h
+++ b/linux-x64/clang/include/lldb/Expression/ExpressionTypeSystemHelper.h
@@ -7,8 +7,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef ExpressionTypeSystemHelper_h
-#define ExpressionTypeSystemHelper_h
+#ifndef LLDB_EXPRESSION_EXPRESSIONTYPESYSTEMHELPER_H
+#define LLDB_EXPRESSION_EXPRESSIONTYPESYSTEMHELPER_H
#include "llvm/Support/Casting.h"
@@ -44,4 +44,4 @@
} // namespace lldb_private
-#endif /* ExpressionTypeSystemHelper_h */
+#endif // LLDB_EXPRESSION_EXPRESSIONTYPESYSTEMHELPER_H
diff --git a/linux-x64/clang/include/lldb/Expression/ExpressionVariable.h b/linux-x64/clang/include/lldb/Expression/ExpressionVariable.h
index 08c9872..4259e63 100644
--- a/linux-x64/clang/include/lldb/Expression/ExpressionVariable.h
+++ b/linux-x64/clang/include/lldb/Expression/ExpressionVariable.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef liblldb_ExpressionVariable_h_
-#define liblldb_ExpressionVariable_h_
+#ifndef LLDB_EXPRESSION_EXPRESSIONVARIABLE_H
+#define LLDB_EXPRESSION_EXPRESSIONVARIABLE_H
#include <memory>
#include <vector>
@@ -32,7 +32,7 @@
virtual ~ExpressionVariable();
- size_t GetByteSize() { return m_frozen_sp->GetByteSize(); }
+ llvm::Optional<uint64_t> GetByteSize() { return m_frozen_sp->GetByteSize(); }
ConstString GetName() { return m_frozen_sp->GetName(); }
@@ -98,9 +98,7 @@
EVTypeIsReference = 1 << 6, ///< The original type of this variable is a
///reference, so materialize the value rather
///than the location
- EVUnknownType = 1 << 7, ///< This is a symbol of unknown type, and the type
- ///must be resolved after parsing is complete
- EVBareRegister = 1 << 8 ///< This variable is a direct reference to $pc or
+ EVBareRegister = 1 << 7 ///< This variable is a direct reference to $pc or
///some other entity.
};
@@ -223,11 +221,7 @@
uint32_t addr_byte_size) = 0;
/// Return a new persistent variable name with the specified prefix.
- ConstString GetNextPersistentVariableName(Target &target,
- llvm::StringRef prefix);
-
- virtual llvm::StringRef
- GetPersistentVariablePrefix(bool is_error = false) const = 0;
+ virtual ConstString GetNextPersistentVariableName(bool is_error = false) = 0;
virtual void
RemovePersistentVariable(lldb::ExpressionVariableSP variable) = 0;
@@ -239,6 +233,10 @@
void RegisterExecutionUnit(lldb::IRExecutionUnitSP &execution_unit_sp);
+protected:
+ virtual llvm::StringRef
+ GetPersistentVariablePrefix(bool is_error = false) const = 0;
+
private:
LLVMCastKind m_kind;
@@ -253,4 +251,4 @@
} // namespace lldb_private
-#endif // liblldb_ExpressionVariable_h_
+#endif // LLDB_EXPRESSION_EXPRESSIONVARIABLE_H
diff --git a/linux-x64/clang/include/lldb/Expression/FunctionCaller.h b/linux-x64/clang/include/lldb/Expression/FunctionCaller.h
index ea9d020..f35ee82 100644
--- a/linux-x64/clang/include/lldb/Expression/FunctionCaller.h
+++ b/linux-x64/clang/include/lldb/Expression/FunctionCaller.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef liblldb_FunctionCaller_h_
-#define liblldb_FunctionCaller_h_
+#ifndef LLDB_EXPRESSION_FUNCTIONCALLER_H
+#define LLDB_EXPRESSION_FUNCTIONCALLER_H
#include <list>
#include <memory>
@@ -54,22 +54,20 @@
/// Any of the methods that take arg_addr_ptr can be passed nullptr, and the
/// argument space will be managed for you.
class FunctionCaller : public Expression {
+ // LLVM RTTI support
+ static char ID;
+
public:
- /// LLVM-style RTTI support.
- static bool classof(const Expression *E) {
- return E->getKind() == eKindFunctionCaller;
- }
-
+ bool isA(const void *ClassID) const override { return ClassID == &ID; }
+ static bool classof(const Expression *obj) { return obj->isA(&ID); }
+
/// Constructor
///
/// \param[in] exe_scope
/// An execution context scope that gets us at least a target and
/// process.
///
- /// \param[in] ast_context
- /// The AST context to evaluate argument types in.
- ///
- /// \param[in] return_qualtype
+ /// \param[in] return_type
/// An opaque Clang QualType for the function result. Should be
/// defined in ast_context.
///
@@ -223,21 +221,12 @@
/// The execution context to insert the function and its arguments
/// into.
///
- /// \param[in] func_addr
- /// The address of the function in the target process.
- ///
/// \param[in] args_addr
/// The address of the argument struct.
///
/// \param[in] diagnostic_manager
/// The diagnostic manager to report errors to.
///
- /// \param[in] stop_others
- /// True if other threads should pause during execution.
- ///
- /// \param[in] unwind_on_error
- /// True if the thread plan may simply be discarded if an error occurs.
- ///
/// \return
/// A ThreadPlan shared pointer for executing the function.
lldb::ThreadPlanSP
@@ -347,4 +336,4 @@
} // namespace lldb_private
-#endif // liblldb_FunctionCaller_h_
+#endif // LLDB_EXPRESSION_FUNCTIONCALLER_H
diff --git a/linux-x64/clang/include/lldb/Expression/IRDynamicChecks.h b/linux-x64/clang/include/lldb/Expression/IRDynamicChecks.h
deleted file mode 100644
index 26f1cdb..0000000
--- a/linux-x64/clang/include/lldb/Expression/IRDynamicChecks.h
+++ /dev/null
@@ -1,146 +0,0 @@
-//===-- IRDynamicChecks.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 liblldb_IRDynamicChecks_h_
-#define liblldb_IRDynamicChecks_h_
-
-#include "lldb/lldb-types.h"
-#include "llvm/Pass.h"
-
-namespace llvm {
-class BasicBlock;
-class CallInst;
-class Constant;
-class Function;
-class Instruction;
-class Module;
-class DataLayout;
-class Value;
-}
-
-namespace lldb_private {
-
-class ClangExpressionDeclMap;
-class ExecutionContext;
-class Stream;
-
-/// \class DynamicCheckerFunctions IRDynamicChecks.h
-/// "lldb/Expression/IRDynamicChecks.h" Encapsulates dynamic check functions
-/// used by expressions.
-///
-/// Each of the utility functions encapsulated in this class is responsible
-/// for validating some data that an expression is about to use. Examples
-/// are:
-///
-/// a = *b; // check that b is a valid pointer [b init]; // check that b
-/// is a valid object to send "init" to
-///
-/// The class installs each checker function into the target process and makes
-/// it available to IRDynamicChecks to use.
-class DynamicCheckerFunctions {
-public:
- /// Constructor
- DynamicCheckerFunctions();
-
- /// Destructor
- ~DynamicCheckerFunctions();
-
- /// Install the utility functions into a process. This binds the instance
- /// of DynamicCheckerFunctions to that process.
- ///
- /// \param[in] diagnostic_manager
- /// A diagnostic manager to report errors to.
- ///
- /// \param[in] exe_ctx
- /// The execution context to install the functions into.
- ///
- /// \return
- /// True on success; false on failure, or if the functions have
- /// already been installed.
- bool Install(DiagnosticManager &diagnostic_manager,
- ExecutionContext &exe_ctx);
-
- bool DoCheckersExplainStop(lldb::addr_t addr, Stream &message);
-
- std::unique_ptr<UtilityFunction> m_valid_pointer_check;
- std::unique_ptr<UtilityFunction> m_objc_object_check;
-};
-
-/// \class IRDynamicChecks IRDynamicChecks.h
-/// "lldb/Expression/IRDynamicChecks.h" Adds dynamic checks to a user-entered
-/// expression to reduce its likelihood of crashing
-///
-/// When an IR function is executed in the target process, it may cause
-/// crashes or hangs by dereferencing NULL pointers, trying to call
-/// Objective-C methods on objects that do not respond to them, and so forth.
-///
-/// IRDynamicChecks adds calls to the functions in DynamicCheckerFunctions to
-/// appropriate locations in an expression's IR.
-class IRDynamicChecks : public llvm::ModulePass {
-public:
- /// Constructor
- ///
- /// \param[in] checker_functions
- /// The checker functions for the target process.
- ///
- /// \param[in] func_name
- /// The name of the function to prepare for execution in the target.
- ///
- /// \param[in] decl_map
- /// The mapping used to look up entities in the target process. In
- /// this case, used to find objc_msgSend
- IRDynamicChecks(DynamicCheckerFunctions &checker_functions,
- const char *func_name = "$__lldb_expr");
-
- /// Destructor
- ~IRDynamicChecks() override;
-
- /// Run this IR transformer on a single module
- ///
- /// \param[in] M
- /// The module to run on. This module is searched for the function
- /// $__lldb_expr, and that function is passed to the passes one by
- /// one.
- ///
- /// \return
- /// True on success; false otherwise
- bool runOnModule(llvm::Module &M) override;
-
- /// Interface stub
- void assignPassManager(
- llvm::PMStack &PMS,
- llvm::PassManagerType T = llvm::PMT_ModulePassManager) override;
-
- /// Returns PMT_ModulePassManager
- llvm::PassManagerType getPotentialPassManagerType() const override;
-
-private:
- /// A basic block-level pass to find all pointer dereferences and
- /// validate them before use.
-
- /// The top-level pass implementation
- ///
- /// \param[in] M
- /// The module currently being processed.
- ///
- /// \param[in] BB
- /// The basic block currently being processed.
- ///
- /// \return
- /// True on success; false otherwise
- bool FindDataLoads(llvm::Module &M, llvm::BasicBlock &BB);
-
- std::string m_func_name; ///< The name of the function to add checks to
- DynamicCheckerFunctions
- &m_checker_functions; ///< The checker functions for the process
-};
-
-} // namespace lldb_private
-
-#endif // liblldb_IRDynamicChecks_h_
diff --git a/linux-x64/clang/include/lldb/Expression/IRExecutionUnit.h b/linux-x64/clang/include/lldb/Expression/IRExecutionUnit.h
index beff44d..ad3c737 100644
--- a/linux-x64/clang/include/lldb/Expression/IRExecutionUnit.h
+++ b/linux-x64/clang/include/lldb/Expression/IRExecutionUnit.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef liblldb_IRExecutionUnit_h_
-#define liblldb_IRExecutionUnit_h_
+#ifndef LLDB_EXPRESSION_IREXECUTIONUNIT_H
+#define LLDB_EXPRESSION_IREXECUTIONUNIT_H
#include <atomic>
#include <memory>
@@ -71,7 +71,7 @@
llvm::Module *GetModule() { return m_module; }
llvm::Function *GetFunction() {
- return ((m_module != nullptr) ? m_module->getFunction(m_name.AsCString())
+ return ((m_module != nullptr) ? m_module->getFunction(m_name.GetStringRef())
: nullptr);
}
@@ -173,6 +173,8 @@
/// The address in the target process.
lldb::addr_t GetRemoteAddressForLocal(lldb::addr_t local_address);
+ typedef std::pair<lldb::addr_t, uintptr_t> AddrRange;
+
/// Look up the object in m_address_map that contains a given address, find
/// where it was copied to, and return its address range in the target
/// process
@@ -182,12 +184,11 @@
///
/// \return
/// The range of the containing object in the target process.
- typedef std::pair<lldb::addr_t, uintptr_t> AddrRange;
AddrRange GetRemoteRangeForLocal(lldb::addr_t local_address);
/// Commit all allocations to the process and record where they were stored.
///
- /// \param[in] process
+ /// \param[in] process_sp
/// The process to allocate memory in.
///
/// \return
@@ -204,7 +205,7 @@
/// Write the contents of all allocations to the process.
///
- /// \param[in] local_address
+ /// \param[in] process_sp
/// The process containing the allocations.
///
/// \return
@@ -298,16 +299,18 @@
return false;
}
+ // Ignore any EHFrame registration.
void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr,
size_t Size) override {}
+ void deregisterEHFrames() override {}
uint64_t getSymbolAddress(const std::string &Name) override;
-
+
// Find the address of the symbol Name. If Name is a missing weak symbol
// then missing_weak will be true.
- uint64_t GetSymbolAddressAndPresence(const std::string &Name,
+ uint64_t GetSymbolAddressAndPresence(const std::string &Name,
bool &missing_weak);
-
+
llvm::JITSymbol findSymbol(const std::string &Name) override;
void *getPointerToNamedFunction(const std::string &Name,
@@ -326,18 +329,16 @@
static const unsigned eSectionIDInvalid = (unsigned)-1;
- /// \class AllocationRecord IRExecutionUnit.h
- /// "lldb/Expression/IRExecutionUnit.h" Encapsulates a single allocation
- /// request made by the JIT.
- ///
- /// Allocations made by the JIT are first queued up and then applied in bulk
- /// to the underlying process.
enum class AllocationKind { Stub, Code, Data, Global, Bytes };
static lldb::SectionType
GetSectionTypeFromSectionName(const llvm::StringRef &name,
AllocationKind alloc_kind);
+ /// Encapsulates a single allocation request made by the JIT.
+ ///
+ /// Allocations made by the JIT are first queued up and then applied in bulk
+ /// to the underlying process.
struct AllocationRecord {
std::string m_name;
lldb::addr_t m_process_address;
@@ -405,4 +406,4 @@
} // namespace lldb_private
-#endif // liblldb_IRExecutionUnit_h_
+#endif // LLDB_EXPRESSION_IREXECUTIONUNIT_H
diff --git a/linux-x64/clang/include/lldb/Expression/IRInterpreter.h b/linux-x64/clang/include/lldb/Expression/IRInterpreter.h
index 6148093..98ece96 100644
--- a/linux-x64/clang/include/lldb/Expression/IRInterpreter.h
+++ b/linux-x64/clang/include/lldb/Expression/IRInterpreter.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef liblldb_IRInterpreter_h_
-#define liblldb_IRInterpreter_h_
+#ifndef LLDB_EXPRESSION_IRINTERPRETER_H
+#define LLDB_EXPRESSION_IRINTERPRETER_H
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Stream.h"
@@ -22,7 +22,6 @@
namespace lldb_private {
-class ClangExpressionDeclMap;
class IRMemoryMap;
}
diff --git a/linux-x64/clang/include/lldb/Expression/IRMemoryMap.h b/linux-x64/clang/include/lldb/Expression/IRMemoryMap.h
index d6a17a9..abec544 100644
--- a/linux-x64/clang/include/lldb/Expression/IRMemoryMap.h
+++ b/linux-x64/clang/include/lldb/Expression/IRMemoryMap.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef lldb_IRMemoryMap_h_
-#define lldb_IRMemoryMap_h_
+#ifndef LLDB_EXPRESSION_IRMEMORYMAP_H
+#define LLDB_EXPRESSION_IRMEMORYMAP_H
#include "lldb/Utility/DataBufferHeap.h"
#include "lldb/Utility/UserID.h"
@@ -107,7 +107,8 @@
size_t size, uint32_t permissions, uint8_t alignment,
AllocationPolicy m_policy);
- DISALLOW_COPY_AND_ASSIGN(Allocation);
+ Allocation(const Allocation &) = delete;
+ const Allocation &operator=(const Allocation &) = delete;
};
static_assert(sizeof(Allocation) <=
diff --git a/linux-x64/clang/include/lldb/Expression/LLVMUserExpression.h b/linux-x64/clang/include/lldb/Expression/LLVMUserExpression.h
index c2af723..244a28a 100644
--- a/linux-x64/clang/include/lldb/Expression/LLVMUserExpression.h
+++ b/linux-x64/clang/include/lldb/Expression/LLVMUserExpression.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef liblldb_LLVMUserExpression_h
-#define liblldb_LLVMUserExpression_h
+#ifndef LLDB_EXPRESSION_LLVMUSEREXPRESSION_H
+#define LLDB_EXPRESSION_LLVMUSEREXPRESSION_H
#include <map>
#include <string>
@@ -30,11 +30,14 @@
/// implementations of LLVMUserExpression - which will be vended through the
/// appropriate TypeSystem.
class LLVMUserExpression : public UserExpression {
+ // LLVM RTTI support
+ static char ID;
+
public:
- /// LLVM-style RTTI support.
- static bool classof(const Expression *E) {
- return E->getKind() == eKindLLVMUserExpression;
+ bool isA(const void *ClassID) const override {
+ return ClassID == &ID || UserExpression::isA(ClassID);
}
+ static bool classof(const Expression *obj) { return obj->isA(&ID); }
// The IRPasses struct is filled in by a runtime after an expression is
// compiled and can be used to to run fixups/analysis passes as required.
@@ -51,8 +54,7 @@
LLVMUserExpression(ExecutionContextScope &exe_scope, llvm::StringRef expr,
llvm::StringRef prefix, lldb::LanguageType language,
ResultType desired_type,
- const EvaluateExpressionOptions &options,
- ExpressionKind kind);
+ const EvaluateExpressionOptions &options);
~LLVMUserExpression() override;
bool FinalizeJITExecution(
@@ -63,12 +65,12 @@
bool CanInterpret() override { return m_can_interpret; }
+ Materializer *GetMaterializer() override { return m_materializer_up.get(); }
+
/// Return the string that the parser should parse. Must be a full
/// translation unit.
const char *Text() override { return m_transformed_text.c_str(); }
- lldb::ModuleSP GetJITModule() override;
-
protected:
lldb::ExpressionResults
DoExecute(DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx,
@@ -103,22 +105,6 @@
/// when running the
/// expression.
lldb::ModuleWP m_jit_module_wp;
- bool m_enforce_valid_object; ///< True if the expression parser should enforce
- ///the presence of a valid class pointer
- /// in order to generate the expression as a method.
- bool m_in_cplusplus_method; ///< True if the expression is compiled as a C++
- ///member function (true if it was parsed
- /// when exe_ctx was in a C++ method).
- bool m_in_objectivec_method; ///< True if the expression is compiled as an
- ///Objective-C method (true if it was parsed
- /// when exe_ctx was in an Objective-C method).
- bool m_in_static_method; ///< True if the expression is compiled as a static
- ///(or class) method (currently true if it
- /// was parsed when exe_ctx was in an Objective-C class method).
- bool m_needs_object_ptr; ///< True if "this" or "self" must be looked up and
- ///passed in. False if the expression
- /// doesn't really use them and they can be NULL.
- bool m_const_object; ///< True if "this" is const.
Target *m_target; ///< The target for storing persistent data like types and
///variables.
diff --git a/linux-x64/clang/include/lldb/Expression/Materializer.h b/linux-x64/clang/include/lldb/Expression/Materializer.h
index 603b4e0..754e67c 100644
--- a/linux-x64/clang/include/lldb/Expression/Materializer.h
+++ b/linux-x64/clang/include/lldb/Expression/Materializer.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef liblldb_Materializer_h
-#define liblldb_Materializer_h
+#ifndef LLDB_EXPRESSION_MATERIALIZER_H
+#define LLDB_EXPRESSION_MATERIALIZER_H
#include <memory>
#include <vector>
@@ -22,14 +22,12 @@
class Materializer {
public:
- Materializer();
+ Materializer() = default;
~Materializer();
class Dematerializer {
public:
- Dematerializer()
- : m_materializer(nullptr), m_map(nullptr),
- m_process_address(LLDB_INVALID_ADDRESS) {}
+ Dematerializer() = default;
~Dematerializer() { Wipe(); }
@@ -56,11 +54,11 @@
}
}
- Materializer *m_materializer;
+ Materializer *m_materializer = nullptr;
lldb::ThreadWP m_thread_wp;
StackID m_stack_id;
- IRMemoryMap *m_map;
- lldb::addr_t m_process_address;
+ IRMemoryMap *m_map = nullptr;
+ lldb::addr_t m_process_address = LLDB_INVALID_ADDRESS;
};
typedef std::shared_ptr<Dematerializer> DematerializerSP;
@@ -115,8 +113,6 @@
void SetOffset(uint32_t offset) { m_offset = offset; }
protected:
- void SetSizeAndAlignmentFromType(CompilerType &type);
-
uint32_t m_alignment;
uint32_t m_size;
uint32_t m_offset;
@@ -130,10 +126,10 @@
DematerializerWP m_dematerializer_wp;
EntityVector m_entities;
- uint32_t m_current_offset;
- uint32_t m_struct_alignment;
+ uint32_t m_current_offset = 0;
+ uint32_t m_struct_alignment = 8;
};
} // namespace lldb_private
-#endif // liblldb_Materializer_h
+#endif // LLDB_EXPRESSION_MATERIALIZER_H
diff --git a/linux-x64/clang/include/lldb/Expression/REPL.h b/linux-x64/clang/include/lldb/Expression/REPL.h
index 850d2f6..a0df53e 100644
--- a/linux-x64/clang/include/lldb/Expression/REPL.h
+++ b/linux-x64/clang/include/lldb/Expression/REPL.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef lldb_REPL_h
-#define lldb_REPL_h
+#ifndef LLDB_EXPRESSION_REPL_H
+#define LLDB_EXPRESSION_REPL_H
#include <string>
@@ -32,7 +32,7 @@
/// Get a REPL with an existing target (or, failing that, a debugger to use),
/// and (optional) extra arguments for the compiler.
///
- /// \param[out] error
+ /// \param[out] Status
/// If this language is supported but the REPL couldn't be created, this
/// error is populated with the reason.
///
@@ -103,10 +103,8 @@
void IOHandlerInputComplete(IOHandler &io_handler,
std::string &line) override;
- int IOHandlerComplete(IOHandler &io_handler, const char *current_line,
- const char *cursor, const char *last_char,
- int skip_first_n_matches, int max_matches,
- StringList &matches, StringList &descriptions) override;
+ void IOHandlerComplete(IOHandler &io_handler,
+ CompletionRequest &request) override;
protected:
static int CalculateActualIndentation(const StringList &lines);
@@ -132,8 +130,8 @@
lldb::ValueObjectSP &valobj_sp,
ExpressionVariable *var = nullptr) = 0;
- virtual int CompleteCode(const std::string ¤t_code,
- StringList &matches) = 0;
+ virtual void CompleteCode(const std::string ¤t_code,
+ CompletionRequest &request) = 0;
OptionGroupFormat m_format_options = OptionGroupFormat(lldb::eFormatDefault);
OptionGroupValueObjectDisplay m_varobj_options;
@@ -160,4 +158,4 @@
} // namespace lldb_private
-#endif // lldb_REPL_h
+#endif // LLDB_EXPRESSION_REPL_H
diff --git a/linux-x64/clang/include/lldb/Expression/UserExpression.h b/linux-x64/clang/include/lldb/Expression/UserExpression.h
index b1d52f8..8236c41 100644
--- a/linux-x64/clang/include/lldb/Expression/UserExpression.h
+++ b/linux-x64/clang/include/lldb/Expression/UserExpression.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef liblldb_UserExpression_h_
-#define liblldb_UserExpression_h_
+#ifndef LLDB_EXPRESSION_USEREXPRESSION_H
+#define LLDB_EXPRESSION_USEREXPRESSION_H
#include <memory>
#include <string>
@@ -33,12 +33,13 @@
/// implementations of UserExpression - which will be vended through the
/// appropriate TypeSystem.
class UserExpression : public Expression {
+ /// LLVM RTTI support.
+ static char ID;
+
public:
- /// LLVM-style RTTI support.
- static bool classof(const Expression *E) {
- return E->getKind() == eKindUserExpression;
- }
-
+ bool isA(const void *ClassID) const override { return ClassID == &ID; }
+ static bool classof(const Expression *obj) { return obj->isA(&ID); }
+
enum { kDefaultTimeout = 500000u };
/// Constructor
@@ -46,10 +47,6 @@
/// \param[in] expr
/// The expression to parse.
///
- /// \param[in] expr_prefix
- /// If non-nullptr, a C string containing translation-unit level
- /// definitions to be included when the expression is parsed.
- ///
/// \param[in] language
/// If not eLanguageTypeUnknown, a language to use when parsing
/// the expression. Currently restricted to those languages
@@ -61,8 +58,7 @@
UserExpression(ExecutionContextScope &exe_scope, llvm::StringRef expr,
llvm::StringRef prefix, lldb::LanguageType language,
ResultType desired_type,
- const EvaluateExpressionOptions &options,
- ExpressionKind kind);
+ const EvaluateExpressionOptions &options);
/// Destructor
~UserExpression() override;
@@ -166,8 +162,14 @@
/// A pointer to direct at the persistent variable in which the
/// expression's result is stored.
///
- /// \param[in] function_stack_pointer
- /// A pointer to the base of the function's stack frame. This
+ /// \param[in] function_stack_bottom
+ /// A pointer to the bottom of the function's stack frame. This
+ /// is used to determine whether the expression result resides in
+ /// memory that will still be valid, or whether it needs to be
+ /// treated as homeless for the purpose of future expressions.
+ ///
+ /// \param[in] function_stack_top
+ /// A pointer to the top of the function's stack frame. This
/// is used to determine whether the expression result resides in
/// memory that will still be valid, or whether it needs to be
/// treated as homeless for the purpose of future expressions.
@@ -192,7 +194,7 @@
/// Return the language that should be used when parsing. To use the
/// default, return eLanguageTypeUnknown.
- lldb::LanguageType Language() override { return m_language; }
+ lldb::LanguageType Language() const override { return m_language; }
/// Return the desired result type of the function, or eResultTypeAny if
/// indifferent.
@@ -211,8 +213,6 @@
return lldb::ExpressionVariableSP();
}
- virtual lldb::ModuleSP GetJITModule() { return lldb::ModuleSP(); }
-
/// Evaluate one expression in the scratch context of the target passed in
/// the exe_ctx and return its result.
///
@@ -242,9 +242,6 @@
/// If non-nullptr, the fixed expression is copied into the provided
/// string.
///
- /// \param[out] jit_module_sp_ptr
- /// If non-nullptr, used to persist the generated IR module.
- ///
/// \param[in] ctx_obj
/// If specified, then the expression will be evaluated in the context of
/// this object. It means that the context object's address will be
@@ -263,7 +260,6 @@
llvm::StringRef expr_cstr, llvm::StringRef expr_prefix,
lldb::ValueObjectSP &result_valobj_sp, Status &error,
std::string *fixed_expression = nullptr,
- lldb::ModuleSP *jit_module_sp_ptr = nullptr,
ValueObject *ctx_obj = nullptr);
static const Status::ValueType kNoResult =
@@ -312,4 +308,4 @@
} // namespace lldb_private
-#endif // liblldb_UserExpression_h_
+#endif // LLDB_EXPRESSION_USEREXPRESSION_H
diff --git a/linux-x64/clang/include/lldb/Expression/UtilityFunction.h b/linux-x64/clang/include/lldb/Expression/UtilityFunction.h
index 26da081..99fb321 100644
--- a/linux-x64/clang/include/lldb/Expression/UtilityFunction.h
+++ b/linux-x64/clang/include/lldb/Expression/UtilityFunction.h
@@ -7,8 +7,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef liblldb_UtilityFunction_h_
-#define liblldb_UtilityFunction_h_
+#ifndef LLDB_EXPRESSION_UTILITYFUNCTION_H
+#define LLDB_EXPRESSION_UTILITYFUNCTION_H
#include <memory>
#include <string>
@@ -28,12 +28,13 @@
/// self-contained function meant to be used from other code. Utility
/// functions can perform error-checking for ClangUserExpressions,
class UtilityFunction : public Expression {
+ // LLVM RTTI support
+ static char ID;
+
public:
- /// LLVM-style RTTI support.
- static bool classof(const Expression *E) {
- return E->getKind() == eKindUtilityFunction;
- }
-
+ bool isA(const void *ClassID) const override { return ClassID == &ID; }
+ static bool classof(const Expression *obj) { return obj->isA(&ID); }
+
/// Constructor
///
/// \param[in] text
@@ -41,8 +42,8 @@
///
/// \param[in] name
/// The name of the function, as used in the text.
- UtilityFunction(ExecutionContextScope &exe_scope, const char *text,
- const char *name, ExpressionKind kind);
+ UtilityFunction(ExecutionContextScope &exe_scope, std::string text,
+ std::string name);
~UtilityFunction() override;
@@ -59,16 +60,16 @@
virtual bool Install(DiagnosticManager &diagnostic_manager,
ExecutionContext &exe_ctx) = 0;
- /// Check whether the given PC is inside the function
+ /// Check whether the given address is inside the function
///
/// Especially useful if the function dereferences nullptr to indicate a
/// failed assert.
///
- /// \param[in] pc
- /// The program counter to check.
+ /// \param[in] address
+ /// The address to check.
///
/// \return
- /// True if the program counter falls within the function's bounds;
+ /// True if the address falls within the function's bounds;
/// false if not (or the function is not JIT compiled)
bool ContainsAddress(lldb::addr_t address) {
// nothing is both >= LLDB_INVALID_ADDRESS and < LLDB_INVALID_ADDRESS, so
@@ -109,12 +110,13 @@
protected:
std::shared_ptr<IRExecutionUnit> m_execution_unit_sp;
lldb::ModuleWP m_jit_module_wp;
- std::string m_function_text; ///< The text of the function. Must be a
- ///well-formed translation unit.
- std::string m_function_name; ///< The name of the function.
+ /// The text of the function. Must be a well-formed translation unit.
+ std::string m_function_text;
+ /// The name of the function.
+ std::string m_function_name;
std::unique_ptr<FunctionCaller> m_caller_up;
};
} // namespace lldb_private
-#endif // liblldb_UtilityFunction_h_
+#endif // LLDB_EXPRESSION_UTILITYFUNCTION_H