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
|
/* ARM EABI compliant unwinding routines.
Copyright (C) 2004-2021 Free Software Foundation, Inc.
Contributed by Paul Brook
This file 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.
This file 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/>. */
#pragma GCC target ("general-regs-only")
#include "unwind.h"
/* Misc constants. */
#define R_IP 12
#define R_SP 13
#define R_LR 14
#define R_PC 15
#define VRS_PC(vrs) ((vrs)->core.r[R_PC])
#define VRS_SP(vrs) ((vrs)->core.r[R_SP])
#define VRS_RETURN(vrs) ((vrs)->core.r[R_LR])
struct core_regs
{
_uw r[16];
};
/* We use normal integer types here to avoid the compiler generating
coprocessor instructions. */
struct vfp_regs
{
_uw64 d[16];
_uw pad;
};
struct vfpv3_regs
{
/* Always populated via VSTM, so no need for the "pad" field from
vfp_regs (which is used to store the format word for FSTMX). */
_uw64 d[16];
};
struct wmmxd_regs
{
_uw64 wd[16];
};
struct wmmxc_regs
{
_uw wc[4];
};
/* The ABI specifies that the unwind routines may only use core registers,
except when actually manipulating coprocessor state. This allows
us to write one implementation that works on all platforms by
demand-saving coprocessor registers.
During unwinding we hold the coprocessor state in the actual hardware
registers and allocate demand-save areas for use during phase1
unwinding. */
typedef struct
{
/* The first fields must be the same as a phase2_vrs. */
_uw demand_save_flags;
struct core_regs core;
_uw prev_sp; /* Only valid during forced unwinding. */
struct vfp_regs vfp;
struct vfpv3_regs vfp_regs_16_to_31;
struct wmmxd_regs wmmxd;
struct wmmxc_regs wmmxc;
} phase1_vrs;
#define DEMAND_SAVE_VFP 1 /* VFP state has been saved if not set */
#define DEMAND_SAVE_VFP_D 2 /* VFP state is for FLDMD/FSTMD if set */
#define DEMAND_SAVE_VFP_V3 4 /* VFPv3 state for regs 16 .. 31 has
been saved if not set */
#define DEMAND_SAVE_WMMXD 8 /* iWMMXt data registers have been
saved if not set. */
#define DEMAND_SAVE_WMMXC 16 /* iWMMXt control registers have been
saved if not set. */
/* This must match the structure created by the assembly wrappers. */
typedef struct
{
_uw demand_save_flags;
struct core_regs core;
} phase2_vrs;
/* Coprocessor register state manipulation functions. */
/* Routines for FLDMX/FSTMX format... */
void __gnu_Unwind_Save_VFP (struct vfp_regs * p);
void __gnu_Unwind_Restore_VFP (struct vfp_regs * p);
void __gnu_Unwind_Save_WMMXD (struct wmmxd_regs * p);
void __gnu_Unwind_Restore_WMMXD (struct wmmxd_regs * p);
void __gnu_Unwind_Save_WMMXC (struct wmmxc_regs * p);
void __gnu_Unwind_Restore_WMMXC (struct wmmxc_regs * p);
/* ...and those for FLDMD/FSTMD format... */
void __gnu_Unwind_Save_VFP_D (struct vfp_regs * p);
void __gnu_Unwind_Restore_VFP_D (struct vfp_regs * p);
/* ...and those for VLDM/VSTM format, saving/restoring only registers
16 through 31. */
void __gnu_Unwind_Save_VFP_D_16_to_31 (struct vfpv3_regs * p);
void __gnu_Unwind_Restore_VFP_D_16_to_31 (struct vfpv3_regs * p);
/* Restore coprocessor state after phase1 unwinding. */
static void
restore_non_core_regs (phase1_vrs * vrs)
{
if ((vrs->demand_save_flags & DEMAND_SAVE_VFP) == 0)
{
if (vrs->demand_save_flags & DEMAND_SAVE_VFP_D)
__gnu_Unwind_Restore_VFP_D (&vrs->vfp);
else
__gnu_Unwind_Restore_VFP (&vrs->vfp);
}
if ((vrs->demand_save_flags & DEMAND_SAVE_VFP_V3) == 0)
__gnu_Unwind_Restore_VFP_D_16_to_31 (&vrs->vfp_regs_16_to_31);
if ((vrs->demand_save_flags & DEMAND_SAVE_WMMXD) == 0)
__gnu_Unwind_Restore_WMMXD (&vrs->wmmxd);
if ((vrs->demand_save_flags & DEMAND_SAVE_WMMXC) == 0)
__gnu_Unwind_Restore_WMMXC (&vrs->wmmxc);
}
#include "unwind-arm-common.inc"
/* ABI defined personality routines. */
extern _Unwind_Reason_Code __aeabi_unwind_cpp_pr0 (_Unwind_State,
_Unwind_Control_Block *, _Unwind_Context *);// __attribute__((weak));
extern _Unwind_Reason_Code __aeabi_unwind_cpp_pr1 (_Unwind_State,
_Unwind_Control_Block *, _Unwind_Context *) __attribute__((weak));
extern _Unwind_Reason_Code __aeabi_unwind_cpp_pr2 (_Unwind_State,
_Unwind_Control_Block *, _Unwind_Context *) __attribute__((weak));
/* ABI defined routine to store a virtual register to memory. */
_Unwind_VRS_Result _Unwind_VRS_Get (_Unwind_Context *context,
_Unwind_VRS_RegClass regclass,
_uw regno,
_Unwind_VRS_DataRepresentation representation,
void *valuep)
{
phase1_vrs *vrs = (phase1_vrs *) context;
switch (regclass)
{
case _UVRSC_CORE:
if (representation != _UVRSD_UINT32
|| regno > 15)
return _UVRSR_FAILED;
*(_uw *) valuep = vrs->core.r[regno];
return _UVRSR_OK;
case _UVRSC_VFP:
case _UVRSC_WMMXD:
case _UVRSC_WMMXC:
return _UVRSR_NOT_IMPLEMENTED;
default:
return _UVRSR_FAILED;
}
}
/* ABI defined function to load a virtual register from memory. */
_Unwind_VRS_Result _Unwind_VRS_Set (_Unwind_Context *context,
_Unwind_VRS_RegClass regclass,
_uw regno,
_Unwind_VRS_DataRepresentation representation,
void *valuep)
{
phase1_vrs *vrs = (phase1_vrs *) context;
switch (regclass)
{
case _UVRSC_CORE:
if (representation != _UVRSD_UINT32
|| regno > 15)
return _UVRSR_FAILED;
vrs->core.r[regno] = *(_uw *) valuep;
return _UVRSR_OK;
case _UVRSC_VFP:
case _UVRSC_WMMXD:
case _UVRSC_WMMXC:
return _UVRSR_NOT_IMPLEMENTED;
default:
return _UVRSR_FAILED;
}
}
/* ABI defined function to pop registers off the stack. */
_Unwind_VRS_Result _Unwind_VRS_Pop (_Unwind_Context *context,
_Unwind_VRS_RegClass regclass,
_uw discriminator,
_Unwind_VRS_DataRepresentation representation)
{
phase1_vrs *vrs = (phase1_vrs *) context;
switch (regclass)
{
case _UVRSC_CORE:
{
_uw *ptr;
_uw mask;
int i;
if (representation != _UVRSD_UINT32)
return _UVRSR_FAILED;
mask = discriminator & 0xffff;
ptr = (_uw *) vrs->core.r[R_SP];
/* Pop the requested registers. */
for (i = 0; i < 16; i++)
{
if (mask & (1 << i))
vrs->core.r[i] = *(ptr++);
}
/* Writeback the stack pointer value if it wasn't restored. */
if ((mask & (1 << R_SP)) == 0)
vrs->core.r[R_SP] = (_uw) ptr;
}
return _UVRSR_OK;
case _UVRSC_VFP:
{
_uw start = discriminator >> 16;
_uw count = discriminator & 0xffff;
struct vfp_regs tmp;
struct vfpv3_regs tmp_16_to_31;
int tmp_count;
_uw *sp;
_uw *dest;
int num_vfpv3_regs = 0;
/* We use an approximation here by bounding _UVRSD_DOUBLE
register numbers at 32 always, since we can't detect if
VFPv3 isn't present (in such a case the upper limit is 16). */
if ((representation != _UVRSD_VFPX && representation != _UVRSD_DOUBLE)
|| start + count > (representation == _UVRSD_VFPX ? 16 : 32)
|| (representation == _UVRSD_VFPX && start >= 16))
return _UVRSR_FAILED;
/* Check if we're being asked to pop VFPv3-only registers
(numbers 16 through 31). */
if (start >= 16)
num_vfpv3_regs = count;
else if (start + count > 16)
num_vfpv3_regs = start + count - 16;
if (num_vfpv3_regs && representation != _UVRSD_DOUBLE)
return _UVRSR_FAILED;
/* Demand-save coprocessor registers for stage1. */
if (start < 16 && (vrs->demand_save_flags & DEMAND_SAVE_VFP))
{
vrs->demand_save_flags &= ~DEMAND_SAVE_VFP;
if (representation == _UVRSD_DOUBLE)
{
/* Save in FLDMD/FSTMD format. */
vrs->demand_save_flags |= DEMAND_SAVE_VFP_D;
__gnu_Unwind_Save_VFP_D (&vrs->vfp);
}
else
{
/* Save in FLDMX/FSTMX format. */
vrs->demand_save_flags &= ~DEMAND_SAVE_VFP_D;
__gnu_Unwind_Save_VFP (&vrs->vfp);
}
}
if (num_vfpv3_regs > 0
&& (vrs->demand_save_flags & DEMAND_SAVE_VFP_V3))
{
vrs->demand_save_flags &= ~DEMAND_SAVE_VFP_V3;
__gnu_Unwind_Save_VFP_D_16_to_31 (&vrs->vfp_regs_16_to_31);
}
/* Restore the registers from the stack. Do this by saving the
current VFP registers to a memory area, moving the in-memory
values into that area, and restoring from the whole area.
For _UVRSD_VFPX we assume FSTMX standard format 1. */
if (representation == _UVRSD_VFPX)
__gnu_Unwind_Save_VFP (&tmp);
else
{
/* Save registers 0 .. 15 if required. */
if (start < 16)
__gnu_Unwind_Save_VFP_D (&tmp);
/* Save VFPv3 registers 16 .. 31 if required. */
if (num_vfpv3_regs)
__gnu_Unwind_Save_VFP_D_16_to_31 (&tmp_16_to_31);
}
/* Work out how many registers below register 16 need popping. */
tmp_count = num_vfpv3_regs > 0 ? 16 - start : count;
/* Copy registers below 16, if needed.
The stack address is only guaranteed to be word aligned, so
we can't use doubleword copies. */
sp = (_uw *) vrs->core.r[R_SP];
if (tmp_count > 0)
{
tmp_count *= 2;
dest = (_uw *) &tmp.d[start];
while (tmp_count--)
*(dest++) = *(sp++);
}
/* Copy VFPv3 registers numbered >= 16, if needed. */
if (num_vfpv3_regs > 0)
{
/* num_vfpv3_regs is needed below, so copy it. */
int tmp_count_2 = num_vfpv3_regs * 2;
int vfpv3_start = start < 16 ? 16 : start;
dest = (_uw *) &tmp_16_to_31.d[vfpv3_start - 16];
while (tmp_count_2--)
*(dest++) = *(sp++);
}
/* Skip the format word space if using FLDMX/FSTMX format. */
if (representation == _UVRSD_VFPX)
sp++;
/* Set the new stack pointer. */
vrs->core.r[R_SP] = (_uw) sp;
/* Reload the registers. */
if (representation == _UVRSD_VFPX)
__gnu_Unwind_Restore_VFP (&tmp);
else
{
/* Restore registers 0 .. 15 if required. */
if (start < 16)
__gnu_Unwind_Restore_VFP_D (&tmp);
/* Restore VFPv3 registers 16 .. 31 if required. */
if (num_vfpv3_regs > 0)
__gnu_Unwind_Restore_VFP_D_16_to_31 (&tmp_16_to_31);
}
}
return _UVRSR_OK;
case _UVRSC_WMMXD:
{
_uw start = discriminator >> 16;
_uw count = discriminator & 0xffff;
struct wmmxd_regs tmp;
_uw *sp;
_uw *dest;
if ((representation != _UVRSD_UINT64) || start + count > 16)
return _UVRSR_FAILED;
if (vrs->demand_save_flags & DEMAND_SAVE_WMMXD)
{
/* Demand-save resisters for stage1. */
vrs->demand_save_flags &= ~DEMAND_SAVE_WMMXD;
__gnu_Unwind_Save_WMMXD (&vrs->wmmxd);
}
/* Restore the registers from the stack. Do this by saving the
current WMMXD registers to a memory area, moving the in-memory
values into that area, and restoring from the whole area. */
__gnu_Unwind_Save_WMMXD (&tmp);
/* The stack address is only guaranteed to be word aligned, so
we can't use doubleword copies. */
sp = (_uw *) vrs->core.r[R_SP];
dest = (_uw *) &tmp.wd[start];
count *= 2;
while (count--)
*(dest++) = *(sp++);
/* Set the new stack pointer. */
vrs->core.r[R_SP] = (_uw) sp;
/* Reload the registers. */
__gnu_Unwind_Restore_WMMXD (&tmp);
}
return _UVRSR_OK;
case _UVRSC_WMMXC:
{
int i;
struct wmmxc_regs tmp;
_uw *sp;
if ((representation != _UVRSD_UINT32) || discriminator > 16)
return _UVRSR_FAILED;
if (vrs->demand_save_flags & DEMAND_SAVE_WMMXC)
{
/* Demand-save resisters for stage1. */
vrs->demand_save_flags &= ~DEMAND_SAVE_WMMXC;
__gnu_Unwind_Save_WMMXC (&vrs->wmmxc);
}
/* Restore the registers from the stack. Do this by saving the
current WMMXC registers to a memory area, moving the in-memory
values into that area, and restoring from the whole area. */
__gnu_Unwind_Save_WMMXC (&tmp);
sp = (_uw *) vrs->core.r[R_SP];
for (i = 0; i < 4; i++)
if (discriminator & (1 << i))
tmp.wc[i] = *(sp++);
/* Set the new stack pointer. */
vrs->core.r[R_SP] = (_uw) sp;
/* Reload the registers. */
__gnu_Unwind_Restore_WMMXC (&tmp);
}
return _UVRSR_OK;
default:
return _UVRSR_FAILED;
}
}
/* Core unwinding functions. */
/* Calculate the address encoded by a 31-bit self-relative offset at address
P. */
static inline _uw
selfrel_offset31 (const _uw *p)
{
_uw offset;
offset = *p;
/* Sign extend to 32 bits. */
if (offset & (1 << 30))
offset |= 1u << 31;
else
offset &= ~(1u << 31);
return offset + (_uw) p;
}
static _uw
__gnu_unwind_get_pr_addr (int idx)
{
switch (idx)
{
case 0:
return (_uw) &__aeabi_unwind_cpp_pr0;
case 1:
return (_uw) &__aeabi_unwind_cpp_pr1;
case 2:
return (_uw) &__aeabi_unwind_cpp_pr2;
default:
return 0;
}
}
/* ABI defined personality routine entry points. */
_Unwind_Reason_Code
__aeabi_unwind_cpp_pr0 (_Unwind_State state,
_Unwind_Control_Block *ucbp,
_Unwind_Context *context)
{
return __gnu_unwind_pr_common (state, ucbp, context, 0);
}
_Unwind_Reason_Code
__aeabi_unwind_cpp_pr1 (_Unwind_State state,
_Unwind_Control_Block *ucbp,
_Unwind_Context *context)
{
return __gnu_unwind_pr_common (state, ucbp, context, 1);
}
_Unwind_Reason_Code
__aeabi_unwind_cpp_pr2 (_Unwind_State state,
_Unwind_Control_Block *ucbp,
_Unwind_Context *context)
{
return __gnu_unwind_pr_common (state, ucbp, context, 2);
}
#ifdef __FreeBSD__
/* FreeBSD expects these to be functions */
inline _Unwind_Ptr
_Unwind_GetIP (struct _Unwind_Context *context)
{
return _Unwind_GetGR (context, 15) & ~(_Unwind_Word)1;
}
inline _Unwind_Ptr
_Unwind_GetIPInfo (struct _Unwind_Context *context, int *ip_before_insn)
{
*ip_before_insn = 0;
return _Unwind_GetIP (context);
}
inline void
_Unwind_SetIP (struct _Unwind_Context *context, _Unwind_Ptr val)
{
_Unwind_SetGR (context, 15, val | (_Unwind_GetGR (context, 15) & 1));
}
#endif
|