blob: 2bf19c563327ee5ea10e19a435169eeadd35e894 [file] [log] [blame]
Saleem Abdulrasool17552662015-04-24 19:39:17 +00001//===-------------------------- 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//
Ed Maste4c43c3d2016-07-19 17:15:50 +00009// Processor specific interpretation of DWARF unwind info.
Saleem Abdulrasool17552662015-04-24 19:39:17 +000010//
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"
Saleem Abdulrasool17552662015-04-24 19:39:17 +000021#include "Registers.hpp"
22#include "DwarfParser.hpp"
23#include "config.h"
24
25
26namespace libunwind {
27
28
Ed Maste4c43c3d2016-07-19 17:15:50 +000029/// DwarfInstructions maps abtract DWARF unwind instructions to a particular
Saleem Abdulrasool17552662015-04-24 19:39:17 +000030/// architecture
31template <typename A, typename R>
32class DwarfInstructions {
33public:
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 &registers);
39
40private:
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 &registers,
57 pint_t initialStackValue);
58 static pint_t getSavedRegister(A &addressSpace, const R &registers,
59 pint_t cfa, const RegisterLocation &savedReg);
60 static double getSavedFloatRegister(A &addressSpace, const R &registers,
61 pint_t cfa, const RegisterLocation &savedReg);
62 static v128 getSavedVectorRegister(A &addressSpace, const R &registers,
63 pint_t cfa, const RegisterLocation &savedReg);
64
65 static pint_t getCFA(A &addressSpace, const PrologInfo &prolog,
66 const R &registers) {
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
79template <typename A, typename R>
80typename A::pint_t DwarfInstructions<A, R>::getSavedRegister(
81 A &addressSpace, const R &registers, pint_t cfa,
82 const RegisterLocation &savedReg) {
83 switch (savedReg.location) {
84 case CFI_Parser<A>::kRegisterInCFA:
John Baldwin1a6e6be2018-02-27 21:24:02 +000085 return addressSpace.getRegister(cfa + (pint_t)savedReg.value);
Saleem Abdulrasool17552662015-04-24 19:39:17 +000086
87 case CFI_Parser<A>::kRegisterAtExpression:
John Baldwin1a6e6be2018-02-27 21:24:02 +000088 return addressSpace.getRegister(
Saleem Abdulrasool17552662015-04-24 19:39:17 +000089 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
107template <typename A, typename R>
108double DwarfInstructions<A, R>::getSavedFloatRegister(
109 A &addressSpace, const R &registers, 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
130template <typename A, typename R>
131v128 DwarfInstructions<A, R>::getSavedVectorRegister(
132 A &addressSpace, const R &registers, 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
153template <typename A, typename R>
154int DwarfInstructions<A, R>::stepWithDwarf(A &addressSpace, pint_t pc,
155 pint_t fdeStart, R &registers) {
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 &prolog)) {
163 // get pointer to cfa (architecture specific)
164 pint_t cfa = getCFA(addressSpace, prolog, registers);
165
Ed Maste4c43c3d2016-07-19 17:15:50 +0000166 // restore registers that DWARF says were saved
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000167 R newRegisters = registers;
168 pint_t returnAddress = 0;
169 const int lastReg = R::lastDwarfRegNum();
Martin Storsjof10f3c92017-10-27 07:59:01 +0000170 assert(static_cast<int>(CFI_Parser<A>::kMaxRegisterNumber) >= lastReg &&
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000171 "register range too large");
Ed Mastec14579b2015-08-13 13:45:45 +0000172 assert(lastReg >= (int)cieInfo.returnAddressRegister &&
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000173 "register range does not contain return address register");
174 for (int i = 0; i <= lastReg; ++i) {
Logan Chien0112edf2015-05-30 14:00:39 +0000175 if (prolog.savedRegisters[i].location !=
176 CFI_Parser<A>::kRegisterUnused) {
177 if (registers.validFloatRegister(i))
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000178 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
Luke Cheeseman4d8e4312018-12-14 11:30:12 +0000201#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 (prolog.savedRegisters[UNW_ARM64_RA_SIGN_STATE].value) {
208#if !defined(_LIBUNWIND_IS_NATIVE_ONLY)
209 return UNW_ECROSSRASIGNING;
210#else
211 register unsigned long long x17 __asm("x17") = returnAddress;
212 register unsigned long long x16 __asm("x16") = cfa;
213
214 // This is the autia1716 instruction. The hint instruction is used here
215 // as gcc does not assemble autia1716 for pre armv8.3a targets.
216 asm("hint 0xc": "+r"(x17): "r"(x16));
217 returnAddress = x17;
218#endif
219 }
220#endif
221
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000222 // Return address is address after call site instruction, so setting IP to
223 // that does simualates a return.
224 newRegisters.setIP(returnAddress);
225
226 // Simulate the step by replacing the register set with the new ones.
227 registers = newRegisters;
228
229 return UNW_STEP_SUCCESS;
230 }
231 }
232 return UNW_EBADFRAME;
233}
234
235template <typename A, typename R>
236typename A::pint_t
237DwarfInstructions<A, R>::evaluateExpression(pint_t expression, A &addressSpace,
238 const R &registers,
239 pint_t initialStackValue) {
240 const bool log = false;
241 pint_t p = expression;
242 pint_t expressionEnd = expression + 20; // temp, until len read
243 pint_t length = (pint_t)addressSpace.getULEB128(p, expressionEnd);
244 expressionEnd = p + length;
245 if (log)
246 fprintf(stderr, "evaluateExpression(): length=%" PRIu64 "\n",
247 (uint64_t)length);
248 pint_t stack[100];
249 pint_t *sp = stack;
250 *(++sp) = initialStackValue;
251
252 while (p < expressionEnd) {
253 if (log) {
254 for (pint_t *t = sp; t > stack; --t) {
255 fprintf(stderr, "sp[] = 0x%" PRIx64 "\n", (uint64_t)(*t));
256 }
257 }
258 uint8_t opcode = addressSpace.get8(p++);
259 sint_t svalue, svalue2;
260 pint_t value;
261 uint32_t reg;
262 switch (opcode) {
263 case DW_OP_addr:
264 // push immediate address sized value
265 value = addressSpace.getP(p);
266 p += sizeof(pint_t);
267 *(++sp) = value;
268 if (log)
269 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
270 break;
271
272 case DW_OP_deref:
273 // pop stack, dereference, push result
274 value = *sp--;
275 *(++sp) = addressSpace.getP(value);
276 if (log)
277 fprintf(stderr, "dereference 0x%" PRIx64 "\n", (uint64_t)value);
278 break;
279
280 case DW_OP_const1u:
281 // push immediate 1 byte value
282 value = addressSpace.get8(p);
283 p += 1;
284 *(++sp) = value;
285 if (log)
286 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
287 break;
288
289 case DW_OP_const1s:
290 // push immediate 1 byte signed value
291 svalue = (int8_t) addressSpace.get8(p);
292 p += 1;
293 *(++sp) = (pint_t)svalue;
294 if (log)
295 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue);
296 break;
297
298 case DW_OP_const2u:
299 // push immediate 2 byte value
300 value = addressSpace.get16(p);
301 p += 2;
302 *(++sp) = value;
303 if (log)
304 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
305 break;
306
307 case DW_OP_const2s:
308 // push immediate 2 byte signed value
309 svalue = (int16_t) addressSpace.get16(p);
310 p += 2;
311 *(++sp) = (pint_t)svalue;
312 if (log)
313 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue);
314 break;
315
316 case DW_OP_const4u:
317 // push immediate 4 byte value
318 value = addressSpace.get32(p);
319 p += 4;
320 *(++sp) = value;
321 if (log)
322 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
323 break;
324
325 case DW_OP_const4s:
326 // push immediate 4 byte signed value
327 svalue = (int32_t)addressSpace.get32(p);
328 p += 4;
329 *(++sp) = (pint_t)svalue;
330 if (log)
331 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue);
332 break;
333
334 case DW_OP_const8u:
335 // push immediate 8 byte value
336 value = (pint_t)addressSpace.get64(p);
337 p += 8;
338 *(++sp) = value;
339 if (log)
340 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
341 break;
342
343 case DW_OP_const8s:
344 // push immediate 8 byte signed value
345 value = (pint_t)addressSpace.get64(p);
346 p += 8;
347 *(++sp) = value;
348 if (log)
349 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
350 break;
351
352 case DW_OP_constu:
353 // push immediate ULEB128 value
354 value = (pint_t)addressSpace.getULEB128(p, expressionEnd);
355 *(++sp) = value;
356 if (log)
357 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value);
358 break;
359
360 case DW_OP_consts:
361 // push immediate SLEB128 value
362 svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd);
363 *(++sp) = (pint_t)svalue;
364 if (log)
365 fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue);
366 break;
367
368 case DW_OP_dup:
369 // push top of stack
370 value = *sp;
371 *(++sp) = value;
372 if (log)
373 fprintf(stderr, "duplicate top of stack\n");
374 break;
375
376 case DW_OP_drop:
377 // pop
378 --sp;
379 if (log)
380 fprintf(stderr, "pop top of stack\n");
381 break;
382
383 case DW_OP_over:
384 // dup second
385 value = sp[-1];
386 *(++sp) = value;
387 if (log)
388 fprintf(stderr, "duplicate second in stack\n");
389 break;
390
391 case DW_OP_pick:
392 // pick from
393 reg = addressSpace.get8(p);
394 p += 1;
395 value = sp[-reg];
396 *(++sp) = value;
397 if (log)
398 fprintf(stderr, "duplicate %d in stack\n", reg);
399 break;
400
401 case DW_OP_swap:
402 // swap top two
403 value = sp[0];
404 sp[0] = sp[-1];
405 sp[-1] = value;
406 if (log)
407 fprintf(stderr, "swap top of stack\n");
408 break;
409
410 case DW_OP_rot:
411 // rotate top three
412 value = sp[0];
413 sp[0] = sp[-1];
414 sp[-1] = sp[-2];
415 sp[-2] = value;
416 if (log)
417 fprintf(stderr, "rotate top three of stack\n");
418 break;
419
420 case DW_OP_xderef:
421 // pop stack, dereference, push result
422 value = *sp--;
423 *sp = *((pint_t*)value);
424 if (log)
425 fprintf(stderr, "x-dereference 0x%" PRIx64 "\n", (uint64_t)value);
426 break;
427
428 case DW_OP_abs:
429 svalue = (sint_t)*sp;
430 if (svalue < 0)
431 *sp = (pint_t)(-svalue);
432 if (log)
433 fprintf(stderr, "abs\n");
434 break;
435
436 case DW_OP_and:
437 value = *sp--;
438 *sp &= value;
439 if (log)
440 fprintf(stderr, "and\n");
441 break;
442
443 case DW_OP_div:
444 svalue = (sint_t)(*sp--);
445 svalue2 = (sint_t)*sp;
446 *sp = (pint_t)(svalue2 / svalue);
447 if (log)
448 fprintf(stderr, "div\n");
449 break;
450
451 case DW_OP_minus:
452 value = *sp--;
453 *sp = *sp - value;
454 if (log)
455 fprintf(stderr, "minus\n");
456 break;
457
458 case DW_OP_mod:
459 svalue = (sint_t)(*sp--);
460 svalue2 = (sint_t)*sp;
461 *sp = (pint_t)(svalue2 % svalue);
462 if (log)
463 fprintf(stderr, "module\n");
464 break;
465
466 case DW_OP_mul:
467 svalue = (sint_t)(*sp--);
468 svalue2 = (sint_t)*sp;
469 *sp = (pint_t)(svalue2 * svalue);
470 if (log)
471 fprintf(stderr, "mul\n");
472 break;
473
474 case DW_OP_neg:
475 *sp = 0 - *sp;
476 if (log)
477 fprintf(stderr, "neg\n");
478 break;
479
480 case DW_OP_not:
481 svalue = (sint_t)(*sp);
482 *sp = (pint_t)(~svalue);
483 if (log)
484 fprintf(stderr, "not\n");
485 break;
486
487 case DW_OP_or:
488 value = *sp--;
489 *sp |= value;
490 if (log)
491 fprintf(stderr, "or\n");
492 break;
493
494 case DW_OP_plus:
495 value = *sp--;
496 *sp += value;
497 if (log)
498 fprintf(stderr, "plus\n");
499 break;
500
501 case DW_OP_plus_uconst:
502 // pop stack, add uelb128 constant, push result
Saleem Abdulrasool92acbf12017-03-08 16:03:27 +0000503 *sp += static_cast<pint_t>(addressSpace.getULEB128(p, expressionEnd));
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000504 if (log)
505 fprintf(stderr, "add constant\n");
506 break;
507
508 case DW_OP_shl:
509 value = *sp--;
510 *sp = *sp << value;
511 if (log)
512 fprintf(stderr, "shift left\n");
513 break;
514
515 case DW_OP_shr:
516 value = *sp--;
517 *sp = *sp >> value;
518 if (log)
519 fprintf(stderr, "shift left\n");
520 break;
521
522 case DW_OP_shra:
523 value = *sp--;
524 svalue = (sint_t)*sp;
525 *sp = (pint_t)(svalue >> value);
526 if (log)
527 fprintf(stderr, "shift left arithmetric\n");
528 break;
529
530 case DW_OP_xor:
531 value = *sp--;
532 *sp ^= value;
533 if (log)
534 fprintf(stderr, "xor\n");
535 break;
536
537 case DW_OP_skip:
538 svalue = (int16_t) addressSpace.get16(p);
539 p += 2;
540 p = (pint_t)((sint_t)p + svalue);
541 if (log)
542 fprintf(stderr, "skip %" PRIu64 "\n", (uint64_t)svalue);
543 break;
544
545 case DW_OP_bra:
546 svalue = (int16_t) addressSpace.get16(p);
547 p += 2;
548 if (*sp--)
549 p = (pint_t)((sint_t)p + svalue);
550 if (log)
551 fprintf(stderr, "bra %" PRIu64 "\n", (uint64_t)svalue);
552 break;
553
554 case DW_OP_eq:
555 value = *sp--;
556 *sp = (*sp == value);
557 if (log)
558 fprintf(stderr, "eq\n");
559 break;
560
561 case DW_OP_ge:
562 value = *sp--;
563 *sp = (*sp >= value);
564 if (log)
565 fprintf(stderr, "ge\n");
566 break;
567
568 case DW_OP_gt:
569 value = *sp--;
570 *sp = (*sp > value);
571 if (log)
572 fprintf(stderr, "gt\n");
573 break;
574
575 case DW_OP_le:
576 value = *sp--;
577 *sp = (*sp <= value);
578 if (log)
579 fprintf(stderr, "le\n");
580 break;
581
582 case DW_OP_lt:
583 value = *sp--;
584 *sp = (*sp < value);
585 if (log)
586 fprintf(stderr, "lt\n");
587 break;
588
589 case DW_OP_ne:
590 value = *sp--;
591 *sp = (*sp != value);
592 if (log)
593 fprintf(stderr, "ne\n");
594 break;
595
596 case DW_OP_lit0:
597 case DW_OP_lit1:
598 case DW_OP_lit2:
599 case DW_OP_lit3:
600 case DW_OP_lit4:
601 case DW_OP_lit5:
602 case DW_OP_lit6:
603 case DW_OP_lit7:
604 case DW_OP_lit8:
605 case DW_OP_lit9:
606 case DW_OP_lit10:
607 case DW_OP_lit11:
608 case DW_OP_lit12:
609 case DW_OP_lit13:
610 case DW_OP_lit14:
611 case DW_OP_lit15:
612 case DW_OP_lit16:
613 case DW_OP_lit17:
614 case DW_OP_lit18:
615 case DW_OP_lit19:
616 case DW_OP_lit20:
617 case DW_OP_lit21:
618 case DW_OP_lit22:
619 case DW_OP_lit23:
620 case DW_OP_lit24:
621 case DW_OP_lit25:
622 case DW_OP_lit26:
623 case DW_OP_lit27:
624 case DW_OP_lit28:
625 case DW_OP_lit29:
626 case DW_OP_lit30:
627 case DW_OP_lit31:
628 value = static_cast<pint_t>(opcode - DW_OP_lit0);
629 *(++sp) = value;
630 if (log)
631 fprintf(stderr, "push literal 0x%" PRIx64 "\n", (uint64_t)value);
632 break;
633
634 case DW_OP_reg0:
635 case DW_OP_reg1:
636 case DW_OP_reg2:
637 case DW_OP_reg3:
638 case DW_OP_reg4:
639 case DW_OP_reg5:
640 case DW_OP_reg6:
641 case DW_OP_reg7:
642 case DW_OP_reg8:
643 case DW_OP_reg9:
644 case DW_OP_reg10:
645 case DW_OP_reg11:
646 case DW_OP_reg12:
647 case DW_OP_reg13:
648 case DW_OP_reg14:
649 case DW_OP_reg15:
650 case DW_OP_reg16:
651 case DW_OP_reg17:
652 case DW_OP_reg18:
653 case DW_OP_reg19:
654 case DW_OP_reg20:
655 case DW_OP_reg21:
656 case DW_OP_reg22:
657 case DW_OP_reg23:
658 case DW_OP_reg24:
659 case DW_OP_reg25:
660 case DW_OP_reg26:
661 case DW_OP_reg27:
662 case DW_OP_reg28:
663 case DW_OP_reg29:
664 case DW_OP_reg30:
665 case DW_OP_reg31:
666 reg = static_cast<uint32_t>(opcode - DW_OP_reg0);
667 *(++sp) = registers.getRegister((int)reg);
668 if (log)
669 fprintf(stderr, "push reg %d\n", reg);
670 break;
671
672 case DW_OP_regx:
673 reg = static_cast<uint32_t>(addressSpace.getULEB128(p, expressionEnd));
674 *(++sp) = registers.getRegister((int)reg);
675 if (log)
676 fprintf(stderr, "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue);
677 break;
678
679 case DW_OP_breg0:
680 case DW_OP_breg1:
681 case DW_OP_breg2:
682 case DW_OP_breg3:
683 case DW_OP_breg4:
684 case DW_OP_breg5:
685 case DW_OP_breg6:
686 case DW_OP_breg7:
687 case DW_OP_breg8:
688 case DW_OP_breg9:
689 case DW_OP_breg10:
690 case DW_OP_breg11:
691 case DW_OP_breg12:
692 case DW_OP_breg13:
693 case DW_OP_breg14:
694 case DW_OP_breg15:
695 case DW_OP_breg16:
696 case DW_OP_breg17:
697 case DW_OP_breg18:
698 case DW_OP_breg19:
699 case DW_OP_breg20:
700 case DW_OP_breg21:
701 case DW_OP_breg22:
702 case DW_OP_breg23:
703 case DW_OP_breg24:
704 case DW_OP_breg25:
705 case DW_OP_breg26:
706 case DW_OP_breg27:
707 case DW_OP_breg28:
708 case DW_OP_breg29:
709 case DW_OP_breg30:
710 case DW_OP_breg31:
711 reg = static_cast<uint32_t>(opcode - DW_OP_breg0);
712 svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd);
713 svalue += static_cast<sint_t>(registers.getRegister((int)reg));
714 *(++sp) = (pint_t)(svalue);
715 if (log)
716 fprintf(stderr, "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue);
717 break;
718
719 case DW_OP_bregx:
720 reg = static_cast<uint32_t>(addressSpace.getULEB128(p, expressionEnd));
721 svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd);
722 svalue += static_cast<sint_t>(registers.getRegister((int)reg));
723 *(++sp) = (pint_t)(svalue);
724 if (log)
725 fprintf(stderr, "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue);
726 break;
727
728 case DW_OP_fbreg:
729 _LIBUNWIND_ABORT("DW_OP_fbreg not implemented");
730 break;
731
732 case DW_OP_piece:
733 _LIBUNWIND_ABORT("DW_OP_piece not implemented");
734 break;
735
736 case DW_OP_deref_size:
737 // pop stack, dereference, push result
738 value = *sp--;
739 switch (addressSpace.get8(p++)) {
740 case 1:
741 value = addressSpace.get8(value);
742 break;
743 case 2:
744 value = addressSpace.get16(value);
745 break;
746 case 4:
747 value = addressSpace.get32(value);
748 break;
749 case 8:
750 value = (pint_t)addressSpace.get64(value);
751 break;
752 default:
753 _LIBUNWIND_ABORT("DW_OP_deref_size with bad size");
754 }
755 *(++sp) = value;
756 if (log)
757 fprintf(stderr, "sized dereference 0x%" PRIx64 "\n", (uint64_t)value);
758 break;
759
760 case DW_OP_xderef_size:
761 case DW_OP_nop:
762 case DW_OP_push_object_addres:
763 case DW_OP_call2:
764 case DW_OP_call4:
765 case DW_OP_call_ref:
766 default:
Ed Maste4c43c3d2016-07-19 17:15:50 +0000767 _LIBUNWIND_ABORT("DWARF opcode not implemented");
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000768 }
769
770 }
771 if (log)
772 fprintf(stderr, "expression evaluates to 0x%" PRIx64 "\n", (uint64_t)*sp);
773 return *sp;
774}
775
776
777
778} // namespace libunwind
779
780#endif // __DWARF_INSTRUCTIONS_HPP__