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