1 //===-------------------------- DwarfInstructions.hpp ---------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //
9 // Processor specific interpretation of DWARF unwind info.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #ifndef __DWARF_INSTRUCTIONS_HPP__
14 #define __DWARF_INSTRUCTIONS_HPP__
15
16 #include <stdint.h>
17 #include <stdio.h>
18 #include <stdlib.h>
19
20 #include "dwarf2.h"
21 #include "Registers.hpp"
22 #include "DwarfParser.hpp"
23 #include "config.h"
24
25
26 namespace libunwind {
27
28
29 /// DwarfInstructions maps abtract DWARF unwind instructions to a particular
30 /// architecture
31 template <typename A, typename R>
32 class DwarfInstructions {
33 public:
34 typedef typename A::pint_t pint_t;
35 typedef typename A::sint_t sint_t;
36
37 static int stepWithDwarf(A &addressSpace, pint_t pc, pint_t fdeStart,
38 R ®isters);
39
40 private:
41
42 enum {
43 DW_X86_64_RET_ADDR = 16
44 };
45
46 enum {
47 DW_X86_RET_ADDR = 8
48 };
49
50 typedef typename CFI_Parser<A>::RegisterLocation RegisterLocation;
51 typedef typename CFI_Parser<A>::PrologInfo PrologInfo;
52 typedef typename CFI_Parser<A>::FDE_Info FDE_Info;
53 typedef typename CFI_Parser<A>::CIE_Info CIE_Info;
54
55 static pint_t evaluateExpression(pint_t expression, A &addressSpace,
56 const R ®isters,
57 pint_t initialStackValue);
58 static pint_t getSavedRegister(A &addressSpace, const R ®isters,
59 pint_t cfa, const RegisterLocation &savedReg);
60 static double getSavedFloatRegister(A &addressSpace, const R ®isters,
61 pint_t cfa, const RegisterLocation &savedReg);
62 static v128 getSavedVectorRegister(A &addressSpace, const R ®isters,
63 pint_t cfa, const RegisterLocation &savedReg);
64
getCFA(A & addressSpace,const PrologInfo & prolog,const R & registers)65 static pint_t getCFA(A &addressSpace, const PrologInfo &prolog,
66 const R ®isters) {
67 if (prolog.cfaRegister != 0)
68 return (pint_t)((sint_t)registers.getRegister((int)prolog.cfaRegister) +
69 prolog.cfaRegisterOffset);
70 if (prolog.cfaExpression != 0)
71 return evaluateExpression((pint_t)prolog.cfaExpression, addressSpace,
72 registers, 0);
73 assert(0 && "getCFA(): unknown location");
74 __builtin_unreachable();
75 }
76 };
77
78
79 template <typename A, typename R>
getSavedRegister(A & addressSpace,const R & registers,pint_t cfa,const RegisterLocation & savedReg)80 typename A::pint_t DwarfInstructions<A, R>::getSavedRegister(
81 A &addressSpace, const R ®isters, pint_t cfa,
82 const RegisterLocation &savedReg) {
83 switch (savedReg.location) {
84 case CFI_Parser<A>::kRegisterInCFA:
85 return addressSpace.getRegister(cfa + (pint_t)savedReg.value);
86
87 case CFI_Parser<A>::kRegisterAtExpression:
88 return addressSpace.getRegister(
89 evaluateExpression((pint_t)savedReg.value, addressSpace,
90 registers, cfa));
91
92 case CFI_Parser<A>::kRegisterIsExpression:
93 return evaluateExpression((pint_t)savedReg.value, addressSpace,
94 registers, cfa);
95
96 case CFI_Parser<A>::kRegisterInRegister:
97 return registers.getRegister((int)savedReg.value);
98
99 case CFI_Parser<A>::kRegisterUnused:
100 case CFI_Parser<A>::kRegisterOffsetFromCFA:
101 // FIX ME
102 break;
103 }
104 _LIBUNWIND_ABORT("unsupported restore location for register");
105 }
106
107 template <typename A, typename R>
getSavedFloatRegister(A & addressSpace,const R & registers,pint_t cfa,const RegisterLocation & savedReg)108 double DwarfInstructions<A, R>::getSavedFloatRegister(
109 A &addressSpace, const R ®isters, pint_t cfa,
110 const RegisterLocation &savedReg) {
111 switch (savedReg.location) {
112 case CFI_Parser<A>::kRegisterInCFA:
113 return addressSpace.getDouble(cfa + (pint_t)savedReg.value);
114
115 case CFI_Parser<A>::kRegisterAtExpression:
116 return addressSpace.getDouble(
117 evaluateExpression((pint_t)savedReg.value, addressSpace,
118 registers, cfa));
119
120 case CFI_Parser<A>::kRegisterIsExpression:
121 case CFI_Parser<A>::kRegisterUnused:
122 case CFI_Parser<A>::kRegisterOffsetFromCFA:
123 case CFI_Parser<A>::kRegisterInRegister:
124 // FIX ME
125 break;
126 }
127 _LIBUNWIND_ABORT("unsupported restore location for float register");
128 }
129
130 template <typename A, typename R>
getSavedVectorRegister(A & addressSpace,const R & registers,pint_t cfa,const RegisterLocation & savedReg)131 v128 DwarfInstructions<A, R>::getSavedVectorRegister(
132 A &addressSpace, const R ®isters, pint_t cfa,
133 const RegisterLocation &savedReg) {
134 switch (savedReg.location) {
135 case CFI_Parser<A>::kRegisterInCFA:
136 return addressSpace.getVector(cfa + (pint_t)savedReg.value);
137
138 case CFI_Parser<A>::kRegisterAtExpression:
139 return addressSpace.getVector(
140 evaluateExpression((pint_t)savedReg.value, addressSpace,
141 registers, cfa));
142
143 case CFI_Parser<A>::kRegisterIsExpression:
144 case CFI_Parser<A>::kRegisterUnused:
145 case CFI_Parser<A>::kRegisterOffsetFromCFA:
146 case CFI_Parser<A>::kRegisterInRegister:
147 // FIX ME
148 break;
149 }
150 _LIBUNWIND_ABORT("unsupported restore location for vector register");
151 }
152
153 template <typename A, typename R>
stepWithDwarf(A & addressSpace,pint_t pc,pint_t fdeStart,R & registers)154 int DwarfInstructions<A, R>::stepWithDwarf(A &addressSpace, pint_t pc,
155 pint_t fdeStart, R ®isters) {
156 FDE_Info fdeInfo;
157 CIE_Info cieInfo;
158 if (CFI_Parser<A>::decodeFDE(addressSpace, fdeStart, &fdeInfo,
159 &cieInfo) == NULL) {
160 PrologInfo prolog;
161 if (CFI_Parser<A>::parseFDEInstructions(addressSpace, fdeInfo, cieInfo, pc,
162 R::getArch(), &prolog)) {
163 // get pointer to cfa (architecture specific)
164 pint_t cfa = getCFA(addressSpace, prolog, registers);
165
166 // restore registers that DWARF says were saved
167 R newRegisters = registers;
168 pint_t returnAddress = 0;
169 const int lastReg = R::lastDwarfRegNum();
170 assert(static_cast<int>(CFI_Parser<A>::kMaxRegisterNumber) >= lastReg &&
171 "register range too large");
172 assert(lastReg >= (int)cieInfo.returnAddressRegister &&
173 "register range does not contain return address register");
174 for (int i = 0; i <= lastReg; ++i) {
175 if (prolog.savedRegisters[i].location !=
176 CFI_Parser<A>::kRegisterUnused) {
177 if (registers.validFloatRegister(i))
178 newRegisters.setFloatRegister(
179 i, getSavedFloatRegister(addressSpace, registers, cfa,
180 prolog.savedRegisters[i]));
181 else if (registers.validVectorRegister(i))
182 newRegisters.setVectorRegister(
183 i, getSavedVectorRegister(addressSpace, registers, cfa,
184 prolog.savedRegisters[i]));
185 else if (i == (int)cieInfo.returnAddressRegister)
186 returnAddress = getSavedRegister(addressSpace, registers, cfa,
187 prolog.savedRegisters[i]);
188 else if (registers.validRegister(i))
189 newRegisters.setRegister(
190 i, getSavedRegister(addressSpace, registers, cfa,
191 prolog.savedRegisters[i]));
192 else
193 return UNW_EBADREG;
194 }
195 }
196
197 // By definition, the CFA is the stack pointer at the call site, so
198 // restoring SP means setting it to CFA.
199 newRegisters.setSP(cfa);
200
201 #if defined(_LIBUNWIND_TARGET_AARCH64)
202 // If the target is aarch64 then the return address may have been signed
203 // using the v8.3 pointer authentication extensions. The original
204 // return address needs to be authenticated before the return address is
205 // restored. autia1716 is used instead of autia as autia1716 assembles
206 // to a NOP on pre-v8.3a architectures.
207 if ((R::getArch() == REGISTERS_ARM64) &&
208 prolog.savedRegisters[UNW_ARM64_RA_SIGN_STATE].value) {
209 #if !defined(_LIBUNWIND_IS_NATIVE_ONLY)
210 return UNW_ECROSSRASIGNING;
211 #else
212 register unsigned long long x17 __asm("x17") = returnAddress;
213 register unsigned long long x16 __asm("x16") = cfa;
214
215 // These are the autia1716/autib1716 instructions. The hint instructions
216 // are used here as gcc does not assemble autia1716/autib1716 for pre
217 // armv8.3a targets.
218 if (cieInfo.addressesSignedWithBKey)
219 asm("hint 0xe" : "+r"(x17) : "r"(x16)); // autib1716
220 else
221 asm("hint 0xc" : "+r"(x17) : "r"(x16)); // autia1716
222 returnAddress = x17;
223 #endif
224 }
225 #endif
226
227 #if defined(_LIBUNWIND_TARGET_SPARC)
228 if (R::getArch() == REGISTERS_SPARC) {
229 // Skip call site instruction and delay slot
230 returnAddress += 8;
231 // Skip unimp instruction if function returns a struct
232 if ((addressSpace.get32(returnAddress) & 0xC1C00000) == 0)
233 returnAddress += 4;
234 }
235 #endif
236
237 #if defined(_LIBUNWIND_TARGET_PPC64)
238 #define PPC64_ELFV1_R2_LOAD_INST_ENCODING 0xe8410028u // ld r2,40(r1)
239 #define PPC64_ELFV1_R2_OFFSET 40
240 #define PPC64_ELFV2_R2_LOAD_INST_ENCODING 0xe8410018u // ld r2,24(r1)
241 #define PPC64_ELFV2_R2_OFFSET 24
242 // If the instruction at return address is a TOC (r2) restore,
243 // then r2 was saved and needs to be restored.
244 // ELFv2 ABI specifies that the TOC Pointer must be saved at SP + 24,
245 // while in ELFv1 ABI it is saved at SP + 40.
246 if (R::getArch() == REGISTERS_PPC64 && returnAddress != 0) {
247 pint_t sp = newRegisters.getRegister(UNW_REG_SP);
248 pint_t r2 = 0;
249 switch (addressSpace.get32(returnAddress)) {
250 case PPC64_ELFV1_R2_LOAD_INST_ENCODING:
251 r2 = addressSpace.get64(sp + PPC64_ELFV1_R2_OFFSET);
252 break;
253 case PPC64_ELFV2_R2_LOAD_INST_ENCODING:
254 r2 = addressSpace.get64(sp + PPC64_ELFV2_R2_OFFSET);
255 break;
256 }
257 if (r2)
258 newRegisters.setRegister(UNW_PPC64_R2, r2);
259 }
260 #endif
261
262 // Return address is address after call site instruction, so setting IP to
263 // that does simualates a return.
264 newRegisters.setIP(returnAddress);
265
266 // Simulate the step by replacing the register set with the new ones.
267 registers = newRegisters;
268
269 return UNW_STEP_SUCCESS;
270 }
271 }
272 return UNW_EBADFRAME;
273 }
274
275 template <typename A, typename R>
276 typename A::pint_t
evaluateExpression(pint_t expression,A & addressSpace,const R & registers,pint_t initialStackValue)277 DwarfInstructions<A, R>::evaluateExpression(pint_t expression, A &addressSpace,
278 const R ®isters,
279 pint_t initialStackValue) {
280 const bool log = false;
281 pint_t p = expression;
282 pint_t expressionEnd = expression + 20; // temp, until len read
283 pint_t length = (pint_t)addressSpace.getULEB128(p, expressionEnd);
284 expressionEnd = p + length;
285 if (log)
286 fprintf(stderr, "evaluateExpression(): length=%" PRIu64 "\n",
287 (uint64_t)length);
288 pint_t stack[100];
289 pint_t *sp = stack;
290 *(++sp) = initialStackValue;
291
292 while (p < expressionEnd) {
293 if (log) {
294 for (pint_t *t = sp; t > stack; --t) {
295 fprintf(stderr, "sp[] = 0x%" PRIx64 "\n", (uint64_t)(*t));
296 }
297 }
298 uint8_t opcode = addressSpace.get8(p++);
299 sint_t svalue, svalue2;
300 pint_t value;
301 uint32_t reg;
302 switch (opcode) {
303 case DW_OP_addr:
304 // push immediate address sized value
305 value = addressSpace.getP(p);
306 p += sizeof(pint_t);
307 *(++sp) = value;
308 if (log)
309 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
310 break;
311
312 case DW_OP_deref:
313 // pop stack, dereference, push result
314 value = *sp--;
315 *(++sp) = addressSpace.getP(value);
316 if (log)
317 fprintf(stderr, "dereference 0x%" PRIx64 "\n", (uint64_t)value);
318 break;
319
320 case DW_OP_const1u:
321 // push immediate 1 byte value
322 value = addressSpace.get8(p);
323 p += 1;
324 *(++sp) = value;
325 if (log)
326 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
327 break;
328
329 case DW_OP_const1s:
330 // push immediate 1 byte signed value
331 svalue = (int8_t) addressSpace.get8(p);
332 p += 1;
333 *(++sp) = (pint_t)svalue;
334 if (log)
335 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue);
336 break;
337
338 case DW_OP_const2u:
339 // push immediate 2 byte value
340 value = addressSpace.get16(p);
341 p += 2;
342 *(++sp) = value;
343 if (log)
344 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
345 break;
346
347 case DW_OP_const2s:
348 // push immediate 2 byte signed value
349 svalue = (int16_t) addressSpace.get16(p);
350 p += 2;
351 *(++sp) = (pint_t)svalue;
352 if (log)
353 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue);
354 break;
355
356 case DW_OP_const4u:
357 // push immediate 4 byte value
358 value = addressSpace.get32(p);
359 p += 4;
360 *(++sp) = value;
361 if (log)
362 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
363 break;
364
365 case DW_OP_const4s:
366 // push immediate 4 byte signed value
367 svalue = (int32_t)addressSpace.get32(p);
368 p += 4;
369 *(++sp) = (pint_t)svalue;
370 if (log)
371 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue);
372 break;
373
374 case DW_OP_const8u:
375 // push immediate 8 byte value
376 value = (pint_t)addressSpace.get64(p);
377 p += 8;
378 *(++sp) = value;
379 if (log)
380 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
381 break;
382
383 case DW_OP_const8s:
384 // push immediate 8 byte signed value
385 value = (pint_t)addressSpace.get64(p);
386 p += 8;
387 *(++sp) = value;
388 if (log)
389 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
390 break;
391
392 case DW_OP_constu:
393 // push immediate ULEB128 value
394 value = (pint_t)addressSpace.getULEB128(p, expressionEnd);
395 *(++sp) = value;
396 if (log)
397 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
398 break;
399
400 case DW_OP_consts:
401 // push immediate SLEB128 value
402 svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd);
403 *(++sp) = (pint_t)svalue;
404 if (log)
405 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue);
406 break;
407
408 case DW_OP_dup:
409 // push top of stack
410 value = *sp;
411 *(++sp) = value;
412 if (log)
413 fprintf(stderr, "duplicate top of stack\n");
414 break;
415
416 case DW_OP_drop:
417 // pop
418 --sp;
419 if (log)
420 fprintf(stderr, "pop top of stack\n");
421 break;
422
423 case DW_OP_over:
424 // dup second
425 value = sp[-1];
426 *(++sp) = value;
427 if (log)
428 fprintf(stderr, "duplicate second in stack\n");
429 break;
430
431 case DW_OP_pick:
432 // pick from
433 reg = addressSpace.get8(p);
434 p += 1;
435 value = sp[-reg];
436 *(++sp) = value;
437 if (log)
438 fprintf(stderr, "duplicate %d in stack\n", reg);
439 break;
440
441 case DW_OP_swap:
442 // swap top two
443 value = sp[0];
444 sp[0] = sp[-1];
445 sp[-1] = value;
446 if (log)
447 fprintf(stderr, "swap top of stack\n");
448 break;
449
450 case DW_OP_rot:
451 // rotate top three
452 value = sp[0];
453 sp[0] = sp[-1];
454 sp[-1] = sp[-2];
455 sp[-2] = value;
456 if (log)
457 fprintf(stderr, "rotate top three of stack\n");
458 break;
459
460 case DW_OP_xderef:
461 // pop stack, dereference, push result
462 value = *sp--;
463 *sp = *((pint_t*)value);
464 if (log)
465 fprintf(stderr, "x-dereference 0x%" PRIx64 "\n", (uint64_t)value);
466 break;
467
468 case DW_OP_abs:
469 svalue = (sint_t)*sp;
470 if (svalue < 0)
471 *sp = (pint_t)(-svalue);
472 if (log)
473 fprintf(stderr, "abs\n");
474 break;
475
476 case DW_OP_and:
477 value = *sp--;
478 *sp &= value;
479 if (log)
480 fprintf(stderr, "and\n");
481 break;
482
483 case DW_OP_div:
484 svalue = (sint_t)(*sp--);
485 svalue2 = (sint_t)*sp;
486 *sp = (pint_t)(svalue2 / svalue);
487 if (log)
488 fprintf(stderr, "div\n");
489 break;
490
491 case DW_OP_minus:
492 value = *sp--;
493 *sp = *sp - value;
494 if (log)
495 fprintf(stderr, "minus\n");
496 break;
497
498 case DW_OP_mod:
499 svalue = (sint_t)(*sp--);
500 svalue2 = (sint_t)*sp;
501 *sp = (pint_t)(svalue2 % svalue);
502 if (log)
503 fprintf(stderr, "module\n");
504 break;
505
506 case DW_OP_mul:
507 svalue = (sint_t)(*sp--);
508 svalue2 = (sint_t)*sp;
509 *sp = (pint_t)(svalue2 * svalue);
510 if (log)
511 fprintf(stderr, "mul\n");
512 break;
513
514 case DW_OP_neg:
515 *sp = 0 - *sp;
516 if (log)
517 fprintf(stderr, "neg\n");
518 break;
519
520 case DW_OP_not:
521 svalue = (sint_t)(*sp);
522 *sp = (pint_t)(~svalue);
523 if (log)
524 fprintf(stderr, "not\n");
525 break;
526
527 case DW_OP_or:
528 value = *sp--;
529 *sp |= value;
530 if (log)
531 fprintf(stderr, "or\n");
532 break;
533
534 case DW_OP_plus:
535 value = *sp--;
536 *sp += value;
537 if (log)
538 fprintf(stderr, "plus\n");
539 break;
540
541 case DW_OP_plus_uconst:
542 // pop stack, add uelb128 constant, push result
543 *sp += static_cast<pint_t>(addressSpace.getULEB128(p, expressionEnd));
544 if (log)
545 fprintf(stderr, "add constant\n");
546 break;
547
548 case DW_OP_shl:
549 value = *sp--;
550 *sp = *sp << value;
551 if (log)
552 fprintf(stderr, "shift left\n");
553 break;
554
555 case DW_OP_shr:
556 value = *sp--;
557 *sp = *sp >> value;
558 if (log)
559 fprintf(stderr, "shift left\n");
560 break;
561
562 case DW_OP_shra:
563 value = *sp--;
564 svalue = (sint_t)*sp;
565 *sp = (pint_t)(svalue >> value);
566 if (log)
567 fprintf(stderr, "shift left arithmetric\n");
568 break;
569
570 case DW_OP_xor:
571 value = *sp--;
572 *sp ^= value;
573 if (log)
574 fprintf(stderr, "xor\n");
575 break;
576
577 case DW_OP_skip:
578 svalue = (int16_t) addressSpace.get16(p);
579 p += 2;
580 p = (pint_t)((sint_t)p + svalue);
581 if (log)
582 fprintf(stderr, "skip %" PRIu64 "\n", (uint64_t)svalue);
583 break;
584
585 case DW_OP_bra:
586 svalue = (int16_t) addressSpace.get16(p);
587 p += 2;
588 if (*sp--)
589 p = (pint_t)((sint_t)p + svalue);
590 if (log)
591 fprintf(stderr, "bra %" PRIu64 "\n", (uint64_t)svalue);
592 break;
593
594 case DW_OP_eq:
595 value = *sp--;
596 *sp = (*sp == value);
597 if (log)
598 fprintf(stderr, "eq\n");
599 break;
600
601 case DW_OP_ge:
602 value = *sp--;
603 *sp = (*sp >= value);
604 if (log)
605 fprintf(stderr, "ge\n");
606 break;
607
608 case DW_OP_gt:
609 value = *sp--;
610 *sp = (*sp > value);
611 if (log)
612 fprintf(stderr, "gt\n");
613 break;
614
615 case DW_OP_le:
616 value = *sp--;
617 *sp = (*sp <= value);
618 if (log)
619 fprintf(stderr, "le\n");
620 break;
621
622 case DW_OP_lt:
623 value = *sp--;
624 *sp = (*sp < value);
625 if (log)
626 fprintf(stderr, "lt\n");
627 break;
628
629 case DW_OP_ne:
630 value = *sp--;
631 *sp = (*sp != value);
632 if (log)
633 fprintf(stderr, "ne\n");
634 break;
635
636 case DW_OP_lit0:
637 case DW_OP_lit1:
638 case DW_OP_lit2:
639 case DW_OP_lit3:
640 case DW_OP_lit4:
641 case DW_OP_lit5:
642 case DW_OP_lit6:
643 case DW_OP_lit7:
644 case DW_OP_lit8:
645 case DW_OP_lit9:
646 case DW_OP_lit10:
647 case DW_OP_lit11:
648 case DW_OP_lit12:
649 case DW_OP_lit13:
650 case DW_OP_lit14:
651 case DW_OP_lit15:
652 case DW_OP_lit16:
653 case DW_OP_lit17:
654 case DW_OP_lit18:
655 case DW_OP_lit19:
656 case DW_OP_lit20:
657 case DW_OP_lit21:
658 case DW_OP_lit22:
659 case DW_OP_lit23:
660 case DW_OP_lit24:
661 case DW_OP_lit25:
662 case DW_OP_lit26:
663 case DW_OP_lit27:
664 case DW_OP_lit28:
665 case DW_OP_lit29:
666 case DW_OP_lit30:
667 case DW_OP_lit31:
668 value = static_cast<pint_t>(opcode - DW_OP_lit0);
669 *(++sp) = value;
670 if (log)
671 fprintf(stderr, "push literal 0x%" PRIx64 "\n", (uint64_t)value);
672 break;
673
674 case DW_OP_reg0:
675 case DW_OP_reg1:
676 case DW_OP_reg2:
677 case DW_OP_reg3:
678 case DW_OP_reg4:
679 case DW_OP_reg5:
680 case DW_OP_reg6:
681 case DW_OP_reg7:
682 case DW_OP_reg8:
683 case DW_OP_reg9:
684 case DW_OP_reg10:
685 case DW_OP_reg11:
686 case DW_OP_reg12:
687 case DW_OP_reg13:
688 case DW_OP_reg14:
689 case DW_OP_reg15:
690 case DW_OP_reg16:
691 case DW_OP_reg17:
692 case DW_OP_reg18:
693 case DW_OP_reg19:
694 case DW_OP_reg20:
695 case DW_OP_reg21:
696 case DW_OP_reg22:
697 case DW_OP_reg23:
698 case DW_OP_reg24:
699 case DW_OP_reg25:
700 case DW_OP_reg26:
701 case DW_OP_reg27:
702 case DW_OP_reg28:
703 case DW_OP_reg29:
704 case DW_OP_reg30:
705 case DW_OP_reg31:
706 reg = static_cast<uint32_t>(opcode - DW_OP_reg0);
707 *(++sp) = registers.getRegister((int)reg);
708 if (log)
709 fprintf(stderr, "push reg %d\n", reg);
710 break;
711
712 case DW_OP_regx:
713 reg = static_cast<uint32_t>(addressSpace.getULEB128(p, expressionEnd));
714 *(++sp) = registers.getRegister((int)reg);
715 if (log)
716 fprintf(stderr, "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue);
717 break;
718
719 case DW_OP_breg0:
720 case DW_OP_breg1:
721 case DW_OP_breg2:
722 case DW_OP_breg3:
723 case DW_OP_breg4:
724 case DW_OP_breg5:
725 case DW_OP_breg6:
726 case DW_OP_breg7:
727 case DW_OP_breg8:
728 case DW_OP_breg9:
729 case DW_OP_breg10:
730 case DW_OP_breg11:
731 case DW_OP_breg12:
732 case DW_OP_breg13:
733 case DW_OP_breg14:
734 case DW_OP_breg15:
735 case DW_OP_breg16:
736 case DW_OP_breg17:
737 case DW_OP_breg18:
738 case DW_OP_breg19:
739 case DW_OP_breg20:
740 case DW_OP_breg21:
741 case DW_OP_breg22:
742 case DW_OP_breg23:
743 case DW_OP_breg24:
744 case DW_OP_breg25:
745 case DW_OP_breg26:
746 case DW_OP_breg27:
747 case DW_OP_breg28:
748 case DW_OP_breg29:
749 case DW_OP_breg30:
750 case DW_OP_breg31:
751 reg = static_cast<uint32_t>(opcode - DW_OP_breg0);
752 svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd);
753 svalue += static_cast<sint_t>(registers.getRegister((int)reg));
754 *(++sp) = (pint_t)(svalue);
755 if (log)
756 fprintf(stderr, "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue);
757 break;
758
759 case DW_OP_bregx:
760 reg = static_cast<uint32_t>(addressSpace.getULEB128(p, expressionEnd));
761 svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd);
762 svalue += static_cast<sint_t>(registers.getRegister((int)reg));
763 *(++sp) = (pint_t)(svalue);
764 if (log)
765 fprintf(stderr, "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue);
766 break;
767
768 case DW_OP_fbreg:
769 _LIBUNWIND_ABORT("DW_OP_fbreg not implemented");
770 break;
771
772 case DW_OP_piece:
773 _LIBUNWIND_ABORT("DW_OP_piece not implemented");
774 break;
775
776 case DW_OP_deref_size:
777 // pop stack, dereference, push result
778 value = *sp--;
779 switch (addressSpace.get8(p++)) {
780 case 1:
781 value = addressSpace.get8(value);
782 break;
783 case 2:
784 value = addressSpace.get16(value);
785 break;
786 case 4:
787 value = addressSpace.get32(value);
788 break;
789 case 8:
790 value = (pint_t)addressSpace.get64(value);
791 break;
792 default:
793 _LIBUNWIND_ABORT("DW_OP_deref_size with bad size");
794 }
795 *(++sp) = value;
796 if (log)
797 fprintf(stderr, "sized dereference 0x%" PRIx64 "\n", (uint64_t)value);
798 break;
799
800 case DW_OP_xderef_size:
801 case DW_OP_nop:
802 case DW_OP_push_object_addres:
803 case DW_OP_call2:
804 case DW_OP_call4:
805 case DW_OP_call_ref:
806 default:
807 _LIBUNWIND_ABORT("DWARF opcode not implemented");
808 }
809
810 }
811 if (log)
812 fprintf(stderr, "expression evaluates to 0x%" PRIx64 "\n", (uint64_t)*sp);
813 return *sp;
814 }
815
816
817
818 } // namespace libunwind
819
820 #endif // __DWARF_INSTRUCTIONS_HPP__
821