]>
Commit | Line | Data |
---|---|---|
1a4d82fc | 1 | /* internal.h -- Internal header file for stack backtrace library. |
ba9703b0 | 2 | Copyright (C) 2012-2020 Free Software Foundation, Inc. |
1a4d82fc JJ |
3 | Written by Ian Lance Taylor, Google. |
4 | ||
5 | Redistribution and use in source and binary forms, with or without | |
6 | modification, are permitted provided that the following conditions are | |
7 | met: | |
8 | ||
9 | (1) Redistributions of source code must retain the above copyright | |
94b46f34 | 10 | notice, this list of conditions and the following disclaimer. |
1a4d82fc JJ |
11 | |
12 | (2) Redistributions in binary form must reproduce the above copyright | |
13 | notice, this list of conditions and the following disclaimer in | |
14 | the documentation and/or other materials provided with the | |
94b46f34 XL |
15 | distribution. |
16 | ||
1a4d82fc JJ |
17 | (3) The name of the author may not be used to |
18 | endorse or promote products derived from this software without | |
19 | specific prior written permission. | |
20 | ||
21 | THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR | |
22 | IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | |
23 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
24 | DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, | |
25 | INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | |
26 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |
27 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
28 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | |
29 | STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING | |
30 | IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
31 | POSSIBILITY OF SUCH DAMAGE. */ | |
32 | ||
33 | #ifndef BACKTRACE_INTERNAL_H | |
34 | #define BACKTRACE_INTERNAL_H | |
35 | ||
36 | /* We assume that <sys/types.h> and "backtrace.h" have already been | |
37 | included. */ | |
38 | ||
39 | #ifndef GCC_VERSION | |
40 | # define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__) | |
41 | #endif | |
42 | ||
43 | #if (GCC_VERSION < 2007) | |
44 | # define __attribute__(x) | |
45 | #endif | |
46 | ||
47 | #ifndef ATTRIBUTE_UNUSED | |
48 | # define ATTRIBUTE_UNUSED __attribute__ ((__unused__)) | |
49 | #endif | |
50 | ||
51 | #ifndef ATTRIBUTE_MALLOC | |
52 | # if (GCC_VERSION >= 2096) | |
53 | # define ATTRIBUTE_MALLOC __attribute__ ((__malloc__)) | |
54 | # else | |
55 | # define ATTRIBUTE_MALLOC | |
56 | # endif | |
57 | #endif | |
58 | ||
59 | #ifndef HAVE_SYNC_FUNCTIONS | |
60 | ||
61 | /* Define out the sync functions. These should never be called if | |
62 | they are not available. */ | |
63 | ||
64 | #define __sync_bool_compare_and_swap(A, B, C) (abort(), 1) | |
65 | #define __sync_lock_test_and_set(A, B) (abort(), 0) | |
66 | #define __sync_lock_release(A) abort() | |
67 | ||
68 | #endif /* !defined (HAVE_SYNC_FUNCTIONS) */ | |
69 | ||
70 | #ifdef HAVE_ATOMIC_FUNCTIONS | |
71 | ||
72 | /* We have the atomic builtin functions. */ | |
73 | ||
74 | #define backtrace_atomic_load_pointer(p) \ | |
75 | __atomic_load_n ((p), __ATOMIC_ACQUIRE) | |
76 | #define backtrace_atomic_load_int(p) \ | |
77 | __atomic_load_n ((p), __ATOMIC_ACQUIRE) | |
78 | #define backtrace_atomic_store_pointer(p, v) \ | |
79 | __atomic_store_n ((p), (v), __ATOMIC_RELEASE) | |
80 | #define backtrace_atomic_store_size_t(p, v) \ | |
81 | __atomic_store_n ((p), (v), __ATOMIC_RELEASE) | |
82 | #define backtrace_atomic_store_int(p, v) \ | |
83 | __atomic_store_n ((p), (v), __ATOMIC_RELEASE) | |
84 | ||
85 | #else /* !defined (HAVE_ATOMIC_FUNCTIONS) */ | |
86 | #ifdef HAVE_SYNC_FUNCTIONS | |
87 | ||
88 | /* We have the sync functions but not the atomic functions. Define | |
89 | the atomic ones in terms of the sync ones. */ | |
90 | ||
91 | extern void *backtrace_atomic_load_pointer (void *); | |
92 | extern int backtrace_atomic_load_int (int *); | |
93 | extern void backtrace_atomic_store_pointer (void *, void *); | |
94 | extern void backtrace_atomic_store_size_t (size_t *, size_t); | |
95 | extern void backtrace_atomic_store_int (int *, int); | |
96 | ||
97 | #else /* !defined (HAVE_SYNC_FUNCTIONS) */ | |
98 | ||
99 | /* We have neither the sync nor the atomic functions. These will | |
100 | never be called. */ | |
101 | ||
9346a6ac | 102 | #define backtrace_atomic_load_pointer(p) (abort(), (void *) NULL) |
1a4d82fc JJ |
103 | #define backtrace_atomic_load_int(p) (abort(), 0) |
104 | #define backtrace_atomic_store_pointer(p, v) abort() | |
105 | #define backtrace_atomic_store_size_t(p, v) abort() | |
106 | #define backtrace_atomic_store_int(p, v) abort() | |
107 | ||
108 | #endif /* !defined (HAVE_SYNC_FUNCTIONS) */ | |
109 | #endif /* !defined (HAVE_ATOMIC_FUNCTIONS) */ | |
110 | ||
111 | /* The type of the function that collects file/line information. This | |
112 | is like backtrace_pcinfo. */ | |
113 | ||
114 | typedef int (*fileline) (struct backtrace_state *state, uintptr_t pc, | |
115 | backtrace_full_callback callback, | |
116 | backtrace_error_callback error_callback, void *data); | |
117 | ||
118 | /* The type of the function that collects symbol information. This is | |
119 | like backtrace_syminfo. */ | |
120 | ||
121 | typedef void (*syminfo) (struct backtrace_state *state, uintptr_t pc, | |
122 | backtrace_syminfo_callback callback, | |
123 | backtrace_error_callback error_callback, void *data); | |
124 | ||
125 | /* What the backtrace state pointer points to. */ | |
126 | ||
127 | struct backtrace_state | |
128 | { | |
129 | /* The name of the executable. */ | |
130 | const char *filename; | |
131 | /* Non-zero if threaded. */ | |
132 | int threaded; | |
133 | /* The master lock for fileline_fn, fileline_data, syminfo_fn, | |
134 | syminfo_data, fileline_initialization_failed and everything the | |
135 | data pointers point to. */ | |
136 | void *lock; | |
137 | /* The function that returns file/line information. */ | |
138 | fileline fileline_fn; | |
139 | /* The data to pass to FILELINE_FN. */ | |
140 | void *fileline_data; | |
141 | /* The function that returns symbol information. */ | |
142 | syminfo syminfo_fn; | |
143 | /* The data to pass to SYMINFO_FN. */ | |
144 | void *syminfo_data; | |
145 | /* Whether initializing the file/line information failed. */ | |
146 | int fileline_initialization_failed; | |
147 | /* The lock for the freelist. */ | |
148 | int lock_alloc; | |
149 | /* The freelist when using mmap. */ | |
150 | struct backtrace_freelist_struct *freelist; | |
151 | }; | |
152 | ||
153 | /* Open a file for reading. Returns -1 on error. If DOES_NOT_EXIST | |
154 | is not NULL, *DOES_NOT_EXIST will be set to 0 normally and set to 1 | |
155 | if the file does not exist. If the file does not exist and | |
156 | DOES_NOT_EXIST is not NULL, the function will return -1 and will | |
157 | not call ERROR_CALLBACK. On other errors, or if DOES_NOT_EXIST is | |
158 | NULL, the function will call ERROR_CALLBACK before returning. */ | |
159 | extern int backtrace_open (const char *filename, | |
160 | backtrace_error_callback error_callback, | |
161 | void *data, | |
162 | int *does_not_exist); | |
163 | ||
164 | /* A view of the contents of a file. This supports mmap when | |
165 | available. A view will remain in memory even after backtrace_close | |
166 | is called on the file descriptor from which the view was | |
167 | obtained. */ | |
168 | ||
169 | struct backtrace_view | |
170 | { | |
171 | /* The data that the caller requested. */ | |
172 | const void *data; | |
173 | /* The base of the view. */ | |
174 | void *base; | |
175 | /* The total length of the view. */ | |
176 | size_t len; | |
177 | }; | |
178 | ||
179 | /* Create a view of SIZE bytes from DESCRIPTOR at OFFSET. Store the | |
180 | result in *VIEW. Returns 1 on success, 0 on error. */ | |
181 | extern int backtrace_get_view (struct backtrace_state *state, int descriptor, | |
ba9703b0 | 182 | off_t offset, uint64_t size, |
1a4d82fc JJ |
183 | backtrace_error_callback error_callback, |
184 | void *data, struct backtrace_view *view); | |
185 | ||
186 | /* Release a view created by backtrace_get_view. */ | |
187 | extern void backtrace_release_view (struct backtrace_state *state, | |
188 | struct backtrace_view *view, | |
189 | backtrace_error_callback error_callback, | |
190 | void *data); | |
191 | ||
192 | /* Close a file opened by backtrace_open. Returns 1 on success, 0 on | |
193 | error. */ | |
194 | ||
195 | extern int backtrace_close (int descriptor, | |
196 | backtrace_error_callback error_callback, | |
197 | void *data); | |
198 | ||
9346a6ac AL |
199 | /* Sort without using memory. */ |
200 | ||
201 | extern void backtrace_qsort (void *base, size_t count, size_t size, | |
202 | int (*compar) (const void *, const void *)); | |
203 | ||
9cc50fc6 SL |
204 | /* Allocate memory. This is like malloc. If ERROR_CALLBACK is NULL, |
205 | this does not report an error, it just returns NULL. */ | |
1a4d82fc JJ |
206 | |
207 | extern void *backtrace_alloc (struct backtrace_state *state, size_t size, | |
208 | backtrace_error_callback error_callback, | |
209 | void *data) ATTRIBUTE_MALLOC; | |
210 | ||
9cc50fc6 SL |
211 | /* Free memory allocated by backtrace_alloc. If ERROR_CALLBACK is |
212 | NULL, this does not report an error. */ | |
1a4d82fc JJ |
213 | |
214 | extern void backtrace_free (struct backtrace_state *state, void *mem, | |
215 | size_t size, | |
216 | backtrace_error_callback error_callback, | |
217 | void *data); | |
218 | ||
219 | /* A growable vector of some struct. This is used for more efficient | |
220 | allocation when we don't know the final size of some group of data | |
221 | that we want to represent as an array. */ | |
222 | ||
223 | struct backtrace_vector | |
224 | { | |
225 | /* The base of the vector. */ | |
226 | void *base; | |
227 | /* The number of bytes in the vector. */ | |
228 | size_t size; | |
229 | /* The number of bytes available at the current allocation. */ | |
230 | size_t alc; | |
231 | }; | |
232 | ||
233 | /* Grow VEC by SIZE bytes. Return a pointer to the newly allocated | |
234 | bytes. Note that this may move the entire vector to a new memory | |
235 | location. Returns NULL on failure. */ | |
236 | ||
237 | extern void *backtrace_vector_grow (struct backtrace_state *state, size_t size, | |
238 | backtrace_error_callback error_callback, | |
239 | void *data, | |
240 | struct backtrace_vector *vec); | |
241 | ||
242 | /* Finish the current allocation on VEC. Prepare to start a new | |
243 | allocation. The finished allocation will never be freed. Returns | |
244 | a pointer to the base of the finished entries, or NULL on | |
245 | failure. */ | |
246 | ||
247 | extern void* backtrace_vector_finish (struct backtrace_state *state, | |
248 | struct backtrace_vector *vec, | |
249 | backtrace_error_callback error_callback, | |
250 | void *data); | |
251 | ||
252 | /* Release any extra space allocated for VEC. This may change | |
253 | VEC->base. Returns 1 on success, 0 on failure. */ | |
254 | ||
255 | extern int backtrace_vector_release (struct backtrace_state *state, | |
256 | struct backtrace_vector *vec, | |
257 | backtrace_error_callback error_callback, | |
258 | void *data); | |
259 | ||
ba9703b0 XL |
260 | /* Free the space managed by VEC. This will reset VEC. */ |
261 | ||
262 | static inline void | |
263 | backtrace_vector_free (struct backtrace_state *state, | |
264 | struct backtrace_vector *vec, | |
265 | backtrace_error_callback error_callback, void *data) | |
266 | { | |
267 | vec->alc += vec->size; | |
268 | vec->size = 0; | |
269 | backtrace_vector_release (state, vec, error_callback, data); | |
270 | } | |
271 | ||
1a4d82fc JJ |
272 | /* Read initial debug data from a descriptor, and set the |
273 | fileline_data, syminfo_fn, and syminfo_data fields of STATE. | |
274 | Return the fileln_fn field in *FILELN_FN--this is done this way so | |
275 | that the synchronization code is only implemented once. This is | |
276 | called after the descriptor has first been opened. It will close | |
277 | the descriptor if it is no longer needed. Returns 1 on success, 0 | |
278 | on error. There will be multiple implementations of this function, | |
279 | for different file formats. Each system will compile the | |
280 | appropriate one. */ | |
281 | ||
282 | extern int backtrace_initialize (struct backtrace_state *state, | |
94b46f34 | 283 | const char *filename, |
1a4d82fc JJ |
284 | int descriptor, |
285 | backtrace_error_callback error_callback, | |
286 | void *data, | |
287 | fileline *fileline_fn); | |
288 | ||
ba9703b0 XL |
289 | /* An enum for the DWARF sections we care about. */ |
290 | ||
291 | enum dwarf_section | |
292 | { | |
293 | DEBUG_INFO, | |
294 | DEBUG_LINE, | |
295 | DEBUG_ABBREV, | |
296 | DEBUG_RANGES, | |
297 | DEBUG_STR, | |
298 | DEBUG_ADDR, | |
299 | DEBUG_STR_OFFSETS, | |
300 | DEBUG_LINE_STR, | |
301 | DEBUG_RNGLISTS, | |
302 | ||
303 | DEBUG_MAX | |
304 | }; | |
305 | ||
306 | /* Data for the DWARF sections we care about. */ | |
307 | ||
308 | struct dwarf_sections | |
309 | { | |
310 | const unsigned char *data[DEBUG_MAX]; | |
311 | size_t size[DEBUG_MAX]; | |
312 | }; | |
313 | ||
314 | /* DWARF data read from a file, used for .gnu_debugaltlink. */ | |
315 | ||
316 | struct dwarf_data; | |
317 | ||
1a4d82fc JJ |
318 | /* Add file/line information for a DWARF module. */ |
319 | ||
320 | extern int backtrace_dwarf_add (struct backtrace_state *state, | |
321 | uintptr_t base_address, | |
ba9703b0 | 322 | const struct dwarf_sections *dwarf_sections, |
1a4d82fc | 323 | int is_bigendian, |
ba9703b0 | 324 | struct dwarf_data *fileline_altlink, |
1a4d82fc | 325 | backtrace_error_callback error_callback, |
ba9703b0 XL |
326 | void *data, fileline *fileline_fn, |
327 | struct dwarf_data **fileline_entry); | |
1a4d82fc | 328 | |
94b46f34 XL |
329 | /* A test-only hook for elf_uncompress_zdebug. */ |
330 | ||
331 | extern int backtrace_uncompress_zdebug (struct backtrace_state *, | |
332 | const unsigned char *compressed, | |
333 | size_t compressed_size, | |
334 | backtrace_error_callback, void *data, | |
335 | unsigned char **uncompressed, | |
336 | size_t *uncompressed_size); | |
337 | ||
1a4d82fc | 338 | #endif |