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