[lldb][NFC] Simplify GetLocation_DW_OP_addr function

[fdeazeve]

Summary

A very old commit (9422dd64f870dd33) changed the signature of this function in a
number of ways. This patch aims to improve it:

1. Reword the documentation, which still mentions old parameters that no longer

exist, and to elaborate upon the behavior of this function.

2. Remove the unnecessary parameter op_addr_idx. This parameter is odd in a

couple of ways: we never use it with a value that is non-zero, and the matching
Update_DW_OP_addr function doesn't use a similar parameter. We also document
that this new behavior. If we ever decide to handle multiple "DW_OP_addr", we
can introduce the complexity again.

[jasonmolenda]

this looks good to me. I'm a little overly paranoid about specifying when things are file addresses versus load addresses -- I'm sure that anyone working in this context would know these are file addresses being returned, but I would probably say that in the prototype doc strings e.g. "Return the file address specified". That's more of a personal style thing than anything important tho.

lldb/include/lldb/Expression/DWARFExpression.h

public:
   DWARFExpression(const DataExtractor &data);
 
   /// Destructor
   virtual ~DWARFExpression();
 
   /// Return true if the location expression contains data
   bool IsValid() const;
 
-  /// If a location is not a location list, return true if the location
-  /// contains a DW_OP_addr () opcode in the stream that matches \a file_addr.
-  /// If file_addr is LLDB_INVALID_ADDRESS, the this function will return true
-  /// if the variable there is any DW_OP_addr in a location that (yet still is
-  /// NOT a location list). This helps us detect if a variable is a global or
-  /// static variable since there is no other indication from DWARF debug
-  /// info.
+  /// Return the address specified by the first
+  /// DW_OP_{addr, addrx, GNU_addr_index} in the operation stream.
   ///
   /// \param[in] dwarf_cu
-  ///     The dwarf unit this expression belongs to.
-  ///
-  /// \param[in] op_addr_idx
-  ///     The DW_OP_addr index to retrieve in case there is more than
-  ///     one DW_OP_addr opcode in the location byte stream.
+  ///     The dwarf unit this expression belongs to. Only required to resolve
+  ///     DW_OP{addrx, GNU_addr_index}.
   ///
   /// \param[out] error
   ///     If the location stream contains unknown DW_OP opcodes or the
   ///     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
+  ///     The address specified by the operation, if the operation exists, or
+  ///     LLDB_INVALID_ADDRESS otherwise.
   lldb::addr_t GetLocation_DW_OP_addr(const DWARFUnit *dwarf_cu,
-                                      uint32_t op_addr_idx, bool &error) const;
+                                      bool &error) const;
 
   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 DWARFUnit *dwarf_cu) const;
 

lldb/source/Expression/DWARFExpression.cpp

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)) {
     const uint8_t op = m_data.GetU8(&offset);
 
-    if (op == DW_OP_addr) {
-      const lldb::addr_t op_file_addr = m_data.GetAddress(&offset);
-      if (curr_op_addr_idx == op_addr_idx)
-        return op_file_addr;
-      ++curr_op_addr_idx;
-    } else if (op == DW_OP_GNU_addr_index || op == DW_OP_addrx) {
+    if (op == DW_OP_addr)
+      return m_data.GetAddress(&offset);
+    if (op == DW_OP_GNU_addr_index || op == DW_OP_addrx) {
       uint64_t index = m_data.GetULEB128(&offset);
-      if (curr_op_addr_idx == op_addr_idx) {
-        if (!dwarf_cu) {
-          error = true;
-          break;
-        }
-
-        return dwarf_cu->ReadAddressFromDebugAddrSection(index);
-      }
-      ++curr_op_addr_idx;
-    } else {
-      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;
-    }
-  }
+      if (dwarf_cu)
+        return dwarf_cu->ReadAddressFromDebugAddrSection(index);
   return LLDB_INVALID_ADDRESS;
 }
 
 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);

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

bool is_static_lifetime =
         has_explicit_mangled ||
         (has_explicit_location && !location_list.IsValid());
     // Check if the location has a DW_OP_addr with any address value...
     lldb::addr_t location_DW_OP_addr = LLDB_INVALID_ADDRESS;
     if (!location_is_const_value_data) {
       bool op_error = false;
       const DWARFExpression* location = location_list.GetAlwaysValidExpr();
       if (location)
-        location_DW_OP_addr = location->GetLocation_DW_OP_addr(
-            location_form.GetUnit(), 0, op_error);
+        location_DW_OP_addr =
+            location->GetLocation_DW_OP_addr(location_form.GetUnit(), op_error);
       if (op_error) {
         StreamString strm;
         location->DumpLocation(&strm, eDescriptionLevelFull, nullptr);
         GetObjectFile()->GetModule()->ReportError(
             "{0:x16}: {1} has an invalid location: {2}", die.GetOffset(),
             die.GetTagAsCString(), strm.GetData());
       }
       if (location_DW_OP_addr != LLDB_INVALID_ADDRESS)