|
111
|
1 /* Exception handling and frame unwind runtime interface routines.
|
|
145
|
2 Copyright (C) 2001-2020 Free Software Foundation, Inc.
|
|
111
|
3
|
|
|
4 This file is part of GCC.
|
|
|
5
|
|
|
6 GCC is free software; you can redistribute it and/or modify it
|
|
|
7 under the terms of the GNU General Public License as published by
|
|
|
8 the Free Software Foundation; either version 3, or (at your option)
|
|
|
9 any later version.
|
|
|
10
|
|
|
11 GCC is distributed in the hope that it will be useful, but WITHOUT
|
|
|
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
|
13 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
|
|
|
14 License for more details.
|
|
|
15
|
|
|
16 Under Section 7 of GPL version 3, you are granted additional
|
|
|
17 permissions described in the GCC Runtime Library Exception, version
|
|
|
18 3.1, as published by the Free Software Foundation.
|
|
|
19
|
|
|
20 You should have received a copy of the GNU General Public License and
|
|
|
21 a copy of the GCC Runtime Library Exception along with this program;
|
|
|
22 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
|
23 <http://www.gnu.org/licenses/>. */
|
|
|
24
|
|
|
25 /* @@@ Really this should be out of line, but this also causes link
|
|
|
26 compatibility problems with the base ABI. This is slightly better
|
|
|
27 than duplicating code, however. */
|
|
|
28
|
|
|
29 #ifndef GCC_UNWIND_PE_H
|
|
|
30 #define GCC_UNWIND_PE_H
|
|
|
31
|
|
|
32 /* If using C++, references to abort have to be qualified with std::. */
|
|
|
33 #if __cplusplus
|
|
|
34 #define __gxx_abort std::abort
|
|
|
35 #else
|
|
|
36 #define __gxx_abort abort
|
|
|
37 #endif
|
|
|
38
|
|
|
39 /* Pointer encodings, from dwarf2.h. */
|
|
|
40 #define DW_EH_PE_absptr 0x00
|
|
|
41 #define DW_EH_PE_omit 0xff
|
|
|
42
|
|
|
43 #define DW_EH_PE_uleb128 0x01
|
|
|
44 #define DW_EH_PE_udata2 0x02
|
|
|
45 #define DW_EH_PE_udata4 0x03
|
|
|
46 #define DW_EH_PE_udata8 0x04
|
|
|
47 #define DW_EH_PE_sleb128 0x09
|
|
|
48 #define DW_EH_PE_sdata2 0x0A
|
|
|
49 #define DW_EH_PE_sdata4 0x0B
|
|
|
50 #define DW_EH_PE_sdata8 0x0C
|
|
|
51 #define DW_EH_PE_signed 0x08
|
|
|
52
|
|
|
53 #define DW_EH_PE_pcrel 0x10
|
|
|
54 #define DW_EH_PE_textrel 0x20
|
|
|
55 #define DW_EH_PE_datarel 0x30
|
|
|
56 #define DW_EH_PE_funcrel 0x40
|
|
|
57 #define DW_EH_PE_aligned 0x50
|
|
|
58
|
|
|
59 #define DW_EH_PE_indirect 0x80
|
|
|
60
|
|
|
61
|
|
|
62 #ifndef NO_SIZE_OF_ENCODED_VALUE
|
|
|
63
|
|
|
64 /* Given an encoding, return the number of bytes the format occupies.
|
|
|
65 This is only defined for fixed-size encodings, and so does not
|
|
|
66 include leb128. */
|
|
|
67
|
|
|
68 static unsigned int
|
|
|
69 size_of_encoded_value (unsigned char encoding) __attribute__ ((unused));
|
|
|
70
|
|
|
71 static unsigned int
|
|
|
72 size_of_encoded_value (unsigned char encoding)
|
|
|
73 {
|
|
|
74 if (encoding == DW_EH_PE_omit)
|
|
|
75 return 0;
|
|
|
76
|
|
|
77 switch (encoding & 0x07)
|
|
|
78 {
|
|
|
79 case DW_EH_PE_absptr:
|
|
|
80 return sizeof (void *);
|
|
|
81 case DW_EH_PE_udata2:
|
|
|
82 return 2;
|
|
|
83 case DW_EH_PE_udata4:
|
|
|
84 return 4;
|
|
|
85 case DW_EH_PE_udata8:
|
|
|
86 return 8;
|
|
|
87 }
|
|
|
88 __gxx_abort ();
|
|
|
89 }
|
|
|
90
|
|
|
91 #endif
|
|
|
92
|
|
|
93 #ifndef NO_BASE_OF_ENCODED_VALUE
|
|
|
94
|
|
|
95 /* Given an encoding and an _Unwind_Context, return the base to which
|
|
|
96 the encoding is relative. This base may then be passed to
|
|
|
97 read_encoded_value_with_base for use when the _Unwind_Context is
|
|
|
98 not available. */
|
|
|
99
|
|
|
100 static _Unwind_Ptr
|
|
|
101 base_of_encoded_value (unsigned char encoding, struct _Unwind_Context *context)
|
|
|
102 {
|
|
|
103 if (encoding == DW_EH_PE_omit)
|
|
|
104 return 0;
|
|
|
105
|
|
|
106 switch (encoding & 0x70)
|
|
|
107 {
|
|
|
108 case DW_EH_PE_absptr:
|
|
|
109 case DW_EH_PE_pcrel:
|
|
|
110 case DW_EH_PE_aligned:
|
|
|
111 return 0;
|
|
|
112
|
|
|
113 case DW_EH_PE_textrel:
|
|
|
114 return _Unwind_GetTextRelBase (context);
|
|
|
115 case DW_EH_PE_datarel:
|
|
|
116 return _Unwind_GetDataRelBase (context);
|
|
|
117 case DW_EH_PE_funcrel:
|
|
|
118 return _Unwind_GetRegionStart (context);
|
|
|
119 }
|
|
|
120 __gxx_abort ();
|
|
|
121 }
|
|
|
122
|
|
|
123 #endif
|
|
|
124
|
|
|
125 /* Read an unsigned leb128 value from P, store the value in VAL, return
|
|
|
126 P incremented past the value. We assume that a word is large enough to
|
|
|
127 hold any value so encoded; if it is smaller than a pointer on some target,
|
|
|
128 pointers should not be leb128 encoded on that target. */
|
|
|
129
|
|
|
130 static const unsigned char *
|
|
|
131 read_uleb128 (const unsigned char *p, _uleb128_t *val)
|
|
|
132 {
|
|
|
133 unsigned int shift = 0;
|
|
|
134 unsigned char byte;
|
|
|
135 _uleb128_t result;
|
|
|
136
|
|
|
137 result = 0;
|
|
|
138 do
|
|
|
139 {
|
|
|
140 byte = *p++;
|
|
|
141 result |= ((_uleb128_t)byte & 0x7f) << shift;
|
|
|
142 shift += 7;
|
|
|
143 }
|
|
|
144 while (byte & 0x80);
|
|
|
145
|
|
|
146 *val = result;
|
|
|
147 return p;
|
|
|
148 }
|
|
|
149
|
|
|
150 /* Similar, but read a signed leb128 value. */
|
|
|
151
|
|
|
152 static const unsigned char *
|
|
|
153 read_sleb128 (const unsigned char *p, _sleb128_t *val)
|
|
|
154 {
|
|
|
155 unsigned int shift = 0;
|
|
|
156 unsigned char byte;
|
|
|
157 _uleb128_t result;
|
|
|
158
|
|
|
159 result = 0;
|
|
|
160 do
|
|
|
161 {
|
|
|
162 byte = *p++;
|
|
|
163 result |= ((_uleb128_t)byte & 0x7f) << shift;
|
|
|
164 shift += 7;
|
|
|
165 }
|
|
|
166 while (byte & 0x80);
|
|
|
167
|
|
|
168 /* Sign-extend a negative value. */
|
|
|
169 if (shift < 8 * sizeof(result) && (byte & 0x40) != 0)
|
|
|
170 result |= -(((_uleb128_t)1L) << shift);
|
|
|
171
|
|
|
172 *val = (_sleb128_t) result;
|
|
|
173 return p;
|
|
|
174 }
|
|
|
175
|
|
|
176 /* Load an encoded value from memory at P. The value is returned in VAL;
|
|
|
177 The function returns P incremented past the value. BASE is as given
|
|
|
178 by base_of_encoded_value for this encoding in the appropriate context. */
|
|
|
179
|
|
145
|
180 #pragma GCC diagnostic push
|
|
|
181 #pragma GCC diagnostic ignored "-Waddress-of-packed-member"
|
|
|
182
|
|
111
|
183 static const unsigned char *
|
|
|
184 read_encoded_value_with_base (unsigned char encoding, _Unwind_Ptr base,
|
|
|
185 const unsigned char *p, _Unwind_Ptr *val)
|
|
|
186 {
|
|
|
187 union unaligned
|
|
|
188 {
|
|
|
189 void *ptr;
|
|
|
190 unsigned u2 __attribute__ ((mode (HI)));
|
|
|
191 unsigned u4 __attribute__ ((mode (SI)));
|
|
|
192 unsigned u8 __attribute__ ((mode (DI)));
|
|
|
193 signed s2 __attribute__ ((mode (HI)));
|
|
|
194 signed s4 __attribute__ ((mode (SI)));
|
|
|
195 signed s8 __attribute__ ((mode (DI)));
|
|
|
196 } __attribute__((__packed__));
|
|
|
197
|
|
|
198 const union unaligned *u = (const union unaligned *) p;
|
|
|
199 _Unwind_Internal_Ptr result;
|
|
|
200
|
|
|
201 if (encoding == DW_EH_PE_aligned)
|
|
|
202 {
|
|
|
203 _Unwind_Internal_Ptr a = (_Unwind_Internal_Ptr) p;
|
|
|
204 a = (a + sizeof (void *) - 1) & - sizeof(void *);
|
|
|
205 result = *(_Unwind_Internal_Ptr *) a;
|
|
|
206 p = (const unsigned char *) (_Unwind_Internal_Ptr) (a + sizeof (void *));
|
|
|
207 }
|
|
|
208 else
|
|
|
209 {
|
|
|
210 switch (encoding & 0x0f)
|
|
|
211 {
|
|
|
212 case DW_EH_PE_absptr:
|
|
|
213 result = (_Unwind_Internal_Ptr) u->ptr;
|
|
|
214 p += sizeof (void *);
|
|
|
215 break;
|
|
|
216
|
|
|
217 case DW_EH_PE_uleb128:
|
|
|
218 {
|
|
|
219 _uleb128_t tmp;
|
|
|
220 p = read_uleb128 (p, &tmp);
|
|
|
221 result = (_Unwind_Internal_Ptr) tmp;
|
|
|
222 }
|
|
|
223 break;
|
|
|
224
|
|
|
225 case DW_EH_PE_sleb128:
|
|
|
226 {
|
|
|
227 _sleb128_t tmp;
|
|
|
228 p = read_sleb128 (p, &tmp);
|
|
|
229 result = (_Unwind_Internal_Ptr) tmp;
|
|
|
230 }
|
|
|
231 break;
|
|
|
232
|
|
|
233 case DW_EH_PE_udata2:
|
|
|
234 result = u->u2;
|
|
|
235 p += 2;
|
|
|
236 break;
|
|
|
237 case DW_EH_PE_udata4:
|
|
|
238 result = u->u4;
|
|
|
239 p += 4;
|
|
|
240 break;
|
|
|
241 case DW_EH_PE_udata8:
|
|
|
242 result = u->u8;
|
|
|
243 p += 8;
|
|
|
244 break;
|
|
|
245
|
|
|
246 case DW_EH_PE_sdata2:
|
|
|
247 result = u->s2;
|
|
|
248 p += 2;
|
|
|
249 break;
|
|
|
250 case DW_EH_PE_sdata4:
|
|
|
251 result = u->s4;
|
|
|
252 p += 4;
|
|
|
253 break;
|
|
|
254 case DW_EH_PE_sdata8:
|
|
|
255 result = u->s8;
|
|
|
256 p += 8;
|
|
|
257 break;
|
|
|
258
|
|
|
259 default:
|
|
|
260 __gxx_abort ();
|
|
|
261 }
|
|
|
262
|
|
|
263 if (result != 0)
|
|
|
264 {
|
|
145
|
265 #if __FDPIC__
|
|
|
266 /* FDPIC relative addresses imply taking the GOT address
|
|
|
267 into account. */
|
|
|
268 if ((encoding & DW_EH_PE_pcrel) && (encoding & DW_EH_PE_indirect))
|
|
|
269 {
|
|
|
270 result += _Unwind_gnu_Find_got ((_Unwind_Ptr) u);
|
|
|
271 result = *(_Unwind_Internal_Ptr *) result;
|
|
|
272 }
|
|
|
273 else
|
|
|
274 {
|
|
|
275 result += ((encoding & 0x70) == DW_EH_PE_pcrel
|
|
|
276 ? (_Unwind_Internal_Ptr) u : base);
|
|
|
277 if (encoding & DW_EH_PE_indirect)
|
|
|
278 result = *(_Unwind_Internal_Ptr *) result;
|
|
|
279 }
|
|
|
280 #else
|
|
111
|
281 result += ((encoding & 0x70) == DW_EH_PE_pcrel
|
|
|
282 ? (_Unwind_Internal_Ptr) u : base);
|
|
|
283 if (encoding & DW_EH_PE_indirect)
|
|
|
284 result = *(_Unwind_Internal_Ptr *) result;
|
|
145
|
285 #endif
|
|
111
|
286 }
|
|
|
287 }
|
|
|
288
|
|
|
289 *val = result;
|
|
|
290 return p;
|
|
|
291 }
|
|
|
292
|
|
145
|
293 #pragma GCC diagnostic pop
|
|
|
294
|
|
111
|
295 #ifndef NO_BASE_OF_ENCODED_VALUE
|
|
|
296
|
|
|
297 /* Like read_encoded_value_with_base, but get the base from the context
|
|
|
298 rather than providing it directly. */
|
|
|
299
|
|
|
300 static inline const unsigned char *
|
|
|
301 read_encoded_value (struct _Unwind_Context *context, unsigned char encoding,
|
|
|
302 const unsigned char *p, _Unwind_Ptr *val)
|
|
|
303 {
|
|
|
304 return read_encoded_value_with_base (encoding,
|
|
|
305 base_of_encoded_value (encoding, context),
|
|
|
306 p, val);
|
|
|
307 }
|
|
|
308
|
|
|
309 #endif
|
|
|
310
|
|
|
311 #endif /* unwind-pe.h */
|
