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