[lldb] Allow plugins to extend DWARF expression parsing for vendor extensions

[pfaffe]

Summary

Parsing DWARF expressions currently does not support DW_OPs that are vendor
extensions. With this change expression parsing calls into SymbolFileDWARF for
unknown opcodes, which is the semantically "closest" plugin that we have right
now. Plugins can then extend SymbolFileDWARF to add support for vendor
extensions.

[DavidSpickett]

I'm missing some context here I think.

I assume the use case is that, for example, we don't want to be adding a bunch of WASM specific DWARF operations to the generic operations. If those can live in a WASM (the "vendor") plugin then we know where to look and they can use any vendor specific knowledge to do their job.

Along the right lines? I think I saw some talk about this on a previous diff but don't remember now.

lldb/include/lldb/Target/Platform.h

959 ↗

(On Diff #472588)

stray change

lldb/source/Expression/DWARFExpressionList.cpp

93

I'm not sure that m_dwarf_cu is always non null. It might be in practice but for example one use ends up in UpdateValueTypeFromLocationDescription which checks that it is not null before use.

Maybe it is reasonable to assume it is never null (and if it is and you have the time, a preparatory patch to make it a ref would be great).

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

342

Seems like clang-format missed a bit here.

lldb/unittests/Expression/DWARFExpressionTest.cpp

571

Is there not 3 more arguments to read off here? The 0x00 0x00 0x00 from above.

751–765

Can you dedeupe this section of both tests? Appears to be the same.

[DavidSpickett]

lldb/unittests/Expression/DWARFExpressionTest.cpp

719

I know it's just a test but is there an EM_WASM you could use?

Maybe lldb doesn't understand that name yet so it makes no difference anyway.

[pfaffe]

Yes, you got the context right! Although technically speaking this change isn't limited to wasm, plugins can implement any vendor extension on top of this change.

lldb/source/Expression/DWARFExpressionList.cpp

93

I think it's worth checking in general. Before https://reviews.llvm.org/D125509, the DWARFExpression used to be assiciated with its dwarf_cu. I was considering bringing that back, what do you think?

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

342

Curious, I would have assumed the linter at the very least would have caught that.

lldb/unittests/Expression/DWARFExpressionTest.cpp

571

No, the second argument to this opcode is of type uint32_t, the zeros are the last three bytes of that. Should I maybe use a simpler/fake opcode? Might be dangerous if that fake opcode ever got occupied/implemented.

[DavidSpickett]

lldb/source/Expression/DWARFExpressionList.cpp

93

I think you should ask the author of that change :)

On the surface that change makes sense but I'm no expert. If that's the case then you'll just want to sprinkle some if not nullptr around wherever you use it.

(nullptrs are fine if there is a reason to use the null state)

lldb/unittests/Expression/DWARFExpressionTest.cpp

571

It was the comment misleading me:

// Called with "arguments" 0x03, 0x04, 0x00, 0x00, 0x00

So I'm thinking there is an operation that is called with arguments 3, 4, 0, 0, 0.

Just reword the comment and it'll be fine.

[pfaffe]

Address comments.

[pfaffe]

lldb/unittests/Expression/DWARFExpressionTest.cpp

719

There's no EM_WASM, in fact wasm has it's own non-ELF container. I picked x86 ELF because ELFYAML has the DWARF section which is convenient, WASMYAML sadly does not.

[pfaffe]

Stray change.

[DavidSpickett]

What was the decision on m_dwarf_cu possibly being nullptr? We at least want asserts in paths where we assume it'll not be null.

Beyond that this seems fine but I'm not really into DWARF, @labath any comments?

Seems like quite a cheap fallback to add, and my assumption is that we don't find many unknown opcodes in general use.

[pfaffe]

I threaded dwarf_cu down to where it's really used and added the necessary check, so if it is nullptr, the fallback will be skipped.

[labath]

Looks ok, module some inline comments.

lldb/source/Expression/DWARFExpression.cpp

2573

For other methods, we just have the dwo class override the method and call the main file instead.

lldb/source/Expression/DWARFExpressionList.cpp

93

DWARF expressions are used in contexts where there is no DWARF unit to speak of. Our use of DWARF expressions in PDB (the motivation behind that patch) is questionable at best, but DWARF expressions are also used in eh_frame for instance, which I think would be a good reason to keep DWARFExpression DWARFUnit-free. OTOH, some of the DWARF operations cannot be evaluated without a DWARFUnit, so.... I don't know...

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h

45

and then you don't need to make this public.

[pfaffe]

Override new functions in DWOs.

[labath]

lldb/source/Expression/DWARFExpression.cpp

41–44

I think these are not needed anymore.

lldb/include/lldb/Expression/DWARFExpression.h

public:
   ///     data is missing, \a error will be set to \b true.
   ///
   /// \return
   ///     LLDB_INVALID_ADDRESS if the location doesn't contain a
   ///     DW_OP_addr for \a op_addr_idx, otherwise a valid file address
   lldb::addr_t GetLocation_DW_OP_addr(const DWARFUnit *dwarf_cu,
                                       uint32_t op_addr_idx, bool &error) const;
 
-  bool Update_DW_OP_addr(lldb::addr_t file_addr);
+  bool Update_DW_OP_addr(const DWARFUnit *dwarf_cu, lldb::addr_t file_addr);
 
   void UpdateValue(uint64_t const_value, lldb::offset_t const_value_byte_size,
                    uint8_t addr_byte_size);
 
-  bool ContainsThreadLocalStorage() const;
+  bool ContainsThreadLocalStorage(const DWARFUnit *dwarf_cu) const;
 
   bool LinkThreadLocalStorage(
+      const DWARFUnit *dwarf_cu,
       std::function<lldb::addr_t(lldb::addr_t file_addr)> const
           &link_address_callback);
 
   /// Return the call-frame-info style register kind
   lldb::RegisterKind GetRegisterKind() const;
 
   /// Set the call-frame-info style register kind
   ///

lldb/source/Expression/DWARFExpression.cpp

 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/StackID.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 
 #include "Plugins/SymbolFile/DWARF/DWARFUnit.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::dwarf;
 
 // DWARFExpression constructor
 DWARFExpression::DWARFExpression() : m_data() {}
 
 DWARFExpression::DWARFExpression(const DataExtractor &data) : m_data(data) {}
 
static bool ReadRegisterValueAsScalar(RegisterContext *reg_ctx,
   }
   return false;
 }
 
 /// Return the length in bytes of the set of operands for \p op. No guarantees
 /// are made on the state of \p data after this call.
 static offset_t GetOpcodeDataSize(const DataExtractor &data,
                                   const lldb::offset_t data_offset,
-                                  const uint8_t op) {
+                                  const uint8_t op, const DWARFUnit *dwarf_cu) {
   lldb::offset_t offset = data_offset;
   switch (op) {
   case DW_OP_addr:
   case DW_OP_call_ref: // 0x9a 1 address sized offset of DIE (DWARF3)
     return data.GetAddressByteSize();
 
   // Opcodes with no arguments
   case DW_OP_deref:                // 0x06
static offset_t GetOpcodeDataSize(const DataExtractor &data,
   case DW_OP_GNU_entry_value:
   case DW_OP_entry_value: // 0xa3 ULEB128 size + variable-length block
   {
     uint64_t subexpr_len = data.GetULEB128(&offset);
     return (offset - data_offset) + subexpr_len;
   }
 
   default:
-    break;
-  }
+    if (!dwarf_cu) {
       return LLDB_INVALID_OFFSET;
     }
+    return dwarf_cu->GetSymbolFileDWARF().GetVendorDWARFOpcodeSize(
+        data, data_offset, op);
+  }
+}
 
 lldb::addr_t DWARFExpression::GetLocation_DW_OP_addr(const DWARFUnit *dwarf_cu,
                                                      uint32_t op_addr_idx,
                                                      bool &error) const {
   error = false;
   lldb::offset_t offset = 0;
   uint32_t curr_op_addr_idx = 0;
   while (m_data.ValidOffset(offset)) {
if (op == DW_OP_addr) {
           error = true;
           break;
         }
 
         return dwarf_cu->ReadAddressFromDebugAddrSection(index);
       }
       ++curr_op_addr_idx;
     } else {
-      const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
+      const offset_t op_arg_size =
+          GetOpcodeDataSize(m_data, offset, op, dwarf_cu);
       if (op_arg_size == LLDB_INVALID_OFFSET) {
         error = true;
         break;
       }
       offset += op_arg_size;
     }
   }
   return LLDB_INVALID_ADDRESS;
 }
 
-bool DWARFExpression::Update_DW_OP_addr(lldb::addr_t file_addr) {
+bool DWARFExpression::Update_DW_OP_addr(const DWARFUnit *dwarf_cu,
+                                        lldb::addr_t file_addr) {
   lldb::offset_t offset = 0;
   while (m_data.ValidOffset(offset)) {
     const uint8_t op = m_data.GetU8(&offset);
 
     if (op == DW_OP_addr) {
       const uint32_t addr_byte_size = m_data.GetAddressByteSize();
       // We have to make a copy of the data as we don't know if this data is
       // from a read only memory mapped buffer, so we duplicate all of the data
if (op == DW_OP_addr) {
       if (encoder.PutAddress(offset, file_addr) == UINT32_MAX)
         return false;
 
       // All went well, so now we can reset the data using a shared pointer to
       // the heap data so "m_data" will now correctly manage the heap data.
       m_data.SetData(encoder.GetDataBuffer());
       return true;
     } else {
-      const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
+      const offset_t op_arg_size =
+          GetOpcodeDataSize(m_data, offset, op, dwarf_cu);
       if (op_arg_size == LLDB_INVALID_OFFSET)
         break;
       offset += op_arg_size;
     }
   }
   return false;
 }
 
-bool DWARFExpression::ContainsThreadLocalStorage() const {
+bool DWARFExpression::ContainsThreadLocalStorage(
+    const DWARFUnit *dwarf_cu) const {
   lldb::offset_t offset = 0;
   while (m_data.ValidOffset(offset)) {
     const uint8_t op = m_data.GetU8(&offset);
 
     if (op == DW_OP_form_tls_address || op == DW_OP_GNU_push_tls_address)
       return true;
-    const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
+    const offset_t op_arg_size =
+        GetOpcodeDataSize(m_data, offset, op, dwarf_cu);
     if (op_arg_size == LLDB_INVALID_OFFSET)
       return false;
     offset += op_arg_size;
   }
   return false;
 }
 bool DWARFExpression::LinkThreadLocalStorage(
+    const DWARFUnit *dwarf_cu,
     std::function<lldb::addr_t(lldb::addr_t file_addr)> const
         &link_address_callback) {
   const uint32_t addr_byte_size = m_data.GetAddressByteSize();
   // We have to make a copy of the data as we don't know if this data is from a
   // read only memory mapped buffer, so we duplicate all of the data first,
   // then modify it, and if all goes well, we then replace the data for this
   // expression.
   // Make en encoder that contains a copy of the location expression data so we
while (m_data.ValidOffset(offset)) {
     default:
       const_offset = 0;
       const_value = 0;
       const_byte_size = 0;
       break;
     }
 
     if (!decoded_data) {
-      const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
+      const offset_t op_arg_size =
+          GetOpcodeDataSize(m_data, offset, op, dwarf_cu);
       if (op_arg_size == LLDB_INVALID_OFFSET)
         return false;
       else
         offset += op_arg_size;
     }
   }
 
   m_data.SetData(encoder.GetDataBuffer());
case DW_OP_entry_value: {
         LLDB_ERRORF(error_ptr, "Could not evaluate %s.",
                     DW_OP_value_to_name(op));
         return false;
       }
       break;
     }
 
     default:
+      if (dwarf_cu) {
+        if (dwarf_cu->GetSymbolFileDWARF().ParseVendorDWARFOpcode(
+                op, opcodes, offset, stack)) {
+          break;
+        }
+      }
       if (error_ptr)
         error_ptr->SetErrorStringWithFormatv(
             "Unhandled opcode {0} in DWARFExpression", LocationAtom(op));
       return false;
     }
   }
 
   if (stack.empty()) {

lldb/source/Expression/DWARFExpressionList.cpp

 bool DWARFExpressionList::ContainsThreadLocalStorage() const {
   // We are assuming for now that any thread local variable will not have a
   // location list. This has been true for all thread local variables we have
   // seen so far produced by any compiler.
   if (!IsAlwaysValidSingleExpr())
     return false;
 
   const DWARFExpression &expr = m_exprs.GetEntryRef(0).data;
-  return expr.ContainsThreadLocalStorage();
+  return expr.ContainsThreadLocalStorage(m_dwarf_cu);
 }
 
 bool DWARFExpressionList::LinkThreadLocalStorage(
     lldb::ModuleSP new_module_sp,
     std::function<lldb::addr_t(lldb::addr_t file_addr)> const
         &link_address_callback) {
   // We are assuming for now that any thread local variable will not have a
   // location list. This has been true for all thread local variables we have
   // seen so far produced by any compiler.
   if (!IsAlwaysValidSingleExpr())
     return false;
 
   DWARFExpression &expr = m_exprs.GetEntryRef(0).data;
   // If we linked the TLS address correctly, update the module so that when the
   // expression is evaluated it can resolve the file address to a load address
   // and read the TLS data
-  if (expr.LinkThreadLocalStorage(link_address_callback))
+  if (expr.LinkThreadLocalStorage(m_dwarf_cu, link_address_callback))
     m_module_wp = new_module_sp;
   return true;
 }
 
 bool DWARFExpressionList::MatchesOperand(
     StackFrame &frame, const Instruction::Operand &operand) const {
   RegisterContextSP reg_ctx_sp = frame.GetRegisterContext();
   if (!reg_ctx_sp) {

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

lldb_private::StatsDuration::Duration GetDebugInfoParseTime() override {
     return m_parse_time;
   }
   lldb_private::StatsDuration::Duration GetDebugInfoIndexTime() override;
 
   lldb_private::StatsDuration &GetDebugInfoParseTimeRef() {
     return m_parse_time;
   }
 
+  virtual lldb::offset_t
+  GetVendorDWARFOpcodeSize(const lldb_private::DataExtractor &data,
+                           const lldb::offset_t data_offset,
+                           const uint8_t op) const {
+    return LLDB_INVALID_OFFSET;
+  }
+
+  virtual bool
+  ParseVendorDWARFOpcode(uint8_t op, const lldb_private::DataExtractor &opcodes,
+                         lldb::offset_t &offset,
+                         std::vector<lldb_private::Value> &stack) const {
+    return false;
+  }
+
   lldb_private::ConstString ConstructFunctionDemangledName(const DWARFDIE &die);
 
 protected:
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *>
       DIEToTypePtr;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP>
       DIEToVariableSP;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *,

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (is_static_lifetime) {
                       Symtab::eVisibilityExtern);
               if (exe_symbol) {
                 if (exe_symbol->ValueIsAddress()) {
                   const addr_t exe_file_addr =
                       exe_symbol->GetAddressRef().GetFileAddress();
                   if (exe_file_addr != LLDB_INVALID_ADDRESS) {
                     DWARFExpression *location =
                         location_list.GetMutableExpressionAtAddress();
-                    if (location->Update_DW_OP_addr(exe_file_addr)) {
+                    if (location->Update_DW_OP_addr(die.GetCU(),
+                                                    exe_file_addr)) {
                       linked_oso_file_addr = true;
                       symbol_context_scope = exe_symbol;
                     }
                   }
                 }
               }
             }
           }
         }
 
         if (!linked_oso_file_addr) {
           // The DW_OP_addr is not zero, but it contains a .o file address
           // which needs to be linked up correctly.
           const lldb::addr_t exe_file_addr =
               debug_map_symfile->LinkOSOFileAddress(this, location_DW_OP_addr);
           if (exe_file_addr != LLDB_INVALID_ADDRESS) {
             // Update the file address for this variable
             DWARFExpression *location =
                 location_list.GetMutableExpressionAtAddress();
-            location->Update_DW_OP_addr(exe_file_addr);
+            location->Update_DW_OP_addr(die.GetCU(), exe_file_addr);
           } else {
             // Variable didn't make it into the final executable
             return nullptr;
           }
         }
       }
     } else {
       if (location_is_const_value_data &&

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h

public:
   llvm::Expected<lldb::TypeSystemSP>
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   DWARFDIE
   GetDIE(const DIERef &die_ref) override;
 
   llvm::Optional<uint32_t> GetDwoNum() override { return GetID() >> 32; }
 
+  lldb::offset_t
+  GetVendorDWARFOpcodeSize(const lldb_private::DataExtractor &data,
+                           const lldb::offset_t data_offset,
+                           const uint8_t op) const override;
+
+  bool ParseVendorDWARFOpcode(
+      uint8_t op, const lldb_private::DataExtractor &opcodes,
+      lldb::offset_t &offset,
+      std::vector<lldb_private::Value> &stack) const override;
+
 protected:
   DIEToTypePtr &GetDIEToType() override;
 
   DIEToVariableSP &GetDIEToVariable() override;
 
   DIEToClangType &GetForwardDeclDieToClangType() override;
 
   ClangTypeToDIE &GetForwardDeclClangTypeToDie() override;
 
   UniqueDWARFASTTypeMap &GetUniqueDWARFASTTypeMap() override;
 
   lldb::TypeSP FindDefinitionTypeForDWARFDeclContext(
       const DWARFDeclContext &die_decl_ctx) override;
 
   lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(
       const DWARFDIE &die, lldb_private::ConstString type_name,
       bool must_be_implementation) override;
 
-  SymbolFileDWARF &GetBaseSymbolFile() { return m_base_symbol_file; }
+  SymbolFileDWARF &GetBaseSymbolFile() const { return m_base_symbol_file; }
 
   /// If this file contains exactly one compile unit, this function will return
   /// it. Otherwise it returns nullptr.
   DWARFCompileUnit *FindSingleCompileUnit();
 
   SymbolFileDWARF &m_base_symbol_file;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_SYMBOLFILEDWARFDWO_H

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp

if (auto *candidate =
       if (cu)
         return nullptr; // More that one CU found.
       cu = candidate;
     }
   }
   return cu;
 }
 
+lldb::offset_t SymbolFileDWARFDwo::GetVendorDWARFOpcodeSize(
+    const lldb_private::DataExtractor &data, const lldb::offset_t data_offset,
+    const uint8_t op) const {
+  return GetBaseSymbolFile().GetVendorDWARFOpcodeSize(data, data_offset, op);
+}
+
+bool SymbolFileDWARFDwo::ParseVendorDWARFOpcode(
+    uint8_t op, const lldb_private::DataExtractor &opcodes,
+    lldb::offset_t &offset, std::vector<lldb_private::Value> &stack) const {
+  return GetBaseSymbolFile().ParseVendorDWARFOpcode(op, opcodes, offset, stack);
+}
+
 SymbolFileDWARF::DIEToTypePtr &SymbolFileDWARFDwo::GetDIEToType() {
   return GetBaseSymbolFile().GetDIEToType();
 }
 
 SymbolFileDWARF::DIEToVariableSP &SymbolFileDWARFDwo::GetDIEToVariable() {
   return GetBaseSymbolFile().GetDIEToVariable();
 }
 

lldb/unittests/Expression/DWARFExpressionTest.cpp

 //===-- DWARFExpressionTest.cpp -------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Expression/DWARFExpression.h"
 #include "Plugins/Platform/Linux/PlatformLinux.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDebugInfo.h"
+#include "Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "TestingSupport/Symbol/YAMLModuleTester.h"
 #include "lldb/Core/Debugger.h"
+#include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/StreamString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
ASSERT_TRUE(DWARFExpression::Evaluate(
       lldb::eRegisterKindLLDB,
       /*initial_value_ptr*/ nullptr,
       /*object_address_ptr*/ nullptr, result, &status))
       << status.ToError();
 
   ASSERT_EQ(result.GetValueType(), Value::ValueType::LoadAddress);
   ASSERT_EQ(result.GetScalar().UInt(), 0x5678u);
 }
+
+class CustomSymbolFileDWARF : public SymbolFileDWARF {
+  static char ID;
+
+public:
+  using SymbolFileDWARF::SymbolFileDWARF;
+
+  bool isA(const void *ClassID) const override {
+    return ClassID == &ID || SymbolFile::isA(ClassID);
+  }
+  static bool classof(const SymbolFile *obj) { return obj->isA(&ID); }
+
+  static llvm::StringRef GetPluginNameStatic() { return "custom_dwarf"; }
+
+  static llvm::StringRef GetPluginDescriptionStatic() {
+    return "Symbol file reader with expression extensions.";
+  }
+
+  static void Initialize() {
+    PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                  GetPluginDescriptionStatic(), CreateInstance,
+                                  SymbolFileDWARF::DebuggerInitialize);
+  }
+
+  static void Terminate() { PluginManager::UnregisterPlugin(CreateInstance); }
+
+  static lldb_private::SymbolFile *
+  CreateInstance(lldb::ObjectFileSP objfile_sp) {
+    return new CustomSymbolFileDWARF(std::move(objfile_sp),
+                                     /*dwo_section_list*/ nullptr);
+  }
+
+  lldb::offset_t
+  GetVendorDWARFOpcodeSize(const lldb_private::DataExtractor &data,
+                           const lldb::offset_t data_offset,
+                           const uint8_t op) const final {
+    auto offset = data_offset;
+    if (op != DW_OP_WASM_location) {
+      return LLDB_INVALID_OFFSET;
+    }
+
+    // DW_OP_WASM_location WASM_GLOBAL:0x03 index:u32
+    // Called with "arguments" 0x03 and 0x04
+    // Location type:
+    if (data.GetU8(&offset) != /* global */ 0x03) {
+      return LLDB_INVALID_OFFSET;
+    }
+
+    // Index
+    if (data.GetU32(&offset) != 0x04) {
+      return LLDB_INVALID_OFFSET;
+    }
+
+    // Report the skipped distance:
+    return offset - data_offset;
+  }
+
+  bool
+  ParseVendorDWARFOpcode(uint8_t op, const lldb_private::DataExtractor &opcodes,
+                         lldb::offset_t &offset,
+                         std::vector<lldb_private::Value> &stack) const final {
+    if (op != DW_OP_WASM_location) {
+      return false;
+    }
+
+    // DW_OP_WASM_location WASM_GLOBAL:0x03 index:u32
+    // Called with "arguments" 0x03 and  0x04
+    // Location type:
+    if (opcodes.GetU8(&offset) != /* global */ 0x03) {
+      return false;
+    }
+
+    // Index:
+    if (opcodes.GetU32(&offset) != 0x04) {
+      return false;
+    }
+
+    // Return some value:
+    stack.push_back({GetScalar(32, 42, false)});
+    return true;
+  }
+};
+
+char CustomSymbolFileDWARF::ID;
+
+static auto testExpressionVendorExtensions(lldb::ModuleSP module_sp,
+                                           DWARFUnit &dwarf_unit) {
+  // Test that expression extensions can be evaluated, for example
+  // DW_OP_WASM_location which is not currently handled by DWARFExpression:
+  EXPECT_THAT_EXPECTED(Evaluate({DW_OP_WASM_location, 0x03, // WASM_GLOBAL:0x03
+                                 0x04, 0x00, 0x00,          // index:u32
+                                 0x00, DW_OP_stack_value},
+                                module_sp, &dwarf_unit),
+                       llvm::HasValue(GetScalar(32, 42, false)));
+
+  // Test that searches for opcodes work in the presence of extensions:
+  uint8_t expr[] = {DW_OP_WASM_location,   0x03, 0x04, 0x00, 0x00, 0x00,
+                    DW_OP_form_tls_address};
+  DataExtractor extractor(expr, sizeof(expr), lldb::eByteOrderLittle,
+                          /*addr_size*/ 4);
+  DWARFExpression dwarf_expr(extractor);
+  ASSERT_TRUE(dwarf_expr.ContainsThreadLocalStorage(&dwarf_unit));
+}
+
+TEST(DWARFExpression, Extensions) {
+  const char *yamldata = R"(
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_386
+DWARF:
+  debug_abbrev:
+    - Table:
+        - Code:            0x00000001
+          Tag:             DW_TAG_compile_unit
+          Children:        DW_CHILDREN_no
+  debug_info:
+    - Version:         4
+      AddrSize:        4
+      Entries:
+        - AbbrCode:        0x1
+        - AbbrCode:        0x0
+)";
+
+  SubsystemRAII<FileSystem, HostInfo, TypeSystemClang, ObjectFileELF,
+                CustomSymbolFileDWARF>
+      subsystems;
+
+  llvm::Expected<TestFile> file = TestFile::fromYaml(yamldata);
+  EXPECT_THAT_EXPECTED(file, llvm::Succeeded());
+
+  auto module_sp = std::make_shared<Module>(file->moduleSpec());
+  auto &symfile =
+      *llvm::cast<CustomSymbolFileDWARF>(module_sp->GetSymbolFile());
+  auto *dwarf_unit = symfile.DebugInfo().GetUnitAtIndex(0);
+
+  testExpressionVendorExtensions(module_sp, *dwarf_unit);
+}
+
+TEST(DWARFExpression, ExtensionsDWO) {
+  const char *skeleton_yamldata = R"(
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_386
+DWARF:
+  debug_abbrev:
+    - Table:
+        - Code:            0x00000001
+          Tag:             DW_TAG_skeleton_unit
+          Children:        DW_CHILDREN_no
+          Attributes:
+            - Attribute:       DW_AT_dwo_name
+              Form:            DW_FORM_string
+            - Attribute:       DW_AT_dwo_id
+              Form:            DW_FORM_data4
+  debug_info:
+    - Version:         4
+      AddrSize:        4
+      Entries:
+        - AbbrCode:        0x1
+          Values:
+            - CStr:           "dwo_unit"
+            - Value:           0x01020304
+        - AbbrCode:        0x0
+)";
+
+  // .dwo sections aren't currently supported by dwarfyaml. The dwo_yamldata
+  // contents where generated by roundtripping the following yaml through
+  // yaml2obj | obj2yaml and renaming the sections. This works because the
+  // structure of the .dwo and non-.dwo sections is identical.
+  //
+  // --- !ELF
+  // FileHeader:
+  //   Class:   ELFCLASS64
+  //   Data:    ELFDATA2LSB
+  //   Type:    ET_EXEC
+  //   Machine: EM_386
+  // DWARF:
+  //   debug_abbrev: #.dwo
+  //     - Table:
+  //         - Code:            0x00000001
+  //           Tag:             DW_TAG_compile_unit
+  //           Children:        DW_CHILDREN_no
+  //           Attributes:
+  //             - Attribute:       DW_AT_dwo_id
+  //               Form:            DW_FORM_data4
+  //   debug_info: #.dwo
+  //     - Version:         4
+  //       AddrSize:        4
+  //       Entries:
+  //         - AbbrCode:        0x1
+  //           Values:
+  //             - Value:           0x01020304
+  //         - AbbrCode:        0x0
+  const char *dwo_yamldata = R"(
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_386
+Sections:
+  - Name:            .debug_abbrev.dwo
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x1
+    Content:         '0111007506000000'
+  - Name:            .debug_info.dwo
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x1
+    Content:         0D00000004000000000004010403020100
+)";
+
+  SubsystemRAII<FileSystem, HostInfo, ObjectFileELF, CustomSymbolFileDWARF>
+      subsystems;
+
+  llvm::Expected<TestFile> skeleton_file =
+      TestFile::fromYaml(skeleton_yamldata);
+  EXPECT_THAT_EXPECTED(skeleton_file, llvm::Succeeded());
+  llvm::Expected<TestFile> dwo_file = TestFile::fromYaml(dwo_yamldata);
+  EXPECT_THAT_EXPECTED(dwo_file, llvm::Succeeded());
+
+  auto skeleton_module_sp =
+      std::make_shared<Module>(skeleton_file->moduleSpec());
+  auto &skeleton_symfile =
+      *llvm::cast<CustomSymbolFileDWARF>(skeleton_module_sp->GetSymbolFile());
+
+  auto dwo_module_sp = std::make_shared<Module>(dwo_file->moduleSpec());
+  SymbolFileDWARFDwo dwo_symfile(
+      skeleton_symfile, dwo_module_sp->GetObjectFile()->shared_from_this(),
+      0x01020304);
+  auto *dwo_dwarf_unit = dwo_symfile.DebugInfo().GetUnitAtIndex(0);
+
+  testExpressionVendorExtensions(dwo_module_sp, *dwo_dwarf_unit);
+}