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