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