DWARFExpression.cpp revision 269024
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 if (stack.empty()) 1433 { 1434 if (error_ptr) 1435 error_ptr->SetErrorString("Expression stack empty for DW_OP_deref."); 1436 return false; 1437 } 1438 Value::ValueType value_type = stack.back().GetValueType(); 1439 switch (value_type) 1440 { 1441 case Value::eValueTypeHostAddress: 1442 { 1443 void *src = (void *)stack.back().GetScalar().ULongLong(); 1444 intptr_t ptr; 1445 ::memcpy (&ptr, src, sizeof(void *)); 1446 stack.back().GetScalar() = ptr; 1447 stack.back().ClearContext(); 1448 } 1449 break; 1450 case Value::eValueTypeLoadAddress: 1451 if (exe_ctx) 1452 { 1453 if (process) 1454 { 1455 lldb::addr_t pointer_addr = stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS); 1456 uint8_t addr_bytes[sizeof(lldb::addr_t)]; 1457 uint32_t addr_size = process->GetAddressByteSize(); 1458 Error error; 1459 if (process->ReadMemory(pointer_addr, &addr_bytes, addr_size, error) == addr_size) 1460 { 1461 DataExtractor addr_data(addr_bytes, sizeof(addr_bytes), process->GetByteOrder(), addr_size); 1462 lldb::offset_t addr_data_offset = 0; 1463 stack.back().GetScalar() = addr_data.GetPointer(&addr_data_offset); 1464 stack.back().ClearContext(); 1465 } 1466 else 1467 { 1468 if (error_ptr) 1469 error_ptr->SetErrorStringWithFormat ("Failed to dereference pointer from 0x%" PRIx64 " for DW_OP_deref: %s\n", 1470 pointer_addr, 1471 error.AsCString()); 1472 return false; 1473 } 1474 } 1475 else 1476 { 1477 if (error_ptr) 1478 error_ptr->SetErrorStringWithFormat ("NULL process for DW_OP_deref.\n"); 1479 return false; 1480 } 1481 } 1482 else 1483 { 1484 if (error_ptr) 1485 error_ptr->SetErrorStringWithFormat ("NULL execution context for DW_OP_deref.\n"); 1486 return false; 1487 } 1488 break; 1489 1490 default: 1491 break; 1492 } 1493 1494 } 1495 break; 1496 1497 //---------------------------------------------------------------------- 1498 // OPCODE: DW_OP_deref_size 1499 // OPERANDS: 1 1500 // 1 - uint8_t that specifies the size of the data to dereference. 1501 // DESCRIPTION: Behaves like the DW_OP_deref operation: it pops the top 1502 // stack entry and treats it as an address. The value retrieved from that 1503 // address is pushed. In the DW_OP_deref_size operation, however, the 1504 // size in bytes of the data retrieved from the dereferenced address is 1505 // specified by the single operand. This operand is a 1-byte unsigned 1506 // integral constant whose value may not be larger than the size of an 1507 // address on the target machine. The data retrieved is zero extended 1508 // to the size of an address on the target machine before being pushed 1509 // on the expression stack. 1510 //---------------------------------------------------------------------- 1511 case DW_OP_deref_size: 1512 { 1513 if (stack.empty()) 1514 { 1515 if (error_ptr) 1516 error_ptr->SetErrorString("Expression stack empty for DW_OP_deref_size."); 1517 return false; 1518 } 1519 uint8_t size = opcodes.GetU8(&offset); 1520 Value::ValueType value_type = stack.back().GetValueType(); 1521 switch (value_type) 1522 { 1523 case Value::eValueTypeHostAddress: 1524 { 1525 void *src = (void *)stack.back().GetScalar().ULongLong(); 1526 intptr_t ptr; 1527 ::memcpy (&ptr, src, sizeof(void *)); 1528 // I can't decide whether the size operand should apply to the bytes in their 1529 // lldb-host endianness or the target endianness.. I doubt this'll ever come up 1530 // but I'll opt for assuming big endian regardless. 1531 switch (size) 1532 { 1533 case 1: ptr = ptr & 0xff; break; 1534 case 2: ptr = ptr & 0xffff; break; 1535 case 3: ptr = ptr & 0xffffff; break; 1536 case 4: ptr = ptr & 0xffffffff; break; 1537 // the casts are added to work around the case where intptr_t is a 32 bit quantity; 1538 // presumably we won't hit the 5..7 cases if (void*) is 32-bits in this program. 1539 case 5: ptr = (intptr_t) ptr & 0xffffffffffULL; break; 1540 case 6: ptr = (intptr_t) ptr & 0xffffffffffffULL; break; 1541 case 7: ptr = (intptr_t) ptr & 0xffffffffffffffULL; break; 1542 default: break; 1543 } 1544 stack.back().GetScalar() = ptr; 1545 stack.back().ClearContext(); 1546 } 1547 break; 1548 case Value::eValueTypeLoadAddress: 1549 if (exe_ctx) 1550 { 1551 if (process) 1552 { 1553 lldb::addr_t pointer_addr = stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS); 1554 uint8_t addr_bytes[sizeof(lldb::addr_t)]; 1555 Error error; 1556 if (process->ReadMemory(pointer_addr, &addr_bytes, size, error) == size) 1557 { 1558 DataExtractor addr_data(addr_bytes, sizeof(addr_bytes), process->GetByteOrder(), size); 1559 lldb::offset_t addr_data_offset = 0; 1560 switch (size) 1561 { 1562 case 1: stack.back().GetScalar() = addr_data.GetU8(&addr_data_offset); break; 1563 case 2: stack.back().GetScalar() = addr_data.GetU16(&addr_data_offset); break; 1564 case 4: stack.back().GetScalar() = addr_data.GetU32(&addr_data_offset); break; 1565 case 8: stack.back().GetScalar() = addr_data.GetU64(&addr_data_offset); break; 1566 default: stack.back().GetScalar() = addr_data.GetPointer(&addr_data_offset); 1567 } 1568 stack.back().ClearContext(); 1569 } 1570 else 1571 { 1572 if (error_ptr) 1573 error_ptr->SetErrorStringWithFormat ("Failed to dereference pointer from 0x%" PRIx64 " for DW_OP_deref: %s\n", 1574 pointer_addr, 1575 error.AsCString()); 1576 return false; 1577 } 1578 } 1579 else 1580 { 1581 if (error_ptr) 1582 error_ptr->SetErrorStringWithFormat ("NULL process for DW_OP_deref.\n"); 1583 return false; 1584 } 1585 } 1586 else 1587 { 1588 if (error_ptr) 1589 error_ptr->SetErrorStringWithFormat ("NULL execution context for DW_OP_deref.\n"); 1590 return false; 1591 } 1592 break; 1593 1594 default: 1595 break; 1596 } 1597 1598 } 1599 break; 1600 1601 //---------------------------------------------------------------------- 1602 // OPCODE: DW_OP_xderef_size 1603 // OPERANDS: 1 1604 // 1 - uint8_t that specifies the size of the data to dereference. 1605 // DESCRIPTION: Behaves like the DW_OP_xderef operation: the entry at 1606 // the top of the stack is treated as an address. The second stack 1607 // entry is treated as an "address space identifier" for those 1608 // architectures that support multiple address spaces. The top two 1609 // stack elements are popped, a data item is retrieved through an 1610 // implementation-defined address calculation and pushed as the new 1611 // stack top. In the DW_OP_xderef_size operation, however, the size in 1612 // bytes of the data retrieved from the dereferenced address is 1613 // specified by the single operand. This operand is a 1-byte unsigned 1614 // integral constant whose value may not be larger than the size of an 1615 // address on the target machine. The data retrieved is zero extended 1616 // to the size of an address on the target machine before being pushed 1617 // on the expression stack. 1618 //---------------------------------------------------------------------- 1619 case DW_OP_xderef_size: 1620 if (error_ptr) 1621 error_ptr->SetErrorString("Unimplemented opcode: DW_OP_xderef_size."); 1622 return false; 1623 //---------------------------------------------------------------------- 1624 // OPCODE: DW_OP_xderef 1625 // OPERANDS: none 1626 // DESCRIPTION: Provides an extended dereference mechanism. The entry at 1627 // the top of the stack is treated as an address. The second stack entry 1628 // is treated as an "address space identifier" for those architectures 1629 // that support multiple address spaces. The top two stack elements are 1630 // popped, a data item is retrieved through an implementation-defined 1631 // address calculation and pushed as the new stack top. The size of the 1632 // data retrieved from the dereferenced address is the size of an address 1633 // on the target machine. 1634 //---------------------------------------------------------------------- 1635 case DW_OP_xderef: 1636 if (error_ptr) 1637 error_ptr->SetErrorString("Unimplemented opcode: DW_OP_xderef."); 1638 return false; 1639 1640 //---------------------------------------------------------------------- 1641 // All DW_OP_constXXX opcodes have a single operand as noted below: 1642 // 1643 // Opcode Operand 1 1644 // --------------- ---------------------------------------------------- 1645 // DW_OP_const1u 1-byte unsigned integer constant 1646 // DW_OP_const1s 1-byte signed integer constant 1647 // DW_OP_const2u 2-byte unsigned integer constant 1648 // DW_OP_const2s 2-byte signed integer constant 1649 // DW_OP_const4u 4-byte unsigned integer constant 1650 // DW_OP_const4s 4-byte signed integer constant 1651 // DW_OP_const8u 8-byte unsigned integer constant 1652 // DW_OP_const8s 8-byte signed integer constant 1653 // DW_OP_constu unsigned LEB128 integer constant 1654 // DW_OP_consts signed LEB128 integer constant 1655 //---------------------------------------------------------------------- 1656 case DW_OP_const1u : stack.push_back(Scalar(( uint8_t)opcodes.GetU8 (&offset))); break; 1657 case DW_OP_const1s : stack.push_back(Scalar(( int8_t)opcodes.GetU8 (&offset))); break; 1658 case DW_OP_const2u : stack.push_back(Scalar((uint16_t)opcodes.GetU16 (&offset))); break; 1659 case DW_OP_const2s : stack.push_back(Scalar(( int16_t)opcodes.GetU16 (&offset))); break; 1660 case DW_OP_const4u : stack.push_back(Scalar((uint32_t)opcodes.GetU32 (&offset))); break; 1661 case DW_OP_const4s : stack.push_back(Scalar(( int32_t)opcodes.GetU32 (&offset))); break; 1662 case DW_OP_const8u : stack.push_back(Scalar((uint64_t)opcodes.GetU64 (&offset))); break; 1663 case DW_OP_const8s : stack.push_back(Scalar(( int64_t)opcodes.GetU64 (&offset))); break; 1664 case DW_OP_constu : stack.push_back(Scalar(opcodes.GetULEB128 (&offset))); break; 1665 case DW_OP_consts : stack.push_back(Scalar(opcodes.GetSLEB128 (&offset))); break; 1666 1667 //---------------------------------------------------------------------- 1668 // OPCODE: DW_OP_dup 1669 // OPERANDS: none 1670 // DESCRIPTION: duplicates the value at the top of the stack 1671 //---------------------------------------------------------------------- 1672 case DW_OP_dup: 1673 if (stack.empty()) 1674 { 1675 if (error_ptr) 1676 error_ptr->SetErrorString("Expression stack empty for DW_OP_dup."); 1677 return false; 1678 } 1679 else 1680 stack.push_back(stack.back()); 1681 break; 1682 1683 //---------------------------------------------------------------------- 1684 // OPCODE: DW_OP_drop 1685 // OPERANDS: none 1686 // DESCRIPTION: pops the value at the top of the stack 1687 //---------------------------------------------------------------------- 1688 case DW_OP_drop: 1689 if (stack.empty()) 1690 { 1691 if (error_ptr) 1692 error_ptr->SetErrorString("Expression stack empty for DW_OP_drop."); 1693 return false; 1694 } 1695 else 1696 stack.pop_back(); 1697 break; 1698 1699 //---------------------------------------------------------------------- 1700 // OPCODE: DW_OP_over 1701 // OPERANDS: none 1702 // DESCRIPTION: Duplicates the entry currently second in the stack at 1703 // the top of the stack. 1704 //---------------------------------------------------------------------- 1705 case DW_OP_over: 1706 if (stack.size() < 2) 1707 { 1708 if (error_ptr) 1709 error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_over."); 1710 return false; 1711 } 1712 else 1713 stack.push_back(stack[stack.size() - 2]); 1714 break; 1715 1716 1717 //---------------------------------------------------------------------- 1718 // OPCODE: DW_OP_pick 1719 // OPERANDS: uint8_t index into the current stack 1720 // DESCRIPTION: The stack entry with the specified index (0 through 255, 1721 // inclusive) is pushed on the stack 1722 //---------------------------------------------------------------------- 1723 case DW_OP_pick: 1724 { 1725 uint8_t pick_idx = opcodes.GetU8(&offset); 1726 if (pick_idx < stack.size()) 1727 stack.push_back(stack[pick_idx]); 1728 else 1729 { 1730 if (error_ptr) 1731 error_ptr->SetErrorStringWithFormat("Index %u out of range for DW_OP_pick.\n", pick_idx); 1732 return false; 1733 } 1734 } 1735 break; 1736 1737 //---------------------------------------------------------------------- 1738 // OPCODE: DW_OP_swap 1739 // OPERANDS: none 1740 // DESCRIPTION: swaps the top two stack entries. The entry at the top 1741 // of the stack becomes the second stack entry, and the second entry 1742 // becomes the top of the stack 1743 //---------------------------------------------------------------------- 1744 case DW_OP_swap: 1745 if (stack.size() < 2) 1746 { 1747 if (error_ptr) 1748 error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_swap."); 1749 return false; 1750 } 1751 else 1752 { 1753 tmp = stack.back(); 1754 stack.back() = stack[stack.size() - 2]; 1755 stack[stack.size() - 2] = tmp; 1756 } 1757 break; 1758 1759 //---------------------------------------------------------------------- 1760 // OPCODE: DW_OP_rot 1761 // OPERANDS: none 1762 // DESCRIPTION: Rotates the first three stack entries. The entry at 1763 // the top of the stack becomes the third stack entry, the second 1764 // entry becomes the top of the stack, and the third entry becomes 1765 // the second entry. 1766 //---------------------------------------------------------------------- 1767 case DW_OP_rot: 1768 if (stack.size() < 3) 1769 { 1770 if (error_ptr) 1771 error_ptr->SetErrorString("Expression stack needs at least 3 items for DW_OP_rot."); 1772 return false; 1773 } 1774 else 1775 { 1776 size_t last_idx = stack.size() - 1; 1777 Value old_top = stack[last_idx]; 1778 stack[last_idx] = stack[last_idx - 1]; 1779 stack[last_idx - 1] = stack[last_idx - 2]; 1780 stack[last_idx - 2] = old_top; 1781 } 1782 break; 1783 1784 //---------------------------------------------------------------------- 1785 // OPCODE: DW_OP_abs 1786 // OPERANDS: none 1787 // DESCRIPTION: pops the top stack entry, interprets it as a signed 1788 // value and pushes its absolute value. If the absolute value can not be 1789 // represented, the result is undefined. 1790 //---------------------------------------------------------------------- 1791 case DW_OP_abs: 1792 if (stack.empty()) 1793 { 1794 if (error_ptr) 1795 error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_abs."); 1796 return false; 1797 } 1798 else if (stack.back().ResolveValue(exe_ctx).AbsoluteValue() == false) 1799 { 1800 if (error_ptr) 1801 error_ptr->SetErrorString("Failed to take the absolute value of the first stack item."); 1802 return false; 1803 } 1804 break; 1805 1806 //---------------------------------------------------------------------- 1807 // OPCODE: DW_OP_and 1808 // OPERANDS: none 1809 // DESCRIPTION: pops the top two stack values, performs a bitwise and 1810 // operation on the two, and pushes the result. 1811 //---------------------------------------------------------------------- 1812 case DW_OP_and: 1813 if (stack.size() < 2) 1814 { 1815 if (error_ptr) 1816 error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_and."); 1817 return false; 1818 } 1819 else 1820 { 1821 tmp = stack.back(); 1822 stack.pop_back(); 1823 stack.back().ResolveValue(exe_ctx) = stack.back().ResolveValue(exe_ctx) & tmp.ResolveValue(exe_ctx); 1824 } 1825 break; 1826 1827 //---------------------------------------------------------------------- 1828 // OPCODE: DW_OP_div 1829 // OPERANDS: none 1830 // DESCRIPTION: pops the top two stack values, divides the former second 1831 // entry by the former top of the stack using signed division, and 1832 // pushes the result. 1833 //---------------------------------------------------------------------- 1834 case DW_OP_div: 1835 if (stack.size() < 2) 1836 { 1837 if (error_ptr) 1838 error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_div."); 1839 return false; 1840 } 1841 else 1842 { 1843 tmp = stack.back(); 1844 if (tmp.ResolveValue(exe_ctx).IsZero()) 1845 { 1846 if (error_ptr) 1847 error_ptr->SetErrorString("Divide by zero."); 1848 return false; 1849 } 1850 else 1851 { 1852 stack.pop_back(); 1853 stack.back() = stack.back().ResolveValue(exe_ctx) / tmp.ResolveValue(exe_ctx); 1854 if (!stack.back().ResolveValue(exe_ctx).IsValid()) 1855 { 1856 if (error_ptr) 1857 error_ptr->SetErrorString("Divide failed."); 1858 return false; 1859 } 1860 } 1861 } 1862 break; 1863 1864 //---------------------------------------------------------------------- 1865 // OPCODE: DW_OP_minus 1866 // OPERANDS: none 1867 // DESCRIPTION: pops the top two stack values, subtracts the former top 1868 // of the stack from the former second entry, and pushes the result. 1869 //---------------------------------------------------------------------- 1870 case DW_OP_minus: 1871 if (stack.size() < 2) 1872 { 1873 if (error_ptr) 1874 error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_minus."); 1875 return false; 1876 } 1877 else 1878 { 1879 tmp = stack.back(); 1880 stack.pop_back(); 1881 stack.back().ResolveValue(exe_ctx) = stack.back().ResolveValue(exe_ctx) - tmp.ResolveValue(exe_ctx); 1882 } 1883 break; 1884 1885 //---------------------------------------------------------------------- 1886 // OPCODE: DW_OP_mod 1887 // OPERANDS: none 1888 // DESCRIPTION: pops the top two stack values and pushes the result of 1889 // the calculation: former second stack entry modulo the former top of 1890 // the stack. 1891 //---------------------------------------------------------------------- 1892 case DW_OP_mod: 1893 if (stack.size() < 2) 1894 { 1895 if (error_ptr) 1896 error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_mod."); 1897 return false; 1898 } 1899 else 1900 { 1901 tmp = stack.back(); 1902 stack.pop_back(); 1903 stack.back().ResolveValue(exe_ctx) = stack.back().ResolveValue(exe_ctx) % tmp.ResolveValue(exe_ctx); 1904 } 1905 break; 1906 1907 1908 //---------------------------------------------------------------------- 1909 // OPCODE: DW_OP_mul 1910 // OPERANDS: none 1911 // DESCRIPTION: pops the top two stack entries, multiplies them 1912 // together, and pushes the result. 1913 //---------------------------------------------------------------------- 1914 case DW_OP_mul: 1915 if (stack.size() < 2) 1916 { 1917 if (error_ptr) 1918 error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_mul."); 1919 return false; 1920 } 1921 else 1922 { 1923 tmp = stack.back(); 1924 stack.pop_back(); 1925 stack.back().ResolveValue(exe_ctx) = stack.back().ResolveValue(exe_ctx) * tmp.ResolveValue(exe_ctx); 1926 } 1927 break; 1928 1929 //---------------------------------------------------------------------- 1930 // OPCODE: DW_OP_neg 1931 // OPERANDS: none 1932 // DESCRIPTION: pops the top stack entry, and pushes its negation. 1933 //---------------------------------------------------------------------- 1934 case DW_OP_neg: 1935 if (stack.empty()) 1936 { 1937 if (error_ptr) 1938 error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_neg."); 1939 return false; 1940 } 1941 else 1942 { 1943 if (stack.back().ResolveValue(exe_ctx).UnaryNegate() == false) 1944 { 1945 if (error_ptr) 1946 error_ptr->SetErrorString("Unary negate failed."); 1947 return false; 1948 } 1949 } 1950 break; 1951 1952 //---------------------------------------------------------------------- 1953 // OPCODE: DW_OP_not 1954 // OPERANDS: none 1955 // DESCRIPTION: pops the top stack entry, and pushes its bitwise 1956 // complement 1957 //---------------------------------------------------------------------- 1958 case DW_OP_not: 1959 if (stack.empty()) 1960 { 1961 if (error_ptr) 1962 error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_not."); 1963 return false; 1964 } 1965 else 1966 { 1967 if (stack.back().ResolveValue(exe_ctx).OnesComplement() == false) 1968 { 1969 if (error_ptr) 1970 error_ptr->SetErrorString("Logical NOT failed."); 1971 return false; 1972 } 1973 } 1974 break; 1975 1976 //---------------------------------------------------------------------- 1977 // OPCODE: DW_OP_or 1978 // OPERANDS: none 1979 // DESCRIPTION: pops the top two stack entries, performs a bitwise or 1980 // operation on the two, and pushes the result. 1981 //---------------------------------------------------------------------- 1982 case DW_OP_or: 1983 if (stack.size() < 2) 1984 { 1985 if (error_ptr) 1986 error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_or."); 1987 return false; 1988 } 1989 else 1990 { 1991 tmp = stack.back(); 1992 stack.pop_back(); 1993 stack.back().ResolveValue(exe_ctx) = stack.back().ResolveValue(exe_ctx) | tmp.ResolveValue(exe_ctx); 1994 } 1995 break; 1996 1997 //---------------------------------------------------------------------- 1998 // OPCODE: DW_OP_plus 1999 // OPERANDS: none 2000 // DESCRIPTION: pops the top two stack entries, adds them together, and 2001 // pushes the result. 2002 //---------------------------------------------------------------------- 2003 case DW_OP_plus: 2004 if (stack.size() < 2) 2005 { 2006 if (error_ptr) 2007 error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_plus."); 2008 return false; 2009 } 2010 else 2011 { 2012 tmp = stack.back(); 2013 stack.pop_back(); 2014 stack.back().ResolveValue(exe_ctx) = stack.back().ResolveValue(exe_ctx) + tmp.ResolveValue(exe_ctx); 2015 } 2016 break; 2017 2018 //---------------------------------------------------------------------- 2019 // OPCODE: DW_OP_plus_uconst 2020 // OPERANDS: none 2021 // DESCRIPTION: pops the top stack entry, adds it to the unsigned LEB128 2022 // constant operand and pushes the result. 2023 //---------------------------------------------------------------------- 2024 case DW_OP_plus_uconst: 2025 if (stack.empty()) 2026 { 2027 if (error_ptr) 2028 error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_plus_uconst."); 2029 return false; 2030 } 2031 else 2032 { 2033 const uint64_t uconst_value = opcodes.GetULEB128(&offset); 2034 // Implicit conversion from a UINT to a Scalar... 2035 stack.back().ResolveValue(exe_ctx) += uconst_value; 2036 if (!stack.back().ResolveValue(exe_ctx).IsValid()) 2037 { 2038 if (error_ptr) 2039 error_ptr->SetErrorString("DW_OP_plus_uconst failed."); 2040 return false; 2041 } 2042 } 2043 break; 2044 2045 //---------------------------------------------------------------------- 2046 // OPCODE: DW_OP_shl 2047 // OPERANDS: none 2048 // DESCRIPTION: pops the top two stack entries, shifts the former 2049 // second entry left by the number of bits specified by the former top 2050 // of the stack, and pushes the result. 2051 //---------------------------------------------------------------------- 2052 case DW_OP_shl: 2053 if (stack.size() < 2) 2054 { 2055 if (error_ptr) 2056 error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_shl."); 2057 return false; 2058 } 2059 else 2060 { 2061 tmp = stack.back(); 2062 stack.pop_back(); 2063 stack.back().ResolveValue(exe_ctx) <<= tmp.ResolveValue(exe_ctx); 2064 } 2065 break; 2066 2067 //---------------------------------------------------------------------- 2068 // OPCODE: DW_OP_shr 2069 // OPERANDS: none 2070 // DESCRIPTION: pops the top two stack entries, shifts the former second 2071 // entry right logically (filling with zero bits) by the number of bits 2072 // specified by the former top of the stack, and pushes the result. 2073 //---------------------------------------------------------------------- 2074 case DW_OP_shr: 2075 if (stack.size() < 2) 2076 { 2077 if (error_ptr) 2078 error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_shr."); 2079 return false; 2080 } 2081 else 2082 { 2083 tmp = stack.back(); 2084 stack.pop_back(); 2085 if (stack.back().ResolveValue(exe_ctx).ShiftRightLogical(tmp.ResolveValue(exe_ctx)) == false) 2086 { 2087 if (error_ptr) 2088 error_ptr->SetErrorString("DW_OP_shr failed."); 2089 return false; 2090 } 2091 } 2092 break; 2093 2094 //---------------------------------------------------------------------- 2095 // OPCODE: DW_OP_shra 2096 // OPERANDS: none 2097 // DESCRIPTION: pops the top two stack entries, shifts the former second 2098 // entry right arithmetically (divide the magnitude by 2, keep the same 2099 // sign for the result) by the number of bits specified by the former 2100 // top of the stack, and pushes the result. 2101 //---------------------------------------------------------------------- 2102 case DW_OP_shra: 2103 if (stack.size() < 2) 2104 { 2105 if (error_ptr) 2106 error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_shra."); 2107 return false; 2108 } 2109 else 2110 { 2111 tmp = stack.back(); 2112 stack.pop_back(); 2113 stack.back().ResolveValue(exe_ctx) >>= tmp.ResolveValue(exe_ctx); 2114 } 2115 break; 2116 2117 //---------------------------------------------------------------------- 2118 // OPCODE: DW_OP_xor 2119 // OPERANDS: none 2120 // DESCRIPTION: pops the top two stack entries, performs the bitwise 2121 // exclusive-or operation on the two, and pushes the result. 2122 //---------------------------------------------------------------------- 2123 case DW_OP_xor: 2124 if (stack.size() < 2) 2125 { 2126 if (error_ptr) 2127 error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_xor."); 2128 return false; 2129 } 2130 else 2131 { 2132 tmp = stack.back(); 2133 stack.pop_back(); 2134 stack.back().ResolveValue(exe_ctx) = stack.back().ResolveValue(exe_ctx) ^ tmp.ResolveValue(exe_ctx); 2135 } 2136 break; 2137 2138 2139 //---------------------------------------------------------------------- 2140 // OPCODE: DW_OP_skip 2141 // OPERANDS: int16_t 2142 // DESCRIPTION: An unconditional branch. Its single operand is a 2-byte 2143 // signed integer constant. The 2-byte constant is the number of bytes 2144 // of the DWARF expression to skip forward or backward from the current 2145 // operation, beginning after the 2-byte constant. 2146 //---------------------------------------------------------------------- 2147 case DW_OP_skip: 2148 { 2149 int16_t skip_offset = (int16_t)opcodes.GetU16(&offset); 2150 lldb::offset_t new_offset = offset + skip_offset; 2151 if (new_offset >= opcodes_offset && new_offset < end_offset) 2152 offset = new_offset; 2153 else 2154 { 2155 if (error_ptr) 2156 error_ptr->SetErrorString("Invalid opcode offset in DW_OP_skip."); 2157 return false; 2158 } 2159 } 2160 break; 2161 2162 //---------------------------------------------------------------------- 2163 // OPCODE: DW_OP_bra 2164 // OPERANDS: int16_t 2165 // DESCRIPTION: A conditional branch. Its single operand is a 2-byte 2166 // signed integer constant. This operation pops the top of stack. If 2167 // the value popped is not the constant 0, the 2-byte constant operand 2168 // is the number of bytes of the DWARF expression to skip forward or 2169 // backward from the current operation, beginning after the 2-byte 2170 // constant. 2171 //---------------------------------------------------------------------- 2172 case DW_OP_bra: 2173 { 2174 tmp = stack.back(); 2175 stack.pop_back(); 2176 int16_t bra_offset = (int16_t)opcodes.GetU16(&offset); 2177 Scalar zero(0); 2178 if (tmp.ResolveValue(exe_ctx) != zero) 2179 { 2180 lldb::offset_t new_offset = offset + bra_offset; 2181 if (new_offset >= opcodes_offset && new_offset < end_offset) 2182 offset = new_offset; 2183 else 2184 { 2185 if (error_ptr) 2186 error_ptr->SetErrorString("Invalid opcode offset in DW_OP_bra."); 2187 return false; 2188 } 2189 } 2190 } 2191 break; 2192 2193 //---------------------------------------------------------------------- 2194 // OPCODE: DW_OP_eq 2195 // OPERANDS: none 2196 // DESCRIPTION: pops the top two stack values, compares using the 2197 // equals (==) operator. 2198 // STACK RESULT: push the constant value 1 onto the stack if the result 2199 // of the operation is true or the constant value 0 if the result of the 2200 // operation is false. 2201 //---------------------------------------------------------------------- 2202 case DW_OP_eq: 2203 if (stack.size() < 2) 2204 { 2205 if (error_ptr) 2206 error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_eq."); 2207 return false; 2208 } 2209 else 2210 { 2211 tmp = stack.back(); 2212 stack.pop_back(); 2213 stack.back().ResolveValue(exe_ctx) = stack.back().ResolveValue(exe_ctx) == tmp.ResolveValue(exe_ctx); 2214 } 2215 break; 2216 2217 //---------------------------------------------------------------------- 2218 // OPCODE: DW_OP_ge 2219 // OPERANDS: none 2220 // DESCRIPTION: pops the top two stack values, compares using the 2221 // greater than or equal to (>=) operator. 2222 // STACK RESULT: push the constant value 1 onto the stack if the result 2223 // of the operation is true or the constant value 0 if the result of the 2224 // operation is false. 2225 //---------------------------------------------------------------------- 2226 case DW_OP_ge: 2227 if (stack.size() < 2) 2228 { 2229 if (error_ptr) 2230 error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_ge."); 2231 return false; 2232 } 2233 else 2234 { 2235 tmp = stack.back(); 2236 stack.pop_back(); 2237 stack.back().ResolveValue(exe_ctx) = stack.back().ResolveValue(exe_ctx) >= tmp.ResolveValue(exe_ctx); 2238 } 2239 break; 2240 2241 //---------------------------------------------------------------------- 2242 // OPCODE: DW_OP_gt 2243 // OPERANDS: none 2244 // DESCRIPTION: pops the top two stack values, compares using the 2245 // greater than (>) operator. 2246 // STACK RESULT: push the constant value 1 onto the stack if the result 2247 // of the operation is true or the constant value 0 if the result of the 2248 // operation is false. 2249 //---------------------------------------------------------------------- 2250 case DW_OP_gt: 2251 if (stack.size() < 2) 2252 { 2253 if (error_ptr) 2254 error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_gt."); 2255 return false; 2256 } 2257 else 2258 { 2259 tmp = stack.back(); 2260 stack.pop_back(); 2261 stack.back().ResolveValue(exe_ctx) = stack.back().ResolveValue(exe_ctx) > tmp.ResolveValue(exe_ctx); 2262 } 2263 break; 2264 2265 //---------------------------------------------------------------------- 2266 // OPCODE: DW_OP_le 2267 // OPERANDS: none 2268 // DESCRIPTION: pops the top two stack values, compares using the 2269 // less than or equal to (<=) operator. 2270 // STACK RESULT: push the constant value 1 onto the stack if the result 2271 // of the operation is true or the constant value 0 if the result of the 2272 // operation is false. 2273 //---------------------------------------------------------------------- 2274 case DW_OP_le: 2275 if (stack.size() < 2) 2276 { 2277 if (error_ptr) 2278 error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_le."); 2279 return false; 2280 } 2281 else 2282 { 2283 tmp = stack.back(); 2284 stack.pop_back(); 2285 stack.back().ResolveValue(exe_ctx) = stack.back().ResolveValue(exe_ctx) <= tmp.ResolveValue(exe_ctx); 2286 } 2287 break; 2288 2289 //---------------------------------------------------------------------- 2290 // OPCODE: DW_OP_lt 2291 // OPERANDS: none 2292 // DESCRIPTION: pops the top two stack values, compares using the 2293 // less than (<) operator. 2294 // STACK RESULT: push the constant value 1 onto the stack if the result 2295 // of the operation is true or the constant value 0 if the result of the 2296 // operation is false. 2297 //---------------------------------------------------------------------- 2298 case DW_OP_lt: 2299 if (stack.size() < 2) 2300 { 2301 if (error_ptr) 2302 error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_lt."); 2303 return false; 2304 } 2305 else 2306 { 2307 tmp = stack.back(); 2308 stack.pop_back(); 2309 stack.back().ResolveValue(exe_ctx) = stack.back().ResolveValue(exe_ctx) < tmp.ResolveValue(exe_ctx); 2310 } 2311 break; 2312 2313 //---------------------------------------------------------------------- 2314 // OPCODE: DW_OP_ne 2315 // OPERANDS: none 2316 // DESCRIPTION: pops the top two stack values, compares using the 2317 // not equal (!=) operator. 2318 // STACK RESULT: push the constant value 1 onto the stack if the result 2319 // of the operation is true or the constant value 0 if the result of the 2320 // operation is false. 2321 //---------------------------------------------------------------------- 2322 case DW_OP_ne: 2323 if (stack.size() < 2) 2324 { 2325 if (error_ptr) 2326 error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_ne."); 2327 return false; 2328 } 2329 else 2330 { 2331 tmp = stack.back(); 2332 stack.pop_back(); 2333 stack.back().ResolveValue(exe_ctx) = stack.back().ResolveValue(exe_ctx) != tmp.ResolveValue(exe_ctx); 2334 } 2335 break; 2336 2337 //---------------------------------------------------------------------- 2338 // OPCODE: DW_OP_litn 2339 // OPERANDS: none 2340 // DESCRIPTION: encode the unsigned literal values from 0 through 31. 2341 // STACK RESULT: push the unsigned literal constant value onto the top 2342 // of the stack. 2343 //---------------------------------------------------------------------- 2344 case DW_OP_lit0: 2345 case DW_OP_lit1: 2346 case DW_OP_lit2: 2347 case DW_OP_lit3: 2348 case DW_OP_lit4: 2349 case DW_OP_lit5: 2350 case DW_OP_lit6: 2351 case DW_OP_lit7: 2352 case DW_OP_lit8: 2353 case DW_OP_lit9: 2354 case DW_OP_lit10: 2355 case DW_OP_lit11: 2356 case DW_OP_lit12: 2357 case DW_OP_lit13: 2358 case DW_OP_lit14: 2359 case DW_OP_lit15: 2360 case DW_OP_lit16: 2361 case DW_OP_lit17: 2362 case DW_OP_lit18: 2363 case DW_OP_lit19: 2364 case DW_OP_lit20: 2365 case DW_OP_lit21: 2366 case DW_OP_lit22: 2367 case DW_OP_lit23: 2368 case DW_OP_lit24: 2369 case DW_OP_lit25: 2370 case DW_OP_lit26: 2371 case DW_OP_lit27: 2372 case DW_OP_lit28: 2373 case DW_OP_lit29: 2374 case DW_OP_lit30: 2375 case DW_OP_lit31: 2376 stack.push_back(Scalar(op - DW_OP_lit0)); 2377 break; 2378 2379 //---------------------------------------------------------------------- 2380 // OPCODE: DW_OP_regN 2381 // OPERANDS: none 2382 // DESCRIPTION: Push the value in register n on the top of the stack. 2383 //---------------------------------------------------------------------- 2384 case DW_OP_reg0: 2385 case DW_OP_reg1: 2386 case DW_OP_reg2: 2387 case DW_OP_reg3: 2388 case DW_OP_reg4: 2389 case DW_OP_reg5: 2390 case DW_OP_reg6: 2391 case DW_OP_reg7: 2392 case DW_OP_reg8: 2393 case DW_OP_reg9: 2394 case DW_OP_reg10: 2395 case DW_OP_reg11: 2396 case DW_OP_reg12: 2397 case DW_OP_reg13: 2398 case DW_OP_reg14: 2399 case DW_OP_reg15: 2400 case DW_OP_reg16: 2401 case DW_OP_reg17: 2402 case DW_OP_reg18: 2403 case DW_OP_reg19: 2404 case DW_OP_reg20: 2405 case DW_OP_reg21: 2406 case DW_OP_reg22: 2407 case DW_OP_reg23: 2408 case DW_OP_reg24: 2409 case DW_OP_reg25: 2410 case DW_OP_reg26: 2411 case DW_OP_reg27: 2412 case DW_OP_reg28: 2413 case DW_OP_reg29: 2414 case DW_OP_reg30: 2415 case DW_OP_reg31: 2416 { 2417 reg_num = op - DW_OP_reg0; 2418 2419 if (ReadRegisterValueAsScalar (reg_ctx, reg_kind, reg_num, error_ptr, tmp)) 2420 stack.push_back(tmp); 2421 else 2422 return false; 2423 } 2424 break; 2425 //---------------------------------------------------------------------- 2426 // OPCODE: DW_OP_regx 2427 // OPERANDS: 2428 // ULEB128 literal operand that encodes the register. 2429 // DESCRIPTION: Push the value in register on the top of the stack. 2430 //---------------------------------------------------------------------- 2431 case DW_OP_regx: 2432 { 2433 reg_num = opcodes.GetULEB128(&offset); 2434 if (ReadRegisterValueAsScalar (reg_ctx, reg_kind, reg_num, error_ptr, tmp)) 2435 stack.push_back(tmp); 2436 else 2437 return false; 2438 } 2439 break; 2440 2441 //---------------------------------------------------------------------- 2442 // OPCODE: DW_OP_bregN 2443 // OPERANDS: 2444 // SLEB128 offset from register N 2445 // DESCRIPTION: Value is in memory at the address specified by register 2446 // N plus an offset. 2447 //---------------------------------------------------------------------- 2448 case DW_OP_breg0: 2449 case DW_OP_breg1: 2450 case DW_OP_breg2: 2451 case DW_OP_breg3: 2452 case DW_OP_breg4: 2453 case DW_OP_breg5: 2454 case DW_OP_breg6: 2455 case DW_OP_breg7: 2456 case DW_OP_breg8: 2457 case DW_OP_breg9: 2458 case DW_OP_breg10: 2459 case DW_OP_breg11: 2460 case DW_OP_breg12: 2461 case DW_OP_breg13: 2462 case DW_OP_breg14: 2463 case DW_OP_breg15: 2464 case DW_OP_breg16: 2465 case DW_OP_breg17: 2466 case DW_OP_breg18: 2467 case DW_OP_breg19: 2468 case DW_OP_breg20: 2469 case DW_OP_breg21: 2470 case DW_OP_breg22: 2471 case DW_OP_breg23: 2472 case DW_OP_breg24: 2473 case DW_OP_breg25: 2474 case DW_OP_breg26: 2475 case DW_OP_breg27: 2476 case DW_OP_breg28: 2477 case DW_OP_breg29: 2478 case DW_OP_breg30: 2479 case DW_OP_breg31: 2480 { 2481 reg_num = op - DW_OP_breg0; 2482 2483 if (ReadRegisterValueAsScalar (reg_ctx, reg_kind, reg_num, error_ptr, tmp)) 2484 { 2485 int64_t breg_offset = opcodes.GetSLEB128(&offset); 2486 tmp.ResolveValue(exe_ctx) += (uint64_t)breg_offset; 2487 tmp.ClearContext(); 2488 stack.push_back(tmp); 2489 stack.back().SetValueType (Value::eValueTypeLoadAddress); 2490 } 2491 else 2492 return false; 2493 } 2494 break; 2495 //---------------------------------------------------------------------- 2496 // OPCODE: DW_OP_bregx 2497 // OPERANDS: 2 2498 // ULEB128 literal operand that encodes the register. 2499 // SLEB128 offset from register N 2500 // DESCRIPTION: Value is in memory at the address specified by register 2501 // N plus an offset. 2502 //---------------------------------------------------------------------- 2503 case DW_OP_bregx: 2504 { 2505 reg_num = opcodes.GetULEB128(&offset); 2506 2507 if (ReadRegisterValueAsScalar (reg_ctx, reg_kind, reg_num, error_ptr, tmp)) 2508 { 2509 int64_t breg_offset = opcodes.GetSLEB128(&offset); 2510 tmp.ResolveValue(exe_ctx) += (uint64_t)breg_offset; 2511 tmp.ClearContext(); 2512 stack.push_back(tmp); 2513 stack.back().SetValueType (Value::eValueTypeLoadAddress); 2514 } 2515 else 2516 return false; 2517 } 2518 break; 2519 2520 case DW_OP_fbreg: 2521 if (exe_ctx) 2522 { 2523 if (frame) 2524 { 2525 Scalar value; 2526 if (frame->GetFrameBaseValue(value, error_ptr)) 2527 { 2528 int64_t fbreg_offset = opcodes.GetSLEB128(&offset); 2529 value += fbreg_offset; 2530 stack.push_back(value); 2531 stack.back().SetValueType (Value::eValueTypeLoadAddress); 2532 } 2533 else 2534 return false; 2535 } 2536 else 2537 { 2538 if (error_ptr) 2539 error_ptr->SetErrorString ("Invalid stack frame in context for DW_OP_fbreg opcode."); 2540 return false; 2541 } 2542 } 2543 else 2544 { 2545 if (error_ptr) 2546 error_ptr->SetErrorStringWithFormat ("NULL execution context for DW_OP_fbreg.\n"); 2547 return false; 2548 } 2549 2550 break; 2551 2552 //---------------------------------------------------------------------- 2553 // OPCODE: DW_OP_nop 2554 // OPERANDS: none 2555 // DESCRIPTION: A place holder. It has no effect on the location stack 2556 // or any of its values. 2557 //---------------------------------------------------------------------- 2558 case DW_OP_nop: 2559 break; 2560 2561 //---------------------------------------------------------------------- 2562 // OPCODE: DW_OP_piece 2563 // OPERANDS: 1 2564 // ULEB128: byte size of the piece 2565 // DESCRIPTION: The operand describes the size in bytes of the piece of 2566 // the object referenced by the DWARF expression whose result is at the 2567 // top of the stack. If the piece is located in a register, but does not 2568 // occupy the entire register, the placement of the piece within that 2569 // register is defined by the ABI. 2570 // 2571 // Many compilers store a single variable in sets of registers, or store 2572 // a variable partially in memory and partially in registers. 2573 // DW_OP_piece provides a way of describing how large a part of a 2574 // variable a particular DWARF expression refers to. 2575 //---------------------------------------------------------------------- 2576 case DW_OP_piece: 2577 if (stack.size() < 1) 2578 { 2579 if (error_ptr) 2580 error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_piece."); 2581 return false; 2582 } 2583 else 2584 { 2585 const uint64_t piece_byte_size = opcodes.GetULEB128(&offset); 2586 switch (stack.back().GetValueType()) 2587 { 2588 case Value::eValueTypeScalar: 2589 case Value::eValueTypeFileAddress: 2590 case Value::eValueTypeLoadAddress: 2591 case Value::eValueTypeHostAddress: 2592 { 2593 uint32_t bit_size = piece_byte_size * 8; 2594 uint32_t bit_offset = 0; 2595 if (!stack.back().GetScalar().ExtractBitfield (bit_size, bit_offset)) 2596 { 2597 if (error_ptr) 2598 error_ptr->SetErrorStringWithFormat("unable to extract %" PRIu64 " bytes from a %" PRIu64 " byte scalar value.", piece_byte_size, (uint64_t)stack.back().GetScalar().GetByteSize()); 2599 return false; 2600 } 2601 } 2602 break; 2603 2604 case Value::eValueTypeVector: 2605 { 2606 if (stack.back().GetVector().length >= piece_byte_size) 2607 stack.back().GetVector().length = piece_byte_size; 2608 else 2609 { 2610 if (error_ptr) 2611 error_ptr->SetErrorStringWithFormat("unable to extract %" PRIu64 " bytes from a %" PRIu64 " byte vector value.", piece_byte_size, (uint64_t)stack.back().GetVector().length); 2612 return false; 2613 } 2614 } 2615 break; 2616 } 2617 } 2618 break; 2619 2620 case DW_OP_bit_piece: // 0x9d ULEB128 bit size, ULEB128 bit offset (DWARF3); 2621 if (stack.size() < 1) 2622 { 2623 if (error_ptr) 2624 error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_bit_piece."); 2625 return false; 2626 } 2627 else 2628 { 2629 const uint64_t piece_bit_size = opcodes.GetULEB128(&offset); 2630 const uint64_t piece_bit_offset = opcodes.GetULEB128(&offset); 2631 switch (stack.back().GetValueType()) 2632 { 2633 case Value::eValueTypeScalar: 2634 case Value::eValueTypeFileAddress: 2635 case Value::eValueTypeLoadAddress: 2636 case Value::eValueTypeHostAddress: 2637 { 2638 if (!stack.back().GetScalar().ExtractBitfield (piece_bit_size, piece_bit_offset)) 2639 { 2640 if (error_ptr) 2641 error_ptr->SetErrorStringWithFormat("unable to extract %" PRIu64 " bit value with %" PRIu64 " bit offset from a %" PRIu64 " bit scalar value.", 2642 piece_bit_size, 2643 piece_bit_offset, 2644 (uint64_t)(stack.back().GetScalar().GetByteSize()*8)); 2645 return false; 2646 } 2647 } 2648 break; 2649 2650 case Value::eValueTypeVector: 2651 if (error_ptr) 2652 { 2653 error_ptr->SetErrorStringWithFormat ("unable to extract %" PRIu64 " bit value with %" PRIu64 " bit offset from a vector value.", 2654 piece_bit_size, 2655 piece_bit_offset); 2656 } 2657 return false; 2658 } 2659 } 2660 break; 2661 2662 //---------------------------------------------------------------------- 2663 // OPCODE: DW_OP_push_object_address 2664 // OPERANDS: none 2665 // DESCRIPTION: Pushes the address of the object currently being 2666 // evaluated as part of evaluation of a user presented expression. 2667 // This object may correspond to an independent variable described by 2668 // its own DIE or it may be a component of an array, structure, or class 2669 // whose address has been dynamically determined by an earlier step 2670 // during user expression evaluation. 2671 //---------------------------------------------------------------------- 2672 case DW_OP_push_object_address: 2673 if (error_ptr) 2674 error_ptr->SetErrorString ("Unimplemented opcode DW_OP_push_object_address."); 2675 return false; 2676 2677 //---------------------------------------------------------------------- 2678 // OPCODE: DW_OP_call2 2679 // OPERANDS: 2680 // uint16_t compile unit relative offset of a DIE 2681 // DESCRIPTION: Performs subroutine calls during evaluation 2682 // of a DWARF expression. The operand is the 2-byte unsigned offset 2683 // of a debugging information entry in the current compilation unit. 2684 // 2685 // Operand interpretation is exactly like that for DW_FORM_ref2. 2686 // 2687 // This operation transfers control of DWARF expression evaluation 2688 // to the DW_AT_location attribute of the referenced DIE. If there is 2689 // no such attribute, then there is no effect. Execution of the DWARF 2690 // expression of a DW_AT_location attribute may add to and/or remove from 2691 // values on the stack. Execution returns to the point following the call 2692 // when the end of the attribute is reached. Values on the stack at the 2693 // time of the call may be used as parameters by the called expression 2694 // and values left on the stack by the called expression may be used as 2695 // return values by prior agreement between the calling and called 2696 // expressions. 2697 //---------------------------------------------------------------------- 2698 case DW_OP_call2: 2699 if (error_ptr) 2700 error_ptr->SetErrorString ("Unimplemented opcode DW_OP_call2."); 2701 return false; 2702 //---------------------------------------------------------------------- 2703 // OPCODE: DW_OP_call4 2704 // OPERANDS: 1 2705 // uint32_t compile unit relative offset of a DIE 2706 // DESCRIPTION: Performs a subroutine call during evaluation of a DWARF 2707 // expression. For DW_OP_call4, the operand is a 4-byte unsigned offset 2708 // of a debugging information entry in the current compilation unit. 2709 // 2710 // Operand interpretation DW_OP_call4 is exactly like that for 2711 // DW_FORM_ref4. 2712 // 2713 // This operation transfers control of DWARF expression evaluation 2714 // to the DW_AT_location attribute of the referenced DIE. If there is 2715 // no such attribute, then there is no effect. Execution of the DWARF 2716 // expression of a DW_AT_location attribute may add to and/or remove from 2717 // values on the stack. Execution returns to the point following the call 2718 // when the end of the attribute is reached. Values on the stack at the 2719 // time of the call may be used as parameters by the called expression 2720 // and values left on the stack by the called expression may be used as 2721 // return values by prior agreement between the calling and called 2722 // expressions. 2723 //---------------------------------------------------------------------- 2724 case DW_OP_call4: 2725 if (error_ptr) 2726 error_ptr->SetErrorString ("Unimplemented opcode DW_OP_call4."); 2727 return false; 2728 2729 //---------------------------------------------------------------------- 2730 // OPCODE: DW_OP_stack_value 2731 // OPERANDS: None 2732 // DESCRIPTION: Specifies that the object does not exist in memory but 2733 // rather is a constant value. The value from the top of the stack is 2734 // the value to be used. This is the actual object value and not the 2735 // location. 2736 //---------------------------------------------------------------------- 2737 case DW_OP_stack_value: 2738 stack.back().SetValueType(Value::eValueTypeScalar); 2739 break; 2740 2741 //---------------------------------------------------------------------- 2742 // OPCODE: DW_OP_call_frame_cfa 2743 // OPERANDS: None 2744 // DESCRIPTION: Specifies a DWARF expression that pushes the value of 2745 // the canonical frame address consistent with the call frame information 2746 // located in .debug_frame (or in the FDEs of the eh_frame section). 2747 //---------------------------------------------------------------------- 2748 case DW_OP_call_frame_cfa: 2749 if (frame) 2750 { 2751 // Note that we don't have to parse FDEs because this DWARF expression 2752 // is commonly evaluated with a valid stack frame. 2753 StackID id = frame->GetStackID(); 2754 addr_t cfa = id.GetCallFrameAddress(); 2755 if (cfa != LLDB_INVALID_ADDRESS) 2756 { 2757 stack.push_back(Scalar(cfa)); 2758 stack.back().SetValueType (Value::eValueTypeHostAddress); 2759 } 2760 else 2761 if (error_ptr) 2762 error_ptr->SetErrorString ("Stack frame does not include a canonical frame address for DW_OP_call_frame_cfa opcode."); 2763 } 2764 else 2765 { 2766 if (error_ptr) 2767 error_ptr->SetErrorString ("Invalid stack frame in context for DW_OP_call_frame_cfa opcode."); 2768 return false; 2769 } 2770 break; 2771 2772 //---------------------------------------------------------------------- 2773 // OPCODE: DW_OP_GNU_push_tls_address 2774 // OPERANDS: none 2775 // DESCRIPTION: Pops a TLS offset from the stack, converts it to 2776 // an absolute value, and pushes it back on. 2777 //---------------------------------------------------------------------- 2778 case DW_OP_GNU_push_tls_address: 2779 { 2780 if (stack.size() < 1) 2781 { 2782 if (error_ptr) 2783 error_ptr->SetErrorString("DW_OP_GNU_push_tls_address needs an argument."); 2784 return false; 2785 } 2786 2787 if (!exe_ctx || !opcode_ctx) 2788 { 2789 if (error_ptr) 2790 error_ptr->SetErrorString("No context to evaluate TLS within."); 2791 return false; 2792 } 2793 2794 Thread *thread = exe_ctx->GetThreadPtr(); 2795 if (!thread) 2796 { 2797 if (error_ptr) 2798 error_ptr->SetErrorString("No thread to evaluate TLS within."); 2799 return false; 2800 } 2801 2802 // Lookup the TLS block address for this thread and module. 2803 addr_t tls_addr = thread->GetThreadLocalData (opcode_ctx); 2804 2805 if (tls_addr == LLDB_INVALID_ADDRESS) 2806 { 2807 if (error_ptr) 2808 error_ptr->SetErrorString ("No TLS data currently exists for this thread."); 2809 return false; 2810 } 2811 2812 // Convert the TLS offset into the absolute address. 2813 Scalar tmp = stack.back().ResolveValue(exe_ctx); 2814 stack.back() = tmp + tls_addr; 2815 stack.back().SetValueType (Value::eValueTypeLoadAddress); 2816 } 2817 break; 2818 2819 default: 2820 if (log) 2821 log->Printf("Unhandled opcode %s in DWARFExpression.", DW_OP_value_to_name(op)); 2822 break; 2823 } 2824 } 2825 2826 if (stack.empty()) 2827 { 2828 if (error_ptr) 2829 error_ptr->SetErrorString ("Stack empty after evaluation."); 2830 return false; 2831 } 2832 else if (log && log->GetVerbose()) 2833 { 2834 size_t count = stack.size(); 2835 log->Printf("Stack after operation has %zu values:", count); 2836 for (size_t i=0; i<count; ++i) 2837 { 2838 StreamString new_value; 2839 new_value.Printf("[%" PRIu64 "]", (uint64_t)i); 2840 stack[i].Dump(&new_value); 2841 log->Printf(" %s", new_value.GetData()); 2842 } 2843 } 2844 2845 result = stack.back(); 2846 return true; // Return true on success 2847} 2848 2849