1 //===-- DWARFExpression.cpp -----------------------------------------------===//
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
7 //===----------------------------------------------------------------------===//
9 #include "lldb/Expression/DWARFExpression.h"
15 #include "lldb/Core/Module.h"
16 #include "lldb/Core/Value.h"
17 #include "lldb/Core/dwarf.h"
18 #include "lldb/Utility/DataEncoder.h"
19 #include "lldb/Utility/Log.h"
20 #include "lldb/Utility/RegisterValue.h"
21 #include "lldb/Utility/Scalar.h"
22 #include "lldb/Utility/StreamString.h"
23 #include "lldb/Utility/VMRange.h"
25 #include "lldb/Host/Host.h"
26 #include "lldb/Utility/Endian.h"
28 #include "lldb/Symbol/Function.h"
30 #include "lldb/Target/ABI.h"
31 #include "lldb/Target/ExecutionContext.h"
32 #include "lldb/Target/Process.h"
33 #include "lldb/Target/RegisterContext.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"
39 #include "Plugins/SymbolFile/DWARF/DWARFUnit.h"
42 using namespace lldb_private;
45 ReadAddressFromDebugAddrSection(const DWARFUnit *dwarf_cu,
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 =
51 dwarf_cu->GetSymbolFileDWARF().GetDWARFContext().getOrLoadAddrData();
52 if (data.ValidOffsetForDataOfSize(offset, index_size))
53 return data.GetMaxU64_unchecked(&offset, index_size);
54 return LLDB_INVALID_ADDRESS;
57 // DWARFExpression constructor
58 DWARFExpression::DWARFExpression()
59 : m_module_wp(), m_data(), m_dwarf_cu(nullptr),
60 m_reg_kind(eRegisterKindDWARF) {}
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) {
68 m_module_wp = module_sp;
72 DWARFExpression::~DWARFExpression() {}
74 bool DWARFExpression::IsValid() const { return m_data.GetByteSize() > 0; }
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)
83 DataBufferSP(new DataBufferHeap(&const_value, const_value_byte_size)));
84 m_data.SetByteOrder(endian::InlHostByteOrder());
85 m_data.SetAddressByteSize(addr_byte_size);
88 void DWARFExpression::DumpLocation(Stream *s, const DataExtractor &data,
89 lldb::DescriptionLevel level,
91 llvm::DWARFExpression(data.GetAsLLVM(), data.GetAddressByteSize())
92 .print(s->AsRawOstream(), abi ? &abi->GetMCRegisterInfo() : nullptr,
96 void DWARFExpression::SetLocationListAddresses(addr_t cu_file_addr,
97 addr_t func_file_addr) {
98 m_loclist_addresses = LoclistAddresses{cu_file_addr, func_file_addr};
101 int DWARFExpression::GetRegisterKind() { return m_reg_kind; }
103 void DWARFExpression::SetRegisterKind(RegisterKind reg_kind) {
104 m_reg_kind = reg_kind;
107 bool DWARFExpression::IsLocationList() const {
108 return bool(m_loclist_addresses);
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 {
117 DummyDWARFObject(bool IsLittleEndian) : IsLittleEndian(IsLittleEndian) {}
119 bool isLittleEndian() const override { return IsLittleEndian; }
121 llvm::Optional<llvm::RelocAddrEntry> find(const llvm::DWARFSection &Sec,
122 uint64_t Pos) const override {
130 void DWARFExpression::GetDescription(Stream *s, lldb::DescriptionLevel level,
131 addr_t location_list_base_addr,
133 if (IsLocationList()) {
134 // We have a location list
135 lldb::offset_t offset = 0;
136 std::unique_ptr<llvm::DWARFLocationTable> loctable_up =
137 m_dwarf_cu->GetLocationTable(m_data);
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));
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);
150 // We have a normal location that contains DW_OP location opcodes
151 DumpLocation(s, m_data, level, abi);
155 static bool ReadRegisterValueAsScalar(RegisterContext *reg_ctx,
156 lldb::RegisterKind reg_kind,
157 uint32_t reg_num, Status *error_ptr,
159 if (reg_ctx == nullptr) {
161 error_ptr->SetErrorStringWithFormat("No register context in frame.\n");
163 uint32_t native_reg =
164 reg_ctx->ConvertRegisterKindToRegisterNumber(reg_kind, reg_num);
165 if (native_reg == LLDB_INVALID_REGNUM) {
167 error_ptr->SetErrorStringWithFormat("Unable to convert register "
168 "kind=%u reg_num=%u to a native "
169 "register number.\n",
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())) {
177 value.SetValueType(Value::eValueTypeScalar);
178 value.SetContext(Value::eContextTypeRegisterInfo,
179 const_cast<RegisterInfo *>(reg_info));
184 // If we get this error, then we need to implement a value buffer in
185 // the dwarf expression evaluation function...
187 error_ptr->SetErrorStringWithFormat(
188 "register %s can't be converted to a scalar value",
193 error_ptr->SetErrorStringWithFormat("register %s is not available",
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.
203 static offset_t GetOpcodeDataSize(const DataExtractor &data,
204 const lldb::offset_t data_offset,
206 lldb::offset_t offset = data_offset;
209 case DW_OP_call_ref: // 0x9a 1 address sized offset of DIE (DWARF3)
210 return data.GetAddressByteSize();
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
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
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)
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)
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
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;
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;
391 case DW_OP_implicit_value: // 0x9e ULEB128 size followed by block of that size
394 uint64_t block_len = data.Skip_LEB128(&offset);
396 return offset - data_offset;
399 case DW_OP_GNU_entry_value:
400 case DW_OP_entry_value: // 0xa3 ULEB128 size + variable-length block
402 uint64_t subexpr_len = data.GetULEB128(&offset);
403 return (offset - data_offset) + subexpr_len;
409 return LLDB_INVALID_OFFSET;
412 lldb::addr_t DWARFExpression::GetLocation_DW_OP_addr(uint32_t op_addr_idx,
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);
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)
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) {
436 return ReadAddressFromDebugAddrSection(m_dwarf_cu, index);
440 const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
441 if (op_arg_size == LLDB_INVALID_OFFSET) {
445 offset += op_arg_size;
448 return LLDB_INVALID_ADDRESS;
451 bool DWARFExpression::Update_DW_OP_addr(lldb::addr_t file_addr) {
452 if (IsLocationList())
454 lldb::offset_t offset = 0;
455 while (m_data.ValidOffset(offset)) {
456 const uint8_t op = m_data.GetU8(&offset);
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
465 // So first we copy the data into a heap buffer
466 std::unique_ptr<DataBufferHeap> head_data_up(
467 new DataBufferHeap(m_data.GetDataStart(), m_data.GetByteSize()));
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);
474 // Replace the address in the new buffer
475 if (encoder.PutUnsigned(offset, addr_byte_size, file_addr) == UINT32_MAX)
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()));
483 const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
484 if (op_arg_size == LLDB_INVALID_OFFSET)
486 offset += op_arg_size;
492 bool DWARFExpression::ContainsThreadLocalStorage() const {
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())
498 lldb::offset_t offset = 0;
499 while (m_data.ValidOffset(offset)) {
500 const uint8_t op = m_data.GetU8(&offset);
502 if (op == DW_OP_form_tls_address || op == DW_OP_GNU_push_tls_address)
504 const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
505 if (op_arg_size == LLDB_INVALID_OFFSET)
508 offset += op_arg_size;
512 bool DWARFExpression::LinkThreadLocalStorage(
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())
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
528 // So first we copy the data into a heap buffer
529 std::shared_ptr<DataBufferHeap> heap_data_sp(
530 new DataBufferHeap(m_data.GetDataStart(), m_data.GetByteSize()));
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);
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);
544 bool decoded_data = false;
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);
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);
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)
580 // Replace the address in the new buffer
581 if (encoder.PutUnsigned(const_offset, const_byte_size,
582 linked_file_addr) == UINT32_MAX)
595 const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
596 if (op_arg_size == LLDB_INVALID_OFFSET)
599 offset += op_arg_size;
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
607 m_module_wp = new_module_sp;
608 m_data.SetData(heap_data_sp);
612 bool DWARFExpression::LocationListContainsAddress(addr_t func_load_addr,
613 lldb::addr_t addr) const {
614 if (func_load_addr == LLDB_INVALID_ADDRESS || addr == LLDB_INVALID_ADDRESS)
617 if (!IsLocationList())
620 return GetLocationExpression(func_load_addr, addr) != llvm::None;
623 bool DWARFExpression::DumpLocationForAddress(Stream *s,
624 lldb::DescriptionLevel level,
625 addr_t func_load_addr,
626 addr_t address, ABI *abi) {
627 if (!IsLocationList()) {
628 DumpLocation(s, m_data, level, abi);
631 if (llvm::Optional<DataExtractor> expr =
632 GetLocationExpression(func_load_addr, address)) {
633 DumpLocation(s, *expr, level, abi);
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.
651 // Example (this is pseudo-code & pseudo-DWARF, but hopefully illustrative):
653 // void child(int &sink, int x) {
655 // /* "x" gets optimized out. */
657 // /* The location of "x" here is: DW_OP_entry_value($reg2). */
665 // * The callsite information emitted here is:
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)
676 // * DW_TAG_call_site
677 // * DW_AT_return_pc ... (for "child(sink, 456);")
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`.
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");
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");
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.
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
717 if (return_pc == LLDB_INVALID_ADDRESS) {
718 return_pc = parent_frame->GetFrameCodeAddress().GetLoadAddress(&target);
720 "Evaluate_DW_OP_entry_value: immediate ancestor with pc = {0:x}",
724 // If we've found an inlined frame, skip it (these have no call site
726 if (parent_frame->IsInlined())
729 // We've found the first non-inlined parent frame.
732 if (!parent_frame || !parent_frame->GetRegisterContext()) {
733 LLDB_LOG(log, "Evaluate_DW_OP_entry_value: no parent frame with reg ctx");
737 Function *parent_func =
738 parent_frame->GetSymbolContext(eSymbolContextFunction).function;
740 LLDB_LOG(log, "Evaluate_DW_OP_entry_value: no parent function");
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;
749 LLDB_LOG(log, "Evaluate_DW_OP_entry_value: no current function");
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);
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());
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");
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();
786 LLDB_LOG(log, "Evaluate_DW_OP_entry_value: no unambiguous edge from parent "
787 "to current function");
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);
797 LLDB_LOG(log, "Evaluate_DW_OP_entry_value: subexpr could not be read");
801 const CallSiteParameter *matched_param = nullptr;
802 for (const CallSiteParameter ¶m : call_edge->GetCallSiteParameters()) {
803 DataExtractor param_subexpr_extractor;
804 if (!param.LocationInCallee.GetExpressionData(param_subexpr_extractor))
806 lldb::offset_t param_subexpr_offset = 0;
807 const void *param_subexpr_data =
808 param_subexpr_extractor.GetData(¶m_subexpr_offset, subexpr_len);
809 if (!param_subexpr_data ||
810 param_subexpr_extractor.BytesLeft(param_subexpr_offset) != 0)
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.
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 = ¶m;
825 if (!matched_param) {
827 "Evaluate_DW_OP_entry_value: no matching call site param found");
831 // TODO: Add support for DW_OP_push_object_address within a DW_OP_entry_value
832 // subexpresion whenever llvm does.
834 const DWARFExpression ¶m_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)) {
841 "Evaluate_DW_OP_entry_value: call site param evaluation failed");
845 stack.push_back(result);
849 bool DWARFExpression::Evaluate(ExecutionContextScope *exe_scope,
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);
859 bool DWARFExpression::Evaluate(ExecutionContext *exe_ctx,
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();
867 if (IsLocationList()) {
869 StackFrame *frame = nullptr;
871 pc = reg_ctx->GetPC();
873 frame = exe_ctx->GetFramePtr();
876 RegisterContextSP reg_ctx_sp = frame->GetRegisterContext();
879 pc = reg_ctx_sp->GetPC();
882 if (func_load_addr != LLDB_INVALID_ADDRESS) {
883 if (pc == LLDB_INVALID_ADDRESS) {
885 error_ptr->SetErrorString("Invalid PC in frame.");
889 if (llvm::Optional<DataExtractor> expr =
890 GetLocationExpression(func_load_addr, pc)) {
891 return DWARFExpression::Evaluate(
892 exe_ctx, reg_ctx, module_sp, *expr, m_dwarf_cu, m_reg_kind,
893 initial_value_ptr, object_address_ptr, result, error_ptr);
897 error_ptr->SetErrorString("variable not available");
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);
907 bool DWARFExpression::Evaluate(
908 ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
909 lldb::ModuleSP module_sp, const DataExtractor &opcodes,
910 const DWARFUnit *dwarf_cu, const lldb::RegisterKind reg_kind,
911 const Value *initial_value_ptr, const Value *object_address_ptr,
912 Value &result, Status *error_ptr) {
914 if (opcodes.GetByteSize() == 0) {
916 error_ptr->SetErrorString(
917 "no location, value may have been optimized out");
920 std::vector<Value> stack;
922 Process *process = nullptr;
923 StackFrame *frame = nullptr;
926 process = exe_ctx->GetProcessPtr();
927 frame = exe_ctx->GetFramePtr();
929 if (reg_ctx == nullptr && frame)
930 reg_ctx = frame->GetRegisterContext().get();
932 if (initial_value_ptr)
933 stack.push_back(*initial_value_ptr);
935 lldb::offset_t offset = 0;
939 /// Insertion point for evaluating multi-piece expression.
940 uint64_t op_piece_offset = 0;
941 Value pieces; // Used for DW_OP_piece
943 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
945 while (opcodes.ValidOffset(offset)) {
946 const lldb::offset_t op_offset = offset;
947 const uint8_t op = opcodes.GetU8(&offset);
949 if (log && log->GetVerbose()) {
950 size_t count = stack.size();
951 LLDB_LOGF(log, "Stack before operation has %" PRIu64 " values:",
953 for (size_t i = 0; i < count; ++i) {
954 StreamString new_value;
955 new_value.Printf("[%" PRIu64 "]", (uint64_t)i);
956 stack[i].Dump(&new_value);
957 LLDB_LOGF(log, " %s", new_value.GetData());
959 LLDB_LOGF(log, "0x%8.8" PRIx64 ": %s", op_offset,
960 DW_OP_value_to_name(op));
964 // The DW_OP_addr operation has a single operand that encodes a machine
965 // address and whose size is the size of an address on the target machine.
967 stack.push_back(Scalar(opcodes.GetAddress(&offset)));
968 stack.back().SetValueType(Value::eValueTypeFileAddress);
969 // Convert the file address to a load address, so subsequent
970 // DWARF operators can operate on it.
972 stack.back().ConvertToLoadAddress(module_sp.get(),
973 frame->CalculateTarget().get());
976 // The DW_OP_addr_sect_offset4 is used for any location expressions in
977 // shared libraries that have a location like:
978 // DW_OP_addr(0x1000)
979 // If this address resides in a shared library, then this virtual address
980 // won't make sense when it is evaluated in the context of a running
981 // process where shared libraries have been slid. To account for this, this
982 // new address type where we can store the section pointer and a 4 byte
984 // case DW_OP_addr_sect_offset4:
986 // result_type = eResultTypeFileAddress;
987 // lldb::Section *sect = (lldb::Section
988 // *)opcodes.GetMaxU64(&offset, sizeof(void *));
989 // lldb::addr_t sect_offset = opcodes.GetU32(&offset);
991 // Address so_addr (sect, sect_offset);
992 // lldb::addr_t load_addr = so_addr.GetLoadAddress();
993 // if (load_addr != LLDB_INVALID_ADDRESS)
995 // // We successfully resolve a file address to a load
997 // stack.push_back(load_addr);
1004 // error_ptr->SetErrorStringWithFormat ("Section %s in
1005 // %s is not currently loaded.\n",
1006 // sect->GetName().AsCString(),
1007 // sect->GetModule()->GetFileSpec().GetFilename().AsCString());
1013 // OPCODE: DW_OP_deref
1015 // DESCRIPTION: Pops the top stack entry and treats it as an address.
1016 // The value retrieved from that address is pushed. The size of the data
1017 // retrieved from the dereferenced address is the size of an address on the
1020 if (stack.empty()) {
1022 error_ptr->SetErrorString("Expression stack empty for DW_OP_deref.");
1025 Value::ValueType value_type = stack.back().GetValueType();
1026 switch (value_type) {
1027 case Value::eValueTypeHostAddress: {
1028 void *src = (void *)stack.back().GetScalar().ULongLong();
1030 ::memcpy(&ptr, src, sizeof(void *));
1031 stack.back().GetScalar() = ptr;
1032 stack.back().ClearContext();
1034 case Value::eValueTypeFileAddress: {
1035 auto file_addr = stack.back().GetScalar().ULongLong(
1036 LLDB_INVALID_ADDRESS);
1039 error_ptr->SetErrorStringWithFormat(
1040 "need module to resolve file address for DW_OP_deref");
1044 if (!module_sp->ResolveFileAddress(file_addr, so_addr)) {
1046 error_ptr->SetErrorStringWithFormat(
1047 "failed to resolve file address in module");
1050 addr_t load_Addr = so_addr.GetLoadAddress(exe_ctx->GetTargetPtr());
1051 if (load_Addr == LLDB_INVALID_ADDRESS) {
1053 error_ptr->SetErrorStringWithFormat(
1054 "failed to resolve load address");
1057 stack.back().GetScalar() = load_Addr;
1058 stack.back().SetValueType(Value::eValueTypeLoadAddress);
1059 // Fall through to load address code below...
1061 case Value::eValueTypeLoadAddress:
1064 lldb::addr_t pointer_addr =
1065 stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1067 lldb::addr_t pointer_value =
1068 process->ReadPointerFromMemory(pointer_addr, error);
1069 if (pointer_value != LLDB_INVALID_ADDRESS) {
1070 stack.back().GetScalar() = pointer_value;
1071 stack.back().ClearContext();
1074 error_ptr->SetErrorStringWithFormat(
1075 "Failed to dereference pointer from 0x%" PRIx64
1076 " for DW_OP_deref: %s\n",
1077 pointer_addr, error.AsCString());
1082 error_ptr->SetErrorStringWithFormat(
1083 "NULL process for DW_OP_deref.\n");
1088 error_ptr->SetErrorStringWithFormat(
1089 "NULL execution context for DW_OP_deref.\n");
1100 // OPCODE: DW_OP_deref_size
1102 // 1 - uint8_t that specifies the size of the data to dereference.
1103 // DESCRIPTION: Behaves like the DW_OP_deref operation: it pops the top
1104 // stack entry and treats it as an address. The value retrieved from that
1105 // address is pushed. In the DW_OP_deref_size operation, however, the size
1106 // in bytes of the data retrieved from the dereferenced address is
1107 // specified by the single operand. This operand is a 1-byte unsigned
1108 // integral constant whose value may not be larger than the size of an
1109 // address on the target machine. The data retrieved is zero extended to
1110 // the size of an address on the target machine before being pushed on the
1111 // expression stack.
1112 case DW_OP_deref_size: {
1113 if (stack.empty()) {
1115 error_ptr->SetErrorString(
1116 "Expression stack empty for DW_OP_deref_size.");
1119 uint8_t size = opcodes.GetU8(&offset);
1120 Value::ValueType value_type = stack.back().GetValueType();
1121 switch (value_type) {
1122 case Value::eValueTypeHostAddress: {
1123 void *src = (void *)stack.back().GetScalar().ULongLong();
1125 ::memcpy(&ptr, src, sizeof(void *));
1126 // I can't decide whether the size operand should apply to the bytes in
1128 // lldb-host endianness or the target endianness.. I doubt this'll ever
1129 // come up but I'll opt for assuming big endian regardless.
1138 ptr = ptr & 0xffffff;
1141 ptr = ptr & 0xffffffff;
1143 // the casts are added to work around the case where intptr_t is a 32
1145 // presumably we won't hit the 5..7 cases if (void*) is 32-bits in this
1148 ptr = (intptr_t)ptr & 0xffffffffffULL;
1151 ptr = (intptr_t)ptr & 0xffffffffffffULL;
1154 ptr = (intptr_t)ptr & 0xffffffffffffffULL;
1159 stack.back().GetScalar() = ptr;
1160 stack.back().ClearContext();
1162 case Value::eValueTypeLoadAddress:
1165 lldb::addr_t pointer_addr =
1166 stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1167 uint8_t addr_bytes[sizeof(lldb::addr_t)];
1169 if (process->ReadMemory(pointer_addr, &addr_bytes, size, error) ==
1171 DataExtractor addr_data(addr_bytes, sizeof(addr_bytes),
1172 process->GetByteOrder(), size);
1173 lldb::offset_t addr_data_offset = 0;
1176 stack.back().GetScalar() = addr_data.GetU8(&addr_data_offset);
1179 stack.back().GetScalar() = addr_data.GetU16(&addr_data_offset);
1182 stack.back().GetScalar() = addr_data.GetU32(&addr_data_offset);
1185 stack.back().GetScalar() = addr_data.GetU64(&addr_data_offset);
1188 stack.back().GetScalar() =
1189 addr_data.GetAddress(&addr_data_offset);
1191 stack.back().ClearContext();
1194 error_ptr->SetErrorStringWithFormat(
1195 "Failed to dereference pointer from 0x%" PRIx64
1196 " for DW_OP_deref: %s\n",
1197 pointer_addr, error.AsCString());
1202 error_ptr->SetErrorStringWithFormat(
1203 "NULL process for DW_OP_deref.\n");
1208 error_ptr->SetErrorStringWithFormat(
1209 "NULL execution context for DW_OP_deref.\n");
1220 // OPCODE: DW_OP_xderef_size
1222 // 1 - uint8_t that specifies the size of the data to dereference.
1223 // DESCRIPTION: Behaves like the DW_OP_xderef operation: the entry at
1224 // the top of the stack is treated as an address. The second stack entry is
1225 // treated as an "address space identifier" for those architectures that
1226 // support multiple address spaces. The top two stack elements are popped,
1227 // a data item is retrieved through an implementation-defined address
1228 // calculation and pushed as the new stack top. In the DW_OP_xderef_size
1229 // operation, however, the size in bytes of the data retrieved from the
1230 // dereferenced address is specified by the single operand. This operand is
1231 // a 1-byte unsigned integral constant whose value may not be larger than
1232 // the size of an address on the target machine. The data retrieved is zero
1233 // extended to the size of an address on the target machine before being
1234 // pushed on the expression stack.
1235 case DW_OP_xderef_size:
1237 error_ptr->SetErrorString("Unimplemented opcode: DW_OP_xderef_size.");
1239 // OPCODE: DW_OP_xderef
1241 // DESCRIPTION: Provides an extended dereference mechanism. The entry at
1242 // the top of the stack is treated as an address. The second stack entry is
1243 // treated as an "address space identifier" for those architectures that
1244 // support multiple address spaces. The top two stack elements are popped,
1245 // a data item is retrieved through an implementation-defined address
1246 // calculation and pushed as the new stack top. The size of the data
1247 // retrieved from the dereferenced address is the size of an address on the
1251 error_ptr->SetErrorString("Unimplemented opcode: DW_OP_xderef.");
1254 // All DW_OP_constXXX opcodes have a single operand as noted below:
1257 // DW_OP_const1u 1-byte unsigned integer constant DW_OP_const1s
1258 // 1-byte signed integer constant DW_OP_const2u 2-byte unsigned integer
1259 // constant DW_OP_const2s 2-byte signed integer constant DW_OP_const4u
1260 // 4-byte unsigned integer constant DW_OP_const4s 4-byte signed integer
1261 // constant DW_OP_const8u 8-byte unsigned integer constant DW_OP_const8s
1262 // 8-byte signed integer constant DW_OP_constu unsigned LEB128 integer
1263 // constant DW_OP_consts signed LEB128 integer constant
1265 stack.push_back(Scalar((uint8_t)opcodes.GetU8(&offset)));
1268 stack.push_back(Scalar((int8_t)opcodes.GetU8(&offset)));
1271 stack.push_back(Scalar((uint16_t)opcodes.GetU16(&offset)));
1274 stack.push_back(Scalar((int16_t)opcodes.GetU16(&offset)));
1277 stack.push_back(Scalar((uint32_t)opcodes.GetU32(&offset)));
1280 stack.push_back(Scalar((int32_t)opcodes.GetU32(&offset)));
1283 stack.push_back(Scalar((uint64_t)opcodes.GetU64(&offset)));
1286 stack.push_back(Scalar((int64_t)opcodes.GetU64(&offset)));
1289 stack.push_back(Scalar(opcodes.GetULEB128(&offset)));
1292 stack.push_back(Scalar(opcodes.GetSLEB128(&offset)));
1295 // OPCODE: DW_OP_dup
1297 // DESCRIPTION: duplicates the value at the top of the stack
1299 if (stack.empty()) {
1301 error_ptr->SetErrorString("Expression stack empty for DW_OP_dup.");
1304 stack.push_back(stack.back());
1307 // OPCODE: DW_OP_drop
1309 // DESCRIPTION: pops the value at the top of the stack
1311 if (stack.empty()) {
1313 error_ptr->SetErrorString("Expression stack empty for DW_OP_drop.");
1319 // OPCODE: DW_OP_over
1321 // DESCRIPTION: Duplicates the entry currently second in the stack at
1322 // the top of the stack.
1324 if (stack.size() < 2) {
1326 error_ptr->SetErrorString(
1327 "Expression stack needs at least 2 items for DW_OP_over.");
1330 stack.push_back(stack[stack.size() - 2]);
1333 // OPCODE: DW_OP_pick
1334 // OPERANDS: uint8_t index into the current stack
1335 // DESCRIPTION: The stack entry with the specified index (0 through 255,
1336 // inclusive) is pushed on the stack
1338 uint8_t pick_idx = opcodes.GetU8(&offset);
1339 if (pick_idx < stack.size())
1340 stack.push_back(stack[stack.size() - 1 - pick_idx]);
1343 error_ptr->SetErrorStringWithFormat(
1344 "Index %u out of range for DW_OP_pick.\n", pick_idx);
1349 // OPCODE: DW_OP_swap
1351 // DESCRIPTION: swaps the top two stack entries. The entry at the top
1352 // of the stack becomes the second stack entry, and the second entry
1353 // becomes the top of the stack
1355 if (stack.size() < 2) {
1357 error_ptr->SetErrorString(
1358 "Expression stack needs at least 2 items for DW_OP_swap.");
1362 stack.back() = stack[stack.size() - 2];
1363 stack[stack.size() - 2] = tmp;
1367 // OPCODE: DW_OP_rot
1369 // DESCRIPTION: Rotates the first three stack entries. The entry at
1370 // the top of the stack becomes the third stack entry, the second entry
1371 // becomes the top of the stack, and the third entry becomes the second
1374 if (stack.size() < 3) {
1376 error_ptr->SetErrorString(
1377 "Expression stack needs at least 3 items for DW_OP_rot.");
1380 size_t last_idx = stack.size() - 1;
1381 Value old_top = stack[last_idx];
1382 stack[last_idx] = stack[last_idx - 1];
1383 stack[last_idx - 1] = stack[last_idx - 2];
1384 stack[last_idx - 2] = old_top;
1388 // OPCODE: DW_OP_abs
1390 // DESCRIPTION: pops the top stack entry, interprets it as a signed
1391 // value and pushes its absolute value. If the absolute value can not be
1392 // represented, the result is undefined.
1394 if (stack.empty()) {
1396 error_ptr->SetErrorString(
1397 "Expression stack needs at least 1 item for DW_OP_abs.");
1399 } else if (!stack.back().ResolveValue(exe_ctx).AbsoluteValue()) {
1401 error_ptr->SetErrorString(
1402 "Failed to take the absolute value of the first stack item.");
1407 // OPCODE: DW_OP_and
1409 // DESCRIPTION: pops the top two stack values, performs a bitwise and
1410 // operation on the two, and pushes the result.
1412 if (stack.size() < 2) {
1414 error_ptr->SetErrorString(
1415 "Expression stack needs at least 2 items for DW_OP_and.");
1420 stack.back().ResolveValue(exe_ctx) =
1421 stack.back().ResolveValue(exe_ctx) & tmp.ResolveValue(exe_ctx);
1425 // OPCODE: DW_OP_div
1427 // DESCRIPTION: pops the top two stack values, divides the former second
1428 // entry by the former top of the stack using signed division, and pushes
1431 if (stack.size() < 2) {
1433 error_ptr->SetErrorString(
1434 "Expression stack needs at least 2 items for DW_OP_div.");
1438 if (tmp.ResolveValue(exe_ctx).IsZero()) {
1440 error_ptr->SetErrorString("Divide by zero.");
1445 stack.back().ResolveValue(exe_ctx) / tmp.ResolveValue(exe_ctx);
1446 if (!stack.back().ResolveValue(exe_ctx).IsValid()) {
1448 error_ptr->SetErrorString("Divide failed.");
1455 // OPCODE: DW_OP_minus
1457 // DESCRIPTION: pops the top two stack values, subtracts the former top
1458 // of the stack from the former second entry, and pushes the result.
1460 if (stack.size() < 2) {
1462 error_ptr->SetErrorString(
1463 "Expression stack needs at least 2 items for DW_OP_minus.");
1468 stack.back().ResolveValue(exe_ctx) =
1469 stack.back().ResolveValue(exe_ctx) - tmp.ResolveValue(exe_ctx);
1473 // OPCODE: DW_OP_mod
1475 // DESCRIPTION: pops the top two stack values and pushes the result of
1476 // the calculation: former second stack entry modulo the former top of the
1479 if (stack.size() < 2) {
1481 error_ptr->SetErrorString(
1482 "Expression stack needs at least 2 items for DW_OP_mod.");
1487 stack.back().ResolveValue(exe_ctx) =
1488 stack.back().ResolveValue(exe_ctx) % tmp.ResolveValue(exe_ctx);
1492 // OPCODE: DW_OP_mul
1494 // DESCRIPTION: pops the top two stack entries, multiplies them
1495 // together, and pushes the result.
1497 if (stack.size() < 2) {
1499 error_ptr->SetErrorString(
1500 "Expression stack needs at least 2 items for DW_OP_mul.");
1505 stack.back().ResolveValue(exe_ctx) =
1506 stack.back().ResolveValue(exe_ctx) * tmp.ResolveValue(exe_ctx);
1510 // OPCODE: DW_OP_neg
1512 // DESCRIPTION: pops the top stack entry, and pushes its negation.
1514 if (stack.empty()) {
1516 error_ptr->SetErrorString(
1517 "Expression stack needs at least 1 item for DW_OP_neg.");
1520 if (!stack.back().ResolveValue(exe_ctx).UnaryNegate()) {
1522 error_ptr->SetErrorString("Unary negate failed.");
1528 // OPCODE: DW_OP_not
1530 // DESCRIPTION: pops the top stack entry, and pushes its bitwise
1533 if (stack.empty()) {
1535 error_ptr->SetErrorString(
1536 "Expression stack needs at least 1 item for DW_OP_not.");
1539 if (!stack.back().ResolveValue(exe_ctx).OnesComplement()) {
1541 error_ptr->SetErrorString("Logical NOT failed.");
1549 // DESCRIPTION: pops the top two stack entries, performs a bitwise or
1550 // operation on the two, and pushes the result.
1552 if (stack.size() < 2) {
1554 error_ptr->SetErrorString(
1555 "Expression stack needs at least 2 items for DW_OP_or.");
1560 stack.back().ResolveValue(exe_ctx) =
1561 stack.back().ResolveValue(exe_ctx) | tmp.ResolveValue(exe_ctx);
1565 // OPCODE: DW_OP_plus
1567 // DESCRIPTION: pops the top two stack entries, adds them together, and
1568 // pushes the result.
1570 if (stack.size() < 2) {
1572 error_ptr->SetErrorString(
1573 "Expression stack needs at least 2 items for DW_OP_plus.");
1578 stack.back().GetScalar() += tmp.GetScalar();
1582 // OPCODE: DW_OP_plus_uconst
1584 // DESCRIPTION: pops the top stack entry, adds it to the unsigned LEB128
1585 // constant operand and pushes the result.
1586 case DW_OP_plus_uconst:
1587 if (stack.empty()) {
1589 error_ptr->SetErrorString(
1590 "Expression stack needs at least 1 item for DW_OP_plus_uconst.");
1593 const uint64_t uconst_value = opcodes.GetULEB128(&offset);
1594 // Implicit conversion from a UINT to a Scalar...
1595 stack.back().GetScalar() += uconst_value;
1596 if (!stack.back().GetScalar().IsValid()) {
1598 error_ptr->SetErrorString("DW_OP_plus_uconst failed.");
1604 // OPCODE: DW_OP_shl
1606 // DESCRIPTION: pops the top two stack entries, shifts the former
1607 // second entry left by the number of bits specified by the former top of
1608 // the stack, and pushes the result.
1610 if (stack.size() < 2) {
1612 error_ptr->SetErrorString(
1613 "Expression stack needs at least 2 items for DW_OP_shl.");
1618 stack.back().ResolveValue(exe_ctx) <<= tmp.ResolveValue(exe_ctx);
1622 // OPCODE: DW_OP_shr
1624 // DESCRIPTION: pops the top two stack entries, shifts the former second
1625 // entry right logically (filling with zero bits) by the number of bits
1626 // specified by the former top of the stack, and pushes the result.
1628 if (stack.size() < 2) {
1630 error_ptr->SetErrorString(
1631 "Expression stack needs at least 2 items for DW_OP_shr.");
1636 if (!stack.back().ResolveValue(exe_ctx).ShiftRightLogical(
1637 tmp.ResolveValue(exe_ctx))) {
1639 error_ptr->SetErrorString("DW_OP_shr failed.");
1645 // OPCODE: DW_OP_shra
1647 // DESCRIPTION: pops the top two stack entries, shifts the former second
1648 // entry right arithmetically (divide the magnitude by 2, keep the same
1649 // sign for the result) by the number of bits specified by the former top
1650 // of the stack, and pushes the result.
1652 if (stack.size() < 2) {
1654 error_ptr->SetErrorString(
1655 "Expression stack needs at least 2 items for DW_OP_shra.");
1660 stack.back().ResolveValue(exe_ctx) >>= tmp.ResolveValue(exe_ctx);
1664 // OPCODE: DW_OP_xor
1666 // DESCRIPTION: pops the top two stack entries, performs the bitwise
1667 // exclusive-or operation on the two, and pushes the result.
1669 if (stack.size() < 2) {
1671 error_ptr->SetErrorString(
1672 "Expression stack needs at least 2 items for DW_OP_xor.");
1677 stack.back().ResolveValue(exe_ctx) =
1678 stack.back().ResolveValue(exe_ctx) ^ tmp.ResolveValue(exe_ctx);
1682 // OPCODE: DW_OP_skip
1683 // OPERANDS: int16_t
1684 // DESCRIPTION: An unconditional branch. Its single operand is a 2-byte
1685 // signed integer constant. The 2-byte constant is the number of bytes of
1686 // the DWARF expression to skip forward or backward from the current
1687 // operation, beginning after the 2-byte constant.
1689 int16_t skip_offset = (int16_t)opcodes.GetU16(&offset);
1690 lldb::offset_t new_offset = offset + skip_offset;
1691 if (opcodes.ValidOffset(new_offset))
1692 offset = new_offset;
1695 error_ptr->SetErrorString("Invalid opcode offset in DW_OP_skip.");
1700 // OPCODE: DW_OP_bra
1701 // OPERANDS: int16_t
1702 // DESCRIPTION: A conditional branch. Its single operand is a 2-byte
1703 // signed integer constant. This operation pops the top of stack. If the
1704 // value popped is not the constant 0, the 2-byte constant operand is the
1705 // number of bytes of the DWARF expression to skip forward or backward from
1706 // the current operation, beginning after the 2-byte constant.
1708 if (stack.empty()) {
1710 error_ptr->SetErrorString(
1711 "Expression stack needs at least 1 item for DW_OP_bra.");
1716 int16_t bra_offset = (int16_t)opcodes.GetU16(&offset);
1718 if (tmp.ResolveValue(exe_ctx) != zero) {
1719 lldb::offset_t new_offset = offset + bra_offset;
1720 if (opcodes.ValidOffset(new_offset))
1721 offset = new_offset;
1724 error_ptr->SetErrorString("Invalid opcode offset in DW_OP_bra.");
1733 // DESCRIPTION: pops the top two stack values, compares using the
1734 // equals (==) operator.
1735 // STACK RESULT: push the constant value 1 onto the stack if the result
1736 // of the operation is true or the constant value 0 if the result of the
1737 // operation is false.
1739 if (stack.size() < 2) {
1741 error_ptr->SetErrorString(
1742 "Expression stack needs at least 2 items for DW_OP_eq.");
1747 stack.back().ResolveValue(exe_ctx) =
1748 stack.back().ResolveValue(exe_ctx) == tmp.ResolveValue(exe_ctx);
1754 // DESCRIPTION: pops the top two stack values, compares using the
1755 // greater than or equal to (>=) operator.
1756 // STACK RESULT: push the constant value 1 onto the stack if the result
1757 // of the operation is true or the constant value 0 if the result of the
1758 // operation is false.
1760 if (stack.size() < 2) {
1762 error_ptr->SetErrorString(
1763 "Expression stack needs at least 2 items for DW_OP_ge.");
1768 stack.back().ResolveValue(exe_ctx) =
1769 stack.back().ResolveValue(exe_ctx) >= tmp.ResolveValue(exe_ctx);
1775 // DESCRIPTION: pops the top two stack values, compares using the
1776 // greater than (>) operator.
1777 // STACK RESULT: push the constant value 1 onto the stack if the result
1778 // of the operation is true or the constant value 0 if the result of the
1779 // operation is false.
1781 if (stack.size() < 2) {
1783 error_ptr->SetErrorString(
1784 "Expression stack needs at least 2 items for DW_OP_gt.");
1789 stack.back().ResolveValue(exe_ctx) =
1790 stack.back().ResolveValue(exe_ctx) > tmp.ResolveValue(exe_ctx);
1796 // DESCRIPTION: pops the top two stack values, compares using the
1797 // less than or equal to (<=) operator.
1798 // STACK RESULT: push the constant value 1 onto the stack if the result
1799 // of the operation is true or the constant value 0 if the result of the
1800 // operation is false.
1802 if (stack.size() < 2) {
1804 error_ptr->SetErrorString(
1805 "Expression stack needs at least 2 items for DW_OP_le.");
1810 stack.back().ResolveValue(exe_ctx) =
1811 stack.back().ResolveValue(exe_ctx) <= tmp.ResolveValue(exe_ctx);
1817 // DESCRIPTION: pops the top two stack values, compares using the
1818 // less than (<) operator.
1819 // STACK RESULT: push the constant value 1 onto the stack if the result
1820 // of the operation is true or the constant value 0 if the result of the
1821 // operation is false.
1823 if (stack.size() < 2) {
1825 error_ptr->SetErrorString(
1826 "Expression stack needs at least 2 items for DW_OP_lt.");
1831 stack.back().ResolveValue(exe_ctx) =
1832 stack.back().ResolveValue(exe_ctx) < tmp.ResolveValue(exe_ctx);
1838 // DESCRIPTION: pops the top two stack values, compares using the
1839 // not equal (!=) operator.
1840 // STACK RESULT: push the constant value 1 onto the stack if the result
1841 // of the operation is true or the constant value 0 if the result of the
1842 // operation is false.
1844 if (stack.size() < 2) {
1846 error_ptr->SetErrorString(
1847 "Expression stack needs at least 2 items for DW_OP_ne.");
1852 stack.back().ResolveValue(exe_ctx) =
1853 stack.back().ResolveValue(exe_ctx) != tmp.ResolveValue(exe_ctx);
1857 // OPCODE: DW_OP_litn
1859 // DESCRIPTION: encode the unsigned literal values from 0 through 31.
1860 // STACK RESULT: push the unsigned literal constant value onto the top
1894 stack.push_back(Scalar((uint64_t)(op - DW_OP_lit0)));
1897 // OPCODE: DW_OP_regN
1899 // DESCRIPTION: Push the value in register n on the top of the stack.
1932 reg_num = op - DW_OP_reg0;
1934 if (ReadRegisterValueAsScalar(reg_ctx, reg_kind, reg_num, error_ptr, tmp))
1935 stack.push_back(tmp);
1939 // OPCODE: DW_OP_regx
1941 // ULEB128 literal operand that encodes the register.
1942 // DESCRIPTION: Push the value in register on the top of the stack.
1944 reg_num = opcodes.GetULEB128(&offset);
1945 if (ReadRegisterValueAsScalar(reg_ctx, reg_kind, reg_num, error_ptr, tmp))
1946 stack.push_back(tmp);
1951 // OPCODE: DW_OP_bregN
1953 // SLEB128 offset from register N
1954 // DESCRIPTION: Value is in memory at the address specified by register
1955 // N plus an offset.
1987 case DW_OP_breg31: {
1988 reg_num = op - DW_OP_breg0;
1990 if (ReadRegisterValueAsScalar(reg_ctx, reg_kind, reg_num, error_ptr,
1992 int64_t breg_offset = opcodes.GetSLEB128(&offset);
1993 tmp.ResolveValue(exe_ctx) += (uint64_t)breg_offset;
1995 stack.push_back(tmp);
1996 stack.back().SetValueType(Value::eValueTypeLoadAddress);
2000 // OPCODE: DW_OP_bregx
2002 // ULEB128 literal operand that encodes the register.
2003 // SLEB128 offset from register N
2004 // DESCRIPTION: Value is in memory at the address specified by register
2005 // N plus an offset.
2007 reg_num = opcodes.GetULEB128(&offset);
2009 if (ReadRegisterValueAsScalar(reg_ctx, reg_kind, reg_num, error_ptr,
2011 int64_t breg_offset = opcodes.GetSLEB128(&offset);
2012 tmp.ResolveValue(exe_ctx) += (uint64_t)breg_offset;
2014 stack.push_back(tmp);
2015 stack.back().SetValueType(Value::eValueTypeLoadAddress);
2024 if (frame->GetFrameBaseValue(value, error_ptr)) {
2025 int64_t fbreg_offset = opcodes.GetSLEB128(&offset);
2026 value += fbreg_offset;
2027 stack.push_back(value);
2028 stack.back().SetValueType(Value::eValueTypeLoadAddress);
2033 error_ptr->SetErrorString(
2034 "Invalid stack frame in context for DW_OP_fbreg opcode.");
2039 error_ptr->SetErrorStringWithFormat(
2040 "NULL execution context for DW_OP_fbreg.\n");
2046 // OPCODE: DW_OP_nop
2048 // DESCRIPTION: A place holder. It has no effect on the location stack
2049 // or any of its values.
2053 // OPCODE: DW_OP_piece
2055 // ULEB128: byte size of the piece
2056 // DESCRIPTION: The operand describes the size in bytes of the piece of
2057 // the object referenced by the DWARF expression whose result is at the top
2058 // of the stack. If the piece is located in a register, but does not occupy
2059 // the entire register, the placement of the piece within that register is
2060 // defined by the ABI.
2062 // Many compilers store a single variable in sets of registers, or store a
2063 // variable partially in memory and partially in registers. DW_OP_piece
2064 // provides a way of describing how large a part of a variable a particular
2065 // DWARF expression refers to.
2067 const uint64_t piece_byte_size = opcodes.GetULEB128(&offset);
2069 if (piece_byte_size > 0) {
2072 if (stack.empty()) {
2073 // In a multi-piece expression, this means that the current piece is
2074 // not available. Fill with zeros for now by resizing the data and
2076 curr_piece.ResizeData(piece_byte_size);
2077 // Note that "0" is not a correct value for the unknown bits.
2078 // It would be better to also return a mask of valid bits together
2079 // with the expression result, so the debugger can print missing
2080 // members as "<optimized out>" or something.
2081 ::memset(curr_piece.GetBuffer().GetBytes(), 0, piece_byte_size);
2082 pieces.AppendDataToHostBuffer(curr_piece);
2085 // Extract the current piece into "curr_piece"
2086 Value curr_piece_source_value(stack.back());
2089 const Value::ValueType curr_piece_source_value_type =
2090 curr_piece_source_value.GetValueType();
2091 switch (curr_piece_source_value_type) {
2092 case Value::eValueTypeLoadAddress:
2094 if (curr_piece.ResizeData(piece_byte_size) == piece_byte_size) {
2095 lldb::addr_t load_addr =
2096 curr_piece_source_value.GetScalar().ULongLong(
2097 LLDB_INVALID_ADDRESS);
2098 if (process->ReadMemory(
2099 load_addr, curr_piece.GetBuffer().GetBytes(),
2100 piece_byte_size, error) != piece_byte_size) {
2102 error_ptr->SetErrorStringWithFormat(
2103 "failed to read memory DW_OP_piece(%" PRIu64
2104 ") from 0x%" PRIx64,
2105 piece_byte_size, load_addr);
2110 error_ptr->SetErrorStringWithFormat(
2111 "failed to resize the piece memory buffer for "
2112 "DW_OP_piece(%" PRIu64 ")",
2119 case Value::eValueTypeFileAddress:
2120 case Value::eValueTypeHostAddress:
2122 lldb::addr_t addr = curr_piece_source_value.GetScalar().ULongLong(
2123 LLDB_INVALID_ADDRESS);
2124 error_ptr->SetErrorStringWithFormat(
2125 "failed to read memory DW_OP_piece(%" PRIu64
2126 ") from %s address 0x%" PRIx64,
2127 piece_byte_size, curr_piece_source_value.GetValueType() ==
2128 Value::eValueTypeFileAddress
2135 case Value::eValueTypeScalar: {
2136 uint32_t bit_size = piece_byte_size * 8;
2137 uint32_t bit_offset = 0;
2138 Scalar &scalar = curr_piece_source_value.GetScalar();
2139 if (!scalar.ExtractBitfield(
2140 bit_size, bit_offset)) {
2142 error_ptr->SetErrorStringWithFormat(
2143 "unable to extract %" PRIu64 " bytes from a %" PRIu64
2144 " byte scalar value.",
2146 (uint64_t)curr_piece_source_value.GetScalar()
2150 // Create curr_piece with bit_size. By default Scalar
2151 // grows to the nearest host integer type.
2152 llvm::APInt fail_value(1, 0, false);
2153 llvm::APInt ap_int = scalar.UInt128(fail_value);
2154 assert(ap_int.getBitWidth() >= bit_size);
2155 llvm::ArrayRef<uint64_t> buf{ap_int.getRawData(),
2156 ap_int.getNumWords()};
2157 curr_piece.GetScalar() = Scalar(llvm::APInt(bit_size, buf));
2160 case Value::eValueTypeVector: {
2161 if (curr_piece_source_value.GetVector().length >= piece_byte_size)
2162 curr_piece_source_value.GetVector().length = piece_byte_size;
2165 error_ptr->SetErrorStringWithFormat(
2166 "unable to extract %" PRIu64 " bytes from a %" PRIu64
2167 " byte vector value.",
2169 (uint64_t)curr_piece_source_value.GetVector().length);
2175 // Check if this is the first piece?
2176 if (op_piece_offset == 0) {
2177 // This is the first piece, we should push it back onto the stack
2178 // so subsequent pieces will be able to access this piece and add
2180 if (pieces.AppendDataToHostBuffer(curr_piece) == 0) {
2182 error_ptr->SetErrorString("failed to append piece data");
2186 // If this is the second or later piece there should be a value on
2188 if (pieces.GetBuffer().GetByteSize() != op_piece_offset) {
2190 error_ptr->SetErrorStringWithFormat(
2191 "DW_OP_piece for offset %" PRIu64
2192 " but top of stack is of size %" PRIu64,
2193 op_piece_offset, pieces.GetBuffer().GetByteSize());
2197 if (pieces.AppendDataToHostBuffer(curr_piece) == 0) {
2199 error_ptr->SetErrorString("failed to append piece data");
2204 op_piece_offset += piece_byte_size;
2208 case DW_OP_bit_piece: // 0x9d ULEB128 bit size, ULEB128 bit offset (DWARF3);
2209 if (stack.size() < 1) {
2211 error_ptr->SetErrorString(
2212 "Expression stack needs at least 1 item for DW_OP_bit_piece.");
2215 const uint64_t piece_bit_size = opcodes.GetULEB128(&offset);
2216 const uint64_t piece_bit_offset = opcodes.GetULEB128(&offset);
2217 switch (stack.back().GetValueType()) {
2218 case Value::eValueTypeScalar: {
2219 if (!stack.back().GetScalar().ExtractBitfield(piece_bit_size,
2220 piece_bit_offset)) {
2222 error_ptr->SetErrorStringWithFormat(
2223 "unable to extract %" PRIu64 " bit value with %" PRIu64
2224 " bit offset from a %" PRIu64 " bit scalar value.",
2225 piece_bit_size, piece_bit_offset,
2226 (uint64_t)(stack.back().GetScalar().GetByteSize() * 8));
2231 case Value::eValueTypeFileAddress:
2232 case Value::eValueTypeLoadAddress:
2233 case Value::eValueTypeHostAddress:
2235 error_ptr->SetErrorStringWithFormat(
2236 "unable to extract DW_OP_bit_piece(bit_size = %" PRIu64
2237 ", bit_offset = %" PRIu64 ") from an address value.",
2238 piece_bit_size, piece_bit_offset);
2242 case Value::eValueTypeVector:
2244 error_ptr->SetErrorStringWithFormat(
2245 "unable to extract DW_OP_bit_piece(bit_size = %" PRIu64
2246 ", bit_offset = %" PRIu64 ") from a vector value.",
2247 piece_bit_size, piece_bit_offset);
2254 // OPCODE: DW_OP_push_object_address
2256 // DESCRIPTION: Pushes the address of the object currently being
2257 // evaluated as part of evaluation of a user presented expression. This
2258 // object may correspond to an independent variable described by its own
2259 // DIE or it may be a component of an array, structure, or class whose
2260 // address has been dynamically determined by an earlier step during user
2261 // expression evaluation.
2262 case DW_OP_push_object_address:
2263 if (object_address_ptr)
2264 stack.push_back(*object_address_ptr);
2267 error_ptr->SetErrorString("DW_OP_push_object_address used without "
2268 "specifying an object address");
2273 // OPCODE: DW_OP_call2
2275 // uint16_t compile unit relative offset of a DIE
2276 // DESCRIPTION: Performs subroutine calls during evaluation
2277 // of a DWARF expression. The operand is the 2-byte unsigned offset of a
2278 // debugging information entry in the current compilation unit.
2280 // Operand interpretation is exactly like that for DW_FORM_ref2.
2282 // This operation transfers control of DWARF expression evaluation to the
2283 // DW_AT_location attribute of the referenced DIE. If there is no such
2284 // attribute, then there is no effect. Execution of the DWARF expression of
2285 // a DW_AT_location attribute may add to and/or remove from values on the
2286 // stack. Execution returns to the point following the call when the end of
2287 // the attribute is reached. Values on the stack at the time of the call
2288 // may be used as parameters by the called expression and values left on
2289 // the stack by the called expression may be used as return values by prior
2290 // agreement between the calling and called expressions.
2293 error_ptr->SetErrorString("Unimplemented opcode DW_OP_call2.");
2295 // OPCODE: DW_OP_call4
2297 // uint32_t compile unit relative offset of a DIE
2298 // DESCRIPTION: Performs a subroutine call during evaluation of a DWARF
2299 // expression. For DW_OP_call4, the operand is a 4-byte unsigned offset of
2300 // a debugging information entry in the current compilation unit.
2302 // Operand interpretation DW_OP_call4 is exactly like that for
2305 // This operation transfers control of DWARF expression evaluation to the
2306 // DW_AT_location attribute of the referenced DIE. If there is no such
2307 // attribute, then there is no effect. Execution of the DWARF expression of
2308 // a DW_AT_location attribute may add to and/or remove from values on the
2309 // stack. Execution returns to the point following the call when the end of
2310 // the attribute is reached. Values on the stack at the time of the call
2311 // may be used as parameters by the called expression and values left on
2312 // the stack by the called expression may be used as return values by prior
2313 // agreement between the calling and called expressions.
2316 error_ptr->SetErrorString("Unimplemented opcode DW_OP_call4.");
2319 // OPCODE: DW_OP_stack_value
2321 // DESCRIPTION: Specifies that the object does not exist in memory but
2322 // rather is a constant value. The value from the top of the stack is the
2323 // value to be used. This is the actual object value and not the location.
2324 case DW_OP_stack_value:
2325 if (stack.empty()) {
2327 error_ptr->SetErrorString(
2328 "Expression stack needs at least 1 item for DW_OP_stack_value.");
2331 stack.back().SetValueType(Value::eValueTypeScalar);
2334 // OPCODE: DW_OP_convert
2336 // A ULEB128 that is either a DIE offset of a
2337 // DW_TAG_base_type or 0 for the generic (pointer-sized) type.
2339 // DESCRIPTION: Pop the top stack element, convert it to a
2340 // different type, and push the result.
2341 case DW_OP_convert: {
2342 if (stack.size() < 1) {
2344 error_ptr->SetErrorString(
2345 "Expression stack needs at least 1 item for DW_OP_convert.");
2348 const uint64_t die_offset = opcodes.GetULEB128(&offset);
2351 if (die_offset == 0) {
2352 // The generic type has the size of an address on the target
2353 // machine and an unspecified signedness. Scalar has no
2354 // "unspecified signedness", so we use unsigned types.
2357 error_ptr->SetErrorString("No module");
2361 bit_size = module_sp->GetArchitecture().GetAddressByteSize() * 8;
2364 error_ptr->SetErrorString("unspecified architecture");
2368 // Retrieve the type DIE that the value is being converted to.
2369 // FIXME: the constness has annoying ripple effects.
2370 DWARFDIE die = const_cast<DWARFUnit *>(dwarf_cu)->GetDIE(die_offset);
2373 error_ptr->SetErrorString("Cannot resolve DW_OP_convert type DIE");
2377 die.GetAttributeValueAsUnsigned(DW_AT_encoding, DW_ATE_hi_user);
2378 bit_size = die.GetAttributeValueAsUnsigned(DW_AT_byte_size, 0) * 8;
2380 bit_size = die.GetAttributeValueAsUnsigned(DW_AT_bit_size, 0);
2383 error_ptr->SetErrorString("Unsupported type size in DW_OP_convert");
2388 case DW_ATE_signed_char:
2391 case DW_ATE_unsigned:
2392 case DW_ATE_unsigned_char:
2397 error_ptr->SetErrorString("Unsupported encoding in DW_OP_convert");
2401 Scalar &top = stack.back().ResolveValue(exe_ctx);
2402 top.TruncOrExtendTo(bit_size, sign);
2406 // OPCODE: DW_OP_call_frame_cfa
2408 // DESCRIPTION: Specifies a DWARF expression that pushes the value of
2409 // the canonical frame address consistent with the call frame information
2410 // located in .debug_frame (or in the FDEs of the eh_frame section).
2411 case DW_OP_call_frame_cfa:
2413 // Note that we don't have to parse FDEs because this DWARF expression
2414 // is commonly evaluated with a valid stack frame.
2415 StackID id = frame->GetStackID();
2416 addr_t cfa = id.GetCallFrameAddress();
2417 if (cfa != LLDB_INVALID_ADDRESS) {
2418 stack.push_back(Scalar(cfa));
2419 stack.back().SetValueType(Value::eValueTypeLoadAddress);
2420 } else if (error_ptr)
2421 error_ptr->SetErrorString("Stack frame does not include a canonical "
2422 "frame address for DW_OP_call_frame_cfa "
2426 error_ptr->SetErrorString("Invalid stack frame in context for "
2427 "DW_OP_call_frame_cfa opcode.");
2432 // OPCODE: DW_OP_form_tls_address (or the old pre-DWARFv3 vendor extension
2433 // opcode, DW_OP_GNU_push_tls_address)
2435 // DESCRIPTION: Pops a TLS offset from the stack, converts it to
2436 // an address in the current thread's thread-local storage block, and
2437 // pushes it on the stack.
2438 case DW_OP_form_tls_address:
2439 case DW_OP_GNU_push_tls_address: {
2440 if (stack.size() < 1) {
2442 if (op == DW_OP_form_tls_address)
2443 error_ptr->SetErrorString(
2444 "DW_OP_form_tls_address needs an argument.");
2446 error_ptr->SetErrorString(
2447 "DW_OP_GNU_push_tls_address needs an argument.");
2452 if (!exe_ctx || !module_sp) {
2454 error_ptr->SetErrorString("No context to evaluate TLS within.");
2458 Thread *thread = exe_ctx->GetThreadPtr();
2461 error_ptr->SetErrorString("No thread to evaluate TLS within.");
2465 // Lookup the TLS block address for this thread and module.
2466 const addr_t tls_file_addr =
2467 stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
2468 const addr_t tls_load_addr =
2469 thread->GetThreadLocalData(module_sp, tls_file_addr);
2471 if (tls_load_addr == LLDB_INVALID_ADDRESS) {
2473 error_ptr->SetErrorString(
2474 "No TLS data currently exists for this thread.");
2478 stack.back().GetScalar() = tls_load_addr;
2479 stack.back().SetValueType(Value::eValueTypeLoadAddress);
2482 // OPCODE: DW_OP_addrx (DW_OP_GNU_addr_index is the legacy name.)
2484 // ULEB128: index to the .debug_addr section
2485 // DESCRIPTION: Pushes an address to the stack from the .debug_addr
2486 // section with the base address specified by the DW_AT_addr_base attribute
2487 // and the 0 based index is the ULEB128 encoded index.
2489 case DW_OP_GNU_addr_index: {
2492 error_ptr->SetErrorString("DW_OP_GNU_addr_index found without a "
2493 "compile unit being specified");
2496 uint64_t index = opcodes.GetULEB128(&offset);
2497 lldb::addr_t value = ReadAddressFromDebugAddrSection(dwarf_cu, index);
2498 stack.push_back(Scalar(value));
2499 stack.back().SetValueType(Value::eValueTypeFileAddress);
2502 // OPCODE: DW_OP_GNU_const_index
2504 // ULEB128: index to the .debug_addr section
2505 // DESCRIPTION: Pushes an constant with the size of a machine address to
2506 // the stack from the .debug_addr section with the base address specified
2507 // by the DW_AT_addr_base attribute and the 0 based index is the ULEB128
2509 case DW_OP_GNU_const_index: {
2512 error_ptr->SetErrorString("DW_OP_GNU_const_index found without a "
2513 "compile unit being specified");
2516 uint64_t index = opcodes.GetULEB128(&offset);
2517 lldb::addr_t value = ReadAddressFromDebugAddrSection(dwarf_cu, index);
2518 stack.push_back(Scalar(value));
2521 case DW_OP_GNU_entry_value:
2522 case DW_OP_entry_value: {
2523 if (!Evaluate_DW_OP_entry_value(stack, exe_ctx, reg_ctx, opcodes, offset,
2525 LLDB_ERRORF(error_ptr, "Could not evaluate %s.",
2526 DW_OP_value_to_name(op));
2534 error_ptr->SetErrorStringWithFormatv(
2535 "Unhandled opcode {0} in DWARFExpression", LocationAtom(op));
2540 if (stack.empty()) {
2541 // Nothing on the stack, check if we created a piece value from DW_OP_piece
2542 // or DW_OP_bit_piece opcodes
2543 if (pieces.GetBuffer().GetByteSize()) {
2547 error_ptr->SetErrorString("Stack empty after evaluation.");
2551 if (log && log->GetVerbose()) {
2552 size_t count = stack.size();
2553 LLDB_LOGF(log, "Stack after operation has %" PRIu64 " values:",
2555 for (size_t i = 0; i < count; ++i) {
2556 StreamString new_value;
2557 new_value.Printf("[%" PRIu64 "]", (uint64_t)i);
2558 stack[i].Dump(&new_value);
2559 LLDB_LOGF(log, " %s", new_value.GetData());
2562 result = stack.back();
2564 return true; // Return true on success
2567 static DataExtractor ToDataExtractor(const llvm::DWARFLocationExpression &loc,
2568 ByteOrder byte_order, uint32_t addr_size) {
2570 std::make_shared<DataBufferHeap>(loc.Expr.data(), loc.Expr.size());
2571 return DataExtractor(buffer_sp, byte_order, addr_size);
2574 llvm::Optional<DataExtractor>
2575 DWARFExpression::GetLocationExpression(addr_t load_function_start,
2576 addr_t addr) const {
2577 Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS);
2579 std::unique_ptr<llvm::DWARFLocationTable> loctable_up =
2580 m_dwarf_cu->GetLocationTable(m_data);
2581 llvm::Optional<DataExtractor> result;
2582 uint64_t offset = 0;
2584 [&](uint32_t index) -> llvm::Optional<llvm::object::SectionedAddress> {
2585 addr_t address = ReadAddressFromDebugAddrSection(m_dwarf_cu, index);
2586 if (address == LLDB_INVALID_ADDRESS)
2588 return llvm::object::SectionedAddress{address};
2590 auto process_list = [&](llvm::Expected<llvm::DWARFLocationExpression> loc) {
2592 LLDB_LOG_ERROR(log, loc.takeError(), "{0}");
2596 // This relocates low_pc and high_pc by adding the difference between the
2597 // function file address, and the actual address it is loaded in memory.
2598 addr_t slide = load_function_start - m_loclist_addresses->func_file_addr;
2599 loc->Range->LowPC += slide;
2600 loc->Range->HighPC += slide;
2602 if (loc->Range->LowPC <= addr && addr < loc->Range->HighPC)
2603 result = ToDataExtractor(*loc, m_data.GetByteOrder(),
2604 m_data.GetAddressByteSize());
2608 llvm::Error E = loctable_up->visitAbsoluteLocationList(
2609 offset, llvm::object::SectionedAddress{m_loclist_addresses->cu_file_addr},
2610 lookup_addr, process_list);
2612 LLDB_LOG_ERROR(log, std::move(E), "{0}");
2616 bool DWARFExpression::MatchesOperand(StackFrame &frame,
2617 const Instruction::Operand &operand) {
2618 using namespace OperandMatchers;
2620 RegisterContextSP reg_ctx_sp = frame.GetRegisterContext();
2625 DataExtractor opcodes;
2626 if (IsLocationList()) {
2627 SymbolContext sc = frame.GetSymbolContext(eSymbolContextFunction);
2631 addr_t load_function_start =
2632 sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
2633 if (load_function_start == LLDB_INVALID_ADDRESS)
2636 addr_t pc = frame.GetFrameCodeAddress().GetLoadAddress(
2637 frame.CalculateTarget().get());
2639 if (llvm::Optional<DataExtractor> expr = GetLocationExpression(load_function_start, pc))
2640 opcodes = std::move(*expr);
2647 lldb::offset_t op_offset = 0;
2648 uint8_t opcode = opcodes.GetU8(&op_offset);
2650 if (opcode == DW_OP_fbreg) {
2651 int64_t offset = opcodes.GetSLEB128(&op_offset);
2653 DWARFExpression *fb_expr = frame.GetFrameBaseExpression(nullptr);
2658 auto recurse = [&frame, fb_expr](const Instruction::Operand &child) {
2659 return fb_expr->MatchesOperand(frame, child);
2663 MatchUnaryOp(MatchOpType(Instruction::Operand::Type::Dereference),
2664 recurse)(operand)) {
2668 return MatchUnaryOp(
2669 MatchOpType(Instruction::Operand::Type::Dereference),
2670 MatchBinaryOp(MatchOpType(Instruction::Operand::Type::Sum),
2671 MatchImmOp(offset), recurse))(operand);
2674 bool dereference = false;
2675 const RegisterInfo *reg = nullptr;
2678 if (opcode >= DW_OP_reg0 && opcode <= DW_OP_reg31) {
2679 reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, opcode - DW_OP_reg0);
2680 } else if (opcode >= DW_OP_breg0 && opcode <= DW_OP_breg31) {
2681 offset = opcodes.GetSLEB128(&op_offset);
2682 reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, opcode - DW_OP_breg0);
2683 } else if (opcode == DW_OP_regx) {
2684 uint32_t reg_num = static_cast<uint32_t>(opcodes.GetULEB128(&op_offset));
2685 reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, reg_num);
2686 } else if (opcode == DW_OP_bregx) {
2687 uint32_t reg_num = static_cast<uint32_t>(opcodes.GetULEB128(&op_offset));
2688 offset = opcodes.GetSLEB128(&op_offset);
2689 reg = reg_ctx_sp->GetRegisterInfo(m_reg_kind, reg_num);
2700 MatchUnaryOp(MatchOpType(Instruction::Operand::Type::Dereference),
2701 MatchRegOp(*reg))(operand)) {
2705 return MatchUnaryOp(
2706 MatchOpType(Instruction::Operand::Type::Dereference),
2707 MatchBinaryOp(MatchOpType(Instruction::Operand::Type::Sum),
2709 MatchImmOp(offset)))(operand);
2711 return MatchRegOp(*reg)(operand);