Update prebuilt Clang to r365631c1 from Android.
The version we had was segfaulting.
Bug: 132420445
Change-Id: Icb45a6fe0b4e2166f7895e669df1157cec9fb4e0
diff --git a/linux-x64/clang/include/lldb/Expression/UtilityFunction.h b/linux-x64/clang/include/lldb/Expression/UtilityFunction.h
new file mode 100644
index 0000000..26da081
--- /dev/null
+++ b/linux-x64/clang/include/lldb/Expression/UtilityFunction.h
@@ -0,0 +1,120 @@
+//===-- UtilityFunction.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_UtilityFunction_h_
+#define liblldb_UtilityFunction_h_
+
+#include <memory>
+#include <string>
+
+#include "lldb/Expression/Expression.h"
+#include "lldb/lldb-forward.h"
+#include "lldb/lldb-private.h"
+
+namespace lldb_private {
+
+/// \class UtilityFunction UtilityFunction.h
+/// "lldb/Expression/UtilityFunction.h" Encapsulates a bit of source code that
+/// provides a function that is callable
+///
+/// LLDB uses expressions for various purposes, notably to call functions
+/// and as a backend for the expr command. UtilityFunction encapsulates a
+/// self-contained function meant to be used from other code. Utility
+/// functions can perform error-checking for ClangUserExpressions,
+class UtilityFunction : public Expression {
+public:
+ /// LLVM-style RTTI support.
+ static bool classof(const Expression *E) {
+ return E->getKind() == eKindUtilityFunction;
+ }
+
+ /// Constructor
+ ///
+ /// \param[in] text
+ /// The text of the function. Must be a full translation unit.
+ ///
+ /// \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() override;
+
+ /// Install the utility function into a process
+ ///
+ /// \param[in] diagnostic_manager
+ /// A diagnostic manager to print parse errors and warnings to.
+ ///
+ /// \param[in] exe_ctx
+ /// The execution context to install the utility function to.
+ ///
+ /// \return
+ /// True on success (no errors); false otherwise.
+ virtual bool Install(DiagnosticManager &diagnostic_manager,
+ ExecutionContext &exe_ctx) = 0;
+
+ /// Check whether the given PC is inside the function
+ ///
+ /// Especially useful if the function dereferences nullptr to indicate a
+ /// failed assert.
+ ///
+ /// \param[in] pc
+ /// The program counter to check.
+ ///
+ /// \return
+ /// True if the program counter 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
+ // this always returns false if the function is not JIT compiled yet
+ return (address >= m_jit_start_addr && address < m_jit_end_addr);
+ }
+
+ /// Return the string that the parser should parse. Must be a full
+ /// translation unit.
+ const char *Text() override { return m_function_text.c_str(); }
+
+ /// Return the function name that should be used for executing the
+ /// expression. Text() should contain the definition of this function.
+ const char *FunctionName() override { return m_function_name.c_str(); }
+
+ /// Return the object that the parser should use when registering local
+ /// variables. May be nullptr if the Expression doesn't care.
+ ExpressionVariableList *LocalVariables() { return nullptr; }
+
+ /// Return true if validation code should be inserted into the expression.
+ bool NeedsValidation() override { return false; }
+
+ /// Return true if external variables in the expression should be resolved.
+ bool NeedsVariableResolution() override { return false; }
+
+ // This makes the function caller function. Pass in the ThreadSP if you have
+ // one available, compilation can end up calling code (e.g. to look up
+ // indirect functions) and we don't want this to wander onto another thread.
+ FunctionCaller *MakeFunctionCaller(const CompilerType &return_type,
+ const ValueList &arg_value_list,
+ lldb::ThreadSP compilation_thread,
+ Status &error);
+
+ // This one retrieves the function caller that is already made. If you
+ // haven't made it yet, this returns nullptr
+ FunctionCaller *GetFunctionCaller() { return m_caller_up.get(); }
+
+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.
+ std::unique_ptr<FunctionCaller> m_caller_up;
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_UtilityFunction_h_