forked from gcc-mirror/gcc
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathunwind-dw2.c
1767 lines (1533 loc) · 47.3 KB
/
unwind-dw2.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* DWARF2 exception handling and frame unwind runtime interface routines.
Copyright (C) 1997-2019 Free Software Foundation, Inc.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
GCC is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
License for more details.
Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.
You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */
#include "tconfig.h"
#include "tsystem.h"
#include "coretypes.h"
#include "tm.h"
#include "libgcc_tm.h"
#include "dwarf2.h"
#include "unwind.h"
#ifdef __USING_SJLJ_EXCEPTIONS__
# define NO_SIZE_OF_ENCODED_VALUE
#endif
#include "unwind-pe.h"
#include "unwind-dw2-fde.h"
#include "gthr.h"
#include "unwind-dw2.h"
#ifdef HAVE_SYS_SDT_H
#include <sys/sdt.h>
#endif
#ifndef __USING_SJLJ_EXCEPTIONS__
#ifndef __LIBGCC_STACK_GROWS_DOWNWARD__
#define __LIBGCC_STACK_GROWS_DOWNWARD__ 0
#else
#undef __LIBGCC_STACK_GROWS_DOWNWARD__
#define __LIBGCC_STACK_GROWS_DOWNWARD__ 1
#endif
/* Dwarf frame registers used for pre gcc 3.0 compiled glibc. */
#ifndef PRE_GCC3_DWARF_FRAME_REGISTERS
#define PRE_GCC3_DWARF_FRAME_REGISTERS __LIBGCC_DWARF_FRAME_REGISTERS__
#endif
/* ??? For the public function interfaces, we tend to gcc_assert that the
column numbers are in range. For the dwarf2 unwind info this does happen,
although so far in a case that doesn't actually matter.
See PR49146, in which a call from x86_64 ms abi to x86_64 unix abi stores
the call-saved xmm registers and annotates them. We havn't bothered
providing support for the xmm registers for the x86_64 port primarily
because the 64-bit windows targets don't use dwarf2 unwind, using sjlj or
SEH instead. Adding the support for unix targets would generally be a
waste. However, some runtime libraries supplied with ICC do contain such
an unorthodox transition, as well as the unwind info to match. This loss
of register restoration doesn't matter in practice, because the exception
is caught in the native unix abi, where all of the xmm registers are
call clobbered.
Ideally, we'd record some bit to notice when we're failing to restore some
register recorded in the unwind info, but to do that we need annotation on
the unix->ms abi edge, so that we know when the register data may be
discarded. And since this edge is also within the ICC library, we're
unlikely to be able to get the new annotation.
Barring a magic solution to restore the ms abi defined 128-bit xmm registers
(as distictly opposed to the full runtime width) without causing extra
overhead for normal unix abis, the best solution seems to be to simply
ignore unwind data for unknown columns. */
#define UNWIND_COLUMN_IN_RANGE(x) \
__builtin_expect((x) <= __LIBGCC_DWARF_FRAME_REGISTERS__, 1)
#ifdef REG_VALUE_IN_UNWIND_CONTEXT
typedef _Unwind_Word _Unwind_Context_Reg_Val;
#ifndef ASSUME_EXTENDED_UNWIND_CONTEXT
#define ASSUME_EXTENDED_UNWIND_CONTEXT 1
#endif
static inline _Unwind_Word
_Unwind_Get_Unwind_Word (_Unwind_Context_Reg_Val val)
{
return val;
}
static inline _Unwind_Context_Reg_Val
_Unwind_Get_Unwind_Context_Reg_Val (_Unwind_Word val)
{
return val;
}
#else
typedef void *_Unwind_Context_Reg_Val;
static inline _Unwind_Word
_Unwind_Get_Unwind_Word (_Unwind_Context_Reg_Val val)
{
return (_Unwind_Word) (_Unwind_Internal_Ptr) val;
}
static inline _Unwind_Context_Reg_Val
_Unwind_Get_Unwind_Context_Reg_Val (_Unwind_Word val)
{
return (_Unwind_Context_Reg_Val) (_Unwind_Internal_Ptr) val;
}
#endif
#ifndef ASSUME_EXTENDED_UNWIND_CONTEXT
#define ASSUME_EXTENDED_UNWIND_CONTEXT 0
#endif
/* This is the register and unwind state for a particular frame. This
provides the information necessary to unwind up past a frame and return
to its caller. */
struct _Unwind_Context
{
_Unwind_Context_Reg_Val reg[__LIBGCC_DWARF_FRAME_REGISTERS__+1];
void *cfa;
void *ra;
void *lsda;
struct dwarf_eh_bases bases;
/* Signal frame context. */
#define SIGNAL_FRAME_BIT ((~(_Unwind_Word) 0 >> 1) + 1)
/* Context which has version/args_size/by_value fields. */
#define EXTENDED_CONTEXT_BIT ((~(_Unwind_Word) 0 >> 2) + 1)
/* Bit reserved on AArch64, return address has been signed with A or B
key. */
#define RA_SIGNED_BIT ((~(_Unwind_Word) 0 >> 3) + 1)
_Unwind_Word flags;
/* 0 for now, can be increased when further fields are added to
struct _Unwind_Context. */
_Unwind_Word version;
_Unwind_Word args_size;
char by_value[__LIBGCC_DWARF_FRAME_REGISTERS__+1];
};
/* Byte size of every register managed by these routines. */
static unsigned char dwarf_reg_size_table[__LIBGCC_DWARF_FRAME_REGISTERS__+1];
/* Read unaligned data from the instruction buffer. */
union unaligned
{
void *p;
unsigned u2 __attribute__ ((mode (HI)));
unsigned u4 __attribute__ ((mode (SI)));
unsigned u8 __attribute__ ((mode (DI)));
signed s2 __attribute__ ((mode (HI)));
signed s4 __attribute__ ((mode (SI)));
signed s8 __attribute__ ((mode (DI)));
} __attribute__ ((packed));
static void uw_update_context (struct _Unwind_Context *, _Unwind_FrameState *);
static _Unwind_Reason_Code uw_frame_state_for (struct _Unwind_Context *,
_Unwind_FrameState *);
static inline void *
read_pointer (const void *p) { const union unaligned *up = p; return up->p; }
static inline int
read_1u (const void *p) { return *(const unsigned char *) p; }
static inline int
read_1s (const void *p) { return *(const signed char *) p; }
static inline int
read_2u (const void *p) { const union unaligned *up = p; return up->u2; }
static inline int
read_2s (const void *p) { const union unaligned *up = p; return up->s2; }
static inline unsigned int
read_4u (const void *p) { const union unaligned *up = p; return up->u4; }
static inline int
read_4s (const void *p) { const union unaligned *up = p; return up->s4; }
static inline unsigned long
read_8u (const void *p) { const union unaligned *up = p; return up->u8; }
static inline unsigned long
read_8s (const void *p) { const union unaligned *up = p; return up->s8; }
static inline _Unwind_Word
_Unwind_IsSignalFrame (struct _Unwind_Context *context)
{
return (context->flags & SIGNAL_FRAME_BIT) ? 1 : 0;
}
static inline void
_Unwind_SetSignalFrame (struct _Unwind_Context *context, int val)
{
if (val)
context->flags |= SIGNAL_FRAME_BIT;
else
context->flags &= ~SIGNAL_FRAME_BIT;
}
static inline _Unwind_Word
_Unwind_IsExtendedContext (struct _Unwind_Context *context)
{
return (ASSUME_EXTENDED_UNWIND_CONTEXT
|| (context->flags & EXTENDED_CONTEXT_BIT));
}
/* Get the value of register REGNO as saved in CONTEXT. */
inline _Unwind_Word
_Unwind_GetGR (struct _Unwind_Context *context, int regno)
{
int size, index;
_Unwind_Context_Reg_Val val;
#ifdef DWARF_ZERO_REG
if (regno == DWARF_ZERO_REG)
return 0;
#endif
index = DWARF_REG_TO_UNWIND_COLUMN (regno);
gcc_assert (index < (int) sizeof(dwarf_reg_size_table));
size = dwarf_reg_size_table[index];
val = context->reg[index];
if (_Unwind_IsExtendedContext (context) && context->by_value[index])
return _Unwind_Get_Unwind_Word (val);
#ifdef DWARF_LAZY_REGISTER_VALUE
{
_Unwind_Word value;
if (DWARF_LAZY_REGISTER_VALUE (regno, &value))
return value;
}
#endif
/* This will segfault if the register hasn't been saved. */
if (size == sizeof(_Unwind_Ptr))
return * (_Unwind_Ptr *) (_Unwind_Internal_Ptr) val;
else
{
gcc_assert (size == sizeof(_Unwind_Word));
return * (_Unwind_Word *) (_Unwind_Internal_Ptr) val;
}
}
static inline void *
_Unwind_GetPtr (struct _Unwind_Context *context, int index)
{
return (void *)(_Unwind_Ptr) _Unwind_GetGR (context, index);
}
/* Get the value of the CFA as saved in CONTEXT. */
_Unwind_Word
_Unwind_GetCFA (struct _Unwind_Context *context)
{
return (_Unwind_Ptr) context->cfa;
}
/* Overwrite the saved value for register INDEX in CONTEXT with VAL. */
inline void
_Unwind_SetGR (struct _Unwind_Context *context, int index, _Unwind_Word val)
{
int size;
void *ptr;
index = DWARF_REG_TO_UNWIND_COLUMN (index);
gcc_assert (index < (int) sizeof(dwarf_reg_size_table));
size = dwarf_reg_size_table[index];
if (_Unwind_IsExtendedContext (context) && context->by_value[index])
{
context->reg[index] = _Unwind_Get_Unwind_Context_Reg_Val (val);
return;
}
ptr = (void *) (_Unwind_Internal_Ptr) context->reg[index];
if (size == sizeof(_Unwind_Ptr))
* (_Unwind_Ptr *) ptr = val;
else
{
gcc_assert (size == sizeof(_Unwind_Word));
* (_Unwind_Word *) ptr = val;
}
}
/* Get the pointer to a register INDEX as saved in CONTEXT. */
static inline void *
_Unwind_GetGRPtr (struct _Unwind_Context *context, int index)
{
index = DWARF_REG_TO_UNWIND_COLUMN (index);
if (_Unwind_IsExtendedContext (context) && context->by_value[index])
return &context->reg[index];
return (void *) (_Unwind_Internal_Ptr) context->reg[index];
}
/* Set the pointer to a register INDEX as saved in CONTEXT. */
static inline void
_Unwind_SetGRPtr (struct _Unwind_Context *context, int index, void *p)
{
index = DWARF_REG_TO_UNWIND_COLUMN (index);
if (_Unwind_IsExtendedContext (context))
context->by_value[index] = 0;
context->reg[index] = (_Unwind_Context_Reg_Val) (_Unwind_Internal_Ptr) p;
}
/* Overwrite the saved value for register INDEX in CONTEXT with VAL. */
static inline void
_Unwind_SetGRValue (struct _Unwind_Context *context, int index,
_Unwind_Word val)
{
index = DWARF_REG_TO_UNWIND_COLUMN (index);
gcc_assert (index < (int) sizeof(dwarf_reg_size_table));
/* Return column size may be smaller than _Unwind_Context_Reg_Val. */
gcc_assert (dwarf_reg_size_table[index] <= sizeof (_Unwind_Context_Reg_Val));
context->by_value[index] = 1;
context->reg[index] = _Unwind_Get_Unwind_Context_Reg_Val (val);
}
/* Return nonzero if register INDEX is stored by value rather than
by reference. */
static inline int
_Unwind_GRByValue (struct _Unwind_Context *context, int index)
{
index = DWARF_REG_TO_UNWIND_COLUMN (index);
return context->by_value[index];
}
/* Retrieve the return address for CONTEXT. */
inline _Unwind_Ptr
_Unwind_GetIP (struct _Unwind_Context *context)
{
return (_Unwind_Ptr) context->ra;
}
/* Retrieve the return address and flag whether that IP is before
or after first not yet fully executed instruction. */
inline _Unwind_Ptr
_Unwind_GetIPInfo (struct _Unwind_Context *context, int *ip_before_insn)
{
*ip_before_insn = _Unwind_IsSignalFrame (context);
return (_Unwind_Ptr) context->ra;
}
/* Overwrite the return address for CONTEXT with VAL. */
inline void
_Unwind_SetIP (struct _Unwind_Context *context, _Unwind_Ptr val)
{
context->ra = (void *) val;
}
void *
_Unwind_GetLanguageSpecificData (struct _Unwind_Context *context)
{
return context->lsda;
}
_Unwind_Ptr
_Unwind_GetRegionStart (struct _Unwind_Context *context)
{
return (_Unwind_Ptr) context->bases.func;
}
void *
_Unwind_FindEnclosingFunction (void *pc)
{
struct dwarf_eh_bases bases;
const struct dwarf_fde *fde = _Unwind_Find_FDE (pc-1, &bases);
if (fde)
return bases.func;
else
return NULL;
}
#ifndef __ia64__
_Unwind_Ptr
_Unwind_GetDataRelBase (struct _Unwind_Context *context)
{
return (_Unwind_Ptr) context->bases.dbase;
}
_Unwind_Ptr
_Unwind_GetTextRelBase (struct _Unwind_Context *context)
{
return (_Unwind_Ptr) context->bases.tbase;
}
#endif
#include "md-unwind-support.h"
/* Extract any interesting information from the CIE for the translation
unit F belongs to. Return a pointer to the byte after the augmentation,
or NULL if we encountered an undecipherable augmentation. */
static const unsigned char *
extract_cie_info (const struct dwarf_cie *cie, struct _Unwind_Context *context,
_Unwind_FrameState *fs)
{
const unsigned char *aug = cie->augmentation;
const unsigned char *p = aug + strlen ((const char *)aug) + 1;
const unsigned char *ret = NULL;
_uleb128_t utmp;
_sleb128_t stmp;
/* g++ v2 "eh" has pointer immediately following augmentation string,
so it must be handled first. */
if (aug[0] == 'e' && aug[1] == 'h')
{
fs->eh_ptr = read_pointer (p);
p += sizeof (void *);
aug += 2;
}
/* After the augmentation resp. pointer for "eh" augmentation
follows for CIE version >= 4 address size byte and
segment size byte. */
if (__builtin_expect (cie->version >= 4, 0))
{
if (p[0] != sizeof (void *) || p[1] != 0)
return NULL;
p += 2;
}
/* Immediately following this are the code and
data alignment and return address column. */
p = read_uleb128 (p, &utmp);
fs->code_align = (_Unwind_Word)utmp;
p = read_sleb128 (p, &stmp);
fs->data_align = (_Unwind_Sword)stmp;
if (cie->version == 1)
fs->retaddr_column = *p++;
else
{
p = read_uleb128 (p, &utmp);
fs->retaddr_column = (_Unwind_Word)utmp;
}
fs->lsda_encoding = DW_EH_PE_omit;
/* If the augmentation starts with 'z', then a uleb128 immediately
follows containing the length of the augmentation field following
the size. */
if (*aug == 'z')
{
p = read_uleb128 (p, &utmp);
ret = p + utmp;
fs->saw_z = 1;
++aug;
}
/* Iterate over recognized augmentation subsequences. */
while (*aug != '\0')
{
/* "L" indicates a byte showing how the LSDA pointer is encoded. */
if (aug[0] == 'L')
{
fs->lsda_encoding = *p++;
aug += 1;
}
/* "R" indicates a byte indicating how FDE addresses are encoded. */
else if (aug[0] == 'R')
{
fs->fde_encoding = *p++;
aug += 1;
}
/* "P" indicates a personality routine in the CIE augmentation. */
else if (aug[0] == 'P')
{
_Unwind_Ptr personality;
p = read_encoded_value (context, *p, p + 1, &personality);
fs->personality = (_Unwind_Personality_Fn) personality;
aug += 1;
}
/* "S" indicates a signal frame. */
else if (aug[0] == 'S')
{
fs->signal_frame = 1;
aug += 1;
}
/* aarch64 B-key pointer authentication. */
else if (aug[0] == 'B')
{
aug += 1;
}
/* Otherwise we have an unknown augmentation string.
Bail unless we saw a 'z' prefix. */
else
return ret;
}
return ret ? ret : p;
}
/* Decode a DW_OP stack program. Return the top of stack. Push INITIAL
onto the stack to start. */
static _Unwind_Word
execute_stack_op (const unsigned char *op_ptr, const unsigned char *op_end,
struct _Unwind_Context *context, _Unwind_Word initial)
{
_Unwind_Word stack[64]; /* ??? Assume this is enough. */
int stack_elt;
stack[0] = initial;
stack_elt = 1;
while (op_ptr < op_end)
{
enum dwarf_location_atom op = *op_ptr++;
_Unwind_Word result;
_uleb128_t reg, utmp;
_sleb128_t offset, stmp;
switch (op)
{
case DW_OP_lit0:
case DW_OP_lit1:
case DW_OP_lit2:
case DW_OP_lit3:
case DW_OP_lit4:
case DW_OP_lit5:
case DW_OP_lit6:
case DW_OP_lit7:
case DW_OP_lit8:
case DW_OP_lit9:
case DW_OP_lit10:
case DW_OP_lit11:
case DW_OP_lit12:
case DW_OP_lit13:
case DW_OP_lit14:
case DW_OP_lit15:
case DW_OP_lit16:
case DW_OP_lit17:
case DW_OP_lit18:
case DW_OP_lit19:
case DW_OP_lit20:
case DW_OP_lit21:
case DW_OP_lit22:
case DW_OP_lit23:
case DW_OP_lit24:
case DW_OP_lit25:
case DW_OP_lit26:
case DW_OP_lit27:
case DW_OP_lit28:
case DW_OP_lit29:
case DW_OP_lit30:
case DW_OP_lit31:
result = op - DW_OP_lit0;
break;
case DW_OP_addr:
result = (_Unwind_Word) (_Unwind_Ptr) read_pointer (op_ptr);
op_ptr += sizeof (void *);
break;
case DW_OP_GNU_encoded_addr:
{
_Unwind_Ptr presult;
op_ptr = read_encoded_value (context, *op_ptr, op_ptr+1, &presult);
result = presult;
}
break;
case DW_OP_const1u:
result = read_1u (op_ptr);
op_ptr += 1;
break;
case DW_OP_const1s:
result = read_1s (op_ptr);
op_ptr += 1;
break;
case DW_OP_const2u:
result = read_2u (op_ptr);
op_ptr += 2;
break;
case DW_OP_const2s:
result = read_2s (op_ptr);
op_ptr += 2;
break;
case DW_OP_const4u:
result = read_4u (op_ptr);
op_ptr += 4;
break;
case DW_OP_const4s:
result = read_4s (op_ptr);
op_ptr += 4;
break;
case DW_OP_const8u:
result = read_8u (op_ptr);
op_ptr += 8;
break;
case DW_OP_const8s:
result = read_8s (op_ptr);
op_ptr += 8;
break;
case DW_OP_constu:
op_ptr = read_uleb128 (op_ptr, &utmp);
result = (_Unwind_Word)utmp;
break;
case DW_OP_consts:
op_ptr = read_sleb128 (op_ptr, &stmp);
result = (_Unwind_Sword)stmp;
break;
case DW_OP_reg0:
case DW_OP_reg1:
case DW_OP_reg2:
case DW_OP_reg3:
case DW_OP_reg4:
case DW_OP_reg5:
case DW_OP_reg6:
case DW_OP_reg7:
case DW_OP_reg8:
case DW_OP_reg9:
case DW_OP_reg10:
case DW_OP_reg11:
case DW_OP_reg12:
case DW_OP_reg13:
case DW_OP_reg14:
case DW_OP_reg15:
case DW_OP_reg16:
case DW_OP_reg17:
case DW_OP_reg18:
case DW_OP_reg19:
case DW_OP_reg20:
case DW_OP_reg21:
case DW_OP_reg22:
case DW_OP_reg23:
case DW_OP_reg24:
case DW_OP_reg25:
case DW_OP_reg26:
case DW_OP_reg27:
case DW_OP_reg28:
case DW_OP_reg29:
case DW_OP_reg30:
case DW_OP_reg31:
result = _Unwind_GetGR (context, op - DW_OP_reg0);
break;
case DW_OP_regx:
op_ptr = read_uleb128 (op_ptr, ®);
result = _Unwind_GetGR (context, reg);
break;
case DW_OP_breg0:
case DW_OP_breg1:
case DW_OP_breg2:
case DW_OP_breg3:
case DW_OP_breg4:
case DW_OP_breg5:
case DW_OP_breg6:
case DW_OP_breg7:
case DW_OP_breg8:
case DW_OP_breg9:
case DW_OP_breg10:
case DW_OP_breg11:
case DW_OP_breg12:
case DW_OP_breg13:
case DW_OP_breg14:
case DW_OP_breg15:
case DW_OP_breg16:
case DW_OP_breg17:
case DW_OP_breg18:
case DW_OP_breg19:
case DW_OP_breg20:
case DW_OP_breg21:
case DW_OP_breg22:
case DW_OP_breg23:
case DW_OP_breg24:
case DW_OP_breg25:
case DW_OP_breg26:
case DW_OP_breg27:
case DW_OP_breg28:
case DW_OP_breg29:
case DW_OP_breg30:
case DW_OP_breg31:
op_ptr = read_sleb128 (op_ptr, &offset);
result = _Unwind_GetGR (context, op - DW_OP_breg0) + offset;
break;
case DW_OP_bregx:
op_ptr = read_uleb128 (op_ptr, ®);
op_ptr = read_sleb128 (op_ptr, &offset);
result = _Unwind_GetGR (context, reg) + (_Unwind_Word)offset;
break;
case DW_OP_dup:
gcc_assert (stack_elt);
result = stack[stack_elt - 1];
break;
case DW_OP_drop:
gcc_assert (stack_elt);
stack_elt -= 1;
goto no_push;
case DW_OP_pick:
offset = *op_ptr++;
gcc_assert (offset < stack_elt - 1);
result = stack[stack_elt - 1 - offset];
break;
case DW_OP_over:
gcc_assert (stack_elt >= 2);
result = stack[stack_elt - 2];
break;
case DW_OP_swap:
{
_Unwind_Word t;
gcc_assert (stack_elt >= 2);
t = stack[stack_elt - 1];
stack[stack_elt - 1] = stack[stack_elt - 2];
stack[stack_elt - 2] = t;
goto no_push;
}
case DW_OP_rot:
{
_Unwind_Word t1, t2, t3;
gcc_assert (stack_elt >= 3);
t1 = stack[stack_elt - 1];
t2 = stack[stack_elt - 2];
t3 = stack[stack_elt - 3];
stack[stack_elt - 1] = t2;
stack[stack_elt - 2] = t3;
stack[stack_elt - 3] = t1;
goto no_push;
}
case DW_OP_deref:
case DW_OP_deref_size:
case DW_OP_abs:
case DW_OP_neg:
case DW_OP_not:
case DW_OP_plus_uconst:
/* Unary operations. */
gcc_assert (stack_elt);
stack_elt -= 1;
result = stack[stack_elt];
switch (op)
{
case DW_OP_deref:
{
void *ptr = (void *) (_Unwind_Ptr) result;
result = (_Unwind_Ptr) read_pointer (ptr);
}
break;
case DW_OP_deref_size:
{
void *ptr = (void *) (_Unwind_Ptr) result;
switch (*op_ptr++)
{
case 1:
result = read_1u (ptr);
break;
case 2:
result = read_2u (ptr);
break;
case 4:
result = read_4u (ptr);
break;
case 8:
result = read_8u (ptr);
break;
default:
gcc_unreachable ();
}
}
break;
case DW_OP_abs:
if ((_Unwind_Sword) result < 0)
result = -result;
break;
case DW_OP_neg:
result = -result;
break;
case DW_OP_not:
result = ~result;
break;
case DW_OP_plus_uconst:
op_ptr = read_uleb128 (op_ptr, &utmp);
result += (_Unwind_Word)utmp;
break;
default:
gcc_unreachable ();
}
break;
case DW_OP_and:
case DW_OP_div:
case DW_OP_minus:
case DW_OP_mod:
case DW_OP_mul:
case DW_OP_or:
case DW_OP_plus:
case DW_OP_shl:
case DW_OP_shr:
case DW_OP_shra:
case DW_OP_xor:
case DW_OP_le:
case DW_OP_ge:
case DW_OP_eq:
case DW_OP_lt:
case DW_OP_gt:
case DW_OP_ne:
{
/* Binary operations. */
_Unwind_Word first, second;
gcc_assert (stack_elt >= 2);
stack_elt -= 2;
second = stack[stack_elt];
first = stack[stack_elt + 1];
switch (op)
{
case DW_OP_and:
result = second & first;
break;
case DW_OP_div:
result = (_Unwind_Sword) second / (_Unwind_Sword) first;
break;
case DW_OP_minus:
result = second - first;
break;
case DW_OP_mod:
result = second % first;
break;
case DW_OP_mul:
result = second * first;
break;
case DW_OP_or:
result = second | first;
break;
case DW_OP_plus:
result = second + first;
break;
case DW_OP_shl:
result = second << first;
break;
case DW_OP_shr:
result = second >> first;
break;
case DW_OP_shra:
result = (_Unwind_Sword) second >> first;
break;
case DW_OP_xor:
result = second ^ first;
break;
case DW_OP_le:
result = (_Unwind_Sword) second <= (_Unwind_Sword) first;
break;
case DW_OP_ge:
result = (_Unwind_Sword) second >= (_Unwind_Sword) first;
break;
case DW_OP_eq:
result = (_Unwind_Sword) second == (_Unwind_Sword) first;
break;
case DW_OP_lt:
result = (_Unwind_Sword) second < (_Unwind_Sword) first;
break;
case DW_OP_gt:
result = (_Unwind_Sword) second > (_Unwind_Sword) first;
break;
case DW_OP_ne:
result = (_Unwind_Sword) second != (_Unwind_Sword) first;
break;
default:
gcc_unreachable ();
}
}
break;
case DW_OP_skip:
offset = read_2s (op_ptr);
op_ptr += 2;
op_ptr += offset;
goto no_push;
case DW_OP_bra:
gcc_assert (stack_elt);
stack_elt -= 1;
offset = read_2s (op_ptr);
op_ptr += 2;
if (stack[stack_elt] != 0)
op_ptr += offset;
goto no_push;
case DW_OP_nop:
goto no_push;
default:
gcc_unreachable ();
}
/* Most things push a result value. */
gcc_assert ((size_t) stack_elt < sizeof(stack)/sizeof(*stack));
stack[stack_elt++] = result;
no_push:;
}
/* We were executing this program to get a value. It should be
at top of stack. */
gcc_assert (stack_elt);
stack_elt -= 1;
return stack[stack_elt];
}
/* Decode DWARF 2 call frame information. Takes pointers the
instruction sequence to decode, current register information and
CIE info, and the PC range to evaluate. */
static void
execute_cfa_program (const unsigned char *insn_ptr,
const unsigned char *insn_end,
struct _Unwind_Context *context,
_Unwind_FrameState *fs)
{
struct frame_state_reg_info *unused_rs = NULL;
/* Don't allow remember/restore between CIE and FDE programs. */
fs->regs.prev = NULL;
/* The comparison with the return address uses < rather than <= because
we are only interested in the effects of code before the call; for a
noreturn function, the return address may point to unrelated code with
a different stack configuration that we are not interested in. We
assume that the call itself is unwind info-neutral; if not, or if
there are delay instructions that adjust the stack, these must be
reflected at the point immediately before the call insn.
In signal frames, return address is after last completed instruction,
so we add 1 to return address to make the comparison <=. */
while (insn_ptr < insn_end
&& fs->pc < context->ra + _Unwind_IsSignalFrame (context))
{
unsigned char insn = *insn_ptr++;
_uleb128_t reg, utmp;
_sleb128_t offset, stmp;
if ((insn & 0xc0) == DW_CFA_advance_loc)
fs->pc += (insn & 0x3f) * fs->code_align;
else if ((insn & 0xc0) == DW_CFA_offset)
{
reg = insn & 0x3f;
insn_ptr = read_uleb128 (insn_ptr, &utmp);
offset = (_Unwind_Sword) utmp * fs->data_align;
reg = DWARF_REG_TO_UNWIND_COLUMN (reg);
if (UNWIND_COLUMN_IN_RANGE (reg))
{
fs->regs.reg[reg].how = REG_SAVED_OFFSET;
fs->regs.reg[reg].loc.offset = offset;
}
}
else if ((insn & 0xc0) == DW_CFA_restore)
{
reg = insn & 0x3f;
reg = DWARF_REG_TO_UNWIND_COLUMN (reg);
if (UNWIND_COLUMN_IN_RANGE (reg))
fs->regs.reg[reg].how = REG_UNSAVED;
}
else switch (insn)
{
case DW_CFA_set_loc:
{