1//===----------------------------------------------------------------------===//
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// Processor specific interpretation of DWARF unwind info.
9//
10//===----------------------------------------------------------------------===//
11
12#ifndef __DWARF_INSTRUCTIONS_HPP__
13#define __DWARF_INSTRUCTIONS_HPP__
14
15#include <stdint.h>
16#include <stdio.h>
17#include <stdlib.h>
18
19#include "DwarfParser.hpp"
20#include "Registers.hpp"
21#include "config.h"
22#include "dwarf2.h"
23#include "libunwind_ext.h"
24
25namespace libunwind {
26
27
28/// DwarfInstructions maps abstract DWARF unwind instructions to a particular
29/// architecture
30template <typename A, typename R>
31class DwarfInstructions {
32public:
33 typedef typename A::pint_t pint_t;
34 typedef typename A::sint_t sint_t;
35
36 static int stepWithDwarf(A &addressSpace,
37 typename R::link_hardened_reg_arg_t pc,
38 pint_t fdeStart, R &registers, bool &isSignalFrame,
39 bool stage2);
40
41private:
42
43 enum {
44 DW_X86_64_RET_ADDR = 16
45 };
46
47 enum {
48 DW_X86_RET_ADDR = 8
49 };
50
51 typedef typename CFI_Parser<A>::RegisterLocation RegisterLocation;
52 typedef typename CFI_Parser<A>::PrologInfo PrologInfo;
53 typedef typename CFI_Parser<A>::FDE_Info FDE_Info;
54 typedef typename CFI_Parser<A>::CIE_Info CIE_Info;
55
56 static pint_t evaluateExpression(pint_t expression, A &addressSpace,
57 const R &registers,
58 pint_t initialStackValue);
59 static pint_t getSavedRegister(A &addressSpace, const R &registers,
60 pint_t cfa, const RegisterLocation &savedReg);
61 static double getSavedFloatRegister(A &addressSpace, const R &registers,
62 pint_t cfa, const RegisterLocation &savedReg);
63 static v128 getSavedVectorRegister(A &addressSpace, const R &registers,
64 pint_t cfa, const RegisterLocation &savedReg);
65
66 static pint_t getCFA(A &addressSpace, const PrologInfo &prolog,
67 const R &registers) {
68 if (prolog.cfaRegister != 0) {
69 uintptr_t cfaRegister = registers.getRegister((int)prolog.cfaRegister);
70 return (pint_t)(cfaRegister + prolog.cfaRegisterOffset);
71 }
72 if (prolog.cfaExpression != 0)
73 return evaluateExpression(expression: (pint_t)prolog.cfaExpression, addressSpace,
74 registers, initialStackValue: 0);
75 assert(0 && "getCFA(): unknown location");
76 __builtin_unreachable();
77 }
78#if defined(_LIBUNWIND_TARGET_AARCH64)
79 enum RASignStatus {
80 RANotSigned = 0,
81 RASigned = 1,
82 RASignedWithPC = 2,
83 };
84 static RASignStatus getReturnAddressSignStatus(A &addressSpace, R registers,
85 pint_t cfa,
86 PrologInfo &prolog);
87
88 __attribute__((target("pauth-lr"))) static pint_t
89 nonHintLRAuthentication(pint_t ptrAuthDiv, pint_t cfa, pint_t returnAddr,
90 bool BKey);
91#endif
92};
93
94template <typename R>
95auto getSparcWCookie(const R &r, int) -> decltype(r.getWCookie()) {
96 return r.getWCookie();
97}
98template <typename R> uint64_t getSparcWCookie(const R &, long) {
99 return 0;
100}
101
102template <typename A, typename R>
103typename A::pint_t DwarfInstructions<A, R>::getSavedRegister(
104 A &addressSpace, const R &registers, pint_t cfa,
105 const RegisterLocation &savedReg) {
106 switch (savedReg.location) {
107 case CFI_Parser<A>::kRegisterInCFA:
108 return (pint_t)addressSpace.getRegister(cfa + (pint_t)savedReg.value);
109
110 case CFI_Parser<A>::kRegisterInCFADecrypt: // sparc64 specific
111 return (pint_t)(addressSpace.getP(cfa + (pint_t)savedReg.value) ^
112 getSparcWCookie(registers, 0));
113
114 case CFI_Parser<A>::kRegisterAtExpression:
115 return (pint_t)addressSpace.getRegister(evaluateExpression(
116 expression: (pint_t)savedReg.value, addressSpace, registers, initialStackValue: cfa));
117
118 case CFI_Parser<A>::kRegisterIsExpression:
119 return evaluateExpression(expression: (pint_t)savedReg.value, addressSpace,
120 registers, initialStackValue: cfa);
121
122 case CFI_Parser<A>::kRegisterInRegister:
123 return registers.getRegister((int)savedReg.value);
124
125 case CFI_Parser<A>::kRegisterUndefined:
126 return 0;
127
128 case CFI_Parser<A>::kRegisterIsPseudo:
129#if defined(_LIBUNWIND_TARGET_AARCH64)
130 return savedReg.value;
131#endif
132 case CFI_Parser<A>::kRegisterUnused:
133 case CFI_Parser<A>::kRegisterOffsetFromCFA:
134 // FIX ME
135 break;
136 }
137 _LIBUNWIND_ABORT("unsupported restore location for register");
138}
139
140template <typename A, typename R>
141double DwarfInstructions<A, R>::getSavedFloatRegister(
142 A &addressSpace, const R &registers, pint_t cfa,
143 const RegisterLocation &savedReg) {
144 switch (savedReg.location) {
145 case CFI_Parser<A>::kRegisterInCFA:
146 return addressSpace.getDouble(cfa + (pint_t)savedReg.value);
147
148 case CFI_Parser<A>::kRegisterAtExpression:
149 return addressSpace.getDouble(
150 evaluateExpression(expression: (pint_t)savedReg.value, addressSpace,
151 registers, initialStackValue: cfa));
152 case CFI_Parser<A>::kRegisterUndefined:
153 return 0.0;
154 case CFI_Parser<A>::kRegisterInRegister:
155#ifndef _LIBUNWIND_TARGET_ARM
156 return registers.getFloatRegister((int)savedReg.value);
157#endif
158 case CFI_Parser<A>::kRegisterIsPseudo:
159 case CFI_Parser<A>::kRegisterIsExpression:
160 case CFI_Parser<A>::kRegisterUnused:
161 case CFI_Parser<A>::kRegisterOffsetFromCFA:
162 case CFI_Parser<A>::kRegisterInCFADecrypt:
163 // FIX ME
164 break;
165 }
166 _LIBUNWIND_ABORT("unsupported restore location for float register");
167}
168
169template <typename A, typename R>
170v128 DwarfInstructions<A, R>::getSavedVectorRegister(
171 A &addressSpace, const R &registers, pint_t cfa,
172 const RegisterLocation &savedReg) {
173 switch (savedReg.location) {
174 case CFI_Parser<A>::kRegisterInCFA:
175 return addressSpace.getVector(cfa + (pint_t)savedReg.value);
176
177 case CFI_Parser<A>::kRegisterAtExpression:
178 return addressSpace.getVector(
179 evaluateExpression(expression: (pint_t)savedReg.value, addressSpace,
180 registers, initialStackValue: cfa));
181
182 case CFI_Parser<A>::kRegisterIsPseudo:
183 case CFI_Parser<A>::kRegisterIsExpression:
184 case CFI_Parser<A>::kRegisterUnused:
185 case CFI_Parser<A>::kRegisterUndefined:
186 case CFI_Parser<A>::kRegisterOffsetFromCFA:
187 case CFI_Parser<A>::kRegisterInRegister:
188 case CFI_Parser<A>::kRegisterInCFADecrypt:
189 // FIX ME
190 break;
191 }
192 _LIBUNWIND_ABORT("unsupported restore location for vector register");
193}
194#if defined(_LIBUNWIND_TARGET_AARCH64)
195template <typename A, typename R>
196typename DwarfInstructions<A, R>::RASignStatus
197DwarfInstructions<A, R>::getReturnAddressSignStatus(A &addressSpace,
198 R registers, pint_t cfa,
199 PrologInfo &prolog) {
200 pint_t raSignState;
201 auto regloc = prolog.savedRegisters[UNW_AARCH64_RA_SIGN_STATE];
202 if (regloc.location == CFI_Parser<A>::kRegisterUnused)
203 raSignState = static_cast<pint_t>(regloc.value);
204 else
205 raSignState = getSavedRegister(addressSpace, registers, cfa, regloc);
206
207 // bits[1:0] describe how RA is signed.
208 assert((raSignState & 0x3) != 3 && "unexpected RA sign state");
209 return static_cast<RASignStatus>(raSignState & 0x3);
210}
211
212template <typename A, typename R>
213__attribute__((target("pauth-lr"))) typename A::pint_t
214DwarfInstructions<A, R>::nonHintLRAuthentication(pint_t ptrAuthDiv, pint_t cfa,
215 pint_t returnAddr, bool BKey) {
216 register unsigned long long x15 __asm("x15") = ptrAuthDiv;
217 register unsigned long long x16 __asm("x16") = cfa;
218 register unsigned long long x17 __asm("x17") = returnAddr;
219 if (BKey)
220 asm("autib171615" : "+r"(x17) : "r"(x16), "r"(x15));
221 else
222 asm("autia171615" : "+r"(x17) : "r"(x16), "r"(x15));
223
224 return x17;
225}
226#endif
227
228template <typename A, typename R>
229int DwarfInstructions<A, R>::stepWithDwarf(
230 A &addressSpace, typename R::link_hardened_reg_arg_t pc, pint_t fdeStart,
231 R &registers, bool &isSignalFrame, bool stage2) {
232 FDE_Info fdeInfo;
233 CIE_Info cieInfo;
234 if (CFI_Parser<A>::decodeFDE(addressSpace, fdeStart, &fdeInfo,
235 &cieInfo) == NULL) {
236 PrologInfo prolog;
237 if (CFI_Parser<A>::template parseFDEInstructions<R>(
238 addressSpace, fdeInfo, cieInfo, pc, R::getArch(), &prolog)) {
239 // get pointer to cfa (architecture specific)
240 pint_t cfa = getCFA(addressSpace, prolog, registers);
241
242 (void)stage2;
243 // __unw_step_stage2 is not used for cross unwinding, so we use
244 // __aarch64__ rather than LIBUNWIND_TARGET_AARCH64 to make sure we are
245 // building for AArch64 natively.
246#if defined(__aarch64__) && !defined(__LFI__)
247 if (stage2 && cieInfo.mteTaggedFrame) {
248 pint_t sp = registers.getSP();
249 pint_t p = sp;
250 // AArch64 doesn't require the value of SP to be 16-byte aligned at
251 // all times, only at memory accesses and public interfaces [1]. Thus,
252 // a signal could arrive at a point where SP is not aligned properly.
253 // In that case, the kernel fixes up [2] the signal frame, but we
254 // still have a misaligned SP in the previous frame. If that signal
255 // handler caused stack unwinding, we would have an unaligned SP.
256 // We do not need to fix up the CFA, as that is the SP at a "public
257 // interface".
258 // [1]:
259 // https://github.com/ARM-software/abi-aa/blob/main/aapcs64/aapcs64.rst#622the-stack
260 // [2]:
261 // https://github.com/torvalds/linux/blob/1930a6e739c4b4a654a69164dbe39e554d228915/arch/arm64/kernel/signal.c#L718
262 p &= ~0xfULL;
263 // CFA is the bottom of the current stack frame.
264 for (; p < cfa; p += 16) {
265 __asm__ __volatile__(".arch armv8.5-a\n"
266 ".arch_extension memtag\n"
267 "stg %[Ptr], [%[Ptr]]\n"
268 :
269 : [Ptr] "r"(p)
270 : "memory");
271 }
272 }
273#endif
274 // restore registers that DWARF says were saved
275 R newRegisters = registers;
276
277 // Typically, the CFA is the stack pointer at the call site in
278 // the previous frame. However, there are scenarios in which this is not
279 // true. For example, if we switched to a new stack. In that case, the
280 // value of the previous SP might be indicated by a CFI directive.
281 //
282 // We set the SP here to the CFA, allowing for it to be overridden
283 // by a CFI directive later on.
284 newRegisters.setSP(cfa);
285
286 typename R::reg_t returnAddress = 0;
287 constexpr int lastReg = R::lastDwarfRegNum();
288 static_assert(static_cast<int>(CFI_Parser<A>::kMaxRegisterNumber) >=
289 lastReg,
290 "register range too large");
291 assert(lastReg >= (int)cieInfo.returnAddressRegister &&
292 "register range does not contain return address register");
293 for (int i = 0; i <= lastReg; ++i) {
294 if (prolog.savedRegisters[i].location !=
295 CFI_Parser<A>::kRegisterUnused) {
296 if (registers.validFloatRegister(i))
297 newRegisters.setFloatRegister(
298 i, getSavedFloatRegister(addressSpace, registers, cfa,
299 savedReg: prolog.savedRegisters[i]));
300 else if (registers.validVectorRegister(i))
301 newRegisters.setVectorRegister(
302 i, getSavedVectorRegister(addressSpace, registers, cfa,
303 savedReg: prolog.savedRegisters[i]));
304 else if (i == (int)cieInfo.returnAddressRegister)
305 returnAddress = getSavedRegister(addressSpace, registers, cfa,
306 savedReg: prolog.savedRegisters[i]);
307 else if (registers.validRegister(i))
308 newRegisters.setRegister(
309 i, getSavedRegister(addressSpace, registers, cfa,
310 savedReg: prolog.savedRegisters[i]));
311 else
312 return UNW_EBADREG;
313 } else if (i == (int)cieInfo.returnAddressRegister) {
314 // Leaf function keeps the return address in register and there is no
315 // explicit instructions how to restore it.
316 returnAddress = registers.getRegister(cieInfo.returnAddressRegister);
317 }
318 }
319
320 isSignalFrame = cieInfo.isSignalFrame;
321
322#if defined(_LIBUNWIND_TARGET_AARCH64)
323 // There are two ways of return address signing: pac-ret (enabled via
324 // -mbranch-protection=pac-ret) and ptrauth-returns (enabled as part of
325 // Apple's arm64e or experimental pauthtest ABI on Linux). The code
326 // below handles signed RA for ptrauth-returns, while pac-ret uses pacm
327 // instructions from the hint space.
328 //
329 // TODO: unify logic for both cases, see
330 // https://github.com/llvm/llvm-project/issues/160110
331#if defined(_LIBUNWIND_TARGET_AARCH64_AUTHENTICATED_UNWINDING)
332 if (getReturnAddressSignStatus(addressSpace, registers, cfa, prolog) ==
333 RASignedWithPC) {
334 newRegisters.setIPPAuthLR(returnAddress, prolog.ptrAuthDiversifier);
335 } else {
336 newRegisters.setIP(returnAddress);
337 }
338
339 // Simulate the step by replacing the register set with the new ones.
340 registers = newRegisters;
341
342 return UNW_STEP_SUCCESS;
343#else
344 // If the target is aarch64 then the return address may have been signed
345 // using the v8.3 pointer authentication extensions. The original
346 // return address needs to be authenticated before the return address is
347 // restored. autia1716 is used instead of autia as autia1716 assembles
348 // to a NOP on pre-v8.3a architectures.
349 RASignStatus RAState =
350 getReturnAddressSignStatus(addressSpace, registers, cfa, prolog);
351 if ((R::getArch() == REGISTERS_ARM64) && RAState != RANotSigned &&
352 returnAddress != 0) {
353#if !defined(_LIBUNWIND_IS_NATIVE_ONLY)
354 return UNW_ECROSSRASIGNING;
355#else
356 register unsigned long long x17 __asm("x17") = returnAddress;
357 register unsigned long long x16 __asm("x16") = cfa;
358
359 // We use the hint versions of the authentication instructions below to
360 // ensure they're assembled by the compiler even for targets with no
361 // FEAT_PAuth/FEAT_PAuth_LR support.
362 if (RAState == RASignedWithPC) {
363 register unsigned long long x15 __asm("x15") =
364 prolog.ptrAuthDiversifier;
365 if (cieInfo.nonHintPAuthFrame)
366 x17 = nonHintLRAuthentication(prolog.ptrAuthDiversifier, cfa,
367 returnAddress,
368 cieInfo.addressesSignedWithBKey);
369 else {
370 if (cieInfo.addressesSignedWithBKey) {
371 asm("hint 0x27\n\t" // pacm
372 "hint 0xe"
373 : "+r"(x17)
374 : "r"(x16), "r"(x15)); // autib1716
375 } else {
376 asm("hint 0x27\n\t" // pacm
377 "hint 0xc"
378 : "+r"(x17)
379 : "r"(x16), "r"(x15)); // autia1716
380 }
381 }
382 } else {
383 assert(!cieInfo.nonHintPAuthFrame &&
384 "Non-hint space FEAT_PAuth_LR instructions expect"
385 "RASignedWithPC");
386 if (cieInfo.addressesSignedWithBKey)
387 asm("hint 0xe" : "+r"(x17) : "r"(x16)); // autib1716
388 else
389 asm("hint 0xc" : "+r"(x17) : "r"(x16)); // autia1716
390 }
391 returnAddress = x17;
392#endif
393 }
394#endif
395#endif
396
397#if defined(_LIBUNWIND_IS_NATIVE_ONLY) && defined(_LIBUNWIND_TARGET_ARM) && \
398 defined(__ARM_FEATURE_PAUTH)
399 if ((R::getArch() == REGISTERS_ARM) &&
400 prolog.savedRegisters[UNW_ARM_RA_AUTH_CODE].value) {
401 pint_t pac =
402 getSavedRegister(addressSpace, registers, cfa,
403 prolog.savedRegisters[UNW_ARM_RA_AUTH_CODE]);
404 __asm__ __volatile__("autg %0, %1, %2"
405 :
406 : "r"(pac), "r"(returnAddress), "r"(cfa)
407 :);
408 }
409#endif
410
411#if defined(_LIBUNWIND_TARGET_SPARC)
412 if (R::getArch() == REGISTERS_SPARC) {
413 // Skip call site instruction and delay slot
414 returnAddress += 8;
415 // Skip unimp instruction if function returns a struct
416 if ((addressSpace.get32(returnAddress) & 0xC1C00000) == 0)
417 returnAddress += 4;
418 }
419#endif
420
421#if defined(_LIBUNWIND_TARGET_SPARC64)
422 // Skip call site instruction and delay slot.
423 if (R::getArch() == REGISTERS_SPARC64)
424 returnAddress += 8;
425#endif
426
427#if defined(_LIBUNWIND_TARGET_PPC64)
428#define PPC64_ELFV1_R2_LOAD_INST_ENCODING 0xe8410028u // ld r2,40(r1)
429#define PPC64_ELFV1_R2_OFFSET 40
430#define PPC64_ELFV2_R2_LOAD_INST_ENCODING 0xe8410018u // ld r2,24(r1)
431#define PPC64_ELFV2_R2_OFFSET 24
432 // If the instruction at return address is a TOC (r2) restore,
433 // then r2 was saved and needs to be restored.
434 // ELFv2 ABI specifies that the TOC Pointer must be saved at SP + 24,
435 // while in ELFv1 ABI it is saved at SP + 40.
436 if (R::getArch() == REGISTERS_PPC64 && returnAddress != 0) {
437 pint_t sp = newRegisters.getRegister(UNW_REG_SP);
438 pint_t r2 = 0;
439 switch (addressSpace.get32(returnAddress)) {
440 case PPC64_ELFV1_R2_LOAD_INST_ENCODING:
441 r2 = addressSpace.get64(sp + PPC64_ELFV1_R2_OFFSET);
442 break;
443 case PPC64_ELFV2_R2_LOAD_INST_ENCODING:
444 r2 = addressSpace.get64(sp + PPC64_ELFV2_R2_OFFSET);
445 break;
446 }
447 if (r2)
448 newRegisters.setRegister(UNW_PPC64_R2, r2);
449 }
450#endif
451
452 // Return address is address after call site instruction, so setting IP to
453 // that does simulates a return.
454 newRegisters.setIP(returnAddress);
455
456 // Simulate the step by replacing the register set with the new ones.
457 registers = newRegisters;
458
459 return UNW_STEP_SUCCESS;
460 }
461 }
462 return UNW_EBADFRAME;
463}
464
465template <typename A, typename R>
466typename A::pint_t
467DwarfInstructions<A, R>::evaluateExpression(pint_t expression, A &addressSpace,
468 const R &registers,
469 pint_t initialStackValue) {
470 const bool log = false;
471 pint_t p = expression;
472 pint_t expressionEnd = expression + 20; // temp, until len read
473 pint_t length = (pint_t)addressSpace.getULEB128(p, expressionEnd);
474 expressionEnd = p + length;
475 if (log)
476 fprintf(stderr, format: "evaluateExpression(): length=%" PRIu64 "\n",
477 (uint64_t)length);
478 constexpr size_t kStackSize = 100;
479 pint_t stack[kStackSize];
480 pint_t *sp = stack;
481 *(++sp) = initialStackValue;
482
483 while (p < expressionEnd) {
484 // Bounds-check the operand stack. Every opcode below pushes at most one
485 // value (writing at most sp[1]) and, except for DW_OP_pick and DW_OP_rot
486 // (checked at their use), reads/writes no deeper than sp[-1]. Keeping sp
487 // within [&stack[1], &stack[kStackSize - 2]] here therefore bounds every
488 // access to the fixed-size array. Compiler-emitted CFI expressions use tiny
489 // stack depths; violating these bounds means corrupted or malicious unwind
490 // data (e.g. a hostile FDE registered via __register_frame()).
491 if (sp < &stack[1] || sp > &stack[kStackSize - 2])
492 _LIBUNWIND_ABORT("DWARF expression operand stack out of bounds");
493 if (log) {
494 for (pint_t *t = sp; t > stack; --t) {
495 fprintf(stderr, format: "sp[] = 0x%" PRIx64 "\n", (uint64_t)(*t));
496 }
497 }
498 uint8_t opcode = addressSpace.get8(p++);
499 sint_t svalue, svalue2;
500 pint_t value;
501 uint32_t reg;
502 switch (opcode) {
503 case DW_OP_addr:
504 // push immediate address sized value
505 value = addressSpace.getP(p);
506 p += sizeof(pint_t);
507 *(++sp) = value;
508 if (log)
509 fprintf(stderr, format: "push 0x%" PRIx64 "\n", (uint64_t)value);
510 break;
511
512 case DW_OP_deref:
513 // pop stack, dereference, push result
514 value = *sp--;
515 *(++sp) = addressSpace.getP(value);
516 if (log)
517 fprintf(stderr, format: "dereference 0x%" PRIx64 "\n", (uint64_t)value);
518 break;
519
520 case DW_OP_const1u:
521 // push immediate 1 byte value
522 value = addressSpace.get8(p);
523 p += 1;
524 *(++sp) = value;
525 if (log)
526 fprintf(stderr, format: "push 0x%" PRIx64 "\n", (uint64_t)value);
527 break;
528
529 case DW_OP_const1s:
530 // push immediate 1 byte signed value
531 svalue = (int8_t) addressSpace.get8(p);
532 p += 1;
533 *(++sp) = (pint_t)svalue;
534 if (log)
535 fprintf(stderr, format: "push 0x%" PRIx64 "\n", (uint64_t)svalue);
536 break;
537
538 case DW_OP_const2u:
539 // push immediate 2 byte value
540 value = addressSpace.get16(p);
541 p += 2;
542 *(++sp) = value;
543 if (log)
544 fprintf(stderr, format: "push 0x%" PRIx64 "\n", (uint64_t)value);
545 break;
546
547 case DW_OP_const2s:
548 // push immediate 2 byte signed value
549 svalue = (int16_t) addressSpace.get16(p);
550 p += 2;
551 *(++sp) = (pint_t)svalue;
552 if (log)
553 fprintf(stderr, format: "push 0x%" PRIx64 "\n", (uint64_t)svalue);
554 break;
555
556 case DW_OP_const4u:
557 // push immediate 4 byte value
558 value = addressSpace.get32(p);
559 p += 4;
560 *(++sp) = value;
561 if (log)
562 fprintf(stderr, format: "push 0x%" PRIx64 "\n", (uint64_t)value);
563 break;
564
565 case DW_OP_const4s:
566 // push immediate 4 byte signed value
567 svalue = (int32_t)addressSpace.get32(p);
568 p += 4;
569 *(++sp) = (pint_t)svalue;
570 if (log)
571 fprintf(stderr, format: "push 0x%" PRIx64 "\n", (uint64_t)svalue);
572 break;
573
574 case DW_OP_const8u:
575 // push immediate 8 byte value
576 value = (pint_t)addressSpace.get64(p);
577 p += 8;
578 *(++sp) = value;
579 if (log)
580 fprintf(stderr, format: "push 0x%" PRIx64 "\n", (uint64_t)value);
581 break;
582
583 case DW_OP_const8s:
584 // push immediate 8 byte signed value
585 value = (pint_t)addressSpace.get64(p);
586 p += 8;
587 *(++sp) = value;
588 if (log)
589 fprintf(stderr, format: "push 0x%" PRIx64 "\n", (uint64_t)value);
590 break;
591
592 case DW_OP_constu:
593 // push immediate ULEB128 value
594 value = (pint_t)addressSpace.getULEB128(p, expressionEnd);
595 *(++sp) = value;
596 if (log)
597 fprintf(stderr, format: "push 0x%" PRIx64 "\n", (uint64_t)value);
598 break;
599
600 case DW_OP_consts:
601 // push immediate SLEB128 value
602 svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd);
603 *(++sp) = (pint_t)svalue;
604 if (log)
605 fprintf(stderr, format: "push 0x%" PRIx64 "\n", (uint64_t)svalue);
606 break;
607
608 case DW_OP_dup:
609 // push top of stack
610 value = *sp;
611 *(++sp) = value;
612 if (log)
613 fprintf(stderr, format: "duplicate top of stack\n");
614 break;
615
616 case DW_OP_drop:
617 // pop
618 --sp;
619 if (log)
620 fprintf(stderr, format: "pop top of stack\n");
621 break;
622
623 case DW_OP_over:
624 // dup second
625 value = sp[-1];
626 *(++sp) = value;
627 if (log)
628 fprintf(stderr, format: "duplicate second in stack\n");
629 break;
630
631 case DW_OP_pick:
632 // pick from
633 reg = addressSpace.get8(p);
634 p += 1;
635 if (sp - (int)reg < &stack[1])
636 _LIBUNWIND_ABORT("DW_OP_pick index out of bounds");
637 value = sp[-(int)reg];
638 *(++sp) = value;
639 if (log)
640 fprintf(stderr, format: "duplicate %d in stack\n", reg);
641 break;
642
643 case DW_OP_swap:
644 // swap top two
645 value = sp[0];
646 sp[0] = sp[-1];
647 sp[-1] = value;
648 if (log)
649 fprintf(stderr, format: "swap top of stack\n");
650 break;
651
652 case DW_OP_rot:
653 // rotate top three
654 if (sp < &stack[3])
655 _LIBUNWIND_ABORT("DW_OP_rot with fewer than three stack entries");
656 value = sp[0];
657 sp[0] = sp[-1];
658 sp[-1] = sp[-2];
659 sp[-2] = value;
660 if (log)
661 fprintf(stderr, format: "rotate top three of stack\n");
662 break;
663
664 case DW_OP_xderef:
665 // pop stack, dereference, push result
666 value = *sp--;
667 *sp = *((pint_t*)value);
668 if (log)
669 fprintf(stderr, format: "x-dereference 0x%" PRIx64 "\n", (uint64_t)value);
670 break;
671
672 case DW_OP_abs:
673 svalue = (sint_t)*sp;
674 if (svalue < 0)
675 *sp = (pint_t)(-svalue);
676 if (log)
677 fprintf(stderr, format: "abs\n");
678 break;
679
680 case DW_OP_and:
681 value = *sp--;
682 *sp &= value;
683 if (log)
684 fprintf(stderr, format: "and\n");
685 break;
686
687 case DW_OP_div:
688 svalue = (sint_t)(*sp--);
689 svalue2 = (sint_t)*sp;
690 *sp = (pint_t)(svalue2 / svalue);
691 if (log)
692 fprintf(stderr, format: "div\n");
693 break;
694
695 case DW_OP_minus:
696 value = *sp--;
697 *sp = *sp - value;
698 if (log)
699 fprintf(stderr, format: "minus\n");
700 break;
701
702 case DW_OP_mod:
703 svalue = (sint_t)(*sp--);
704 svalue2 = (sint_t)*sp;
705 *sp = (pint_t)(svalue2 % svalue);
706 if (log)
707 fprintf(stderr, format: "module\n");
708 break;
709
710 case DW_OP_mul:
711 svalue = (sint_t)(*sp--);
712 svalue2 = (sint_t)*sp;
713 *sp = (pint_t)(svalue2 * svalue);
714 if (log)
715 fprintf(stderr, format: "mul\n");
716 break;
717
718 case DW_OP_neg:
719 *sp = 0 - *sp;
720 if (log)
721 fprintf(stderr, format: "neg\n");
722 break;
723
724 case DW_OP_not:
725 svalue = (sint_t)(*sp);
726 *sp = (pint_t)(~svalue);
727 if (log)
728 fprintf(stderr, format: "not\n");
729 break;
730
731 case DW_OP_or:
732 value = *sp--;
733 *sp |= value;
734 if (log)
735 fprintf(stderr, format: "or\n");
736 break;
737
738 case DW_OP_plus:
739 value = *sp--;
740 *sp += value;
741 if (log)
742 fprintf(stderr, format: "plus\n");
743 break;
744
745 case DW_OP_plus_uconst:
746 // pop stack, add uelb128 constant, push result
747 *sp += static_cast<pint_t>(addressSpace.getULEB128(p, expressionEnd));
748 if (log)
749 fprintf(stderr, format: "add constant\n");
750 break;
751
752 case DW_OP_shl:
753 value = *sp--;
754 *sp = *sp << value;
755 if (log)
756 fprintf(stderr, format: "shift left\n");
757 break;
758
759 case DW_OP_shr:
760 value = *sp--;
761 *sp = *sp >> value;
762 if (log)
763 fprintf(stderr, format: "shift left\n");
764 break;
765
766 case DW_OP_shra:
767 value = *sp--;
768 svalue = (sint_t)*sp;
769 *sp = (pint_t)(svalue >> value);
770 if (log)
771 fprintf(stderr, format: "shift left arithmetic\n");
772 break;
773
774 case DW_OP_xor:
775 value = *sp--;
776 *sp ^= value;
777 if (log)
778 fprintf(stderr, format: "xor\n");
779 break;
780
781 case DW_OP_skip:
782 svalue = (int16_t) addressSpace.get16(p);
783 p += 2;
784 p = (pint_t)((sint_t)p + svalue);
785 if (log)
786 fprintf(stderr, format: "skip %" PRIu64 "\n", (uint64_t)svalue);
787 break;
788
789 case DW_OP_bra:
790 svalue = (int16_t) addressSpace.get16(p);
791 p += 2;
792 if (*sp--)
793 p = (pint_t)((sint_t)p + svalue);
794 if (log)
795 fprintf(stderr, format: "bra %" PRIu64 "\n", (uint64_t)svalue);
796 break;
797
798 case DW_OP_eq:
799 value = *sp--;
800 *sp = (*sp == value);
801 if (log)
802 fprintf(stderr, format: "eq\n");
803 break;
804
805 case DW_OP_ge:
806 value = *sp--;
807 *sp = (*sp >= value);
808 if (log)
809 fprintf(stderr, format: "ge\n");
810 break;
811
812 case DW_OP_gt:
813 value = *sp--;
814 *sp = (*sp > value);
815 if (log)
816 fprintf(stderr, format: "gt\n");
817 break;
818
819 case DW_OP_le:
820 value = *sp--;
821 *sp = (*sp <= value);
822 if (log)
823 fprintf(stderr, format: "le\n");
824 break;
825
826 case DW_OP_lt:
827 value = *sp--;
828 *sp = (*sp < value);
829 if (log)
830 fprintf(stderr, format: "lt\n");
831 break;
832
833 case DW_OP_ne:
834 value = *sp--;
835 *sp = (*sp != value);
836 if (log)
837 fprintf(stderr, format: "ne\n");
838 break;
839
840 case DW_OP_lit0:
841 case DW_OP_lit1:
842 case DW_OP_lit2:
843 case DW_OP_lit3:
844 case DW_OP_lit4:
845 case DW_OP_lit5:
846 case DW_OP_lit6:
847 case DW_OP_lit7:
848 case DW_OP_lit8:
849 case DW_OP_lit9:
850 case DW_OP_lit10:
851 case DW_OP_lit11:
852 case DW_OP_lit12:
853 case DW_OP_lit13:
854 case DW_OP_lit14:
855 case DW_OP_lit15:
856 case DW_OP_lit16:
857 case DW_OP_lit17:
858 case DW_OP_lit18:
859 case DW_OP_lit19:
860 case DW_OP_lit20:
861 case DW_OP_lit21:
862 case DW_OP_lit22:
863 case DW_OP_lit23:
864 case DW_OP_lit24:
865 case DW_OP_lit25:
866 case DW_OP_lit26:
867 case DW_OP_lit27:
868 case DW_OP_lit28:
869 case DW_OP_lit29:
870 case DW_OP_lit30:
871 case DW_OP_lit31:
872 value = static_cast<pint_t>(opcode - DW_OP_lit0);
873 *(++sp) = value;
874 if (log)
875 fprintf(stderr, format: "push literal 0x%" PRIx64 "\n", (uint64_t)value);
876 break;
877
878 case DW_OP_reg0:
879 case DW_OP_reg1:
880 case DW_OP_reg2:
881 case DW_OP_reg3:
882 case DW_OP_reg4:
883 case DW_OP_reg5:
884 case DW_OP_reg6:
885 case DW_OP_reg7:
886 case DW_OP_reg8:
887 case DW_OP_reg9:
888 case DW_OP_reg10:
889 case DW_OP_reg11:
890 case DW_OP_reg12:
891 case DW_OP_reg13:
892 case DW_OP_reg14:
893 case DW_OP_reg15:
894 case DW_OP_reg16:
895 case DW_OP_reg17:
896 case DW_OP_reg18:
897 case DW_OP_reg19:
898 case DW_OP_reg20:
899 case DW_OP_reg21:
900 case DW_OP_reg22:
901 case DW_OP_reg23:
902 case DW_OP_reg24:
903 case DW_OP_reg25:
904 case DW_OP_reg26:
905 case DW_OP_reg27:
906 case DW_OP_reg28:
907 case DW_OP_reg29:
908 case DW_OP_reg30:
909 case DW_OP_reg31:
910 reg = static_cast<uint32_t>(opcode - DW_OP_reg0);
911 *(++sp) = registers.getRegister((int)reg);
912 if (log)
913 fprintf(stderr, format: "push reg %d\n", reg);
914 break;
915
916 case DW_OP_regx:
917 reg = static_cast<uint32_t>(addressSpace.getULEB128(p, expressionEnd));
918 *(++sp) = registers.getRegister((int)reg);
919 if (log)
920 fprintf(stderr, format: "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue);
921 break;
922
923 case DW_OP_breg0:
924 case DW_OP_breg1:
925 case DW_OP_breg2:
926 case DW_OP_breg3:
927 case DW_OP_breg4:
928 case DW_OP_breg5:
929 case DW_OP_breg6:
930 case DW_OP_breg7:
931 case DW_OP_breg8:
932 case DW_OP_breg9:
933 case DW_OP_breg10:
934 case DW_OP_breg11:
935 case DW_OP_breg12:
936 case DW_OP_breg13:
937 case DW_OP_breg14:
938 case DW_OP_breg15:
939 case DW_OP_breg16:
940 case DW_OP_breg17:
941 case DW_OP_breg18:
942 case DW_OP_breg19:
943 case DW_OP_breg20:
944 case DW_OP_breg21:
945 case DW_OP_breg22:
946 case DW_OP_breg23:
947 case DW_OP_breg24:
948 case DW_OP_breg25:
949 case DW_OP_breg26:
950 case DW_OP_breg27:
951 case DW_OP_breg28:
952 case DW_OP_breg29:
953 case DW_OP_breg30:
954 case DW_OP_breg31:
955 reg = static_cast<uint32_t>(opcode - DW_OP_breg0);
956 svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd);
957 svalue += static_cast<sint_t>(registers.getRegister((int)reg));
958 *(++sp) = (pint_t)(svalue);
959 if (log)
960 fprintf(stderr, format: "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue);
961 break;
962
963 case DW_OP_bregx:
964 reg = static_cast<uint32_t>(addressSpace.getULEB128(p, expressionEnd));
965 svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd);
966 svalue += static_cast<sint_t>(registers.getRegister((int)reg));
967 *(++sp) = (pint_t)(svalue);
968 if (log)
969 fprintf(stderr, format: "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue);
970 break;
971
972 case DW_OP_fbreg:
973 _LIBUNWIND_ABORT("DW_OP_fbreg not implemented");
974 break;
975
976 case DW_OP_piece:
977 _LIBUNWIND_ABORT("DW_OP_piece not implemented");
978 break;
979
980 case DW_OP_deref_size:
981 // pop stack, dereference, push result
982 value = *sp--;
983 switch (addressSpace.get8(p++)) {
984 case 1:
985 value = addressSpace.get8(value);
986 break;
987 case 2:
988 value = addressSpace.get16(value);
989 break;
990 case 4:
991 value = addressSpace.get32(value);
992 break;
993 case 8:
994 value = (pint_t)addressSpace.get64(value);
995 break;
996 default:
997 _LIBUNWIND_ABORT("DW_OP_deref_size with bad size");
998 }
999 *(++sp) = value;
1000 if (log)
1001 fprintf(stderr, format: "sized dereference 0x%" PRIx64 "\n", (uint64_t)value);
1002 break;
1003
1004 case DW_OP_xderef_size:
1005 case DW_OP_nop:
1006 case DW_OP_push_object_addres:
1007 case DW_OP_call2:
1008 case DW_OP_call4:
1009 case DW_OP_call_ref:
1010 default:
1011 _LIBUNWIND_ABORT("DWARF opcode not implemented");
1012 }
1013
1014 }
1015 if (sp < &stack[1])
1016 _LIBUNWIND_ABORT("DWARF expression operand stack out of bounds");
1017 if (log)
1018 fprintf(stderr, format: "expression evaluates to 0x%" PRIx64 "\n", (uint64_t)*sp);
1019 return *sp;
1020}
1021
1022
1023
1024} // namespace libunwind
1025
1026#endif // __DWARF_INSTRUCTIONS_HPP__
1027