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