1 //===-- DWARFExpression.cpp -----------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "lldb/Expression/DWARFExpression.h" 10 11 #include <cinttypes> 12 13 #include <vector> 14 15 #include "lldb/Core/Module.h" 16 #include "lldb/Core/Value.h" 17 #include "lldb/Core/dwarf.h" 18 #include "lldb/Utility/DataEncoder.h" 19 #include "lldb/Utility/Log.h" 20 #include "lldb/Utility/RegisterValue.h" 21 #include "lldb/Utility/Scalar.h" 22 #include "lldb/Utility/StreamString.h" 23 #include "lldb/Utility/VMRange.h" 24 25 #include "lldb/Host/Host.h" 26 #include "lldb/Utility/Endian.h" 27 28 #include "lldb/Symbol/Function.h" 29 30 #include "lldb/Target/ABI.h" 31 #include "lldb/Target/ExecutionContext.h" 32 #include "lldb/Target/Process.h" 33 #include "lldb/Target/RegisterContext.h" 34 #include "lldb/Target/StackFrame.h" 35 #include "lldb/Target/StackID.h" 36 #include "lldb/Target/Target.h" 37 #include "lldb/Target/Thread.h" 38 39 #include "Plugins/SymbolFile/DWARF/DWARFUnit.h" 40 41 using namespace lldb; 42 using namespace lldb_private; 43 44 static lldb::addr_t 45 ReadAddressFromDebugAddrSection(const DWARFUnit *dwarf_cu, 46 uint32_t index) { 47 uint32_t index_size = dwarf_cu->GetAddressByteSize(); 48 dw_offset_t addr_base = dwarf_cu->GetAddrBase(); 49 lldb::offset_t offset = addr_base + index * index_size; 50 const DWARFDataExtractor &data = 51 dwarf_cu->GetSymbolFileDWARF().GetDWARFContext().getOrLoadAddrData(); 52 if (data.ValidOffsetForDataOfSize(offset, index_size)) 53 return data.GetMaxU64_unchecked(&offset, index_size); 54 return LLDB_INVALID_ADDRESS; 55 } 56 57 // DWARFExpression constructor 58 DWARFExpression::DWARFExpression() : m_module_wp(), m_data() {} 59 60 DWARFExpression::DWARFExpression(lldb::ModuleSP module_sp, 61 const DataExtractor &data, 62 const DWARFUnit *dwarf_cu) 63 : m_module_wp(), m_data(data), m_dwarf_cu(dwarf_cu), 64 m_reg_kind(eRegisterKindDWARF) { 65 if (module_sp) 66 m_module_wp = module_sp; 67 } 68 69 // Destructor 70 DWARFExpression::~DWARFExpression() = default; 71 72 bool DWARFExpression::IsValid() const { return m_data.GetByteSize() > 0; } 73 74 void DWARFExpression::UpdateValue(uint64_t const_value, 75 lldb::offset_t const_value_byte_size, 76 uint8_t addr_byte_size) { 77 if (!const_value_byte_size) 78 return; 79 80 m_data.SetData( 81 DataBufferSP(new DataBufferHeap(&const_value, const_value_byte_size))); 82 m_data.SetByteOrder(endian::InlHostByteOrder()); 83 m_data.SetAddressByteSize(addr_byte_size); 84 } 85 86 void DWARFExpression::DumpLocation(Stream *s, const DataExtractor &data, 87 lldb::DescriptionLevel level, 88 ABI *abi) const { 89 llvm::DWARFExpression(data.GetAsLLVM(), data.GetAddressByteSize()) 90 .print(s->AsRawOstream(), llvm::DIDumpOptions(), 91 abi ? &abi->GetMCRegisterInfo() : nullptr, nullptr); 92 } 93 94 void DWARFExpression::SetLocationListAddresses(addr_t cu_file_addr, 95 addr_t func_file_addr) { 96 m_loclist_addresses = LoclistAddresses{cu_file_addr, func_file_addr}; 97 } 98 99 int DWARFExpression::GetRegisterKind() { return m_reg_kind; } 100 101 void DWARFExpression::SetRegisterKind(RegisterKind reg_kind) { 102 m_reg_kind = reg_kind; 103 } 104 105 bool DWARFExpression::IsLocationList() const { 106 return bool(m_loclist_addresses); 107 } 108 109 namespace { 110 /// Implement enough of the DWARFObject interface in order to be able to call 111 /// DWARFLocationTable::dumpLocationList. We don't have access to a real 112 /// DWARFObject here because DWARFExpression is used in non-DWARF scenarios too. 113 class DummyDWARFObject final: public llvm::DWARFObject { 114 public: 115 DummyDWARFObject(bool IsLittleEndian) : IsLittleEndian(IsLittleEndian) {} 116 117 bool isLittleEndian() const override { return IsLittleEndian; } 118 119 llvm::Optional<llvm::RelocAddrEntry> find(const llvm::DWARFSection &Sec, 120 uint64_t Pos) const override { 121 return llvm::None; 122 } 123 private: 124 bool IsLittleEndian; 125 }; 126 } 127 128 void DWARFExpression::GetDescription(Stream *s, lldb::DescriptionLevel level, 129 addr_t location_list_base_addr, 130 ABI *abi) const { 131 if (IsLocationList()) { 132 // We have a location list 133 lldb::offset_t offset = 0; 134 std::unique_ptr<llvm::DWARFLocationTable> loctable_up = 135 m_dwarf_cu->GetLocationTable(m_data); 136 137 llvm::MCRegisterInfo *MRI = abi ? &abi->GetMCRegisterInfo() : nullptr; 138 llvm::DIDumpOptions DumpOpts; 139 DumpOpts.RecoverableErrorHandler = [&](llvm::Error E) { 140 s->AsRawOstream() << "error: " << toString(std::move(E)); 141 }; 142 loctable_up->dumpLocationList( 143 &offset, s->AsRawOstream(), 144 llvm::object::SectionedAddress{m_loclist_addresses->cu_file_addr}, MRI, 145 DummyDWARFObject(m_data.GetByteOrder() == eByteOrderLittle), nullptr, 146 DumpOpts, s->GetIndentLevel() + 2); 147 } else { 148 // We have a normal location that contains DW_OP location opcodes 149 DumpLocation(s, m_data, level, abi); 150 } 151 } 152 153 static bool ReadRegisterValueAsScalar(RegisterContext *reg_ctx, 154 lldb::RegisterKind reg_kind, 155 uint32_t reg_num, Status *error_ptr, 156 Value &value) { 157 if (reg_ctx == nullptr) { 158 if (error_ptr) 159 error_ptr->SetErrorString("No register context in frame.\n"); 160 } else { 161 uint32_t native_reg = 162 reg_ctx->ConvertRegisterKindToRegisterNumber(reg_kind, reg_num); 163 if (native_reg == LLDB_INVALID_REGNUM) { 164 if (error_ptr) 165 error_ptr->SetErrorStringWithFormat("Unable to convert register " 166 "kind=%u reg_num=%u to a native " 167 "register number.\n", 168 reg_kind, reg_num); 169 } else { 170 const RegisterInfo *reg_info = 171 reg_ctx->GetRegisterInfoAtIndex(native_reg); 172 RegisterValue reg_value; 173 if (reg_ctx->ReadRegister(reg_info, reg_value)) { 174 if (reg_value.GetScalarValue(value.GetScalar())) { 175 value.SetValueType(Value::ValueType::Scalar); 176 value.SetContext(Value::ContextType::RegisterInfo, 177 const_cast<RegisterInfo *>(reg_info)); 178 if (error_ptr) 179 error_ptr->Clear(); 180 return true; 181 } else { 182 // If we get this error, then we need to implement a value buffer in 183 // the dwarf expression evaluation function... 184 if (error_ptr) 185 error_ptr->SetErrorStringWithFormat( 186 "register %s can't be converted to a scalar value", 187 reg_info->name); 188 } 189 } else { 190 if (error_ptr) 191 error_ptr->SetErrorStringWithFormat("register %s is not available", 192 reg_info->name); 193 } 194 } 195 } 196 return false; 197 } 198 199 /// Return the length in bytes of the set of operands for \p op. No guarantees 200 /// are made on the state of \p data after this call. 201 static offset_t GetOpcodeDataSize(const DataExtractor &data, 202 const lldb::offset_t data_offset, 203 const uint8_t op) { 204 lldb::offset_t offset = data_offset; 205 switch (op) { 206 case DW_OP_addr: 207 case DW_OP_call_ref: // 0x9a 1 address sized offset of DIE (DWARF3) 208 return data.GetAddressByteSize(); 209 210 // Opcodes with no arguments 211 case DW_OP_deref: // 0x06 212 case DW_OP_dup: // 0x12 213 case DW_OP_drop: // 0x13 214 case DW_OP_over: // 0x14 215 case DW_OP_swap: // 0x16 216 case DW_OP_rot: // 0x17 217 case DW_OP_xderef: // 0x18 218 case DW_OP_abs: // 0x19 219 case DW_OP_and: // 0x1a 220 case DW_OP_div: // 0x1b 221 case DW_OP_minus: // 0x1c 222 case DW_OP_mod: // 0x1d 223 case DW_OP_mul: // 0x1e 224 case DW_OP_neg: // 0x1f 225 case DW_OP_not: // 0x20 226 case DW_OP_or: // 0x21 227 case DW_OP_plus: // 0x22 228 case DW_OP_shl: // 0x24 229 case DW_OP_shr: // 0x25 230 case DW_OP_shra: // 0x26 231 case DW_OP_xor: // 0x27 232 case DW_OP_eq: // 0x29 233 case DW_OP_ge: // 0x2a 234 case DW_OP_gt: // 0x2b 235 case DW_OP_le: // 0x2c 236 case DW_OP_lt: // 0x2d 237 case DW_OP_ne: // 0x2e 238 case DW_OP_lit0: // 0x30 239 case DW_OP_lit1: // 0x31 240 case DW_OP_lit2: // 0x32 241 case DW_OP_lit3: // 0x33 242 case DW_OP_lit4: // 0x34 243 case DW_OP_lit5: // 0x35 244 case DW_OP_lit6: // 0x36 245 case DW_OP_lit7: // 0x37 246 case DW_OP_lit8: // 0x38 247 case DW_OP_lit9: // 0x39 248 case DW_OP_lit10: // 0x3A 249 case DW_OP_lit11: // 0x3B 250 case DW_OP_lit12: // 0x3C 251 case DW_OP_lit13: // 0x3D 252 case DW_OP_lit14: // 0x3E 253 case DW_OP_lit15: // 0x3F 254 case DW_OP_lit16: // 0x40 255 case DW_OP_lit17: // 0x41 256 case DW_OP_lit18: // 0x42 257 case DW_OP_lit19: // 0x43 258 case DW_OP_lit20: // 0x44 259 case DW_OP_lit21: // 0x45 260 case DW_OP_lit22: // 0x46 261 case DW_OP_lit23: // 0x47 262 case DW_OP_lit24: // 0x48 263 case DW_OP_lit25: // 0x49 264 case DW_OP_lit26: // 0x4A 265 case DW_OP_lit27: // 0x4B 266 case DW_OP_lit28: // 0x4C 267 case DW_OP_lit29: // 0x4D 268 case DW_OP_lit30: // 0x4E 269 case DW_OP_lit31: // 0x4f 270 case DW_OP_reg0: // 0x50 271 case DW_OP_reg1: // 0x51 272 case DW_OP_reg2: // 0x52 273 case DW_OP_reg3: // 0x53 274 case DW_OP_reg4: // 0x54 275 case DW_OP_reg5: // 0x55 276 case DW_OP_reg6: // 0x56 277 case DW_OP_reg7: // 0x57 278 case DW_OP_reg8: // 0x58 279 case DW_OP_reg9: // 0x59 280 case DW_OP_reg10: // 0x5A 281 case DW_OP_reg11: // 0x5B 282 case DW_OP_reg12: // 0x5C 283 case DW_OP_reg13: // 0x5D 284 case DW_OP_reg14: // 0x5E 285 case DW_OP_reg15: // 0x5F 286 case DW_OP_reg16: // 0x60 287 case DW_OP_reg17: // 0x61 288 case DW_OP_reg18: // 0x62 289 case DW_OP_reg19: // 0x63 290 case DW_OP_reg20: // 0x64 291 case DW_OP_reg21: // 0x65 292 case DW_OP_reg22: // 0x66 293 case DW_OP_reg23: // 0x67 294 case DW_OP_reg24: // 0x68 295 case DW_OP_reg25: // 0x69 296 case DW_OP_reg26: // 0x6A 297 case DW_OP_reg27: // 0x6B 298 case DW_OP_reg28: // 0x6C 299 case DW_OP_reg29: // 0x6D 300 case DW_OP_reg30: // 0x6E 301 case DW_OP_reg31: // 0x6F 302 case DW_OP_nop: // 0x96 303 case DW_OP_push_object_address: // 0x97 DWARF3 304 case DW_OP_form_tls_address: // 0x9b DWARF3 305 case DW_OP_call_frame_cfa: // 0x9c DWARF3 306 case DW_OP_stack_value: // 0x9f DWARF4 307 case DW_OP_GNU_push_tls_address: // 0xe0 GNU extension 308 return 0; 309 310 // Opcodes with a single 1 byte arguments 311 case DW_OP_const1u: // 0x08 1 1-byte constant 312 case DW_OP_const1s: // 0x09 1 1-byte constant 313 case DW_OP_pick: // 0x15 1 1-byte stack index 314 case DW_OP_deref_size: // 0x94 1 1-byte size of data retrieved 315 case DW_OP_xderef_size: // 0x95 1 1-byte size of data retrieved 316 return 1; 317 318 // Opcodes with a single 2 byte arguments 319 case DW_OP_const2u: // 0x0a 1 2-byte constant 320 case DW_OP_const2s: // 0x0b 1 2-byte constant 321 case DW_OP_skip: // 0x2f 1 signed 2-byte constant 322 case DW_OP_bra: // 0x28 1 signed 2-byte constant 323 case DW_OP_call2: // 0x98 1 2-byte offset of DIE (DWARF3) 324 return 2; 325 326 // Opcodes with a single 4 byte arguments 327 case DW_OP_const4u: // 0x0c 1 4-byte constant 328 case DW_OP_const4s: // 0x0d 1 4-byte constant 329 case DW_OP_call4: // 0x99 1 4-byte offset of DIE (DWARF3) 330 return 4; 331 332 // Opcodes with a single 8 byte arguments 333 case DW_OP_const8u: // 0x0e 1 8-byte constant 334 case DW_OP_const8s: // 0x0f 1 8-byte constant 335 return 8; 336 337 // All opcodes that have a single ULEB (signed or unsigned) argument 338 case DW_OP_addrx: // 0xa1 1 ULEB128 index 339 case DW_OP_constu: // 0x10 1 ULEB128 constant 340 case DW_OP_consts: // 0x11 1 SLEB128 constant 341 case DW_OP_plus_uconst: // 0x23 1 ULEB128 addend 342 case DW_OP_breg0: // 0x70 1 ULEB128 register 343 case DW_OP_breg1: // 0x71 1 ULEB128 register 344 case DW_OP_breg2: // 0x72 1 ULEB128 register 345 case DW_OP_breg3: // 0x73 1 ULEB128 register 346 case DW_OP_breg4: // 0x74 1 ULEB128 register 347 case DW_OP_breg5: // 0x75 1 ULEB128 register 348 case DW_OP_breg6: // 0x76 1 ULEB128 register 349 case DW_OP_breg7: // 0x77 1 ULEB128 register 350 case DW_OP_breg8: // 0x78 1 ULEB128 register 351 case DW_OP_breg9: // 0x79 1 ULEB128 register 352 case DW_OP_breg10: // 0x7a 1 ULEB128 register 353 case DW_OP_breg11: // 0x7b 1 ULEB128 register 354 case DW_OP_breg12: // 0x7c 1 ULEB128 register 355 case DW_OP_breg13: // 0x7d 1 ULEB128 register 356 case DW_OP_breg14: // 0x7e 1 ULEB128 register 357 case DW_OP_breg15: // 0x7f 1 ULEB128 register 358 case DW_OP_breg16: // 0x80 1 ULEB128 register 359 case DW_OP_breg17: // 0x81 1 ULEB128 register 360 case DW_OP_breg18: // 0x82 1 ULEB128 register 361 case DW_OP_breg19: // 0x83 1 ULEB128 register 362 case DW_OP_breg20: // 0x84 1 ULEB128 register 363 case DW_OP_breg21: // 0x85 1 ULEB128 register 364 case DW_OP_breg22: // 0x86 1 ULEB128 register 365 case DW_OP_breg23: // 0x87 1 ULEB128 register 366 case DW_OP_breg24: // 0x88 1 ULEB128 register 367 case DW_OP_breg25: // 0x89 1 ULEB128 register 368 case DW_OP_breg26: // 0x8a 1 ULEB128 register 369 case DW_OP_breg27: // 0x8b 1 ULEB128 register 370 case DW_OP_breg28: // 0x8c 1 ULEB128 register 371 case DW_OP_breg29: // 0x8d 1 ULEB128 register 372 case DW_OP_breg30: // 0x8e 1 ULEB128 register 373 case DW_OP_breg31: // 0x8f 1 ULEB128 register 374 case DW_OP_regx: // 0x90 1 ULEB128 register 375 case DW_OP_fbreg: // 0x91 1 SLEB128 offset 376 case DW_OP_piece: // 0x93 1 ULEB128 size of piece addressed 377 case DW_OP_GNU_addr_index: // 0xfb 1 ULEB128 index 378 case DW_OP_GNU_const_index: // 0xfc 1 ULEB128 index 379 data.Skip_LEB128(&offset); 380 return offset - data_offset; 381 382 // All opcodes that have a 2 ULEB (signed or unsigned) arguments 383 case DW_OP_bregx: // 0x92 2 ULEB128 register followed by SLEB128 offset 384 case DW_OP_bit_piece: // 0x9d ULEB128 bit size, ULEB128 bit offset (DWARF3); 385 data.Skip_LEB128(&offset); 386 data.Skip_LEB128(&offset); 387 return offset - data_offset; 388 389 case DW_OP_implicit_value: // 0x9e ULEB128 size followed by block of that size 390 // (DWARF4) 391 { 392 uint64_t block_len = data.Skip_LEB128(&offset); 393 offset += block_len; 394 return offset - data_offset; 395 } 396 397 case DW_OP_GNU_entry_value: 398 case DW_OP_entry_value: // 0xa3 ULEB128 size + variable-length block 399 { 400 uint64_t subexpr_len = data.GetULEB128(&offset); 401 return (offset - data_offset) + subexpr_len; 402 } 403 404 default: 405 break; 406 } 407 return LLDB_INVALID_OFFSET; 408 } 409 410 lldb::addr_t DWARFExpression::GetLocation_DW_OP_addr(uint32_t op_addr_idx, 411 bool &error) const { 412 error = false; 413 if (IsLocationList()) 414 return LLDB_INVALID_ADDRESS; 415 lldb::offset_t offset = 0; 416 uint32_t curr_op_addr_idx = 0; 417 while (m_data.ValidOffset(offset)) { 418 const uint8_t op = m_data.GetU8(&offset); 419 420 if (op == DW_OP_addr) { 421 const lldb::addr_t op_file_addr = m_data.GetAddress(&offset); 422 if (curr_op_addr_idx == op_addr_idx) 423 return op_file_addr; 424 else 425 ++curr_op_addr_idx; 426 } else if (op == DW_OP_GNU_addr_index || op == DW_OP_addrx) { 427 uint64_t index = m_data.GetULEB128(&offset); 428 if (curr_op_addr_idx == op_addr_idx) { 429 if (!m_dwarf_cu) { 430 error = true; 431 break; 432 } 433 434 return ReadAddressFromDebugAddrSection(m_dwarf_cu, index); 435 } else 436 ++curr_op_addr_idx; 437 } else { 438 const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op); 439 if (op_arg_size == LLDB_INVALID_OFFSET) { 440 error = true; 441 break; 442 } 443 offset += op_arg_size; 444 } 445 } 446 return LLDB_INVALID_ADDRESS; 447 } 448 449 bool DWARFExpression::Update_DW_OP_addr(lldb::addr_t file_addr) { 450 if (IsLocationList()) 451 return false; 452 lldb::offset_t offset = 0; 453 while (m_data.ValidOffset(offset)) { 454 const uint8_t op = m_data.GetU8(&offset); 455 456 if (op == DW_OP_addr) { 457 const uint32_t addr_byte_size = m_data.GetAddressByteSize(); 458 // We have to make a copy of the data as we don't know if this data is 459 // from a read only memory mapped buffer, so we duplicate all of the data 460 // first, then modify it, and if all goes well, we then replace the data 461 // for this expression 462 463 // So first we copy the data into a heap buffer 464 std::unique_ptr<DataBufferHeap> head_data_up( 465 new DataBufferHeap(m_data.GetDataStart(), m_data.GetByteSize())); 466 467 // Make en encoder so we can write the address into the buffer using the 468 // correct byte order (endianness) 469 DataEncoder encoder(head_data_up->GetBytes(), head_data_up->GetByteSize(), 470 m_data.GetByteOrder(), addr_byte_size); 471 472 // Replace the address in the new buffer 473 if (encoder.PutUnsigned(offset, addr_byte_size, file_addr) == UINT32_MAX) 474 return false; 475 476 // All went well, so now we can reset the data using a shared pointer to 477 // the heap data so "m_data" will now correctly manage the heap data. 478 m_data.SetData(DataBufferSP(head_data_up.release())); 479 return true; 480 } else { 481 const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op); 482 if (op_arg_size == LLDB_INVALID_OFFSET) 483 break; 484 offset += op_arg_size; 485 } 486 } 487 return false; 488 } 489 490 bool DWARFExpression::ContainsThreadLocalStorage() const { 491 // We are assuming for now that any thread local variable will not have a 492 // location list. This has been true for all thread local variables we have 493 // seen so far produced by any compiler. 494 if (IsLocationList()) 495 return false; 496 lldb::offset_t offset = 0; 497 while (m_data.ValidOffset(offset)) { 498 const uint8_t op = m_data.GetU8(&offset); 499 500 if (op == DW_OP_form_tls_address || op == DW_OP_GNU_push_tls_address) 501 return true; 502 const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op); 503 if (op_arg_size == LLDB_INVALID_OFFSET) 504 return false; 505 else 506 offset += op_arg_size; 507 } 508 return false; 509 } 510 bool DWARFExpression::LinkThreadLocalStorage( 511 lldb::ModuleSP new_module_sp, 512 std::function<lldb::addr_t(lldb::addr_t file_addr)> const 513 &link_address_callback) { 514 // We are assuming for now that any thread local variable will not have a 515 // location list. This has been true for all thread local variables we have 516 // seen so far produced by any compiler. 517 if (IsLocationList()) 518 return false; 519 520 const uint32_t addr_byte_size = m_data.GetAddressByteSize(); 521 // We have to make a copy of the data as we don't know if this data is from a 522 // read only memory mapped buffer, so we duplicate all of the data first, 523 // then modify it, and if all goes well, we then replace the data for this 524 // expression 525 526 // So first we copy the data into a heap buffer 527 std::shared_ptr<DataBufferHeap> heap_data_sp( 528 new DataBufferHeap(m_data.GetDataStart(), m_data.GetByteSize())); 529 530 // Make en encoder so we can write the address into the buffer using the 531 // correct byte order (endianness) 532 DataEncoder encoder(heap_data_sp->GetBytes(), heap_data_sp->GetByteSize(), 533 m_data.GetByteOrder(), addr_byte_size); 534 535 lldb::offset_t offset = 0; 536 lldb::offset_t const_offset = 0; 537 lldb::addr_t const_value = 0; 538 size_t const_byte_size = 0; 539 while (m_data.ValidOffset(offset)) { 540 const uint8_t op = m_data.GetU8(&offset); 541 542 bool decoded_data = false; 543 switch (op) { 544 case DW_OP_const4u: 545 // Remember the const offset in case we later have a 546 // DW_OP_form_tls_address or DW_OP_GNU_push_tls_address 547 const_offset = offset; 548 const_value = m_data.GetU32(&offset); 549 decoded_data = true; 550 const_byte_size = 4; 551 break; 552 553 case DW_OP_const8u: 554 // Remember the const offset in case we later have a 555 // DW_OP_form_tls_address or DW_OP_GNU_push_tls_address 556 const_offset = offset; 557 const_value = m_data.GetU64(&offset); 558 decoded_data = true; 559 const_byte_size = 8; 560 break; 561 562 case DW_OP_form_tls_address: 563 case DW_OP_GNU_push_tls_address: 564 // DW_OP_form_tls_address and DW_OP_GNU_push_tls_address must be preceded 565 // by a file address on the stack. We assume that DW_OP_const4u or 566 // DW_OP_const8u is used for these values, and we check that the last 567 // opcode we got before either of these was DW_OP_const4u or 568 // DW_OP_const8u. If so, then we can link the value accodingly. For 569 // Darwin, the value in the DW_OP_const4u or DW_OP_const8u is the file 570 // address of a structure that contains a function pointer, the pthread 571 // key and the offset into the data pointed to by the pthread key. So we 572 // must link this address and also set the module of this expression to 573 // the new_module_sp so we can resolve the file address correctly 574 if (const_byte_size > 0) { 575 lldb::addr_t linked_file_addr = link_address_callback(const_value); 576 if (linked_file_addr == LLDB_INVALID_ADDRESS) 577 return false; 578 // Replace the address in the new buffer 579 if (encoder.PutUnsigned(const_offset, const_byte_size, 580 linked_file_addr) == UINT32_MAX) 581 return false; 582 } 583 break; 584 585 default: 586 const_offset = 0; 587 const_value = 0; 588 const_byte_size = 0; 589 break; 590 } 591 592 if (!decoded_data) { 593 const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op); 594 if (op_arg_size == LLDB_INVALID_OFFSET) 595 return false; 596 else 597 offset += op_arg_size; 598 } 599 } 600 601 // If we linked the TLS address correctly, update the module so that when the 602 // expression is evaluated it can resolve the file address to a load address 603 // and read the 604 // TLS data 605 m_module_wp = new_module_sp; 606 m_data.SetData(heap_data_sp); 607 return true; 608 } 609 610 bool DWARFExpression::LocationListContainsAddress(addr_t func_load_addr, 611 lldb::addr_t addr) const { 612 if (func_load_addr == LLDB_INVALID_ADDRESS || addr == LLDB_INVALID_ADDRESS) 613 return false; 614 615 if (!IsLocationList()) 616 return false; 617 618 return GetLocationExpression(func_load_addr, addr) != llvm::None; 619 } 620 621 bool DWARFExpression::DumpLocationForAddress(Stream *s, 622 lldb::DescriptionLevel level, 623 addr_t func_load_addr, 624 addr_t address, ABI *abi) { 625 if (!IsLocationList()) { 626 DumpLocation(s, m_data, level, abi); 627 return true; 628 } 629 if (llvm::Optional<DataExtractor> expr = 630 GetLocationExpression(func_load_addr, address)) { 631 DumpLocation(s, *expr, level, abi); 632 return true; 633 } 634 return false; 635 } 636 637 static bool Evaluate_DW_OP_entry_value(std::vector<Value> &stack, 638 ExecutionContext *exe_ctx, 639 RegisterContext *reg_ctx, 640 const DataExtractor &opcodes, 641 lldb::offset_t &opcode_offset, 642 Status *error_ptr, Log *log) { 643 // DW_OP_entry_value(sub-expr) describes the location a variable had upon 644 // function entry: this variable location is presumed to be optimized out at 645 // the current PC value. The caller of the function may have call site 646 // information that describes an alternate location for the variable (e.g. a 647 // constant literal, or a spilled stack value) in the parent frame. 648 // 649 // Example (this is pseudo-code & pseudo-DWARF, but hopefully illustrative): 650 // 651 // void child(int &sink, int x) { 652 // ... 653 // /* "x" gets optimized out. */ 654 // 655 // /* The location of "x" here is: DW_OP_entry_value($reg2). */ 656 // ++sink; 657 // } 658 // 659 // void parent() { 660 // int sink; 661 // 662 // /* 663 // * The callsite information emitted here is: 664 // * 665 // * DW_TAG_call_site 666 // * DW_AT_return_pc ... (for "child(sink, 123);") 667 // * DW_TAG_call_site_parameter (for "sink") 668 // * DW_AT_location ($reg1) 669 // * DW_AT_call_value ($SP - 8) 670 // * DW_TAG_call_site_parameter (for "x") 671 // * DW_AT_location ($reg2) 672 // * DW_AT_call_value ($literal 123) 673 // * 674 // * DW_TAG_call_site 675 // * DW_AT_return_pc ... (for "child(sink, 456);") 676 // * ... 677 // */ 678 // child(sink, 123); 679 // child(sink, 456); 680 // } 681 // 682 // When the program stops at "++sink" within `child`, the debugger determines 683 // the call site by analyzing the return address. Once the call site is found, 684 // the debugger determines which parameter is referenced by DW_OP_entry_value 685 // and evaluates the corresponding location for that parameter in `parent`. 686 687 // 1. Find the function which pushed the current frame onto the stack. 688 if ((!exe_ctx || !exe_ctx->HasTargetScope()) || !reg_ctx) { 689 LLDB_LOG(log, "Evaluate_DW_OP_entry_value: no exe/reg context"); 690 return false; 691 } 692 693 StackFrame *current_frame = exe_ctx->GetFramePtr(); 694 Thread *thread = exe_ctx->GetThreadPtr(); 695 if (!current_frame || !thread) { 696 LLDB_LOG(log, "Evaluate_DW_OP_entry_value: no current frame/thread"); 697 return false; 698 } 699 700 Target &target = exe_ctx->GetTargetRef(); 701 StackFrameSP parent_frame = nullptr; 702 addr_t return_pc = LLDB_INVALID_ADDRESS; 703 uint32_t current_frame_idx = current_frame->GetFrameIndex(); 704 uint32_t num_frames = thread->GetStackFrameCount(); 705 for (uint32_t parent_frame_idx = current_frame_idx + 1; 706 parent_frame_idx < num_frames; ++parent_frame_idx) { 707 parent_frame = thread->GetStackFrameAtIndex(parent_frame_idx); 708 // Require a valid sequence of frames. 709 if (!parent_frame) 710 break; 711 712 // Record the first valid return address, even if this is an inlined frame, 713 // in order to look up the associated call edge in the first non-inlined 714 // parent frame. 715 if (return_pc == LLDB_INVALID_ADDRESS) { 716 return_pc = parent_frame->GetFrameCodeAddress().GetLoadAddress(&target); 717 LLDB_LOG(log, 718 "Evaluate_DW_OP_entry_value: immediate ancestor with pc = {0:x}", 719 return_pc); 720 } 721 722 // If we've found an inlined frame, skip it (these have no call site 723 // parameters). 724 if (parent_frame->IsInlined()) 725 continue; 726 727 // We've found the first non-inlined parent frame. 728 break; 729 } 730 if (!parent_frame || !parent_frame->GetRegisterContext()) { 731 LLDB_LOG(log, "Evaluate_DW_OP_entry_value: no parent frame with reg ctx"); 732 return false; 733 } 734 735 Function *parent_func = 736 parent_frame->GetSymbolContext(eSymbolContextFunction).function; 737 if (!parent_func) { 738 LLDB_LOG(log, "Evaluate_DW_OP_entry_value: no parent function"); 739 return false; 740 } 741 742 // 2. Find the call edge in the parent function responsible for creating the 743 // current activation. 744 Function *current_func = 745 current_frame->GetSymbolContext(eSymbolContextFunction).function; 746 if (!current_func) { 747 LLDB_LOG(log, "Evaluate_DW_OP_entry_value: no current function"); 748 return false; 749 } 750 751 CallEdge *call_edge = nullptr; 752 ModuleList &modlist = target.GetImages(); 753 ExecutionContext parent_exe_ctx = *exe_ctx; 754 parent_exe_ctx.SetFrameSP(parent_frame); 755 if (!parent_frame->IsArtificial()) { 756 // If the parent frame is not artificial, the current activation may be 757 // produced by an ambiguous tail call. In this case, refuse to proceed. 758 call_edge = parent_func->GetCallEdgeForReturnAddress(return_pc, target); 759 if (!call_edge) { 760 LLDB_LOG(log, 761 "Evaluate_DW_OP_entry_value: no call edge for retn-pc = {0:x} " 762 "in parent frame {1}", 763 return_pc, parent_func->GetName()); 764 return false; 765 } 766 Function *callee_func = call_edge->GetCallee(modlist, parent_exe_ctx); 767 if (callee_func != current_func) { 768 LLDB_LOG(log, "Evaluate_DW_OP_entry_value: ambiguous call sequence, " 769 "can't find real parent frame"); 770 return false; 771 } 772 } else { 773 // The StackFrameList solver machinery has deduced that an unambiguous tail 774 // call sequence that produced the current activation. The first edge in 775 // the parent that points to the current function must be valid. 776 for (auto &edge : parent_func->GetTailCallingEdges()) { 777 if (edge->GetCallee(modlist, parent_exe_ctx) == current_func) { 778 call_edge = edge.get(); 779 break; 780 } 781 } 782 } 783 if (!call_edge) { 784 LLDB_LOG(log, "Evaluate_DW_OP_entry_value: no unambiguous edge from parent " 785 "to current function"); 786 return false; 787 } 788 789 // 3. Attempt to locate the DW_OP_entry_value expression in the set of 790 // available call site parameters. If found, evaluate the corresponding 791 // parameter in the context of the parent frame. 792 const uint32_t subexpr_len = opcodes.GetULEB128(&opcode_offset); 793 const void *subexpr_data = opcodes.GetData(&opcode_offset, subexpr_len); 794 if (!subexpr_data) { 795 LLDB_LOG(log, "Evaluate_DW_OP_entry_value: subexpr could not be read"); 796 return false; 797 } 798 799 const CallSiteParameter *matched_param = nullptr; 800 for (const CallSiteParameter ¶m : call_edge->GetCallSiteParameters()) { 801 DataExtractor param_subexpr_extractor; 802 if (!param.LocationInCallee.GetExpressionData(param_subexpr_extractor)) 803 continue; 804 lldb::offset_t param_subexpr_offset = 0; 805 const void *param_subexpr_data = 806 param_subexpr_extractor.GetData(¶m_subexpr_offset, subexpr_len); 807 if (!param_subexpr_data || 808 param_subexpr_extractor.BytesLeft(param_subexpr_offset) != 0) 809 continue; 810 811 // At this point, the DW_OP_entry_value sub-expression and the callee-side 812 // expression in the call site parameter are known to have the same length. 813 // Check whether they are equal. 814 // 815 // Note that an equality check is sufficient: the contents of the 816 // DW_OP_entry_value subexpression are only used to identify the right call 817 // site parameter in the parent, and do not require any special handling. 818 if (memcmp(subexpr_data, param_subexpr_data, subexpr_len) == 0) { 819 matched_param = ¶m; 820 break; 821 } 822 } 823 if (!matched_param) { 824 LLDB_LOG(log, 825 "Evaluate_DW_OP_entry_value: no matching call site param found"); 826 return false; 827 } 828 829 // TODO: Add support for DW_OP_push_object_address within a DW_OP_entry_value 830 // subexpresion whenever llvm does. 831 Value result; 832 const DWARFExpression ¶m_expr = matched_param->LocationInCaller; 833 if (!param_expr.Evaluate(&parent_exe_ctx, 834 parent_frame->GetRegisterContext().get(), 835 /*loclist_base_addr=*/LLDB_INVALID_ADDRESS, 836 /*initial_value_ptr=*/nullptr, 837 /*object_address_ptr=*/nullptr, result, error_ptr)) { 838 LLDB_LOG(log, 839 "Evaluate_DW_OP_entry_value: call site param evaluation failed"); 840 return false; 841 } 842 843 stack.push_back(result); 844 return true; 845 } 846 847 bool DWARFExpression::Evaluate(ExecutionContextScope *exe_scope, 848 lldb::addr_t loclist_base_load_addr, 849 const Value *initial_value_ptr, 850 const Value *object_address_ptr, Value &result, 851 Status *error_ptr) const { 852 ExecutionContext exe_ctx(exe_scope); 853 return Evaluate(&exe_ctx, nullptr, loclist_base_load_addr, initial_value_ptr, 854 object_address_ptr, result, error_ptr); 855 } 856 857 bool DWARFExpression::Evaluate(ExecutionContext *exe_ctx, 858 RegisterContext *reg_ctx, 859 lldb::addr_t func_load_addr, 860 const Value *initial_value_ptr, 861 const Value *object_address_ptr, Value &result, 862 Status *error_ptr) const { 863 ModuleSP module_sp = m_module_wp.lock(); 864 865 if (IsLocationList()) { 866 addr_t pc; 867 StackFrame *frame = nullptr; 868 if (reg_ctx) 869 pc = reg_ctx->GetPC(); 870 else { 871 frame = exe_ctx->GetFramePtr(); 872 if (!frame) 873 return false; 874 RegisterContextSP reg_ctx_sp = frame->GetRegisterContext(); 875 if (!reg_ctx_sp) 876 return false; 877 pc = reg_ctx_sp->GetPC(); 878 } 879 880 if (func_load_addr != LLDB_INVALID_ADDRESS) { 881 if (pc == LLDB_INVALID_ADDRESS) { 882 if (error_ptr) 883 error_ptr->SetErrorString("Invalid PC in frame."); 884 return false; 885 } 886 887 if (llvm::Optional<DataExtractor> expr = 888 GetLocationExpression(func_load_addr, pc)) { 889 return DWARFExpression::Evaluate( 890 exe_ctx, reg_ctx, module_sp, *expr, m_dwarf_cu, m_reg_kind, 891 initial_value_ptr, object_address_ptr, result, error_ptr); 892 } 893 } 894 if (error_ptr) 895 error_ptr->SetErrorString("variable not available"); 896 return false; 897 } 898 899 // Not a location list, just a single expression. 900 return DWARFExpression::Evaluate(exe_ctx, reg_ctx, module_sp, m_data, 901 m_dwarf_cu, m_reg_kind, initial_value_ptr, 902 object_address_ptr, result, error_ptr); 903 } 904 905 namespace { 906 /// The location description kinds described by the DWARF v5 907 /// specification. Composite locations are handled out-of-band and 908 /// thus aren't part of the enum. 909 enum LocationDescriptionKind { 910 Empty, 911 Memory, 912 Register, 913 Implicit 914 /* Composite*/ 915 }; 916 /// Adjust value's ValueType according to the kind of location description. 917 void UpdateValueTypeFromLocationDescription(Log *log, const DWARFUnit *dwarf_cu, 918 LocationDescriptionKind kind, 919 Value *value = nullptr) { 920 // Note that this function is conflating DWARF expressions with 921 // DWARF location descriptions. Perhaps it would be better to define 922 // a wrapper for DWARFExpresssion::Eval() that deals with DWARF 923 // location descriptions (which consist of one or more DWARF 924 // expressions). But doing this would mean we'd also need factor the 925 // handling of DW_OP_(bit_)piece out of this function. 926 if (dwarf_cu && dwarf_cu->GetVersion() >= 4) { 927 const char *log_msg = "DWARF location description kind: %s"; 928 switch (kind) { 929 case Empty: 930 LLDB_LOGF(log, log_msg, "Empty"); 931 break; 932 case Memory: 933 LLDB_LOGF(log, log_msg, "Memory"); 934 if (value->GetValueType() == Value::ValueType::Scalar) 935 value->SetValueType(Value::ValueType::LoadAddress); 936 break; 937 case Register: 938 LLDB_LOGF(log, log_msg, "Register"); 939 value->SetValueType(Value::ValueType::Scalar); 940 break; 941 case Implicit: 942 LLDB_LOGF(log, log_msg, "Implicit"); 943 if (value->GetValueType() == Value::ValueType::LoadAddress) 944 value->SetValueType(Value::ValueType::Scalar); 945 break; 946 } 947 } 948 } 949 } // namespace 950 951 bool DWARFExpression::Evaluate( 952 ExecutionContext *exe_ctx, RegisterContext *reg_ctx, 953 lldb::ModuleSP module_sp, const DataExtractor &opcodes, 954 const DWARFUnit *dwarf_cu, const lldb::RegisterKind reg_kind, 955 const Value *initial_value_ptr, const Value *object_address_ptr, 956 Value &result, Status *error_ptr) { 957 958 if (opcodes.GetByteSize() == 0) { 959 if (error_ptr) 960 error_ptr->SetErrorString( 961 "no location, value may have been optimized out"); 962 return false; 963 } 964 std::vector<Value> stack; 965 966 Process *process = nullptr; 967 StackFrame *frame = nullptr; 968 969 if (exe_ctx) { 970 process = exe_ctx->GetProcessPtr(); 971 frame = exe_ctx->GetFramePtr(); 972 } 973 if (reg_ctx == nullptr && frame) 974 reg_ctx = frame->GetRegisterContext().get(); 975 976 if (initial_value_ptr) 977 stack.push_back(*initial_value_ptr); 978 979 lldb::offset_t offset = 0; 980 Value tmp; 981 uint32_t reg_num; 982 983 /// Insertion point for evaluating multi-piece expression. 984 uint64_t op_piece_offset = 0; 985 Value pieces; // Used for DW_OP_piece 986 987 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 988 // A generic type is "an integral type that has the size of an address and an 989 // unspecified signedness". For now, just use the signedness of the operand. 990 // TODO: Implement a real typed stack, and store the genericness of the value 991 // there. 992 auto to_generic = [&](auto v) { 993 bool is_signed = std::is_signed<decltype(v)>::value; 994 return Scalar(llvm::APSInt( 995 llvm::APInt(8 * opcodes.GetAddressByteSize(), v, is_signed), 996 !is_signed)); 997 }; 998 999 // The default kind is a memory location. This is updated by any 1000 // operation that changes this, such as DW_OP_stack_value, and reset 1001 // by composition operations like DW_OP_piece. 1002 LocationDescriptionKind dwarf4_location_description_kind = Memory; 1003 1004 while (opcodes.ValidOffset(offset)) { 1005 const lldb::offset_t op_offset = offset; 1006 const uint8_t op = opcodes.GetU8(&offset); 1007 1008 if (log && log->GetVerbose()) { 1009 size_t count = stack.size(); 1010 LLDB_LOGF(log, "Stack before operation has %" PRIu64 " values:", 1011 (uint64_t)count); 1012 for (size_t i = 0; i < count; ++i) { 1013 StreamString new_value; 1014 new_value.Printf("[%" PRIu64 "]", (uint64_t)i); 1015 stack[i].Dump(&new_value); 1016 LLDB_LOGF(log, " %s", new_value.GetData()); 1017 } 1018 LLDB_LOGF(log, "0x%8.8" PRIx64 ": %s", op_offset, 1019 DW_OP_value_to_name(op)); 1020 } 1021 1022 switch (op) { 1023 // The DW_OP_addr operation has a single operand that encodes a machine 1024 // address and whose size is the size of an address on the target machine. 1025 case DW_OP_addr: 1026 stack.push_back(Scalar(opcodes.GetAddress(&offset))); 1027 stack.back().SetValueType(Value::ValueType::FileAddress); 1028 // Convert the file address to a load address, so subsequent 1029 // DWARF operators can operate on it. 1030 if (frame) 1031 stack.back().ConvertToLoadAddress(module_sp.get(), 1032 frame->CalculateTarget().get()); 1033 break; 1034 1035 // The DW_OP_addr_sect_offset4 is used for any location expressions in 1036 // shared libraries that have a location like: 1037 // DW_OP_addr(0x1000) 1038 // If this address resides in a shared library, then this virtual address 1039 // won't make sense when it is evaluated in the context of a running 1040 // process where shared libraries have been slid. To account for this, this 1041 // new address type where we can store the section pointer and a 4 byte 1042 // offset. 1043 // case DW_OP_addr_sect_offset4: 1044 // { 1045 // result_type = eResultTypeFileAddress; 1046 // lldb::Section *sect = (lldb::Section 1047 // *)opcodes.GetMaxU64(&offset, sizeof(void *)); 1048 // lldb::addr_t sect_offset = opcodes.GetU32(&offset); 1049 // 1050 // Address so_addr (sect, sect_offset); 1051 // lldb::addr_t load_addr = so_addr.GetLoadAddress(); 1052 // if (load_addr != LLDB_INVALID_ADDRESS) 1053 // { 1054 // // We successfully resolve a file address to a load 1055 // // address. 1056 // stack.push_back(load_addr); 1057 // break; 1058 // } 1059 // else 1060 // { 1061 // // We were able 1062 // if (error_ptr) 1063 // error_ptr->SetErrorStringWithFormat ("Section %s in 1064 // %s is not currently loaded.\n", 1065 // sect->GetName().AsCString(), 1066 // sect->GetModule()->GetFileSpec().GetFilename().AsCString()); 1067 // return false; 1068 // } 1069 // } 1070 // break; 1071 1072 // OPCODE: DW_OP_deref 1073 // OPERANDS: none 1074 // DESCRIPTION: Pops the top stack entry and treats it as an address. 1075 // The value retrieved from that address is pushed. The size of the data 1076 // retrieved from the dereferenced address is the size of an address on the 1077 // target machine. 1078 case DW_OP_deref: { 1079 if (stack.empty()) { 1080 if (error_ptr) 1081 error_ptr->SetErrorString("Expression stack empty for DW_OP_deref."); 1082 return false; 1083 } 1084 Value::ValueType value_type = stack.back().GetValueType(); 1085 switch (value_type) { 1086 case Value::ValueType::HostAddress: { 1087 void *src = (void *)stack.back().GetScalar().ULongLong(); 1088 intptr_t ptr; 1089 ::memcpy(&ptr, src, sizeof(void *)); 1090 stack.back().GetScalar() = ptr; 1091 stack.back().ClearContext(); 1092 } break; 1093 case Value::ValueType::FileAddress: { 1094 auto file_addr = stack.back().GetScalar().ULongLong( 1095 LLDB_INVALID_ADDRESS); 1096 if (!module_sp) { 1097 if (error_ptr) 1098 error_ptr->SetErrorString( 1099 "need module to resolve file address for DW_OP_deref"); 1100 return false; 1101 } 1102 Address so_addr; 1103 if (!module_sp->ResolveFileAddress(file_addr, so_addr)) { 1104 if (error_ptr) 1105 error_ptr->SetErrorString( 1106 "failed to resolve file address in module"); 1107 return false; 1108 } 1109 addr_t load_Addr = so_addr.GetLoadAddress(exe_ctx->GetTargetPtr()); 1110 if (load_Addr == LLDB_INVALID_ADDRESS) { 1111 if (error_ptr) 1112 error_ptr->SetErrorString("failed to resolve load address"); 1113 return false; 1114 } 1115 stack.back().GetScalar() = load_Addr; 1116 // Fall through to load address promotion code below. 1117 } LLVM_FALLTHROUGH; 1118 case Value::ValueType::Scalar: 1119 // Promote Scalar to LoadAddress and fall through. 1120 stack.back().SetValueType(Value::ValueType::LoadAddress); 1121 LLVM_FALLTHROUGH; 1122 case Value::ValueType::LoadAddress: 1123 if (exe_ctx) { 1124 if (process) { 1125 lldb::addr_t pointer_addr = 1126 stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS); 1127 Status error; 1128 lldb::addr_t pointer_value = 1129 process->ReadPointerFromMemory(pointer_addr, error); 1130 if (pointer_value != LLDB_INVALID_ADDRESS) { 1131 if (ABISP abi_sp = process->GetABI()) 1132 pointer_value = abi_sp->FixCodeAddress(pointer_value); 1133 stack.back().GetScalar() = pointer_value; 1134 stack.back().ClearContext(); 1135 } else { 1136 if (error_ptr) 1137 error_ptr->SetErrorStringWithFormat( 1138 "Failed to dereference pointer from 0x%" PRIx64 1139 " for DW_OP_deref: %s\n", 1140 pointer_addr, error.AsCString()); 1141 return false; 1142 } 1143 } else { 1144 if (error_ptr) 1145 error_ptr->SetErrorString("NULL process for DW_OP_deref.\n"); 1146 return false; 1147 } 1148 } else { 1149 if (error_ptr) 1150 error_ptr->SetErrorString( 1151 "NULL execution context for DW_OP_deref.\n"); 1152 return false; 1153 } 1154 break; 1155 1156 case Value::ValueType::Invalid: 1157 if (error_ptr) 1158 error_ptr->SetErrorString("Invalid value type for DW_OP_deref.\n"); 1159 return false; 1160 } 1161 1162 } break; 1163 1164 // OPCODE: DW_OP_deref_size 1165 // OPERANDS: 1 1166 // 1 - uint8_t that specifies the size of the data to dereference. 1167 // DESCRIPTION: Behaves like the DW_OP_deref operation: it pops the top 1168 // stack entry and treats it as an address. The value retrieved from that 1169 // address is pushed. In the DW_OP_deref_size operation, however, the size 1170 // in bytes of the data retrieved from the dereferenced address is 1171 // specified by the single operand. This operand is a 1-byte unsigned 1172 // integral constant whose value may not be larger than the size of an 1173 // address on the target machine. The data retrieved is zero extended to 1174 // the size of an address on the target machine before being pushed on the 1175 // expression stack. 1176 case DW_OP_deref_size: { 1177 if (stack.empty()) { 1178 if (error_ptr) 1179 error_ptr->SetErrorString( 1180 "Expression stack empty for DW_OP_deref_size."); 1181 return false; 1182 } 1183 uint8_t size = opcodes.GetU8(&offset); 1184 Value::ValueType value_type = stack.back().GetValueType(); 1185 switch (value_type) { 1186 case Value::ValueType::HostAddress: { 1187 void *src = (void *)stack.back().GetScalar().ULongLong(); 1188 intptr_t ptr; 1189 ::memcpy(&ptr, src, sizeof(void *)); 1190 // I can't decide whether the size operand should apply to the bytes in 1191 // their 1192 // lldb-host endianness or the target endianness.. I doubt this'll ever 1193 // come up but I'll opt for assuming big endian regardless. 1194 switch (size) { 1195 case 1: 1196 ptr = ptr & 0xff; 1197 break; 1198 case 2: 1199 ptr = ptr & 0xffff; 1200 break; 1201 case 3: 1202 ptr = ptr & 0xffffff; 1203 break; 1204 case 4: 1205 ptr = ptr & 0xffffffff; 1206 break; 1207 // the casts are added to work around the case where intptr_t is a 32 1208 // bit quantity; 1209 // presumably we won't hit the 5..7 cases if (void*) is 32-bits in this 1210 // program. 1211 case 5: 1212 ptr = (intptr_t)ptr & 0xffffffffffULL; 1213 break; 1214 case 6: 1215 ptr = (intptr_t)ptr & 0xffffffffffffULL; 1216 break; 1217 case 7: 1218 ptr = (intptr_t)ptr & 0xffffffffffffffULL; 1219 break; 1220 default: 1221 break; 1222 } 1223 stack.back().GetScalar() = ptr; 1224 stack.back().ClearContext(); 1225 } break; 1226 case Value::ValueType::Scalar: 1227 case Value::ValueType::LoadAddress: 1228 if (exe_ctx) { 1229 if (process) { 1230 lldb::addr_t pointer_addr = 1231 stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS); 1232 uint8_t addr_bytes[sizeof(lldb::addr_t)]; 1233 Status error; 1234 if (process->ReadMemory(pointer_addr, &addr_bytes, size, error) == 1235 size) { 1236 DataExtractor addr_data(addr_bytes, sizeof(addr_bytes), 1237 process->GetByteOrder(), size); 1238 lldb::offset_t addr_data_offset = 0; 1239 switch (size) { 1240 case 1: 1241 stack.back().GetScalar() = addr_data.GetU8(&addr_data_offset); 1242 break; 1243 case 2: 1244 stack.back().GetScalar() = addr_data.GetU16(&addr_data_offset); 1245 break; 1246 case 4: 1247 stack.back().GetScalar() = addr_data.GetU32(&addr_data_offset); 1248 break; 1249 case 8: 1250 stack.back().GetScalar() = addr_data.GetU64(&addr_data_offset); 1251 break; 1252 default: 1253 stack.back().GetScalar() = 1254 addr_data.GetAddress(&addr_data_offset); 1255 } 1256 stack.back().ClearContext(); 1257 } else { 1258 if (error_ptr) 1259 error_ptr->SetErrorStringWithFormat( 1260 "Failed to dereference pointer from 0x%" PRIx64 1261 " for DW_OP_deref: %s\n", 1262 pointer_addr, error.AsCString()); 1263 return false; 1264 } 1265 } else { 1266 if (error_ptr) 1267 error_ptr->SetErrorString("NULL process for DW_OP_deref_size.\n"); 1268 return false; 1269 } 1270 } else { 1271 if (error_ptr) 1272 error_ptr->SetErrorString( 1273 "NULL execution context for DW_OP_deref_size.\n"); 1274 return false; 1275 } 1276 break; 1277 1278 case Value::ValueType::FileAddress: 1279 case Value::ValueType::Invalid: 1280 if (error_ptr) 1281 error_ptr->SetErrorString("Invalid value for DW_OP_deref_size.\n"); 1282 return false; 1283 } 1284 1285 } break; 1286 1287 // OPCODE: DW_OP_xderef_size 1288 // OPERANDS: 1 1289 // 1 - uint8_t that specifies the size of the data to dereference. 1290 // DESCRIPTION: Behaves like the DW_OP_xderef operation: the entry at 1291 // the top of the stack is treated as an address. The second stack entry is 1292 // treated as an "address space identifier" for those architectures that 1293 // support multiple address spaces. The top two stack elements are popped, 1294 // a data item is retrieved through an implementation-defined address 1295 // calculation and pushed as the new stack top. In the DW_OP_xderef_size 1296 // operation, however, the size in bytes of the data retrieved from the 1297 // dereferenced address is specified by the single operand. This operand is 1298 // a 1-byte unsigned integral constant whose value may not be larger than 1299 // the size of an address on the target machine. The data retrieved is zero 1300 // extended to the size of an address on the target machine before being 1301 // pushed on the expression stack. 1302 case DW_OP_xderef_size: 1303 if (error_ptr) 1304 error_ptr->SetErrorString("Unimplemented opcode: DW_OP_xderef_size."); 1305 return false; 1306 // OPCODE: DW_OP_xderef 1307 // OPERANDS: none 1308 // DESCRIPTION: Provides an extended dereference mechanism. The entry at 1309 // the top of the stack is treated as an address. The second stack entry is 1310 // treated as an "address space identifier" for those architectures that 1311 // support multiple address spaces. The top two stack elements are popped, 1312 // a data item is retrieved through an implementation-defined address 1313 // calculation and pushed as the new stack top. The size of the data 1314 // retrieved from the dereferenced address is the size of an address on the 1315 // target machine. 1316 case DW_OP_xderef: 1317 if (error_ptr) 1318 error_ptr->SetErrorString("Unimplemented opcode: DW_OP_xderef."); 1319 return false; 1320 1321 // All DW_OP_constXXX opcodes have a single operand as noted below: 1322 // 1323 // Opcode Operand 1 1324 // DW_OP_const1u 1-byte unsigned integer constant 1325 // DW_OP_const1s 1-byte signed integer constant 1326 // DW_OP_const2u 2-byte unsigned integer constant 1327 // DW_OP_const2s 2-byte signed integer constant 1328 // DW_OP_const4u 4-byte unsigned integer constant 1329 // DW_OP_const4s 4-byte signed integer constant 1330 // DW_OP_const8u 8-byte unsigned integer constant 1331 // DW_OP_const8s 8-byte signed integer constant 1332 // DW_OP_constu unsigned LEB128 integer constant 1333 // DW_OP_consts signed LEB128 integer constant 1334 case DW_OP_const1u: 1335 stack.push_back(to_generic(opcodes.GetU8(&offset))); 1336 break; 1337 case DW_OP_const1s: 1338 stack.push_back(to_generic((int8_t)opcodes.GetU8(&offset))); 1339 break; 1340 case DW_OP_const2u: 1341 stack.push_back(to_generic(opcodes.GetU16(&offset))); 1342 break; 1343 case DW_OP_const2s: 1344 stack.push_back(to_generic((int16_t)opcodes.GetU16(&offset))); 1345 break; 1346 case DW_OP_const4u: 1347 stack.push_back(to_generic(opcodes.GetU32(&offset))); 1348 break; 1349 case DW_OP_const4s: 1350 stack.push_back(to_generic((int32_t)opcodes.GetU32(&offset))); 1351 break; 1352 case DW_OP_const8u: 1353 stack.push_back(to_generic(opcodes.GetU64(&offset))); 1354 break; 1355 case DW_OP_const8s: 1356 stack.push_back(to_generic((int64_t)opcodes.GetU64(&offset))); 1357 break; 1358 // These should also use to_generic, but we can't do that due to a 1359 // producer-side bug in llvm. See llvm.org/pr48087. 1360 case DW_OP_constu: 1361 stack.push_back(Scalar(opcodes.GetULEB128(&offset))); 1362 break; 1363 case DW_OP_consts: 1364 stack.push_back(Scalar(opcodes.GetSLEB128(&offset))); 1365 break; 1366 1367 // OPCODE: DW_OP_dup 1368 // OPERANDS: none 1369 // DESCRIPTION: duplicates the value at the top of the stack 1370 case DW_OP_dup: 1371 if (stack.empty()) { 1372 if (error_ptr) 1373 error_ptr->SetErrorString("Expression stack empty for DW_OP_dup."); 1374 return false; 1375 } else 1376 stack.push_back(stack.back()); 1377 break; 1378 1379 // OPCODE: DW_OP_drop 1380 // OPERANDS: none 1381 // DESCRIPTION: pops the value at the top of the stack 1382 case DW_OP_drop: 1383 if (stack.empty()) { 1384 if (error_ptr) 1385 error_ptr->SetErrorString("Expression stack empty for DW_OP_drop."); 1386 return false; 1387 } else 1388 stack.pop_back(); 1389 break; 1390 1391 // OPCODE: DW_OP_over 1392 // OPERANDS: none 1393 // DESCRIPTION: Duplicates the entry currently second in the stack at 1394 // the top of the stack. 1395 case DW_OP_over: 1396 if (stack.size() < 2) { 1397 if (error_ptr) 1398 error_ptr->SetErrorString( 1399 "Expression stack needs at least 2 items for DW_OP_over."); 1400 return false; 1401 } else 1402 stack.push_back(stack[stack.size() - 2]); 1403 break; 1404 1405 // OPCODE: DW_OP_pick 1406 // OPERANDS: uint8_t index into the current stack 1407 // DESCRIPTION: The stack entry with the specified index (0 through 255, 1408 // inclusive) is pushed on the stack 1409 case DW_OP_pick: { 1410 uint8_t pick_idx = opcodes.GetU8(&offset); 1411 if (pick_idx < stack.size()) 1412 stack.push_back(stack[stack.size() - 1 - pick_idx]); 1413 else { 1414 if (error_ptr) 1415 error_ptr->SetErrorStringWithFormat( 1416 "Index %u out of range for DW_OP_pick.\n", pick_idx); 1417 return false; 1418 } 1419 } break; 1420 1421 // OPCODE: DW_OP_swap 1422 // OPERANDS: none 1423 // DESCRIPTION: swaps the top two stack entries. The entry at the top 1424 // of the stack becomes the second stack entry, and the second entry 1425 // becomes the top of the stack 1426 case DW_OP_swap: 1427 if (stack.size() < 2) { 1428 if (error_ptr) 1429 error_ptr->SetErrorString( 1430 "Expression stack needs at least 2 items for DW_OP_swap."); 1431 return false; 1432 } else { 1433 tmp = stack.back(); 1434 stack.back() = stack[stack.size() - 2]; 1435 stack[stack.size() - 2] = tmp; 1436 } 1437 break; 1438 1439 // OPCODE: DW_OP_rot 1440 // OPERANDS: none 1441 // DESCRIPTION: Rotates the first three stack entries. The entry at 1442 // the top of the stack becomes the third stack entry, the second entry 1443 // becomes the top of the stack, and the third entry becomes the second 1444 // entry. 1445 case DW_OP_rot: 1446 if (stack.size() < 3) { 1447 if (error_ptr) 1448 error_ptr->SetErrorString( 1449 "Expression stack needs at least 3 items for DW_OP_rot."); 1450 return false; 1451 } else { 1452 size_t last_idx = stack.size() - 1; 1453 Value old_top = stack[last_idx]; 1454 stack[last_idx] = stack[last_idx - 1]; 1455 stack[last_idx - 1] = stack[last_idx - 2]; 1456 stack[last_idx - 2] = old_top; 1457 } 1458 break; 1459 1460 // OPCODE: DW_OP_abs 1461 // OPERANDS: none 1462 // DESCRIPTION: pops the top stack entry, interprets it as a signed 1463 // value and pushes its absolute value. If the absolute value can not be 1464 // represented, the result is undefined. 1465 case DW_OP_abs: 1466 if (stack.empty()) { 1467 if (error_ptr) 1468 error_ptr->SetErrorString( 1469 "Expression stack needs at least 1 item for DW_OP_abs."); 1470 return false; 1471 } else if (!stack.back().ResolveValue(exe_ctx).AbsoluteValue()) { 1472 if (error_ptr) 1473 error_ptr->SetErrorString( 1474 "Failed to take the absolute value of the first stack item."); 1475 return false; 1476 } 1477 break; 1478 1479 // OPCODE: DW_OP_and 1480 // OPERANDS: none 1481 // DESCRIPTION: pops the top two stack values, performs a bitwise and 1482 // operation on the two, and pushes the result. 1483 case DW_OP_and: 1484 if (stack.size() < 2) { 1485 if (error_ptr) 1486 error_ptr->SetErrorString( 1487 "Expression stack needs at least 2 items for DW_OP_and."); 1488 return false; 1489 } else { 1490 tmp = stack.back(); 1491 stack.pop_back(); 1492 stack.back().ResolveValue(exe_ctx) = 1493 stack.back().ResolveValue(exe_ctx) & tmp.ResolveValue(exe_ctx); 1494 } 1495 break; 1496 1497 // OPCODE: DW_OP_div 1498 // OPERANDS: none 1499 // DESCRIPTION: pops the top two stack values, divides the former second 1500 // entry by the former top of the stack using signed division, and pushes 1501 // the result. 1502 case DW_OP_div: 1503 if (stack.size() < 2) { 1504 if (error_ptr) 1505 error_ptr->SetErrorString( 1506 "Expression stack needs at least 2 items for DW_OP_div."); 1507 return false; 1508 } else { 1509 tmp = stack.back(); 1510 if (tmp.ResolveValue(exe_ctx).IsZero()) { 1511 if (error_ptr) 1512 error_ptr->SetErrorString("Divide by zero."); 1513 return false; 1514 } else { 1515 stack.pop_back(); 1516 stack.back() = 1517 stack.back().ResolveValue(exe_ctx) / tmp.ResolveValue(exe_ctx); 1518 if (!stack.back().ResolveValue(exe_ctx).IsValid()) { 1519 if (error_ptr) 1520 error_ptr->SetErrorString("Divide failed."); 1521 return false; 1522 } 1523 } 1524 } 1525 break; 1526 1527 // OPCODE: DW_OP_minus 1528 // OPERANDS: none 1529 // DESCRIPTION: pops the top two stack values, subtracts the former top 1530 // of the stack from the former second entry, and pushes the result. 1531 case DW_OP_minus: 1532 if (stack.size() < 2) { 1533 if (error_ptr) 1534 error_ptr->SetErrorString( 1535 "Expression stack needs at least 2 items for DW_OP_minus."); 1536 return false; 1537 } else { 1538 tmp = stack.back(); 1539 stack.pop_back(); 1540 stack.back().ResolveValue(exe_ctx) = 1541 stack.back().ResolveValue(exe_ctx) - tmp.ResolveValue(exe_ctx); 1542 } 1543 break; 1544 1545 // OPCODE: DW_OP_mod 1546 // OPERANDS: none 1547 // DESCRIPTION: pops the top two stack values and pushes the result of 1548 // the calculation: former second stack entry modulo the former top of the 1549 // stack. 1550 case DW_OP_mod: 1551 if (stack.size() < 2) { 1552 if (error_ptr) 1553 error_ptr->SetErrorString( 1554 "Expression stack needs at least 2 items for DW_OP_mod."); 1555 return false; 1556 } else { 1557 tmp = stack.back(); 1558 stack.pop_back(); 1559 stack.back().ResolveValue(exe_ctx) = 1560 stack.back().ResolveValue(exe_ctx) % tmp.ResolveValue(exe_ctx); 1561 } 1562 break; 1563 1564 // OPCODE: DW_OP_mul 1565 // OPERANDS: none 1566 // DESCRIPTION: pops the top two stack entries, multiplies them 1567 // together, and pushes the result. 1568 case DW_OP_mul: 1569 if (stack.size() < 2) { 1570 if (error_ptr) 1571 error_ptr->SetErrorString( 1572 "Expression stack needs at least 2 items for DW_OP_mul."); 1573 return false; 1574 } else { 1575 tmp = stack.back(); 1576 stack.pop_back(); 1577 stack.back().ResolveValue(exe_ctx) = 1578 stack.back().ResolveValue(exe_ctx) * tmp.ResolveValue(exe_ctx); 1579 } 1580 break; 1581 1582 // OPCODE: DW_OP_neg 1583 // OPERANDS: none 1584 // DESCRIPTION: pops the top stack entry, and pushes its negation. 1585 case DW_OP_neg: 1586 if (stack.empty()) { 1587 if (error_ptr) 1588 error_ptr->SetErrorString( 1589 "Expression stack needs at least 1 item for DW_OP_neg."); 1590 return false; 1591 } else { 1592 if (!stack.back().ResolveValue(exe_ctx).UnaryNegate()) { 1593 if (error_ptr) 1594 error_ptr->SetErrorString("Unary negate failed."); 1595 return false; 1596 } 1597 } 1598 break; 1599 1600 // OPCODE: DW_OP_not 1601 // OPERANDS: none 1602 // DESCRIPTION: pops the top stack entry, and pushes its bitwise 1603 // complement 1604 case DW_OP_not: 1605 if (stack.empty()) { 1606 if (error_ptr) 1607 error_ptr->SetErrorString( 1608 "Expression stack needs at least 1 item for DW_OP_not."); 1609 return false; 1610 } else { 1611 if (!stack.back().ResolveValue(exe_ctx).OnesComplement()) { 1612 if (error_ptr) 1613 error_ptr->SetErrorString("Logical NOT failed."); 1614 return false; 1615 } 1616 } 1617 break; 1618 1619 // OPCODE: DW_OP_or 1620 // OPERANDS: none 1621 // DESCRIPTION: pops the top two stack entries, performs a bitwise or 1622 // operation on the two, and pushes the result. 1623 case DW_OP_or: 1624 if (stack.size() < 2) { 1625 if (error_ptr) 1626 error_ptr->SetErrorString( 1627 "Expression stack needs at least 2 items for DW_OP_or."); 1628 return false; 1629 } else { 1630 tmp = stack.back(); 1631 stack.pop_back(); 1632 stack.back().ResolveValue(exe_ctx) = 1633 stack.back().ResolveValue(exe_ctx) | tmp.ResolveValue(exe_ctx); 1634 } 1635 break; 1636 1637 // OPCODE: DW_OP_plus 1638 // OPERANDS: none 1639 // DESCRIPTION: pops the top two stack entries, adds them together, and 1640 // pushes the result. 1641 case DW_OP_plus: 1642 if (stack.size() < 2) { 1643 if (error_ptr) 1644 error_ptr->SetErrorString( 1645 "Expression stack needs at least 2 items for DW_OP_plus."); 1646 return false; 1647 } else { 1648 tmp = stack.back(); 1649 stack.pop_back(); 1650 stack.back().GetScalar() += tmp.GetScalar(); 1651 } 1652 break; 1653 1654 // OPCODE: DW_OP_plus_uconst 1655 // OPERANDS: none 1656 // DESCRIPTION: pops the top stack entry, adds it to the unsigned LEB128 1657 // constant operand and pushes the result. 1658 case DW_OP_plus_uconst: 1659 if (stack.empty()) { 1660 if (error_ptr) 1661 error_ptr->SetErrorString( 1662 "Expression stack needs at least 1 item for DW_OP_plus_uconst."); 1663 return false; 1664 } else { 1665 const uint64_t uconst_value = opcodes.GetULEB128(&offset); 1666 // Implicit conversion from a UINT to a Scalar... 1667 stack.back().GetScalar() += uconst_value; 1668 if (!stack.back().GetScalar().IsValid()) { 1669 if (error_ptr) 1670 error_ptr->SetErrorString("DW_OP_plus_uconst failed."); 1671 return false; 1672 } 1673 } 1674 break; 1675 1676 // OPCODE: DW_OP_shl 1677 // OPERANDS: none 1678 // DESCRIPTION: pops the top two stack entries, shifts the former 1679 // second entry left by the number of bits specified by the former top of 1680 // the stack, and pushes the result. 1681 case DW_OP_shl: 1682 if (stack.size() < 2) { 1683 if (error_ptr) 1684 error_ptr->SetErrorString( 1685 "Expression stack needs at least 2 items for DW_OP_shl."); 1686 return false; 1687 } else { 1688 tmp = stack.back(); 1689 stack.pop_back(); 1690 stack.back().ResolveValue(exe_ctx) <<= tmp.ResolveValue(exe_ctx); 1691 } 1692 break; 1693 1694 // OPCODE: DW_OP_shr 1695 // OPERANDS: none 1696 // DESCRIPTION: pops the top two stack entries, shifts the former second 1697 // entry right logically (filling with zero bits) by the number of bits 1698 // specified by the former top of the stack, and pushes the result. 1699 case DW_OP_shr: 1700 if (stack.size() < 2) { 1701 if (error_ptr) 1702 error_ptr->SetErrorString( 1703 "Expression stack needs at least 2 items for DW_OP_shr."); 1704 return false; 1705 } else { 1706 tmp = stack.back(); 1707 stack.pop_back(); 1708 if (!stack.back().ResolveValue(exe_ctx).ShiftRightLogical( 1709 tmp.ResolveValue(exe_ctx))) { 1710 if (error_ptr) 1711 error_ptr->SetErrorString("DW_OP_shr failed."); 1712 return false; 1713 } 1714 } 1715 break; 1716 1717 // OPCODE: DW_OP_shra 1718 // OPERANDS: none 1719 // DESCRIPTION: pops the top two stack entries, shifts the former second 1720 // entry right arithmetically (divide the magnitude by 2, keep the same 1721 // sign for the result) by the number of bits specified by the former top 1722 // of the stack, and pushes the result. 1723 case DW_OP_shra: 1724 if (stack.size() < 2) { 1725 if (error_ptr) 1726 error_ptr->SetErrorString( 1727 "Expression stack needs at least 2 items for DW_OP_shra."); 1728 return false; 1729 } else { 1730 tmp = stack.back(); 1731 stack.pop_back(); 1732 stack.back().ResolveValue(exe_ctx) >>= tmp.ResolveValue(exe_ctx); 1733 } 1734 break; 1735 1736 // OPCODE: DW_OP_xor 1737 // OPERANDS: none 1738 // DESCRIPTION: pops the top two stack entries, performs the bitwise 1739 // exclusive-or operation on the two, and pushes the result. 1740 case DW_OP_xor: 1741 if (stack.size() < 2) { 1742 if (error_ptr) 1743 error_ptr->SetErrorString( 1744 "Expression stack needs at least 2 items for DW_OP_xor."); 1745 return false; 1746 } else { 1747 tmp = stack.back(); 1748 stack.pop_back(); 1749 stack.back().ResolveValue(exe_ctx) = 1750 stack.back().ResolveValue(exe_ctx) ^ tmp.ResolveValue(exe_ctx); 1751 } 1752 break; 1753 1754 // OPCODE: DW_OP_skip 1755 // OPERANDS: int16_t 1756 // DESCRIPTION: An unconditional branch. Its single operand is a 2-byte 1757 // signed integer constant. The 2-byte constant is the number of bytes of 1758 // the DWARF expression to skip forward or backward from the current 1759 // operation, beginning after the 2-byte constant. 1760 case DW_OP_skip: { 1761 int16_t skip_offset = (int16_t)opcodes.GetU16(&offset); 1762 lldb::offset_t new_offset = offset + skip_offset; 1763 if (opcodes.ValidOffset(new_offset)) 1764 offset = new_offset; 1765 else { 1766 if (error_ptr) 1767 error_ptr->SetErrorString("Invalid opcode offset in DW_OP_skip."); 1768 return false; 1769 } 1770 } break; 1771 1772 // OPCODE: DW_OP_bra 1773 // OPERANDS: int16_t 1774 // DESCRIPTION: A conditional branch. Its single operand is a 2-byte 1775 // signed integer constant. This operation pops the top of stack. If the 1776 // value popped is not the constant 0, the 2-byte constant operand is the 1777 // number of bytes of the DWARF expression to skip forward or backward from 1778 // the current operation, beginning after the 2-byte constant. 1779 case DW_OP_bra: 1780 if (stack.empty()) { 1781 if (error_ptr) 1782 error_ptr->SetErrorString( 1783 "Expression stack needs at least 1 item for DW_OP_bra."); 1784 return false; 1785 } else { 1786 tmp = stack.back(); 1787 stack.pop_back(); 1788 int16_t bra_offset = (int16_t)opcodes.GetU16(&offset); 1789 Scalar zero(0); 1790 if (tmp.ResolveValue(exe_ctx) != zero) { 1791 lldb::offset_t new_offset = offset + bra_offset; 1792 if (opcodes.ValidOffset(new_offset)) 1793 offset = new_offset; 1794 else { 1795 if (error_ptr) 1796 error_ptr->SetErrorString("Invalid opcode offset in DW_OP_bra."); 1797 return false; 1798 } 1799 } 1800 } 1801 break; 1802 1803 // OPCODE: DW_OP_eq 1804 // OPERANDS: none 1805 // DESCRIPTION: pops the top two stack values, compares using the 1806 // equals (==) operator. 1807 // STACK RESULT: push the constant value 1 onto the stack if the result 1808 // of the operation is true or the constant value 0 if the result of the 1809 // operation is false. 1810 case DW_OP_eq: 1811 if (stack.size() < 2) { 1812 if (error_ptr) 1813 error_ptr->SetErrorString( 1814 "Expression stack needs at least 2 items for DW_OP_eq."); 1815 return false; 1816 } else { 1817 tmp = stack.back(); 1818 stack.pop_back(); 1819 stack.back().ResolveValue(exe_ctx) = 1820 stack.back().ResolveValue(exe_ctx) == tmp.ResolveValue(exe_ctx); 1821 } 1822 break; 1823 1824 // OPCODE: DW_OP_ge 1825 // OPERANDS: none 1826 // DESCRIPTION: pops the top two stack values, compares using the 1827 // greater than or equal to (>=) operator. 1828 // STACK RESULT: push the constant value 1 onto the stack if the result 1829 // of the operation is true or the constant value 0 if the result of the 1830 // operation is false. 1831 case DW_OP_ge: 1832 if (stack.size() < 2) { 1833 if (error_ptr) 1834 error_ptr->SetErrorString( 1835 "Expression stack needs at least 2 items for DW_OP_ge."); 1836 return false; 1837 } else { 1838 tmp = stack.back(); 1839 stack.pop_back(); 1840 stack.back().ResolveValue(exe_ctx) = 1841 stack.back().ResolveValue(exe_ctx) >= tmp.ResolveValue(exe_ctx); 1842 } 1843 break; 1844 1845 // OPCODE: DW_OP_gt 1846 // OPERANDS: none 1847 // DESCRIPTION: pops the top two stack values, compares using the 1848 // greater than (>) operator. 1849 // STACK RESULT: push the constant value 1 onto the stack if the result 1850 // of the operation is true or the constant value 0 if the result of the 1851 // operation is false. 1852 case DW_OP_gt: 1853 if (stack.size() < 2) { 1854 if (error_ptr) 1855 error_ptr->SetErrorString( 1856 "Expression stack needs at least 2 items for DW_OP_gt."); 1857 return false; 1858 } else { 1859 tmp = stack.back(); 1860 stack.pop_back(); 1861 stack.back().ResolveValue(exe_ctx) = 1862 stack.back().ResolveValue(exe_ctx) > tmp.ResolveValue(exe_ctx); 1863 } 1864 break; 1865 1866 // OPCODE: DW_OP_le 1867 // OPERANDS: none 1868 // DESCRIPTION: pops the top two stack values, compares using the 1869 // less than or equal to (<=) operator. 1870 // STACK RESULT: push the constant value 1 onto the stack if the result 1871 // of the operation is true or the constant value 0 if the result of the 1872 // operation is false. 1873 case DW_OP_le: 1874 if (stack.size() < 2) { 1875 if (error_ptr) 1876 error_ptr->SetErrorString( 1877 "Expression stack needs at least 2 items for DW_OP_le."); 1878 return false; 1879 } else { 1880 tmp = stack.back(); 1881 stack.pop_back(); 1882 stack.back().ResolveValue(exe_ctx) = 1883 stack.back().ResolveValue(exe_ctx) <= tmp.ResolveValue(exe_ctx); 1884 } 1885 break; 1886 1887 // OPCODE: DW_OP_lt 1888 // OPERANDS: none 1889 // DESCRIPTION: pops the top two stack values, compares using the 1890 // less than (<) operator. 1891 // STACK RESULT: push the constant value 1 onto the stack if the result 1892 // of the operation is true or the constant value 0 if the result of the 1893 // operation is false. 1894 case DW_OP_lt: 1895 if (stack.size() < 2) { 1896 if (error_ptr) 1897 error_ptr->SetErrorString( 1898 "Expression stack needs at least 2 items for DW_OP_lt."); 1899 return false; 1900 } else { 1901 tmp = stack.back(); 1902 stack.pop_back(); 1903 stack.back().ResolveValue(exe_ctx) = 1904 stack.back().ResolveValue(exe_ctx) < tmp.ResolveValue(exe_ctx); 1905 } 1906 break; 1907 1908 // OPCODE: DW_OP_ne 1909 // OPERANDS: none 1910 // DESCRIPTION: pops the top two stack values, compares using the 1911 // not equal (!=) operator. 1912 // STACK RESULT: push the constant value 1 onto the stack if the result 1913 // of the operation is true or the constant value 0 if the result of the 1914 // operation is false. 1915 case DW_OP_ne: 1916 if (stack.size() < 2) { 1917 if (error_ptr) 1918 error_ptr->SetErrorString( 1919 "Expression stack needs at least 2 items for DW_OP_ne."); 1920 return false; 1921 } else { 1922 tmp = stack.back(); 1923 stack.pop_back(); 1924 stack.back().ResolveValue(exe_ctx) = 1925 stack.back().ResolveValue(exe_ctx) != tmp.ResolveValue(exe_ctx); 1926 } 1927 break; 1928 1929 // OPCODE: DW_OP_litn 1930 // OPERANDS: none 1931 // DESCRIPTION: encode the unsigned literal values from 0 through 31. 1932 // STACK RESULT: push the unsigned literal constant value onto the top 1933 // of the stack. 1934 case DW_OP_lit0: 1935 case DW_OP_lit1: 1936 case DW_OP_lit2: 1937 case DW_OP_lit3: 1938 case DW_OP_lit4: 1939 case DW_OP_lit5: 1940 case DW_OP_lit6: 1941 case DW_OP_lit7: 1942 case DW_OP_lit8: 1943 case DW_OP_lit9: 1944 case DW_OP_lit10: 1945 case DW_OP_lit11: 1946 case DW_OP_lit12: 1947 case DW_OP_lit13: 1948 case DW_OP_lit14: 1949 case DW_OP_lit15: 1950 case DW_OP_lit16: 1951 case DW_OP_lit17: 1952 case DW_OP_lit18: 1953 case DW_OP_lit19: 1954 case DW_OP_lit20: 1955 case DW_OP_lit21: 1956 case DW_OP_lit22: 1957 case DW_OP_lit23: 1958 case DW_OP_lit24: 1959 case DW_OP_lit25: 1960 case DW_OP_lit26: 1961 case DW_OP_lit27: 1962 case DW_OP_lit28: 1963 case DW_OP_lit29: 1964 case DW_OP_lit30: 1965 case DW_OP_lit31: 1966 stack.push_back(to_generic(op - DW_OP_lit0)); 1967 break; 1968 1969 // OPCODE: DW_OP_regN 1970 // OPERANDS: none 1971 // DESCRIPTION: Push the value in register n on the top of the stack. 1972 case DW_OP_reg0: 1973 case DW_OP_reg1: 1974 case DW_OP_reg2: 1975 case DW_OP_reg3: 1976 case DW_OP_reg4: 1977 case DW_OP_reg5: 1978 case DW_OP_reg6: 1979 case DW_OP_reg7: 1980 case DW_OP_reg8: 1981 case DW_OP_reg9: 1982 case DW_OP_reg10: 1983 case DW_OP_reg11: 1984 case DW_OP_reg12: 1985 case DW_OP_reg13: 1986 case DW_OP_reg14: 1987 case DW_OP_reg15: 1988 case DW_OP_reg16: 1989 case DW_OP_reg17: 1990 case DW_OP_reg18: 1991 case DW_OP_reg19: 1992 case DW_OP_reg20: 1993 case DW_OP_reg21: 1994 case DW_OP_reg22: 1995 case DW_OP_reg23: 1996 case DW_OP_reg24: 1997 case DW_OP_reg25: 1998 case DW_OP_reg26: 1999 case DW_OP_reg27: 2000 case DW_OP_reg28: 2001 case DW_OP_reg29: 2002 case DW_OP_reg30: 2003 case DW_OP_reg31: { 2004 dwarf4_location_description_kind = Register; 2005 reg_num = op - DW_OP_reg0; 2006 2007 if (ReadRegisterValueAsScalar(reg_ctx, reg_kind, reg_num, error_ptr, tmp)) 2008 stack.push_back(tmp); 2009 else 2010 return false; 2011 } break; 2012 // OPCODE: DW_OP_regx 2013 // OPERANDS: 2014 // ULEB128 literal operand that encodes the register. 2015 // DESCRIPTION: Push the value in register on the top of the stack. 2016 case DW_OP_regx: { 2017 dwarf4_location_description_kind = Register; 2018 reg_num = opcodes.GetULEB128(&offset); 2019 if (ReadRegisterValueAsScalar(reg_ctx, reg_kind, reg_num, error_ptr, tmp)) 2020 stack.push_back(tmp); 2021 else 2022 return false; 2023 } break; 2024 2025 // OPCODE: DW_OP_bregN 2026 // OPERANDS: 2027 // SLEB128 offset from register N 2028 // DESCRIPTION: Value is in memory at the address specified by register 2029 // N plus an offset. 2030 case DW_OP_breg0: 2031 case DW_OP_breg1: 2032 case DW_OP_breg2: 2033 case DW_OP_breg3: 2034 case DW_OP_breg4: 2035 case DW_OP_breg5: 2036 case DW_OP_breg6: 2037 case DW_OP_breg7: 2038 case DW_OP_breg8: 2039 case DW_OP_breg9: 2040 case DW_OP_breg10: 2041 case DW_OP_breg11: 2042 case DW_OP_breg12: 2043 case DW_OP_breg13: 2044 case DW_OP_breg14: 2045 case DW_OP_breg15: 2046 case DW_OP_breg16: 2047 case DW_OP_breg17: 2048 case DW_OP_breg18: 2049 case DW_OP_breg19: 2050 case DW_OP_breg20: 2051 case DW_OP_breg21: 2052 case DW_OP_breg22: 2053 case DW_OP_breg23: 2054 case DW_OP_breg24: 2055 case DW_OP_breg25: 2056 case DW_OP_breg26: 2057 case DW_OP_breg27: 2058 case DW_OP_breg28: 2059 case DW_OP_breg29: 2060 case DW_OP_breg30: 2061 case DW_OP_breg31: { 2062 reg_num = op - DW_OP_breg0; 2063 2064 if (ReadRegisterValueAsScalar(reg_ctx, reg_kind, reg_num, error_ptr, 2065 tmp)) { 2066 int64_t breg_offset = opcodes.GetSLEB128(&offset); 2067 tmp.ResolveValue(exe_ctx) += (uint64_t)breg_offset; 2068 tmp.ClearContext(); 2069 stack.push_back(tmp); 2070 stack.back().SetValueType(Value::ValueType::LoadAddress); 2071 } else 2072 return false; 2073 } break; 2074 // OPCODE: DW_OP_bregx 2075 // OPERANDS: 2 2076 // ULEB128 literal operand that encodes the register. 2077 // SLEB128 offset from register N 2078 // DESCRIPTION: Value is in memory at the address specified by register 2079 // N plus an offset. 2080 case DW_OP_bregx: { 2081 reg_num = opcodes.GetULEB128(&offset); 2082 2083 if (ReadRegisterValueAsScalar(reg_ctx, reg_kind, reg_num, error_ptr, 2084 tmp)) { 2085 int64_t breg_offset = opcodes.GetSLEB128(&offset); 2086 tmp.ResolveValue(exe_ctx) += (uint64_t)breg_offset; 2087 tmp.ClearContext(); 2088 stack.push_back(tmp); 2089 stack.back().SetValueType(Value::ValueType::LoadAddress); 2090 } else 2091 return false; 2092 } break; 2093 2094 case DW_OP_fbreg: 2095 if (exe_ctx) { 2096 if (frame) { 2097 Scalar value; 2098 if (frame->GetFrameBaseValue(value, error_ptr)) { 2099 int64_t fbreg_offset = opcodes.GetSLEB128(&offset); 2100 value += fbreg_offset; 2101 stack.push_back(value); 2102 stack.back().SetValueType(Value::ValueType::LoadAddress); 2103 } else 2104 return false; 2105 } else { 2106 if (error_ptr) 2107 error_ptr->SetErrorString( 2108 "Invalid stack frame in context for DW_OP_fbreg opcode."); 2109 return false; 2110 } 2111 } else { 2112 if (error_ptr) 2113 error_ptr->SetErrorString( 2114 "NULL execution context for DW_OP_fbreg.\n"); 2115 return false; 2116 } 2117 2118 break; 2119 2120 // OPCODE: DW_OP_nop 2121 // OPERANDS: none 2122 // DESCRIPTION: A place holder. It has no effect on the location stack 2123 // or any of its values. 2124 case DW_OP_nop: 2125 break; 2126 2127 // OPCODE: DW_OP_piece 2128 // OPERANDS: 1 2129 // ULEB128: byte size of the piece 2130 // DESCRIPTION: The operand describes the size in bytes of the piece of 2131 // the object referenced by the DWARF expression whose result is at the top 2132 // of the stack. If the piece is located in a register, but does not occupy 2133 // the entire register, the placement of the piece within that register is 2134 // defined by the ABI. 2135 // 2136 // Many compilers store a single variable in sets of registers, or store a 2137 // variable partially in memory and partially in registers. DW_OP_piece 2138 // provides a way of describing how large a part of a variable a particular 2139 // DWARF expression refers to. 2140 case DW_OP_piece: { 2141 LocationDescriptionKind piece_locdesc = dwarf4_location_description_kind; 2142 // Reset for the next piece. 2143 dwarf4_location_description_kind = Memory; 2144 2145 const uint64_t piece_byte_size = opcodes.GetULEB128(&offset); 2146 2147 if (piece_byte_size > 0) { 2148 Value curr_piece; 2149 2150 if (stack.empty()) { 2151 UpdateValueTypeFromLocationDescription( 2152 log, dwarf_cu, LocationDescriptionKind::Empty); 2153 // In a multi-piece expression, this means that the current piece is 2154 // not available. Fill with zeros for now by resizing the data and 2155 // appending it 2156 curr_piece.ResizeData(piece_byte_size); 2157 // Note that "0" is not a correct value for the unknown bits. 2158 // It would be better to also return a mask of valid bits together 2159 // with the expression result, so the debugger can print missing 2160 // members as "<optimized out>" or something. 2161 ::memset(curr_piece.GetBuffer().GetBytes(), 0, piece_byte_size); 2162 pieces.AppendDataToHostBuffer(curr_piece); 2163 } else { 2164 Status error; 2165 // Extract the current piece into "curr_piece" 2166 Value curr_piece_source_value(stack.back()); 2167 stack.pop_back(); 2168 UpdateValueTypeFromLocationDescription(log, dwarf_cu, piece_locdesc, 2169 &curr_piece_source_value); 2170 2171 const Value::ValueType curr_piece_source_value_type = 2172 curr_piece_source_value.GetValueType(); 2173 switch (curr_piece_source_value_type) { 2174 case Value::ValueType::Invalid: 2175 return false; 2176 case Value::ValueType::LoadAddress: 2177 if (process) { 2178 if (curr_piece.ResizeData(piece_byte_size) == piece_byte_size) { 2179 lldb::addr_t load_addr = 2180 curr_piece_source_value.GetScalar().ULongLong( 2181 LLDB_INVALID_ADDRESS); 2182 if (process->ReadMemory( 2183 load_addr, curr_piece.GetBuffer().GetBytes(), 2184 piece_byte_size, error) != piece_byte_size) { 2185 if (error_ptr) 2186 error_ptr->SetErrorStringWithFormat( 2187 "failed to read memory DW_OP_piece(%" PRIu64 2188 ") from 0x%" PRIx64, 2189 piece_byte_size, load_addr); 2190 return false; 2191 } 2192 } else { 2193 if (error_ptr) 2194 error_ptr->SetErrorStringWithFormat( 2195 "failed to resize the piece memory buffer for " 2196 "DW_OP_piece(%" PRIu64 ")", 2197 piece_byte_size); 2198 return false; 2199 } 2200 } 2201 break; 2202 2203 case Value::ValueType::FileAddress: 2204 case Value::ValueType::HostAddress: 2205 if (error_ptr) { 2206 lldb::addr_t addr = curr_piece_source_value.GetScalar().ULongLong( 2207 LLDB_INVALID_ADDRESS); 2208 error_ptr->SetErrorStringWithFormat( 2209 "failed to read memory DW_OP_piece(%" PRIu64 2210 ") from %s address 0x%" PRIx64, 2211 piece_byte_size, curr_piece_source_value.GetValueType() == 2212 Value::ValueType::FileAddress 2213 ? "file" 2214 : "host", 2215 addr); 2216 } 2217 return false; 2218 2219 case Value::ValueType::Scalar: { 2220 uint32_t bit_size = piece_byte_size * 8; 2221 uint32_t bit_offset = 0; 2222 Scalar &scalar = curr_piece_source_value.GetScalar(); 2223 if (!scalar.ExtractBitfield( 2224 bit_size, bit_offset)) { 2225 if (error_ptr) 2226 error_ptr->SetErrorStringWithFormat( 2227 "unable to extract %" PRIu64 " bytes from a %" PRIu64 2228 " byte scalar value.", 2229 piece_byte_size, 2230 (uint64_t)curr_piece_source_value.GetScalar() 2231 .GetByteSize()); 2232 return false; 2233 } 2234 // Create curr_piece with bit_size. By default Scalar 2235 // grows to the nearest host integer type. 2236 llvm::APInt fail_value(1, 0, false); 2237 llvm::APInt ap_int = scalar.UInt128(fail_value); 2238 assert(ap_int.getBitWidth() >= bit_size); 2239 llvm::ArrayRef<uint64_t> buf{ap_int.getRawData(), 2240 ap_int.getNumWords()}; 2241 curr_piece.GetScalar() = Scalar(llvm::APInt(bit_size, buf)); 2242 } break; 2243 } 2244 2245 // Check if this is the first piece? 2246 if (op_piece_offset == 0) { 2247 // This is the first piece, we should push it back onto the stack 2248 // so subsequent pieces will be able to access this piece and add 2249 // to it. 2250 if (pieces.AppendDataToHostBuffer(curr_piece) == 0) { 2251 if (error_ptr) 2252 error_ptr->SetErrorString("failed to append piece data"); 2253 return false; 2254 } 2255 } else { 2256 // If this is the second or later piece there should be a value on 2257 // the stack. 2258 if (pieces.GetBuffer().GetByteSize() != op_piece_offset) { 2259 if (error_ptr) 2260 error_ptr->SetErrorStringWithFormat( 2261 "DW_OP_piece for offset %" PRIu64 2262 " but top of stack is of size %" PRIu64, 2263 op_piece_offset, pieces.GetBuffer().GetByteSize()); 2264 return false; 2265 } 2266 2267 if (pieces.AppendDataToHostBuffer(curr_piece) == 0) { 2268 if (error_ptr) 2269 error_ptr->SetErrorString("failed to append piece data"); 2270 return false; 2271 } 2272 } 2273 } 2274 op_piece_offset += piece_byte_size; 2275 } 2276 } break; 2277 2278 case DW_OP_bit_piece: // 0x9d ULEB128 bit size, ULEB128 bit offset (DWARF3); 2279 if (stack.size() < 1) { 2280 UpdateValueTypeFromLocationDescription(log, dwarf_cu, 2281 LocationDescriptionKind::Empty); 2282 // Reset for the next piece. 2283 dwarf4_location_description_kind = Memory; 2284 if (error_ptr) 2285 error_ptr->SetErrorString( 2286 "Expression stack needs at least 1 item for DW_OP_bit_piece."); 2287 return false; 2288 } else { 2289 UpdateValueTypeFromLocationDescription( 2290 log, dwarf_cu, dwarf4_location_description_kind, &stack.back()); 2291 // Reset for the next piece. 2292 dwarf4_location_description_kind = Memory; 2293 const uint64_t piece_bit_size = opcodes.GetULEB128(&offset); 2294 const uint64_t piece_bit_offset = opcodes.GetULEB128(&offset); 2295 switch (stack.back().GetValueType()) { 2296 case Value::ValueType::Invalid: 2297 return false; 2298 case Value::ValueType::Scalar: { 2299 if (!stack.back().GetScalar().ExtractBitfield(piece_bit_size, 2300 piece_bit_offset)) { 2301 if (error_ptr) 2302 error_ptr->SetErrorStringWithFormat( 2303 "unable to extract %" PRIu64 " bit value with %" PRIu64 2304 " bit offset from a %" PRIu64 " bit scalar value.", 2305 piece_bit_size, piece_bit_offset, 2306 (uint64_t)(stack.back().GetScalar().GetByteSize() * 8)); 2307 return false; 2308 } 2309 } break; 2310 2311 case Value::ValueType::FileAddress: 2312 case Value::ValueType::LoadAddress: 2313 case Value::ValueType::HostAddress: 2314 if (error_ptr) { 2315 error_ptr->SetErrorStringWithFormat( 2316 "unable to extract DW_OP_bit_piece(bit_size = %" PRIu64 2317 ", bit_offset = %" PRIu64 ") from an address value.", 2318 piece_bit_size, piece_bit_offset); 2319 } 2320 return false; 2321 } 2322 } 2323 break; 2324 2325 // OPCODE: DW_OP_implicit_value 2326 // OPERANDS: 2 2327 // ULEB128 size of the value block in bytes 2328 // uint8_t* block bytes encoding value in target's memory 2329 // representation 2330 // DESCRIPTION: Value is immediately stored in block in the debug info with 2331 // the memory representation of the target. 2332 case DW_OP_implicit_value: { 2333 dwarf4_location_description_kind = Implicit; 2334 2335 const uint32_t len = opcodes.GetULEB128(&offset); 2336 const void *data = opcodes.GetData(&offset, len); 2337 2338 if (!data) { 2339 LLDB_LOG(log, "Evaluate_DW_OP_implicit_value: could not be read data"); 2340 LLDB_ERRORF(error_ptr, "Could not evaluate %s.", 2341 DW_OP_value_to_name(op)); 2342 return false; 2343 } 2344 2345 Value result(data, len); 2346 stack.push_back(result); 2347 break; 2348 } 2349 2350 case DW_OP_implicit_pointer: { 2351 dwarf4_location_description_kind = Implicit; 2352 LLDB_ERRORF(error_ptr, "Could not evaluate %s.", DW_OP_value_to_name(op)); 2353 return false; 2354 } 2355 2356 // OPCODE: DW_OP_push_object_address 2357 // OPERANDS: none 2358 // DESCRIPTION: Pushes the address of the object currently being 2359 // evaluated as part of evaluation of a user presented expression. This 2360 // object may correspond to an independent variable described by its own 2361 // DIE or it may be a component of an array, structure, or class whose 2362 // address has been dynamically determined by an earlier step during user 2363 // expression evaluation. 2364 case DW_OP_push_object_address: 2365 if (object_address_ptr) 2366 stack.push_back(*object_address_ptr); 2367 else { 2368 if (error_ptr) 2369 error_ptr->SetErrorString("DW_OP_push_object_address used without " 2370 "specifying an object address"); 2371 return false; 2372 } 2373 break; 2374 2375 // OPCODE: DW_OP_call2 2376 // OPERANDS: 2377 // uint16_t compile unit relative offset of a DIE 2378 // DESCRIPTION: Performs subroutine calls during evaluation 2379 // of a DWARF expression. The operand is the 2-byte unsigned offset of a 2380 // debugging information entry in the current compilation unit. 2381 // 2382 // Operand interpretation is exactly like that for DW_FORM_ref2. 2383 // 2384 // This operation transfers control of DWARF expression evaluation to the 2385 // DW_AT_location attribute of the referenced DIE. If there is no such 2386 // attribute, then there is no effect. Execution of the DWARF expression of 2387 // a DW_AT_location attribute may add to and/or remove from values on the 2388 // stack. Execution returns to the point following the call when the end of 2389 // the attribute is reached. Values on the stack at the time of the call 2390 // may be used as parameters by the called expression and values left on 2391 // the stack by the called expression may be used as return values by prior 2392 // agreement between the calling and called expressions. 2393 case DW_OP_call2: 2394 if (error_ptr) 2395 error_ptr->SetErrorString("Unimplemented opcode DW_OP_call2."); 2396 return false; 2397 // OPCODE: DW_OP_call4 2398 // OPERANDS: 1 2399 // uint32_t compile unit relative offset of a DIE 2400 // DESCRIPTION: Performs a subroutine call during evaluation of a DWARF 2401 // expression. For DW_OP_call4, the operand is a 4-byte unsigned offset of 2402 // a debugging information entry in the current compilation unit. 2403 // 2404 // Operand interpretation DW_OP_call4 is exactly like that for 2405 // DW_FORM_ref4. 2406 // 2407 // This operation transfers control of DWARF expression evaluation to the 2408 // DW_AT_location attribute of the referenced DIE. If there is no such 2409 // attribute, then there is no effect. Execution of the DWARF expression of 2410 // a DW_AT_location attribute may add to and/or remove from values on the 2411 // stack. Execution returns to the point following the call when the end of 2412 // the attribute is reached. Values on the stack at the time of the call 2413 // may be used as parameters by the called expression and values left on 2414 // the stack by the called expression may be used as return values by prior 2415 // agreement between the calling and called expressions. 2416 case DW_OP_call4: 2417 if (error_ptr) 2418 error_ptr->SetErrorString("Unimplemented opcode DW_OP_call4."); 2419 return false; 2420 2421 // OPCODE: DW_OP_stack_value 2422 // OPERANDS: None 2423 // DESCRIPTION: Specifies that the object does not exist in memory but 2424 // rather is a constant value. The value from the top of the stack is the 2425 // value to be used. This is the actual object value and not the location. 2426 case DW_OP_stack_value: 2427 dwarf4_location_description_kind = Implicit; 2428 if (stack.empty()) { 2429 if (error_ptr) 2430 error_ptr->SetErrorString( 2431 "Expression stack needs at least 1 item for DW_OP_stack_value."); 2432 return false; 2433 } 2434 stack.back().SetValueType(Value::ValueType::Scalar); 2435 break; 2436 2437 // OPCODE: DW_OP_convert 2438 // OPERANDS: 1 2439 // A ULEB128 that is either a DIE offset of a 2440 // DW_TAG_base_type or 0 for the generic (pointer-sized) type. 2441 // 2442 // DESCRIPTION: Pop the top stack element, convert it to a 2443 // different type, and push the result. 2444 case DW_OP_convert: { 2445 if (stack.size() < 1) { 2446 if (error_ptr) 2447 error_ptr->SetErrorString( 2448 "Expression stack needs at least 1 item for DW_OP_convert."); 2449 return false; 2450 } 2451 const uint64_t die_offset = opcodes.GetULEB128(&offset); 2452 uint64_t bit_size; 2453 bool sign; 2454 if (die_offset == 0) { 2455 // The generic type has the size of an address on the target 2456 // machine and an unspecified signedness. Scalar has no 2457 // "unspecified signedness", so we use unsigned types. 2458 if (!module_sp) { 2459 if (error_ptr) 2460 error_ptr->SetErrorString("No module"); 2461 return false; 2462 } 2463 sign = false; 2464 bit_size = module_sp->GetArchitecture().GetAddressByteSize() * 8; 2465 if (!bit_size) { 2466 if (error_ptr) 2467 error_ptr->SetErrorString("unspecified architecture"); 2468 return false; 2469 } 2470 } else { 2471 // Retrieve the type DIE that the value is being converted to. 2472 // FIXME: the constness has annoying ripple effects. 2473 DWARFDIE die = const_cast<DWARFUnit *>(dwarf_cu)->GetDIE(die_offset); 2474 if (!die) { 2475 if (error_ptr) 2476 error_ptr->SetErrorString("Cannot resolve DW_OP_convert type DIE"); 2477 return false; 2478 } 2479 uint64_t encoding = 2480 die.GetAttributeValueAsUnsigned(DW_AT_encoding, DW_ATE_hi_user); 2481 bit_size = die.GetAttributeValueAsUnsigned(DW_AT_byte_size, 0) * 8; 2482 if (!bit_size) 2483 bit_size = die.GetAttributeValueAsUnsigned(DW_AT_bit_size, 0); 2484 if (!bit_size) { 2485 if (error_ptr) 2486 error_ptr->SetErrorString("Unsupported type size in DW_OP_convert"); 2487 return false; 2488 } 2489 switch (encoding) { 2490 case DW_ATE_signed: 2491 case DW_ATE_signed_char: 2492 sign = true; 2493 break; 2494 case DW_ATE_unsigned: 2495 case DW_ATE_unsigned_char: 2496 sign = false; 2497 break; 2498 default: 2499 if (error_ptr) 2500 error_ptr->SetErrorString("Unsupported encoding in DW_OP_convert"); 2501 return false; 2502 } 2503 } 2504 Scalar &top = stack.back().ResolveValue(exe_ctx); 2505 top.TruncOrExtendTo(bit_size, sign); 2506 break; 2507 } 2508 2509 // OPCODE: DW_OP_call_frame_cfa 2510 // OPERANDS: None 2511 // DESCRIPTION: Specifies a DWARF expression that pushes the value of 2512 // the canonical frame address consistent with the call frame information 2513 // located in .debug_frame (or in the FDEs of the eh_frame section). 2514 case DW_OP_call_frame_cfa: 2515 if (frame) { 2516 // Note that we don't have to parse FDEs because this DWARF expression 2517 // is commonly evaluated with a valid stack frame. 2518 StackID id = frame->GetStackID(); 2519 addr_t cfa = id.GetCallFrameAddress(); 2520 if (cfa != LLDB_INVALID_ADDRESS) { 2521 stack.push_back(Scalar(cfa)); 2522 stack.back().SetValueType(Value::ValueType::LoadAddress); 2523 } else if (error_ptr) 2524 error_ptr->SetErrorString("Stack frame does not include a canonical " 2525 "frame address for DW_OP_call_frame_cfa " 2526 "opcode."); 2527 } else { 2528 if (error_ptr) 2529 error_ptr->SetErrorString("Invalid stack frame in context for " 2530 "DW_OP_call_frame_cfa opcode."); 2531 return false; 2532 } 2533 break; 2534 2535 // OPCODE: DW_OP_form_tls_address (or the old pre-DWARFv3 vendor extension 2536 // opcode, DW_OP_GNU_push_tls_address) 2537 // OPERANDS: none 2538 // DESCRIPTION: Pops a TLS offset from the stack, converts it to 2539 // an address in the current thread's thread-local storage block, and 2540 // pushes it on the stack. 2541 case DW_OP_form_tls_address: 2542 case DW_OP_GNU_push_tls_address: { 2543 if (stack.size() < 1) { 2544 if (error_ptr) { 2545 if (op == DW_OP_form_tls_address) 2546 error_ptr->SetErrorString( 2547 "DW_OP_form_tls_address needs an argument."); 2548 else 2549 error_ptr->SetErrorString( 2550 "DW_OP_GNU_push_tls_address needs an argument."); 2551 } 2552 return false; 2553 } 2554 2555 if (!exe_ctx || !module_sp) { 2556 if (error_ptr) 2557 error_ptr->SetErrorString("No context to evaluate TLS within."); 2558 return false; 2559 } 2560 2561 Thread *thread = exe_ctx->GetThreadPtr(); 2562 if (!thread) { 2563 if (error_ptr) 2564 error_ptr->SetErrorString("No thread to evaluate TLS within."); 2565 return false; 2566 } 2567 2568 // Lookup the TLS block address for this thread and module. 2569 const addr_t tls_file_addr = 2570 stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS); 2571 const addr_t tls_load_addr = 2572 thread->GetThreadLocalData(module_sp, tls_file_addr); 2573 2574 if (tls_load_addr == LLDB_INVALID_ADDRESS) { 2575 if (error_ptr) 2576 error_ptr->SetErrorString( 2577 "No TLS data currently exists for this thread."); 2578 return false; 2579 } 2580 2581 stack.back().GetScalar() = tls_load_addr; 2582 stack.back().SetValueType(Value::ValueType::LoadAddress); 2583 } break; 2584 2585 // OPCODE: DW_OP_addrx (DW_OP_GNU_addr_index is the legacy name.) 2586 // OPERANDS: 1 2587 // ULEB128: index to the .debug_addr section 2588 // DESCRIPTION: Pushes an address to the stack from the .debug_addr 2589 // section with the base address specified by the DW_AT_addr_base attribute 2590 // and the 0 based index is the ULEB128 encoded index. 2591 case DW_OP_addrx: 2592 case DW_OP_GNU_addr_index: { 2593 if (!dwarf_cu) { 2594 if (error_ptr) 2595 error_ptr->SetErrorString("DW_OP_GNU_addr_index found without a " 2596 "compile unit being specified"); 2597 return false; 2598 } 2599 uint64_t index = opcodes.GetULEB128(&offset); 2600 lldb::addr_t value = ReadAddressFromDebugAddrSection(dwarf_cu, index); 2601 stack.push_back(Scalar(value)); 2602 stack.back().SetValueType(Value::ValueType::FileAddress); 2603 } break; 2604 2605 // OPCODE: DW_OP_GNU_const_index 2606 // OPERANDS: 1 2607 // ULEB128: index to the .debug_addr section 2608 // DESCRIPTION: Pushes an constant with the size of a machine address to 2609 // the stack from the .debug_addr section with the base address specified 2610 // by the DW_AT_addr_base attribute and the 0 based index is the ULEB128 2611 // encoded index. 2612 case DW_OP_GNU_const_index: { 2613 if (!dwarf_cu) { 2614 if (error_ptr) 2615 error_ptr->SetErrorString("DW_OP_GNU_const_index found without a " 2616 "compile unit being specified"); 2617 return false; 2618 } 2619 uint64_t index = opcodes.GetULEB128(&offset); 2620 lldb::addr_t value = ReadAddressFromDebugAddrSection(dwarf_cu, index); 2621 stack.push_back(Scalar(value)); 2622 } break; 2623 2624 case DW_OP_GNU_entry_value: 2625 case DW_OP_entry_value: { 2626 if (!Evaluate_DW_OP_entry_value(stack, exe_ctx, reg_ctx, opcodes, offset, 2627 error_ptr, log)) { 2628 LLDB_ERRORF(error_ptr, "Could not evaluate %s.", 2629 DW_OP_value_to_name(op)); 2630 return false; 2631 } 2632 break; 2633 } 2634 2635 default: 2636 if (error_ptr) 2637 error_ptr->SetErrorStringWithFormatv( 2638 "Unhandled opcode {0} in DWARFExpression", LocationAtom(op)); 2639 return false; 2640 } 2641 } 2642 2643 if (stack.empty()) { 2644 // Nothing on the stack, check if we created a piece value from DW_OP_piece 2645 // or DW_OP_bit_piece opcodes 2646 if (pieces.GetBuffer().GetByteSize()) { 2647 result = pieces; 2648 return true; 2649 } 2650 if (error_ptr) 2651 error_ptr->SetErrorString("Stack empty after evaluation."); 2652 return false; 2653 } 2654 2655 UpdateValueTypeFromLocationDescription( 2656 log, dwarf_cu, dwarf4_location_description_kind, &stack.back()); 2657 2658 if (log && log->GetVerbose()) { 2659 size_t count = stack.size(); 2660 LLDB_LOGF(log, 2661 "Stack after operation has %" PRIu64 " values:", (uint64_t)count); 2662 for (size_t i = 0; i < count; ++i) { 2663 StreamString new_value; 2664 new_value.Printf("[%" PRIu64 "]", (uint64_t)i); 2665 stack[i].Dump(&new_value); 2666 LLDB_LOGF(log, " %s", new_value.GetData()); 2667 } 2668 } 2669 result = stack.back(); 2670 return true; // Return true on success 2671 } 2672 2673 static DataExtractor ToDataExtractor(const llvm::DWARFLocationExpression &loc, 2674 ByteOrder byte_order, uint32_t addr_size) { 2675 auto buffer_sp = 2676 std::make_shared<DataBufferHeap>(loc.Expr.data(), loc.Expr.size()); 2677 return DataExtractor(buffer_sp, byte_order, addr_size); 2678 } 2679 2680 llvm::Optional<DataExtractor> 2681 DWARFExpression::GetLocationExpression(addr_t load_function_start, 2682 addr_t addr) const { 2683 Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS); 2684 2685 std::unique_ptr<llvm::DWARFLocationTable> loctable_up = 2686 m_dwarf_cu->GetLocationTable(m_data); 2687 llvm::Optional<DataExtractor> result; 2688 uint64_t offset = 0; 2689 auto lookup_addr = 2690 [&](uint32_t index) -> llvm::Optional<llvm::object::SectionedAddress> { 2691 addr_t address = ReadAddressFromDebugAddrSection(m_dwarf_cu, index); 2692 if (address == LLDB_INVALID_ADDRESS) 2693 return llvm::None; 2694 return llvm::object::SectionedAddress{address}; 2695 }; 2696 auto process_list = [&](llvm::Expected<llvm::DWARFLocationExpression> loc) { 2697 if (!loc) { 2698 LLDB_LOG_ERROR(log, loc.takeError(), "{0}"); 2699 return true; 2700 } 2701 if (loc->Range) { 2702 // This relocates low_pc and high_pc by adding the difference between the 2703 // function file address, and the actual address it is loaded in memory. 2704 addr_t slide = load_function_start - m_loclist_addresses->func_file_addr; 2705 loc->Range->LowPC += slide; 2706 loc->Range->HighPC += slide; 2707 2708 if (loc->Range->LowPC <= addr && addr < loc->Range->HighPC) 2709 result = ToDataExtractor(*loc, m_data.GetByteOrder(), 2710 m_data.GetAddressByteSize()); 2711 } 2712 return !result; 2713 }; 2714 llvm::Error E = loctable_up->visitAbsoluteLocationList( 2715 offset, llvm::object::SectionedAddress{m_loclist_addresses->cu_file_addr}, 2716 lookup_addr, process_list); 2717 if (E) 2718 LLDB_LOG_ERROR(log, std::move(E), "{0}"); 2719 return result; 2720 } 2721 2722 bool DWARFExpression::MatchesOperand(StackFrame &frame, 2723 const Instruction::Operand &operand) { 2724 using namespace OperandMatchers; 2725 2726 RegisterContextSP reg_ctx_sp = frame.GetRegisterContext(); 2727 if (!reg_ctx_sp) { 2728 return false; 2729 } 2730 2731 DataExtractor opcodes; 2732 if (IsLocationList()) { 2733 SymbolContext sc = frame.GetSymbolContext(eSymbolContextFunction); 2734 if (!sc.function) 2735 return false; 2736 2737 addr_t load_function_start = 2738 sc.function->GetAddressRange().GetBaseAddress().GetFileAddress(); 2739 if (load_function_start == LLDB_INVALID_ADDRESS) 2740 return false; 2741 2742 addr_t pc = frame.GetFrameCodeAddress().GetLoadAddress( 2743 frame.CalculateTarget().get()); 2744 2745 if (llvm::Optional<DataExtractor> expr = GetLocationExpression(load_function_start, pc)) 2746 opcodes = std::move(*expr); 2747 else 2748 return false; 2749 } else 2750 opcodes = m_data; 2751 2752 2753 lldb::offset_t op_offset = 0; 2754 uint8_t opcode = opcodes.GetU8(&op_offset); 2755 2756 if (opcode == DW_OP_fbreg) { 2757 int64_t offset = opcodes.GetSLEB128(&op_offset); 2758 2759 DWARFExpression *fb_expr = frame.GetFrameBaseExpression(nullptr); 2760 if (!fb_expr) { 2761 return false; 2762 } 2763 2764 auto recurse = [&frame, fb_expr](const Instruction::Operand &child) { 2765 return fb_expr->MatchesOperand(frame, child); 2766 }; 2767 2768 if (!offset && 2769 MatchUnaryOp(MatchOpType(Instruction::Operand::Type::Dereference), 2770 recurse)(operand)) { 2771 return true; 2772 } 2773 2774 return MatchUnaryOp( 2775 MatchOpType(Instruction::Operand::Type::Dereference), 2776 MatchBinaryOp(MatchOpType(Instruction::Operand::Type::Sum), 2777 MatchImmOp(offset), recurse))(operand); 2778 } 2779 2780 bool dereference = false; 2781 const RegisterInfo *reg = nullptr; 2782 int64_t offset = 0; 2783 2784 if (opcode >= DW_OP_reg0 && opcode <= DW_OP_reg31) { 2785 reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, opcode - DW_OP_reg0); 2786 } else if (opcode >= DW_OP_breg0 && opcode <= DW_OP_breg31) { 2787 offset = opcodes.GetSLEB128(&op_offset); 2788 reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, opcode - DW_OP_breg0); 2789 } else if (opcode == DW_OP_regx) { 2790 uint32_t reg_num = static_cast<uint32_t>(opcodes.GetULEB128(&op_offset)); 2791 reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, reg_num); 2792 } else if (opcode == DW_OP_bregx) { 2793 uint32_t reg_num = static_cast<uint32_t>(opcodes.GetULEB128(&op_offset)); 2794 offset = opcodes.GetSLEB128(&op_offset); 2795 reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, reg_num); 2796 } else { 2797 return false; 2798 } 2799 2800 if (!reg) { 2801 return false; 2802 } 2803 2804 if (dereference) { 2805 if (!offset && 2806 MatchUnaryOp(MatchOpType(Instruction::Operand::Type::Dereference), 2807 MatchRegOp(*reg))(operand)) { 2808 return true; 2809 } 2810 2811 return MatchUnaryOp( 2812 MatchOpType(Instruction::Operand::Type::Dereference), 2813 MatchBinaryOp(MatchOpType(Instruction::Operand::Type::Sum), 2814 MatchRegOp(*reg), 2815 MatchImmOp(offset)))(operand); 2816 } else { 2817 return MatchRegOp(*reg)(operand); 2818 } 2819 } 2820 2821