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 &current_code,
-                           StringList &matches) = 0;
+  virtual void CompleteCode(const std::string &current_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