Rev 5217 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
5217 | serge | 1 | /* wrstabs.c -- Output stabs debugging information |
6324 | serge | 2 | Copyright (C) 1996-2015 Free Software Foundation, Inc. |
5217 | serge | 3 | Written by Ian Lance Taylor |
4 | |||
5 | This file is part of GNU Binutils. |
||
6 | |||
7 | This program is free software; you can redistribute it and/or modify |
||
8 | it under the terms of the GNU General Public License as published by |
||
9 | the Free Software Foundation; either version 3 of the License, or |
||
10 | (at your option) any later version. |
||
11 | |||
12 | This program is distributed in the hope that it will be useful, |
||
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||
15 | GNU General Public License for more details. |
||
16 | |||
17 | You should have received a copy of the GNU General Public License |
||
18 | along with this program; if not, write to the Free Software |
||
19 | Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA |
||
20 | 02110-1301, USA. */ |
||
21 | |||
22 | /* This file contains code which writes out stabs debugging |
||
23 | information. */ |
||
24 | |||
25 | #include "sysdep.h" |
||
26 | #include |
||
27 | #include "bfd.h" |
||
28 | #include "libiberty.h" |
||
29 | #include "filenames.h" |
||
30 | #include "safe-ctype.h" |
||
31 | #include "bucomm.h" |
||
32 | #include "debug.h" |
||
33 | #include "budbg.h" |
||
34 | #include "aout/aout64.h" |
||
35 | #include "aout/stab_gnu.h" |
||
36 | |||
37 | /* The size of a stabs symbol. This presumes 32 bit values. */ |
||
38 | |||
39 | #define STAB_SYMBOL_SIZE (12) |
||
40 | |||
41 | /* An entry in a string hash table. */ |
||
42 | |||
43 | struct string_hash_entry |
||
44 | { |
||
45 | struct bfd_hash_entry root; |
||
46 | /* Next string in this table. */ |
||
47 | struct string_hash_entry *next; |
||
48 | /* Index in string table. */ |
||
49 | long index; |
||
50 | /* Size of type if this is a typedef. */ |
||
51 | unsigned int size; |
||
52 | }; |
||
53 | |||
54 | /* A string hash table. */ |
||
55 | |||
56 | struct string_hash_table |
||
57 | { |
||
58 | struct bfd_hash_table table; |
||
59 | }; |
||
60 | |||
61 | /* The type stack. Each element on the stack is a string. */ |
||
62 | |||
63 | struct stab_type_stack |
||
64 | { |
||
65 | /* The next element on the stack. */ |
||
66 | struct stab_type_stack *next; |
||
67 | /* This element as a string. */ |
||
68 | char *string; |
||
69 | /* The type index of this element. */ |
||
70 | long index; |
||
71 | /* The size of the type. */ |
||
72 | unsigned int size; |
||
73 | /* Whether type string defines a new type. */ |
||
74 | bfd_boolean definition; |
||
75 | /* String defining struct fields. */ |
||
76 | char *fields; |
||
77 | /* NULL terminated array of strings defining base classes for a |
||
78 | class. */ |
||
79 | char **baseclasses; |
||
80 | /* String defining class methods. */ |
||
81 | char *methods; |
||
82 | /* String defining vtable pointer for a class. */ |
||
83 | char *vtable; |
||
84 | }; |
||
85 | |||
86 | /* This structure is used to keep track of type indices for tagged |
||
87 | types. */ |
||
88 | |||
89 | struct stab_tag |
||
90 | { |
||
91 | /* The type index. */ |
||
92 | long index; |
||
93 | /* The tag name. */ |
||
94 | const char *tag; |
||
95 | /* The kind of type. This is set to DEBUG_KIND_ILLEGAL when the |
||
96 | type is defined. */ |
||
97 | enum debug_type_kind kind; |
||
98 | /* The size of the struct. */ |
||
99 | unsigned int size; |
||
100 | }; |
||
101 | |||
102 | /* We remember various sorts of type indices. They are not related, |
||
103 | but, for convenience, we keep all the information in this |
||
104 | structure. */ |
||
105 | |||
106 | struct stab_type_cache |
||
107 | { |
||
108 | /* The void type index. */ |
||
109 | long void_type; |
||
110 | /* Signed integer type indices, indexed by size - 1. */ |
||
111 | long signed_integer_types[8]; |
||
112 | /* Unsigned integer type indices, indexed by size - 1. */ |
||
113 | long unsigned_integer_types[8]; |
||
114 | /* Floating point types, indexed by size - 1. */ |
||
115 | long float_types[16]; |
||
116 | /* Pointers to types, indexed by the type index. */ |
||
117 | long *pointer_types; |
||
118 | size_t pointer_types_alloc; |
||
119 | /* Functions returning types, indexed by the type index. */ |
||
120 | long *function_types; |
||
121 | size_t function_types_alloc; |
||
122 | /* References to types, indexed by the type index. */ |
||
123 | long *reference_types; |
||
124 | size_t reference_types_alloc; |
||
125 | /* Struct/union/class type indices, indexed by the struct id. */ |
||
126 | struct stab_tag *struct_types; |
||
127 | size_t struct_types_alloc; |
||
128 | }; |
||
129 | |||
130 | /* This is the handle passed through debug_write. */ |
||
131 | |||
132 | struct stab_write_handle |
||
133 | { |
||
134 | /* The BFD. */ |
||
135 | bfd *abfd; |
||
136 | /* This buffer holds the symbols. */ |
||
137 | bfd_byte *symbols; |
||
138 | size_t symbols_size; |
||
139 | size_t symbols_alloc; |
||
140 | /* This is a list of hash table entries for the strings. */ |
||
141 | struct string_hash_entry *strings; |
||
142 | /* The last string hash table entry. */ |
||
143 | struct string_hash_entry *last_string; |
||
144 | /* The size of the strings. */ |
||
145 | size_t strings_size; |
||
146 | /* This hash table eliminates duplicate strings. */ |
||
147 | struct string_hash_table strhash; |
||
148 | /* The type stack. */ |
||
149 | struct stab_type_stack *type_stack; |
||
150 | /* The next type index. */ |
||
151 | long type_index; |
||
152 | /* The type cache. */ |
||
153 | struct stab_type_cache type_cache; |
||
154 | /* A mapping from typedef names to type indices. */ |
||
155 | struct string_hash_table typedef_hash; |
||
156 | /* If this is not -1, it is the offset to the most recent N_SO |
||
157 | symbol, and the value of that symbol needs to be set. */ |
||
158 | long so_offset; |
||
159 | /* If this is not -1, it is the offset to the most recent N_FUN |
||
160 | symbol, and the value of that symbol needs to be set. */ |
||
161 | long fun_offset; |
||
162 | /* The last text section address seen. */ |
||
163 | bfd_vma last_text_address; |
||
164 | /* The block nesting depth. */ |
||
165 | unsigned int nesting; |
||
166 | /* The function address. */ |
||
167 | bfd_vma fnaddr; |
||
168 | /* A pending LBRAC symbol. */ |
||
169 | bfd_vma pending_lbrac; |
||
170 | /* The current line number file name. */ |
||
171 | const char *lineno_filename; |
||
172 | }; |
||
173 | |||
174 | static struct bfd_hash_entry *string_hash_newfunc |
||
175 | (struct bfd_hash_entry *, struct bfd_hash_table *, const char *); |
||
176 | static bfd_boolean stab_write_symbol |
||
177 | (struct stab_write_handle *, int, int, bfd_vma, const char *); |
||
178 | static bfd_boolean stab_push_string |
||
179 | (struct stab_write_handle *, const char *, long, bfd_boolean, unsigned int); |
||
180 | static bfd_boolean stab_push_defined_type |
||
181 | (struct stab_write_handle *, long, unsigned int); |
||
182 | static char *stab_pop_type (struct stab_write_handle *); |
||
183 | static bfd_boolean stab_modify_type |
||
184 | (struct stab_write_handle *, int, unsigned int, long **, size_t *); |
||
185 | static long stab_get_struct_index |
||
186 | (struct stab_write_handle *, const char *, unsigned int, |
||
187 | enum debug_type_kind, unsigned int *); |
||
188 | static bfd_boolean stab_class_method_var |
||
189 | (struct stab_write_handle *, const char *, enum debug_visibility, |
||
190 | bfd_boolean, bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean); |
||
191 | static bfd_boolean stab_start_compilation_unit (void *, const char *); |
||
192 | static bfd_boolean stab_start_source (void *, const char *); |
||
193 | static bfd_boolean stab_empty_type (void *); |
||
194 | static bfd_boolean stab_void_type (void *); |
||
195 | static bfd_boolean stab_int_type (void *, unsigned int, bfd_boolean); |
||
196 | static bfd_boolean stab_float_type (void *, unsigned int); |
||
197 | static bfd_boolean stab_complex_type (void *, unsigned int); |
||
198 | static bfd_boolean stab_bool_type (void *, unsigned int); |
||
199 | static bfd_boolean stab_enum_type |
||
200 | (void *, const char *, const char **, bfd_signed_vma *); |
||
201 | static bfd_boolean stab_pointer_type (void *); |
||
202 | static bfd_boolean stab_function_type (void *, int, bfd_boolean); |
||
203 | static bfd_boolean stab_reference_type (void *); |
||
204 | static bfd_boolean stab_range_type (void *, bfd_signed_vma, bfd_signed_vma); |
||
205 | static bfd_boolean stab_array_type |
||
206 | (void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean); |
||
207 | static bfd_boolean stab_set_type (void *, bfd_boolean); |
||
208 | static bfd_boolean stab_offset_type (void *); |
||
209 | static bfd_boolean stab_method_type (void *, bfd_boolean, int, bfd_boolean); |
||
210 | static bfd_boolean stab_const_type (void *); |
||
211 | static bfd_boolean stab_volatile_type (void *); |
||
212 | static bfd_boolean stab_start_struct_type |
||
213 | (void *, const char *, unsigned int, bfd_boolean, unsigned int); |
||
214 | static bfd_boolean stab_struct_field |
||
215 | (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility); |
||
216 | static bfd_boolean stab_end_struct_type (void *); |
||
217 | static bfd_boolean stab_start_class_type |
||
218 | (void *, const char *, unsigned int, bfd_boolean, unsigned int, |
||
219 | bfd_boolean, bfd_boolean); |
||
220 | static bfd_boolean stab_class_static_member |
||
221 | (void *, const char *, const char *, enum debug_visibility); |
||
222 | static bfd_boolean stab_class_baseclass |
||
223 | (void *, bfd_vma, bfd_boolean, enum debug_visibility); |
||
224 | static bfd_boolean stab_class_start_method (void *, const char *); |
||
225 | static bfd_boolean stab_class_method_variant |
||
226 | (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean, |
||
227 | bfd_vma, bfd_boolean); |
||
228 | static bfd_boolean stab_class_static_method_variant |
||
229 | (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean); |
||
230 | static bfd_boolean stab_class_end_method (void *); |
||
231 | static bfd_boolean stab_end_class_type (void *); |
||
232 | static bfd_boolean stab_typedef_type (void *, const char *); |
||
233 | static bfd_boolean stab_tag_type |
||
234 | (void *, const char *, unsigned int, enum debug_type_kind); |
||
235 | static bfd_boolean stab_typdef (void *, const char *); |
||
236 | static bfd_boolean stab_tag (void *, const char *); |
||
237 | static bfd_boolean stab_int_constant (void *, const char *, bfd_vma); |
||
238 | static bfd_boolean stab_float_constant (void *, const char *, double); |
||
239 | static bfd_boolean stab_typed_constant (void *, const char *, bfd_vma); |
||
240 | static bfd_boolean stab_variable |
||
241 | (void *, const char *, enum debug_var_kind, bfd_vma); |
||
242 | static bfd_boolean stab_start_function (void *, const char *, bfd_boolean); |
||
243 | static bfd_boolean stab_function_parameter |
||
244 | (void *, const char *, enum debug_parm_kind, bfd_vma); |
||
245 | static bfd_boolean stab_start_block (void *, bfd_vma); |
||
246 | static bfd_boolean stab_end_block (void *, bfd_vma); |
||
247 | static bfd_boolean stab_end_function (void *); |
||
248 | static bfd_boolean stab_lineno (void *, const char *, unsigned long, bfd_vma); |
||
249 | |||
250 | static const struct debug_write_fns stab_fns = |
||
251 | { |
||
252 | stab_start_compilation_unit, |
||
253 | stab_start_source, |
||
254 | stab_empty_type, |
||
255 | stab_void_type, |
||
256 | stab_int_type, |
||
257 | stab_float_type, |
||
258 | stab_complex_type, |
||
259 | stab_bool_type, |
||
260 | stab_enum_type, |
||
261 | stab_pointer_type, |
||
262 | stab_function_type, |
||
263 | stab_reference_type, |
||
264 | stab_range_type, |
||
265 | stab_array_type, |
||
266 | stab_set_type, |
||
267 | stab_offset_type, |
||
268 | stab_method_type, |
||
269 | stab_const_type, |
||
270 | stab_volatile_type, |
||
271 | stab_start_struct_type, |
||
272 | stab_struct_field, |
||
273 | stab_end_struct_type, |
||
274 | stab_start_class_type, |
||
275 | stab_class_static_member, |
||
276 | stab_class_baseclass, |
||
277 | stab_class_start_method, |
||
278 | stab_class_method_variant, |
||
279 | stab_class_static_method_variant, |
||
280 | stab_class_end_method, |
||
281 | stab_end_class_type, |
||
282 | stab_typedef_type, |
||
283 | stab_tag_type, |
||
284 | stab_typdef, |
||
285 | stab_tag, |
||
286 | stab_int_constant, |
||
287 | stab_float_constant, |
||
288 | stab_typed_constant, |
||
289 | stab_variable, |
||
290 | stab_start_function, |
||
291 | stab_function_parameter, |
||
292 | stab_start_block, |
||
293 | stab_end_block, |
||
294 | stab_end_function, |
||
295 | stab_lineno |
||
296 | }; |
||
297 | |||
298 | /* Routine to create an entry in a string hash table. */ |
||
299 | |||
300 | static struct bfd_hash_entry * |
||
301 | string_hash_newfunc (struct bfd_hash_entry *entry, |
||
302 | struct bfd_hash_table *table, const char *string) |
||
303 | { |
||
304 | struct string_hash_entry *ret = (struct string_hash_entry *) entry; |
||
305 | |||
306 | /* Allocate the structure if it has not already been allocated by a |
||
307 | subclass. */ |
||
308 | if (ret == (struct string_hash_entry *) NULL) |
||
309 | ret = ((struct string_hash_entry *) |
||
310 | bfd_hash_allocate (table, sizeof (struct string_hash_entry))); |
||
311 | if (ret == (struct string_hash_entry *) NULL) |
||
312 | return NULL; |
||
313 | |||
314 | /* Call the allocation method of the superclass. */ |
||
315 | ret = ((struct string_hash_entry *) |
||
316 | bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string)); |
||
317 | |||
318 | if (ret) |
||
319 | { |
||
320 | /* Initialize the local fields. */ |
||
321 | ret->next = NULL; |
||
322 | ret->index = -1; |
||
323 | ret->size = 0; |
||
324 | } |
||
325 | |||
326 | return (struct bfd_hash_entry *) ret; |
||
327 | } |
||
328 | |||
329 | /* Look up an entry in a string hash table. */ |
||
330 | |||
331 | #define string_hash_lookup(t, string, create, copy) \ |
||
332 | ((struct string_hash_entry *) \ |
||
333 | bfd_hash_lookup (&(t)->table, (string), (create), (copy))) |
||
334 | |||
335 | /* Add a symbol to the stabs debugging information we are building. */ |
||
336 | |||
337 | static bfd_boolean |
||
338 | stab_write_symbol (struct stab_write_handle *info, int type, int desc, |
||
339 | bfd_vma value, const char *string) |
||
340 | { |
||
341 | bfd_size_type strx; |
||
342 | bfd_byte sym[STAB_SYMBOL_SIZE]; |
||
343 | |||
344 | if (string == NULL) |
||
345 | strx = 0; |
||
346 | else |
||
347 | { |
||
348 | struct string_hash_entry *h; |
||
349 | |||
350 | h = string_hash_lookup (&info->strhash, string, TRUE, TRUE); |
||
351 | if (h == NULL) |
||
352 | { |
||
353 | non_fatal (_("string_hash_lookup failed: %s"), |
||
354 | bfd_errmsg (bfd_get_error ())); |
||
355 | return FALSE; |
||
356 | } |
||
357 | if (h->index != -1) |
||
358 | strx = h->index; |
||
359 | else |
||
360 | { |
||
361 | strx = info->strings_size; |
||
362 | h->index = strx; |
||
363 | if (info->last_string == NULL) |
||
364 | info->strings = h; |
||
365 | else |
||
366 | info->last_string->next = h; |
||
367 | info->last_string = h; |
||
368 | info->strings_size += strlen (string) + 1; |
||
369 | } |
||
370 | } |
||
371 | |||
372 | /* This presumes 32 bit values. */ |
||
373 | bfd_put_32 (info->abfd, strx, sym); |
||
374 | bfd_put_8 (info->abfd, type, sym + 4); |
||
375 | bfd_put_8 (info->abfd, 0, sym + 5); |
||
376 | bfd_put_16 (info->abfd, desc, sym + 6); |
||
377 | bfd_put_32 (info->abfd, value, sym + 8); |
||
378 | |||
379 | if (info->symbols_size + STAB_SYMBOL_SIZE > info->symbols_alloc) |
||
380 | { |
||
381 | info->symbols_alloc *= 2; |
||
382 | info->symbols = (bfd_byte *) xrealloc (info->symbols, |
||
383 | info->symbols_alloc); |
||
384 | } |
||
385 | |||
386 | memcpy (info->symbols + info->symbols_size, sym, STAB_SYMBOL_SIZE); |
||
387 | |||
388 | info->symbols_size += STAB_SYMBOL_SIZE; |
||
389 | |||
390 | return TRUE; |
||
391 | } |
||
392 | |||
393 | /* Push a string on to the type stack. */ |
||
394 | |||
395 | static bfd_boolean |
||
396 | stab_push_string (struct stab_write_handle *info, const char *string, |
||
397 | long tindex, bfd_boolean definition, unsigned int size) |
||
398 | { |
||
399 | struct stab_type_stack *s; |
||
400 | |||
401 | s = (struct stab_type_stack *) xmalloc (sizeof *s); |
||
402 | s->string = xstrdup (string); |
||
403 | s->index = tindex; |
||
404 | s->definition = definition; |
||
405 | s->size = size; |
||
406 | |||
407 | s->fields = NULL; |
||
408 | s->baseclasses = NULL; |
||
409 | s->methods = NULL; |
||
410 | s->vtable = NULL; |
||
411 | |||
412 | s->next = info->type_stack; |
||
413 | info->type_stack = s; |
||
414 | |||
415 | return TRUE; |
||
416 | } |
||
417 | |||
418 | /* Push a type index which has already been defined. */ |
||
419 | |||
420 | static bfd_boolean |
||
421 | stab_push_defined_type (struct stab_write_handle *info, long tindex, |
||
422 | unsigned int size) |
||
423 | { |
||
424 | char buf[20]; |
||
425 | |||
426 | sprintf (buf, "%ld", tindex); |
||
427 | return stab_push_string (info, buf, tindex, FALSE, size); |
||
428 | } |
||
429 | |||
430 | /* Pop a type off the type stack. The caller is responsible for |
||
431 | freeing the string. */ |
||
432 | |||
433 | static char * |
||
434 | stab_pop_type (struct stab_write_handle *info) |
||
435 | { |
||
436 | struct stab_type_stack *s; |
||
437 | char *ret; |
||
438 | |||
439 | s = info->type_stack; |
||
440 | assert (s != NULL); |
||
441 | |||
442 | info->type_stack = s->next; |
||
443 | |||
444 | ret = s->string; |
||
445 | |||
446 | free (s); |
||
447 | |||
448 | return ret; |
||
449 | } |
||
450 | |||
451 | /* The general routine to write out stabs in sections debugging |
||
452 | information. This accumulates the stabs symbols and the strings in |
||
453 | two obstacks. We can't easily write out the information as we go |
||
454 | along, because we need to know the section sizes before we can |
||
455 | write out the section contents. ABFD is the BFD and DHANDLE is the |
||
456 | handle for the debugging information. This sets *PSYMS to point to |
||
457 | the symbols, *PSYMSIZE the size of the symbols, *PSTRINGS to the |
||
458 | strings, and *PSTRINGSIZE to the size of the strings. */ |
||
459 | |||
460 | bfd_boolean |
||
461 | write_stabs_in_sections_debugging_info (bfd *abfd, void *dhandle, |
||
462 | bfd_byte **psyms, |
||
463 | bfd_size_type *psymsize, |
||
464 | bfd_byte **pstrings, |
||
465 | bfd_size_type *pstringsize) |
||
466 | { |
||
467 | struct stab_write_handle info; |
||
468 | struct string_hash_entry *h; |
||
469 | bfd_byte *p; |
||
470 | |||
471 | info.abfd = abfd; |
||
472 | |||
473 | info.symbols_size = 0; |
||
474 | info.symbols_alloc = 500; |
||
475 | info.symbols = (bfd_byte *) xmalloc (info.symbols_alloc); |
||
476 | |||
477 | info.strings = NULL; |
||
478 | info.last_string = NULL; |
||
479 | /* Reserve 1 byte for a null byte. */ |
||
480 | info.strings_size = 1; |
||
481 | |||
482 | if (!bfd_hash_table_init (&info.strhash.table, string_hash_newfunc, |
||
483 | sizeof (struct string_hash_entry)) |
||
484 | || !bfd_hash_table_init (&info.typedef_hash.table, string_hash_newfunc, |
||
485 | sizeof (struct string_hash_entry))) |
||
486 | { |
||
487 | non_fatal ("bfd_hash_table_init_failed: %s", |
||
488 | bfd_errmsg (bfd_get_error ())); |
||
489 | return FALSE; |
||
490 | } |
||
491 | |||
492 | info.type_stack = NULL; |
||
493 | info.type_index = 1; |
||
494 | memset (&info.type_cache, 0, sizeof info.type_cache); |
||
495 | info.so_offset = -1; |
||
496 | info.fun_offset = -1; |
||
497 | info.last_text_address = 0; |
||
498 | info.nesting = 0; |
||
499 | info.fnaddr = 0; |
||
500 | info.pending_lbrac = (bfd_vma) -1; |
||
501 | |||
502 | /* The initial symbol holds the string size. */ |
||
503 | if (! stab_write_symbol (&info, 0, 0, 0, (const char *) NULL)) |
||
504 | return FALSE; |
||
505 | |||
506 | /* Output an initial N_SO symbol. */ |
||
507 | info.so_offset = info.symbols_size; |
||
508 | if (! stab_write_symbol (&info, N_SO, 0, 0, bfd_get_filename (abfd))) |
||
509 | return FALSE; |
||
510 | |||
511 | if (! debug_write (dhandle, &stab_fns, (void *) &info)) |
||
512 | return FALSE; |
||
513 | |||
514 | assert (info.pending_lbrac == (bfd_vma) -1); |
||
515 | |||
516 | /* Output a trailing N_SO. */ |
||
517 | if (! stab_write_symbol (&info, N_SO, 0, info.last_text_address, |
||
518 | (const char *) NULL)) |
||
519 | return FALSE; |
||
520 | |||
521 | /* Put the string size in the initial symbol. */ |
||
522 | bfd_put_32 (abfd, info.strings_size, info.symbols + 8); |
||
523 | |||
524 | *psyms = info.symbols; |
||
525 | *psymsize = info.symbols_size; |
||
526 | |||
527 | *pstringsize = info.strings_size; |
||
528 | *pstrings = (bfd_byte *) xmalloc (info.strings_size); |
||
529 | |||
530 | p = *pstrings; |
||
531 | *p++ = '\0'; |
||
532 | for (h = info.strings; h != NULL; h = h->next) |
||
533 | { |
||
534 | strcpy ((char *) p, h->root.string); |
||
535 | p += strlen ((char *) p) + 1; |
||
536 | } |
||
537 | |||
538 | return TRUE; |
||
539 | } |
||
540 | |||
541 | /* Start writing out information for a compilation unit. */ |
||
542 | |||
543 | static bfd_boolean |
||
544 | stab_start_compilation_unit (void *p, const char *filename) |
||
545 | { |
||
546 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
547 | |||
548 | /* We would normally output an N_SO symbol here. However, that |
||
549 | would force us to reset all of our type information. I think we |
||
550 | will be better off just outputting an N_SOL symbol, and not |
||
551 | worrying about splitting information between files. */ |
||
552 | |||
553 | info->lineno_filename = filename; |
||
554 | |||
555 | return stab_write_symbol (info, N_SOL, 0, 0, filename); |
||
556 | } |
||
557 | |||
558 | /* Start writing out information for a particular source file. */ |
||
559 | |||
560 | static bfd_boolean |
||
561 | stab_start_source (void *p, const char *filename) |
||
562 | { |
||
563 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
564 | |||
565 | /* FIXME: The symbol's value is supposed to be the text section |
||
566 | address. However, we would have to fill it in later, and gdb |
||
567 | doesn't care, so we don't bother with it. */ |
||
568 | |||
569 | info->lineno_filename = filename; |
||
570 | |||
571 | return stab_write_symbol (info, N_SOL, 0, 0, filename); |
||
572 | } |
||
573 | |||
574 | /* Push an empty type. This shouldn't normally happen. We just use a |
||
575 | void type. */ |
||
576 | |||
577 | static bfd_boolean |
||
578 | stab_empty_type (void *p) |
||
579 | { |
||
580 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
581 | |||
582 | /* We don't call stab_void_type if the type is not yet defined, |
||
583 | because that might screw up the typedef. */ |
||
584 | |||
585 | if (info->type_cache.void_type != 0) |
||
586 | return stab_push_defined_type (info, info->type_cache.void_type, 0); |
||
587 | else |
||
588 | { |
||
589 | long tindex; |
||
590 | char buf[40]; |
||
591 | |||
592 | tindex = info->type_index; |
||
593 | ++info->type_index; |
||
594 | |||
595 | sprintf (buf, "%ld=%ld", tindex, tindex); |
||
596 | |||
597 | return stab_push_string (info, buf, tindex, FALSE, 0); |
||
598 | } |
||
599 | } |
||
600 | |||
601 | /* Push a void type. */ |
||
602 | |||
603 | static bfd_boolean |
||
604 | stab_void_type (void *p) |
||
605 | { |
||
606 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
607 | |||
608 | if (info->type_cache.void_type != 0) |
||
609 | return stab_push_defined_type (info, info->type_cache.void_type, 0); |
||
610 | else |
||
611 | { |
||
612 | long tindex; |
||
613 | char buf[40]; |
||
614 | |||
615 | tindex = info->type_index; |
||
616 | ++info->type_index; |
||
617 | |||
618 | info->type_cache.void_type = tindex; |
||
619 | |||
620 | sprintf (buf, "%ld=%ld", tindex, tindex); |
||
621 | |||
622 | return stab_push_string (info, buf, tindex, TRUE, 0); |
||
623 | } |
||
624 | } |
||
625 | |||
626 | /* Push an integer type. */ |
||
627 | |||
628 | static bfd_boolean |
||
629 | stab_int_type (void *p, unsigned int size, bfd_boolean unsignedp) |
||
630 | { |
||
631 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
632 | long *cache; |
||
633 | |||
634 | if (size <= 0 || (size > sizeof (long) && size != 8)) |
||
635 | { |
||
636 | non_fatal (_("stab_int_type: bad size %u"), size); |
||
637 | return FALSE; |
||
638 | } |
||
639 | |||
640 | if (unsignedp) |
||
641 | cache = info->type_cache.signed_integer_types; |
||
642 | else |
||
643 | cache = info->type_cache.unsigned_integer_types; |
||
644 | |||
645 | if (cache[size - 1] != 0) |
||
646 | return stab_push_defined_type (info, cache[size - 1], size); |
||
647 | else |
||
648 | { |
||
649 | long tindex; |
||
650 | char buf[100]; |
||
651 | |||
652 | tindex = info->type_index; |
||
653 | ++info->type_index; |
||
654 | |||
655 | cache[size - 1] = tindex; |
||
656 | |||
657 | sprintf (buf, "%ld=r%ld;", tindex, tindex); |
||
658 | if (unsignedp) |
||
659 | { |
||
660 | strcat (buf, "0;"); |
||
661 | if (size < sizeof (long)) |
||
662 | sprintf (buf + strlen (buf), "%ld;", ((long) 1 << (size * 8)) - 1); |
||
663 | else if (size == sizeof (long)) |
||
664 | strcat (buf, "-1;"); |
||
665 | else if (size == 8) |
||
666 | strcat (buf, "01777777777777777777777;"); |
||
667 | else |
||
668 | abort (); |
||
669 | } |
||
670 | else |
||
671 | { |
||
672 | if (size <= sizeof (long)) |
||
673 | sprintf (buf + strlen (buf), "%ld;%ld;", |
||
674 | (long) - ((unsigned long) 1 << (size * 8 - 1)), |
||
675 | (long) (((unsigned long) 1 << (size * 8 - 1)) - 1)); |
||
676 | else if (size == 8) |
||
677 | strcat (buf, "01000000000000000000000;0777777777777777777777;"); |
||
678 | else |
||
679 | abort (); |
||
680 | } |
||
681 | |||
682 | return stab_push_string (info, buf, tindex, TRUE, size); |
||
683 | } |
||
684 | } |
||
685 | |||
686 | /* Push a floating point type. */ |
||
687 | |||
688 | static bfd_boolean |
||
689 | stab_float_type (void *p, unsigned int size) |
||
690 | { |
||
691 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
692 | |||
693 | if (size > 0 |
||
694 | && size - 1 < (sizeof info->type_cache.float_types |
||
695 | / sizeof info->type_cache.float_types[0]) |
||
696 | && info->type_cache.float_types[size - 1] != 0) |
||
697 | return stab_push_defined_type (info, |
||
698 | info->type_cache.float_types[size - 1], |
||
699 | size); |
||
700 | else |
||
701 | { |
||
702 | long tindex; |
||
703 | char *int_type; |
||
704 | char buf[50]; |
||
705 | |||
706 | /* Floats are defined as a subrange of int. */ |
||
707 | if (! stab_int_type (info, 4, FALSE)) |
||
708 | return FALSE; |
||
709 | int_type = stab_pop_type (info); |
||
710 | |||
711 | tindex = info->type_index; |
||
712 | ++info->type_index; |
||
713 | |||
714 | if (size > 0 |
||
715 | && size - 1 < (sizeof info->type_cache.float_types |
||
716 | / sizeof info->type_cache.float_types[0])) |
||
717 | info->type_cache.float_types[size - 1] = tindex; |
||
718 | |||
719 | sprintf (buf, "%ld=r%s;%u;0;", tindex, int_type, size); |
||
720 | |||
721 | free (int_type); |
||
722 | |||
723 | return stab_push_string (info, buf, tindex, TRUE, size); |
||
724 | } |
||
725 | } |
||
726 | |||
727 | /* Push a complex type. */ |
||
728 | |||
729 | static bfd_boolean |
||
730 | stab_complex_type (void *p, unsigned int size) |
||
731 | { |
||
732 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
733 | char buf[50]; |
||
734 | long tindex; |
||
735 | |||
736 | tindex = info->type_index; |
||
737 | ++info->type_index; |
||
738 | |||
739 | sprintf (buf, "%ld=r%ld;%u;0;", tindex, tindex, size); |
||
740 | |||
741 | return stab_push_string (info, buf, tindex, TRUE, size * 2); |
||
742 | } |
||
743 | |||
744 | /* Push a bfd_boolean type. We use an XCOFF predefined type, since gdb |
||
745 | always recognizes them. */ |
||
746 | |||
747 | static bfd_boolean |
||
748 | stab_bool_type (void *p, unsigned int size) |
||
749 | { |
||
750 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
751 | long tindex; |
||
752 | |||
753 | switch (size) |
||
754 | { |
||
755 | case 1: |
||
756 | tindex = -21; |
||
757 | break; |
||
758 | |||
759 | case 2: |
||
760 | tindex = -22; |
||
761 | break; |
||
762 | |||
763 | default: |
||
764 | case 4: |
||
765 | tindex = -16; |
||
766 | break; |
||
767 | |||
768 | case 8: |
||
769 | tindex = -33; |
||
770 | break; |
||
771 | } |
||
772 | |||
773 | return stab_push_defined_type (info, tindex, size); |
||
774 | } |
||
775 | |||
776 | /* Push an enum type. */ |
||
777 | |||
778 | static bfd_boolean |
||
779 | stab_enum_type (void *p, const char *tag, const char **names, |
||
780 | bfd_signed_vma *vals) |
||
781 | { |
||
782 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
783 | size_t len; |
||
784 | const char **pn; |
||
785 | char *buf; |
||
786 | long tindex = 0; |
||
787 | bfd_signed_vma *pv; |
||
788 | |||
789 | if (names == NULL) |
||
790 | { |
||
791 | assert (tag != NULL); |
||
792 | |||
793 | buf = (char *) xmalloc (10 + strlen (tag)); |
||
794 | sprintf (buf, "xe%s:", tag); |
||
795 | /* FIXME: The size is just a guess. */ |
||
796 | if (! stab_push_string (info, buf, 0, FALSE, 4)) |
||
797 | return FALSE; |
||
798 | free (buf); |
||
799 | return TRUE; |
||
800 | } |
||
801 | |||
802 | len = 10; |
||
803 | if (tag != NULL) |
||
804 | len += strlen (tag); |
||
805 | for (pn = names; *pn != NULL; pn++) |
||
806 | len += strlen (*pn) + 20; |
||
807 | |||
808 | buf = (char *) xmalloc (len); |
||
809 | |||
810 | if (tag == NULL) |
||
811 | strcpy (buf, "e"); |
||
812 | else |
||
813 | { |
||
814 | tindex = info->type_index; |
||
815 | ++info->type_index; |
||
816 | sprintf (buf, "%s:T%ld=e", tag, tindex); |
||
817 | } |
||
818 | |||
819 | for (pn = names, pv = vals; *pn != NULL; pn++, pv++) |
||
820 | sprintf (buf + strlen (buf), "%s:%ld,", *pn, (long) *pv); |
||
821 | strcat (buf, ";"); |
||
822 | |||
823 | if (tag == NULL) |
||
824 | { |
||
825 | /* FIXME: The size is just a guess. */ |
||
826 | if (! stab_push_string (info, buf, 0, FALSE, 4)) |
||
827 | return FALSE; |
||
828 | } |
||
829 | else |
||
830 | { |
||
831 | /* FIXME: The size is just a guess. */ |
||
832 | if (! stab_write_symbol (info, N_LSYM, 0, 0, buf) |
||
833 | || ! stab_push_defined_type (info, tindex, 4)) |
||
834 | return FALSE; |
||
835 | } |
||
836 | |||
837 | free (buf); |
||
838 | |||
839 | return TRUE; |
||
840 | } |
||
841 | |||
842 | /* Push a modification of the top type on the stack. Cache the |
||
843 | results in CACHE and CACHE_ALLOC. */ |
||
844 | |||
845 | static bfd_boolean |
||
846 | stab_modify_type (struct stab_write_handle *info, int mod, |
||
847 | unsigned int size, long **cache, size_t *cache_alloc) |
||
848 | { |
||
849 | long targindex; |
||
850 | long tindex; |
||
851 | char *s, *buf; |
||
852 | |||
853 | assert (info->type_stack != NULL); |
||
854 | targindex = info->type_stack->index; |
||
855 | |||
856 | if (targindex <= 0 |
||
857 | || cache == NULL) |
||
858 | { |
||
859 | bfd_boolean definition; |
||
860 | |||
861 | /* Either the target type has no index, or we aren't caching |
||
862 | this modifier. Either way we have no way of recording the |
||
863 | new type, so we don't bother to define one. */ |
||
864 | definition = info->type_stack->definition; |
||
865 | s = stab_pop_type (info); |
||
866 | buf = (char *) xmalloc (strlen (s) + 2); |
||
867 | sprintf (buf, "%c%s", mod, s); |
||
868 | free (s); |
||
869 | if (! stab_push_string (info, buf, 0, definition, size)) |
||
870 | return FALSE; |
||
871 | free (buf); |
||
872 | } |
||
873 | else |
||
874 | { |
||
875 | if ((size_t) targindex >= *cache_alloc) |
||
876 | { |
||
877 | size_t alloc; |
||
878 | |||
879 | alloc = *cache_alloc; |
||
880 | if (alloc == 0) |
||
881 | alloc = 10; |
||
882 | while ((size_t) targindex >= alloc) |
||
883 | alloc *= 2; |
||
884 | *cache = (long *) xrealloc (*cache, alloc * sizeof (long)); |
||
885 | memset (*cache + *cache_alloc, 0, |
||
886 | (alloc - *cache_alloc) * sizeof (long)); |
||
887 | *cache_alloc = alloc; |
||
888 | } |
||
889 | |||
890 | tindex = (*cache)[targindex]; |
||
891 | if (tindex != 0 && ! info->type_stack->definition) |
||
892 | { |
||
893 | /* We have already defined a modification of this type, and |
||
894 | the entry on the type stack is not a definition, so we |
||
895 | can safely discard it (we may have a definition on the |
||
896 | stack, even if we already defined a modification, if it |
||
897 | is a struct which we did not define at the time it was |
||
898 | referenced). */ |
||
899 | free (stab_pop_type (info)); |
||
900 | if (! stab_push_defined_type (info, tindex, size)) |
||
901 | return FALSE; |
||
902 | } |
||
903 | else |
||
904 | { |
||
905 | tindex = info->type_index; |
||
906 | ++info->type_index; |
||
907 | |||
908 | s = stab_pop_type (info); |
||
909 | buf = (char *) xmalloc (strlen (s) + 20); |
||
910 | sprintf (buf, "%ld=%c%s", tindex, mod, s); |
||
911 | free (s); |
||
912 | |||
913 | (*cache)[targindex] = tindex; |
||
914 | |||
915 | if (! stab_push_string (info, buf, tindex, TRUE, size)) |
||
916 | return FALSE; |
||
917 | |||
918 | free (buf); |
||
919 | } |
||
920 | } |
||
921 | |||
922 | return TRUE; |
||
923 | } |
||
924 | |||
925 | /* Push a pointer type. */ |
||
926 | |||
927 | static bfd_boolean |
||
928 | stab_pointer_type (void *p) |
||
929 | { |
||
930 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
931 | |||
932 | /* FIXME: The size should depend upon the architecture. */ |
||
933 | return stab_modify_type (info, '*', 4, &info->type_cache.pointer_types, |
||
934 | &info->type_cache.pointer_types_alloc); |
||
935 | } |
||
936 | |||
937 | /* Push a function type. */ |
||
938 | |||
939 | static bfd_boolean |
||
940 | stab_function_type (void *p, int argcount, |
||
941 | bfd_boolean varargs ATTRIBUTE_UNUSED) |
||
942 | { |
||
943 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
944 | int i; |
||
945 | |||
946 | /* We have no way to represent the argument types, so we just |
||
947 | discard them. However, if they define new types, we must output |
||
948 | them. We do this by producing empty typedefs. */ |
||
949 | for (i = 0; i < argcount; i++) |
||
950 | { |
||
951 | if (! info->type_stack->definition) |
||
952 | free (stab_pop_type (info)); |
||
953 | else |
||
954 | { |
||
955 | char *s, *buf; |
||
956 | |||
957 | s = stab_pop_type (info); |
||
958 | |||
959 | buf = (char *) xmalloc (strlen (s) + 3); |
||
960 | sprintf (buf, ":t%s", s); |
||
961 | free (s); |
||
962 | |||
963 | if (! stab_write_symbol (info, N_LSYM, 0, 0, buf)) |
||
964 | return FALSE; |
||
965 | |||
966 | free (buf); |
||
967 | } |
||
968 | } |
||
969 | |||
970 | return stab_modify_type (info, 'f', 0, &info->type_cache.function_types, |
||
971 | &info->type_cache.function_types_alloc); |
||
972 | } |
||
973 | |||
974 | /* Push a reference type. */ |
||
975 | |||
976 | static bfd_boolean |
||
977 | stab_reference_type (void *p) |
||
978 | { |
||
979 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
980 | |||
981 | /* FIXME: The size should depend upon the architecture. */ |
||
982 | return stab_modify_type (info, '&', 4, &info->type_cache.reference_types, |
||
983 | &info->type_cache.reference_types_alloc); |
||
984 | } |
||
985 | |||
986 | /* Push a range type. */ |
||
987 | |||
988 | static bfd_boolean |
||
989 | stab_range_type (void *p, bfd_signed_vma low, bfd_signed_vma high) |
||
990 | { |
||
991 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
992 | bfd_boolean definition; |
||
993 | unsigned int size; |
||
994 | char *s, *buf; |
||
995 | |||
996 | definition = info->type_stack->definition; |
||
997 | size = info->type_stack->size; |
||
998 | |||
999 | s = stab_pop_type (info); |
||
1000 | buf = (char *) xmalloc (strlen (s) + 100); |
||
1001 | sprintf (buf, "r%s;%ld;%ld;", s, (long) low, (long) high); |
||
1002 | free (s); |
||
1003 | |||
1004 | if (! stab_push_string (info, buf, 0, definition, size)) |
||
1005 | return FALSE; |
||
1006 | |||
1007 | free (buf); |
||
1008 | |||
1009 | return TRUE; |
||
1010 | } |
||
1011 | |||
1012 | /* Push an array type. */ |
||
1013 | |||
1014 | static bfd_boolean |
||
1015 | stab_array_type (void *p, bfd_signed_vma low, bfd_signed_vma high, |
||
1016 | bfd_boolean stringp) |
||
1017 | { |
||
1018 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1019 | bfd_boolean definition; |
||
1020 | unsigned int element_size; |
||
1021 | char *range, *element, *buf; |
||
1022 | long tindex; |
||
1023 | unsigned int size; |
||
1024 | |||
1025 | definition = info->type_stack->definition; |
||
1026 | range = stab_pop_type (info); |
||
1027 | |||
1028 | definition = definition || info->type_stack->definition; |
||
1029 | element_size = info->type_stack->size; |
||
1030 | element = stab_pop_type (info); |
||
1031 | |||
1032 | buf = (char *) xmalloc (strlen (range) + strlen (element) + 100); |
||
1033 | |||
1034 | if (! stringp) |
||
1035 | { |
||
1036 | tindex = 0; |
||
1037 | *buf = '\0'; |
||
1038 | } |
||
1039 | else |
||
1040 | { |
||
1041 | /* We need to define a type in order to include the string |
||
1042 | attribute. */ |
||
1043 | tindex = info->type_index; |
||
1044 | ++info->type_index; |
||
1045 | definition = TRUE; |
||
1046 | sprintf (buf, "%ld=@S;", tindex); |
||
1047 | } |
||
1048 | |||
1049 | sprintf (buf + strlen (buf), "ar%s;%ld;%ld;%s", |
||
1050 | range, (long) low, (long) high, element); |
||
1051 | free (range); |
||
1052 | free (element); |
||
1053 | |||
1054 | if (high < low) |
||
1055 | size = 0; |
||
1056 | else |
||
1057 | size = element_size * ((high - low) + 1); |
||
1058 | if (! stab_push_string (info, buf, tindex, definition, size)) |
||
1059 | return FALSE; |
||
1060 | |||
1061 | free (buf); |
||
1062 | |||
1063 | return TRUE; |
||
1064 | } |
||
1065 | |||
1066 | /* Push a set type. */ |
||
1067 | |||
1068 | static bfd_boolean |
||
1069 | stab_set_type (void *p, bfd_boolean bitstringp) |
||
1070 | { |
||
1071 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1072 | bfd_boolean definition; |
||
1073 | char *s, *buf; |
||
1074 | long tindex; |
||
1075 | |||
1076 | definition = info->type_stack->definition; |
||
1077 | |||
1078 | s = stab_pop_type (info); |
||
1079 | buf = (char *) xmalloc (strlen (s) + 30); |
||
1080 | |||
1081 | if (! bitstringp) |
||
1082 | { |
||
1083 | *buf = '\0'; |
||
1084 | tindex = 0; |
||
1085 | } |
||
1086 | else |
||
1087 | { |
||
1088 | /* We need to define a type in order to include the string |
||
1089 | attribute. */ |
||
1090 | tindex = info->type_index; |
||
1091 | ++info->type_index; |
||
1092 | definition = TRUE; |
||
1093 | sprintf (buf, "%ld=@S;", tindex); |
||
1094 | } |
||
1095 | |||
1096 | sprintf (buf + strlen (buf), "S%s", s); |
||
1097 | free (s); |
||
1098 | |||
1099 | if (! stab_push_string (info, buf, tindex, definition, 0)) |
||
1100 | return FALSE; |
||
1101 | |||
1102 | free (buf); |
||
1103 | |||
1104 | return TRUE; |
||
1105 | } |
||
1106 | |||
1107 | /* Push an offset type. */ |
||
1108 | |||
1109 | static bfd_boolean |
||
1110 | stab_offset_type (void *p) |
||
1111 | { |
||
1112 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1113 | bfd_boolean definition; |
||
1114 | char *target, *base, *buf; |
||
1115 | |||
1116 | definition = info->type_stack->definition; |
||
1117 | target = stab_pop_type (info); |
||
1118 | |||
1119 | definition = definition || info->type_stack->definition; |
||
1120 | base = stab_pop_type (info); |
||
1121 | |||
1122 | buf = (char *) xmalloc (strlen (target) + strlen (base) + 3); |
||
1123 | sprintf (buf, "@%s,%s", base, target); |
||
1124 | free (base); |
||
1125 | free (target); |
||
1126 | |||
1127 | if (! stab_push_string (info, buf, 0, definition, 0)) |
||
1128 | return FALSE; |
||
1129 | |||
1130 | free (buf); |
||
1131 | |||
1132 | return TRUE; |
||
1133 | } |
||
1134 | |||
1135 | /* Push a method type. */ |
||
1136 | |||
1137 | static bfd_boolean |
||
1138 | stab_method_type (void *p, bfd_boolean domainp, int argcount, |
||
1139 | bfd_boolean varargs) |
||
1140 | { |
||
1141 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1142 | bfd_boolean definition; |
||
1143 | char *domain, *return_type, *buf; |
||
1144 | char **args; |
||
1145 | int i; |
||
1146 | size_t len; |
||
1147 | |||
1148 | /* We don't bother with stub method types, because that would |
||
1149 | require a mangler for C++ argument types. This will waste space |
||
1150 | in the debugging output. */ |
||
1151 | |||
1152 | /* We need a domain. I'm not sure DOMAINP can ever be false, |
||
1153 | anyhow. */ |
||
1154 | if (! domainp) |
||
1155 | { |
||
1156 | if (! stab_empty_type (p)) |
||
1157 | return FALSE; |
||
1158 | } |
||
1159 | |||
1160 | definition = info->type_stack->definition; |
||
1161 | domain = stab_pop_type (info); |
||
1162 | |||
1163 | /* A non-varargs function is indicated by making the last parameter |
||
1164 | type be void. */ |
||
1165 | |||
1166 | if (argcount < 0) |
||
1167 | { |
||
1168 | args = NULL; |
||
1169 | argcount = 0; |
||
1170 | } |
||
1171 | else if (argcount == 0) |
||
1172 | { |
||
1173 | if (varargs) |
||
1174 | args = NULL; |
||
1175 | else |
||
1176 | { |
||
1177 | args = (char **) xmalloc (1 * sizeof (*args)); |
||
1178 | if (! stab_empty_type (p)) |
||
1179 | return FALSE; |
||
1180 | definition = definition || info->type_stack->definition; |
||
1181 | args[0] = stab_pop_type (info); |
||
1182 | argcount = 1; |
||
1183 | } |
||
1184 | } |
||
1185 | else |
||
1186 | { |
||
1187 | args = (char **) xmalloc ((argcount + 1) * sizeof (*args)); |
||
1188 | for (i = argcount - 1; i >= 0; i--) |
||
1189 | { |
||
1190 | definition = definition || info->type_stack->definition; |
||
1191 | args[i] = stab_pop_type (info); |
||
1192 | } |
||
1193 | if (! varargs) |
||
1194 | { |
||
1195 | if (! stab_empty_type (p)) |
||
1196 | return FALSE; |
||
1197 | definition = definition || info->type_stack->definition; |
||
1198 | args[argcount] = stab_pop_type (info); |
||
1199 | ++argcount; |
||
1200 | } |
||
1201 | } |
||
1202 | |||
1203 | definition = definition || info->type_stack->definition; |
||
1204 | return_type = stab_pop_type (info); |
||
1205 | |||
1206 | len = strlen (domain) + strlen (return_type) + 10; |
||
1207 | for (i = 0; i < argcount; i++) |
||
1208 | len += strlen (args[i]); |
||
1209 | |||
1210 | buf = (char *) xmalloc (len); |
||
1211 | |||
1212 | sprintf (buf, "#%s,%s", domain, return_type); |
||
1213 | free (domain); |
||
1214 | free (return_type); |
||
1215 | for (i = 0; i < argcount; i++) |
||
1216 | { |
||
1217 | strcat (buf, ","); |
||
1218 | strcat (buf, args[i]); |
||
1219 | free (args[i]); |
||
1220 | } |
||
1221 | strcat (buf, ";"); |
||
1222 | |||
1223 | if (args != NULL) |
||
1224 | free (args); |
||
1225 | |||
1226 | if (! stab_push_string (info, buf, 0, definition, 0)) |
||
1227 | return FALSE; |
||
1228 | |||
1229 | free (buf); |
||
1230 | |||
1231 | return TRUE; |
||
1232 | } |
||
1233 | |||
1234 | /* Push a const version of a type. */ |
||
1235 | |||
1236 | static bfd_boolean |
||
1237 | stab_const_type (void *p) |
||
1238 | { |
||
1239 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1240 | |||
1241 | return stab_modify_type (info, 'k', info->type_stack->size, |
||
1242 | (long **) NULL, (size_t *) NULL); |
||
1243 | } |
||
1244 | |||
1245 | /* Push a volatile version of a type. */ |
||
1246 | |||
1247 | static bfd_boolean |
||
1248 | stab_volatile_type (void *p) |
||
1249 | { |
||
1250 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1251 | |||
1252 | return stab_modify_type (info, 'B', info->type_stack->size, |
||
1253 | (long **) NULL, (size_t *) NULL); |
||
1254 | } |
||
1255 | |||
1256 | /* Get the type index to use for a struct/union/class ID. This should |
||
1257 | return -1 if it fails. */ |
||
1258 | |||
1259 | static long |
||
1260 | stab_get_struct_index (struct stab_write_handle *info, const char *tag, |
||
1261 | unsigned int id, enum debug_type_kind kind, |
||
1262 | unsigned int *psize) |
||
1263 | { |
||
1264 | if (id >= info->type_cache.struct_types_alloc) |
||
1265 | { |
||
1266 | size_t alloc; |
||
1267 | |||
1268 | alloc = info->type_cache.struct_types_alloc; |
||
1269 | if (alloc == 0) |
||
1270 | alloc = 10; |
||
1271 | while (id >= alloc) |
||
1272 | alloc *= 2; |
||
1273 | info->type_cache.struct_types = |
||
1274 | (struct stab_tag *) xrealloc (info->type_cache.struct_types, |
||
1275 | alloc * sizeof (struct stab_tag)); |
||
1276 | memset ((info->type_cache.struct_types |
||
1277 | + info->type_cache.struct_types_alloc), |
||
1278 | 0, |
||
1279 | ((alloc - info->type_cache.struct_types_alloc) |
||
1280 | * sizeof (struct stab_tag))); |
||
1281 | info->type_cache.struct_types_alloc = alloc; |
||
1282 | } |
||
1283 | |||
1284 | if (info->type_cache.struct_types[id].index == 0) |
||
1285 | { |
||
1286 | info->type_cache.struct_types[id].index = info->type_index; |
||
1287 | ++info->type_index; |
||
1288 | info->type_cache.struct_types[id].tag = tag; |
||
1289 | info->type_cache.struct_types[id].kind = kind; |
||
1290 | } |
||
1291 | |||
1292 | if (kind == DEBUG_KIND_ILLEGAL) |
||
1293 | { |
||
1294 | /* This is a definition of the struct. */ |
||
1295 | info->type_cache.struct_types[id].kind = kind; |
||
1296 | info->type_cache.struct_types[id].size = *psize; |
||
1297 | } |
||
1298 | else |
||
1299 | *psize = info->type_cache.struct_types[id].size; |
||
1300 | |||
1301 | return info->type_cache.struct_types[id].index; |
||
1302 | } |
||
1303 | |||
1304 | /* Start outputting a struct. We ignore the tag, and handle it in |
||
1305 | stab_tag. */ |
||
1306 | |||
1307 | static bfd_boolean |
||
1308 | stab_start_struct_type (void *p, const char *tag, unsigned int id, |
||
1309 | bfd_boolean structp, unsigned int size) |
||
1310 | { |
||
1311 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1312 | long tindex; |
||
1313 | bfd_boolean definition; |
||
1314 | char buf[40]; |
||
1315 | |||
1316 | if (id == 0) |
||
1317 | { |
||
1318 | tindex = 0; |
||
1319 | *buf = '\0'; |
||
1320 | definition = FALSE; |
||
1321 | } |
||
1322 | else |
||
1323 | { |
||
1324 | tindex = stab_get_struct_index (info, tag, id, DEBUG_KIND_ILLEGAL, |
||
1325 | &size); |
||
1326 | if (tindex < 0) |
||
1327 | return FALSE; |
||
1328 | sprintf (buf, "%ld=", tindex); |
||
1329 | definition = TRUE; |
||
1330 | } |
||
1331 | |||
1332 | sprintf (buf + strlen (buf), "%c%u", |
||
1333 | structp ? 's' : 'u', |
||
1334 | size); |
||
1335 | |||
1336 | if (! stab_push_string (info, buf, tindex, definition, size)) |
||
1337 | return FALSE; |
||
1338 | |||
1339 | info->type_stack->fields = (char *) xmalloc (1); |
||
1340 | info->type_stack->fields[0] = '\0'; |
||
1341 | |||
1342 | return TRUE; |
||
1343 | } |
||
1344 | |||
1345 | /* Add a field to a struct. */ |
||
1346 | |||
1347 | static bfd_boolean |
||
1348 | stab_struct_field (void *p, const char *name, bfd_vma bitpos, |
||
1349 | bfd_vma bitsize, enum debug_visibility visibility) |
||
1350 | { |
||
1351 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1352 | bfd_boolean definition; |
||
1353 | unsigned int size; |
||
1354 | char *s, *n; |
||
1355 | const char *vis; |
||
1356 | |||
1357 | definition = info->type_stack->definition; |
||
1358 | size = info->type_stack->size; |
||
1359 | s = stab_pop_type (info); |
||
1360 | |||
1361 | /* Add this field to the end of the current struct fields, which is |
||
1362 | currently on the top of the stack. */ |
||
1363 | |||
1364 | assert (info->type_stack->fields != NULL); |
||
1365 | n = (char *) xmalloc (strlen (info->type_stack->fields) |
||
1366 | + strlen (name) |
||
1367 | + strlen (s) |
||
1368 | + 50); |
||
1369 | |||
1370 | switch (visibility) |
||
1371 | { |
||
1372 | default: |
||
1373 | abort (); |
||
1374 | |||
1375 | case DEBUG_VISIBILITY_PUBLIC: |
||
1376 | vis = ""; |
||
1377 | break; |
||
1378 | |||
1379 | case DEBUG_VISIBILITY_PRIVATE: |
||
1380 | vis = "/0"; |
||
1381 | break; |
||
1382 | |||
1383 | case DEBUG_VISIBILITY_PROTECTED: |
||
1384 | vis = "/1"; |
||
1385 | break; |
||
1386 | } |
||
1387 | |||
1388 | if (bitsize == 0) |
||
1389 | { |
||
1390 | bitsize = size * 8; |
||
1391 | if (bitsize == 0) |
||
1392 | non_fatal (_("%s: warning: unknown size for field `%s' in struct"), |
||
1393 | bfd_get_filename (info->abfd), name); |
||
1394 | } |
||
1395 | |||
1396 | sprintf (n, "%s%s:%s%s,%ld,%ld;", info->type_stack->fields, name, vis, s, |
||
1397 | (long) bitpos, (long) bitsize); |
||
1398 | |||
1399 | free (info->type_stack->fields); |
||
1400 | info->type_stack->fields = n; |
||
1401 | |||
1402 | if (definition) |
||
1403 | info->type_stack->definition = TRUE; |
||
1404 | |||
1405 | return TRUE; |
||
1406 | } |
||
1407 | |||
1408 | /* Finish up a struct. */ |
||
1409 | |||
1410 | static bfd_boolean |
||
1411 | stab_end_struct_type (void *p) |
||
1412 | { |
||
1413 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1414 | bfd_boolean definition; |
||
1415 | long tindex; |
||
1416 | unsigned int size; |
||
1417 | char *fields, *first, *buf; |
||
1418 | |||
1419 | assert (info->type_stack != NULL && info->type_stack->fields != NULL); |
||
1420 | |||
1421 | definition = info->type_stack->definition; |
||
1422 | tindex = info->type_stack->index; |
||
1423 | size = info->type_stack->size; |
||
1424 | fields = info->type_stack->fields; |
||
1425 | first = stab_pop_type (info); |
||
1426 | |||
1427 | buf = (char *) xmalloc (strlen (first) + strlen (fields) + 2); |
||
1428 | sprintf (buf, "%s%s;", first, fields); |
||
1429 | free (first); |
||
1430 | free (fields); |
||
1431 | |||
1432 | if (! stab_push_string (info, buf, tindex, definition, size)) |
||
1433 | return FALSE; |
||
1434 | |||
1435 | free (buf); |
||
1436 | |||
1437 | return TRUE; |
||
1438 | } |
||
1439 | |||
1440 | /* Start outputting a class. */ |
||
1441 | |||
1442 | static bfd_boolean |
||
1443 | stab_start_class_type (void *p, const char *tag, unsigned int id, bfd_boolean structp, unsigned int size, bfd_boolean vptr, bfd_boolean ownvptr) |
||
1444 | { |
||
1445 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1446 | bfd_boolean definition; |
||
1447 | char *vstring; |
||
1448 | |||
1449 | if (! vptr || ownvptr) |
||
1450 | { |
||
1451 | definition = FALSE; |
||
1452 | vstring = NULL; |
||
1453 | } |
||
1454 | else |
||
1455 | { |
||
1456 | definition = info->type_stack->definition; |
||
1457 | vstring = stab_pop_type (info); |
||
1458 | } |
||
1459 | |||
1460 | if (! stab_start_struct_type (p, tag, id, structp, size)) |
||
1461 | return FALSE; |
||
1462 | |||
1463 | if (vptr) |
||
1464 | { |
||
1465 | char *vtable; |
||
1466 | |||
1467 | if (ownvptr) |
||
1468 | { |
||
1469 | assert (info->type_stack->index > 0); |
||
1470 | vtable = (char *) xmalloc (20); |
||
1471 | sprintf (vtable, "~%%%ld", info->type_stack->index); |
||
1472 | } |
||
1473 | else |
||
1474 | { |
||
1475 | vtable = (char *) xmalloc (strlen (vstring) + 3); |
||
1476 | sprintf (vtable, "~%%%s", vstring); |
||
1477 | free (vstring); |
||
1478 | } |
||
1479 | |||
1480 | info->type_stack->vtable = vtable; |
||
1481 | } |
||
1482 | |||
1483 | if (definition) |
||
1484 | info->type_stack->definition = TRUE; |
||
1485 | |||
1486 | return TRUE; |
||
1487 | } |
||
1488 | |||
1489 | /* Add a static member to the class on the type stack. */ |
||
1490 | |||
1491 | static bfd_boolean |
||
1492 | stab_class_static_member (void *p, const char *name, const char *physname, |
||
1493 | enum debug_visibility visibility) |
||
1494 | { |
||
1495 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1496 | bfd_boolean definition; |
||
1497 | char *s, *n; |
||
1498 | const char *vis; |
||
1499 | |||
1500 | definition = info->type_stack->definition; |
||
1501 | s = stab_pop_type (info); |
||
1502 | |||
1503 | /* Add this field to the end of the current struct fields, which is |
||
1504 | currently on the top of the stack. */ |
||
1505 | |||
1506 | assert (info->type_stack->fields != NULL); |
||
1507 | n = (char *) xmalloc (strlen (info->type_stack->fields) |
||
1508 | + strlen (name) |
||
1509 | + strlen (s) |
||
1510 | + strlen (physname) |
||
1511 | + 10); |
||
1512 | |||
1513 | switch (visibility) |
||
1514 | { |
||
1515 | default: |
||
1516 | abort (); |
||
1517 | |||
1518 | case DEBUG_VISIBILITY_PUBLIC: |
||
1519 | vis = ""; |
||
1520 | break; |
||
1521 | |||
1522 | case DEBUG_VISIBILITY_PRIVATE: |
||
1523 | vis = "/0"; |
||
1524 | break; |
||
1525 | |||
1526 | case DEBUG_VISIBILITY_PROTECTED: |
||
1527 | vis = "/1"; |
||
1528 | break; |
||
1529 | } |
||
1530 | |||
1531 | sprintf (n, "%s%s:%s%s:%s;", info->type_stack->fields, name, vis, s, |
||
1532 | physname); |
||
1533 | |||
1534 | free (info->type_stack->fields); |
||
1535 | info->type_stack->fields = n; |
||
1536 | |||
1537 | if (definition) |
||
1538 | info->type_stack->definition = TRUE; |
||
1539 | |||
1540 | return TRUE; |
||
1541 | } |
||
1542 | |||
1543 | /* Add a base class to the class on the type stack. */ |
||
1544 | |||
1545 | static bfd_boolean |
||
1546 | stab_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean is_virtual, |
||
1547 | enum debug_visibility visibility) |
||
1548 | { |
||
1549 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1550 | bfd_boolean definition; |
||
1551 | char *s; |
||
1552 | char *buf; |
||
1553 | unsigned int c; |
||
1554 | char **baseclasses; |
||
1555 | |||
1556 | definition = info->type_stack->definition; |
||
1557 | s = stab_pop_type (info); |
||
1558 | |||
1559 | /* Build the base class specifier. */ |
||
1560 | |||
1561 | buf = (char *) xmalloc (strlen (s) + 25); |
||
1562 | buf[0] = is_virtual ? '1' : '0'; |
||
1563 | switch (visibility) |
||
1564 | { |
||
1565 | default: |
||
1566 | abort (); |
||
1567 | |||
1568 | case DEBUG_VISIBILITY_PRIVATE: |
||
1569 | buf[1] = '0'; |
||
1570 | break; |
||
1571 | |||
1572 | case DEBUG_VISIBILITY_PROTECTED: |
||
1573 | buf[1] = '1'; |
||
1574 | break; |
||
1575 | |||
1576 | case DEBUG_VISIBILITY_PUBLIC: |
||
1577 | buf[1] = '2'; |
||
1578 | break; |
||
1579 | } |
||
1580 | |||
1581 | sprintf (buf + 2, "%ld,%s;", (long) bitpos, s); |
||
1582 | free (s); |
||
1583 | |||
1584 | /* Add the new baseclass to the existing ones. */ |
||
1585 | |||
1586 | assert (info->type_stack != NULL && info->type_stack->fields != NULL); |
||
1587 | |||
1588 | if (info->type_stack->baseclasses == NULL) |
||
1589 | c = 0; |
||
1590 | else |
||
1591 | { |
||
1592 | c = 0; |
||
1593 | while (info->type_stack->baseclasses[c] != NULL) |
||
1594 | ++c; |
||
1595 | } |
||
1596 | |||
1597 | baseclasses = (char **) xrealloc (info->type_stack->baseclasses, |
||
1598 | (c + 2) * sizeof (*baseclasses)); |
||
1599 | baseclasses[c] = buf; |
||
1600 | baseclasses[c + 1] = NULL; |
||
1601 | |||
1602 | info->type_stack->baseclasses = baseclasses; |
||
1603 | |||
1604 | if (definition) |
||
1605 | info->type_stack->definition = TRUE; |
||
1606 | |||
1607 | return TRUE; |
||
1608 | } |
||
1609 | |||
1610 | /* Start adding a method to the class on the type stack. */ |
||
1611 | |||
1612 | static bfd_boolean |
||
1613 | stab_class_start_method (void *p, const char *name) |
||
1614 | { |
||
1615 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1616 | char *m; |
||
1617 | |||
1618 | assert (info->type_stack != NULL && info->type_stack->fields != NULL); |
||
1619 | |||
1620 | if (info->type_stack->methods == NULL) |
||
1621 | { |
||
1622 | m = (char *) xmalloc (strlen (name) + 3); |
||
1623 | *m = '\0'; |
||
1624 | } |
||
1625 | else |
||
1626 | { |
||
1627 | m = (char *) xrealloc (info->type_stack->methods, |
||
1628 | (strlen (info->type_stack->methods) |
||
1629 | + strlen (name) |
||
1630 | + 4)); |
||
1631 | } |
||
1632 | |||
1633 | sprintf (m + strlen (m), "%s::", name); |
||
1634 | |||
1635 | info->type_stack->methods = m; |
||
1636 | |||
1637 | return TRUE; |
||
1638 | } |
||
1639 | |||
1640 | /* Add a variant, either static or not, to the current method. */ |
||
1641 | |||
1642 | static bfd_boolean |
||
1643 | stab_class_method_var (struct stab_write_handle *info, const char *physname, |
||
1644 | enum debug_visibility visibility, |
||
1645 | bfd_boolean staticp, bfd_boolean constp, |
||
1646 | bfd_boolean volatilep, bfd_vma voffset, |
||
1647 | bfd_boolean contextp) |
||
1648 | { |
||
1649 | bfd_boolean definition; |
||
1650 | char *type; |
||
1651 | char *context = NULL; |
||
1652 | char visc, qualc, typec; |
||
1653 | |||
1654 | definition = info->type_stack->definition; |
||
1655 | type = stab_pop_type (info); |
||
1656 | |||
1657 | if (contextp) |
||
1658 | { |
||
1659 | definition = definition || info->type_stack->definition; |
||
1660 | context = stab_pop_type (info); |
||
1661 | } |
||
1662 | |||
1663 | assert (info->type_stack != NULL && info->type_stack->methods != NULL); |
||
1664 | |||
1665 | switch (visibility) |
||
1666 | { |
||
1667 | default: |
||
1668 | abort (); |
||
1669 | |||
1670 | case DEBUG_VISIBILITY_PRIVATE: |
||
1671 | visc = '0'; |
||
1672 | break; |
||
1673 | |||
1674 | case DEBUG_VISIBILITY_PROTECTED: |
||
1675 | visc = '1'; |
||
1676 | break; |
||
1677 | |||
1678 | case DEBUG_VISIBILITY_PUBLIC: |
||
1679 | visc = '2'; |
||
1680 | break; |
||
1681 | } |
||
1682 | |||
1683 | if (constp) |
||
1684 | { |
||
1685 | if (volatilep) |
||
1686 | qualc = 'D'; |
||
1687 | else |
||
1688 | qualc = 'B'; |
||
1689 | } |
||
1690 | else |
||
1691 | { |
||
1692 | if (volatilep) |
||
1693 | qualc = 'C'; |
||
1694 | else |
||
1695 | qualc = 'A'; |
||
1696 | } |
||
1697 | |||
1698 | if (staticp) |
||
1699 | typec = '?'; |
||
1700 | else if (! contextp) |
||
1701 | typec = '.'; |
||
1702 | else |
||
1703 | typec = '*'; |
||
1704 | |||
1705 | info->type_stack->methods = |
||
1706 | (char *) xrealloc (info->type_stack->methods, |
||
1707 | (strlen (info->type_stack->methods) |
||
1708 | + strlen (type) |
||
1709 | + strlen (physname) |
||
1710 | + (contextp ? strlen (context) : 0) |
||
1711 | + 40)); |
||
1712 | |||
1713 | sprintf (info->type_stack->methods + strlen (info->type_stack->methods), |
||
1714 | "%s:%s;%c%c%c", type, physname, visc, qualc, typec); |
||
1715 | free (type); |
||
1716 | |||
1717 | if (contextp) |
||
1718 | { |
||
1719 | sprintf (info->type_stack->methods + strlen (info->type_stack->methods), |
||
1720 | "%ld;%s;", (long) voffset, context); |
||
1721 | free (context); |
||
1722 | } |
||
1723 | |||
1724 | if (definition) |
||
1725 | info->type_stack->definition = TRUE; |
||
1726 | |||
1727 | return TRUE; |
||
1728 | } |
||
1729 | |||
1730 | /* Add a variant to the current method. */ |
||
1731 | |||
1732 | static bfd_boolean |
||
1733 | stab_class_method_variant (void *p, const char *physname, |
||
1734 | enum debug_visibility visibility, |
||
1735 | bfd_boolean constp, bfd_boolean volatilep, |
||
1736 | bfd_vma voffset, bfd_boolean contextp) |
||
1737 | { |
||
1738 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1739 | |||
1740 | return stab_class_method_var (info, physname, visibility, FALSE, constp, |
||
1741 | volatilep, voffset, contextp); |
||
1742 | } |
||
1743 | |||
1744 | /* Add a static variant to the current method. */ |
||
1745 | |||
1746 | static bfd_boolean |
||
1747 | stab_class_static_method_variant (void *p, const char *physname, |
||
1748 | enum debug_visibility visibility, |
||
1749 | bfd_boolean constp, bfd_boolean volatilep) |
||
1750 | { |
||
1751 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1752 | |||
1753 | return stab_class_method_var (info, physname, visibility, TRUE, constp, |
||
1754 | volatilep, 0, FALSE); |
||
1755 | } |
||
1756 | |||
1757 | /* Finish up a method. */ |
||
1758 | |||
1759 | static bfd_boolean |
||
1760 | stab_class_end_method (void *p) |
||
1761 | { |
||
1762 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1763 | |||
1764 | assert (info->type_stack != NULL && info->type_stack->methods != NULL); |
||
1765 | |||
1766 | /* We allocated enough room on info->type_stack->methods to add the |
||
1767 | trailing semicolon. */ |
||
1768 | strcat (info->type_stack->methods, ";"); |
||
1769 | |||
1770 | return TRUE; |
||
1771 | } |
||
1772 | |||
1773 | /* Finish up a class. */ |
||
1774 | |||
1775 | static bfd_boolean |
||
1776 | stab_end_class_type (void *p) |
||
1777 | { |
||
1778 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1779 | size_t len; |
||
1780 | unsigned int i = 0; |
||
1781 | char *buf; |
||
1782 | |||
1783 | assert (info->type_stack != NULL && info->type_stack->fields != NULL); |
||
1784 | |||
1785 | /* Work out the size we need to allocate for the class definition. */ |
||
1786 | |||
1787 | len = (strlen (info->type_stack->string) |
||
1788 | + strlen (info->type_stack->fields) |
||
1789 | + 10); |
||
1790 | if (info->type_stack->baseclasses != NULL) |
||
1791 | { |
||
1792 | len += 20; |
||
1793 | for (i = 0; info->type_stack->baseclasses[i] != NULL; i++) |
||
1794 | len += strlen (info->type_stack->baseclasses[i]); |
||
1795 | } |
||
1796 | if (info->type_stack->methods != NULL) |
||
1797 | len += strlen (info->type_stack->methods); |
||
1798 | if (info->type_stack->vtable != NULL) |
||
1799 | len += strlen (info->type_stack->vtable); |
||
1800 | |||
1801 | /* Build the class definition. */ |
||
1802 | |||
1803 | buf = (char *) xmalloc (len); |
||
1804 | |||
1805 | strcpy (buf, info->type_stack->string); |
||
1806 | |||
1807 | if (info->type_stack->baseclasses != NULL) |
||
1808 | { |
||
1809 | sprintf (buf + strlen (buf), "!%u,", i); |
||
1810 | for (i = 0; info->type_stack->baseclasses[i] != NULL; i++) |
||
1811 | { |
||
1812 | strcat (buf, info->type_stack->baseclasses[i]); |
||
1813 | free (info->type_stack->baseclasses[i]); |
||
1814 | } |
||
1815 | free (info->type_stack->baseclasses); |
||
1816 | info->type_stack->baseclasses = NULL; |
||
1817 | } |
||
1818 | |||
1819 | strcat (buf, info->type_stack->fields); |
||
1820 | free (info->type_stack->fields); |
||
1821 | info->type_stack->fields = NULL; |
||
1822 | |||
1823 | if (info->type_stack->methods != NULL) |
||
1824 | { |
||
1825 | strcat (buf, info->type_stack->methods); |
||
1826 | free (info->type_stack->methods); |
||
1827 | info->type_stack->methods = NULL; |
||
1828 | } |
||
1829 | |||
1830 | strcat (buf, ";"); |
||
1831 | |||
1832 | if (info->type_stack->vtable != NULL) |
||
1833 | { |
||
1834 | strcat (buf, info->type_stack->vtable); |
||
1835 | free (info->type_stack->vtable); |
||
1836 | info->type_stack->vtable = NULL; |
||
1837 | } |
||
1838 | |||
1839 | /* Replace the string on the top of the stack with the complete |
||
1840 | class definition. */ |
||
1841 | free (info->type_stack->string); |
||
1842 | info->type_stack->string = buf; |
||
1843 | |||
1844 | return TRUE; |
||
1845 | } |
||
1846 | |||
1847 | /* Push a typedef which was previously defined. */ |
||
1848 | |||
1849 | static bfd_boolean |
||
1850 | stab_typedef_type (void *p, const char *name) |
||
1851 | { |
||
1852 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1853 | struct string_hash_entry *h; |
||
1854 | |||
1855 | h = string_hash_lookup (&info->typedef_hash, name, FALSE, FALSE); |
||
1856 | assert (h != NULL && h->index > 0); |
||
1857 | |||
1858 | return stab_push_defined_type (info, h->index, h->size); |
||
1859 | } |
||
1860 | |||
1861 | /* Push a struct, union or class tag. */ |
||
1862 | |||
1863 | static bfd_boolean |
||
1864 | stab_tag_type (void *p, const char *name, unsigned int id, |
||
1865 | enum debug_type_kind kind) |
||
1866 | { |
||
1867 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1868 | long tindex; |
||
1869 | unsigned int size = 0; |
||
1870 | |||
1871 | tindex = stab_get_struct_index (info, name, id, kind, &size); |
||
1872 | if (tindex < 0) |
||
1873 | return FALSE; |
||
1874 | |||
1875 | return stab_push_defined_type (info, tindex, size); |
||
1876 | } |
||
1877 | |||
1878 | /* Define a typedef. */ |
||
1879 | |||
1880 | static bfd_boolean |
||
1881 | stab_typdef (void *p, const char *name) |
||
1882 | { |
||
1883 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1884 | long tindex; |
||
1885 | unsigned int size; |
||
1886 | char *s, *buf; |
||
1887 | struct string_hash_entry *h; |
||
1888 | |||
1889 | tindex = info->type_stack->index; |
||
1890 | size = info->type_stack->size; |
||
1891 | s = stab_pop_type (info); |
||
1892 | |||
1893 | buf = (char *) xmalloc (strlen (name) + strlen (s) + 20); |
||
1894 | |||
1895 | if (tindex > 0) |
||
1896 | sprintf (buf, "%s:t%s", name, s); |
||
1897 | else |
||
1898 | { |
||
1899 | tindex = info->type_index; |
||
1900 | ++info->type_index; |
||
1901 | sprintf (buf, "%s:t%ld=%s", name, tindex, s); |
||
1902 | } |
||
1903 | |||
1904 | free (s); |
||
1905 | |||
1906 | if (! stab_write_symbol (info, N_LSYM, 0, 0, buf)) |
||
1907 | return FALSE; |
||
1908 | |||
1909 | free (buf); |
||
1910 | |||
1911 | h = string_hash_lookup (&info->typedef_hash, name, TRUE, FALSE); |
||
1912 | if (h == NULL) |
||
1913 | { |
||
1914 | non_fatal (_("string_hash_lookup failed: %s"), |
||
1915 | bfd_errmsg (bfd_get_error ())); |
||
1916 | return FALSE; |
||
1917 | } |
||
1918 | |||
1919 | /* I don't think we care about redefinitions. */ |
||
1920 | |||
1921 | h->index = tindex; |
||
1922 | h->size = size; |
||
1923 | |||
1924 | return TRUE; |
||
1925 | } |
||
1926 | |||
1927 | /* Define a tag. */ |
||
1928 | |||
1929 | static bfd_boolean |
||
1930 | stab_tag (void *p, const char *tag) |
||
1931 | { |
||
1932 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1933 | char *s, *buf; |
||
1934 | |||
1935 | s = stab_pop_type (info); |
||
1936 | |||
1937 | buf = (char *) xmalloc (strlen (tag) + strlen (s) + 3); |
||
1938 | |||
1939 | sprintf (buf, "%s:T%s", tag, s); |
||
1940 | free (s); |
||
1941 | |||
1942 | if (! stab_write_symbol (info, N_LSYM, 0, 0, buf)) |
||
1943 | return FALSE; |
||
1944 | |||
1945 | free (buf); |
||
1946 | |||
1947 | return TRUE; |
||
1948 | } |
||
1949 | |||
1950 | /* Define an integer constant. */ |
||
1951 | |||
1952 | static bfd_boolean |
||
1953 | stab_int_constant (void *p, const char *name, bfd_vma val) |
||
1954 | { |
||
1955 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1956 | char *buf; |
||
1957 | |||
1958 | buf = (char *) xmalloc (strlen (name) + 20); |
||
1959 | sprintf (buf, "%s:c=i%ld", name, (long) val); |
||
1960 | |||
1961 | if (! stab_write_symbol (info, N_LSYM, 0, 0, buf)) |
||
1962 | return FALSE; |
||
1963 | |||
1964 | free (buf); |
||
1965 | |||
1966 | return TRUE; |
||
1967 | } |
||
1968 | |||
1969 | /* Define a floating point constant. */ |
||
1970 | |||
1971 | static bfd_boolean |
||
1972 | stab_float_constant (void *p, const char *name, double val) |
||
1973 | { |
||
1974 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1975 | char *buf; |
||
1976 | |||
1977 | buf = (char *) xmalloc (strlen (name) + 20); |
||
1978 | sprintf (buf, "%s:c=f%g", name, val); |
||
1979 | |||
1980 | if (! stab_write_symbol (info, N_LSYM, 0, 0, buf)) |
||
1981 | return FALSE; |
||
1982 | |||
1983 | free (buf); |
||
1984 | |||
1985 | return TRUE; |
||
1986 | } |
||
1987 | |||
1988 | /* Define a typed constant. */ |
||
1989 | |||
1990 | static bfd_boolean |
||
1991 | stab_typed_constant (void *p, const char *name, bfd_vma val) |
||
1992 | { |
||
1993 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
1994 | char *s, *buf; |
||
1995 | |||
1996 | s = stab_pop_type (info); |
||
1997 | |||
1998 | buf = (char *) xmalloc (strlen (name) + strlen (s) + 20); |
||
1999 | sprintf (buf, "%s:c=e%s,%ld", name, s, (long) val); |
||
2000 | free (s); |
||
2001 | |||
2002 | if (! stab_write_symbol (info, N_LSYM, 0, 0, buf)) |
||
2003 | return FALSE; |
||
2004 | |||
2005 | free (buf); |
||
2006 | |||
2007 | return TRUE; |
||
2008 | } |
||
2009 | |||
2010 | /* Record a variable. */ |
||
2011 | |||
2012 | static bfd_boolean |
||
2013 | stab_variable (void *p, const char *name, enum debug_var_kind kind, |
||
2014 | bfd_vma val) |
||
2015 | { |
||
2016 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
2017 | char *s, *buf; |
||
2018 | int stab_type; |
||
2019 | const char *kindstr; |
||
2020 | |||
2021 | s = stab_pop_type (info); |
||
2022 | |||
2023 | switch (kind) |
||
2024 | { |
||
2025 | default: |
||
2026 | abort (); |
||
2027 | |||
2028 | case DEBUG_GLOBAL: |
||
2029 | stab_type = N_GSYM; |
||
2030 | kindstr = "G"; |
||
2031 | break; |
||
2032 | |||
2033 | case DEBUG_STATIC: |
||
2034 | stab_type = N_STSYM; |
||
2035 | kindstr = "S"; |
||
2036 | break; |
||
2037 | |||
2038 | case DEBUG_LOCAL_STATIC: |
||
2039 | stab_type = N_STSYM; |
||
2040 | kindstr = "V"; |
||
2041 | break; |
||
2042 | |||
2043 | case DEBUG_LOCAL: |
||
2044 | stab_type = N_LSYM; |
||
2045 | kindstr = ""; |
||
2046 | |||
2047 | /* Make sure that this is a type reference or definition. */ |
||
2048 | if (! ISDIGIT (*s)) |
||
2049 | { |
||
2050 | char *n; |
||
2051 | long tindex; |
||
2052 | |||
2053 | tindex = info->type_index; |
||
2054 | ++info->type_index; |
||
2055 | n = (char *) xmalloc (strlen (s) + 20); |
||
2056 | sprintf (n, "%ld=%s", tindex, s); |
||
2057 | free (s); |
||
2058 | s = n; |
||
2059 | } |
||
2060 | break; |
||
2061 | |||
2062 | case DEBUG_REGISTER: |
||
2063 | stab_type = N_RSYM; |
||
2064 | kindstr = "r"; |
||
2065 | break; |
||
2066 | } |
||
2067 | |||
2068 | buf = (char *) xmalloc (strlen (name) + strlen (s) + 3); |
||
2069 | sprintf (buf, "%s:%s%s", name, kindstr, s); |
||
2070 | free (s); |
||
2071 | |||
2072 | if (! stab_write_symbol (info, stab_type, 0, val, buf)) |
||
2073 | return FALSE; |
||
2074 | |||
2075 | free (buf); |
||
2076 | |||
2077 | return TRUE; |
||
2078 | } |
||
2079 | |||
2080 | /* Start outputting a function. */ |
||
2081 | |||
2082 | static bfd_boolean |
||
2083 | stab_start_function (void *p, const char *name, bfd_boolean globalp) |
||
2084 | { |
||
2085 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
2086 | char *rettype, *buf; |
||
2087 | |||
2088 | assert (info->nesting == 0 && info->fun_offset == -1); |
||
2089 | |||
2090 | rettype = stab_pop_type (info); |
||
2091 | |||
2092 | buf = (char *) xmalloc (strlen (name) + strlen (rettype) + 3); |
||
2093 | sprintf (buf, "%s:%c%s", name, |
||
2094 | globalp ? 'F' : 'f', |
||
2095 | rettype); |
||
2096 | |||
2097 | /* We don't know the value now, so we set it in start_block. */ |
||
2098 | info->fun_offset = info->symbols_size; |
||
2099 | |||
2100 | if (! stab_write_symbol (info, N_FUN, 0, 0, buf)) |
||
2101 | return FALSE; |
||
2102 | |||
2103 | free (buf); |
||
2104 | |||
2105 | return TRUE; |
||
2106 | } |
||
2107 | |||
2108 | /* Output a function parameter. */ |
||
2109 | |||
2110 | static bfd_boolean |
||
2111 | stab_function_parameter (void *p, const char *name, enum debug_parm_kind kind, bfd_vma val) |
||
2112 | { |
||
2113 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
2114 | char *s, *buf; |
||
2115 | int stab_type; |
||
2116 | char kindc; |
||
2117 | |||
2118 | s = stab_pop_type (info); |
||
2119 | |||
2120 | switch (kind) |
||
2121 | { |
||
2122 | default: |
||
2123 | abort (); |
||
2124 | |||
2125 | case DEBUG_PARM_STACK: |
||
2126 | stab_type = N_PSYM; |
||
2127 | kindc = 'p'; |
||
2128 | break; |
||
2129 | |||
2130 | case DEBUG_PARM_REG: |
||
2131 | stab_type = N_RSYM; |
||
2132 | kindc = 'P'; |
||
2133 | break; |
||
2134 | |||
2135 | case DEBUG_PARM_REFERENCE: |
||
2136 | stab_type = N_PSYM; |
||
2137 | kindc = 'v'; |
||
2138 | break; |
||
2139 | |||
2140 | case DEBUG_PARM_REF_REG: |
||
2141 | stab_type = N_RSYM; |
||
2142 | kindc = 'a'; |
||
2143 | break; |
||
2144 | } |
||
2145 | |||
2146 | buf = (char *) xmalloc (strlen (name) + strlen (s) + 3); |
||
2147 | sprintf (buf, "%s:%c%s", name, kindc, s); |
||
2148 | free (s); |
||
2149 | |||
2150 | if (! stab_write_symbol (info, stab_type, 0, val, buf)) |
||
2151 | return FALSE; |
||
2152 | |||
2153 | free (buf); |
||
2154 | |||
2155 | return TRUE; |
||
2156 | } |
||
2157 | |||
2158 | /* Start a block. */ |
||
2159 | |||
2160 | static bfd_boolean |
||
2161 | stab_start_block (void *p, bfd_vma addr) |
||
2162 | { |
||
2163 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
2164 | |||
2165 | /* Fill in any slots which have been waiting for the first known |
||
2166 | text address. */ |
||
2167 | |||
2168 | if (info->so_offset != -1) |
||
2169 | { |
||
2170 | bfd_put_32 (info->abfd, addr, info->symbols + info->so_offset + 8); |
||
2171 | info->so_offset = -1; |
||
2172 | } |
||
2173 | |||
2174 | if (info->fun_offset != -1) |
||
2175 | { |
||
2176 | bfd_put_32 (info->abfd, addr, info->symbols + info->fun_offset + 8); |
||
2177 | info->fun_offset = -1; |
||
2178 | } |
||
2179 | |||
2180 | ++info->nesting; |
||
2181 | |||
2182 | /* We will be called with a top level block surrounding the |
||
2183 | function, but stabs information does not output that block, so we |
||
2184 | ignore it. */ |
||
2185 | |||
2186 | if (info->nesting == 1) |
||
2187 | { |
||
2188 | info->fnaddr = addr; |
||
2189 | return TRUE; |
||
2190 | } |
||
2191 | |||
2192 | /* We have to output the LBRAC symbol after any variables which are |
||
2193 | declared inside the block. We postpone the LBRAC until the next |
||
2194 | start_block or end_block. */ |
||
2195 | |||
2196 | /* If we have postponed an LBRAC, output it now. */ |
||
2197 | if (info->pending_lbrac != (bfd_vma) -1) |
||
2198 | { |
||
2199 | if (! stab_write_symbol (info, N_LBRAC, 0, info->pending_lbrac, |
||
2200 | (const char *) NULL)) |
||
2201 | return FALSE; |
||
2202 | } |
||
2203 | |||
2204 | /* Remember the address and output it later. */ |
||
2205 | |||
2206 | info->pending_lbrac = addr - info->fnaddr; |
||
2207 | |||
2208 | return TRUE; |
||
2209 | } |
||
2210 | |||
2211 | /* End a block. */ |
||
2212 | |||
2213 | static bfd_boolean |
||
2214 | stab_end_block (void *p, bfd_vma addr) |
||
2215 | { |
||
2216 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
2217 | |||
2218 | if (addr > info->last_text_address) |
||
2219 | info->last_text_address = addr; |
||
2220 | |||
2221 | /* If we have postponed an LBRAC, output it now. */ |
||
2222 | if (info->pending_lbrac != (bfd_vma) -1) |
||
2223 | { |
||
2224 | if (! stab_write_symbol (info, N_LBRAC, 0, info->pending_lbrac, |
||
2225 | (const char *) NULL)) |
||
2226 | return FALSE; |
||
2227 | info->pending_lbrac = (bfd_vma) -1; |
||
2228 | } |
||
2229 | |||
2230 | assert (info->nesting > 0); |
||
2231 | |||
2232 | --info->nesting; |
||
2233 | |||
2234 | /* We ignore the outermost block. */ |
||
2235 | if (info->nesting == 0) |
||
2236 | return TRUE; |
||
2237 | |||
2238 | return stab_write_symbol (info, N_RBRAC, 0, addr - info->fnaddr, |
||
2239 | (const char *) NULL); |
||
2240 | } |
||
2241 | |||
2242 | /* End a function. */ |
||
2243 | |||
2244 | static bfd_boolean |
||
2245 | stab_end_function (void *p ATTRIBUTE_UNUSED) |
||
2246 | { |
||
2247 | return TRUE; |
||
2248 | } |
||
2249 | |||
2250 | /* Output a line number. */ |
||
2251 | |||
2252 | static bfd_boolean |
||
2253 | stab_lineno (void *p, const char *file, unsigned long lineno, bfd_vma addr) |
||
2254 | { |
||
2255 | struct stab_write_handle *info = (struct stab_write_handle *) p; |
||
2256 | |||
2257 | assert (info->lineno_filename != NULL); |
||
2258 | |||
2259 | if (addr > info->last_text_address) |
||
2260 | info->last_text_address = addr; |
||
2261 | |||
2262 | if (filename_cmp (file, info->lineno_filename) != 0) |
||
2263 | { |
||
2264 | if (! stab_write_symbol (info, N_SOL, 0, addr, file)) |
||
2265 | return FALSE; |
||
2266 | info->lineno_filename = file; |
||
2267 | } |
||
2268 | |||
2269 | return stab_write_symbol (info, N_SLINE, lineno, addr - info->fnaddr, |
||
2270 | (const char *) NULL); |
||
2271 | }>>>>>>>=>>>><>><>=>><>>=> |