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