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