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