Commit | Line | Data |
---|---|---|
252b5132 | 1 | /* ieee.c -- Read and write IEEE-695 debugging information. |
220df88b NC |
2 | Copyright 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2006, 2007, |
3 | 2008, 2009 Free Software Foundation, Inc. | |
252b5132 RH |
4 | Written by Ian Lance Taylor <ian@cygnus.com>. |
5 | ||
6 | This file is part of GNU Binutils. | |
7 | ||
8 | This program is free software; you can redistribute it and/or modify | |
9 | it under the terms of the GNU General Public License as published by | |
32866df7 | 10 | the Free Software Foundation; either version 3 of the License, or |
252b5132 RH |
11 | (at your option) any later version. |
12 | ||
13 | This program is distributed in the hope that it will be useful, | |
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | GNU General Public License for more details. | |
17 | ||
18 | You should have received a copy of the GNU General Public License | |
19 | along with this program; if not, write to the Free Software | |
b43b5d5f NC |
20 | Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA |
21 | 02110-1301, USA. */ | |
252b5132 RH |
22 | |
23 | /* This file reads and writes IEEE-695 debugging information. */ | |
24 | ||
3db64b00 | 25 | #include "sysdep.h" |
252b5132 | 26 | #include <assert.h> |
252b5132 RH |
27 | #include "bfd.h" |
28 | #include "ieee.h" | |
252b5132 RH |
29 | #include "libiberty.h" |
30 | #include "debug.h" | |
31 | #include "budbg.h" | |
5af11cab | 32 | #include "filenames.h" |
252b5132 RH |
33 | |
34 | /* This structure holds an entry on the block stack. */ | |
35 | ||
36 | struct ieee_block | |
37 | { | |
38 | /* The kind of block. */ | |
39 | int kind; | |
40 | /* The source file name, for a BB5 block. */ | |
41 | const char *filename; | |
42 | /* The index of the function type, for a BB4 or BB6 block. */ | |
43 | unsigned int fnindx; | |
b34976b6 AM |
44 | /* TRUE if this function is being skipped. */ |
45 | bfd_boolean skip; | |
252b5132 RH |
46 | }; |
47 | ||
48 | /* This structure is the block stack. */ | |
49 | ||
50 | #define BLOCKSTACK_SIZE (16) | |
51 | ||
52 | struct ieee_blockstack | |
53 | { | |
54 | /* The stack pointer. */ | |
55 | struct ieee_block *bsp; | |
56 | /* The stack. */ | |
57 | struct ieee_block stack[BLOCKSTACK_SIZE]; | |
58 | }; | |
59 | ||
60 | /* This structure holds information for a variable. */ | |
61 | ||
62 | struct ieee_var | |
63 | { | |
64 | /* Start of name. */ | |
65 | const char *name; | |
66 | /* Length of name. */ | |
67 | unsigned long namlen; | |
68 | /* Type. */ | |
69 | debug_type type; | |
70 | /* Slot if we make an indirect type. */ | |
71 | debug_type *pslot; | |
72 | /* Kind of variable or function. */ | |
73 | enum | |
74 | { | |
75 | IEEE_UNKNOWN, | |
76 | IEEE_EXTERNAL, | |
77 | IEEE_GLOBAL, | |
78 | IEEE_STATIC, | |
79 | IEEE_LOCAL, | |
80 | IEEE_FUNCTION | |
81 | } kind; | |
82 | }; | |
83 | ||
84 | /* This structure holds all the variables. */ | |
85 | ||
86 | struct ieee_vars | |
87 | { | |
88 | /* Number of slots allocated. */ | |
89 | unsigned int alloc; | |
90 | /* Variables. */ | |
91 | struct ieee_var *vars; | |
92 | }; | |
93 | ||
94 | /* This structure holds information for a type. We need this because | |
95 | we don't want to represent bitfields as real types. */ | |
96 | ||
97 | struct ieee_type | |
98 | { | |
99 | /* Type. */ | |
100 | debug_type type; | |
101 | /* Slot if this is type is referenced before it is defined. */ | |
102 | debug_type *pslot; | |
103 | /* Slots for arguments if we make indirect types for them. */ | |
104 | debug_type *arg_slots; | |
105 | /* If this is a bitfield, this is the size in bits. If this is not | |
106 | a bitfield, this is zero. */ | |
107 | unsigned long bitsize; | |
108 | }; | |
109 | ||
110 | /* This structure holds all the type information. */ | |
111 | ||
112 | struct ieee_types | |
113 | { | |
114 | /* Number of slots allocated. */ | |
115 | unsigned int alloc; | |
116 | /* Types. */ | |
117 | struct ieee_type *types; | |
118 | /* Builtin types. */ | |
119 | #define BUILTIN_TYPE_COUNT (60) | |
120 | debug_type builtins[BUILTIN_TYPE_COUNT]; | |
121 | }; | |
122 | ||
123 | /* This structure holds a linked last of structs with their tag names, | |
124 | so that we can convert them to C++ classes if necessary. */ | |
125 | ||
126 | struct ieee_tag | |
127 | { | |
128 | /* Next tag. */ | |
129 | struct ieee_tag *next; | |
130 | /* This tag name. */ | |
131 | const char *name; | |
132 | /* The type of the tag. */ | |
133 | debug_type type; | |
134 | /* The tagged type is an indirect type pointing at this slot. */ | |
135 | debug_type slot; | |
136 | /* This is an array of slots used when a field type is converted | |
137 | into a indirect type, in case it needs to be later converted into | |
138 | a reference type. */ | |
139 | debug_type *fslots; | |
140 | }; | |
141 | ||
142 | /* This structure holds the information we pass around to the parsing | |
143 | functions. */ | |
144 | ||
145 | struct ieee_info | |
146 | { | |
147 | /* The debugging handle. */ | |
2da42df6 | 148 | void *dhandle; |
252b5132 RH |
149 | /* The BFD. */ |
150 | bfd *abfd; | |
151 | /* The start of the bytes to be parsed. */ | |
152 | const bfd_byte *bytes; | |
153 | /* The end of the bytes to be parsed. */ | |
154 | const bfd_byte *pend; | |
155 | /* The block stack. */ | |
156 | struct ieee_blockstack blockstack; | |
157 | /* Whether we have seen a BB1 or BB2. */ | |
b34976b6 | 158 | bfd_boolean saw_filename; |
252b5132 RH |
159 | /* The variables. */ |
160 | struct ieee_vars vars; | |
161 | /* The global variables, after a global typedef block. */ | |
162 | struct ieee_vars *global_vars; | |
163 | /* The types. */ | |
164 | struct ieee_types types; | |
165 | /* The global types, after a global typedef block. */ | |
166 | struct ieee_types *global_types; | |
167 | /* The list of tagged structs. */ | |
168 | struct ieee_tag *tags; | |
169 | }; | |
170 | ||
171 | /* Basic builtin types, not including the pointers. */ | |
172 | ||
173 | enum builtin_types | |
174 | { | |
175 | builtin_unknown = 0, | |
176 | builtin_void = 1, | |
177 | builtin_signed_char = 2, | |
178 | builtin_unsigned_char = 3, | |
179 | builtin_signed_short_int = 4, | |
180 | builtin_unsigned_short_int = 5, | |
181 | builtin_signed_long = 6, | |
182 | builtin_unsigned_long = 7, | |
183 | builtin_signed_long_long = 8, | |
184 | builtin_unsigned_long_long = 9, | |
185 | builtin_float = 10, | |
186 | builtin_double = 11, | |
187 | builtin_long_double = 12, | |
188 | builtin_long_long_double = 13, | |
189 | builtin_quoted_string = 14, | |
190 | builtin_instruction_address = 15, | |
191 | builtin_int = 16, | |
192 | builtin_unsigned = 17, | |
193 | builtin_unsigned_int = 18, | |
194 | builtin_char = 19, | |
195 | builtin_long = 20, | |
196 | builtin_short = 21, | |
197 | builtin_unsigned_short = 22, | |
198 | builtin_short_int = 23, | |
199 | builtin_signed_short = 24, | |
200 | builtin_bcd_float = 25 | |
201 | }; | |
202 | ||
203 | /* These are the values found in the derivation flags of a 'b' | |
204 | component record of a 'T' type extension record in a C++ pmisc | |
205 | record. These are bitmasks. */ | |
206 | ||
207 | /* Set for a private base class, clear for a public base class. | |
208 | Protected base classes are not supported. */ | |
209 | #define BASEFLAGS_PRIVATE (0x1) | |
210 | /* Set for a virtual base class. */ | |
211 | #define BASEFLAGS_VIRTUAL (0x2) | |
212 | /* Set for a friend class, clear for a base class. */ | |
213 | #define BASEFLAGS_FRIEND (0x10) | |
214 | ||
215 | /* These are the values found in the specs flags of a 'd', 'm', or 'v' | |
216 | component record of a 'T' type extension record in a C++ pmisc | |
217 | record. The same flags are used for a 'M' record in a C++ pmisc | |
218 | record. */ | |
219 | ||
220 | /* The lower two bits hold visibility information. */ | |
221 | #define CXXFLAGS_VISIBILITY (0x3) | |
222 | /* This value in the lower two bits indicates a public member. */ | |
223 | #define CXXFLAGS_VISIBILITY_PUBLIC (0x0) | |
224 | /* This value in the lower two bits indicates a private member. */ | |
225 | #define CXXFLAGS_VISIBILITY_PRIVATE (0x1) | |
226 | /* This value in the lower two bits indicates a protected member. */ | |
227 | #define CXXFLAGS_VISIBILITY_PROTECTED (0x2) | |
228 | /* Set for a static member. */ | |
229 | #define CXXFLAGS_STATIC (0x4) | |
230 | /* Set for a virtual override. */ | |
231 | #define CXXFLAGS_OVERRIDE (0x8) | |
232 | /* Set for a friend function. */ | |
233 | #define CXXFLAGS_FRIEND (0x10) | |
234 | /* Set for a const function. */ | |
235 | #define CXXFLAGS_CONST (0x20) | |
236 | /* Set for a volatile function. */ | |
237 | #define CXXFLAGS_VOLATILE (0x40) | |
238 | /* Set for an overloaded function. */ | |
239 | #define CXXFLAGS_OVERLOADED (0x80) | |
240 | /* Set for an operator function. */ | |
241 | #define CXXFLAGS_OPERATOR (0x100) | |
242 | /* Set for a constructor or destructor. */ | |
243 | #define CXXFLAGS_CTORDTOR (0x400) | |
244 | /* Set for a constructor. */ | |
245 | #define CXXFLAGS_CTOR (0x200) | |
246 | /* Set for an inline function. */ | |
247 | #define CXXFLAGS_INLINE (0x800) | |
248 | ||
249 | /* Local functions. */ | |
250 | ||
2da42df6 AJ |
251 | static void ieee_error (struct ieee_info *, const bfd_byte *, const char *); |
252 | static void ieee_eof (struct ieee_info *); | |
253 | static char *savestring (const char *, unsigned long); | |
b34976b6 | 254 | static bfd_boolean ieee_read_number |
2da42df6 | 255 | (struct ieee_info *, const bfd_byte **, bfd_vma *); |
b34976b6 | 256 | static bfd_boolean ieee_read_optional_number |
2da42df6 | 257 | (struct ieee_info *, const bfd_byte **, bfd_vma *, bfd_boolean *); |
b34976b6 | 258 | static bfd_boolean ieee_read_id |
2da42df6 | 259 | (struct ieee_info *, const bfd_byte **, const char **, unsigned long *); |
b34976b6 | 260 | static bfd_boolean ieee_read_optional_id |
2da42df6 AJ |
261 | (struct ieee_info *, const bfd_byte **, const char **, unsigned long *, |
262 | bfd_boolean *); | |
b34976b6 | 263 | static bfd_boolean ieee_read_expression |
2da42df6 | 264 | (struct ieee_info *, const bfd_byte **, bfd_vma *); |
252b5132 | 265 | static debug_type ieee_builtin_type |
2da42df6 | 266 | (struct ieee_info *, const bfd_byte *, unsigned int); |
b34976b6 | 267 | static bfd_boolean ieee_alloc_type |
2da42df6 | 268 | (struct ieee_info *, unsigned int, bfd_boolean); |
b34976b6 | 269 | static bfd_boolean ieee_read_type_index |
2da42df6 AJ |
270 | (struct ieee_info *, const bfd_byte **, debug_type *); |
271 | static int ieee_regno_to_genreg (bfd *, int); | |
272 | static int ieee_genreg_to_regno (bfd *, int); | |
273 | static bfd_boolean parse_ieee_bb (struct ieee_info *, const bfd_byte **); | |
274 | static bfd_boolean parse_ieee_be (struct ieee_info *, const bfd_byte **); | |
275 | static bfd_boolean parse_ieee_nn (struct ieee_info *, const bfd_byte **); | |
276 | static bfd_boolean parse_ieee_ty (struct ieee_info *, const bfd_byte **); | |
277 | static bfd_boolean parse_ieee_atn (struct ieee_info *, const bfd_byte **); | |
b34976b6 | 278 | static bfd_boolean ieee_read_cxx_misc |
2da42df6 | 279 | (struct ieee_info *, const bfd_byte **, unsigned long); |
b34976b6 | 280 | static bfd_boolean ieee_read_cxx_class |
2da42df6 | 281 | (struct ieee_info *, const bfd_byte **, unsigned long); |
b34976b6 | 282 | static bfd_boolean ieee_read_cxx_defaults |
2da42df6 | 283 | (struct ieee_info *, const bfd_byte **, unsigned long); |
b34976b6 | 284 | static bfd_boolean ieee_read_reference |
2da42df6 | 285 | (struct ieee_info *, const bfd_byte **); |
b34976b6 | 286 | static bfd_boolean ieee_require_asn |
2da42df6 | 287 | (struct ieee_info *, const bfd_byte **, bfd_vma *); |
b34976b6 | 288 | static bfd_boolean ieee_require_atn65 |
2da42df6 | 289 | (struct ieee_info *, const bfd_byte **, const char **, unsigned long *); |
252b5132 RH |
290 | |
291 | /* Report an error in the IEEE debugging information. */ | |
292 | ||
293 | static void | |
2da42df6 | 294 | ieee_error (struct ieee_info *info, const bfd_byte *p, const char *s) |
252b5132 RH |
295 | { |
296 | if (p != NULL) | |
297 | fprintf (stderr, "%s: 0x%lx: %s (0x%x)\n", bfd_get_filename (info->abfd), | |
298 | (unsigned long) (p - info->bytes), s, *p); | |
299 | else | |
300 | fprintf (stderr, "%s: %s\n", bfd_get_filename (info->abfd), s); | |
301 | } | |
302 | ||
303 | /* Report an unexpected EOF in the IEEE debugging information. */ | |
304 | ||
305 | static void | |
2da42df6 | 306 | ieee_eof (struct ieee_info *info) |
252b5132 RH |
307 | { |
308 | ieee_error (info, (const bfd_byte *) NULL, | |
309 | _("unexpected end of debugging information")); | |
310 | } | |
311 | ||
312 | /* Save a string in memory. */ | |
313 | ||
314 | static char * | |
2da42df6 | 315 | savestring (const char *start, unsigned long len) |
252b5132 RH |
316 | { |
317 | char *ret; | |
318 | ||
319 | ret = (char *) xmalloc (len + 1); | |
320 | memcpy (ret, start, len); | |
321 | ret[len] = '\0'; | |
322 | return ret; | |
323 | } | |
324 | ||
325 | /* Read a number which must be present in an IEEE file. */ | |
326 | ||
b34976b6 | 327 | static bfd_boolean |
2da42df6 | 328 | ieee_read_number (struct ieee_info *info, const bfd_byte **pp, bfd_vma *pv) |
252b5132 | 329 | { |
b34976b6 | 330 | return ieee_read_optional_number (info, pp, pv, (bfd_boolean *) NULL); |
252b5132 RH |
331 | } |
332 | ||
333 | /* Read a number in an IEEE file. If ppresent is not NULL, the number | |
0af11b59 | 334 | need not be there. */ |
252b5132 | 335 | |
b34976b6 | 336 | static bfd_boolean |
2da42df6 AJ |
337 | ieee_read_optional_number (struct ieee_info *info, const bfd_byte **pp, |
338 | bfd_vma *pv, bfd_boolean *ppresent) | |
252b5132 RH |
339 | { |
340 | ieee_record_enum_type b; | |
341 | ||
342 | if (*pp >= info->pend) | |
343 | { | |
344 | if (ppresent != NULL) | |
345 | { | |
b34976b6 AM |
346 | *ppresent = FALSE; |
347 | return TRUE; | |
252b5132 RH |
348 | } |
349 | ieee_eof (info); | |
b34976b6 | 350 | return FALSE; |
252b5132 RH |
351 | } |
352 | ||
353 | b = (ieee_record_enum_type) **pp; | |
354 | ++*pp; | |
355 | ||
356 | if (b <= ieee_number_end_enum) | |
357 | { | |
358 | *pv = (bfd_vma) b; | |
359 | if (ppresent != NULL) | |
b34976b6 AM |
360 | *ppresent = TRUE; |
361 | return TRUE; | |
252b5132 RH |
362 | } |
363 | ||
364 | if (b >= ieee_number_repeat_start_enum && b <= ieee_number_repeat_end_enum) | |
365 | { | |
366 | unsigned int i; | |
367 | ||
368 | i = (int) b - (int) ieee_number_repeat_start_enum; | |
369 | if (*pp + i - 1 >= info->pend) | |
370 | { | |
371 | ieee_eof (info); | |
b34976b6 | 372 | return FALSE; |
252b5132 RH |
373 | } |
374 | ||
375 | *pv = 0; | |
376 | for (; i > 0; i--) | |
377 | { | |
378 | *pv <<= 8; | |
379 | *pv += **pp; | |
380 | ++*pp; | |
381 | } | |
382 | ||
383 | if (ppresent != NULL) | |
b34976b6 | 384 | *ppresent = TRUE; |
252b5132 | 385 | |
b34976b6 | 386 | return TRUE; |
252b5132 RH |
387 | } |
388 | ||
389 | if (ppresent != NULL) | |
390 | { | |
391 | --*pp; | |
b34976b6 AM |
392 | *ppresent = FALSE; |
393 | return TRUE; | |
252b5132 RH |
394 | } |
395 | ||
396 | ieee_error (info, *pp - 1, _("invalid number")); | |
b34976b6 | 397 | return FALSE; |
252b5132 RH |
398 | } |
399 | ||
400 | /* Read a required string from an IEEE file. */ | |
401 | ||
b34976b6 | 402 | static bfd_boolean |
2da42df6 AJ |
403 | ieee_read_id (struct ieee_info *info, const bfd_byte **pp, |
404 | const char **pname, unsigned long *pnamlen) | |
252b5132 | 405 | { |
b34976b6 | 406 | return ieee_read_optional_id (info, pp, pname, pnamlen, (bfd_boolean *) NULL); |
252b5132 RH |
407 | } |
408 | ||
409 | /* Read a string from an IEEE file. If ppresent is not NULL, the | |
410 | string is optional. */ | |
411 | ||
b34976b6 | 412 | static bfd_boolean |
2da42df6 AJ |
413 | ieee_read_optional_id (struct ieee_info *info, const bfd_byte **pp, |
414 | const char **pname, unsigned long *pnamlen, | |
415 | bfd_boolean *ppresent) | |
252b5132 RH |
416 | { |
417 | bfd_byte b; | |
418 | unsigned long len; | |
419 | ||
420 | if (*pp >= info->pend) | |
421 | { | |
422 | ieee_eof (info); | |
b34976b6 | 423 | return FALSE; |
252b5132 RH |
424 | } |
425 | ||
426 | b = **pp; | |
427 | ++*pp; | |
428 | ||
429 | if (b <= 0x7f) | |
430 | len = b; | |
431 | else if ((ieee_record_enum_type) b == ieee_extension_length_1_enum) | |
432 | { | |
433 | len = **pp; | |
434 | ++*pp; | |
435 | } | |
436 | else if ((ieee_record_enum_type) b == ieee_extension_length_2_enum) | |
437 | { | |
438 | len = (**pp << 8) + (*pp)[1]; | |
439 | *pp += 2; | |
440 | } | |
441 | else | |
442 | { | |
443 | if (ppresent != NULL) | |
444 | { | |
445 | --*pp; | |
b34976b6 AM |
446 | *ppresent = FALSE; |
447 | return TRUE; | |
252b5132 RH |
448 | } |
449 | ieee_error (info, *pp - 1, _("invalid string length")); | |
b34976b6 | 450 | return FALSE; |
252b5132 RH |
451 | } |
452 | ||
453 | if ((unsigned long) (info->pend - *pp) < len) | |
454 | { | |
455 | ieee_eof (info); | |
b34976b6 | 456 | return FALSE; |
252b5132 RH |
457 | } |
458 | ||
459 | *pname = (const char *) *pp; | |
460 | *pnamlen = len; | |
461 | *pp += len; | |
462 | ||
463 | if (ppresent != NULL) | |
b34976b6 | 464 | *ppresent = TRUE; |
252b5132 | 465 | |
b34976b6 | 466 | return TRUE; |
252b5132 RH |
467 | } |
468 | ||
469 | /* Read an expression from an IEEE file. Since this code is only used | |
470 | to parse debugging information, I haven't bothered to write a full | |
471 | blown IEEE expression parser. I've only thrown in the things I've | |
472 | seen in debugging information. This can be easily extended if | |
473 | necessary. */ | |
474 | ||
b34976b6 | 475 | static bfd_boolean |
2da42df6 AJ |
476 | ieee_read_expression (struct ieee_info *info, const bfd_byte **pp, |
477 | bfd_vma *pv) | |
252b5132 RH |
478 | { |
479 | const bfd_byte *expr_start; | |
480 | #define EXPR_STACK_SIZE (10) | |
481 | bfd_vma expr_stack[EXPR_STACK_SIZE]; | |
482 | bfd_vma *esp; | |
483 | ||
484 | expr_start = *pp; | |
485 | ||
486 | esp = expr_stack; | |
487 | ||
488 | while (1) | |
489 | { | |
490 | const bfd_byte *start; | |
491 | bfd_vma val; | |
b34976b6 | 492 | bfd_boolean present; |
252b5132 RH |
493 | ieee_record_enum_type c; |
494 | ||
495 | start = *pp; | |
496 | ||
497 | if (! ieee_read_optional_number (info, pp, &val, &present)) | |
b34976b6 | 498 | return FALSE; |
252b5132 RH |
499 | |
500 | if (present) | |
501 | { | |
502 | if (esp - expr_stack >= EXPR_STACK_SIZE) | |
503 | { | |
504 | ieee_error (info, start, _("expression stack overflow")); | |
b34976b6 | 505 | return FALSE; |
252b5132 RH |
506 | } |
507 | *esp++ = val; | |
508 | continue; | |
509 | } | |
510 | ||
511 | c = (ieee_record_enum_type) **pp; | |
512 | ||
513 | if (c >= ieee_module_beginning_enum) | |
514 | break; | |
515 | ||
516 | ++*pp; | |
517 | ||
518 | if (c == ieee_comma) | |
519 | break; | |
520 | ||
521 | switch (c) | |
522 | { | |
523 | default: | |
524 | ieee_error (info, start, _("unsupported IEEE expression operator")); | |
525 | break; | |
526 | ||
527 | case ieee_variable_R_enum: | |
528 | { | |
529 | bfd_vma indx; | |
530 | asection *s; | |
531 | ||
532 | if (! ieee_read_number (info, pp, &indx)) | |
b34976b6 | 533 | return FALSE; |
252b5132 RH |
534 | for (s = info->abfd->sections; s != NULL; s = s->next) |
535 | if ((bfd_vma) s->target_index == indx) | |
536 | break; | |
537 | if (s == NULL) | |
538 | { | |
539 | ieee_error (info, start, _("unknown section")); | |
b34976b6 | 540 | return FALSE; |
252b5132 | 541 | } |
c7f2731e | 542 | |
252b5132 RH |
543 | if (esp - expr_stack >= EXPR_STACK_SIZE) |
544 | { | |
545 | ieee_error (info, start, _("expression stack overflow")); | |
b34976b6 | 546 | return FALSE; |
252b5132 RH |
547 | } |
548 | ||
549 | *esp++ = bfd_get_section_vma (info->abfd, s); | |
550 | } | |
551 | break; | |
552 | ||
553 | case ieee_function_plus_enum: | |
554 | case ieee_function_minus_enum: | |
555 | { | |
556 | bfd_vma v1, v2; | |
557 | ||
558 | if (esp - expr_stack < 2) | |
559 | { | |
560 | ieee_error (info, start, _("expression stack underflow")); | |
b34976b6 | 561 | return FALSE; |
252b5132 RH |
562 | } |
563 | ||
564 | v1 = *--esp; | |
565 | v2 = *--esp; | |
566 | *esp++ = v1 + v2; | |
567 | } | |
568 | break; | |
569 | } | |
570 | } | |
571 | ||
572 | if (esp - 1 != expr_stack) | |
573 | { | |
574 | ieee_error (info, expr_start, _("expression stack mismatch")); | |
b34976b6 | 575 | return FALSE; |
252b5132 RH |
576 | } |
577 | ||
578 | *pv = *--esp; | |
579 | ||
b34976b6 | 580 | return TRUE; |
252b5132 RH |
581 | } |
582 | ||
583 | /* Return an IEEE builtin type. */ | |
584 | ||
585 | static debug_type | |
2da42df6 AJ |
586 | ieee_builtin_type (struct ieee_info *info, const bfd_byte *p, |
587 | unsigned int indx) | |
252b5132 | 588 | { |
2da42df6 | 589 | void *dhandle; |
252b5132 RH |
590 | debug_type type; |
591 | const char *name; | |
592 | ||
593 | if (indx < BUILTIN_TYPE_COUNT | |
594 | && info->types.builtins[indx] != DEBUG_TYPE_NULL) | |
595 | return info->types.builtins[indx]; | |
596 | ||
597 | dhandle = info->dhandle; | |
598 | ||
599 | if (indx >= 32 && indx < 64) | |
600 | { | |
601 | type = debug_make_pointer_type (dhandle, | |
602 | ieee_builtin_type (info, p, indx - 32)); | |
603 | assert (indx < BUILTIN_TYPE_COUNT); | |
604 | info->types.builtins[indx] = type; | |
605 | return type; | |
606 | } | |
607 | ||
608 | switch ((enum builtin_types) indx) | |
609 | { | |
610 | default: | |
611 | ieee_error (info, p, _("unknown builtin type")); | |
612 | return NULL; | |
613 | ||
614 | case builtin_unknown: | |
615 | type = debug_make_void_type (dhandle); | |
616 | name = NULL; | |
617 | break; | |
618 | ||
619 | case builtin_void: | |
620 | type = debug_make_void_type (dhandle); | |
621 | name = "void"; | |
622 | break; | |
623 | ||
624 | case builtin_signed_char: | |
b34976b6 | 625 | type = debug_make_int_type (dhandle, 1, FALSE); |
252b5132 RH |
626 | name = "signed char"; |
627 | break; | |
628 | ||
629 | case builtin_unsigned_char: | |
b34976b6 | 630 | type = debug_make_int_type (dhandle, 1, TRUE); |
252b5132 RH |
631 | name = "unsigned char"; |
632 | break; | |
633 | ||
634 | case builtin_signed_short_int: | |
b34976b6 | 635 | type = debug_make_int_type (dhandle, 2, FALSE); |
252b5132 RH |
636 | name = "signed short int"; |
637 | break; | |
638 | ||
639 | case builtin_unsigned_short_int: | |
b34976b6 | 640 | type = debug_make_int_type (dhandle, 2, TRUE); |
252b5132 RH |
641 | name = "unsigned short int"; |
642 | break; | |
643 | ||
644 | case builtin_signed_long: | |
b34976b6 | 645 | type = debug_make_int_type (dhandle, 4, FALSE); |
252b5132 RH |
646 | name = "signed long"; |
647 | break; | |
648 | ||
649 | case builtin_unsigned_long: | |
b34976b6 | 650 | type = debug_make_int_type (dhandle, 4, TRUE); |
252b5132 RH |
651 | name = "unsigned long"; |
652 | break; | |
653 | ||
654 | case builtin_signed_long_long: | |
b34976b6 | 655 | type = debug_make_int_type (dhandle, 8, FALSE); |
252b5132 RH |
656 | name = "signed long long"; |
657 | break; | |
658 | ||
659 | case builtin_unsigned_long_long: | |
b34976b6 | 660 | type = debug_make_int_type (dhandle, 8, TRUE); |
252b5132 RH |
661 | name = "unsigned long long"; |
662 | break; | |
663 | ||
664 | case builtin_float: | |
665 | type = debug_make_float_type (dhandle, 4); | |
666 | name = "float"; | |
667 | break; | |
668 | ||
669 | case builtin_double: | |
670 | type = debug_make_float_type (dhandle, 8); | |
671 | name = "double"; | |
672 | break; | |
673 | ||
674 | case builtin_long_double: | |
675 | /* FIXME: The size for this type should depend upon the | |
676 | processor. */ | |
677 | type = debug_make_float_type (dhandle, 12); | |
678 | name = "long double"; | |
679 | break; | |
680 | ||
681 | case builtin_long_long_double: | |
682 | type = debug_make_float_type (dhandle, 16); | |
683 | name = "long long double"; | |
684 | break; | |
685 | ||
686 | case builtin_quoted_string: | |
687 | type = debug_make_array_type (dhandle, | |
688 | ieee_builtin_type (info, p, | |
689 | ((unsigned int) | |
690 | builtin_char)), | |
691 | ieee_builtin_type (info, p, | |
692 | ((unsigned int) | |
693 | builtin_int)), | |
b34976b6 | 694 | 0, -1, TRUE); |
252b5132 RH |
695 | name = "QUOTED STRING"; |
696 | break; | |
697 | ||
698 | case builtin_instruction_address: | |
699 | /* FIXME: This should be a code address. */ | |
b34976b6 | 700 | type = debug_make_int_type (dhandle, 4, TRUE); |
252b5132 RH |
701 | name = "instruction address"; |
702 | break; | |
703 | ||
704 | case builtin_int: | |
705 | /* FIXME: The size for this type should depend upon the | |
706 | processor. */ | |
b34976b6 | 707 | type = debug_make_int_type (dhandle, 4, FALSE); |
252b5132 RH |
708 | name = "int"; |
709 | break; | |
710 | ||
711 | case builtin_unsigned: | |
712 | /* FIXME: The size for this type should depend upon the | |
713 | processor. */ | |
b34976b6 | 714 | type = debug_make_int_type (dhandle, 4, TRUE); |
252b5132 RH |
715 | name = "unsigned"; |
716 | break; | |
717 | ||
718 | case builtin_unsigned_int: | |
719 | /* FIXME: The size for this type should depend upon the | |
720 | processor. */ | |
b34976b6 | 721 | type = debug_make_int_type (dhandle, 4, TRUE); |
252b5132 RH |
722 | name = "unsigned int"; |
723 | break; | |
724 | ||
725 | case builtin_char: | |
b34976b6 | 726 | type = debug_make_int_type (dhandle, 1, FALSE); |
252b5132 RH |
727 | name = "char"; |
728 | break; | |
729 | ||
730 | case builtin_long: | |
b34976b6 | 731 | type = debug_make_int_type (dhandle, 4, FALSE); |
252b5132 RH |
732 | name = "long"; |
733 | break; | |
734 | ||
735 | case builtin_short: | |
b34976b6 | 736 | type = debug_make_int_type (dhandle, 2, FALSE); |
252b5132 RH |
737 | name = "short"; |
738 | break; | |
739 | ||
740 | case builtin_unsigned_short: | |
b34976b6 | 741 | type = debug_make_int_type (dhandle, 2, TRUE); |
252b5132 RH |
742 | name = "unsigned short"; |
743 | break; | |
744 | ||
745 | case builtin_short_int: | |
b34976b6 | 746 | type = debug_make_int_type (dhandle, 2, FALSE); |
252b5132 RH |
747 | name = "short int"; |
748 | break; | |
749 | ||
750 | case builtin_signed_short: | |
b34976b6 | 751 | type = debug_make_int_type (dhandle, 2, FALSE); |
252b5132 RH |
752 | name = "signed short"; |
753 | break; | |
754 | ||
755 | case builtin_bcd_float: | |
756 | ieee_error (info, p, _("BCD float type not supported")); | |
3dceb55b | 757 | return DEBUG_TYPE_NULL; |
252b5132 RH |
758 | } |
759 | ||
760 | if (name != NULL) | |
761 | type = debug_name_type (dhandle, name, type); | |
762 | ||
763 | assert (indx < BUILTIN_TYPE_COUNT); | |
764 | ||
765 | info->types.builtins[indx] = type; | |
766 | ||
767 | return type; | |
768 | } | |
769 | ||
b34976b6 | 770 | /* Allocate more space in the type table. If ref is TRUE, this is a |
252b5132 RH |
771 | reference to the type; if it is not already defined, we should set |
772 | up an indirect type. */ | |
773 | ||
b34976b6 | 774 | static bfd_boolean |
2da42df6 | 775 | ieee_alloc_type (struct ieee_info *info, unsigned int indx, bfd_boolean ref) |
252b5132 RH |
776 | { |
777 | unsigned int nalloc; | |
778 | register struct ieee_type *t; | |
779 | struct ieee_type *tend; | |
780 | ||
781 | if (indx >= info->types.alloc) | |
782 | { | |
783 | nalloc = info->types.alloc; | |
784 | if (nalloc == 0) | |
785 | nalloc = 4; | |
786 | while (indx >= nalloc) | |
787 | nalloc *= 2; | |
788 | ||
789 | info->types.types = ((struct ieee_type *) | |
790 | xrealloc (info->types.types, | |
791 | nalloc * sizeof *info->types.types)); | |
792 | ||
793 | memset (info->types.types + info->types.alloc, 0, | |
794 | (nalloc - info->types.alloc) * sizeof *info->types.types); | |
795 | ||
796 | tend = info->types.types + nalloc; | |
797 | for (t = info->types.types + info->types.alloc; t < tend; t++) | |
798 | t->type = DEBUG_TYPE_NULL; | |
799 | ||
800 | info->types.alloc = nalloc; | |
801 | } | |
802 | ||
803 | if (ref) | |
804 | { | |
805 | t = info->types.types + indx; | |
806 | if (t->type == NULL) | |
807 | { | |
808 | t->pslot = (debug_type *) xmalloc (sizeof *t->pslot); | |
809 | *t->pslot = DEBUG_TYPE_NULL; | |
810 | t->type = debug_make_indirect_type (info->dhandle, t->pslot, | |
811 | (const char *) NULL); | |
812 | if (t->type == NULL) | |
b34976b6 | 813 | return FALSE; |
252b5132 RH |
814 | } |
815 | } | |
816 | ||
b34976b6 | 817 | return TRUE; |
252b5132 RH |
818 | } |
819 | ||
820 | /* Read a type index and return the corresponding type. */ | |
821 | ||
b34976b6 | 822 | static bfd_boolean |
2da42df6 AJ |
823 | ieee_read_type_index (struct ieee_info *info, const bfd_byte **pp, |
824 | debug_type *ptype) | |
252b5132 RH |
825 | { |
826 | const bfd_byte *start; | |
827 | bfd_vma indx; | |
828 | ||
829 | start = *pp; | |
830 | ||
831 | if (! ieee_read_number (info, pp, &indx)) | |
b34976b6 | 832 | return FALSE; |
252b5132 RH |
833 | |
834 | if (indx < 256) | |
835 | { | |
836 | *ptype = ieee_builtin_type (info, start, indx); | |
837 | if (*ptype == NULL) | |
b34976b6 AM |
838 | return FALSE; |
839 | return TRUE; | |
252b5132 RH |
840 | } |
841 | ||
842 | indx -= 256; | |
b34976b6 AM |
843 | if (! ieee_alloc_type (info, indx, TRUE)) |
844 | return FALSE; | |
252b5132 RH |
845 | |
846 | *ptype = info->types.types[indx].type; | |
847 | ||
b34976b6 | 848 | return TRUE; |
252b5132 RH |
849 | } |
850 | ||
851 | /* Parse IEEE debugging information for a file. This is passed the | |
852 | bytes which compose the Debug Information Part of an IEEE file. */ | |
853 | ||
b34976b6 | 854 | bfd_boolean |
2da42df6 | 855 | parse_ieee (void *dhandle, bfd *abfd, const bfd_byte *bytes, bfd_size_type len) |
252b5132 RH |
856 | { |
857 | struct ieee_info info; | |
858 | unsigned int i; | |
859 | const bfd_byte *p, *pend; | |
860 | ||
861 | info.dhandle = dhandle; | |
862 | info.abfd = abfd; | |
863 | info.bytes = bytes; | |
864 | info.pend = bytes + len; | |
865 | info.blockstack.bsp = info.blockstack.stack; | |
b34976b6 | 866 | info.saw_filename = FALSE; |
252b5132 RH |
867 | info.vars.alloc = 0; |
868 | info.vars.vars = NULL; | |
869 | info.global_vars = NULL; | |
870 | info.types.alloc = 0; | |
871 | info.types.types = NULL; | |
872 | info.global_types = NULL; | |
873 | info.tags = NULL; | |
874 | for (i = 0; i < BUILTIN_TYPE_COUNT; i++) | |
875 | info.types.builtins[i] = DEBUG_TYPE_NULL; | |
876 | ||
877 | p = bytes; | |
878 | pend = info.pend; | |
879 | while (p < pend) | |
880 | { | |
881 | const bfd_byte *record_start; | |
882 | ieee_record_enum_type c; | |
883 | ||
884 | record_start = p; | |
885 | ||
886 | c = (ieee_record_enum_type) *p++; | |
887 | ||
888 | if (c == ieee_at_record_enum) | |
889 | c = (ieee_record_enum_type) (((unsigned int) c << 8) | *p++); | |
890 | ||
891 | if (c <= ieee_number_repeat_end_enum) | |
892 | { | |
893 | ieee_error (&info, record_start, _("unexpected number")); | |
b34976b6 | 894 | return FALSE; |
252b5132 RH |
895 | } |
896 | ||
897 | switch (c) | |
898 | { | |
899 | default: | |
900 | ieee_error (&info, record_start, _("unexpected record type")); | |
b34976b6 | 901 | return FALSE; |
252b5132 RH |
902 | |
903 | case ieee_bb_record_enum: | |
904 | if (! parse_ieee_bb (&info, &p)) | |
b34976b6 | 905 | return FALSE; |
252b5132 RH |
906 | break; |
907 | ||
908 | case ieee_be_record_enum: | |
909 | if (! parse_ieee_be (&info, &p)) | |
b34976b6 | 910 | return FALSE; |
252b5132 RH |
911 | break; |
912 | ||
913 | case ieee_nn_record: | |
914 | if (! parse_ieee_nn (&info, &p)) | |
b34976b6 | 915 | return FALSE; |
252b5132 RH |
916 | break; |
917 | ||
918 | case ieee_ty_record_enum: | |
919 | if (! parse_ieee_ty (&info, &p)) | |
b34976b6 | 920 | return FALSE; |
252b5132 RH |
921 | break; |
922 | ||
923 | case ieee_atn_record_enum: | |
924 | if (! parse_ieee_atn (&info, &p)) | |
b34976b6 | 925 | return FALSE; |
252b5132 RH |
926 | break; |
927 | } | |
928 | } | |
929 | ||
930 | if (info.blockstack.bsp != info.blockstack.stack) | |
931 | { | |
932 | ieee_error (&info, (const bfd_byte *) NULL, | |
933 | _("blocks left on stack at end")); | |
b34976b6 | 934 | return FALSE; |
252b5132 RH |
935 | } |
936 | ||
b34976b6 | 937 | return TRUE; |
252b5132 RH |
938 | } |
939 | ||
940 | /* Handle an IEEE BB record. */ | |
941 | ||
b34976b6 | 942 | static bfd_boolean |
2da42df6 | 943 | parse_ieee_bb (struct ieee_info *info, const bfd_byte **pp) |
252b5132 RH |
944 | { |
945 | const bfd_byte *block_start; | |
946 | bfd_byte b; | |
947 | bfd_vma size; | |
948 | const char *name; | |
949 | unsigned long namlen; | |
950 | char *namcopy = NULL; | |
951 | unsigned int fnindx; | |
b34976b6 | 952 | bfd_boolean skip; |
252b5132 RH |
953 | |
954 | block_start = *pp; | |
955 | ||
956 | b = **pp; | |
957 | ++*pp; | |
958 | ||
959 | if (! ieee_read_number (info, pp, &size) | |
960 | || ! ieee_read_id (info, pp, &name, &namlen)) | |
b34976b6 | 961 | return FALSE; |
252b5132 RH |
962 | |
963 | fnindx = (unsigned int) -1; | |
b34976b6 | 964 | skip = FALSE; |
252b5132 RH |
965 | |
966 | switch (b) | |
967 | { | |
968 | case 1: | |
969 | /* BB1: Type definitions local to a module. */ | |
970 | namcopy = savestring (name, namlen); | |
971 | if (namcopy == NULL) | |
b34976b6 | 972 | return FALSE; |
252b5132 | 973 | if (! debug_set_filename (info->dhandle, namcopy)) |
b34976b6 AM |
974 | return FALSE; |
975 | info->saw_filename = TRUE; | |
252b5132 RH |
976 | |
977 | /* Discard any variables or types we may have seen before. */ | |
978 | if (info->vars.vars != NULL) | |
979 | free (info->vars.vars); | |
980 | info->vars.vars = NULL; | |
981 | info->vars.alloc = 0; | |
982 | if (info->types.types != NULL) | |
983 | free (info->types.types); | |
984 | info->types.types = NULL; | |
985 | info->types.alloc = 0; | |
986 | ||
987 | /* Initialize the types to the global types. */ | |
988 | if (info->global_types != NULL) | |
989 | { | |
990 | info->types.alloc = info->global_types->alloc; | |
991 | info->types.types = ((struct ieee_type *) | |
992 | xmalloc (info->types.alloc | |
993 | * sizeof (*info->types.types))); | |
994 | memcpy (info->types.types, info->global_types->types, | |
995 | info->types.alloc * sizeof (*info->types.types)); | |
996 | } | |
997 | ||
998 | break; | |
999 | ||
1000 | case 2: | |
1001 | /* BB2: Global type definitions. The name is supposed to be | |
0af11b59 | 1002 | empty, but we don't check. */ |
252b5132 | 1003 | if (! debug_set_filename (info->dhandle, "*global*")) |
b34976b6 AM |
1004 | return FALSE; |
1005 | info->saw_filename = TRUE; | |
252b5132 RH |
1006 | break; |
1007 | ||
1008 | case 3: | |
1009 | /* BB3: High level module block begin. We don't have to do | |
1010 | anything here. The name is supposed to be the same as for | |
1011 | the BB1, but we don't check. */ | |
1012 | break; | |
1013 | ||
1014 | case 4: | |
1015 | /* BB4: Global function. */ | |
1016 | { | |
1017 | bfd_vma stackspace, typindx, offset; | |
1018 | debug_type return_type; | |
1019 | ||
1020 | if (! ieee_read_number (info, pp, &stackspace) | |
1021 | || ! ieee_read_number (info, pp, &typindx) | |
1022 | || ! ieee_read_expression (info, pp, &offset)) | |
b34976b6 | 1023 | return FALSE; |
252b5132 RH |
1024 | |
1025 | /* We have no way to record the stack space. FIXME. */ | |
1026 | ||
1027 | if (typindx < 256) | |
1028 | { | |
1029 | return_type = ieee_builtin_type (info, block_start, typindx); | |
1030 | if (return_type == DEBUG_TYPE_NULL) | |
b34976b6 | 1031 | return FALSE; |
252b5132 RH |
1032 | } |
1033 | else | |
1034 | { | |
1035 | typindx -= 256; | |
b34976b6 AM |
1036 | if (! ieee_alloc_type (info, typindx, TRUE)) |
1037 | return FALSE; | |
252b5132 RH |
1038 | fnindx = typindx; |
1039 | return_type = info->types.types[typindx].type; | |
1040 | if (debug_get_type_kind (info->dhandle, return_type) | |
1041 | == DEBUG_KIND_FUNCTION) | |
1042 | return_type = debug_get_return_type (info->dhandle, | |
1043 | return_type); | |
1044 | } | |
1045 | ||
1046 | namcopy = savestring (name, namlen); | |
1047 | if (namcopy == NULL) | |
b34976b6 | 1048 | return FALSE; |
252b5132 | 1049 | if (! debug_record_function (info->dhandle, namcopy, return_type, |
b34976b6 AM |
1050 | TRUE, offset)) |
1051 | return FALSE; | |
252b5132 RH |
1052 | } |
1053 | break; | |
1054 | ||
1055 | case 5: | |
1056 | /* BB5: File name for source line numbers. */ | |
1057 | { | |
1058 | unsigned int i; | |
1059 | ||
1060 | /* We ignore the date and time. FIXME. */ | |
1061 | for (i = 0; i < 6; i++) | |
1062 | { | |
1063 | bfd_vma ignore; | |
b34976b6 | 1064 | bfd_boolean present; |
252b5132 RH |
1065 | |
1066 | if (! ieee_read_optional_number (info, pp, &ignore, &present)) | |
b34976b6 | 1067 | return FALSE; |
252b5132 RH |
1068 | if (! present) |
1069 | break; | |
1070 | } | |
1071 | ||
220df88b NC |
1072 | if (! info->saw_filename) |
1073 | { | |
1074 | namcopy = savestring (name, namlen); | |
1075 | if (namcopy == NULL) | |
1076 | return FALSE; | |
1077 | if (! debug_set_filename (info->dhandle, namcopy)) | |
1078 | return FALSE; | |
1079 | info->saw_filename = TRUE; | |
1080 | } | |
1081 | ||
252b5132 RH |
1082 | namcopy = savestring (name, namlen); |
1083 | if (namcopy == NULL) | |
b34976b6 | 1084 | return FALSE; |
252b5132 | 1085 | if (! debug_start_source (info->dhandle, namcopy)) |
b34976b6 | 1086 | return FALSE; |
252b5132 RH |
1087 | } |
1088 | break; | |
1089 | ||
1090 | case 6: | |
1091 | /* BB6: Local function or block. */ | |
1092 | { | |
1093 | bfd_vma stackspace, typindx, offset; | |
1094 | ||
1095 | if (! ieee_read_number (info, pp, &stackspace) | |
1096 | || ! ieee_read_number (info, pp, &typindx) | |
1097 | || ! ieee_read_expression (info, pp, &offset)) | |
b34976b6 | 1098 | return FALSE; |
252b5132 RH |
1099 | |
1100 | /* We have no way to record the stack space. FIXME. */ | |
1101 | ||
1102 | if (namlen == 0) | |
1103 | { | |
1104 | if (! debug_start_block (info->dhandle, offset)) | |
b34976b6 | 1105 | return FALSE; |
252b5132 RH |
1106 | /* Change b to indicate that this is a block |
1107 | rather than a function. */ | |
1108 | b = 0x86; | |
1109 | } | |
1110 | else | |
1111 | { | |
1112 | /* The MRI C++ compiler will output a fake function named | |
1113 | __XRYCPP to hold C++ debugging information. We skip | |
1114 | that function. This is not crucial, but it makes | |
1115 | converting from IEEE to other debug formats work | |
1116 | better. */ | |
1117 | if (strncmp (name, "__XRYCPP", namlen) == 0) | |
b34976b6 | 1118 | skip = TRUE; |
252b5132 RH |
1119 | else |
1120 | { | |
1121 | debug_type return_type; | |
1122 | ||
1123 | if (typindx < 256) | |
1124 | { | |
1125 | return_type = ieee_builtin_type (info, block_start, | |
1126 | typindx); | |
1127 | if (return_type == NULL) | |
b34976b6 | 1128 | return FALSE; |
252b5132 RH |
1129 | } |
1130 | else | |
1131 | { | |
1132 | typindx -= 256; | |
b34976b6 AM |
1133 | if (! ieee_alloc_type (info, typindx, TRUE)) |
1134 | return FALSE; | |
252b5132 RH |
1135 | fnindx = typindx; |
1136 | return_type = info->types.types[typindx].type; | |
1137 | if (debug_get_type_kind (info->dhandle, return_type) | |
1138 | == DEBUG_KIND_FUNCTION) | |
1139 | return_type = debug_get_return_type (info->dhandle, | |
1140 | return_type); | |
1141 | } | |
1142 | ||
1143 | namcopy = savestring (name, namlen); | |
1144 | if (namcopy == NULL) | |
b34976b6 | 1145 | return FALSE; |
252b5132 | 1146 | if (! debug_record_function (info->dhandle, namcopy, |
b34976b6 AM |
1147 | return_type, FALSE, offset)) |
1148 | return FALSE; | |
252b5132 RH |
1149 | } |
1150 | } | |
1151 | } | |
1152 | break; | |
1153 | ||
1154 | case 10: | |
1155 | /* BB10: Assembler module scope. In the normal case, we | |
1156 | completely ignore all this information. FIXME. */ | |
1157 | { | |
1158 | const char *inam, *vstr; | |
1159 | unsigned long inamlen, vstrlen; | |
1160 | bfd_vma tool_type; | |
b34976b6 | 1161 | bfd_boolean present; |
252b5132 RH |
1162 | unsigned int i; |
1163 | ||
1164 | if (! info->saw_filename) | |
1165 | { | |
1166 | namcopy = savestring (name, namlen); | |
1167 | if (namcopy == NULL) | |
b34976b6 | 1168 | return FALSE; |
252b5132 | 1169 | if (! debug_set_filename (info->dhandle, namcopy)) |
b34976b6 AM |
1170 | return FALSE; |
1171 | info->saw_filename = TRUE; | |
252b5132 RH |
1172 | } |
1173 | ||
1174 | if (! ieee_read_id (info, pp, &inam, &inamlen) | |
1175 | || ! ieee_read_number (info, pp, &tool_type) | |
1176 | || ! ieee_read_optional_id (info, pp, &vstr, &vstrlen, &present)) | |
b34976b6 | 1177 | return FALSE; |
252b5132 RH |
1178 | for (i = 0; i < 6; i++) |
1179 | { | |
1180 | bfd_vma ignore; | |
1181 | ||
1182 | if (! ieee_read_optional_number (info, pp, &ignore, &present)) | |
b34976b6 | 1183 | return FALSE; |
252b5132 RH |
1184 | if (! present) |
1185 | break; | |
1186 | } | |
1187 | } | |
1188 | break; | |
1189 | ||
1190 | case 11: | |
1191 | /* BB11: Module section. We completely ignore all this | |
1192 | information. FIXME. */ | |
1193 | { | |
1194 | bfd_vma sectype, secindx, offset, map; | |
b34976b6 | 1195 | bfd_boolean present; |
252b5132 RH |
1196 | |
1197 | if (! ieee_read_number (info, pp, §ype) | |
1198 | || ! ieee_read_number (info, pp, &secindx) | |
1199 | || ! ieee_read_expression (info, pp, &offset) | |
1200 | || ! ieee_read_optional_number (info, pp, &map, &present)) | |
b34976b6 | 1201 | return FALSE; |
252b5132 RH |
1202 | } |
1203 | break; | |
1204 | ||
1205 | default: | |
1206 | ieee_error (info, block_start, _("unknown BB type")); | |
b34976b6 | 1207 | return FALSE; |
252b5132 RH |
1208 | } |
1209 | ||
1210 | ||
1211 | /* Push this block on the block stack. */ | |
1212 | ||
1213 | if (info->blockstack.bsp >= info->blockstack.stack + BLOCKSTACK_SIZE) | |
1214 | { | |
1215 | ieee_error (info, (const bfd_byte *) NULL, _("stack overflow")); | |
b34976b6 | 1216 | return FALSE; |
252b5132 RH |
1217 | } |
1218 | ||
1219 | info->blockstack.bsp->kind = b; | |
1220 | if (b == 5) | |
1221 | info->blockstack.bsp->filename = namcopy; | |
1222 | info->blockstack.bsp->fnindx = fnindx; | |
1223 | info->blockstack.bsp->skip = skip; | |
1224 | ++info->blockstack.bsp; | |
1225 | ||
b34976b6 | 1226 | return TRUE; |
252b5132 RH |
1227 | } |
1228 | ||
1229 | /* Handle an IEEE BE record. */ | |
1230 | ||
b34976b6 | 1231 | static bfd_boolean |
2da42df6 | 1232 | parse_ieee_be (struct ieee_info *info, const bfd_byte **pp) |
252b5132 RH |
1233 | { |
1234 | bfd_vma offset; | |
1235 | ||
1236 | if (info->blockstack.bsp <= info->blockstack.stack) | |
1237 | { | |
1238 | ieee_error (info, *pp, _("stack underflow")); | |
b34976b6 | 1239 | return FALSE; |
252b5132 RH |
1240 | } |
1241 | --info->blockstack.bsp; | |
1242 | ||
1243 | switch (info->blockstack.bsp->kind) | |
1244 | { | |
1245 | case 2: | |
1be59579 | 1246 | /* When we end the global typedefs block, we copy out the |
252b5132 RH |
1247 | contents of info->vars. This is because the variable indices |
1248 | may be reused in the local blocks. However, we need to | |
1249 | preserve them so that we can locate a function returning a | |
1250 | reference variable whose type is named in the global typedef | |
1251 | block. */ | |
1252 | info->global_vars = ((struct ieee_vars *) | |
1253 | xmalloc (sizeof *info->global_vars)); | |
1254 | info->global_vars->alloc = info->vars.alloc; | |
1255 | info->global_vars->vars = ((struct ieee_var *) | |
1256 | xmalloc (info->vars.alloc | |
1257 | * sizeof (*info->vars.vars))); | |
1258 | memcpy (info->global_vars->vars, info->vars.vars, | |
1259 | info->vars.alloc * sizeof (*info->vars.vars)); | |
1260 | ||
1261 | /* We also copy out the non builtin parts of info->types, since | |
1262 | the types are discarded when we start a new block. */ | |
1263 | info->global_types = ((struct ieee_types *) | |
1264 | xmalloc (sizeof *info->global_types)); | |
1265 | info->global_types->alloc = info->types.alloc; | |
1266 | info->global_types->types = ((struct ieee_type *) | |
1267 | xmalloc (info->types.alloc | |
1268 | * sizeof (*info->types.types))); | |
1269 | memcpy (info->global_types->types, info->types.types, | |
1270 | info->types.alloc * sizeof (*info->types.types)); | |
1271 | memset (info->global_types->builtins, 0, | |
1272 | sizeof (info->global_types->builtins)); | |
1273 | ||
1274 | break; | |
1275 | ||
1276 | case 4: | |
1277 | case 6: | |
1278 | if (! ieee_read_expression (info, pp, &offset)) | |
b34976b6 | 1279 | return FALSE; |
252b5132 RH |
1280 | if (! info->blockstack.bsp->skip) |
1281 | { | |
1282 | if (! debug_end_function (info->dhandle, offset + 1)) | |
b34976b6 | 1283 | return FALSE; |
252b5132 RH |
1284 | } |
1285 | break; | |
1286 | ||
1287 | case 0x86: | |
1288 | /* This is BE6 when BB6 started a block rather than a local | |
1289 | function. */ | |
1290 | if (! ieee_read_expression (info, pp, &offset)) | |
b34976b6 | 1291 | return FALSE; |
252b5132 | 1292 | if (! debug_end_block (info->dhandle, offset + 1)) |
b34976b6 | 1293 | return FALSE; |
252b5132 RH |
1294 | break; |
1295 | ||
1296 | case 5: | |
1297 | /* When we end a BB5, we look up the stack for the last BB5, if | |
1298 | there is one, so that we can call debug_start_source. */ | |
1299 | if (info->blockstack.bsp > info->blockstack.stack) | |
1300 | { | |
1301 | struct ieee_block *bl; | |
1302 | ||
1303 | bl = info->blockstack.bsp; | |
1304 | do | |
1305 | { | |
1306 | --bl; | |
1307 | if (bl->kind == 5) | |
1308 | { | |
1309 | if (! debug_start_source (info->dhandle, bl->filename)) | |
b34976b6 | 1310 | return FALSE; |
252b5132 RH |
1311 | break; |
1312 | } | |
1313 | } | |
1314 | while (bl != info->blockstack.stack); | |
1315 | } | |
1316 | break; | |
1317 | ||
1318 | case 11: | |
1319 | if (! ieee_read_expression (info, pp, &offset)) | |
b34976b6 | 1320 | return FALSE; |
252b5132 RH |
1321 | /* We just ignore the module size. FIXME. */ |
1322 | break; | |
1323 | ||
1324 | default: | |
1325 | /* Other block types do not have any trailing information. */ | |
1326 | break; | |
1327 | } | |
1328 | ||
b34976b6 | 1329 | return TRUE; |
252b5132 RH |
1330 | } |
1331 | ||
1332 | /* Parse an NN record. */ | |
1333 | ||
b34976b6 | 1334 | static bfd_boolean |
2da42df6 | 1335 | parse_ieee_nn (struct ieee_info *info, const bfd_byte **pp) |
252b5132 RH |
1336 | { |
1337 | const bfd_byte *nn_start; | |
1338 | bfd_vma varindx; | |
1339 | const char *name; | |
1340 | unsigned long namlen; | |
1341 | ||
1342 | nn_start = *pp; | |
1343 | ||
1344 | if (! ieee_read_number (info, pp, &varindx) | |
1345 | || ! ieee_read_id (info, pp, &name, &namlen)) | |
b34976b6 | 1346 | return FALSE; |
252b5132 RH |
1347 | |
1348 | if (varindx < 32) | |
1349 | { | |
1350 | ieee_error (info, nn_start, _("illegal variable index")); | |
b34976b6 | 1351 | return FALSE; |
252b5132 RH |
1352 | } |
1353 | varindx -= 32; | |
1354 | ||
1355 | if (varindx >= info->vars.alloc) | |
1356 | { | |
1357 | unsigned int alloc; | |
1358 | ||
1359 | alloc = info->vars.alloc; | |
1360 | if (alloc == 0) | |
1361 | alloc = 4; | |
1362 | while (varindx >= alloc) | |
1363 | alloc *= 2; | |
1364 | info->vars.vars = ((struct ieee_var *) | |
1365 | xrealloc (info->vars.vars, | |
1366 | alloc * sizeof *info->vars.vars)); | |
1367 | memset (info->vars.vars + info->vars.alloc, 0, | |
1368 | (alloc - info->vars.alloc) * sizeof *info->vars.vars); | |
1369 | info->vars.alloc = alloc; | |
1370 | } | |
1371 | ||
1372 | info->vars.vars[varindx].name = name; | |
1373 | info->vars.vars[varindx].namlen = namlen; | |
1374 | ||
b34976b6 | 1375 | return TRUE; |
252b5132 RH |
1376 | } |
1377 | ||
1378 | /* Parse a TY record. */ | |
1379 | ||
b34976b6 | 1380 | static bfd_boolean |
2da42df6 | 1381 | parse_ieee_ty (struct ieee_info *info, const bfd_byte **pp) |
252b5132 RH |
1382 | { |
1383 | const bfd_byte *ty_start, *ty_var_start, *ty_code_start; | |
1384 | bfd_vma typeindx, varindx, tc; | |
2da42df6 | 1385 | void *dhandle; |
b34976b6 | 1386 | bfd_boolean tag, typdef; |
252b5132 RH |
1387 | debug_type *arg_slots; |
1388 | unsigned long type_bitsize; | |
1389 | debug_type type; | |
1390 | ||
1391 | ty_start = *pp; | |
1392 | ||
1393 | if (! ieee_read_number (info, pp, &typeindx)) | |
b34976b6 | 1394 | return FALSE; |
252b5132 RH |
1395 | |
1396 | if (typeindx < 256) | |
1397 | { | |
1398 | ieee_error (info, ty_start, _("illegal type index")); | |
b34976b6 | 1399 | return FALSE; |
252b5132 RH |
1400 | } |
1401 | ||
1402 | typeindx -= 256; | |
b34976b6 AM |
1403 | if (! ieee_alloc_type (info, typeindx, FALSE)) |
1404 | return FALSE; | |
252b5132 RH |
1405 | |
1406 | if (**pp != 0xce) | |
1407 | { | |
1408 | ieee_error (info, *pp, _("unknown TY code")); | |
b34976b6 | 1409 | return FALSE; |
252b5132 RH |
1410 | } |
1411 | ++*pp; | |
1412 | ||
1413 | ty_var_start = *pp; | |
1414 | ||
1415 | if (! ieee_read_number (info, pp, &varindx)) | |
b34976b6 | 1416 | return FALSE; |
252b5132 RH |
1417 | |
1418 | if (varindx < 32) | |
1419 | { | |
1420 | ieee_error (info, ty_var_start, _("illegal variable index")); | |
b34976b6 | 1421 | return FALSE; |
252b5132 RH |
1422 | } |
1423 | varindx -= 32; | |
1424 | ||
1425 | if (varindx >= info->vars.alloc || info->vars.vars[varindx].name == NULL) | |
1426 | { | |
1427 | ieee_error (info, ty_var_start, _("undefined variable in TY")); | |
b34976b6 | 1428 | return FALSE; |
252b5132 RH |
1429 | } |
1430 | ||
1431 | ty_code_start = *pp; | |
1432 | ||
1433 | if (! ieee_read_number (info, pp, &tc)) | |
b34976b6 | 1434 | return FALSE; |
252b5132 RH |
1435 | |
1436 | dhandle = info->dhandle; | |
1437 | ||
b34976b6 AM |
1438 | tag = FALSE; |
1439 | typdef = FALSE; | |
252b5132 RH |
1440 | arg_slots = NULL; |
1441 | type_bitsize = 0; | |
1442 | switch (tc) | |
1443 | { | |
1444 | default: | |
1445 | ieee_error (info, ty_code_start, _("unknown TY code")); | |
b34976b6 | 1446 | return FALSE; |
252b5132 RH |
1447 | |
1448 | case '!': | |
1449 | /* Unknown type, with size. We treat it as int. FIXME. */ | |
1450 | { | |
1451 | bfd_vma size; | |
1452 | ||
1453 | if (! ieee_read_number (info, pp, &size)) | |
b34976b6 AM |
1454 | return FALSE; |
1455 | type = debug_make_int_type (dhandle, size, FALSE); | |
252b5132 RH |
1456 | } |
1457 | break; | |
1458 | ||
1459 | case 'A': /* Array. */ | |
1460 | case 'a': /* FORTRAN array in column/row order. FIXME: Not | |
1461 | distinguished from normal array. */ | |
1462 | { | |
1463 | debug_type ele_type; | |
1464 | bfd_vma lower, upper; | |
1465 | ||
1466 | if (! ieee_read_type_index (info, pp, &ele_type) | |
1467 | || ! ieee_read_number (info, pp, &lower) | |
1468 | || ! ieee_read_number (info, pp, &upper)) | |
b34976b6 | 1469 | return FALSE; |
252b5132 RH |
1470 | type = debug_make_array_type (dhandle, ele_type, |
1471 | ieee_builtin_type (info, ty_code_start, | |
1472 | ((unsigned int) | |
1473 | builtin_int)), | |
1474 | (bfd_signed_vma) lower, | |
1475 | (bfd_signed_vma) upper, | |
b34976b6 | 1476 | FALSE); |
252b5132 RH |
1477 | } |
1478 | break; | |
1479 | ||
1480 | case 'E': | |
1481 | /* Simple enumeration. */ | |
1482 | { | |
1483 | bfd_vma size; | |
1484 | unsigned int alloc; | |
1485 | const char **names; | |
1486 | unsigned int c; | |
1487 | bfd_signed_vma *vals; | |
1488 | unsigned int i; | |
1489 | ||
1490 | if (! ieee_read_number (info, pp, &size)) | |
b34976b6 | 1491 | return FALSE; |
252b5132 RH |
1492 | /* FIXME: we ignore the enumeration size. */ |
1493 | ||
1494 | alloc = 10; | |
1495 | names = (const char **) xmalloc (alloc * sizeof *names); | |
1496 | memset (names, 0, alloc * sizeof *names); | |
1497 | c = 0; | |
1498 | while (1) | |
1499 | { | |
1500 | const char *name; | |
1501 | unsigned long namlen; | |
b34976b6 | 1502 | bfd_boolean present; |
252b5132 RH |
1503 | |
1504 | if (! ieee_read_optional_id (info, pp, &name, &namlen, &present)) | |
b34976b6 | 1505 | return FALSE; |
252b5132 RH |
1506 | if (! present) |
1507 | break; | |
1508 | ||
1509 | if (c + 1 >= alloc) | |
1510 | { | |
1511 | alloc += 10; | |
1512 | names = ((const char **) | |
1513 | xrealloc (names, alloc * sizeof *names)); | |
1514 | } | |
1515 | ||
1516 | names[c] = savestring (name, namlen); | |
1517 | if (names[c] == NULL) | |
b34976b6 | 1518 | return FALSE; |
252b5132 RH |
1519 | ++c; |
1520 | } | |
1521 | ||
1522 | names[c] = NULL; | |
1523 | ||
1524 | vals = (bfd_signed_vma *) xmalloc (c * sizeof *vals); | |
1525 | for (i = 0; i < c; i++) | |
1526 | vals[i] = i; | |
1527 | ||
1528 | type = debug_make_enum_type (dhandle, names, vals); | |
b34976b6 | 1529 | tag = TRUE; |
252b5132 RH |
1530 | } |
1531 | break; | |
1532 | ||
1533 | case 'G': | |
1534 | /* Struct with bit fields. */ | |
1535 | { | |
1536 | bfd_vma size; | |
1537 | unsigned int alloc; | |
1538 | debug_field *fields; | |
1539 | unsigned int c; | |
1540 | ||
1541 | if (! ieee_read_number (info, pp, &size)) | |
b34976b6 | 1542 | return FALSE; |
252b5132 RH |
1543 | |
1544 | alloc = 10; | |
1545 | fields = (debug_field *) xmalloc (alloc * sizeof *fields); | |
1546 | c = 0; | |
1547 | while (1) | |
1548 | { | |
1549 | const char *name; | |
1550 | unsigned long namlen; | |
b34976b6 | 1551 | bfd_boolean present; |
252b5132 RH |
1552 | debug_type ftype; |
1553 | bfd_vma bitpos, bitsize; | |
1554 | ||
1555 | if (! ieee_read_optional_id (info, pp, &name, &namlen, &present)) | |
b34976b6 | 1556 | return FALSE; |
252b5132 RH |
1557 | if (! present) |
1558 | break; | |
1559 | if (! ieee_read_type_index (info, pp, &ftype) | |
1560 | || ! ieee_read_number (info, pp, &bitpos) | |
1561 | || ! ieee_read_number (info, pp, &bitsize)) | |
b34976b6 | 1562 | return FALSE; |
252b5132 RH |
1563 | |
1564 | if (c + 1 >= alloc) | |
1565 | { | |
1566 | alloc += 10; | |
1567 | fields = ((debug_field *) | |
1568 | xrealloc (fields, alloc * sizeof *fields)); | |
1569 | } | |
1570 | ||
1571 | fields[c] = debug_make_field (dhandle, savestring (name, namlen), | |
1572 | ftype, bitpos, bitsize, | |
1573 | DEBUG_VISIBILITY_PUBLIC); | |
1574 | if (fields[c] == NULL) | |
b34976b6 | 1575 | return FALSE; |
252b5132 RH |
1576 | ++c; |
1577 | } | |
1578 | ||
1579 | fields[c] = NULL; | |
1580 | ||
b34976b6 AM |
1581 | type = debug_make_struct_type (dhandle, TRUE, size, fields); |
1582 | tag = TRUE; | |
252b5132 RH |
1583 | } |
1584 | break; | |
1585 | ||
1586 | case 'N': | |
1587 | /* Enumeration. */ | |
1588 | { | |
1589 | unsigned int alloc; | |
1590 | const char **names; | |
1591 | bfd_signed_vma *vals; | |
1592 | unsigned int c; | |
1593 | ||
1594 | alloc = 10; | |
1595 | names = (const char **) xmalloc (alloc * sizeof *names); | |
1596 | vals = (bfd_signed_vma *) xmalloc (alloc * sizeof *names); | |
1597 | c = 0; | |
1598 | while (1) | |
1599 | { | |
1600 | const char *name; | |
1601 | unsigned long namlen; | |
b34976b6 | 1602 | bfd_boolean present; |
252b5132 RH |
1603 | bfd_vma val; |
1604 | ||
1605 | if (! ieee_read_optional_id (info, pp, &name, &namlen, &present)) | |
b34976b6 | 1606 | return FALSE; |
252b5132 RH |
1607 | if (! present) |
1608 | break; | |
1609 | if (! ieee_read_number (info, pp, &val)) | |
b34976b6 | 1610 | return FALSE; |
252b5132 RH |
1611 | |
1612 | /* If the length of the name is zero, then the value is | |
1613 | actually the size of the enum. We ignore this | |
1614 | information. FIXME. */ | |
1615 | if (namlen == 0) | |
1616 | continue; | |
1617 | ||
1618 | if (c + 1 >= alloc) | |
1619 | { | |
1620 | alloc += 10; | |
1621 | names = ((const char **) | |
1622 | xrealloc (names, alloc * sizeof *names)); | |
1623 | vals = ((bfd_signed_vma *) | |
1624 | xrealloc (vals, alloc * sizeof *vals)); | |
1625 | } | |
1626 | ||
1627 | names[c] = savestring (name, namlen); | |
1628 | if (names[c] == NULL) | |
b34976b6 | 1629 | return FALSE; |
252b5132 RH |
1630 | vals[c] = (bfd_signed_vma) val; |
1631 | ++c; | |
1632 | } | |
1633 | ||
1634 | names[c] = NULL; | |
1635 | ||
1636 | type = debug_make_enum_type (dhandle, names, vals); | |
b34976b6 | 1637 | tag = TRUE; |
252b5132 RH |
1638 | } |
1639 | break; | |
1640 | ||
1641 | case 'O': /* Small pointer. We don't distinguish small and large | |
1642 | pointers. FIXME. */ | |
1643 | case 'P': /* Large pointer. */ | |
1644 | { | |
1645 | debug_type t; | |
1646 | ||
1647 | if (! ieee_read_type_index (info, pp, &t)) | |
b34976b6 | 1648 | return FALSE; |
252b5132 RH |
1649 | type = debug_make_pointer_type (dhandle, t); |
1650 | } | |
1651 | break; | |
1652 | ||
1653 | case 'R': | |
1654 | /* Range. */ | |
1655 | { | |
1656 | bfd_vma low, high, signedp, size; | |
1657 | ||
1658 | if (! ieee_read_number (info, pp, &low) | |
1659 | || ! ieee_read_number (info, pp, &high) | |
1660 | || ! ieee_read_number (info, pp, &signedp) | |
1661 | || ! ieee_read_number (info, pp, &size)) | |
b34976b6 | 1662 | return FALSE; |
252b5132 RH |
1663 | |
1664 | type = debug_make_range_type (dhandle, | |
1665 | debug_make_int_type (dhandle, size, | |
1666 | ! signedp), | |
1667 | (bfd_signed_vma) low, | |
1668 | (bfd_signed_vma) high); | |
1669 | } | |
1670 | break; | |
1671 | ||
1672 | case 'S': /* Struct. */ | |
1673 | case 'U': /* Union. */ | |
1674 | { | |
1675 | bfd_vma size; | |
1676 | unsigned int alloc; | |
1677 | debug_field *fields; | |
1678 | unsigned int c; | |
1679 | ||
1680 | if (! ieee_read_number (info, pp, &size)) | |
b34976b6 | 1681 | return FALSE; |
252b5132 RH |
1682 | |
1683 | alloc = 10; | |
1684 | fields = (debug_field *) xmalloc (alloc * sizeof *fields); | |
1685 | c = 0; | |
1686 | while (1) | |
1687 | { | |
1688 | const char *name; | |
1689 | unsigned long namlen; | |
b34976b6 | 1690 | bfd_boolean present; |
252b5132 RH |
1691 | bfd_vma tindx; |
1692 | bfd_vma offset; | |
1693 | debug_type ftype; | |
1694 | bfd_vma bitsize; | |
1695 | ||
1696 | if (! ieee_read_optional_id (info, pp, &name, &namlen, &present)) | |
b34976b6 | 1697 | return FALSE; |
252b5132 RH |
1698 | if (! present) |
1699 | break; | |
1700 | if (! ieee_read_number (info, pp, &tindx) | |
1701 | || ! ieee_read_number (info, pp, &offset)) | |
b34976b6 | 1702 | return FALSE; |
252b5132 RH |
1703 | |
1704 | if (tindx < 256) | |
1705 | { | |
1706 | ftype = ieee_builtin_type (info, ty_code_start, tindx); | |
1707 | bitsize = 0; | |
1708 | offset *= 8; | |
1709 | } | |
1710 | else | |
1711 | { | |
1712 | struct ieee_type *t; | |
1713 | ||
1714 | tindx -= 256; | |
b34976b6 AM |
1715 | if (! ieee_alloc_type (info, tindx, TRUE)) |
1716 | return FALSE; | |
252b5132 RH |
1717 | t = info->types.types + tindx; |
1718 | ftype = t->type; | |
1719 | bitsize = t->bitsize; | |
1720 | if (bitsize == 0) | |
1721 | offset *= 8; | |
1722 | } | |
1723 | ||
1724 | if (c + 1 >= alloc) | |
1725 | { | |
1726 | alloc += 10; | |
1727 | fields = ((debug_field *) | |
1728 | xrealloc (fields, alloc * sizeof *fields)); | |
1729 | } | |
1730 | ||
1731 | fields[c] = debug_make_field (dhandle, savestring (name, namlen), | |
1732 | ftype, offset, bitsize, | |
1733 | DEBUG_VISIBILITY_PUBLIC); | |
1734 | if (fields[c] == NULL) | |
b34976b6 | 1735 | return FALSE; |
252b5132 RH |
1736 | ++c; |
1737 | } | |
1738 | ||
1739 | fields[c] = NULL; | |
1740 | ||
1741 | type = debug_make_struct_type (dhandle, tc == 'S', size, fields); | |
b34976b6 | 1742 | tag = TRUE; |
252b5132 RH |
1743 | } |
1744 | break; | |
1745 | ||
1746 | case 'T': | |
1747 | /* Typedef. */ | |
1748 | if (! ieee_read_type_index (info, pp, &type)) | |
b34976b6 AM |
1749 | return FALSE; |
1750 | typdef = TRUE; | |
252b5132 RH |
1751 | break; |
1752 | ||
1753 | case 'X': | |
1754 | /* Procedure. FIXME: This is an extern declaration, which we | |
1755 | have no way of representing. */ | |
1756 | { | |
1757 | bfd_vma attr; | |
1758 | debug_type rtype; | |
1759 | bfd_vma nargs; | |
b34976b6 | 1760 | bfd_boolean present; |
252b5132 RH |
1761 | struct ieee_var *pv; |
1762 | ||
1763 | /* FIXME: We ignore the attribute and the argument names. */ | |
1764 | ||
1765 | if (! ieee_read_number (info, pp, &attr) | |
1766 | || ! ieee_read_type_index (info, pp, &rtype) | |
1767 | || ! ieee_read_number (info, pp, &nargs)) | |
b34976b6 | 1768 | return FALSE; |
252b5132 RH |
1769 | do |
1770 | { | |
1771 | const char *name; | |
1772 | unsigned long namlen; | |
1773 | ||
1774 | if (! ieee_read_optional_id (info, pp, &name, &namlen, &present)) | |
b34976b6 | 1775 | return FALSE; |
252b5132 RH |
1776 | } |
1777 | while (present); | |
1778 | ||
1779 | pv = info->vars.vars + varindx; | |
1780 | pv->kind = IEEE_EXTERNAL; | |
1781 | if (pv->namlen > 0 | |
1782 | && debug_get_type_kind (dhandle, rtype) == DEBUG_KIND_POINTER) | |
1783 | { | |
1784 | /* Set up the return type as an indirect type pointing to | |
1785 | the variable slot, so that we can change it to a | |
1786 | reference later if appropriate. */ | |
1787 | pv->pslot = (debug_type *) xmalloc (sizeof *pv->pslot); | |
1788 | *pv->pslot = rtype; | |
1789 | rtype = debug_make_indirect_type (dhandle, pv->pslot, | |
1790 | (const char *) NULL); | |
1791 | } | |
1792 | ||
1793 | type = debug_make_function_type (dhandle, rtype, (debug_type *) NULL, | |
b34976b6 | 1794 | FALSE); |
252b5132 RH |
1795 | } |
1796 | break; | |
1797 | ||
1798 | case 'V': | |
220df88b | 1799 | case 'v': |
252b5132 RH |
1800 | /* Void. This is not documented, but the MRI compiler emits it. */ |
1801 | type = debug_make_void_type (dhandle); | |
1802 | break; | |
1803 | ||
1804 | case 'Z': | |
1805 | /* Array with 0 lower bound. */ | |
1806 | { | |
1807 | debug_type etype; | |
1808 | bfd_vma high; | |
1809 | ||
1810 | if (! ieee_read_type_index (info, pp, &etype) | |
1811 | || ! ieee_read_number (info, pp, &high)) | |
b34976b6 | 1812 | return FALSE; |
252b5132 RH |
1813 | |
1814 | type = debug_make_array_type (dhandle, etype, | |
1815 | ieee_builtin_type (info, ty_code_start, | |
1816 | ((unsigned int) | |
1817 | builtin_int)), | |
b34976b6 | 1818 | 0, (bfd_signed_vma) high, FALSE); |
252b5132 RH |
1819 | } |
1820 | break; | |
1821 | ||
1822 | case 'c': /* Complex. */ | |
1823 | case 'd': /* Double complex. */ | |
1824 | { | |
1825 | const char *name; | |
1826 | unsigned long namlen; | |
1827 | ||
1828 | /* FIXME: I don't know what the name means. */ | |
1829 | ||
1830 | if (! ieee_read_id (info, pp, &name, &namlen)) | |
b34976b6 | 1831 | return FALSE; |
252b5132 RH |
1832 | |
1833 | type = debug_make_complex_type (dhandle, tc == 'c' ? 4 : 8); | |
1834 | } | |
1835 | break; | |
1836 | ||
1837 | case 'f': | |
1838 | /* Pascal file name. FIXME. */ | |
1839 | ieee_error (info, ty_code_start, _("Pascal file name not supported")); | |
b34976b6 | 1840 | return FALSE; |
252b5132 RH |
1841 | |
1842 | case 'g': | |
1843 | /* Bitfield type. */ | |
1844 | { | |
1845 | bfd_vma signedp, bitsize, dummy; | |
1846 | const bfd_byte *hold; | |
b34976b6 | 1847 | bfd_boolean present; |
252b5132 RH |
1848 | |
1849 | if (! ieee_read_number (info, pp, &signedp) | |
1850 | || ! ieee_read_number (info, pp, &bitsize)) | |
b34976b6 | 1851 | return FALSE; |
252b5132 RH |
1852 | |
1853 | /* I think the documentation says that there is a type index, | |
1854 | but some actual files do not have one. */ | |
1855 | hold = *pp; | |
1856 | if (! ieee_read_optional_number (info, pp, &dummy, &present)) | |
b34976b6 | 1857 | return FALSE; |
252b5132 RH |
1858 | if (! present) |
1859 | { | |
1860 | /* FIXME: This is just a guess. */ | |
1861 | type = debug_make_int_type (dhandle, 4, | |
b34976b6 | 1862 | signedp ? FALSE : TRUE); |
252b5132 RH |
1863 | } |
1864 | else | |
1865 | { | |
1866 | *pp = hold; | |
1867 | if (! ieee_read_type_index (info, pp, &type)) | |
b34976b6 | 1868 | return FALSE; |
252b5132 RH |
1869 | } |
1870 | type_bitsize = bitsize; | |
1871 | } | |
1872 | break; | |
1873 | ||
1874 | case 'n': | |
1875 | /* Qualifier. */ | |
1876 | { | |
1877 | bfd_vma kind; | |
1878 | debug_type t; | |
1879 | ||
1880 | if (! ieee_read_number (info, pp, &kind) | |
1881 | || ! ieee_read_type_index (info, pp, &t)) | |
b34976b6 | 1882 | return FALSE; |
252b5132 RH |
1883 | |
1884 | switch (kind) | |
1885 | { | |
1886 | default: | |
3a1a2036 | 1887 | ieee_error (info, ty_start, _("unsupported qualifier")); |
b34976b6 | 1888 | return FALSE; |
252b5132 RH |
1889 | |
1890 | case 1: | |
1891 | type = debug_make_const_type (dhandle, t); | |
1892 | break; | |
1893 | ||
1894 | case 2: | |
1895 | type = debug_make_volatile_type (dhandle, t); | |
1896 | break; | |
1897 | } | |
1898 | } | |
1899 | break; | |
1900 | ||
1901 | case 's': | |
1902 | /* Set. */ | |
1903 | { | |
1904 | bfd_vma size; | |
1905 | debug_type etype; | |
1906 | ||
1907 | if (! ieee_read_number (info, pp, &size) | |
1908 | || ! ieee_read_type_index (info, pp, &etype)) | |
b34976b6 | 1909 | return FALSE; |
252b5132 RH |
1910 | |
1911 | /* FIXME: We ignore the size. */ | |
1912 | ||
b34976b6 | 1913 | type = debug_make_set_type (dhandle, etype, FALSE); |
252b5132 RH |
1914 | } |
1915 | break; | |
1916 | ||
1917 | case 'x': | |
1918 | /* Procedure with compiler dependencies. */ | |
1919 | { | |
1920 | struct ieee_var *pv; | |
1921 | bfd_vma attr, frame_type, push_mask, nargs, level, father; | |
1922 | debug_type rtype; | |
1923 | debug_type *arg_types; | |
b34976b6 AM |
1924 | bfd_boolean varargs; |
1925 | bfd_boolean present; | |
252b5132 RH |
1926 | |
1927 | /* FIXME: We ignore some of this information. */ | |
1928 | ||
1929 | pv = info->vars.vars + varindx; | |
1930 | ||
1931 | if (! ieee_read_number (info, pp, &attr) | |
1932 | || ! ieee_read_number (info, pp, &frame_type) | |
1933 | || ! ieee_read_number (info, pp, &push_mask) | |
1934 | || ! ieee_read_type_index (info, pp, &rtype) | |
1935 | || ! ieee_read_number (info, pp, &nargs)) | |
b34976b6 | 1936 | return FALSE; |
252b5132 RH |
1937 | if (nargs == (bfd_vma) -1) |
1938 | { | |
1939 | arg_types = NULL; | |
b34976b6 | 1940 | varargs = FALSE; |
252b5132 RH |
1941 | } |
1942 | else | |
1943 | { | |
1944 | unsigned int i; | |
1945 | ||
1946 | arg_types = ((debug_type *) | |
1947 | xmalloc ((nargs + 1) * sizeof *arg_types)); | |
1948 | for (i = 0; i < nargs; i++) | |
1949 | if (! ieee_read_type_index (info, pp, arg_types + i)) | |
b34976b6 | 1950 | return FALSE; |
252b5132 RH |
1951 | |
1952 | /* If the last type is pointer to void, this is really a | |
1953 | varargs function. */ | |
b34976b6 | 1954 | varargs = FALSE; |
252b5132 RH |
1955 | if (nargs > 0) |
1956 | { | |
1957 | debug_type last; | |
1958 | ||
1959 | last = arg_types[nargs - 1]; | |
1960 | if (debug_get_type_kind (dhandle, last) == DEBUG_KIND_POINTER | |
1961 | && (debug_get_type_kind (dhandle, | |
1962 | debug_get_target_type (dhandle, | |
1963 | last)) | |
1964 | == DEBUG_KIND_VOID)) | |
1965 | { | |
1966 | --nargs; | |
b34976b6 | 1967 | varargs = TRUE; |
252b5132 RH |
1968 | } |
1969 | } | |
1970 | ||
1971 | /* If there are any pointer arguments, turn them into | |
1972 | indirect types in case we later need to convert them to | |
1973 | reference types. */ | |
1974 | for (i = 0; i < nargs; i++) | |
1975 | { | |
1976 | if (debug_get_type_kind (dhandle, arg_types[i]) | |
1977 | == DEBUG_KIND_POINTER) | |
1978 | { | |
1979 | if (arg_slots == NULL) | |
1980 | { | |
1981 | arg_slots = ((debug_type *) | |
1982 | xmalloc (nargs * sizeof *arg_slots)); | |
1983 | memset (arg_slots, 0, nargs * sizeof *arg_slots); | |
1984 | } | |
1985 | arg_slots[i] = arg_types[i]; | |
1986 | arg_types[i] = | |
1987 | debug_make_indirect_type (dhandle, | |
1988 | arg_slots + i, | |
1989 | (const char *) NULL); | |
1990 | } | |
1991 | } | |
1992 | ||
1993 | arg_types[nargs] = DEBUG_TYPE_NULL; | |
1994 | } | |
1995 | if (! ieee_read_number (info, pp, &level) | |
1996 | || ! ieee_read_optional_number (info, pp, &father, &present)) | |
b34976b6 | 1997 | return FALSE; |
252b5132 RH |
1998 | |
1999 | /* We can't distinguish between a global function and a static | |
2000 | function. */ | |
2001 | pv->kind = IEEE_FUNCTION; | |
2002 | ||
2003 | if (pv->namlen > 0 | |
2004 | && debug_get_type_kind (dhandle, rtype) == DEBUG_KIND_POINTER) | |
2005 | { | |
2006 | /* Set up the return type as an indirect type pointing to | |
2007 | the variable slot, so that we can change it to a | |
2008 | reference later if appropriate. */ | |
2009 | pv->pslot = (debug_type *) xmalloc (sizeof *pv->pslot); | |
2010 | *pv->pslot = rtype; | |
2011 | rtype = debug_make_indirect_type (dhandle, pv->pslot, | |
2012 | (const char *) NULL); | |
2013 | } | |
2014 | ||
2015 | type = debug_make_function_type (dhandle, rtype, arg_types, varargs); | |
2016 | } | |
2017 | break; | |
2018 | } | |
2019 | ||
2020 | /* Record the type in the table. */ | |
2021 | ||
2022 | if (type == DEBUG_TYPE_NULL) | |
b34976b6 | 2023 | return FALSE; |
252b5132 RH |
2024 | |
2025 | info->vars.vars[varindx].type = type; | |
2026 | ||
2027 | if ((tag || typdef) | |
2028 | && info->vars.vars[varindx].namlen > 0) | |
2029 | { | |
2030 | const char *name; | |
2031 | ||
2032 | name = savestring (info->vars.vars[varindx].name, | |
2033 | info->vars.vars[varindx].namlen); | |
2034 | if (typdef) | |
2035 | type = debug_name_type (dhandle, name, type); | |
2036 | else if (tc == 'E' || tc == 'N') | |
2037 | type = debug_tag_type (dhandle, name, type); | |
2038 | else | |
2039 | { | |
2040 | struct ieee_tag *it; | |
2041 | ||
2042 | /* We must allocate all struct tags as indirect types, so | |
2043 | that if we later see a definition of the tag as a C++ | |
2044 | record we can update the indirect slot and automatically | |
2045 | change all the existing references. */ | |
2046 | it = (struct ieee_tag *) xmalloc (sizeof *it); | |
2047 | memset (it, 0, sizeof *it); | |
2048 | it->next = info->tags; | |
2049 | info->tags = it; | |
2050 | it->name = name; | |
2051 | it->slot = type; | |
2052 | ||
2053 | type = debug_make_indirect_type (dhandle, &it->slot, name); | |
2054 | type = debug_tag_type (dhandle, name, type); | |
2055 | ||
2056 | it->type = type; | |
2057 | } | |
2058 | if (type == NULL) | |
b34976b6 | 2059 | return FALSE; |
252b5132 RH |
2060 | } |
2061 | ||
2062 | info->types.types[typeindx].type = type; | |
2063 | info->types.types[typeindx].arg_slots = arg_slots; | |
2064 | info->types.types[typeindx].bitsize = type_bitsize; | |
2065 | ||
2066 | /* We may have already allocated type as an indirect type pointing | |
2067 | to slot. It does no harm to replace the indirect type with the | |
2068 | real type. Filling in slot as well handles the indirect types | |
2069 | which are already hanging around. */ | |
2070 | if (info->types.types[typeindx].pslot != NULL) | |
2071 | *info->types.types[typeindx].pslot = type; | |
2072 | ||
b34976b6 | 2073 | return TRUE; |
252b5132 RH |
2074 | } |
2075 | ||
2076 | /* Parse an ATN record. */ | |
2077 | ||
b34976b6 | 2078 | static bfd_boolean |
2da42df6 | 2079 | parse_ieee_atn (struct ieee_info *info, const bfd_byte **pp) |
252b5132 RH |
2080 | { |
2081 | const bfd_byte *atn_start, *atn_code_start; | |
2082 | bfd_vma varindx; | |
2083 | struct ieee_var *pvar; | |
2084 | debug_type type; | |
2085 | bfd_vma atn_code; | |
2da42df6 | 2086 | void *dhandle; |
252b5132 RH |
2087 | bfd_vma v, v2, v3, v4, v5; |
2088 | const char *name; | |
2089 | unsigned long namlen; | |
2090 | char *namcopy; | |
b34976b6 | 2091 | bfd_boolean present; |
252b5132 RH |
2092 | int blocktype; |
2093 | ||
2094 | atn_start = *pp; | |
2095 | ||
2096 | if (! ieee_read_number (info, pp, &varindx) | |
2097 | || ! ieee_read_type_index (info, pp, &type)) | |
b34976b6 | 2098 | return FALSE; |
252b5132 RH |
2099 | |
2100 | atn_code_start = *pp; | |
2101 | ||
2102 | if (! ieee_read_number (info, pp, &atn_code)) | |
b34976b6 | 2103 | return FALSE; |
252b5132 RH |
2104 | |
2105 | if (varindx == 0) | |
2106 | { | |
2107 | pvar = NULL; | |
2108 | name = ""; | |
2109 | namlen = 0; | |
2110 | } | |
2111 | else if (varindx < 32) | |
2112 | { | |
2113 | /* The MRI compiler reportedly sometimes emits variable lifetime | |
2114 | information for a register. We just ignore it. */ | |
2115 | if (atn_code == 9) | |
2116 | return ieee_read_number (info, pp, &v); | |
2117 | ||
2118 | ieee_error (info, atn_start, _("illegal variable index")); | |
b34976b6 | 2119 | return FALSE; |
252b5132 RH |
2120 | } |
2121 | else | |
2122 | { | |
2123 | varindx -= 32; | |
2124 | if (varindx >= info->vars.alloc | |
2125 | || info->vars.vars[varindx].name == NULL) | |
2126 | { | |
2127 | /* The MRI compiler or linker sometimes omits the NN record | |
2128 | for a pmisc record. */ | |
2129 | if (atn_code == 62) | |
2130 | { | |
2131 | if (varindx >= info->vars.alloc) | |
2132 | { | |
2133 | unsigned int alloc; | |
2134 | ||
2135 | alloc = info->vars.alloc; | |
2136 | if (alloc == 0) | |
2137 | alloc = 4; | |
2138 | while (varindx >= alloc) | |
2139 | alloc *= 2; | |
2140 | info->vars.vars = ((struct ieee_var *) | |
2141 | xrealloc (info->vars.vars, | |
2142 | (alloc | |
2143 | * sizeof *info->vars.vars))); | |
2144 | memset (info->vars.vars + info->vars.alloc, 0, | |
2145 | ((alloc - info->vars.alloc) | |
2146 | * sizeof *info->vars.vars)); | |
2147 | info->vars.alloc = alloc; | |
2148 | } | |
2149 | ||
2150 | pvar = info->vars.vars + varindx; | |
2151 | pvar->name = ""; | |
2152 | pvar->namlen = 0; | |
2153 | } | |
2154 | else | |
2155 | { | |
2156 | ieee_error (info, atn_start, _("undefined variable in ATN")); | |
b34976b6 | 2157 | return FALSE; |
252b5132 RH |
2158 | } |
2159 | } | |
2160 | ||
2161 | pvar = info->vars.vars + varindx; | |
2162 | ||
2163 | pvar->type = type; | |
2164 | ||
2165 | name = pvar->name; | |
2166 | namlen = pvar->namlen; | |
2167 | } | |
2168 | ||
2169 | dhandle = info->dhandle; | |
2170 | ||
2171 | /* If we are going to call debug_record_variable with a pointer | |
2172 | type, change the type to an indirect type so that we can later | |
2173 | change it to a reference type if we encounter a C++ pmisc 'R' | |
2174 | record. */ | |
2175 | if (pvar != NULL | |
2176 | && type != DEBUG_TYPE_NULL | |
2177 | && debug_get_type_kind (dhandle, type) == DEBUG_KIND_POINTER) | |
2178 | { | |
2179 | switch (atn_code) | |
2180 | { | |
2181 | case 1: | |
2182 | case 2: | |
2183 | case 3: | |
2184 | case 5: | |
2185 | case 8: | |
2186 | case 10: | |
2187 | pvar->pslot = (debug_type *) xmalloc (sizeof *pvar->pslot); | |
2188 | *pvar->pslot = type; | |
2189 | type = debug_make_indirect_type (dhandle, pvar->pslot, | |
2190 | (const char *) NULL); | |
2191 | pvar->type = type; | |
2192 | break; | |
2193 | } | |
2194 | } | |
2195 | ||
2196 | switch (atn_code) | |
2197 | { | |
2198 | default: | |
2199 | ieee_error (info, atn_code_start, _("unknown ATN type")); | |
b34976b6 | 2200 | return FALSE; |
252b5132 RH |
2201 | |
2202 | case 1: | |
2203 | /* Automatic variable. */ | |
2204 | if (! ieee_read_number (info, pp, &v)) | |
b34976b6 | 2205 | return FALSE; |
252b5132 RH |
2206 | namcopy = savestring (name, namlen); |
2207 | if (type == NULL) | |
2208 | type = debug_make_void_type (dhandle); | |
2209 | if (pvar != NULL) | |
2210 | pvar->kind = IEEE_LOCAL; | |
2211 | return debug_record_variable (dhandle, namcopy, type, DEBUG_LOCAL, v); | |
2212 | ||
2213 | case 2: | |
2214 | /* Register variable. */ | |
2215 | if (! ieee_read_number (info, pp, &v)) | |
b34976b6 | 2216 | return FALSE; |
252b5132 RH |
2217 | namcopy = savestring (name, namlen); |
2218 | if (type == NULL) | |
2219 | type = debug_make_void_type (dhandle); | |
2220 | if (pvar != NULL) | |
2221 | pvar->kind = IEEE_LOCAL; | |
2222 | return debug_record_variable (dhandle, namcopy, type, DEBUG_REGISTER, | |
2223 | ieee_regno_to_genreg (info->abfd, v)); | |
2224 | ||
2225 | case 3: | |
2226 | /* Static variable. */ | |
2227 | if (! ieee_require_asn (info, pp, &v)) | |
b34976b6 | 2228 | return FALSE; |
252b5132 RH |
2229 | namcopy = savestring (name, namlen); |
2230 | if (type == NULL) | |
2231 | type = debug_make_void_type (dhandle); | |
2232 | if (info->blockstack.bsp <= info->blockstack.stack) | |
2233 | blocktype = 0; | |
2234 | else | |
2235 | blocktype = info->blockstack.bsp[-1].kind; | |
2236 | if (pvar != NULL) | |
2237 | { | |
2238 | if (blocktype == 4 || blocktype == 6) | |
2239 | pvar->kind = IEEE_LOCAL; | |
2240 | else | |
2241 | pvar->kind = IEEE_STATIC; | |
2242 | } | |
2243 | return debug_record_variable (dhandle, namcopy, type, | |
2244 | (blocktype == 4 || blocktype == 6 | |
2245 | ? DEBUG_LOCAL_STATIC | |
2246 | : DEBUG_STATIC), | |
2247 | v); | |
2248 | ||
2249 | case 4: | |
2250 | /* External function. We don't currently record these. FIXME. */ | |
2251 | if (pvar != NULL) | |
2252 | pvar->kind = IEEE_EXTERNAL; | |
b34976b6 | 2253 | return TRUE; |
252b5132 RH |
2254 | |
2255 | case 5: | |
2256 | /* External variable. We don't currently record these. FIXME. */ | |
2257 | if (pvar != NULL) | |
2258 | pvar->kind = IEEE_EXTERNAL; | |
b34976b6 | 2259 | return TRUE; |
252b5132 RH |
2260 | |
2261 | case 7: | |
2262 | if (! ieee_read_number (info, pp, &v) | |
2263 | || ! ieee_read_number (info, pp, &v2) | |
2264 | || ! ieee_read_optional_number (info, pp, &v3, &present)) | |
b34976b6 | 2265 | return FALSE; |
252b5132 RH |
2266 | if (present) |
2267 | { | |
2268 | if (! ieee_read_optional_number (info, pp, &v4, &present)) | |
b34976b6 | 2269 | return FALSE; |
252b5132 RH |
2270 | } |
2271 | ||
2272 | /* We just ignore the two optional fields in v3 and v4, since | |
2273 | they are not defined. */ | |
2274 | ||
2275 | if (! ieee_require_asn (info, pp, &v3)) | |
b34976b6 | 2276 | return FALSE; |
252b5132 RH |
2277 | |
2278 | /* We have no way to record the column number. FIXME. */ | |
2279 | ||
2280 | return debug_record_line (dhandle, v, v3); | |
2281 | ||
2282 | case 8: | |
2283 | /* Global variable. */ | |
2284 | if (! ieee_require_asn (info, pp, &v)) | |
b34976b6 | 2285 | return FALSE; |
252b5132 RH |
2286 | namcopy = savestring (name, namlen); |
2287 | if (type == NULL) | |
2288 | type = debug_make_void_type (dhandle); | |
2289 | if (pvar != NULL) | |
2290 | pvar->kind = IEEE_GLOBAL; | |
2291 | return debug_record_variable (dhandle, namcopy, type, DEBUG_GLOBAL, v); | |
2292 | ||
2293 | case 9: | |
2294 | /* Variable lifetime information. */ | |
2295 | if (! ieee_read_number (info, pp, &v)) | |
b34976b6 | 2296 | return FALSE; |
252b5132 RH |
2297 | |
2298 | /* We have no way to record this information. FIXME. */ | |
b34976b6 | 2299 | return TRUE; |
252b5132 RH |
2300 | |
2301 | case 10: | |
2302 | /* Locked register. The spec says that there are two required | |
2303 | fields, but at least on occasion the MRI compiler only emits | |
2304 | one. */ | |
2305 | if (! ieee_read_number (info, pp, &v) | |
2306 | || ! ieee_read_optional_number (info, pp, &v2, &present)) | |
b34976b6 | 2307 | return FALSE; |
252b5132 RH |
2308 | |
2309 | /* I think this means a variable that is both in a register and | |
2310 | a frame slot. We ignore the frame slot. FIXME. */ | |
2311 | ||
2312 | namcopy = savestring (name, namlen); | |
2313 | if (type == NULL) | |
2314 | type = debug_make_void_type (dhandle); | |
2315 | if (pvar != NULL) | |
2316 | pvar->kind = IEEE_LOCAL; | |
2317 | return debug_record_variable (dhandle, namcopy, type, DEBUG_REGISTER, v); | |
2318 | ||
2319 | case 11: | |
2320 | /* Reserved for FORTRAN common. */ | |
2321 | ieee_error (info, atn_code_start, _("unsupported ATN11")); | |
2322 | ||
b34976b6 AM |
2323 | /* Return TRUE to keep going. */ |
2324 | return TRUE; | |
252b5132 RH |
2325 | |
2326 | case 12: | |
2327 | /* Based variable. */ | |
2328 | v3 = 0; | |
2329 | v4 = 0x80; | |
2330 | v5 = 0; | |
2331 | if (! ieee_read_number (info, pp, &v) | |
2332 | || ! ieee_read_number (info, pp, &v2) | |
2333 | || ! ieee_read_optional_number (info, pp, &v3, &present)) | |
b34976b6 | 2334 | return FALSE; |
252b5132 RH |
2335 | if (present) |
2336 | { | |
2337 | if (! ieee_read_optional_number (info, pp, &v4, &present)) | |
b34976b6 | 2338 | return FALSE; |
252b5132 RH |
2339 | if (present) |
2340 | { | |
2341 | if (! ieee_read_optional_number (info, pp, &v5, &present)) | |
b34976b6 | 2342 | return FALSE; |
252b5132 RH |
2343 | } |
2344 | } | |
2345 | ||
2346 | /* We have no way to record this information. FIXME. */ | |
2347 | ||
2348 | ieee_error (info, atn_code_start, _("unsupported ATN12")); | |
2349 | ||
b34976b6 AM |
2350 | /* Return TRUE to keep going. */ |
2351 | return TRUE; | |
252b5132 RH |
2352 | |
2353 | case 16: | |
2354 | /* Constant. The description of this that I have is ambiguous, | |
2355 | so I'm not going to try to implement it. */ | |
2356 | if (! ieee_read_number (info, pp, &v) | |
2357 | || ! ieee_read_optional_number (info, pp, &v2, &present)) | |
b34976b6 | 2358 | return FALSE; |
252b5132 RH |
2359 | if (present) |
2360 | { | |
2361 | if (! ieee_read_optional_number (info, pp, &v2, &present)) | |
b34976b6 | 2362 | return FALSE; |
252b5132 RH |
2363 | if (present) |
2364 | { | |
2365 | if (! ieee_read_optional_id (info, pp, &name, &namlen, &present)) | |
b34976b6 | 2366 | return FALSE; |
252b5132 RH |
2367 | } |
2368 | } | |
2369 | ||
2370 | if ((ieee_record_enum_type) **pp == ieee_e2_first_byte_enum) | |
2371 | { | |
2372 | if (! ieee_require_asn (info, pp, &v3)) | |
b34976b6 | 2373 | return FALSE; |
252b5132 RH |
2374 | } |
2375 | ||
b34976b6 | 2376 | return TRUE; |
252b5132 RH |
2377 | |
2378 | case 19: | |
2379 | /* Static variable from assembler. */ | |
2380 | v2 = 0; | |
2381 | if (! ieee_read_number (info, pp, &v) | |
2382 | || ! ieee_read_optional_number (info, pp, &v2, &present) | |
2383 | || ! ieee_require_asn (info, pp, &v3)) | |
b34976b6 | 2384 | return FALSE; |
252b5132 RH |
2385 | namcopy = savestring (name, namlen); |
2386 | /* We don't really handle this correctly. FIXME. */ | |
2387 | return debug_record_variable (dhandle, namcopy, | |
2388 | debug_make_void_type (dhandle), | |
2389 | v2 != 0 ? DEBUG_GLOBAL : DEBUG_STATIC, | |
2390 | v3); | |
2391 | ||
2392 | case 62: | |
2393 | /* Procedure miscellaneous information. */ | |
2394 | case 63: | |
2395 | /* Variable miscellaneous information. */ | |
2396 | case 64: | |
2397 | /* Module miscellaneous information. */ | |
2398 | if (! ieee_read_number (info, pp, &v) | |
2399 | || ! ieee_read_number (info, pp, &v2) | |
2400 | || ! ieee_read_optional_id (info, pp, &name, &namlen, &present)) | |
b34976b6 | 2401 | return FALSE; |
252b5132 RH |
2402 | |
2403 | if (atn_code == 62 && v == 80) | |
2404 | { | |
2405 | if (present) | |
2406 | { | |
2407 | ieee_error (info, atn_code_start, | |
2408 | _("unexpected string in C++ misc")); | |
b34976b6 | 2409 | return FALSE; |
252b5132 RH |
2410 | } |
2411 | return ieee_read_cxx_misc (info, pp, v2); | |
2412 | } | |
2413 | ||
2414 | /* We just ignore all of this stuff. FIXME. */ | |
2415 | ||
2416 | for (; v2 > 0; --v2) | |
2417 | { | |
2418 | switch ((ieee_record_enum_type) **pp) | |
2419 | { | |
2420 | default: | |
2421 | ieee_error (info, *pp, _("bad misc record")); | |
b34976b6 | 2422 | return FALSE; |
252b5132 RH |
2423 | |
2424 | case ieee_at_record_enum: | |
2425 | if (! ieee_require_atn65 (info, pp, &name, &namlen)) | |
b34976b6 | 2426 | return FALSE; |
252b5132 RH |
2427 | break; |
2428 | ||
2429 | case ieee_e2_first_byte_enum: | |
2430 | if (! ieee_require_asn (info, pp, &v3)) | |
b34976b6 | 2431 | return FALSE; |
252b5132 RH |
2432 | break; |
2433 | } | |
2434 | } | |
2435 | ||
b34976b6 | 2436 | return TRUE; |
252b5132 RH |
2437 | } |
2438 | ||
2439 | /*NOTREACHED*/ | |
2440 | } | |
2441 | ||
2442 | /* Handle C++ debugging miscellaneous records. This is called for | |
2443 | procedure miscellaneous records of type 80. */ | |
2444 | ||
b34976b6 | 2445 | static bfd_boolean |
2da42df6 AJ |
2446 | ieee_read_cxx_misc (struct ieee_info *info, const bfd_byte **pp, |
2447 | unsigned long count) | |
252b5132 RH |
2448 | { |
2449 | const bfd_byte *start; | |
2450 | bfd_vma category; | |
2451 | ||
2452 | start = *pp; | |
2453 | ||
2454 | /* Get the category of C++ misc record. */ | |
2455 | if (! ieee_require_asn (info, pp, &category)) | |
b34976b6 | 2456 | return FALSE; |
252b5132 RH |
2457 | --count; |
2458 | ||
2459 | switch (category) | |
2460 | { | |
2461 | default: | |
2462 | ieee_error (info, start, _("unrecognized C++ misc record")); | |
b34976b6 | 2463 | return FALSE; |
252b5132 RH |
2464 | |
2465 | case 'T': | |
2466 | if (! ieee_read_cxx_class (info, pp, count)) | |
b34976b6 | 2467 | return FALSE; |
252b5132 RH |
2468 | break; |
2469 | ||
2470 | case 'M': | |
2471 | { | |
2472 | bfd_vma flags; | |
2473 | const char *name; | |
2474 | unsigned long namlen; | |
2475 | ||
2476 | /* The IEEE spec indicates that the 'M' record only has a | |
2477 | flags field. The MRI compiler also emits the name of the | |
2478 | function. */ | |
2479 | ||
2480 | if (! ieee_require_asn (info, pp, &flags)) | |
b34976b6 | 2481 | return FALSE; |
252b5132 RH |
2482 | if (*pp < info->pend |
2483 | && (ieee_record_enum_type) **pp == ieee_at_record_enum) | |
2484 | { | |
2485 | if (! ieee_require_atn65 (info, pp, &name, &namlen)) | |
b34976b6 | 2486 | return FALSE; |
252b5132 RH |
2487 | } |
2488 | ||
2489 | /* This is emitted for method functions, but I don't think we | |
2490 | care very much. It might help if it told us useful | |
2491 | information like the class with which this function is | |
2492 | associated, but it doesn't, so it isn't helpful. */ | |
2493 | } | |
2494 | break; | |
2495 | ||
2496 | case 'B': | |
2497 | if (! ieee_read_cxx_defaults (info, pp, count)) | |
b34976b6 | 2498 | return FALSE; |
252b5132 RH |
2499 | break; |
2500 | ||
2501 | case 'z': | |
2502 | { | |
2503 | const char *name, *mangled, *class; | |
2504 | unsigned long namlen, mangledlen, classlen; | |
2505 | bfd_vma control; | |
2506 | ||
2507 | /* Pointer to member. */ | |
2508 | ||
2509 | if (! ieee_require_atn65 (info, pp, &name, &namlen) | |
2510 | || ! ieee_require_atn65 (info, pp, &mangled, &mangledlen) | |
2511 | || ! ieee_require_atn65 (info, pp, &class, &classlen) | |
2512 | || ! ieee_require_asn (info, pp, &control)) | |
b34976b6 | 2513 | return FALSE; |
252b5132 RH |
2514 | |
2515 | /* FIXME: We should now track down name and change its type. */ | |
2516 | } | |
2517 | break; | |
2518 | ||
2519 | case 'R': | |
2520 | if (! ieee_read_reference (info, pp)) | |
b34976b6 | 2521 | return FALSE; |
252b5132 RH |
2522 | break; |
2523 | } | |
2524 | ||
b34976b6 | 2525 | return TRUE; |
252b5132 RH |
2526 | } |
2527 | ||
2528 | /* Read a C++ class definition. This is a pmisc type 80 record of | |
2529 | category 'T'. */ | |
2530 | ||
b34976b6 | 2531 | static bfd_boolean |
2da42df6 AJ |
2532 | ieee_read_cxx_class (struct ieee_info *info, const bfd_byte **pp, |
2533 | unsigned long count) | |
252b5132 RH |
2534 | { |
2535 | const bfd_byte *start; | |
2536 | bfd_vma class; | |
2537 | const char *tag; | |
2538 | unsigned long taglen; | |
2539 | struct ieee_tag *it; | |
2da42df6 | 2540 | void *dhandle; |
252b5132 RH |
2541 | debug_field *fields; |
2542 | unsigned int field_count, field_alloc; | |
2543 | debug_baseclass *baseclasses; | |
2544 | unsigned int baseclasses_count, baseclasses_alloc; | |
2545 | const debug_field *structfields; | |
2546 | struct ieee_method | |
2547 | { | |
2548 | const char *name; | |
2549 | unsigned long namlen; | |
2550 | debug_method_variant *variants; | |
2551 | unsigned count; | |
2552 | unsigned int alloc; | |
2553 | } *methods; | |
2554 | unsigned int methods_count, methods_alloc; | |
2555 | debug_type vptrbase; | |
b34976b6 | 2556 | bfd_boolean ownvptr; |
252b5132 RH |
2557 | debug_method *dmethods; |
2558 | ||
2559 | start = *pp; | |
2560 | ||
2561 | if (! ieee_require_asn (info, pp, &class)) | |
b34976b6 | 2562 | return FALSE; |
252b5132 RH |
2563 | --count; |
2564 | ||
2565 | if (! ieee_require_atn65 (info, pp, &tag, &taglen)) | |
b34976b6 | 2566 | return FALSE; |
252b5132 RH |
2567 | --count; |
2568 | ||
2569 | /* Find the C struct with this name. */ | |
2570 | for (it = info->tags; it != NULL; it = it->next) | |
2571 | if (it->name[0] == tag[0] | |
2572 | && strncmp (it->name, tag, taglen) == 0 | |
2573 | && strlen (it->name) == taglen) | |
2574 | break; | |
2575 | if (it == NULL) | |
2576 | { | |
2577 | ieee_error (info, start, _("undefined C++ object")); | |
b34976b6 | 2578 | return FALSE; |
252b5132 RH |
2579 | } |
2580 | ||
2581 | dhandle = info->dhandle; | |
2582 | ||
2583 | fields = NULL; | |
2584 | field_count = 0; | |
2585 | field_alloc = 0; | |
2586 | baseclasses = NULL; | |
2587 | baseclasses_count = 0; | |
2588 | baseclasses_alloc = 0; | |
2589 | methods = NULL; | |
2590 | methods_count = 0; | |
2591 | methods_alloc = 0; | |
2592 | vptrbase = DEBUG_TYPE_NULL; | |
b34976b6 | 2593 | ownvptr = FALSE; |
252b5132 RH |
2594 | |
2595 | structfields = debug_get_fields (dhandle, it->type); | |
2596 | ||
2597 | while (count > 0) | |
2598 | { | |
2599 | bfd_vma id; | |
2600 | const bfd_byte *spec_start; | |
2601 | ||
2602 | spec_start = *pp; | |
2603 | ||
2604 | if (! ieee_require_asn (info, pp, &id)) | |
b34976b6 | 2605 | return FALSE; |
252b5132 RH |
2606 | --count; |
2607 | ||
2608 | switch (id) | |
2609 | { | |
2610 | default: | |
2611 | ieee_error (info, spec_start, _("unrecognized C++ object spec")); | |
b34976b6 | 2612 | return FALSE; |
252b5132 RH |
2613 | |
2614 | case 'b': | |
2615 | { | |
2616 | bfd_vma flags, cinline; | |
2617 | const char *basename, *fieldname; | |
2618 | unsigned long baselen, fieldlen; | |
2619 | char *basecopy; | |
2620 | debug_type basetype; | |
2621 | bfd_vma bitpos; | |
b34976b6 | 2622 | bfd_boolean virtualp; |
252b5132 RH |
2623 | enum debug_visibility visibility; |
2624 | debug_baseclass baseclass; | |
2625 | ||
2626 | /* This represents a base or friend class. */ | |
2627 | ||
2628 | if (! ieee_require_asn (info, pp, &flags) | |
2629 | || ! ieee_require_atn65 (info, pp, &basename, &baselen) | |
2630 | || ! ieee_require_asn (info, pp, &cinline) | |
2631 | || ! ieee_require_atn65 (info, pp, &fieldname, &fieldlen)) | |
b34976b6 | 2632 | return FALSE; |
252b5132 RH |
2633 | count -= 4; |
2634 | ||
2635 | /* We have no way of recording friend information, so we | |
2636 | just ignore it. */ | |
2637 | if ((flags & BASEFLAGS_FRIEND) != 0) | |
2638 | break; | |
2639 | ||
2640 | /* I assume that either all of the members of the | |
2641 | baseclass are included in the object, starting at the | |
2642 | beginning of the object, or that none of them are | |
2643 | included. */ | |
2644 | ||
2645 | if ((fieldlen == 0) == (cinline == 0)) | |
2646 | { | |
2647 | ieee_error (info, start, _("unsupported C++ object type")); | |
b34976b6 | 2648 | return FALSE; |
252b5132 RH |
2649 | } |
2650 | ||
2651 | basecopy = savestring (basename, baselen); | |
2652 | basetype = debug_find_tagged_type (dhandle, basecopy, | |
2653 | DEBUG_KIND_ILLEGAL); | |
2654 | free (basecopy); | |
2655 | if (basetype == DEBUG_TYPE_NULL) | |
2656 | { | |
2657 | ieee_error (info, start, _("C++ base class not defined")); | |
b34976b6 | 2658 | return FALSE; |
252b5132 RH |
2659 | } |
2660 | ||
2661 | if (fieldlen == 0) | |
2662 | bitpos = 0; | |
2663 | else | |
2664 | { | |
2665 | const debug_field *pf; | |
2666 | ||
2667 | if (structfields == NULL) | |
2668 | { | |
2669 | ieee_error (info, start, _("C++ object has no fields")); | |
b34976b6 | 2670 | return FALSE; |
252b5132 RH |
2671 | } |
2672 | ||
2673 | for (pf = structfields; *pf != DEBUG_FIELD_NULL; pf++) | |
2674 | { | |
2675 | const char *fname; | |
2676 | ||
2677 | fname = debug_get_field_name (dhandle, *pf); | |
2678 | if (fname == NULL) | |
b34976b6 | 2679 | return FALSE; |
252b5132 RH |
2680 | if (fname[0] == fieldname[0] |
2681 | && strncmp (fname, fieldname, fieldlen) == 0 | |
2682 | && strlen (fname) == fieldlen) | |
2683 | break; | |
2684 | } | |
2685 | if (*pf == DEBUG_FIELD_NULL) | |
2686 | { | |
2687 | ieee_error (info, start, | |
2688 | _("C++ base class not found in container")); | |
b34976b6 | 2689 | return FALSE; |
252b5132 RH |
2690 | } |
2691 | ||
2692 | bitpos = debug_get_field_bitpos (dhandle, *pf); | |
2693 | } | |
2694 | ||
2695 | if ((flags & BASEFLAGS_VIRTUAL) != 0) | |
b34976b6 | 2696 | virtualp = TRUE; |
252b5132 | 2697 | else |
b34976b6 | 2698 | virtualp = FALSE; |
252b5132 RH |
2699 | if ((flags & BASEFLAGS_PRIVATE) != 0) |
2700 | visibility = DEBUG_VISIBILITY_PRIVATE; | |
2701 | else | |
2702 | visibility = DEBUG_VISIBILITY_PUBLIC; | |
2703 | ||
2704 | baseclass = debug_make_baseclass (dhandle, basetype, bitpos, | |
2705 | virtualp, visibility); | |
2706 | if (baseclass == DEBUG_BASECLASS_NULL) | |
b34976b6 | 2707 | return FALSE; |
252b5132 RH |
2708 | |
2709 | if (baseclasses_count + 1 >= baseclasses_alloc) | |
2710 | { | |
2711 | baseclasses_alloc += 10; | |
2712 | baseclasses = ((debug_baseclass *) | |
2713 | xrealloc (baseclasses, | |
2714 | (baseclasses_alloc | |
2715 | * sizeof *baseclasses))); | |
2716 | } | |
2717 | ||
2718 | baseclasses[baseclasses_count] = baseclass; | |
2719 | ++baseclasses_count; | |
2720 | baseclasses[baseclasses_count] = DEBUG_BASECLASS_NULL; | |
2721 | } | |
2722 | break; | |
2723 | ||
2724 | case 'd': | |
2725 | { | |
2726 | bfd_vma flags; | |
2727 | const char *fieldname, *mangledname; | |
2728 | unsigned long fieldlen, mangledlen; | |
2729 | char *fieldcopy; | |
b34976b6 | 2730 | bfd_boolean staticp; |
252b5132 RH |
2731 | debug_type ftype; |
2732 | const debug_field *pf = NULL; | |
2733 | enum debug_visibility visibility; | |
2734 | debug_field field; | |
2735 | ||
2736 | /* This represents a data member. */ | |
2737 | ||
2738 | if (! ieee_require_asn (info, pp, &flags) | |
2739 | || ! ieee_require_atn65 (info, pp, &fieldname, &fieldlen) | |
2740 | || ! ieee_require_atn65 (info, pp, &mangledname, &mangledlen)) | |
b34976b6 | 2741 | return FALSE; |
252b5132 RH |
2742 | count -= 3; |
2743 | ||
2744 | fieldcopy = savestring (fieldname, fieldlen); | |
2745 | ||
b34976b6 | 2746 | staticp = (flags & CXXFLAGS_STATIC) != 0 ? TRUE : FALSE; |
252b5132 RH |
2747 | |
2748 | if (staticp) | |
2749 | { | |
2750 | struct ieee_var *pv, *pvend; | |
2751 | ||
2752 | /* See if we can find a definition for this variable. */ | |
2753 | pv = info->vars.vars; | |
2754 | pvend = pv + info->vars.alloc; | |
2755 | for (; pv < pvend; pv++) | |
2756 | if (pv->namlen == mangledlen | |
2757 | && strncmp (pv->name, mangledname, mangledlen) == 0) | |
2758 | break; | |
2759 | if (pv < pvend) | |
2760 | ftype = pv->type; | |
2761 | else | |
2762 | { | |
2763 | /* This can happen if the variable is never used. */ | |
2764 | ftype = ieee_builtin_type (info, start, | |
2765 | (unsigned int) builtin_void); | |
2766 | } | |
2767 | } | |
2768 | else | |
2769 | { | |
2770 | unsigned int findx; | |
2771 | ||
2772 | if (structfields == NULL) | |
2773 | { | |
2774 | ieee_error (info, start, _("C++ object has no fields")); | |
b34976b6 | 2775 | return FALSE; |
252b5132 RH |
2776 | } |
2777 | ||
2778 | for (pf = structfields, findx = 0; | |
2779 | *pf != DEBUG_FIELD_NULL; | |
2780 | pf++, findx++) | |
2781 | { | |
2782 | const char *fname; | |
2783 | ||
2784 | fname = debug_get_field_name (dhandle, *pf); | |
2785 | if (fname == NULL) | |
b34976b6 | 2786 | return FALSE; |
252b5132 RH |
2787 | if (fname[0] == mangledname[0] |
2788 | && strncmp (fname, mangledname, mangledlen) == 0 | |
2789 | && strlen (fname) == mangledlen) | |
2790 | break; | |
2791 | } | |
2792 | if (*pf == DEBUG_FIELD_NULL) | |
2793 | { | |
2794 | ieee_error (info, start, | |
2795 | _("C++ data member not found in container")); | |
b34976b6 | 2796 | return FALSE; |
252b5132 RH |
2797 | } |
2798 | ||
2799 | ftype = debug_get_field_type (dhandle, *pf); | |
2800 | ||
2801 | if (debug_get_type_kind (dhandle, ftype) == DEBUG_KIND_POINTER) | |
2802 | { | |
2803 | /* We might need to convert this field into a | |
2804 | reference type later on, so make it an indirect | |
2805 | type. */ | |
2806 | if (it->fslots == NULL) | |
2807 | { | |
2808 | unsigned int fcnt; | |
2809 | const debug_field *pfcnt; | |
2810 | ||
2811 | fcnt = 0; | |
2812 | for (pfcnt = structfields; | |
2813 | *pfcnt != DEBUG_FIELD_NULL; | |
2814 | pfcnt++) | |
2815 | ++fcnt; | |
2816 | it->fslots = ((debug_type *) | |
2817 | xmalloc (fcnt * sizeof *it->fslots)); | |
2818 | memset (it->fslots, 0, | |
2819 | fcnt * sizeof *it->fslots); | |
2820 | } | |
2821 | ||
2822 | if (ftype == DEBUG_TYPE_NULL) | |
b34976b6 | 2823 | return FALSE; |
252b5132 RH |
2824 | it->fslots[findx] = ftype; |
2825 | ftype = debug_make_indirect_type (dhandle, | |
2826 | it->fslots + findx, | |
2827 | (const char *) NULL); | |
2828 | } | |
2829 | } | |
2830 | if (ftype == DEBUG_TYPE_NULL) | |
b34976b6 | 2831 | return FALSE; |
252b5132 RH |
2832 | |
2833 | switch (flags & CXXFLAGS_VISIBILITY) | |
2834 | { | |
2835 | default: | |
2836 | ieee_error (info, start, _("unknown C++ visibility")); | |
b34976b6 | 2837 | return FALSE; |
252b5132 RH |
2838 | |
2839 | case CXXFLAGS_VISIBILITY_PUBLIC: | |
2840 | visibility = DEBUG_VISIBILITY_PUBLIC; | |
2841 | break; | |
2842 | ||
2843 | case CXXFLAGS_VISIBILITY_PRIVATE: | |
2844 | visibility = DEBUG_VISIBILITY_PRIVATE; | |
2845 | break; | |
2846 | ||
2847 | case CXXFLAGS_VISIBILITY_PROTECTED: | |
2848 | visibility = DEBUG_VISIBILITY_PROTECTED; | |
2849 | break; | |
2850 | } | |
2851 | ||
2852 | if (staticp) | |
2853 | { | |
2854 | char *mangledcopy; | |
2855 | ||
2856 | mangledcopy = savestring (mangledname, mangledlen); | |
2857 | ||
2858 | field = debug_make_static_member (dhandle, fieldcopy, | |
2859 | ftype, mangledcopy, | |
2860 | visibility); | |
2861 | } | |
2862 | else | |
2863 | { | |
2864 | bfd_vma bitpos, bitsize; | |
2865 | ||
2866 | bitpos = debug_get_field_bitpos (dhandle, *pf); | |
2867 | bitsize = debug_get_field_bitsize (dhandle, *pf); | |
2868 | if (bitpos == (bfd_vma) -1 || bitsize == (bfd_vma) -1) | |
2869 | { | |
2870 | ieee_error (info, start, _("bad C++ field bit pos or size")); | |
b34976b6 | 2871 | return FALSE; |
252b5132 RH |
2872 | } |
2873 | field = debug_make_field (dhandle, fieldcopy, ftype, bitpos, | |
2874 | bitsize, visibility); | |
2875 | } | |
2876 | ||
2877 | if (field == DEBUG_FIELD_NULL) | |
b34976b6 | 2878 | return FALSE; |
252b5132 RH |
2879 | |
2880 | if (field_count + 1 >= field_alloc) | |
2881 | { | |
2882 | field_alloc += 10; | |
2883 | fields = ((debug_field *) | |
2884 | xrealloc (fields, field_alloc * sizeof *fields)); | |
2885 | } | |
2886 | ||
2887 | fields[field_count] = field; | |
2888 | ++field_count; | |
2889 | fields[field_count] = DEBUG_FIELD_NULL; | |
2890 | } | |
2891 | break; | |
2892 | ||
2893 | case 'm': | |
2894 | case 'v': | |
2895 | { | |
2896 | bfd_vma flags, voffset, control; | |
2897 | const char *name, *mangled; | |
2898 | unsigned long namlen, mangledlen; | |
2899 | struct ieee_var *pv, *pvend; | |
2900 | debug_type type; | |
2901 | enum debug_visibility visibility; | |
b34976b6 | 2902 | bfd_boolean constp, volatilep; |
252b5132 RH |
2903 | char *mangledcopy; |
2904 | debug_method_variant mv; | |
2905 | struct ieee_method *meth; | |
2906 | unsigned int im; | |
2907 | ||
2908 | if (! ieee_require_asn (info, pp, &flags) | |
2909 | || ! ieee_require_atn65 (info, pp, &name, &namlen) | |
2910 | || ! ieee_require_atn65 (info, pp, &mangled, &mangledlen)) | |
b34976b6 | 2911 | return FALSE; |
252b5132 RH |
2912 | count -= 3; |
2913 | if (id != 'v') | |
2914 | voffset = 0; | |
2915 | else | |
2916 | { | |
2917 | if (! ieee_require_asn (info, pp, &voffset)) | |
b34976b6 | 2918 | return FALSE; |
252b5132 RH |
2919 | --count; |
2920 | } | |
2921 | if (! ieee_require_asn (info, pp, &control)) | |
b34976b6 | 2922 | return FALSE; |
252b5132 RH |
2923 | --count; |
2924 | ||
2925 | /* We just ignore the control information. */ | |
2926 | ||
2927 | /* We have no way to represent friend information, so we | |
2928 | just ignore it. */ | |
2929 | if ((flags & CXXFLAGS_FRIEND) != 0) | |
2930 | break; | |
2931 | ||
2932 | /* We should already have seen a type for the function. */ | |
2933 | pv = info->vars.vars; | |
2934 | pvend = pv + info->vars.alloc; | |
2935 | for (; pv < pvend; pv++) | |
2936 | if (pv->namlen == mangledlen | |
2937 | && strncmp (pv->name, mangled, mangledlen) == 0) | |
2938 | break; | |
2939 | ||
2940 | if (pv >= pvend) | |
2941 | { | |
2942 | /* We won't have type information for this function if | |
2943 | it is not included in this file. We don't try to | |
2944 | handle this case. FIXME. */ | |
2945 | type = (debug_make_function_type | |
2946 | (dhandle, | |
2947 | ieee_builtin_type (info, start, | |
2948 | (unsigned int) builtin_void), | |
2949 | (debug_type *) NULL, | |
b34976b6 | 2950 | FALSE)); |
252b5132 RH |
2951 | } |
2952 | else | |
2953 | { | |
2954 | debug_type return_type; | |
2955 | const debug_type *arg_types; | |
b34976b6 | 2956 | bfd_boolean varargs; |
252b5132 RH |
2957 | |
2958 | if (debug_get_type_kind (dhandle, pv->type) | |
2959 | != DEBUG_KIND_FUNCTION) | |
2960 | { | |
2961 | ieee_error (info, start, | |
2962 | _("bad type for C++ method function")); | |
b34976b6 | 2963 | return FALSE; |
252b5132 RH |
2964 | } |
2965 | ||
2966 | return_type = debug_get_return_type (dhandle, pv->type); | |
2967 | arg_types = debug_get_parameter_types (dhandle, pv->type, | |
2968 | &varargs); | |
2969 | if (return_type == DEBUG_TYPE_NULL || arg_types == NULL) | |
2970 | { | |
2971 | ieee_error (info, start, | |
2972 | _("no type information for C++ method function")); | |
b34976b6 | 2973 | return FALSE; |
252b5132 RH |
2974 | } |
2975 | ||
2976 | type = debug_make_method_type (dhandle, return_type, it->type, | |
2977 | (debug_type *) arg_types, | |
2978 | varargs); | |
2979 | } | |
2980 | if (type == DEBUG_TYPE_NULL) | |
b34976b6 | 2981 | return FALSE; |
252b5132 RH |
2982 | |
2983 | switch (flags & CXXFLAGS_VISIBILITY) | |
2984 | { | |
2985 | default: | |
2986 | ieee_error (info, start, _("unknown C++ visibility")); | |
b34976b6 | 2987 | return FALSE; |
252b5132 RH |
2988 | |
2989 | case CXXFLAGS_VISIBILITY_PUBLIC: | |
2990 | visibility = DEBUG_VISIBILITY_PUBLIC; | |
2991 | break; | |
2992 | ||
2993 | case CXXFLAGS_VISIBILITY_PRIVATE: | |
2994 | visibility = DEBUG_VISIBILITY_PRIVATE; | |
2995 | break; | |
2996 | ||
2997 | case CXXFLAGS_VISIBILITY_PROTECTED: | |
2998 | visibility = DEBUG_VISIBILITY_PROTECTED; | |
2999 | break; | |
3000 | } | |
3001 | ||
b34976b6 AM |
3002 | constp = (flags & CXXFLAGS_CONST) != 0 ? TRUE : FALSE; |
3003 | volatilep = (flags & CXXFLAGS_VOLATILE) != 0 ? TRUE : FALSE; | |
252b5132 RH |
3004 | |
3005 | mangledcopy = savestring (mangled, mangledlen); | |
3006 | ||
3007 | if ((flags & CXXFLAGS_STATIC) != 0) | |
3008 | { | |
3009 | if (id == 'v') | |
3010 | { | |
3011 | ieee_error (info, start, _("C++ static virtual method")); | |
b34976b6 | 3012 | return FALSE; |
252b5132 RH |
3013 | } |
3014 | mv = debug_make_static_method_variant (dhandle, mangledcopy, | |
3015 | type, visibility, | |
3016 | constp, volatilep); | |
3017 | } | |
3018 | else | |
3019 | { | |
3020 | debug_type vcontext; | |
3021 | ||
3022 | if (id != 'v') | |
3023 | vcontext = DEBUG_TYPE_NULL; | |
3024 | else | |
3025 | { | |
3026 | /* FIXME: How can we calculate this correctly? */ | |
3027 | vcontext = it->type; | |
3028 | } | |
3029 | mv = debug_make_method_variant (dhandle, mangledcopy, type, | |
3030 | visibility, constp, | |
3031 | volatilep, voffset, | |
3032 | vcontext); | |
3033 | } | |
3034 | if (mv == DEBUG_METHOD_VARIANT_NULL) | |
b34976b6 | 3035 | return FALSE; |
252b5132 RH |
3036 | |
3037 | for (meth = methods, im = 0; im < methods_count; meth++, im++) | |
3038 | if (meth->namlen == namlen | |
3039 | && strncmp (meth->name, name, namlen) == 0) | |
3040 | break; | |
3041 | if (im >= methods_count) | |
3042 | { | |
3043 | if (methods_count >= methods_alloc) | |
3044 | { | |
3045 | methods_alloc += 10; | |
3046 | methods = ((struct ieee_method *) | |
3047 | xrealloc (methods, | |
3048 | methods_alloc * sizeof *methods)); | |
3049 | } | |
3050 | methods[methods_count].name = name; | |
3051 | methods[methods_count].namlen = namlen; | |
3052 | methods[methods_count].variants = NULL; | |
3053 | methods[methods_count].count = 0; | |
3054 | methods[methods_count].alloc = 0; | |
3055 | meth = methods + methods_count; | |
3056 | ++methods_count; | |
3057 | } | |
3058 | ||
3059 | if (meth->count + 1 >= meth->alloc) | |
3060 | { | |
3061 | meth->alloc += 10; | |
3062 | meth->variants = ((debug_method_variant *) | |
3063 | xrealloc (meth->variants, | |
3064 | (meth->alloc | |
3065 | * sizeof *meth->variants))); | |
3066 | } | |
3067 | ||
3068 | meth->variants[meth->count] = mv; | |
3069 | ++meth->count; | |
3070 | meth->variants[meth->count] = DEBUG_METHOD_VARIANT_NULL; | |
3071 | } | |
3072 | break; | |
3073 | ||
3074 | case 'o': | |
3075 | { | |
3076 | bfd_vma spec; | |
3077 | ||
3078 | /* We have no way to store this information, so we just | |
3079 | ignore it. */ | |
3080 | if (! ieee_require_asn (info, pp, &spec)) | |
b34976b6 | 3081 | return FALSE; |
252b5132 RH |
3082 | --count; |
3083 | if ((spec & 4) != 0) | |
3084 | { | |
3085 | const char *filename; | |
3086 | unsigned long filenamlen; | |
3087 | bfd_vma lineno; | |
3088 | ||
3089 | if (! ieee_require_atn65 (info, pp, &filename, &filenamlen) | |
3090 | || ! ieee_require_asn (info, pp, &lineno)) | |
b34976b6 | 3091 | return FALSE; |
252b5132 RH |
3092 | count -= 2; |
3093 | } | |
3094 | else if ((spec & 8) != 0) | |
3095 | { | |
3096 | const char *mangled; | |
3097 | unsigned long mangledlen; | |
3098 | ||
3099 | if (! ieee_require_atn65 (info, pp, &mangled, &mangledlen)) | |
b34976b6 | 3100 | return FALSE; |
252b5132 RH |
3101 | --count; |
3102 | } | |
3103 | else | |
3104 | { | |
3105 | ieee_error (info, start, | |
3106 | _("unrecognized C++ object overhead spec")); | |
b34976b6 | 3107 | return FALSE; |
252b5132 RH |
3108 | } |
3109 | } | |
3110 | break; | |
3111 | ||
3112 | case 'z': | |
3113 | { | |
3114 | const char *vname, *basename; | |
3115 | unsigned long vnamelen, baselen; | |
3116 | bfd_vma vsize, control; | |
3117 | ||
3118 | /* A virtual table pointer. */ | |
3119 | ||
3120 | if (! ieee_require_atn65 (info, pp, &vname, &vnamelen) | |
3121 | || ! ieee_require_asn (info, pp, &vsize) | |
3122 | || ! ieee_require_atn65 (info, pp, &basename, &baselen) | |
3123 | || ! ieee_require_asn (info, pp, &control)) | |
b34976b6 | 3124 | return FALSE; |
252b5132 RH |
3125 | count -= 4; |
3126 | ||
3127 | /* We just ignore the control number. We don't care what | |
3128 | the virtual table name is. We have no way to store the | |
3129 | virtual table size, and I don't think we care anyhow. */ | |
3130 | ||
3131 | /* FIXME: We can't handle multiple virtual table pointers. */ | |
3132 | ||
3133 | if (baselen == 0) | |
b34976b6 | 3134 | ownvptr = TRUE; |
252b5132 RH |
3135 | else |
3136 | { | |
3137 | char *basecopy; | |
3138 | ||
3139 | basecopy = savestring (basename, baselen); | |
3140 | vptrbase = debug_find_tagged_type (dhandle, basecopy, | |
3141 | DEBUG_KIND_ILLEGAL); | |
3142 | free (basecopy); | |
3143 | if (vptrbase == DEBUG_TYPE_NULL) | |
3144 | { | |
3145 | ieee_error (info, start, _("undefined C++ vtable")); | |
b34976b6 | 3146 | return FALSE; |
252b5132 RH |
3147 | } |
3148 | } | |
3149 | } | |
3150 | break; | |
3151 | } | |
3152 | } | |
3153 | ||
3154 | /* Now that we have seen all the method variants, we can call | |
3155 | debug_make_method for each one. */ | |
3156 | ||
3157 | if (methods_count == 0) | |
3158 | dmethods = NULL; | |
3159 | else | |
3160 | { | |
3161 | unsigned int i; | |
3162 | ||
3163 | dmethods = ((debug_method *) | |
3164 | xmalloc ((methods_count + 1) * sizeof *dmethods)); | |
3165 | for (i = 0; i < methods_count; i++) | |
3166 | { | |
3167 | char *namcopy; | |
3168 | ||
3169 | namcopy = savestring (methods[i].name, methods[i].namlen); | |
3170 | dmethods[i] = debug_make_method (dhandle, namcopy, | |
3171 | methods[i].variants); | |
3172 | if (dmethods[i] == DEBUG_METHOD_NULL) | |
b34976b6 | 3173 | return FALSE; |
252b5132 RH |
3174 | } |
3175 | dmethods[i] = DEBUG_METHOD_NULL; | |
3176 | free (methods); | |
3177 | } | |
3178 | ||
3179 | /* The struct type was created as an indirect type pointing at | |
3180 | it->slot. We update it->slot to automatically update all | |
3181 | references to this struct. */ | |
3182 | it->slot = debug_make_object_type (dhandle, | |
3183 | class != 'u', | |
3184 | debug_get_type_size (dhandle, | |
3185 | it->slot), | |
3186 | fields, baseclasses, dmethods, | |
3187 | vptrbase, ownvptr); | |
3188 | if (it->slot == DEBUG_TYPE_NULL) | |
b34976b6 | 3189 | return FALSE; |
252b5132 | 3190 | |
b34976b6 | 3191 | return TRUE; |
252b5132 RH |
3192 | } |
3193 | ||
3194 | /* Read C++ default argument value and reference type information. */ | |
3195 | ||
b34976b6 | 3196 | static bfd_boolean |
2da42df6 AJ |
3197 | ieee_read_cxx_defaults (struct ieee_info *info, const bfd_byte **pp, |
3198 | unsigned long count) | |
252b5132 RH |
3199 | { |
3200 | const bfd_byte *start; | |
3201 | const char *fnname; | |
3202 | unsigned long fnlen; | |
3203 | bfd_vma defcount; | |
3204 | ||
3205 | start = *pp; | |
3206 | ||
3207 | /* Giving the function name before the argument count is an addendum | |
3208 | to the spec. The function name is demangled, though, so this | |
3209 | record must always refer to the current function. */ | |
3210 | ||
3211 | if (info->blockstack.bsp <= info->blockstack.stack | |
3212 | || info->blockstack.bsp[-1].fnindx == (unsigned int) -1) | |
3213 | { | |
3214 | ieee_error (info, start, _("C++ default values not in a function")); | |
b34976b6 | 3215 | return FALSE; |
252b5132 RH |
3216 | } |
3217 | ||
3218 | if (! ieee_require_atn65 (info, pp, &fnname, &fnlen) | |
3219 | || ! ieee_require_asn (info, pp, &defcount)) | |
b34976b6 | 3220 | return FALSE; |
252b5132 RH |
3221 | count -= 2; |
3222 | ||
3223 | while (defcount-- > 0) | |
3224 | { | |
3225 | bfd_vma type, val; | |
3226 | const char *strval; | |
3227 | unsigned long strvallen; | |
3228 | ||
3229 | if (! ieee_require_asn (info, pp, &type)) | |
b34976b6 | 3230 | return FALSE; |
252b5132 RH |
3231 | --count; |
3232 | ||
3233 | switch (type) | |
3234 | { | |
3235 | case 0: | |
3236 | case 4: | |
3237 | break; | |
3238 | ||
3239 | case 1: | |
3240 | case 2: | |
3241 | if (! ieee_require_asn (info, pp, &val)) | |
b34976b6 | 3242 | return FALSE; |
252b5132 RH |
3243 | --count; |
3244 | break; | |
3245 | ||
3246 | case 3: | |
3247 | case 7: | |
3248 | if (! ieee_require_atn65 (info, pp, &strval, &strvallen)) | |
b34976b6 | 3249 | return FALSE; |
252b5132 RH |
3250 | --count; |
3251 | break; | |
3252 | ||
3253 | default: | |
3254 | ieee_error (info, start, _("unrecognized C++ default type")); | |
b34976b6 | 3255 | return FALSE; |
252b5132 RH |
3256 | } |
3257 | ||
3258 | /* We have no way to record the default argument values, so we | |
3259 | just ignore them. FIXME. */ | |
3260 | } | |
3261 | ||
3262 | /* Any remaining arguments are indices of parameters that are really | |
3263 | reference type. */ | |
3264 | if (count > 0) | |
3265 | { | |
2da42df6 | 3266 | void *dhandle; |
252b5132 RH |
3267 | debug_type *arg_slots; |
3268 | ||
3269 | dhandle = info->dhandle; | |
3270 | arg_slots = info->types.types[info->blockstack.bsp[-1].fnindx].arg_slots; | |
3271 | while (count-- > 0) | |
3272 | { | |
3273 | bfd_vma indx; | |
3274 | debug_type target; | |
3275 | ||
3276 | if (! ieee_require_asn (info, pp, &indx)) | |
b34976b6 | 3277 | return FALSE; |
252b5132 RH |
3278 | /* The index is 1 based. */ |
3279 | --indx; | |
3280 | if (arg_slots == NULL | |
3281 | || arg_slots[indx] == DEBUG_TYPE_NULL | |
3282 | || (debug_get_type_kind (dhandle, arg_slots[indx]) | |
3283 | != DEBUG_KIND_POINTER)) | |
3284 | { | |
3285 | ieee_error (info, start, _("reference parameter is not a pointer")); | |
b34976b6 | 3286 | return FALSE; |
252b5132 RH |
3287 | } |
3288 | ||
3289 | target = debug_get_target_type (dhandle, arg_slots[indx]); | |
3290 | arg_slots[indx] = debug_make_reference_type (dhandle, target); | |
3291 | if (arg_slots[indx] == DEBUG_TYPE_NULL) | |
b34976b6 | 3292 | return FALSE; |
252b5132 RH |
3293 | } |
3294 | } | |
3295 | ||
b34976b6 | 3296 | return TRUE; |
252b5132 RH |
3297 | } |
3298 | ||
3299 | /* Read a C++ reference definition. */ | |
3300 | ||
b34976b6 | 3301 | static bfd_boolean |
2da42df6 | 3302 | ieee_read_reference (struct ieee_info *info, const bfd_byte **pp) |
252b5132 RH |
3303 | { |
3304 | const bfd_byte *start; | |
3305 | bfd_vma flags; | |
3306 | const char *class, *name; | |
3307 | unsigned long classlen, namlen; | |
3308 | debug_type *pslot; | |
3309 | debug_type target; | |
3310 | ||
3311 | start = *pp; | |
3312 | ||
3313 | if (! ieee_require_asn (info, pp, &flags)) | |
b34976b6 | 3314 | return FALSE; |
252b5132 RH |
3315 | |
3316 | /* Giving the class name before the member name is in an addendum to | |
3317 | the spec. */ | |
3318 | if (flags == 3) | |
3319 | { | |
3320 | if (! ieee_require_atn65 (info, pp, &class, &classlen)) | |
b34976b6 | 3321 | return FALSE; |
252b5132 RH |
3322 | } |
3323 | ||
3324 | if (! ieee_require_atn65 (info, pp, &name, &namlen)) | |
b34976b6 | 3325 | return FALSE; |
252b5132 RH |
3326 | |
3327 | pslot = NULL; | |
3328 | if (flags != 3) | |
3329 | { | |
3330 | int pass; | |
3331 | ||
3332 | /* We search from the last variable indices to the first in | |
3333 | hopes of finding local variables correctly. We search the | |
3334 | local variables on the first pass, and the global variables | |
3335 | on the second. FIXME: This probably won't work in all cases. | |
3336 | On the other hand, I don't know what will. */ | |
3337 | for (pass = 0; pass < 2; pass++) | |
3338 | { | |
3339 | struct ieee_vars *vars; | |
3340 | int i; | |
3341 | struct ieee_var *pv = NULL; | |
3342 | ||
3343 | if (pass == 0) | |
3344 | vars = &info->vars; | |
3345 | else | |
3346 | { | |
3347 | vars = info->global_vars; | |
3348 | if (vars == NULL) | |
3349 | break; | |
3350 | } | |
3351 | ||
3352 | for (i = (int) vars->alloc - 1; i >= 0; i--) | |
3353 | { | |
b34976b6 | 3354 | bfd_boolean found; |
252b5132 RH |
3355 | |
3356 | pv = vars->vars + i; | |
3357 | ||
3358 | if (pv->pslot == NULL | |
3359 | || pv->namlen != namlen | |
3360 | || strncmp (pv->name, name, namlen) != 0) | |
3361 | continue; | |
3362 | ||
b34976b6 | 3363 | found = FALSE; |
252b5132 RH |
3364 | switch (flags) |
3365 | { | |
3366 | default: | |
3367 | ieee_error (info, start, | |
3368 | _("unrecognized C++ reference type")); | |
b34976b6 | 3369 | return FALSE; |
252b5132 RH |
3370 | |
3371 | case 0: | |
3372 | /* Global variable or function. */ | |
3373 | if (pv->kind == IEEE_GLOBAL | |
3374 | || pv->kind == IEEE_EXTERNAL | |
3375 | || pv->kind == IEEE_FUNCTION) | |
b34976b6 | 3376 | found = TRUE; |
252b5132 RH |
3377 | break; |
3378 | ||
3379 | case 1: | |
3380 | /* Global static variable or function. */ | |
3381 | if (pv->kind == IEEE_STATIC | |
3382 | || pv->kind == IEEE_FUNCTION) | |
b34976b6 | 3383 | found = TRUE; |
252b5132 RH |
3384 | break; |
3385 | ||
3386 | case 2: | |
3387 | /* Local variable. */ | |
3388 | if (pv->kind == IEEE_LOCAL) | |
b34976b6 | 3389 | found = TRUE; |
252b5132 RH |
3390 | break; |
3391 | } | |
3392 | ||
3393 | if (found) | |
3394 | break; | |
3395 | } | |
3396 | ||
3397 | if (i >= 0) | |
3398 | { | |
3399 | pslot = pv->pslot; | |
3400 | break; | |
3401 | } | |
3402 | } | |
3403 | } | |
3404 | else | |
3405 | { | |
3406 | struct ieee_tag *it; | |
3407 | ||
3408 | for (it = info->tags; it != NULL; it = it->next) | |
3409 | { | |
3410 | if (it->name[0] == class[0] | |
3411 | && strncmp (it->name, class, classlen) == 0 | |
3412 | && strlen (it->name) == classlen) | |
3413 | { | |
3414 | if (it->fslots != NULL) | |
3415 | { | |
3416 | const debug_field *pf; | |
3417 | unsigned int findx; | |
3418 | ||
3419 | pf = debug_get_fields (info->dhandle, it->type); | |
3420 | if (pf == NULL) | |
3421 | { | |
3422 | ieee_error (info, start, | |
3423 | "C++ reference in class with no fields"); | |
b34976b6 | 3424 | return FALSE; |
252b5132 RH |
3425 | } |
3426 | ||
3427 | for (findx = 0; *pf != DEBUG_FIELD_NULL; pf++, findx++) | |
3428 | { | |
3429 | const char *fname; | |
3430 | ||
3431 | fname = debug_get_field_name (info->dhandle, *pf); | |
3432 | if (fname == NULL) | |
b34976b6 | 3433 | return FALSE; |
252b5132 RH |
3434 | if (strncmp (fname, name, namlen) == 0 |
3435 | && strlen (fname) == namlen) | |
3436 | { | |
3437 | pslot = it->fslots + findx; | |
3438 | break; | |
3439 | } | |
3440 | } | |
3441 | } | |
3442 | ||
3443 | break; | |
3444 | } | |
3445 | } | |
3446 | } | |
3447 | ||
3448 | if (pslot == NULL) | |
3449 | { | |
3450 | ieee_error (info, start, _("C++ reference not found")); | |
b34976b6 | 3451 | return FALSE; |
252b5132 RH |
3452 | } |
3453 | ||
3454 | /* We allocated the type of the object as an indirect type pointing | |
3455 | to *pslot, which we can now update to be a reference type. */ | |
3456 | if (debug_get_type_kind (info->dhandle, *pslot) != DEBUG_KIND_POINTER) | |
3457 | { | |
3458 | ieee_error (info, start, _("C++ reference is not pointer")); | |
b34976b6 | 3459 | return FALSE; |
252b5132 RH |
3460 | } |
3461 | ||
3462 | target = debug_get_target_type (info->dhandle, *pslot); | |
3463 | *pslot = debug_make_reference_type (info->dhandle, target); | |
3464 | if (*pslot == DEBUG_TYPE_NULL) | |
b34976b6 | 3465 | return FALSE; |
252b5132 | 3466 | |
b34976b6 | 3467 | return TRUE; |
252b5132 RH |
3468 | } |
3469 | ||
3470 | /* Require an ASN record. */ | |
3471 | ||
b34976b6 | 3472 | static bfd_boolean |
2da42df6 | 3473 | ieee_require_asn (struct ieee_info *info, const bfd_byte **pp, bfd_vma *pv) |
252b5132 RH |
3474 | { |
3475 | const bfd_byte *start; | |
3476 | ieee_record_enum_type c; | |
3477 | bfd_vma varindx; | |
3478 | ||
3479 | start = *pp; | |
3480 | ||
3481 | c = (ieee_record_enum_type) **pp; | |
3482 | if (c != ieee_e2_first_byte_enum) | |
3483 | { | |
3484 | ieee_error (info, start, _("missing required ASN")); | |
b34976b6 | 3485 | return FALSE; |
252b5132 RH |
3486 | } |
3487 | ++*pp; | |
3488 | ||
3489 | c = (ieee_record_enum_type) (((unsigned int) c << 8) | **pp); | |
3490 | if (c != ieee_asn_record_enum) | |
3491 | { | |
3492 | ieee_error (info, start, _("missing required ASN")); | |
b34976b6 | 3493 | return FALSE; |
252b5132 RH |
3494 | } |
3495 | ++*pp; | |
3496 | ||
3497 | /* Just ignore the variable index. */ | |
3498 | if (! ieee_read_number (info, pp, &varindx)) | |
b34976b6 | 3499 | return FALSE; |
252b5132 RH |
3500 | |
3501 | return ieee_read_expression (info, pp, pv); | |
3502 | } | |
3503 | ||
3504 | /* Require an ATN65 record. */ | |
3505 | ||
b34976b6 | 3506 | static bfd_boolean |
2da42df6 AJ |
3507 | ieee_require_atn65 (struct ieee_info *info, const bfd_byte **pp, |
3508 | const char **pname, unsigned long *pnamlen) | |
252b5132 RH |
3509 | { |
3510 | const bfd_byte *start; | |
3511 | ieee_record_enum_type c; | |
3512 | bfd_vma name_indx, type_indx, atn_code; | |
3513 | ||
3514 | start = *pp; | |
3515 | ||
3516 | c = (ieee_record_enum_type) **pp; | |
3517 | if (c != ieee_at_record_enum) | |
3518 | { | |
3519 | ieee_error (info, start, _("missing required ATN65")); | |
b34976b6 | 3520 | return FALSE; |
252b5132 RH |
3521 | } |
3522 | ++*pp; | |
3523 | ||
3524 | c = (ieee_record_enum_type) (((unsigned int) c << 8) | **pp); | |
3525 | if (c != ieee_atn_record_enum) | |
3526 | { | |
3527 | ieee_error (info, start, _("missing required ATN65")); | |
b34976b6 | 3528 | return FALSE; |
252b5132 RH |
3529 | } |
3530 | ++*pp; | |
3531 | ||
3532 | if (! ieee_read_number (info, pp, &name_indx) | |
3533 | || ! ieee_read_number (info, pp, &type_indx) | |
3534 | || ! ieee_read_number (info, pp, &atn_code)) | |
b34976b6 | 3535 | return FALSE; |
252b5132 RH |
3536 | |
3537 | /* Just ignore name_indx. */ | |
3538 | ||
3539 | if (type_indx != 0 || atn_code != 65) | |
3540 | { | |
3541 | ieee_error (info, start, _("bad ATN65 record")); | |
b34976b6 | 3542 | return FALSE; |
252b5132 RH |
3543 | } |
3544 | ||
3545 | return ieee_read_id (info, pp, pname, pnamlen); | |
3546 | } | |
3547 | \f | |
3548 | /* Convert a register number in IEEE debugging information into a | |
3549 | generic register number. */ | |
3550 | ||
3551 | static int | |
2da42df6 | 3552 | ieee_regno_to_genreg (bfd *abfd, int r) |
252b5132 RH |
3553 | { |
3554 | switch (bfd_get_arch (abfd)) | |
3555 | { | |
3556 | case bfd_arch_m68k: | |
3557 | /* For some reasons stabs adds 2 to the floating point register | |
3558 | numbers. */ | |
3559 | if (r >= 16) | |
3560 | r += 2; | |
3561 | break; | |
3562 | ||
3563 | case bfd_arch_i960: | |
3564 | /* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and | |
3565 | 32 to 35 for fp0 to fp3. */ | |
3566 | --r; | |
3567 | break; | |
3568 | ||
3569 | default: | |
3570 | break; | |
3571 | } | |
3572 | ||
3573 | return r; | |
3574 | } | |
3575 | ||
3576 | /* Convert a generic register number to an IEEE specific one. */ | |
3577 | ||
3578 | static int | |
2da42df6 | 3579 | ieee_genreg_to_regno (bfd *abfd, int r) |
252b5132 RH |
3580 | { |
3581 | switch (bfd_get_arch (abfd)) | |
3582 | { | |
3583 | case bfd_arch_m68k: | |
3584 | /* For some reason stabs add 2 to the floating point register | |
3585 | numbers. */ | |
3586 | if (r >= 18) | |
3587 | r -= 2; | |
3588 | break; | |
3589 | ||
3590 | case bfd_arch_i960: | |
3591 | /* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and | |
3592 | 32 to 35 for fp0 to fp3. */ | |
3593 | ++r; | |
3594 | break; | |
3595 | ||
3596 | default: | |
3597 | break; | |
3598 | } | |
3599 | ||
3600 | return r; | |
3601 | } | |
3602 | \f | |
3603 | /* These routines build IEEE debugging information out of the generic | |
3604 | debugging information. */ | |
3605 | ||
3606 | /* We build the IEEE debugging information byte by byte. Rather than | |
3607 | waste time copying data around, we use a linked list of buffers to | |
3608 | hold the data. */ | |
3609 | ||
3610 | #define IEEE_BUFSIZE (490) | |
3611 | ||
3612 | struct ieee_buf | |
3613 | { | |
3614 | /* Next buffer. */ | |
3615 | struct ieee_buf *next; | |
3616 | /* Number of data bytes in this buffer. */ | |
3617 | unsigned int c; | |
3618 | /* Bytes. */ | |
3619 | bfd_byte buf[IEEE_BUFSIZE]; | |
3620 | }; | |
3621 | ||
3622 | /* A list of buffers. */ | |
3623 | ||
3624 | struct ieee_buflist | |
3625 | { | |
3626 | /* Head of list. */ | |
3627 | struct ieee_buf *head; | |
3628 | /* Tail--last buffer on list. */ | |
3629 | struct ieee_buf *tail; | |
3630 | }; | |
3631 | ||
3632 | /* In order to generate the BB11 blocks required by the HP emulator, | |
3633 | we keep track of ranges of addresses which correspond to a given | |
3634 | compilation unit. */ | |
3635 | ||
3636 | struct ieee_range | |
3637 | { | |
3638 | /* Next range. */ | |
3639 | struct ieee_range *next; | |
3640 | /* Low address. */ | |
3641 | bfd_vma low; | |
3642 | /* High address. */ | |
3643 | bfd_vma high; | |
3644 | }; | |
3645 | ||
3646 | /* This structure holds information for a class on the type stack. */ | |
3647 | ||
3648 | struct ieee_type_class | |
3649 | { | |
3650 | /* The name index in the debugging information. */ | |
3651 | unsigned int indx; | |
3652 | /* The pmisc records for the class. */ | |
3653 | struct ieee_buflist pmiscbuf; | |
3654 | /* The number of pmisc records. */ | |
3655 | unsigned int pmisccount; | |
3656 | /* The name of the class holding the virtual table, if not this | |
3657 | class. */ | |
3658 | const char *vclass; | |
3659 | /* Whether this class holds its own virtual table. */ | |
b34976b6 | 3660 | bfd_boolean ownvptr; |
252b5132 RH |
3661 | /* The largest virtual table offset seen so far. */ |
3662 | bfd_vma voffset; | |
3663 | /* The current method. */ | |
3664 | const char *method; | |
3665 | /* Additional pmisc records used to record fields of reference type. */ | |
3666 | struct ieee_buflist refs; | |
3667 | }; | |
3668 | ||
3669 | /* This is how we store types for the writing routines. Most types | |
3670 | are simply represented by a type index. */ | |
3671 | ||
3672 | struct ieee_write_type | |
3673 | { | |
3674 | /* Type index. */ | |
3675 | unsigned int indx; | |
3676 | /* The size of the type, if known. */ | |
3677 | unsigned int size; | |
3678 | /* The name of the type, if any. */ | |
3679 | const char *name; | |
3680 | /* If this is a function or method type, we build the type here, and | |
3681 | only add it to the output buffers if we need it. */ | |
3682 | struct ieee_buflist fndef; | |
3683 | /* If this is a struct, this is where the struct definition is | |
3684 | built. */ | |
3685 | struct ieee_buflist strdef; | |
3686 | /* If this is a class, this is where the class information is built. */ | |
3687 | struct ieee_type_class *classdef; | |
3688 | /* Whether the type is unsigned. */ | |
3689 | unsigned int unsignedp : 1; | |
3690 | /* Whether this is a reference type. */ | |
3691 | unsigned int referencep : 1; | |
3692 | /* Whether this is in the local type block. */ | |
3693 | unsigned int localp : 1; | |
3694 | /* Whether this is a duplicate struct definition which we are | |
3695 | ignoring. */ | |
3696 | unsigned int ignorep : 1; | |
3697 | }; | |
3698 | ||
3699 | /* This is the type stack used by the debug writing routines. FIXME: | |
3700 | We could generate more efficient output if we remembered when we | |
3701 | have output a particular type before. */ | |
3702 | ||
3703 | struct ieee_type_stack | |
3704 | { | |
3705 | /* Next entry on stack. */ | |
3706 | struct ieee_type_stack *next; | |
3707 | /* Type information. */ | |
3708 | struct ieee_write_type type; | |
3709 | }; | |
3710 | ||
3711 | /* This is a list of associations between a name and some types. | |
3712 | These are used for typedefs and tags. */ | |
3713 | ||
3714 | struct ieee_name_type | |
3715 | { | |
3716 | /* Next type for this name. */ | |
3717 | struct ieee_name_type *next; | |
3718 | /* ID number. For a typedef, this is the index of the type to which | |
3719 | this name is typedefed. */ | |
3720 | unsigned int id; | |
3721 | /* Type. */ | |
3722 | struct ieee_write_type type; | |
3723 | /* If this is a tag which has not yet been defined, this is the | |
3724 | kind. If the tag has been defined, this is DEBUG_KIND_ILLEGAL. */ | |
3725 | enum debug_type_kind kind; | |
3726 | }; | |
3727 | ||
3728 | /* We use a hash table to associate names and types. */ | |
3729 | ||
3730 | struct ieee_name_type_hash_table | |
3731 | { | |
3732 | struct bfd_hash_table root; | |
3733 | }; | |
3734 | ||
3735 | struct ieee_name_type_hash_entry | |
3736 | { | |
3737 | struct bfd_hash_entry root; | |
3738 | /* Information for this name. */ | |
3739 | struct ieee_name_type *types; | |
3740 | }; | |
3741 | ||
3742 | /* This is a list of enums. */ | |
3743 | ||
3744 | struct ieee_defined_enum | |
3745 | { | |
3746 | /* Next enum. */ | |
3747 | struct ieee_defined_enum *next; | |
3748 | /* Type index. */ | |
3749 | unsigned int indx; | |
3750 | /* Whether this enum has been defined. */ | |
b34976b6 | 3751 | bfd_boolean defined; |
252b5132 RH |
3752 | /* Tag. */ |
3753 | const char *tag; | |
3754 | /* Names. */ | |
3755 | const char **names; | |
3756 | /* Values. */ | |
3757 | bfd_signed_vma *vals; | |
3758 | }; | |
3759 | ||
3760 | /* We keep a list of modified versions of types, so that we don't | |
3761 | output them more than once. */ | |
3762 | ||
3763 | struct ieee_modified_type | |
3764 | { | |
3765 | /* Pointer to this type. */ | |
3766 | unsigned int pointer; | |
3767 | /* Function with unknown arguments returning this type. */ | |
3768 | unsigned int function; | |
3769 | /* Const version of this type. */ | |
3770 | unsigned int const_qualified; | |
3771 | /* Volatile version of this type. */ | |
3772 | unsigned int volatile_qualified; | |
3773 | /* List of arrays of this type of various bounds. */ | |
3774 | struct ieee_modified_array_type *arrays; | |
3775 | }; | |
3776 | ||
3777 | /* A list of arrays bounds. */ | |
3778 | ||
3779 | struct ieee_modified_array_type | |
3780 | { | |
3781 | /* Next array bounds. */ | |
3782 | struct ieee_modified_array_type *next; | |
3783 | /* Type index with these bounds. */ | |
3784 | unsigned int indx; | |
3785 | /* Low bound. */ | |
3786 | bfd_signed_vma low; | |
3787 | /* High bound. */ | |
3788 | bfd_signed_vma high; | |
3789 | }; | |
3790 | ||
3791 | /* This is a list of pending function parameter information. We don't | |
3792 | output them until we see the first block. */ | |
3793 | ||
3794 | struct ieee_pending_parm | |
3795 | { | |
3796 | /* Next pending parameter. */ | |
3797 | struct ieee_pending_parm *next; | |
3798 | /* Name. */ | |
3799 | const char *name; | |
3800 | /* Type index. */ | |
3801 | unsigned int type; | |
3802 | /* Whether the type is a reference. */ | |
b34976b6 | 3803 | bfd_boolean referencep; |
252b5132 RH |
3804 | /* Kind. */ |
3805 | enum debug_parm_kind kind; | |
3806 | /* Value. */ | |
3807 | bfd_vma val; | |
3808 | }; | |
3809 | ||
3810 | /* This is the handle passed down by debug_write. */ | |
3811 | ||
3812 | struct ieee_handle | |
3813 | { | |
3814 | /* BFD we are writing to. */ | |
3815 | bfd *abfd; | |
3816 | /* Whether we got an error in a subroutine called via traverse or | |
3817 | map_over_sections. */ | |
b34976b6 | 3818 | bfd_boolean error; |
252b5132 RH |
3819 | /* Current data buffer list. */ |
3820 | struct ieee_buflist *current; | |
3821 | /* Current data buffer. */ | |
3822 | struct ieee_buf *curbuf; | |
3823 | /* Filename of current compilation unit. */ | |
3824 | const char *filename; | |
3825 | /* Module name of current compilation unit. */ | |
3826 | const char *modname; | |
3827 | /* List of buffer for global types. */ | |
3828 | struct ieee_buflist global_types; | |
3829 | /* List of finished data buffers. */ | |
3830 | struct ieee_buflist data; | |
3831 | /* List of buffers for typedefs in the current compilation unit. */ | |
3832 | struct ieee_buflist types; | |
3833 | /* List of buffers for variables and functions in the current | |
3834 | compilation unit. */ | |
3835 | struct ieee_buflist vars; | |
3836 | /* List of buffers for C++ class definitions in the current | |
3837 | compilation unit. */ | |
3838 | struct ieee_buflist cxx; | |
3839 | /* List of buffers for line numbers in the current compilation unit. */ | |
3840 | struct ieee_buflist linenos; | |
3841 | /* Ranges for the current compilation unit. */ | |
3842 | struct ieee_range *ranges; | |
3843 | /* Ranges for all debugging information. */ | |
3844 | struct ieee_range *global_ranges; | |
3845 | /* Nested pending ranges. */ | |
3846 | struct ieee_range *pending_ranges; | |
3847 | /* Type stack. */ | |
3848 | struct ieee_type_stack *type_stack; | |
3849 | /* Next unallocated type index. */ | |
3850 | unsigned int type_indx; | |
3851 | /* Next unallocated name index. */ | |
3852 | unsigned int name_indx; | |
3853 | /* Typedefs. */ | |
3854 | struct ieee_name_type_hash_table typedefs; | |
3855 | /* Tags. */ | |
3856 | struct ieee_name_type_hash_table tags; | |
3857 | /* Enums. */ | |
3858 | struct ieee_defined_enum *enums; | |
3859 | /* Modified versions of types. */ | |
3860 | struct ieee_modified_type *modified; | |
3861 | /* Number of entries allocated in modified. */ | |
3862 | unsigned int modified_alloc; | |
3863 | /* 4 byte complex type. */ | |
3864 | unsigned int complex_float_index; | |
3865 | /* 8 byte complex type. */ | |
3866 | unsigned int complex_double_index; | |
3867 | /* The depth of block nesting. This is 0 outside a function, and 1 | |
3868 | just after start_function is called. */ | |
3869 | unsigned int block_depth; | |
3870 | /* The name of the current function. */ | |
3871 | const char *fnname; | |
3872 | /* List of buffers for the type of the function we are currently | |
3873 | writing out. */ | |
3874 | struct ieee_buflist fntype; | |
3875 | /* List of buffers for the parameters of the function we are | |
3876 | currently writing out. */ | |
3877 | struct ieee_buflist fnargs; | |
3878 | /* Number of arguments written to fnargs. */ | |
3879 | unsigned int fnargcount; | |
3880 | /* Pending function parameters. */ | |
3881 | struct ieee_pending_parm *pending_parms; | |
3882 | /* Current line number filename. */ | |
3883 | const char *lineno_filename; | |
3884 | /* Line number name index. */ | |
3885 | unsigned int lineno_name_indx; | |
3886 | /* Filename of pending line number. */ | |
3887 | const char *pending_lineno_filename; | |
3888 | /* Pending line number. */ | |
3889 | unsigned long pending_lineno; | |
3890 | /* Address of pending line number. */ | |
3891 | bfd_vma pending_lineno_addr; | |
3892 | /* Highest address seen at end of procedure. */ | |
3893 | bfd_vma highaddr; | |
3894 | }; | |
3895 | ||
b34976b6 | 3896 | static bfd_boolean ieee_init_buffer |
2da42df6 | 3897 | (struct ieee_handle *, struct ieee_buflist *); |
b34976b6 | 3898 | static bfd_boolean ieee_change_buffer |
2da42df6 | 3899 | (struct ieee_handle *, struct ieee_buflist *); |
b34976b6 | 3900 | static bfd_boolean ieee_append_buffer |
2da42df6 AJ |
3901 | (struct ieee_handle *, struct ieee_buflist *, struct ieee_buflist *); |
3902 | static bfd_boolean ieee_real_write_byte (struct ieee_handle *, int); | |
3903 | static bfd_boolean ieee_write_2bytes (struct ieee_handle *, int); | |
3904 | static bfd_boolean ieee_write_number (struct ieee_handle *, bfd_vma); | |
3905 | static bfd_boolean ieee_write_id (struct ieee_handle *, const char *); | |
b34976b6 | 3906 | static bfd_boolean ieee_write_asn |
2da42df6 | 3907 | (struct ieee_handle *, unsigned int, bfd_vma); |
b34976b6 | 3908 | static bfd_boolean ieee_write_atn65 |
2da42df6 | 3909 | (struct ieee_handle *, unsigned int, const char *); |
b34976b6 | 3910 | static bfd_boolean ieee_push_type |
2da42df6 AJ |
3911 | (struct ieee_handle *, unsigned int, unsigned int, bfd_boolean, |
3912 | bfd_boolean); | |
3913 | static unsigned int ieee_pop_type (struct ieee_handle *); | |
3914 | static void ieee_pop_unused_type (struct ieee_handle *); | |
3915 | static unsigned int ieee_pop_type_used (struct ieee_handle *, bfd_boolean); | |
b34976b6 | 3916 | static bfd_boolean ieee_add_range |
2da42df6 AJ |
3917 | (struct ieee_handle *, bfd_boolean, bfd_vma, bfd_vma); |
3918 | static bfd_boolean ieee_start_range (struct ieee_handle *, bfd_vma); | |
3919 | static bfd_boolean ieee_end_range (struct ieee_handle *, bfd_vma); | |
b34976b6 | 3920 | static bfd_boolean ieee_define_type |
2da42df6 | 3921 | (struct ieee_handle *, unsigned int, bfd_boolean, bfd_boolean); |
b34976b6 | 3922 | static bfd_boolean ieee_define_named_type |
2da42df6 AJ |
3923 | (struct ieee_handle *, const char *, unsigned int, unsigned int, |
3924 | bfd_boolean, bfd_boolean, struct ieee_buflist *); | |
252b5132 | 3925 | static struct ieee_modified_type *ieee_get_modified_info |
2da42df6 | 3926 | (struct ieee_handle *, unsigned int); |
252b5132 | 3927 | static struct bfd_hash_entry *ieee_name_type_newfunc |
2da42df6 | 3928 | (struct bfd_hash_entry *, struct bfd_hash_table *, const char *); |
b34976b6 | 3929 | static bfd_boolean ieee_write_undefined_tag |
2da42df6 AJ |
3930 | (struct ieee_name_type_hash_entry *, void *); |
3931 | static bfd_boolean ieee_finish_compilation_unit (struct ieee_handle *); | |
3932 | static void ieee_add_bb11_blocks (bfd *, asection *, void *); | |
b34976b6 | 3933 | static bfd_boolean ieee_add_bb11 |
2da42df6 AJ |
3934 | (struct ieee_handle *, asection *, bfd_vma, bfd_vma); |
3935 | static bfd_boolean ieee_output_pending_parms (struct ieee_handle *); | |
3936 | static unsigned int ieee_vis_to_flags (enum debug_visibility); | |
b34976b6 | 3937 | static bfd_boolean ieee_class_method_var |
2da42df6 AJ |
3938 | (struct ieee_handle *, const char *, enum debug_visibility, bfd_boolean, |
3939 | bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean); | |
3940 | ||
3941 | static bfd_boolean ieee_start_compilation_unit (void *, const char *); | |
3942 | static bfd_boolean ieee_start_source (void *, const char *); | |
3943 | static bfd_boolean ieee_empty_type (void *); | |
3944 | static bfd_boolean ieee_void_type (void *); | |
3945 | static bfd_boolean ieee_int_type (void *, unsigned int, bfd_boolean); | |
3946 | static bfd_boolean ieee_float_type (void *, unsigned int); | |
3947 | static bfd_boolean ieee_complex_type (void *, unsigned int); | |
3948 | static bfd_boolean ieee_bool_type (void *, unsigned int); | |
b34976b6 | 3949 | static bfd_boolean ieee_enum_type |
2da42df6 AJ |
3950 | (void *, const char *, const char **, bfd_signed_vma *); |
3951 | static bfd_boolean ieee_pointer_type (void *); | |
3952 | static bfd_boolean ieee_function_type (void *, int, bfd_boolean); | |
3953 | static bfd_boolean ieee_reference_type (void *); | |
3954 | static bfd_boolean ieee_range_type (void *, bfd_signed_vma, bfd_signed_vma); | |
b34976b6 | 3955 | static bfd_boolean ieee_array_type |
2da42df6 AJ |
3956 | (void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean); |
3957 | static bfd_boolean ieee_set_type (void *, bfd_boolean); | |
3958 | static bfd_boolean ieee_offset_type (void *); | |
3959 | static bfd_boolean ieee_method_type (void *, bfd_boolean, int, bfd_boolean); | |
3960 | static bfd_boolean ieee_const_type (void *); | |
3961 | static bfd_boolean ieee_volatile_type (void *); | |
b34976b6 | 3962 | static bfd_boolean ieee_start_struct_type |
2da42df6 | 3963 | (void *, const char *, unsigned int, bfd_boolean, unsigned int); |
b34976b6 | 3964 | static bfd_boolean ieee_struct_field |
2da42df6 AJ |
3965 | (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility); |
3966 | static bfd_boolean ieee_end_struct_type (void *); | |
b34976b6 | 3967 | static bfd_boolean ieee_start_class_type |
2da42df6 AJ |
3968 | (void *, const char *, unsigned int, bfd_boolean, unsigned int, bfd_boolean, |
3969 | bfd_boolean); | |
b34976b6 | 3970 | static bfd_boolean ieee_class_static_member |
2da42df6 | 3971 | (void *, const char *, const char *, enum debug_visibility); |
b34976b6 | 3972 | static bfd_boolean ieee_class_baseclass |
2da42df6 AJ |
3973 | (void *, bfd_vma, bfd_boolean, enum debug_visibility); |
3974 | static bfd_boolean ieee_class_start_method (void *, const char *); | |
b34976b6 | 3975 | static bfd_boolean ieee_class_method_variant |
2da42df6 AJ |
3976 | (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean, |
3977 | bfd_vma, bfd_boolean); | |
b34976b6 | 3978 | static bfd_boolean ieee_class_static_method_variant |
2da42df6 AJ |
3979 | (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean); |
3980 | static bfd_boolean ieee_class_end_method (void *); | |
3981 | static bfd_boolean ieee_end_class_type (void *); | |
3982 | static bfd_boolean ieee_typedef_type (void *, const char *); | |
b34976b6 | 3983 | static bfd_boolean ieee_tag_type |
2da42df6 AJ |
3984 | (void *, const char *, unsigned int, enum debug_type_kind); |
3985 | static bfd_boolean ieee_typdef (void *, const char *); | |
3986 | static bfd_boolean ieee_tag (void *, const char *); | |
3987 | static bfd_boolean ieee_int_constant (void *, const char *, bfd_vma); | |
3988 | static bfd_boolean ieee_float_constant (void *, const char *, double); | |
3989 | static bfd_boolean ieee_typed_constant (void *, const char *, bfd_vma); | |
b34976b6 | 3990 | static bfd_boolean ieee_variable |
2da42df6 AJ |
3991 | (void *, const char *, enum debug_var_kind, bfd_vma); |
3992 | static bfd_boolean ieee_start_function (void *, const char *, bfd_boolean); | |
b34976b6 | 3993 | static bfd_boolean ieee_function_parameter |
2da42df6 AJ |
3994 | (void *, const char *, enum debug_parm_kind, bfd_vma); |
3995 | static bfd_boolean ieee_start_block (void *, bfd_vma); | |
3996 | static bfd_boolean ieee_end_block (void *, bfd_vma); | |
3997 | static bfd_boolean ieee_end_function (void *); | |
3998 | static bfd_boolean ieee_lineno (void *, const char *, unsigned long, bfd_vma); | |
252b5132 RH |
3999 | |
4000 | static const struct debug_write_fns ieee_fns = | |
4001 | { | |
4002 | ieee_start_compilation_unit, | |
4003 | ieee_start_source, | |
4004 | ieee_empty_type, | |
4005 | ieee_void_type, | |
4006 | ieee_int_type, | |
4007 | ieee_float_type, | |
4008 | ieee_complex_type, | |
4009 | ieee_bool_type, | |
4010 | ieee_enum_type, | |
4011 | ieee_pointer_type, | |
4012 | ieee_function_type, | |
4013 | ieee_reference_type, | |
4014 | ieee_range_type, | |
4015 | ieee_array_type, | |
4016 | ieee_set_type, | |
4017 | ieee_offset_type, | |
4018 | ieee_method_type, | |
4019 | ieee_const_type, | |
4020 | ieee_volatile_type, | |
4021 | ieee_start_struct_type, | |
4022 | ieee_struct_field, | |
4023 | ieee_end_struct_type, | |
4024 | ieee_start_class_type, | |
4025 | ieee_class_static_member, | |
4026 | ieee_class_baseclass, | |
4027 | ieee_class_start_method, | |
4028 | ieee_class_method_variant, | |
4029 | ieee_class_static_method_variant, | |
4030 | ieee_class_end_method, | |
4031 | ieee_end_class_type, | |
4032 | ieee_typedef_type, | |
4033 | ieee_tag_type, | |
4034 | ieee_typdef, | |
4035 | ieee_tag, | |
4036 | ieee_int_constant, | |
4037 | ieee_float_constant, | |
4038 | ieee_typed_constant, | |
4039 | ieee_variable, | |
4040 | ieee_start_function, | |
4041 | ieee_function_parameter, | |
4042 | ieee_start_block, | |
4043 | ieee_end_block, | |
4044 | ieee_end_function, | |
4045 | ieee_lineno | |
4046 | }; | |
4047 | ||
4048 | /* Initialize a buffer to be empty. */ | |
4049 | ||
b34976b6 | 4050 | static bfd_boolean |
2da42df6 AJ |
4051 | ieee_init_buffer (struct ieee_handle *info ATTRIBUTE_UNUSED, |
4052 | struct ieee_buflist *buflist) | |
252b5132 RH |
4053 | { |
4054 | buflist->head = NULL; | |
4055 | buflist->tail = NULL; | |
b34976b6 | 4056 | return TRUE; |
252b5132 RH |
4057 | } |
4058 | ||
4059 | /* See whether a buffer list has any data. */ | |
4060 | ||
4061 | #define ieee_buffer_emptyp(buflist) ((buflist)->head == NULL) | |
4062 | ||
4063 | /* Change the current buffer to a specified buffer chain. */ | |
4064 | ||
b34976b6 | 4065 | static bfd_boolean |
2da42df6 | 4066 | ieee_change_buffer (struct ieee_handle *info, struct ieee_buflist *buflist) |
252b5132 RH |
4067 | { |
4068 | if (buflist->head == NULL) | |
4069 | { | |
4070 | struct ieee_buf *buf; | |
4071 | ||
4072 | buf = (struct ieee_buf *) xmalloc (sizeof *buf); | |
4073 | buf->next = NULL; | |
4074 | buf->c = 0; | |
4075 | buflist->head = buf; | |
4076 | buflist->tail = buf; | |
4077 | } | |
4078 | ||
4079 | info->current = buflist; | |
4080 | info->curbuf = buflist->tail; | |
4081 | ||
b34976b6 | 4082 | return TRUE; |
252b5132 RH |
4083 | } |
4084 | ||
4085 | /* Append a buffer chain. */ | |
4086 | ||
b34976b6 | 4087 | static bfd_boolean |
2da42df6 AJ |
4088 | ieee_append_buffer (struct ieee_handle *info ATTRIBUTE_UNUSED, |
4089 | struct ieee_buflist *mainbuf, | |
4090 | struct ieee_buflist *newbuf) | |
252b5132 RH |
4091 | { |
4092 | if (newbuf->head != NULL) | |
4093 | { | |
4094 | if (mainbuf->head == NULL) | |
4095 | mainbuf->head = newbuf->head; | |
4096 | else | |
4097 | mainbuf->tail->next = newbuf->head; | |
4098 | mainbuf->tail = newbuf->tail; | |
4099 | } | |
b34976b6 | 4100 | return TRUE; |
252b5132 RH |
4101 | } |
4102 | ||
4103 | /* Write a byte into the buffer. We use a macro for speed and a | |
4104 | function for the complex cases. */ | |
4105 | ||
4106 | #define ieee_write_byte(info, b) \ | |
4107 | ((info)->curbuf->c < IEEE_BUFSIZE \ | |
b34976b6 | 4108 | ? ((info)->curbuf->buf[(info)->curbuf->c++] = (b), TRUE) \ |
252b5132 RH |
4109 | : ieee_real_write_byte ((info), (b))) |
4110 | ||
b34976b6 | 4111 | static bfd_boolean |
2da42df6 | 4112 | ieee_real_write_byte (struct ieee_handle *info, int b) |
252b5132 RH |
4113 | { |
4114 | if (info->curbuf->c >= IEEE_BUFSIZE) | |
4115 | { | |
4116 | struct ieee_buf *n; | |
4117 | ||
4118 | n = (struct ieee_buf *) xmalloc (sizeof *n); | |
4119 | n->next = NULL; | |
4120 | n->c = 0; | |
4121 | if (info->current->head == NULL) | |
4122 | info->current->head = n; | |
4123 | else | |
4124 | info->current->tail->next = n; | |
4125 | info->current->tail = n; | |
4126 | info->curbuf = n; | |
4127 | } | |
4128 | ||
4129 | info->curbuf->buf[info->curbuf->c] = b; | |
4130 | ++info->curbuf->c; | |
4131 | ||
b34976b6 | 4132 | return TRUE; |
252b5132 RH |
4133 | } |
4134 | ||
4135 | /* Write out two bytes. */ | |
4136 | ||
b34976b6 | 4137 | static bfd_boolean |
2da42df6 | 4138 | ieee_write_2bytes (struct ieee_handle *info, int i) |
252b5132 RH |
4139 | { |
4140 | return (ieee_write_byte (info, i >> 8) | |
4141 | && ieee_write_byte (info, i & 0xff)); | |
4142 | } | |
4143 | ||
4144 | /* Write out an integer. */ | |
4145 | ||
b34976b6 | 4146 | static bfd_boolean |
2da42df6 | 4147 | ieee_write_number (struct ieee_handle *info, bfd_vma v) |
252b5132 RH |
4148 | { |
4149 | bfd_vma t; | |
4150 | bfd_byte ab[20]; | |
4151 | bfd_byte *p; | |
4152 | unsigned int c; | |
4153 | ||
4154 | if (v <= (bfd_vma) ieee_number_end_enum) | |
4155 | return ieee_write_byte (info, (int) v); | |
4156 | ||
4157 | t = v; | |
4158 | p = ab + sizeof ab; | |
4159 | while (t != 0) | |
4160 | { | |
4161 | *--p = t & 0xff; | |
4162 | t >>= 8; | |
4163 | } | |
4164 | c = (ab + 20) - p; | |
4165 | ||
4166 | if (c > (unsigned int) (ieee_number_repeat_end_enum | |
4167 | - ieee_number_repeat_start_enum)) | |
4168 | { | |
4169 | fprintf (stderr, _("IEEE numeric overflow: 0x")); | |
4170 | fprintf_vma (stderr, v); | |
4171 | fprintf (stderr, "\n"); | |
b34976b6 | 4172 | return FALSE; |
252b5132 RH |
4173 | } |
4174 | ||
4175 | if (! ieee_write_byte (info, (int) ieee_number_repeat_start_enum + c)) | |
b34976b6 | 4176 | return FALSE; |
252b5132 RH |
4177 | for (; c > 0; --c, ++p) |
4178 | { | |
4179 | if (! ieee_write_byte (info, *p)) | |
b34976b6 | 4180 | return FALSE; |
252b5132 RH |
4181 | } |
4182 | ||
b34976b6 | 4183 | return TRUE; |
252b5132 RH |
4184 | } |
4185 | ||
4186 | /* Write out a string. */ | |
4187 | ||
b34976b6 | 4188 | static bfd_boolean |
2da42df6 | 4189 | ieee_write_id (struct ieee_handle *info, const char *s) |
252b5132 RH |
4190 | { |
4191 | unsigned int len; | |
4192 | ||
4193 | len = strlen (s); | |
4194 | if (len <= 0x7f) | |
4195 | { | |
4196 | if (! ieee_write_byte (info, len)) | |
b34976b6 | 4197 | return FALSE; |
252b5132 RH |
4198 | } |
4199 | else if (len <= 0xff) | |
4200 | { | |
4201 | if (! ieee_write_byte (info, (int) ieee_extension_length_1_enum) | |
4202 | || ! ieee_write_byte (info, len)) | |
b34976b6 | 4203 | return FALSE; |
252b5132 RH |
4204 | } |
4205 | else if (len <= 0xffff) | |
4206 | { | |
4207 | if (! ieee_write_byte (info, (int) ieee_extension_length_2_enum) | |
4208 | || ! ieee_write_2bytes (info, len)) | |
b34976b6 | 4209 | return FALSE; |
252b5132 RH |
4210 | } |
4211 | else | |
4212 | { | |
4213 | fprintf (stderr, _("IEEE string length overflow: %u\n"), len); | |
b34976b6 | 4214 | return FALSE; |
252b5132 RH |
4215 | } |
4216 | ||
4217 | for (; *s != '\0'; s++) | |
4218 | if (! ieee_write_byte (info, *s)) | |
b34976b6 | 4219 | return FALSE; |
252b5132 | 4220 | |
b34976b6 | 4221 | return TRUE; |
252b5132 RH |
4222 | } |
4223 | ||
4224 | /* Write out an ASN record. */ | |
4225 | ||
b34976b6 | 4226 | static bfd_boolean |
2da42df6 | 4227 | ieee_write_asn (struct ieee_handle *info, unsigned int indx, bfd_vma val) |
252b5132 RH |
4228 | { |
4229 | return (ieee_write_2bytes (info, (int) ieee_asn_record_enum) | |
4230 | && ieee_write_number (info, indx) | |
4231 | && ieee_write_number (info, val)); | |
4232 | } | |
4233 | ||
4234 | /* Write out an ATN65 record. */ | |
4235 | ||
b34976b6 | 4236 | static bfd_boolean |
2da42df6 | 4237 | ieee_write_atn65 (struct ieee_handle *info, unsigned int indx, const char *s) |
252b5132 RH |
4238 | { |
4239 | return (ieee_write_2bytes (info, (int) ieee_atn_record_enum) | |
4240 | && ieee_write_number (info, indx) | |
4241 | && ieee_write_number (info, 0) | |
4242 | && ieee_write_number (info, 65) | |
4243 | && ieee_write_id (info, s)); | |
4244 | } | |
4245 | ||
4246 | /* Push a type index onto the type stack. */ | |
4247 | ||
b34976b6 | 4248 | static bfd_boolean |
2da42df6 AJ |
4249 | ieee_push_type (struct ieee_handle *info, unsigned int indx, |
4250 | unsigned int size, bfd_boolean unsignedp, bfd_boolean localp) | |
252b5132 RH |
4251 | { |
4252 | struct ieee_type_stack *ts; | |
4253 | ||
4254 | ts = (struct ieee_type_stack *) xmalloc (sizeof *ts); | |
4255 | memset (ts, 0, sizeof *ts); | |
4256 | ||
4257 | ts->type.indx = indx; | |
4258 | ts->type.size = size; | |
4259 | ts->type.unsignedp = unsignedp; | |
4260 | ts->type.localp = localp; | |
4261 | ||
4262 | ts->next = info->type_stack; | |
4263 | info->type_stack = ts; | |
4264 | ||
b34976b6 | 4265 | return TRUE; |
252b5132 RH |
4266 | } |
4267 | ||
4268 | /* Pop a type index off the type stack. */ | |
4269 | ||
4270 | static unsigned int | |
2da42df6 | 4271 | ieee_pop_type (struct ieee_handle *info) |
252b5132 | 4272 | { |
b34976b6 | 4273 | return ieee_pop_type_used (info, TRUE); |
252b5132 RH |
4274 | } |
4275 | ||
4276 | /* Pop an unused type index off the type stack. */ | |
4277 | ||
4278 | static void | |
2da42df6 | 4279 | ieee_pop_unused_type (struct ieee_handle *info) |
252b5132 | 4280 | { |
b34976b6 | 4281 | (void) ieee_pop_type_used (info, FALSE); |
252b5132 RH |
4282 | } |
4283 | ||
4284 | /* Pop a used or unused type index off the type stack. */ | |
4285 | ||
4286 | static unsigned int | |
2da42df6 | 4287 | ieee_pop_type_used (struct ieee_handle *info, bfd_boolean used) |
252b5132 RH |
4288 | { |
4289 | struct ieee_type_stack *ts; | |
4290 | unsigned int ret; | |
4291 | ||
4292 | ts = info->type_stack; | |
4293 | assert (ts != NULL); | |
4294 | ||
4295 | /* If this is a function type, and we need it, we need to append the | |
4296 | actual definition to the typedef block now. */ | |
4297 | if (used && ! ieee_buffer_emptyp (&ts->type.fndef)) | |
4298 | { | |
4299 | struct ieee_buflist *buflist; | |
4300 | ||
4301 | if (ts->type.localp) | |
4302 | { | |
4303 | /* Make sure we have started the types block. */ | |
4304 | if (ieee_buffer_emptyp (&info->types)) | |
4305 | { | |
4306 | if (! ieee_change_buffer (info, &info->types) | |
4307 | || ! ieee_write_byte (info, (int) ieee_bb_record_enum) | |
4308 | || ! ieee_write_byte (info, 1) | |
4309 | || ! ieee_write_number (info, 0) | |
4310 | || ! ieee_write_id (info, info->modname)) | |
b34976b6 | 4311 | return FALSE; |
252b5132 RH |
4312 | } |
4313 | buflist = &info->types; | |
4314 | } | |
4315 | else | |
4316 | { | |
4317 | /* Make sure we started the global type block. */ | |
4318 | if (ieee_buffer_emptyp (&info->global_types)) | |
4319 | { | |
4320 | if (! ieee_change_buffer (info, &info->global_types) | |
4321 | || ! ieee_write_byte (info, (int) ieee_bb_record_enum) | |
4322 | || ! ieee_write_byte (info, 2) | |
4323 | || ! ieee_write_number (info, 0) | |
4324 | || ! ieee_write_id (info, "")) | |
b34976b6 | 4325 | return FALSE; |
252b5132 RH |
4326 | } |
4327 | buflist = &info->global_types; | |
4328 | } | |
4329 | ||
4330 | if (! ieee_append_buffer (info, buflist, &ts->type.fndef)) | |
b34976b6 | 4331 | return FALSE; |
252b5132 RH |
4332 | } |
4333 | ||
4334 | ret = ts->type.indx; | |
4335 | info->type_stack = ts->next; | |
4336 | free (ts); | |
4337 | return ret; | |
4338 | } | |
4339 | ||
4340 | /* Add a range of bytes included in the current compilation unit. */ | |
4341 | ||
b34976b6 | 4342 | static bfd_boolean |
2da42df6 AJ |
4343 | ieee_add_range (struct ieee_handle *info, bfd_boolean global, bfd_vma low, |
4344 | bfd_vma high) | |
252b5132 RH |
4345 | { |
4346 | struct ieee_range **plist, *r, **pr; | |
4347 | ||
4348 | if (low == (bfd_vma) -1 || high == (bfd_vma) -1 || low == high) | |
b34976b6 | 4349 | return TRUE; |
252b5132 RH |
4350 | |
4351 | if (global) | |
4352 | plist = &info->global_ranges; | |
4353 | else | |
4354 | plist = &info->ranges; | |
4355 | ||
4356 | for (r = *plist; r != NULL; r = r->next) | |
4357 | { | |
4358 | if (high >= r->low && low <= r->high) | |
4359 | { | |
4360 | /* The new range overlaps r. */ | |
4361 | if (low < r->low) | |
4362 | r->low = low; | |
4363 | if (high > r->high) | |
4364 | r->high = high; | |
4365 | pr = &r->next; | |
4366 | while (*pr != NULL && (*pr)->low <= r->high) | |
4367 | { | |
4368 | struct ieee_range *n; | |
4369 | ||
4370 | if ((*pr)->high > r->high) | |
4371 | r->high = (*pr)->high; | |
4372 | n = (*pr)->next; | |
4373 | free (*pr); | |
4374 | *pr = n; | |
4375 | } | |
b34976b6 | 4376 | return TRUE; |
252b5132 RH |
4377 | } |
4378 | } | |
4379 | ||
4380 | r = (struct ieee_range *) xmalloc (sizeof *r); | |
4381 | memset (r, 0, sizeof *r); | |
4382 | ||
4383 | r->low = low; | |
4384 | r->high = high; | |
4385 | ||
4386 | /* Store the ranges sorted by address. */ | |
4387 | for (pr = plist; *pr != NULL; pr = &(*pr)->next) | |
4388 | if ((*pr)->low > high) | |
4389 | break; | |
4390 | r->next = *pr; | |
4391 | *pr = r; | |
4392 | ||
b34976b6 | 4393 | return TRUE; |
252b5132 RH |
4394 | } |
4395 | ||
4396 | /* Start a new range for which we only have the low address. */ | |
4397 | ||
b34976b6 | 4398 | static bfd_boolean |
2da42df6 | 4399 | ieee_start_range (struct ieee_handle *info, bfd_vma low) |
252b5132 RH |
4400 | { |
4401 | struct ieee_range *r; | |
4402 | ||
4403 | r = (struct ieee_range *) xmalloc (sizeof *r); | |
4404 | memset (r, 0, sizeof *r); | |
4405 | r->low = low; | |
4406 | r->next = info->pending_ranges; | |
4407 | info->pending_ranges = r; | |
b34976b6 | 4408 | return TRUE; |
c7f2731e | 4409 | } |
252b5132 RH |
4410 | |
4411 | /* Finish a range started by ieee_start_range. */ | |
4412 | ||
b34976b6 | 4413 | static bfd_boolean |
2da42df6 | 4414 | ieee_end_range (struct ieee_handle *info, bfd_vma high) |
252b5132 RH |
4415 | { |
4416 | struct ieee_range *r; | |
4417 | bfd_vma low; | |
4418 | ||
4419 | assert (info->pending_ranges != NULL); | |
4420 | r = info->pending_ranges; | |
4421 | low = r->low; | |
4422 | info->pending_ranges = r->next; | |
4423 | free (r); | |
b34976b6 | 4424 | return ieee_add_range (info, FALSE, low, high); |
252b5132 RH |
4425 | } |
4426 | ||
4427 | /* Start defining a type. */ | |
4428 | ||
b34976b6 | 4429 | static bfd_boolean |
2da42df6 AJ |
4430 | ieee_define_type (struct ieee_handle *info, unsigned int size, |
4431 | bfd_boolean unsignedp, bfd_boolean localp) | |
252b5132 RH |
4432 | { |
4433 | return ieee_define_named_type (info, (const char *) NULL, | |
4434 | (unsigned int) -1, size, unsignedp, | |
4435 | localp, (struct ieee_buflist *) NULL); | |
4436 | } | |
4437 | ||
4438 | /* Start defining a named type. */ | |
4439 | ||
b34976b6 | 4440 | static bfd_boolean |
2da42df6 AJ |
4441 | ieee_define_named_type (struct ieee_handle *info, const char *name, |
4442 | unsigned int indx, unsigned int size, | |
4443 | bfd_boolean unsignedp, bfd_boolean localp, | |
4444 | struct ieee_buflist *buflist) | |
252b5132 RH |
4445 | { |
4446 | unsigned int type_indx; | |
4447 | unsigned int name_indx; | |
4448 | ||
4449 | if (indx != (unsigned int) -1) | |
4450 | type_indx = indx; | |
4451 | else | |
4452 | { | |
4453 | type_indx = info->type_indx; | |
4454 | ++info->type_indx; | |
4455 | } | |
4456 | ||
4457 | name_indx = info->name_indx; | |
4458 | ++info->name_indx; | |
4459 | ||
4460 | if (name == NULL) | |
4461 | name = ""; | |
4462 | ||
4463 | /* If we were given a buffer, use it; otherwise, use either the | |
4464 | local or the global type information, and make sure that the type | |
4465 | block is started. */ | |
4466 | if (buflist != NULL) | |
4467 | { | |
4468 | if (! ieee_change_buffer (info, buflist)) | |
b34976b6 | 4469 | return FALSE; |
252b5132 RH |
4470 | } |
4471 | else if (localp) | |
4472 | { | |
4473 | if (! ieee_buffer_emptyp (&info->types)) | |
4474 | { | |
4475 | if (! ieee_change_buffer (info, &info->types)) | |
b34976b6 | 4476 | return FALSE; |
252b5132 RH |
4477 | } |
4478 | else | |
4479 | { | |
4480 | if (! ieee_change_buffer (info, &info->types) | |
4481 | || ! ieee_write_byte (info, (int) ieee_bb_record_enum) | |
4482 | || ! ieee_write_byte (info, 1) | |
4483 | || ! ieee_write_number (info, 0) | |
4484 | || ! ieee_write_id (info, info->modname)) | |
b34976b6 | 4485 | return FALSE; |
252b5132 RH |
4486 | } |
4487 | } | |
4488 | else | |
4489 | { | |
4490 | if (! ieee_buffer_emptyp (&info->global_types)) | |
4491 | { | |
4492 | if (! ieee_change_buffer (info, &info->global_types)) | |
b34976b6 | 4493 | return FALSE; |
252b5132 RH |
4494 | } |
4495 | else | |
4496 | { | |
4497 | if (! ieee_change_buffer (info, &info->global_types) | |
4498 | || ! ieee_write_byte (info, (int) ieee_bb_record_enum) | |
4499 | || ! ieee_write_byte (info, 2) | |
4500 | || ! ieee_write_number (info, 0) | |
4501 | || ! ieee_write_id (info, "")) | |
b34976b6 | 4502 | return FALSE; |
252b5132 RH |
4503 | } |
4504 | } | |
4505 | ||
4506 | /* Push the new type on the type stack, write out an NN record, and | |
4507 | write out the start of a TY record. The caller will then finish | |
4508 | the TY record. */ | |
4509 | if (! ieee_push_type (info, type_indx, size, unsignedp, localp)) | |
b34976b6 | 4510 | return FALSE; |
252b5132 RH |
4511 | |
4512 | return (ieee_write_byte (info, (int) ieee_nn_record) | |
4513 | && ieee_write_number (info, name_indx) | |
4514 | && ieee_write_id (info, name) | |
4515 | && ieee_write_byte (info, (int) ieee_ty_record_enum) | |
4516 | && ieee_write_number (info, type_indx) | |
4517 | && ieee_write_byte (info, 0xce) | |
4518 | && ieee_write_number (info, name_indx)); | |
4519 | } | |
4520 | ||
4521 | /* Get an entry to the list of modified versions of a type. */ | |
4522 | ||
4523 | static struct ieee_modified_type * | |
2da42df6 | 4524 | ieee_get_modified_info (struct ieee_handle *info, unsigned int indx) |
252b5132 RH |
4525 | { |
4526 | if (indx >= info->modified_alloc) | |
4527 | { | |
4528 | unsigned int nalloc; | |
4529 | ||
4530 | nalloc = info->modified_alloc; | |
4531 | if (nalloc == 0) | |
4532 | nalloc = 16; | |
4533 | while (indx >= nalloc) | |
4534 | nalloc *= 2; | |
4535 | info->modified = ((struct ieee_modified_type *) | |
4536 | xrealloc (info->modified, | |
4537 | nalloc * sizeof *info->modified)); | |
4538 | memset (info->modified + info->modified_alloc, 0, | |
4539 | (nalloc - info->modified_alloc) * sizeof *info->modified); | |
4540 | info->modified_alloc = nalloc; | |
4541 | } | |
4542 | ||
4543 | return info->modified + indx; | |
4544 | } | |
4545 | \f | |
4546 | /* Routines for the hash table mapping names to types. */ | |
4547 | ||
4548 | /* Initialize an entry in the hash table. */ | |
4549 | ||
4550 | static struct bfd_hash_entry * | |
2da42df6 AJ |
4551 | ieee_name_type_newfunc (struct bfd_hash_entry *entry, |
4552 | struct bfd_hash_table *table, const char *string) | |
252b5132 RH |
4553 | { |
4554 | struct ieee_name_type_hash_entry *ret = | |
4555 | (struct ieee_name_type_hash_entry *) entry; | |
4556 | ||
4557 | /* Allocate the structure if it has not already been allocated by a | |
4558 | subclass. */ | |
4559 | if (ret == NULL) | |
4560 | ret = ((struct ieee_name_type_hash_entry *) | |
4561 | bfd_hash_allocate (table, sizeof *ret)); | |
4562 | if (ret == NULL) | |
4563 | return NULL; | |
4564 | ||
4565 | /* Call the allocation method of the superclass. */ | |
4566 | ret = ((struct ieee_name_type_hash_entry *) | |
4567 | bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string)); | |
4568 | if (ret) | |
4569 | { | |
4570 | /* Set local fields. */ | |
4571 | ret->types = NULL; | |
4572 | } | |
4573 | ||
4574 | return (struct bfd_hash_entry *) ret; | |
4575 | } | |
4576 | ||
4577 | /* Look up an entry in the hash table. */ | |
4578 | ||
4579 | #define ieee_name_type_hash_lookup(table, string, create, copy) \ | |
4580 | ((struct ieee_name_type_hash_entry *) \ | |
4581 | bfd_hash_lookup (&(table)->root, (string), (create), (copy))) | |
4582 | ||
4583 | /* Traverse the hash table. */ | |
4584 | ||
4585 | #define ieee_name_type_hash_traverse(table, func, info) \ | |
4586 | (bfd_hash_traverse \ | |
4587 | (&(table)->root, \ | |
2da42df6 | 4588 | (bfd_boolean (*) (struct bfd_hash_entry *, void *)) (func), \ |
252b5132 RH |
4589 | (info))) |
4590 | \f | |
4591 | /* The general routine to write out IEEE debugging information. */ | |
4592 | ||
b34976b6 | 4593 | bfd_boolean |
2da42df6 | 4594 | write_ieee_debugging_info (bfd *abfd, void *dhandle) |
252b5132 RH |
4595 | { |
4596 | struct ieee_handle info; | |
4597 | asection *s; | |
4598 | const char *err; | |
4599 | struct ieee_buf *b; | |
4600 | ||
4601 | memset (&info, 0, sizeof info); | |
4602 | info.abfd = abfd; | |
4603 | info.type_indx = 256; | |
4604 | info.name_indx = 32; | |
4605 | ||
66eb6687 AM |
4606 | if (!bfd_hash_table_init (&info.typedefs.root, ieee_name_type_newfunc, |
4607 | sizeof (struct ieee_name_type_hash_entry)) | |
4608 | || !bfd_hash_table_init (&info.tags.root, ieee_name_type_newfunc, | |
4609 | sizeof (struct ieee_name_type_hash_entry))) | |
b34976b6 | 4610 | return FALSE; |
252b5132 RH |
4611 | |
4612 | if (! ieee_init_buffer (&info, &info.global_types) | |
4613 | || ! ieee_init_buffer (&info, &info.data) | |
4614 | || ! ieee_init_buffer (&info, &info.types) | |
4615 | || ! ieee_init_buffer (&info, &info.vars) | |
4616 | || ! ieee_init_buffer (&info, &info.cxx) | |
4617 | || ! ieee_init_buffer (&info, &info.linenos) | |
4618 | || ! ieee_init_buffer (&info, &info.fntype) | |
4619 | || ! ieee_init_buffer (&info, &info.fnargs)) | |
b34976b6 | 4620 | return FALSE; |
252b5132 | 4621 | |
2da42df6 | 4622 | if (! debug_write (dhandle, &ieee_fns, (void *) &info)) |
b34976b6 | 4623 | return FALSE; |
252b5132 RH |
4624 | |
4625 | if (info.filename != NULL) | |
4626 | { | |
4627 | if (! ieee_finish_compilation_unit (&info)) | |
b34976b6 | 4628 | return FALSE; |
252b5132 RH |
4629 | } |
4630 | ||
4631 | /* Put any undefined tags in the global typedef information. */ | |
b34976b6 | 4632 | info.error = FALSE; |
252b5132 RH |
4633 | ieee_name_type_hash_traverse (&info.tags, |
4634 | ieee_write_undefined_tag, | |
2da42df6 | 4635 | (void *) &info); |
252b5132 | 4636 | if (info.error) |
b34976b6 | 4637 | return FALSE; |
252b5132 RH |
4638 | |
4639 | /* Prepend the global typedef information to the other data. */ | |
4640 | if (! ieee_buffer_emptyp (&info.global_types)) | |
4641 | { | |
4642 | /* The HP debugger seems to have a bug in which it ignores the | |
4643 | last entry in the global types, so we add a dummy entry. */ | |
4644 | if (! ieee_change_buffer (&info, &info.global_types) | |
4645 | || ! ieee_write_byte (&info, (int) ieee_nn_record) | |
4646 | || ! ieee_write_number (&info, info.name_indx) | |
4647 | || ! ieee_write_id (&info, "") | |
4648 | || ! ieee_write_byte (&info, (int) ieee_ty_record_enum) | |
4649 | || ! ieee_write_number (&info, info.type_indx) | |
4650 | || ! ieee_write_byte (&info, 0xce) | |
4651 | || ! ieee_write_number (&info, info.name_indx) | |
4652 | || ! ieee_write_number (&info, 'P') | |
4653 | || ! ieee_write_number (&info, (int) builtin_void + 32) | |
4654 | || ! ieee_write_byte (&info, (int) ieee_be_record_enum)) | |
b34976b6 | 4655 | return FALSE; |
252b5132 RH |
4656 | |
4657 | if (! ieee_append_buffer (&info, &info.global_types, &info.data)) | |
b34976b6 | 4658 | return FALSE; |
252b5132 RH |
4659 | info.data = info.global_types; |
4660 | } | |
4661 | ||
4662 | /* Make sure that we have declare BB11 blocks for each range in the | |
4663 | file. They are added to info->vars. */ | |
b34976b6 | 4664 | info.error = FALSE; |
252b5132 | 4665 | if (! ieee_init_buffer (&info, &info.vars)) |
b34976b6 | 4666 | return FALSE; |
2da42df6 | 4667 | bfd_map_over_sections (abfd, ieee_add_bb11_blocks, (void *) &info); |
252b5132 | 4668 | if (info.error) |
b34976b6 | 4669 | return FALSE; |
252b5132 RH |
4670 | if (! ieee_buffer_emptyp (&info.vars)) |
4671 | { | |
4672 | if (! ieee_change_buffer (&info, &info.vars) | |
4673 | || ! ieee_write_byte (&info, (int) ieee_be_record_enum)) | |
b34976b6 | 4674 | return FALSE; |
252b5132 RH |
4675 | |
4676 | if (! ieee_append_buffer (&info, &info.data, &info.vars)) | |
b34976b6 | 4677 | return FALSE; |
252b5132 RH |
4678 | } |
4679 | ||
4680 | /* Now all the data is in info.data. Write it out to the BFD. We | |
4681 | normally would need to worry about whether all the other sections | |
4682 | are set up yet, but the IEEE backend will handle this particular | |
4683 | case correctly regardless. */ | |
4684 | if (ieee_buffer_emptyp (&info.data)) | |
4685 | { | |
4686 | /* There is no debugging information. */ | |
b34976b6 | 4687 | return TRUE; |
252b5132 RH |
4688 | } |
4689 | err = NULL; | |
0eb80fd3 AM |
4690 | s = bfd_make_section_with_flags (abfd, ".debug", |
4691 | SEC_DEBUGGING | SEC_HAS_CONTENTS); | |
252b5132 RH |
4692 | if (s == NULL) |
4693 | err = "bfd_make_section"; | |
252b5132 RH |
4694 | if (err == NULL) |
4695 | { | |
4696 | bfd_size_type size; | |
4697 | ||
4698 | size = 0; | |
4699 | for (b = info.data.head; b != NULL; b = b->next) | |
4700 | size += b->c; | |
4701 | if (! bfd_set_section_size (abfd, s, size)) | |
4702 | err = "bfd_set_section_size"; | |
4703 | } | |
4704 | if (err == NULL) | |
4705 | { | |
4706 | file_ptr offset; | |
4707 | ||
4708 | offset = 0; | |
4709 | for (b = info.data.head; b != NULL; b = b->next) | |
4710 | { | |
4711 | if (! bfd_set_section_contents (abfd, s, b->buf, offset, b->c)) | |
4712 | { | |
4713 | err = "bfd_set_section_contents"; | |
4714 | break; | |
4715 | } | |
4716 | offset += b->c; | |
4717 | } | |
4718 | } | |
4719 | ||
4720 | if (err != NULL) | |
4721 | { | |
4722 | fprintf (stderr, "%s: %s: %s\n", bfd_get_filename (abfd), err, | |
4723 | bfd_errmsg (bfd_get_error ())); | |
b34976b6 | 4724 | return FALSE; |
252b5132 RH |
4725 | } |
4726 | ||
4727 | bfd_hash_table_free (&info.typedefs.root); | |
4728 | bfd_hash_table_free (&info.tags.root); | |
4729 | ||
b34976b6 | 4730 | return TRUE; |
252b5132 RH |
4731 | } |
4732 | ||
4733 | /* Write out information for an undefined tag. This is called via | |
4734 | ieee_name_type_hash_traverse. */ | |
4735 | ||
b34976b6 | 4736 | static bfd_boolean |
2da42df6 | 4737 | ieee_write_undefined_tag (struct ieee_name_type_hash_entry *h, void *p) |
252b5132 RH |
4738 | { |
4739 | struct ieee_handle *info = (struct ieee_handle *) p; | |
4740 | struct ieee_name_type *nt; | |
4741 | ||
4742 | for (nt = h->types; nt != NULL; nt = nt->next) | |
4743 | { | |
4744 | unsigned int name_indx; | |
4745 | char code; | |
4746 | ||
4747 | if (nt->kind == DEBUG_KIND_ILLEGAL) | |
4748 | continue; | |
4749 | ||
4750 | if (ieee_buffer_emptyp (&info->global_types)) | |
4751 | { | |
4752 | if (! ieee_change_buffer (info, &info->global_types) | |
4753 | || ! ieee_write_byte (info, (int) ieee_bb_record_enum) | |
4754 | || ! ieee_write_byte (info, 2) | |
4755 | || ! ieee_write_number (info, 0) | |
4756 | || ! ieee_write_id (info, "")) | |
4757 | { | |
b34976b6 AM |
4758 | info->error = TRUE; |
4759 | return FALSE; | |
252b5132 RH |
4760 | } |
4761 | } | |
4762 | else | |
4763 | { | |
4764 | if (! ieee_change_buffer (info, &info->global_types)) | |
4765 | { | |
b34976b6 AM |
4766 | info->error = TRUE; |
4767 | return FALSE; | |
252b5132 RH |
4768 | } |
4769 | } | |
4770 | ||
4771 | name_indx = info->name_indx; | |
4772 | ++info->name_indx; | |
4773 | if (! ieee_write_byte (info, (int) ieee_nn_record) | |
4774 | || ! ieee_write_number (info, name_indx) | |
4775 | || ! ieee_write_id (info, nt->type.name) | |
4776 | || ! ieee_write_byte (info, (int) ieee_ty_record_enum) | |
4777 | || ! ieee_write_number (info, nt->type.indx) | |
4778 | || ! ieee_write_byte (info, 0xce) | |
4779 | || ! ieee_write_number (info, name_indx)) | |
4780 | { | |
b34976b6 AM |
4781 | info->error = TRUE; |
4782 | return FALSE; | |
252b5132 RH |
4783 | } |
4784 | ||
4785 | switch (nt->kind) | |
4786 | { | |
4787 | default: | |
4788 | abort (); | |
b34976b6 AM |
4789 | info->error = TRUE; |
4790 | return FALSE; | |
252b5132 RH |
4791 | case DEBUG_KIND_STRUCT: |
4792 | case DEBUG_KIND_CLASS: | |
4793 | code = 'S'; | |
4794 | break; | |
4795 | case DEBUG_KIND_UNION: | |
4796 | case DEBUG_KIND_UNION_CLASS: | |
4797 | code = 'U'; | |
4798 | break; | |
4799 | case DEBUG_KIND_ENUM: | |
4800 | code = 'E'; | |
4801 | break; | |
4802 | } | |
4803 | if (! ieee_write_number (info, code) | |
4804 | || ! ieee_write_number (info, 0)) | |
4805 | { | |
b34976b6 AM |
4806 | info->error = TRUE; |
4807 | return FALSE; | |
252b5132 RH |
4808 | } |
4809 | } | |
4810 | ||
b34976b6 | 4811 | return TRUE; |
252b5132 RH |
4812 | } |
4813 | ||
4814 | /* Start writing out information for a compilation unit. */ | |
4815 | ||
b34976b6 | 4816 | static bfd_boolean |
2da42df6 | 4817 | ieee_start_compilation_unit (void *p, const char *filename) |
252b5132 RH |
4818 | { |
4819 | struct ieee_handle *info = (struct ieee_handle *) p; | |
4820 | const char *modname; | |
c7f2731e | 4821 | #ifdef HAVE_DOS_BASED_FILE_SYSTEM |
5af11cab | 4822 | const char *backslash; |
c7f2731e | 4823 | #endif |
252b5132 RH |
4824 | char *c, *s; |
4825 | unsigned int nindx; | |
4826 | ||
4827 | if (info->filename != NULL) | |
4828 | { | |
4829 | if (! ieee_finish_compilation_unit (info)) | |
b34976b6 | 4830 | return FALSE; |
252b5132 RH |
4831 | } |
4832 | ||
4833 | info->filename = filename; | |
4834 | modname = strrchr (filename, '/'); | |
c7f2731e | 4835 | #ifdef HAVE_DOS_BASED_FILE_SYSTEM |
5af11cab | 4836 | /* We could have a mixed forward/back slash case. */ |
2ab47eed AM |
4837 | backslash = strrchr (filename, '\\'); |
4838 | if (modname == NULL || (backslash != NULL && backslash > modname)) | |
5af11cab | 4839 | modname = backslash; |
c7f2731e | 4840 | #endif |
5af11cab | 4841 | |
252b5132 RH |
4842 | if (modname != NULL) |
4843 | ++modname; | |
5af11cab AM |
4844 | #ifdef HAVE_DOS_BASED_FILE_SYSTEM |
4845 | else if (filename[0] && filename[1] == ':') | |
4846 | modname = filename + 2; | |
4847 | #endif | |
252b5132 | 4848 | else |
5af11cab AM |
4849 | modname = filename; |
4850 | ||
252b5132 RH |
4851 | c = xstrdup (modname); |
4852 | s = strrchr (c, '.'); | |
4853 | if (s != NULL) | |
4854 | *s = '\0'; | |
4855 | info->modname = c; | |
4856 | ||
4857 | if (! ieee_init_buffer (info, &info->types) | |
4858 | || ! ieee_init_buffer (info, &info->vars) | |
4859 | || ! ieee_init_buffer (info, &info->cxx) | |
4860 | || ! ieee_init_buffer (info, &info->linenos)) | |
b34976b6 | 4861 | return FALSE; |
252b5132 RH |
4862 | info->ranges = NULL; |
4863 | ||
4864 | /* Always include a BB1 and a BB3 block. That is what the output of | |
4865 | the MRI linker seems to look like. */ | |
4866 | if (! ieee_change_buffer (info, &info->types) | |
4867 | || ! ieee_write_byte (info, (int) ieee_bb_record_enum) | |
4868 | || ! ieee_write_byte (info, 1) | |
4869 | || ! ieee_write_number (info, 0) | |
4870 | || ! ieee_write_id (info, info->modname)) | |
b34976b6 | 4871 | return FALSE; |
252b5132 RH |
4872 | |
4873 | nindx = info->name_indx; | |
4874 | ++info->name_indx; | |
4875 | if (! ieee_change_buffer (info, &info->vars) | |
4876 | || ! ieee_write_byte (info, (int) ieee_bb_record_enum) | |
4877 | || ! ieee_write_byte (info, 3) | |
4878 | || ! ieee_write_number (info, 0) | |
4879 | || ! ieee_write_id (info, info->modname)) | |
b34976b6 | 4880 | return FALSE; |
252b5132 | 4881 | |
b34976b6 | 4882 | return TRUE; |
252b5132 RH |
4883 | } |
4884 | ||
4885 | /* Finish up a compilation unit. */ | |
4886 | ||
b34976b6 | 4887 | static bfd_boolean |
2da42df6 | 4888 | ieee_finish_compilation_unit (struct ieee_handle *info) |
252b5132 RH |
4889 | { |
4890 | struct ieee_range *r; | |
4891 | ||
4892 | if (! ieee_buffer_emptyp (&info->types)) | |
4893 | { | |
4894 | if (! ieee_change_buffer (info, &info->types) | |
4895 | || ! ieee_write_byte (info, (int) ieee_be_record_enum)) | |
b34976b6 | 4896 | return FALSE; |
252b5132 RH |
4897 | } |
4898 | ||
4899 | if (! ieee_buffer_emptyp (&info->cxx)) | |
4900 | { | |
4901 | /* Append any C++ information to the global function and | |
4902 | variable information. */ | |
4903 | assert (! ieee_buffer_emptyp (&info->vars)); | |
4904 | if (! ieee_change_buffer (info, &info->vars)) | |
b34976b6 | 4905 | return FALSE; |
252b5132 RH |
4906 | |
4907 | /* We put the pmisc records in a dummy procedure, just as the | |
4908 | MRI compiler does. */ | |
4909 | if (! ieee_write_byte (info, (int) ieee_bb_record_enum) | |
4910 | || ! ieee_write_byte (info, 6) | |
4911 | || ! ieee_write_number (info, 0) | |
4912 | || ! ieee_write_id (info, "__XRYCPP") | |
4913 | || ! ieee_write_number (info, 0) | |
4914 | || ! ieee_write_number (info, 0) | |
4915 | || ! ieee_write_number (info, info->highaddr - 1) | |
4916 | || ! ieee_append_buffer (info, &info->vars, &info->cxx) | |
4917 | || ! ieee_change_buffer (info, &info->vars) | |
4918 | || ! ieee_write_byte (info, (int) ieee_be_record_enum) | |
4919 | || ! ieee_write_number (info, info->highaddr - 1)) | |
b34976b6 | 4920 | return FALSE; |
252b5132 RH |
4921 | } |
4922 | ||
4923 | if (! ieee_buffer_emptyp (&info->vars)) | |
4924 | { | |
4925 | if (! ieee_change_buffer (info, &info->vars) | |
4926 | || ! ieee_write_byte (info, (int) ieee_be_record_enum)) | |
b34976b6 | 4927 | return FALSE; |
252b5132 RH |
4928 | } |
4929 | ||
4930 | if (info->pending_lineno_filename != NULL) | |
4931 | { | |
4932 | /* Force out the pending line number. */ | |
2da42df6 | 4933 | if (! ieee_lineno ((void *) info, (const char *) NULL, 0, (bfd_vma) -1)) |
b34976b6 | 4934 | return FALSE; |
252b5132 RH |
4935 | } |
4936 | if (! ieee_buffer_emptyp (&info->linenos)) | |
4937 | { | |
4938 | if (! ieee_change_buffer (info, &info->linenos) | |
4939 | || ! ieee_write_byte (info, (int) ieee_be_record_enum)) | |
b34976b6 | 4940 | return FALSE; |
252b5132 RH |
4941 | if (strcmp (info->filename, info->lineno_filename) != 0) |
4942 | { | |
4943 | /* We were not in the main file. We just closed the | |
4944 | included line number block, and now we must close the | |
4945 | main line number block. */ | |
4946 | if (! ieee_write_byte (info, (int) ieee_be_record_enum)) | |
b34976b6 | 4947 | return FALSE; |
252b5132 RH |
4948 | } |
4949 | } | |
4950 | ||
4951 | if (! ieee_append_buffer (info, &info->data, &info->types) | |
4952 | || ! ieee_append_buffer (info, &info->data, &info->vars) | |
4953 | || ! ieee_append_buffer (info, &info->data, &info->linenos)) | |
b34976b6 | 4954 | return FALSE; |
252b5132 RH |
4955 | |
4956 | /* Build BB10/BB11 blocks based on the ranges we recorded. */ | |
4957 | if (! ieee_change_buffer (info, &info->data)) | |
b34976b6 | 4958 | return FALSE; |
252b5132 RH |
4959 | |
4960 | if (! ieee_write_byte (info, (int) ieee_bb_record_enum) | |
4961 | || ! ieee_write_byte (info, 10) | |
4962 | || ! ieee_write_number (info, 0) | |
4963 | || ! ieee_write_id (info, info->modname) | |
4964 | || ! ieee_write_id (info, "") | |
4965 | || ! ieee_write_number (info, 0) | |
4966 | || ! ieee_write_id (info, "GNU objcopy")) | |
b34976b6 | 4967 | return FALSE; |
252b5132 RH |
4968 | |
4969 | for (r = info->ranges; r != NULL; r = r->next) | |
4970 | { | |
4971 | bfd_vma low, high; | |
4972 | asection *s; | |
4973 | int kind; | |
4974 | ||
4975 | low = r->low; | |
4976 | high = r->high; | |
4977 | ||
4978 | /* Find the section corresponding to this range. */ | |
4979 | for (s = info->abfd->sections; s != NULL; s = s->next) | |
4980 | { | |
4981 | if (bfd_get_section_vma (info->abfd, s) <= low | |
4982 | && high <= (bfd_get_section_vma (info->abfd, s) | |
4983 | + bfd_section_size (info->abfd, s))) | |
4984 | break; | |
4985 | } | |
4986 | ||
4987 | if (s == NULL) | |
4988 | { | |
4989 | /* Just ignore this range. */ | |
4990 | continue; | |
4991 | } | |
4992 | ||
4993 | /* Coalesce ranges if it seems reasonable. */ | |
4994 | while (r->next != NULL | |
4995 | && high + 0x1000 >= r->next->low | |
4996 | && (r->next->high | |
4997 | <= (bfd_get_section_vma (info->abfd, s) | |
4998 | + bfd_section_size (info->abfd, s)))) | |
4999 | { | |
5000 | r = r->next; | |
5001 | high = r->high; | |
5002 | } | |
5003 | ||
5004 | if ((s->flags & SEC_CODE) != 0) | |
5005 | kind = 1; | |
5006 | else if ((s->flags & SEC_READONLY) != 0) | |
5007 | kind = 3; | |
5008 | else | |
5009 | kind = 2; | |
5010 | ||
5011 | if (! ieee_write_byte (info, (int) ieee_bb_record_enum) | |
5012 | || ! ieee_write_byte (info, 11) | |
5013 | || ! ieee_write_number (info, 0) | |
5014 | || ! ieee_write_id (info, "") | |
5015 | || ! ieee_write_number (info, kind) | |
5016 | || ! ieee_write_number (info, s->index + IEEE_SECTION_NUMBER_BASE) | |
5017 | || ! ieee_write_number (info, low) | |
5018 | || ! ieee_write_byte (info, (int) ieee_be_record_enum) | |
5019 | || ! ieee_write_number (info, high - low)) | |
b34976b6 | 5020 | return FALSE; |
252b5132 RH |
5021 | |
5022 | /* Add this range to the list of global ranges. */ | |
b34976b6 AM |
5023 | if (! ieee_add_range (info, TRUE, low, high)) |
5024 | return FALSE; | |
252b5132 RH |
5025 | } |
5026 | ||
5027 | if (! ieee_write_byte (info, (int) ieee_be_record_enum)) | |
b34976b6 | 5028 | return FALSE; |
252b5132 | 5029 | |
b34976b6 | 5030 | return TRUE; |
252b5132 RH |
5031 | } |
5032 | ||
5033 | /* Add BB11 blocks describing each range that we have not already | |
5034 | described. */ | |
5035 | ||
5036 | static void | |
2da42df6 | 5037 | ieee_add_bb11_blocks (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *data) |
252b5132 RH |
5038 | { |
5039 | struct ieee_handle *info = (struct ieee_handle *) data; | |
5040 | bfd_vma low, high; | |
5041 | struct ieee_range *r; | |
5042 | ||
5043 | low = bfd_get_section_vma (abfd, sec); | |
5044 | high = low + bfd_section_size (abfd, sec); | |
5045 | ||
5046 | /* Find the first range at or after this section. The ranges are | |
5047 | sorted by address. */ | |
5048 | for (r = info->global_ranges; r != NULL; r = r->next) | |
5049 | if (r->high > low) | |
5050 | break; | |
5051 | ||
5052 | while (low < high) | |
5053 | { | |
5054 | if (r == NULL || r->low >= high) | |
5055 | { | |
5056 | if (! ieee_add_bb11 (info, sec, low, high)) | |
b34976b6 | 5057 | info->error = TRUE; |
252b5132 RH |
5058 | return; |
5059 | } | |
5060 | ||
5061 | if (low < r->low | |
5062 | && r->low - low > 0x100) | |
5063 | { | |
5064 | if (! ieee_add_bb11 (info, sec, low, r->low)) | |
5065 | { | |
b34976b6 | 5066 | info->error = TRUE; |
252b5132 RH |
5067 | return; |
5068 | } | |
5069 | } | |
5070 | low = r->high; | |
5071 | ||
5072 | r = r->next; | |
5073 | } | |
5074 | } | |
5075 | ||
5076 | /* Add a single BB11 block for a range. We add it to info->vars. */ | |
5077 | ||
b34976b6 | 5078 | static bfd_boolean |
2da42df6 AJ |
5079 | ieee_add_bb11 (struct ieee_handle *info, asection *sec, bfd_vma low, |
5080 | bfd_vma high) | |
252b5132 RH |
5081 | { |
5082 | int kind; | |
5083 | ||
5084 | if (! ieee_buffer_emptyp (&info->vars)) | |
5085 | { | |
5086 | if (! ieee_change_buffer (info, &info->vars)) | |
b34976b6 | 5087 | return FALSE; |
252b5132 RH |
5088 | } |
5089 | else | |
5090 | { | |
956eedd4 AM |
5091 | const char *filename, *modname; |
5092 | #ifdef HAVE_DOS_BASED_FILE_SYSTEM | |
5093 | const char *backslash; | |
5094 | #endif | |
252b5132 RH |
5095 | char *c, *s; |
5096 | ||
5097 | /* Start the enclosing BB10 block. */ | |
5098 | filename = bfd_get_filename (info->abfd); | |
5099 | modname = strrchr (filename, '/'); | |
956eedd4 | 5100 | #ifdef HAVE_DOS_BASED_FILE_SYSTEM |
2ab47eed AM |
5101 | backslash = strrchr (filename, '\\'); |
5102 | if (modname == NULL || (backslash != NULL && backslash > modname)) | |
5af11cab | 5103 | modname = backslash; |
956eedd4 | 5104 | #endif |
5af11cab | 5105 | |
252b5132 RH |
5106 | if (modname != NULL) |
5107 | ++modname; | |
5af11cab AM |
5108 | #ifdef HAVE_DOS_BASED_FILE_SYSTEM |
5109 | else if (filename[0] && filename[1] == ':') | |
5110 | modname = filename + 2; | |
5111 | #endif | |
252b5132 | 5112 | else |
5af11cab AM |
5113 | modname = filename; |
5114 | ||
252b5132 RH |
5115 | c = xstrdup (modname); |
5116 | s = strrchr (c, '.'); | |
5117 | if (s != NULL) | |
5118 | *s = '\0'; | |
5119 | ||
5120 | if (! ieee_change_buffer (info, &info->vars) | |
5121 | || ! ieee_write_byte (info, (int) ieee_bb_record_enum) | |
5122 | || ! ieee_write_byte (info, 10) | |
5123 | || ! ieee_write_number (info, 0) | |
5124 | || ! ieee_write_id (info, c) | |
5125 | || ! ieee_write_id (info, "") | |
5126 | || ! ieee_write_number (info, 0) | |
5127 | || ! ieee_write_id (info, "GNU objcopy")) | |
b34976b6 | 5128 | return FALSE; |
252b5132 RH |
5129 | |
5130 | free (c); | |
5131 | } | |
5132 | ||
5133 | if ((sec->flags & SEC_CODE) != 0) | |
5134 | kind = 1; | |
5135 | else if ((sec->flags & SEC_READONLY) != 0) | |
5136 | kind = 3; | |
5137 | else | |
5138 | kind = 2; | |
5139 | ||
5140 | if (! ieee_write_byte (info, (int) ieee_bb_record_enum) | |
5141 | || ! ieee_write_byte (info, 11) | |
5142 | || ! ieee_write_number (info, 0) | |
5143 | || ! ieee_write_id (info, "") | |
5144 | || ! ieee_write_number (info, kind) | |
5145 | || ! ieee_write_number (info, sec->index + IEEE_SECTION_NUMBER_BASE) | |
5146 | || ! ieee_write_number (info, low) | |
5147 | || ! ieee_write_byte (info, (int) ieee_be_record_enum) | |
5148 | || ! ieee_write_number (info, high - low)) | |
b34976b6 | 5149 | return FALSE; |
252b5132 | 5150 | |
b34976b6 | 5151 | return TRUE; |
252b5132 RH |
5152 | } |
5153 | ||
5154 | /* Start recording information from a particular source file. This is | |
5155 | used to record which file defined which types, variables, etc. It | |
5156 | is not used for line numbers, since the lineno entry point passes | |
5157 | down the file name anyhow. IEEE debugging information doesn't seem | |
5158 | to store this information anywhere. */ | |
5159 | ||
b34976b6 | 5160 | static bfd_boolean |
2da42df6 AJ |
5161 | ieee_start_source (void *p ATTRIBUTE_UNUSED, |
5162 | const char *filename ATTRIBUTE_UNUSED) | |
252b5132 | 5163 | { |
b34976b6 | 5164 | return TRUE; |
252b5132 RH |
5165 | } |
5166 | ||
5167 | /* Make an empty type. */ | |
5168 | ||
b34976b6 | 5169 | static bfd_boolean |
2da42df6 | 5170 | ieee_empty_type (void *p) |
252b5132 RH |
5171 | { |
5172 | struct ieee_handle *info = (struct ieee_handle *) p; | |
5173 | ||
b34976b6 | 5174 | return ieee_push_type (info, (int) builtin_unknown, 0, FALSE, FALSE); |
252b5132 RH |
5175 | } |
5176 | ||
5177 | /* Make a void type. */ | |
5178 | ||
b34976b6 | 5179 | static bfd_boolean |
2da42df6 | 5180 | ieee_void_type (void *p) |
252b5132 RH |
5181 | { |
5182 | struct ieee_handle *info = (struct ieee_handle *) p; | |
5183 | ||
b34976b6 | 5184 | return ieee_push_type (info, (int) builtin_void, 0, FALSE, FALSE); |
252b5132 RH |
5185 | } |
5186 | ||
5187 | /* Make an integer type. */ | |
5188 | ||
b34976b6 | 5189 | static bfd_boolean |
2da42df6 | 5190 | ieee_int_type (void *p, unsigned int size, bfd_boolean unsignedp) |
252b5132 RH |
5191 | { |
5192 | struct ieee_handle *info = (struct ieee_handle *) p; | |
5193 | unsigned int indx; | |
5194 | ||
5195 | switch (size) | |
5196 | { | |
5197 | case 1: | |
5198 | indx = (int) builtin_signed_char; | |
5199 | break; | |
5200 | case 2: | |
5201 | indx = (int) builtin_signed_short_int; | |
5202 | break; | |
5203 | case 4: | |
5204 | indx = (int) builtin_signed_long; | |
5205 | break; | |
5206 | case 8: | |
5207 | indx = (int) builtin_signed_long_long; | |
5208 | break; | |
5209 | default: | |
5210 | fprintf (stderr, _("IEEE unsupported integer type size %u\n"), size); | |
b34976b6 | 5211 | return FALSE; |
252b5132 RH |
5212 | } |
5213 | ||
5214 | if (unsignedp) | |
5215 | ++indx; | |
5216 | ||
b34976b6 | 5217 | return ieee_push_type (info, indx, size, unsignedp, FALSE); |
252b5132 RH |
5218 | } |
5219 | ||
5220 | /* Make a floating point type. */ | |
5221 | ||
b34976b6 | 5222 | static bfd_boolean |
2da42df6 | 5223 | ieee_float_type (void *p, unsigned int size) |
252b5132 RH |
5224 | { |
5225 | struct ieee_handle *info = (struct ieee_handle *) p; | |
5226 | unsigned int indx; | |
5227 | ||
5228 | switch (size) | |
5229 | { | |
5230 | case 4: | |
5231 | indx = (int) builtin_float; | |
5232 | break; | |
5233 | case 8: | |
5234 | indx = (int) builtin_double; | |
5235 | break; | |
5236 | case 12: | |
5237 | /* FIXME: This size really depends upon the processor. */ | |
5238 | indx = (int) builtin_long_double; | |
5239 | break; | |
5240 | case 16: | |
5241 | indx = (int) builtin_long_long_double; | |
5242 | break; | |
5243 | default: | |
5244 | fprintf (stderr, _("IEEE unsupported float type size %u\n"), size); | |
b34976b6 | 5245 | return FALSE; |
252b5132 RH |
5246 | } |
5247 | ||
b34976b6 | 5248 | return ieee_push_type (info, indx, size, FALSE, FALSE); |
252b5132 RH |
5249 | } |
5250 | ||
5251 | /* Make a complex type. */ | |
5252 | ||
b34976b6 | 5253 | static bfd_boolean |
2da42df6 | 5254 | ieee_complex_type (void *p, unsigned int size) |
252b5132 RH |
5255 | { |
5256 | struct ieee_handle *info = (struct ieee_handle *) p; | |
5257 | char code; | |
5258 | ||
5259 | switch (size) | |
5260 | { | |
5261 | case 4: | |
5262 | if (info->complex_float_index != 0) | |
5263 | return ieee_push_type (info, info->complex_float_index, size * 2, | |
b34976b6 | 5264 | FALSE, FALSE); |
252b5132 RH |
5265 | code = 'c'; |
5266 | break; | |
5267 | case 12: | |
5268 | case 16: | |
5269 | /* These cases can be output by gcc -gstabs. Outputting the | |
5270 | wrong type is better than crashing. */ | |
5271 | case 8: | |
5272 | if (info->complex_double_index != 0) | |
5273 | return ieee_push_type (info, info->complex_double_index, size * 2, | |
b34976b6 | 5274 | FALSE, FALSE); |
252b5132 RH |
5275 | code = 'd'; |
5276 | break; | |
5277 | default: | |
5278 | fprintf (stderr, _("IEEE unsupported complex type size %u\n"), size); | |
b34976b6 | 5279 | return FALSE; |
252b5132 RH |
5280 | } |
5281 | ||
5282 | /* FIXME: I don't know what the string is for. */ | |
b34976b6 | 5283 | if (! ieee_define_type (info, size * 2, FALSE, FALSE) |
252b5132 RH |
5284 | || ! ieee_write_number (info, code) |
5285 | || ! ieee_write_id (info, "")) | |
b34976b6 | 5286 | return FALSE; |
252b5132 RH |
5287 | |
5288 | if (size == 4) | |
5289 | info->complex_float_index = info->type_stack->type.indx; | |
5290 | else | |
5291 | info->complex_double_index = info->type_stack->type.indx; | |
5292 | ||
b34976b6 | 5293 | return TRUE; |
252b5132 RH |
5294 | } |
5295 | ||
5296 | /* Make a boolean type. IEEE doesn't support these, so we just make | |
5297 | an integer type instead. */ | |
5298 | ||
b34976b6 | 5299 | static bfd_boolean |
2da42df6 | 5300 | ieee_bool_type (void *p, unsigned int size) |
252b5132 | 5301 | { |
b34976b6 | 5302 | return ieee_int_type (p, size, TRUE); |
252b5132 RH |
5303 | } |
5304 | ||
5305 | /* Make an enumeration. */ | |
5306 | ||
b34976b6 | 5307 | static bfd_boolean |
2da42df6 AJ |
5308 | ieee_enum_type (void *p, const char *tag, const char **names, |
5309 | bfd_signed_vma *vals) | |
252b5132 RH |
5310 | { |
5311 | struct ieee_handle *info = (struct ieee_handle *) p; | |
5312 | struct ieee_defined_enum *e; | |
b34976b6 | 5313 | bfd_boolean localp, simple; |
252b5132 RH |
5314 | unsigned int indx; |
5315 | int i = 0; | |
5316 | ||
b34976b6 | 5317 | localp = FALSE; |
252b5132 RH |
5318 | indx = (unsigned int) -1; |
5319 | for (e = info->enums; e != NULL; e = e->next) | |
5320 | { | |
5321 | if (tag == NULL) | |
5322 | { | |
5323 | if (e->tag != NULL) | |
5324 | continue; | |
5325 | } | |
5326 | else | |
5327 | { | |
5328 | if (e->tag == NULL | |
5329 | || tag[0] != e->tag[0] | |
5330 | || strcmp (tag, e->tag) != 0) | |
5331 | continue; | |
5332 | } | |
5333 | ||
5334 | if (! e->defined) | |
5335 | { | |
5336 | /* This enum tag has been seen but not defined. */ | |
5337 | indx = e->indx; | |
5338 | break; | |
5339 | } | |
5340 | ||
5341 | if (names != NULL && e->names != NULL) | |
5342 | { | |
5343 | for (i = 0; names[i] != NULL && e->names[i] != NULL; i++) | |
5344 | { | |
5345 | if (names[i][0] != e->names[i][0] | |
5346 | || vals[i] != e->vals[i] | |
5347 | || strcmp (names[i], e->names[i]) != 0) | |
5348 | break; | |
5349 | } | |
5350 | } | |
5351 | ||
5352 | if ((names == NULL && e->names == NULL) | |
5353 | || (names != NULL | |
5354 | && e->names != NULL | |
5355 | && names[i] == NULL | |
5356 | && e->names[i] == NULL)) | |
5357 | { | |
5358 | /* We've seen this enum before. */ | |
b34976b6 | 5359 | return ieee_push_type (info, e->indx, 0, TRUE, FALSE); |
252b5132 RH |
5360 | } |
5361 | ||
5362 | if (tag != NULL) | |
5363 | { | |
5364 | /* We've already seen an enum of the same name, so we must make | |
5365 | sure to output this one locally. */ | |
b34976b6 | 5366 | localp = TRUE; |
252b5132 RH |
5367 | break; |
5368 | } | |
5369 | } | |
5370 | ||
5371 | /* If this is a simple enumeration, in which the values start at 0 | |
5372 | and always increment by 1, we can use type E. Otherwise we must | |
5373 | use type N. */ | |
5374 | ||
b34976b6 | 5375 | simple = TRUE; |
252b5132 RH |
5376 | if (names != NULL) |
5377 | { | |
5378 | for (i = 0; names[i] != NULL; i++) | |
5379 | { | |
5380 | if (vals[i] != i) | |
5381 | { | |
b34976b6 | 5382 | simple = FALSE; |
252b5132 RH |
5383 | break; |
5384 | } | |
5385 | } | |
5386 | } | |
5387 | ||
b34976b6 | 5388 | if (! ieee_define_named_type (info, tag, indx, 0, TRUE, localp, |
252b5132 RH |
5389 | (struct ieee_buflist *) NULL) |
5390 | || ! ieee_write_number (info, simple ? 'E' : 'N')) | |
b34976b6 | 5391 | return FALSE; |
252b5132 RH |
5392 | if (simple) |
5393 | { | |
5394 | /* FIXME: This is supposed to be the enumeration size, but we | |
5395 | don't store that. */ | |
5396 | if (! ieee_write_number (info, 4)) | |
b34976b6 | 5397 | return FALSE; |
252b5132 RH |
5398 | } |
5399 | if (names != NULL) | |
5400 | { | |
5401 | for (i = 0; names[i] != NULL; i++) | |
5402 | { | |
5403 | if (! ieee_write_id (info, names[i])) | |
b34976b6 | 5404 | return FALSE; |
252b5132 RH |
5405 | if (! simple) |
5406 | { | |
5407 | if (! ieee_write_number (info, vals[i])) | |
b34976b6 | 5408 | return FALSE; |
252b5132 RH |
5409 | } |
5410 | } | |
5411 | } | |
5412 | ||
5413 | if (! localp) | |
5414 | { | |
5415 | if (indx == (unsigned int) -1) | |
5416 | { | |
5417 | e = (struct ieee_defined_enum *) xmalloc (sizeof *e); | |
5418 | memset (e, 0, sizeof *e); | |
5419 | e->indx = info->type_stack->type.indx; | |
5420 | e->tag = tag; | |
5421 | ||
5422 | e->next = info->enums; | |
5423 | info->enums = e; | |
5424 | } | |
5425 | ||
5426 | e->names = names; | |
5427 | e->vals = vals; | |
b34976b6 | 5428 | e->defined = TRUE; |
252b5132 RH |
5429 | } |
5430 | ||
b34976b6 | 5431 | return TRUE; |
252b5132 RH |
5432 | } |
5433 | ||
5434 | /* Make a pointer type. */ | |
5435 | ||
b34976b6 | 5436 | static bfd_boolean |
2da42df6 | 5437 | ieee_pointer_type (void *p) |
252b5132 RH |
5438 | { |
5439 | struct ieee_handle *info = (struct ieee_handle *) p; | |
b34976b6 | 5440 | bfd_boolean localp; |
252b5132 RH |
5441 | unsigned int indx; |
5442 | struct ieee_modified_type *m = NULL; | |
5443 | ||
5444 | localp = info->type_stack->type.localp; | |
5445 | indx = ieee_pop_type (info); | |
5446 | ||
5447 | /* A pointer to a simple builtin type can be obtained by adding 32. | |
5448 | FIXME: Will this be a short pointer, and will that matter? */ | |
5449 | if (indx < 32) | |
b34976b6 | 5450 | return ieee_push_type (info, indx + 32, 0, TRUE, FALSE); |
252b5132 RH |
5451 | |
5452 | if (! localp) | |
5453 | { | |
5454 | m = ieee_get_modified_info (p, indx); | |
5455 | if (m == NULL) | |
b34976b6 | 5456 | return FALSE; |
252b5132 RH |
5457 | |
5458 | /* FIXME: The size should depend upon the architecture. */ | |
5459 | if (m->pointer > 0) | |
b34976b6 | 5460 | return ieee_push_type (info, m->pointer, 4, TRUE, FALSE); |
252b5132 RH |
5461 | } |
5462 | ||
b34976b6 | 5463 | if (! ieee_define_type (info, 4, TRUE, localp) |
252b5132 RH |
5464 | || ! ieee_write_number (info, 'P') |
5465 | || ! ieee_write_number (info, indx)) | |
b34976b6 | 5466 | return FALSE; |
252b5132 RH |
5467 | |
5468 | if (! localp) | |
5469 | m->pointer = info->type_stack->type.indx; | |
5470 | ||
b34976b6 | 5471 | return TRUE; |
252b5132 RH |
5472 | } |
5473 | ||
5474 | /* Make a function type. This will be called for a method, but we | |
5475 | don't want to actually add it to the type table in that case. We | |
5476 | handle this by defining the type in a private buffer, and only | |
5477 | adding that buffer to the typedef block if we are going to use it. */ | |
5478 | ||
b34976b6 | 5479 | static bfd_boolean |
2da42df6 | 5480 | ieee_function_type (void *p, int argcount, bfd_boolean varargs) |
252b5132 RH |
5481 | { |
5482 | struct ieee_handle *info = (struct ieee_handle *) p; | |
b34976b6 | 5483 | bfd_boolean localp; |
252b5132 RH |
5484 | unsigned int *args = NULL; |
5485 | int i; | |
5486 | unsigned int retindx; | |
5487 | struct ieee_buflist fndef; | |
5488 | struct ieee_modified_type *m; | |
5489 | ||
b34976b6 | 5490 | localp = FALSE; |
252b5132 RH |
5491 | |
5492 | if (argcount > 0) | |
5493 | { | |
5494 | args = (unsigned int *) xmalloc (argcount * sizeof *args); | |
5495 | for (i = argcount - 1; i >= 0; i--) | |
5496 | { | |
5497 | if (info->type_stack->type.localp) | |
b34976b6 | 5498 | localp = TRUE; |
252b5132 RH |
5499 | args[i] = ieee_pop_type (info); |
5500 | } | |
5501 | } | |
5502 | else if (argcount < 0) | |
b34976b6 | 5503 | varargs = FALSE; |
252b5132 RH |
5504 | |
5505 | if (info->type_stack->type.localp) | |
b34976b6 | 5506 | localp = TRUE; |
252b5132 RH |
5507 | retindx = ieee_pop_type (info); |
5508 | ||
5509 | m = NULL; | |
5510 | if (argcount < 0 && ! localp) | |
5511 | { | |
5512 | m = ieee_get_modified_info (p, retindx); | |
5513 | if (m == NULL) | |
b34976b6 | 5514 | return FALSE; |
252b5132 RH |
5515 | |
5516 | if (m->function > 0) | |
b34976b6 | 5517 | return ieee_push_type (info, m->function, 0, TRUE, FALSE); |
252b5132 RH |
5518 | } |
5519 | ||
5520 | /* An attribute of 0x41 means that the frame and push mask are | |
5521 | unknown. */ | |
5522 | if (! ieee_init_buffer (info, &fndef) | |
5523 | || ! ieee_define_named_type (info, (const char *) NULL, | |
b34976b6 | 5524 | (unsigned int) -1, 0, TRUE, localp, |
252b5132 RH |
5525 | &fndef) |
5526 | || ! ieee_write_number (info, 'x') | |
5527 | || ! ieee_write_number (info, 0x41) | |
5528 | || ! ieee_write_number (info, 0) | |
5529 | || ! ieee_write_number (info, 0) | |
5530 | || ! ieee_write_number (info, retindx) | |
5531 | || ! ieee_write_number (info, (bfd_vma) argcount + (varargs ? 1 : 0))) | |
b34976b6 | 5532 | return FALSE; |
252b5132 RH |
5533 | if (argcount > 0) |
5534 | { | |
5535 | for (i = 0; i < argcount; i++) | |
5536 | if (! ieee_write_number (info, args[i])) | |
b34976b6 | 5537 | return FALSE; |
252b5132 RH |
5538 | free (args); |
5539 | } | |
5540 | if (varargs) | |
5541 | { | |
5542 | /* A varargs function is represented by writing out the last | |
5543 | argument as type void *, although this makes little sense. */ | |
5544 | if (! ieee_write_number (info, (bfd_vma) builtin_void + 32)) | |
b34976b6 | 5545 | return FALSE; |
252b5132 RH |
5546 | } |
5547 | ||
5548 | if (! ieee_write_number (info, 0)) | |
b34976b6 | 5549 | return FALSE; |
252b5132 RH |
5550 | |
5551 | /* We wrote the information into fndef, in case we don't need it. | |
5552 | It will be appended to info->types by ieee_pop_type. */ | |
5553 | info->type_stack->type.fndef = fndef; | |
5554 | ||
5555 | if (m != NULL) | |
5556 | m->function = info->type_stack->type.indx; | |
5557 | ||
b34976b6 | 5558 | return TRUE; |
252b5132 RH |
5559 | } |
5560 | ||
5561 | /* Make a reference type. */ | |
5562 | ||
b34976b6 | 5563 | static bfd_boolean |
2da42df6 | 5564 | ieee_reference_type (void *p) |
252b5132 RH |
5565 | { |
5566 | struct ieee_handle *info = (struct ieee_handle *) p; | |
5567 | ||
5568 | /* IEEE appears to record a normal pointer type, and then use a | |
5569 | pmisc record to indicate that it is really a reference. */ | |
5570 | ||
5571 | if (! ieee_pointer_type (p)) | |
b34976b6 AM |
5572 | return FALSE; |
5573 | info->type_stack->type.referencep = TRUE; | |
5574 | return TRUE; | |
252b5132 RH |
5575 | } |
5576 | ||
5577 | /* Make a range type. */ | |
5578 | ||
b34976b6 | 5579 | static bfd_boolean |
2da42df6 | 5580 | ieee_range_type (void *p, bfd_signed_vma low, bfd_signed_vma high) |
252b5132 RH |
5581 | { |
5582 | struct ieee_handle *info = (struct ieee_handle *) p; | |
5583 | unsigned int size; | |
b34976b6 | 5584 | bfd_boolean unsignedp, localp; |
252b5132 RH |
5585 | |
5586 | size = info->type_stack->type.size; | |
5587 | unsignedp = info->type_stack->type.unsignedp; | |
5588 | localp = info->type_stack->type.localp; | |
5589 | ieee_pop_unused_type (info); | |
5590 | return (ieee_define_type (info, size, unsignedp, localp) | |
5591 | && ieee_write_number (info, 'R') | |
5592 | && ieee_write_number (info, (bfd_vma) low) | |
5593 | && ieee_write_number (info, (bfd_vma) high) | |
5594 | && ieee_write_number (info, unsignedp ? 0 : 1) | |
5595 | && ieee_write_number (info, size)); | |
5596 | } | |
5597 | ||
5598 | /* Make an array type. */ | |
5599 | ||
b34976b6 | 5600 | static bfd_boolean |
2da42df6 AJ |
5601 | ieee_array_type (void *p, bfd_signed_vma low, bfd_signed_vma high, |
5602 | bfd_boolean stringp ATTRIBUTE_UNUSED) | |
252b5132 RH |
5603 | { |
5604 | struct ieee_handle *info = (struct ieee_handle *) p; | |
5605 | unsigned int eleindx; | |
b34976b6 | 5606 | bfd_boolean localp; |
252b5132 RH |
5607 | unsigned int size; |
5608 | struct ieee_modified_type *m = NULL; | |
5609 | struct ieee_modified_array_type *a; | |
5610 | ||
5611 | /* IEEE does not store the range, so we just ignore it. */ | |
5612 | ieee_pop_unused_type (info); | |
5613 | localp = info->type_stack->type.localp; | |
5614 | size = info->type_stack->type.size; | |
5615 | eleindx = ieee_pop_type (info); | |
5616 | ||
5617 | /* If we don't know the range, treat the size as exactly one | |
5618 | element. */ | |
5619 | if (low < high) | |
5620 | size *= (high - low) + 1; | |
5621 | ||
5622 | if (! localp) | |
5623 | { | |
5624 | m = ieee_get_modified_info (info, eleindx); | |
5625 | if (m == NULL) | |
b34976b6 | 5626 | return FALSE; |
252b5132 RH |
5627 | |
5628 | for (a = m->arrays; a != NULL; a = a->next) | |
5629 | { | |
5630 | if (a->low == low && a->high == high) | |
b34976b6 | 5631 | return ieee_push_type (info, a->indx, size, FALSE, FALSE); |
252b5132 RH |
5632 | } |
5633 | } | |
5634 | ||
b34976b6 | 5635 | if (! ieee_define_type (info, size, FALSE, localp) |
252b5132 RH |
5636 | || ! ieee_write_number (info, low == 0 ? 'Z' : 'C') |
5637 | || ! ieee_write_number (info, eleindx)) | |
b34976b6 | 5638 | return FALSE; |
252b5132 RH |
5639 | if (low != 0) |
5640 | { | |
5641 | if (! ieee_write_number (info, low)) | |
b34976b6 | 5642 | return FALSE; |
252b5132 RH |
5643 | } |
5644 | ||
5645 | if (! ieee_write_number (info, high + 1)) | |
b34976b6 | 5646 | return FALSE; |
252b5132 RH |
5647 | |
5648 | if (! localp) | |
5649 | { | |
5650 | a = (struct ieee_modified_array_type *) xmalloc (sizeof *a); | |
5651 | memset (a, 0, sizeof *a); | |
5652 | ||
5653 | a->indx = info->type_stack->type.indx; | |
5654 | a->low = low; | |
5655 | a->high = high; | |
5656 | ||
5657 | a->next = m->arrays; | |
5658 | m->arrays = a; | |
5659 | } | |
5660 | ||
b34976b6 | 5661 | return TRUE; |
252b5132 RH |
5662 | } |
5663 | ||
5664 | /* Make a set type. */ | |
5665 | ||
b34976b6 | 5666 | static bfd_boolean |
2da42df6 | 5667 | ieee_set_type (void *p, bfd_boolean bitstringp ATTRIBUTE_UNUSED) |
252b5132 RH |
5668 | { |
5669 | struct ieee_handle *info = (struct ieee_handle *) p; | |
b34976b6 | 5670 | bfd_boolean localp; |
252b5132 RH |
5671 | unsigned int eleindx; |
5672 | ||
5673 | localp = info->type_stack->type.localp; | |
5674 | eleindx = ieee_pop_type (info); | |
5675 | ||
5676 | /* FIXME: We don't know the size, so we just use 4. */ | |
5677 | ||
b34976b6 | 5678 | return (ieee_define_type (info, 0, TRUE, localp) |
252b5132 RH |
5679 | && ieee_write_number (info, 's') |
5680 | && ieee_write_number (info, 4) | |
5681 | && ieee_write_number (info, eleindx)); | |
5682 | } | |
5683 | ||
5684 | /* Make an offset type. */ | |
5685 | ||
b34976b6 | 5686 | static bfd_boolean |
2da42df6 | 5687 | ieee_offset_type (void *p) |
252b5132 RH |
5688 | { |
5689 | struct ieee_handle *info = (struct ieee_handle *) p; | |
5690 | unsigned int targetindx, baseindx; | |
5691 | ||
5692 | targetindx = ieee_pop_type (info); | |
5693 | baseindx = ieee_pop_type (info); | |
5694 | ||
5695 | /* FIXME: The MRI C++ compiler does not appear to generate any | |
5696 | useful type information about an offset type. It just records a | |
5697 | pointer to member as an integer. The MRI/HP IEEE spec does | |
5698 | describe a pmisc record which can be used for a pointer to | |
5699 | member. Unfortunately, it does not describe the target type, | |
5700 | which seems pretty important. I'm going to punt this for now. */ | |
5701 | ||
b34976b6 | 5702 | return ieee_int_type (p, 4, TRUE); |
c7f2731e | 5703 | } |
252b5132 RH |
5704 | |
5705 | /* Make a method type. */ | |
5706 | ||
b34976b6 | 5707 | static bfd_boolean |
2da42df6 AJ |
5708 | ieee_method_type (void *p, bfd_boolean domain, int argcount, |
5709 | bfd_boolean varargs) | |
252b5132 RH |
5710 | { |
5711 | struct ieee_handle *info = (struct ieee_handle *) p; | |
5712 | ||
5713 | /* FIXME: The MRI/HP IEEE spec defines a pmisc record to use for a | |
5714 | method, but the definition is incomplete. We just output an 'x' | |
5715 | type. */ | |
5716 | ||
5717 | if (domain) | |
5718 | ieee_pop_unused_type (info); | |
5719 | ||
5720 | return ieee_function_type (p, argcount, varargs); | |
5721 | } | |
5722 | ||
5723 | /* Make a const qualified type. */ | |
5724 | ||
b34976b6 | 5725 | static bfd_boolean |
2da42df6 | 5726 | ieee_const_type (void *p) |
252b5132 RH |
5727 | { |
5728 | struct ieee_handle *info = (struct ieee_handle *) p; | |
5729 | unsigned int size; | |
b34976b6 | 5730 | bfd_boolean unsignedp, localp; |
252b5132 RH |
5731 | unsigned int indx; |
5732 | struct ieee_modified_type *m = NULL; | |
5733 | ||
5734 | size = info->type_stack->type.size; | |
5735 | unsignedp = info->type_stack->type.unsignedp; | |
5736 | localp = info->type_stack->type.localp; | |
5737 | indx = ieee_pop_type (info); | |
5738 | ||
5739 | if (! localp) | |
5740 | { | |
5741 | m = ieee_get_modified_info (info, indx); | |
5742 | if (m == NULL) | |
b34976b6 | 5743 | return FALSE; |
252b5132 RH |
5744 | |
5745 | if (m->const_qualified > 0) | |
5746 | return ieee_push_type (info, m->const_qualified, size, unsignedp, | |
b34976b6 | 5747 | FALSE); |
252b5132 RH |
5748 | } |
5749 | ||
5750 | if (! ieee_define_type (info, size, unsignedp, localp) | |
5751 | || ! ieee_write_number (info, 'n') | |
5752 | || ! ieee_write_number (info, 1) | |
5753 | || ! ieee_write_number (info, indx)) | |
b34976b6 | 5754 | return FALSE; |
252b5132 RH |
5755 | |
5756 | if (! localp) | |
5757 | m->const_qualified = info->type_stack->type.indx; | |
5758 | ||
b34976b6 | 5759 | return TRUE; |
252b5132 RH |
5760 | } |
5761 | ||
5762 | /* Make a volatile qualified type. */ | |
5763 | ||
b34976b6 | 5764 | static bfd_boolean |
2da42df6 | 5765 | ieee_volatile_type (void *p) |
252b5132 RH |
5766 | { |
5767 | struct ieee_handle *info = (struct ieee_handle *) p; | |
5768 | unsigned int size; | |
b34976b6 | 5769 | bfd_boolean unsignedp, localp; |
252b5132 RH |
5770 | unsigned int indx; |
5771 | struct ieee_modified_type *m = NULL; | |
5772 | ||
5773 | size = info->type_stack->type.size; | |
5774 | unsignedp = info->type_stack->type.unsignedp; | |
5775 | localp = info->type_stack->type.localp; | |
5776 | indx = ieee_pop_type (info); | |
5777 | ||
5778 | if (! localp) | |
5779 | { | |
5780 | m = ieee_get_modified_info (info, indx); | |
5781 | if (m == NULL) | |
b34976b6 | 5782 | return FALSE; |
252b5132 RH |
5783 | |
5784 | if (m->volatile_qualified > 0) | |
5785 | return ieee_push_type (info, m->volatile_qualified, size, unsignedp, | |
b34976b6 | 5786 | FALSE); |
252b5132 RH |
5787 | } |
5788 | ||
5789 | if (! ieee_define_type (info, size, unsignedp, localp) | |
5790 | || ! ieee_write_number (info, 'n') | |
5791 | || ! ieee_write_number (info, 2) | |
5792 | || ! ieee_write_number (info, indx)) | |
b34976b6 | 5793 | return FALSE; |
252b5132 RH |
5794 | |
5795 | if (! localp) | |
5796 | m->volatile_qualified = info->type_stack->type.indx; | |
5797 | ||
b34976b6 | 5798 | return TRUE; |
252b5132 RH |
5799 | } |
5800 | ||
5801 | /* Convert an enum debug_visibility into a CXXFLAGS value. */ | |
5802 | ||
5803 | static unsigned int | |
2da42df6 | 5804 | ieee_vis_to_flags (enum debug_visibility visibility) |
252b5132 RH |
5805 | { |
5806 | switch (visibility) | |
5807 | { | |
5808 | default: | |
5809 | abort (); | |
5810 | case DEBUG_VISIBILITY_PUBLIC: | |
5811 | return CXXFLAGS_VISIBILITY_PUBLIC; | |
5812 | case DEBUG_VISIBILITY_PRIVATE: | |
5813 | return CXXFLAGS_VISIBILITY_PRIVATE; | |
5814 | case DEBUG_VISIBILITY_PROTECTED: | |
5815 | return CXXFLAGS_VISIBILITY_PROTECTED; | |
5816 | } | |
5817 | /*NOTREACHED*/ | |
5818 | } | |
5819 | ||
5820 | /* Start defining a struct type. We build it in the strdef field on | |
5821 | the stack, to avoid confusing type definitions required by the | |
5822 | fields with the struct type itself. */ | |
5823 | ||
b34976b6 | 5824 | static bfd_boolean |
2da42df6 AJ |
5825 | ieee_start_struct_type (void *p, const char *tag, unsigned int id, |
5826 | bfd_boolean structp, unsigned int size) | |
252b5132 RH |
5827 | { |
5828 | struct ieee_handle *info = (struct ieee_handle *) p; | |
b34976b6 AM |
5829 | bfd_boolean localp, ignorep; |
5830 | bfd_boolean copy; | |
252b5132 RH |
5831 | char ab[20]; |
5832 | const char *look; | |
5833 | struct ieee_name_type_hash_entry *h; | |
5834 | struct ieee_name_type *nt, *ntlook; | |
5835 | struct ieee_buflist strdef; | |
5836 | ||
b34976b6 AM |
5837 | localp = FALSE; |
5838 | ignorep = FALSE; | |
252b5132 RH |
5839 | |
5840 | /* We need to create a tag for internal use even if we don't want | |
5841 | one for external use. This will let us refer to an anonymous | |
5842 | struct. */ | |
5843 | if (tag != NULL) | |
5844 | { | |
5845 | look = tag; | |
b34976b6 | 5846 | copy = FALSE; |
252b5132 RH |
5847 | } |
5848 | else | |
5849 | { | |
5850 | sprintf (ab, "__anon%u", id); | |
5851 | look = ab; | |
b34976b6 | 5852 | copy = TRUE; |
252b5132 RH |
5853 | } |
5854 | ||
5855 | /* If we already have references to the tag, we must use the | |
5856 | existing type index. */ | |
b34976b6 | 5857 | h = ieee_name_type_hash_lookup (&info->tags, look, TRUE, copy); |
252b5132 | 5858 | if (h == NULL) |
b34976b6 | 5859 | return FALSE; |
252b5132 RH |
5860 | |
5861 | nt = NULL; | |
5862 | for (ntlook = h->types; ntlook != NULL; ntlook = ntlook->next) | |
5863 | { | |
5864 | if (ntlook->id == id) | |
5865 | nt = ntlook; | |
5866 | else if (! ntlook->type.localp) | |
5867 | { | |
5868 | /* We are creating a duplicate definition of a globally | |
5869 | defined tag. Force it to be local to avoid | |
5870 | confusion. */ | |
b34976b6 | 5871 | localp = TRUE; |
252b5132 RH |
5872 | } |
5873 | } | |
5874 | ||
5875 | if (nt != NULL) | |
5876 | { | |
5877 | assert (localp == nt->type.localp); | |
5878 | if (nt->kind == DEBUG_KIND_ILLEGAL && ! localp) | |
5879 | { | |
5880 | /* We've already seen a global definition of the type. | |
5881 | Ignore this new definition. */ | |
b34976b6 | 5882 | ignorep = TRUE; |
252b5132 RH |
5883 | } |
5884 | } | |
5885 | else | |
5886 | { | |
5887 | nt = (struct ieee_name_type *) xmalloc (sizeof *nt); | |
5888 | memset (nt, 0, sizeof *nt); | |
5889 | nt->id = id; | |
5890 | nt->type.name = h->root.string; | |
5891 | nt->next = h->types; | |
5892 | h->types = nt; | |
5893 | nt->type.indx = info->type_indx; | |
5894 | ++info->type_indx; | |
5895 | } | |
5896 | ||
5897 | nt->kind = DEBUG_KIND_ILLEGAL; | |
5898 | ||
5899 | if (! ieee_init_buffer (info, &strdef) | |
b34976b6 | 5900 | || ! ieee_define_named_type (info, tag, nt->type.indx, size, TRUE, |
252b5132 RH |
5901 | localp, &strdef) |
5902 | || ! ieee_write_number (info, structp ? 'S' : 'U') | |
5903 | || ! ieee_write_number (info, size)) | |
b34976b6 | 5904 | return FALSE; |
252b5132 RH |
5905 | |
5906 | if (! ignorep) | |
5907 | { | |
5908 | const char *hold; | |
5909 | ||
5910 | /* We never want nt->type.name to be NULL. We want the rest of | |
5911 | the type to be the object set up on the type stack; it will | |
5912 | have a NULL name if tag is NULL. */ | |
5913 | hold = nt->type.name; | |
5914 | nt->type = info->type_stack->type; | |
5915 | nt->type.name = hold; | |
5916 | } | |
5917 | ||
5918 | info->type_stack->type.name = tag; | |
5919 | info->type_stack->type.strdef = strdef; | |
5920 | info->type_stack->type.ignorep = ignorep; | |
5921 | ||
b34976b6 | 5922 | return TRUE; |
252b5132 RH |
5923 | } |
5924 | ||
5925 | /* Add a field to a struct. */ | |
5926 | ||
b34976b6 | 5927 | static bfd_boolean |
2da42df6 AJ |
5928 | ieee_struct_field (void *p, const char *name, bfd_vma bitpos, bfd_vma bitsize, |
5929 | enum debug_visibility visibility) | |
252b5132 RH |
5930 | { |
5931 | struct ieee_handle *info = (struct ieee_handle *) p; | |
5932 | unsigned int size; | |
b34976b6 AM |
5933 | bfd_boolean unsignedp; |
5934 | bfd_boolean referencep; | |
5935 | bfd_boolean localp; | |
252b5132 RH |
5936 | unsigned int indx; |
5937 | bfd_vma offset; | |
5938 | ||
5939 | assert (info->type_stack != NULL | |
5940 | && info->type_stack->next != NULL | |
5941 | && ! ieee_buffer_emptyp (&info->type_stack->next->type.strdef)); | |
5942 | ||
5943 | /* If we are ignoring this struct definition, just pop and ignore | |
5944 | the type. */ | |
5945 | if (info->type_stack->next->type.ignorep) | |
5946 | { | |
5947 | ieee_pop_unused_type (info); | |
b34976b6 | 5948 | return TRUE; |
252b5132 RH |
5949 | } |
5950 | ||
5951 | size = info->type_stack->type.size; | |
5952 | unsignedp = info->type_stack->type.unsignedp; | |
5953 | referencep = info->type_stack->type.referencep; | |
5954 | localp = info->type_stack->type.localp; | |
5955 | indx = ieee_pop_type (info); | |
5956 | ||
5957 | if (localp) | |
b34976b6 | 5958 | info->type_stack->type.localp = TRUE; |
252b5132 RH |
5959 | |
5960 | if (info->type_stack->type.classdef != NULL) | |
5961 | { | |
5962 | unsigned int flags; | |
5963 | unsigned int nindx; | |
5964 | ||
5965 | /* This is a class. We must add a description of this field to | |
5966 | the class records we are building. */ | |
5967 | ||
5968 | flags = ieee_vis_to_flags (visibility); | |
5969 | nindx = info->type_stack->type.classdef->indx; | |
5970 | if (! ieee_change_buffer (info, | |
5971 | &info->type_stack->type.classdef->pmiscbuf) | |
5972 | || ! ieee_write_asn (info, nindx, 'd') | |
5973 | || ! ieee_write_asn (info, nindx, flags) | |
5974 | || ! ieee_write_atn65 (info, nindx, name) | |
5975 | || ! ieee_write_atn65 (info, nindx, name)) | |
b34976b6 | 5976 | return FALSE; |
252b5132 RH |
5977 | info->type_stack->type.classdef->pmisccount += 4; |
5978 | ||
5979 | if (referencep) | |
5980 | { | |
5981 | unsigned int nindx; | |
5982 | ||
5983 | /* We need to output a record recording that this field is | |
5984 | really of reference type. We put this on the refs field | |
5985 | of classdef, so that it can be appended to the C++ | |
5986 | records after the class is defined. */ | |
5987 | ||
5988 | nindx = info->name_indx; | |
5989 | ++info->name_indx; | |
5990 | ||
5991 | if (! ieee_change_buffer (info, | |
5992 | &info->type_stack->type.classdef->refs) | |
5993 | || ! ieee_write_byte (info, (int) ieee_nn_record) | |
5994 | || ! ieee_write_number (info, nindx) | |
5995 | || ! ieee_write_id (info, "") | |
5996 | || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum) | |
5997 | || ! ieee_write_number (info, nindx) | |
5998 | || ! ieee_write_number (info, 0) | |
5999 | || ! ieee_write_number (info, 62) | |
6000 | || ! ieee_write_number (info, 80) | |
6001 | || ! ieee_write_number (info, 4) | |
6002 | || ! ieee_write_asn (info, nindx, 'R') | |
6003 | || ! ieee_write_asn (info, nindx, 3) | |
6004 | || ! ieee_write_atn65 (info, nindx, info->type_stack->type.name) | |
6005 | || ! ieee_write_atn65 (info, nindx, name)) | |
b34976b6 | 6006 | return FALSE; |
252b5132 RH |
6007 | } |
6008 | } | |
6009 | ||
6010 | /* If the bitsize doesn't match the expected size, we need to output | |
6011 | a bitfield type. */ | |
6012 | if (size == 0 || bitsize == 0 || bitsize == size * 8) | |
6013 | offset = bitpos / 8; | |
6014 | else | |
6015 | { | |
6016 | if (! ieee_define_type (info, 0, unsignedp, | |
6017 | info->type_stack->type.localp) | |
6018 | || ! ieee_write_number (info, 'g') | |
6019 | || ! ieee_write_number (info, unsignedp ? 0 : 1) | |
6020 | || ! ieee_write_number (info, bitsize) | |
6021 | || ! ieee_write_number (info, indx)) | |
b34976b6 | 6022 | return FALSE; |
252b5132 RH |
6023 | indx = ieee_pop_type (info); |
6024 | offset = bitpos; | |
6025 | } | |
6026 | ||
6027 | /* Switch to the struct we are building in order to output this | |
6028 | field definition. */ | |
6029 | return (ieee_change_buffer (info, &info->type_stack->type.strdef) | |
6030 | && ieee_write_id (info, name) | |
6031 | && ieee_write_number (info, indx) | |
6032 | && ieee_write_number (info, offset)); | |
6033 | } | |
6034 | ||
6035 | /* Finish up a struct type. */ | |
6036 | ||
b34976b6 | 6037 | static bfd_boolean |
2da42df6 | 6038 | ieee_end_struct_type (void *p) |
252b5132 RH |
6039 | { |
6040 | struct ieee_handle *info = (struct ieee_handle *) p; | |
6041 | struct ieee_buflist *pb; | |
6042 | ||
6043 | assert (info->type_stack != NULL | |
6044 | && ! ieee_buffer_emptyp (&info->type_stack->type.strdef)); | |
6045 | ||
6046 | /* If we were ignoring this struct definition because it was a | |
50c2245b | 6047 | duplicate definition, just through away whatever bytes we have |
0af11b59 | 6048 | accumulated. Leave the type on the stack. */ |
252b5132 | 6049 | if (info->type_stack->type.ignorep) |
b34976b6 | 6050 | return TRUE; |
252b5132 RH |
6051 | |
6052 | /* If this is not a duplicate definition of this tag, then localp | |
b34976b6 | 6053 | will be FALSE, and we can put it in the global type block. |
252b5132 RH |
6054 | FIXME: We should avoid outputting duplicate definitions which are |
6055 | the same. */ | |
6056 | if (! info->type_stack->type.localp) | |
6057 | { | |
6058 | /* Make sure we have started the global type block. */ | |
6059 | if (ieee_buffer_emptyp (&info->global_types)) | |
6060 | { | |
6061 | if (! ieee_change_buffer (info, &info->global_types) | |
6062 | || ! ieee_write_byte (info, (int) ieee_bb_record_enum) | |
6063 | || ! ieee_write_byte (info, 2) | |
6064 | || ! ieee_write_number (info, 0) | |
6065 | || ! ieee_write_id (info, "")) | |
b34976b6 | 6066 | return FALSE; |
252b5132 RH |
6067 | } |
6068 | pb = &info->global_types; | |
6069 | } | |
6070 | else | |
6071 | { | |
6072 | /* Make sure we have started the types block. */ | |
6073 | if (ieee_buffer_emptyp (&info->types)) | |
6074 | { | |
6075 | if (! ieee_change_buffer (info, &info->types) | |
6076 | || ! ieee_write_byte (info, (int) ieee_bb_record_enum) | |
6077 | || ! ieee_write_byte (info, 1) | |
6078 | || ! ieee_write_number (info, 0) | |
6079 | || ! ieee_write_id (info, info->modname)) | |
b34976b6 | 6080 | return FALSE; |
252b5132 RH |
6081 | } |
6082 | pb = &info->types; | |
6083 | } | |
6084 | ||
6085 | /* Append the struct definition to the types. */ | |
6086 | if (! ieee_append_buffer (info, pb, &info->type_stack->type.strdef) | |
6087 | || ! ieee_init_buffer (info, &info->type_stack->type.strdef)) | |
b34976b6 | 6088 | return FALSE; |
252b5132 RH |
6089 | |
6090 | /* Leave the struct on the type stack. */ | |
6091 | ||
b34976b6 | 6092 | return TRUE; |
252b5132 RH |
6093 | } |
6094 | ||
6095 | /* Start a class type. */ | |
6096 | ||
b34976b6 | 6097 | static bfd_boolean |
2da42df6 AJ |
6098 | ieee_start_class_type (void *p, const char *tag, unsigned int id, |
6099 | bfd_boolean structp, unsigned int size, | |
6100 | bfd_boolean vptr, bfd_boolean ownvptr) | |
252b5132 RH |
6101 | { |
6102 | struct ieee_handle *info = (struct ieee_handle *) p; | |
6103 | const char *vclass; | |
6104 | struct ieee_buflist pmiscbuf; | |
6105 | unsigned int indx; | |
6106 | struct ieee_type_class *classdef; | |
6107 | ||
6108 | /* A C++ class is output as a C++ struct along with a set of pmisc | |
6109 | records describing the class. */ | |
6110 | ||
6111 | /* We need to have a name so that we can associate the struct and | |
6112 | the class. */ | |
6113 | if (tag == NULL) | |
6114 | { | |
6115 | char *t; | |
6116 | ||
6117 | t = (char *) xmalloc (20); | |
6118 | sprintf (t, "__anon%u", id); | |
6119 | tag = t; | |
6120 | } | |
6121 | ||
6122 | /* We can't write out the virtual table information until we have | |
6123 | finished the class, because we don't know the virtual table size. | |
6124 | We get the size from the largest voffset we see. */ | |
6125 | vclass = NULL; | |
6126 | if (vptr && ! ownvptr) | |
6127 | { | |
6128 | vclass = info->type_stack->type.name; | |
6129 | assert (vclass != NULL); | |
6130 | /* We don't call ieee_pop_unused_type, since the class should | |
6131 | get defined. */ | |
6132 | (void) ieee_pop_type (info); | |
6133 | } | |
6134 | ||
6135 | if (! ieee_start_struct_type (p, tag, id, structp, size)) | |
b34976b6 | 6136 | return FALSE; |
252b5132 RH |
6137 | |
6138 | indx = info->name_indx; | |
6139 | ++info->name_indx; | |
6140 | ||
6141 | /* We write out pmisc records into the classdef field. We will | |
6142 | write out the pmisc start after we know the number of records we | |
6143 | need. */ | |
6144 | if (! ieee_init_buffer (info, &pmiscbuf) | |
6145 | || ! ieee_change_buffer (info, &pmiscbuf) | |
6146 | || ! ieee_write_asn (info, indx, 'T') | |
6147 | || ! ieee_write_asn (info, indx, structp ? 'o' : 'u') | |
6148 | || ! ieee_write_atn65 (info, indx, tag)) | |
b34976b6 | 6149 | return FALSE; |
252b5132 RH |
6150 | |
6151 | classdef = (struct ieee_type_class *) xmalloc (sizeof *classdef); | |
6152 | memset (classdef, 0, sizeof *classdef); | |
6153 | ||
6154 | classdef->indx = indx; | |
6155 | classdef->pmiscbuf = pmiscbuf; | |
6156 | classdef->pmisccount = 3; | |
6157 | classdef->vclass = vclass; | |
6158 | classdef->ownvptr = ownvptr; | |
6159 | ||
6160 | info->type_stack->type.classdef = classdef; | |
6161 | ||
b34976b6 | 6162 | return TRUE; |
252b5132 RH |
6163 | } |
6164 | ||
6165 | /* Add a static member to a class. */ | |
6166 | ||
b34976b6 | 6167 | static bfd_boolean |
2da42df6 AJ |
6168 | ieee_class_static_member (void *p, const char *name, const char *physname, |
6169 | enum debug_visibility visibility) | |
252b5132 RH |
6170 | { |
6171 | struct ieee_handle *info = (struct ieee_handle *) p; | |
6172 | unsigned int flags; | |
6173 | unsigned int nindx; | |
6174 | ||
6175 | /* We don't care about the type. Hopefully there will be a call to | |
6176 | ieee_variable declaring the physical name and the type, since | |
6177 | that is where an IEEE consumer must get the type. */ | |
6178 | ieee_pop_unused_type (info); | |
6179 | ||
6180 | assert (info->type_stack != NULL | |
6181 | && info->type_stack->type.classdef != NULL); | |
6182 | ||
6183 | flags = ieee_vis_to_flags (visibility); | |
6184 | flags |= CXXFLAGS_STATIC; | |
6185 | ||
6186 | nindx = info->type_stack->type.classdef->indx; | |
6187 | ||
6188 | if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf) | |
6189 | || ! ieee_write_asn (info, nindx, 'd') | |
6190 | || ! ieee_write_asn (info, nindx, flags) | |
6191 | || ! ieee_write_atn65 (info, nindx, name) | |
6192 | || ! ieee_write_atn65 (info, nindx, physname)) | |
b34976b6 | 6193 | return FALSE; |
252b5132 RH |
6194 | info->type_stack->type.classdef->pmisccount += 4; |
6195 | ||
b34976b6 | 6196 | return TRUE; |
252b5132 RH |
6197 | } |
6198 | ||
6199 | /* Add a base class to a class. */ | |
6200 | ||
b34976b6 | 6201 | static bfd_boolean |
2da42df6 AJ |
6202 | ieee_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean virtual, |
6203 | enum debug_visibility visibility) | |
252b5132 RH |
6204 | { |
6205 | struct ieee_handle *info = (struct ieee_handle *) p; | |
6206 | const char *bname; | |
b34976b6 | 6207 | bfd_boolean localp; |
252b5132 RH |
6208 | unsigned int bindx; |
6209 | char *fname; | |
6210 | unsigned int flags; | |
6211 | unsigned int nindx; | |
6212 | ||
6213 | assert (info->type_stack != NULL | |
6214 | && info->type_stack->type.name != NULL | |
6215 | && info->type_stack->next != NULL | |
6216 | && info->type_stack->next->type.classdef != NULL | |
6217 | && ! ieee_buffer_emptyp (&info->type_stack->next->type.strdef)); | |
6218 | ||
6219 | bname = info->type_stack->type.name; | |
6220 | localp = info->type_stack->type.localp; | |
6221 | bindx = ieee_pop_type (info); | |
6222 | ||
6223 | /* We are currently defining both a struct and a class. We must | |
6224 | write out a field definition in the struct which holds the base | |
6225 | class. The stabs debugging reader will create a field named | |
6226 | _vb$CLASS for a virtual base class, so we just use that. FIXME: | |
6227 | we should not depend upon a detail of stabs debugging. */ | |
6228 | if (virtual) | |
6229 | { | |
6230 | fname = (char *) xmalloc (strlen (bname) + sizeof "_vb$"); | |
6231 | sprintf (fname, "_vb$%s", bname); | |
6232 | flags = BASEFLAGS_VIRTUAL; | |
6233 | } | |
6234 | else | |
6235 | { | |
6236 | if (localp) | |
b34976b6 | 6237 | info->type_stack->type.localp = TRUE; |
252b5132 RH |
6238 | |
6239 | fname = (char *) xmalloc (strlen (bname) + sizeof "_b$"); | |
6240 | sprintf (fname, "_b$%s", bname); | |
6241 | ||
6242 | if (! ieee_change_buffer (info, &info->type_stack->type.strdef) | |
6243 | || ! ieee_write_id (info, fname) | |
6244 | || ! ieee_write_number (info, bindx) | |
6245 | || ! ieee_write_number (info, bitpos / 8)) | |
b34976b6 | 6246 | return FALSE; |
252b5132 RH |
6247 | flags = 0; |
6248 | } | |
6249 | ||
6250 | if (visibility == DEBUG_VISIBILITY_PRIVATE) | |
6251 | flags |= BASEFLAGS_PRIVATE; | |
6252 | ||
6253 | nindx = info->type_stack->type.classdef->indx; | |
6254 | ||
6255 | if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf) | |
6256 | || ! ieee_write_asn (info, nindx, 'b') | |
6257 | || ! ieee_write_asn (info, nindx, flags) | |
6258 | || ! ieee_write_atn65 (info, nindx, bname) | |
6259 | || ! ieee_write_asn (info, nindx, 0) | |
6260 | || ! ieee_write_atn65 (info, nindx, fname)) | |
b34976b6 | 6261 | return FALSE; |
252b5132 RH |
6262 | info->type_stack->type.classdef->pmisccount += 5; |
6263 | ||
6264 | free (fname); | |
6265 | ||
b34976b6 | 6266 | return TRUE; |
252b5132 RH |
6267 | } |
6268 | ||
6269 | /* Start building a method for a class. */ | |
6270 | ||
b34976b6 | 6271 | static bfd_boolean |
2da42df6 | 6272 | ieee_class_start_method (void *p, const char *name) |
252b5132 RH |
6273 | { |
6274 | struct ieee_handle *info = (struct ieee_handle *) p; | |
6275 | ||
6276 | assert (info->type_stack != NULL | |
6277 | && info->type_stack->type.classdef != NULL | |
6278 | && info->type_stack->type.classdef->method == NULL); | |
6279 | ||
6280 | info->type_stack->type.classdef->method = name; | |
6281 | ||
b34976b6 | 6282 | return TRUE; |
252b5132 RH |
6283 | } |
6284 | ||
6285 | /* Define a new method variant, either static or not. */ | |
6286 | ||
b34976b6 | 6287 | static bfd_boolean |
2da42df6 AJ |
6288 | ieee_class_method_var (struct ieee_handle *info, const char *physname, |
6289 | enum debug_visibility visibility, | |
6290 | bfd_boolean staticp, bfd_boolean constp, | |
6291 | bfd_boolean volatilep, bfd_vma voffset, | |
6292 | bfd_boolean context) | |
252b5132 RH |
6293 | { |
6294 | unsigned int flags; | |
6295 | unsigned int nindx; | |
b34976b6 | 6296 | bfd_boolean virtual; |
252b5132 RH |
6297 | |
6298 | /* We don't need the type of the method. An IEEE consumer which | |
6299 | wants the type must track down the function by the physical name | |
6300 | and get the type from that. */ | |
6301 | ieee_pop_unused_type (info); | |
6302 | ||
6303 | /* We don't use the context. FIXME: We probably ought to use it to | |
6304 | adjust the voffset somehow, but I don't really know how. */ | |
6305 | if (context) | |
6306 | ieee_pop_unused_type (info); | |
6307 | ||
6308 | assert (info->type_stack != NULL | |
6309 | && info->type_stack->type.classdef != NULL | |
6310 | && info->type_stack->type.classdef->method != NULL); | |
6311 | ||
6312 | flags = ieee_vis_to_flags (visibility); | |
6313 | ||
6314 | /* FIXME: We never set CXXFLAGS_OVERRIDE, CXXFLAGS_OPERATOR, | |
6315 | CXXFLAGS_CTORDTOR, CXXFLAGS_CTOR, or CXXFLAGS_INLINE. */ | |
6316 | ||
6317 | if (staticp) | |
6318 | flags |= CXXFLAGS_STATIC; | |
6319 | if (constp) | |
6320 | flags |= CXXFLAGS_CONST; | |
6321 | if (volatilep) | |
6322 | flags |= CXXFLAGS_VOLATILE; | |
6323 | ||
6324 | nindx = info->type_stack->type.classdef->indx; | |
6325 | ||
6326 | virtual = context || voffset > 0; | |
6327 | ||
6328 | if (! ieee_change_buffer (info, | |
6329 | &info->type_stack->type.classdef->pmiscbuf) | |
6330 | || ! ieee_write_asn (info, nindx, virtual ? 'v' : 'm') | |
6331 | || ! ieee_write_asn (info, nindx, flags) | |
6332 | || ! ieee_write_atn65 (info, nindx, | |
6333 | info->type_stack->type.classdef->method) | |
6334 | || ! ieee_write_atn65 (info, nindx, physname)) | |
b34976b6 | 6335 | return FALSE; |
252b5132 RH |
6336 | |
6337 | if (virtual) | |
6338 | { | |
6339 | if (voffset > info->type_stack->type.classdef->voffset) | |
6340 | info->type_stack->type.classdef->voffset = voffset; | |
6341 | if (! ieee_write_asn (info, nindx, voffset)) | |
b34976b6 | 6342 | return FALSE; |
252b5132 RH |
6343 | ++info->type_stack->type.classdef->pmisccount; |
6344 | } | |
6345 | ||
6346 | if (! ieee_write_asn (info, nindx, 0)) | |
b34976b6 | 6347 | return FALSE; |
252b5132 RH |
6348 | |
6349 | info->type_stack->type.classdef->pmisccount += 5; | |
6350 | ||
b34976b6 | 6351 | return TRUE; |
252b5132 RH |
6352 | } |
6353 | ||
6354 | /* Define a new method variant. */ | |
6355 | ||
b34976b6 | 6356 | static bfd_boolean |
2da42df6 AJ |
6357 | ieee_class_method_variant (void *p, const char *physname, |
6358 | enum debug_visibility visibility, | |
6359 | bfd_boolean constp, bfd_boolean volatilep, | |
6360 | bfd_vma voffset, bfd_boolean context) | |
252b5132 RH |
6361 | { |
6362 | struct ieee_handle *info = (struct ieee_handle *) p; | |
6363 | ||
b34976b6 | 6364 | return ieee_class_method_var (info, physname, visibility, FALSE, constp, |
252b5132 RH |
6365 | volatilep, voffset, context); |
6366 | } | |
6367 | ||
6368 | /* Define a new static method variant. */ | |
6369 | ||
b34976b6 | 6370 | static bfd_boolean |
2da42df6 AJ |
6371 | ieee_class_static_method_variant (void *p, const char *physname, |
6372 | enum debug_visibility visibility, | |
6373 | bfd_boolean constp, bfd_boolean volatilep) | |
252b5132 RH |
6374 | { |
6375 | struct ieee_handle *info = (struct ieee_handle *) p; | |
6376 | ||
b34976b6 AM |
6377 | return ieee_class_method_var (info, physname, visibility, TRUE, constp, |
6378 | volatilep, 0, FALSE); | |
252b5132 RH |
6379 | } |
6380 | ||
6381 | /* Finish up a method. */ | |
6382 | ||
b34976b6 | 6383 | static bfd_boolean |
2da42df6 | 6384 | ieee_class_end_method (void *p) |
252b5132 RH |
6385 | { |
6386 | struct ieee_handle *info = (struct ieee_handle *) p; | |
6387 | ||
6388 | assert (info->type_stack != NULL | |
6389 | && info->type_stack->type.classdef != NULL | |
6390 | && info->type_stack->type.classdef->method != NULL); | |
6391 | ||
6392 | info->type_stack->type.classdef->method = NULL; | |
6393 | ||
b34976b6 | 6394 | return TRUE; |
252b5132 RH |
6395 | } |
6396 | ||
6397 | /* Finish up a class. */ | |
6398 | ||
b34976b6 | 6399 | static bfd_boolean |
2da42df6 | 6400 | ieee_end_class_type (void *p) |
252b5132 RH |
6401 | { |
6402 | struct ieee_handle *info = (struct ieee_handle *) p; | |
6403 | unsigned int nindx; | |
6404 | ||
6405 | assert (info->type_stack != NULL | |
6406 | && info->type_stack->type.classdef != NULL); | |
6407 | ||
6408 | /* If we were ignoring this class definition because it was a | |
6409 | duplicate definition, just through away whatever bytes we have | |
6410 | accumulated. Leave the type on the stack. */ | |
6411 | if (info->type_stack->type.ignorep) | |
b34976b6 | 6412 | return TRUE; |
252b5132 RH |
6413 | |
6414 | nindx = info->type_stack->type.classdef->indx; | |
6415 | ||
6416 | /* If we have a virtual table, we can write out the information now. */ | |
6417 | if (info->type_stack->type.classdef->vclass != NULL | |
6418 | || info->type_stack->type.classdef->ownvptr) | |
6419 | { | |
6420 | if (! ieee_change_buffer (info, | |
6421 | &info->type_stack->type.classdef->pmiscbuf) | |
6422 | || ! ieee_write_asn (info, nindx, 'z') | |
6423 | || ! ieee_write_atn65 (info, nindx, "") | |
6424 | || ! ieee_write_asn (info, nindx, | |
6425 | info->type_stack->type.classdef->voffset)) | |
b34976b6 | 6426 | return FALSE; |
252b5132 RH |
6427 | if (info->type_stack->type.classdef->ownvptr) |
6428 | { | |
6429 | if (! ieee_write_atn65 (info, nindx, "")) | |
b34976b6 | 6430 | return FALSE; |
252b5132 RH |
6431 | } |
6432 | else | |
6433 | { | |
6434 | if (! ieee_write_atn65 (info, nindx, | |
6435 | info->type_stack->type.classdef->vclass)) | |
b34976b6 | 6436 | return FALSE; |
252b5132 RH |
6437 | } |
6438 | if (! ieee_write_asn (info, nindx, 0)) | |
b34976b6 | 6439 | return FALSE; |
252b5132 RH |
6440 | info->type_stack->type.classdef->pmisccount += 5; |
6441 | } | |
6442 | ||
6443 | /* Now that we know the number of pmisc records, we can write out | |
6444 | the atn62 which starts the pmisc records, and append them to the | |
6445 | C++ buffers. */ | |
6446 | ||
6447 | if (! ieee_change_buffer (info, &info->cxx) | |
6448 | || ! ieee_write_byte (info, (int) ieee_nn_record) | |
6449 | || ! ieee_write_number (info, nindx) | |
6450 | || ! ieee_write_id (info, "") | |
6451 | || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum) | |
6452 | || ! ieee_write_number (info, nindx) | |
6453 | || ! ieee_write_number (info, 0) | |
6454 | || ! ieee_write_number (info, 62) | |
6455 | || ! ieee_write_number (info, 80) | |
6456 | || ! ieee_write_number (info, | |
6457 | info->type_stack->type.classdef->pmisccount)) | |
b34976b6 | 6458 | return FALSE; |
252b5132 RH |
6459 | |
6460 | if (! ieee_append_buffer (info, &info->cxx, | |
6461 | &info->type_stack->type.classdef->pmiscbuf)) | |
b34976b6 | 6462 | return FALSE; |
252b5132 RH |
6463 | if (! ieee_buffer_emptyp (&info->type_stack->type.classdef->refs)) |
6464 | { | |
6465 | if (! ieee_append_buffer (info, &info->cxx, | |
6466 | &info->type_stack->type.classdef->refs)) | |
b34976b6 | 6467 | return FALSE; |
252b5132 RH |
6468 | } |
6469 | ||
6470 | return ieee_end_struct_type (p); | |
6471 | } | |
6472 | ||
6473 | /* Push a previously seen typedef onto the type stack. */ | |
6474 | ||
b34976b6 | 6475 | static bfd_boolean |
2da42df6 | 6476 | ieee_typedef_type (void *p, const char *name) |
252b5132 RH |
6477 | { |
6478 | struct ieee_handle *info = (struct ieee_handle *) p; | |
6479 | struct ieee_name_type_hash_entry *h; | |
6480 | struct ieee_name_type *nt; | |
6481 | ||
b34976b6 | 6482 | h = ieee_name_type_hash_lookup (&info->typedefs, name, FALSE, FALSE); |
252b5132 RH |
6483 | |
6484 | /* h should never be NULL, since that would imply that the generic | |
6485 | debugging code has asked for a typedef which it has not yet | |
6486 | defined. */ | |
6487 | assert (h != NULL); | |
6488 | ||
6489 | /* We always use the most recently defined type for this name, which | |
6490 | will be the first one on the list. */ | |
6491 | ||
6492 | nt = h->types; | |
6493 | if (! ieee_push_type (info, nt->type.indx, nt->type.size, | |
6494 | nt->type.unsignedp, nt->type.localp)) | |
b34976b6 | 6495 | return FALSE; |
252b5132 RH |
6496 | |
6497 | /* Copy over any other type information we may have. */ | |
6498 | info->type_stack->type = nt->type; | |
6499 | ||
b34976b6 | 6500 | return TRUE; |
252b5132 RH |
6501 | } |
6502 | ||
6503 | /* Push a tagged type onto the type stack. */ | |
6504 | ||
b34976b6 | 6505 | static bfd_boolean |
2da42df6 AJ |
6506 | ieee_tag_type (void *p, const char *name, unsigned int id, |
6507 | enum debug_type_kind kind) | |
252b5132 RH |
6508 | { |
6509 | struct ieee_handle *info = (struct ieee_handle *) p; | |
b34976b6 AM |
6510 | bfd_boolean localp; |
6511 | bfd_boolean copy; | |
252b5132 RH |
6512 | char ab[20]; |
6513 | struct ieee_name_type_hash_entry *h; | |
6514 | struct ieee_name_type *nt; | |
6515 | ||
6516 | if (kind == DEBUG_KIND_ENUM) | |
6517 | { | |
6518 | struct ieee_defined_enum *e; | |
6519 | ||
6520 | if (name == NULL) | |
6521 | abort (); | |
6522 | for (e = info->enums; e != NULL; e = e->next) | |
6523 | if (e->tag != NULL && strcmp (e->tag, name) == 0) | |
b34976b6 | 6524 | return ieee_push_type (info, e->indx, 0, TRUE, FALSE); |
252b5132 RH |
6525 | |
6526 | e = (struct ieee_defined_enum *) xmalloc (sizeof *e); | |
6527 | memset (e, 0, sizeof *e); | |
6528 | ||
6529 | e->indx = info->type_indx; | |
6530 | ++info->type_indx; | |
6531 | e->tag = name; | |
b34976b6 | 6532 | e->defined = FALSE; |
252b5132 RH |
6533 | |
6534 | e->next = info->enums; | |
6535 | info->enums = e; | |
6536 | ||
b34976b6 | 6537 | return ieee_push_type (info, e->indx, 0, TRUE, FALSE); |
252b5132 RH |
6538 | } |
6539 | ||
b34976b6 | 6540 | localp = FALSE; |
252b5132 | 6541 | |
b34976b6 | 6542 | copy = FALSE; |
252b5132 RH |
6543 | if (name == NULL) |
6544 | { | |
6545 | sprintf (ab, "__anon%u", id); | |
6546 | name = ab; | |
b34976b6 | 6547 | copy = TRUE; |
252b5132 RH |
6548 | } |
6549 | ||
b34976b6 | 6550 | h = ieee_name_type_hash_lookup (&info->tags, name, TRUE, copy); |
252b5132 | 6551 | if (h == NULL) |
b34976b6 | 6552 | return FALSE; |
252b5132 RH |
6553 | |
6554 | for (nt = h->types; nt != NULL; nt = nt->next) | |
6555 | { | |
6556 | if (nt->id == id) | |
6557 | { | |
6558 | if (! ieee_push_type (info, nt->type.indx, nt->type.size, | |
6559 | nt->type.unsignedp, nt->type.localp)) | |
b34976b6 | 6560 | return FALSE; |
252b5132 RH |
6561 | /* Copy over any other type information we may have. */ |
6562 | info->type_stack->type = nt->type; | |
b34976b6 | 6563 | return TRUE; |
252b5132 RH |
6564 | } |
6565 | ||
6566 | if (! nt->type.localp) | |
6567 | { | |
6568 | /* This is a duplicate of a global type, so it must be | |
0af11b59 | 6569 | local. */ |
b34976b6 | 6570 | localp = TRUE; |
252b5132 RH |
6571 | } |
6572 | } | |
6573 | ||
6574 | nt = (struct ieee_name_type *) xmalloc (sizeof *nt); | |
6575 | memset (nt, 0, sizeof *nt); | |
6576 | ||
6577 | nt->id = id; | |
6578 | nt->type.name = h->root.string; | |
6579 | nt->type.indx = info->type_indx; | |
6580 | nt->type.localp = localp; | |
6581 | ++info->type_indx; | |
6582 | nt->kind = kind; | |
6583 | ||
6584 | nt->next = h->types; | |
6585 | h->types = nt; | |
6586 | ||
b34976b6 AM |
6587 | if (! ieee_push_type (info, nt->type.indx, 0, FALSE, localp)) |
6588 | return FALSE; | |
252b5132 RH |
6589 | |
6590 | info->type_stack->type.name = h->root.string; | |
6591 | ||
b34976b6 | 6592 | return TRUE; |
252b5132 RH |
6593 | } |
6594 | ||
6595 | /* Output a typedef. */ | |
6596 | ||
b34976b6 | 6597 | static bfd_boolean |
2da42df6 | 6598 | ieee_typdef (void *p, const char *name) |
252b5132 RH |
6599 | { |
6600 | struct ieee_handle *info = (struct ieee_handle *) p; | |
6601 | struct ieee_write_type type; | |
6602 | unsigned int indx; | |
b34976b6 AM |
6603 | bfd_boolean found; |
6604 | bfd_boolean localp; | |
252b5132 RH |
6605 | struct ieee_name_type_hash_entry *h; |
6606 | struct ieee_name_type *nt; | |
6607 | ||
6608 | type = info->type_stack->type; | |
6609 | indx = type.indx; | |
6610 | ||
6611 | /* If this is a simple builtin type using a builtin name, we don't | |
6612 | want to output the typedef itself. We also want to change the | |
6613 | type index to correspond to the name being used. We recognize | |
6614 | names used in stabs debugging output even if they don't exactly | |
6615 | correspond to the names used for the IEEE builtin types. */ | |
b34976b6 | 6616 | found = FALSE; |
252b5132 RH |
6617 | if (indx <= (unsigned int) builtin_bcd_float) |
6618 | { | |
6619 | switch ((enum builtin_types) indx) | |
6620 | { | |
6621 | default: | |
6622 | break; | |
6623 | ||
6624 | case builtin_void: | |
6625 | if (strcmp (name, "void") == 0) | |
b34976b6 | 6626 | found = TRUE; |
252b5132 RH |
6627 | break; |
6628 | ||
6629 | case builtin_signed_char: | |
6630 | case builtin_char: | |
6631 | if (strcmp (name, "signed char") == 0) | |
6632 | { | |
6633 | indx = (unsigned int) builtin_signed_char; | |
b34976b6 | 6634 | found = TRUE; |
252b5132 RH |
6635 | } |
6636 | else if (strcmp (name, "char") == 0) | |
6637 | { | |
6638 | indx = (unsigned int) builtin_char; | |
b34976b6 | 6639 | found = TRUE; |
252b5132 RH |
6640 | } |
6641 | break; | |
6642 | ||
6643 | case builtin_unsigned_char: | |
6644 | if (strcmp (name, "unsigned char") == 0) | |
b34976b6 | 6645 | found = TRUE; |
252b5132 RH |
6646 | break; |
6647 | ||
6648 | case builtin_signed_short_int: | |
6649 | case builtin_short: | |
6650 | case builtin_short_int: | |
6651 | case builtin_signed_short: | |
6652 | if (strcmp (name, "signed short int") == 0) | |
6653 | { | |
6654 | indx = (unsigned int) builtin_signed_short_int; | |
b34976b6 | 6655 | found = TRUE; |
252b5132 RH |
6656 | } |
6657 | else if (strcmp (name, "short") == 0) | |
6658 | { | |
6659 | indx = (unsigned int) builtin_short; | |
b34976b6 | 6660 | found = TRUE; |
252b5132 RH |
6661 | } |
6662 | else if (strcmp (name, "short int") == 0) | |
6663 | { | |
6664 | indx = (unsigned int) builtin_short_int; | |
b34976b6 | 6665 | found = TRUE; |
252b5132 RH |
6666 | } |
6667 | else if (strcmp (name, "signed short") == 0) | |
6668 | { | |
6669 | indx = (unsigned int) builtin_signed_short; | |
b34976b6 | 6670 | found = TRUE; |
252b5132 RH |
6671 | } |
6672 | break; | |
6673 | ||
6674 | case builtin_unsigned_short_int: | |
6675 | case builtin_unsigned_short: | |
6676 | if (strcmp (name, "unsigned short int") == 0 | |
6677 | || strcmp (name, "short unsigned int") == 0) | |
6678 | { | |
6679 | indx = builtin_unsigned_short_int; | |
b34976b6 | 6680 | found = TRUE; |
252b5132 RH |
6681 | } |
6682 | else if (strcmp (name, "unsigned short") == 0) | |
6683 | { | |
6684 | indx = builtin_unsigned_short; | |
b34976b6 | 6685 | found = TRUE; |
252b5132 RH |
6686 | } |
6687 | break; | |
6688 | ||
6689 | case builtin_signed_long: | |
6690 | case builtin_int: /* FIXME: Size depends upon architecture. */ | |
6691 | case builtin_long: | |
6692 | if (strcmp (name, "signed long") == 0) | |
6693 | { | |
6694 | indx = builtin_signed_long; | |
b34976b6 | 6695 | found = TRUE; |
252b5132 RH |
6696 | } |
6697 | else if (strcmp (name, "int") == 0) | |
6698 | { | |
6699 | indx = builtin_int; | |
b34976b6 | 6700 | found = TRUE; |
252b5132 RH |
6701 | } |
6702 | else if (strcmp (name, "long") == 0 | |
6703 | || strcmp (name, "long int") == 0) | |
6704 | { | |
6705 | indx = builtin_long; | |
b34976b6 | 6706 | found = TRUE; |
252b5132 RH |
6707 | } |
6708 | break; | |
6709 | ||
6710 | case builtin_unsigned_long: | |
6711 | case builtin_unsigned: /* FIXME: Size depends upon architecture. */ | |
6712 | case builtin_unsigned_int: /* FIXME: Like builtin_unsigned. */ | |
6713 | if (strcmp (name, "unsigned long") == 0 | |
6714 | || strcmp (name, "long unsigned int") == 0) | |
6715 | { | |
6716 | indx = builtin_unsigned_long; | |
b34976b6 | 6717 | found = TRUE; |
252b5132 RH |
6718 | } |
6719 | else if (strcmp (name, "unsigned") == 0) | |
6720 | { | |
6721 | indx = builtin_unsigned; | |
b34976b6 | 6722 | found = TRUE; |
252b5132 RH |
6723 | } |
6724 | else if (strcmp (name, "unsigned int") == 0) | |
6725 | { | |
6726 | indx = builtin_unsigned_int; | |
b34976b6 | 6727 | found = TRUE; |
252b5132 RH |
6728 | } |
6729 | break; | |
6730 | ||
6731 | case builtin_signed_long_long: | |
6732 | if (strcmp (name, "signed long long") == 0 | |
6733 | || strcmp (name, "long long int") == 0) | |
b34976b6 | 6734 | found = TRUE; |
252b5132 RH |
6735 | break; |
6736 | ||
6737 | case builtin_unsigned_long_long: | |
6738 | if (strcmp (name, "unsigned long long") == 0 | |
6739 | || strcmp (name, "long long unsigned int") == 0) | |
b34976b6 | 6740 | found = TRUE; |
252b5132 RH |
6741 | break; |
6742 | ||
6743 | case builtin_float: | |
6744 | if (strcmp (name, "float") == 0) | |
b34976b6 | 6745 | found = TRUE; |
252b5132 RH |
6746 | break; |
6747 | ||
6748 | case builtin_double: | |
6749 | if (strcmp (name, "double") == 0) | |
b34976b6 | 6750 | found = TRUE; |
252b5132 RH |
6751 | break; |
6752 | ||
6753 | case builtin_long_double: | |
6754 | if (strcmp (name, "long double") == 0) | |
b34976b6 | 6755 | found = TRUE; |
252b5132 RH |
6756 | break; |
6757 | ||
6758 | case builtin_long_long_double: | |
6759 | if (strcmp (name, "long long double") == 0) | |
b34976b6 | 6760 | found = TRUE; |
252b5132 RH |
6761 | break; |
6762 | } | |
6763 | ||
6764 | if (found) | |
6765 | type.indx = indx; | |
6766 | } | |
6767 | ||
b34976b6 | 6768 | h = ieee_name_type_hash_lookup (&info->typedefs, name, TRUE, FALSE); |
252b5132 | 6769 | if (h == NULL) |
b34976b6 | 6770 | return FALSE; |
252b5132 RH |
6771 | |
6772 | /* See if we have already defined this type with this name. */ | |
6773 | localp = type.localp; | |
6774 | for (nt = h->types; nt != NULL; nt = nt->next) | |
6775 | { | |
6776 | if (nt->id == indx) | |
6777 | { | |
6778 | /* If this is a global definition, then we don't need to | |
6779 | do anything here. */ | |
6780 | if (! nt->type.localp) | |
6781 | { | |
6782 | ieee_pop_unused_type (info); | |
b34976b6 | 6783 | return TRUE; |
252b5132 RH |
6784 | } |
6785 | } | |
6786 | else | |
6787 | { | |
6788 | /* This is a duplicate definition, so make this one local. */ | |
b34976b6 | 6789 | localp = TRUE; |
252b5132 RH |
6790 | } |
6791 | } | |
6792 | ||
6793 | /* We need to add a new typedef for this type. */ | |
6794 | ||
6795 | nt = (struct ieee_name_type *) xmalloc (sizeof *nt); | |
6796 | memset (nt, 0, sizeof *nt); | |
6797 | nt->id = indx; | |
6798 | nt->type = type; | |
6799 | nt->type.name = name; | |
6800 | nt->type.localp = localp; | |
6801 | nt->kind = DEBUG_KIND_ILLEGAL; | |
6802 | ||
6803 | nt->next = h->types; | |
6804 | h->types = nt; | |
6805 | ||
6806 | if (found) | |
6807 | { | |
6808 | /* This is one of the builtin typedefs, so we don't need to | |
6809 | actually define it. */ | |
6810 | ieee_pop_unused_type (info); | |
b34976b6 | 6811 | return TRUE; |
252b5132 RH |
6812 | } |
6813 | ||
6814 | indx = ieee_pop_type (info); | |
6815 | ||
6816 | if (! ieee_define_named_type (info, name, (unsigned int) -1, type.size, | |
6817 | type.unsignedp, localp, | |
6818 | (struct ieee_buflist *) NULL) | |
6819 | || ! ieee_write_number (info, 'T') | |
6820 | || ! ieee_write_number (info, indx)) | |
b34976b6 | 6821 | return FALSE; |
252b5132 RH |
6822 | |
6823 | /* Remove the type we just added to the type stack. This should not | |
6824 | be ieee_pop_unused_type, since the type is used, we just don't | |
6825 | need it now. */ | |
6826 | (void) ieee_pop_type (info); | |
6827 | ||
b34976b6 | 6828 | return TRUE; |
252b5132 RH |
6829 | } |
6830 | ||
6831 | /* Output a tag for a type. We don't have to do anything here. */ | |
6832 | ||
b34976b6 | 6833 | static bfd_boolean |
2da42df6 | 6834 | ieee_tag (void *p, const char *name ATTRIBUTE_UNUSED) |
252b5132 RH |
6835 | { |
6836 | struct ieee_handle *info = (struct ieee_handle *) p; | |
6837 | ||
6838 | /* This should not be ieee_pop_unused_type, since we want the type | |
6839 | to be defined. */ | |
6840 | (void) ieee_pop_type (info); | |
b34976b6 | 6841 | return TRUE; |
252b5132 RH |
6842 | } |
6843 | ||
6844 | /* Output an integer constant. */ | |
6845 | ||
b34976b6 | 6846 | static bfd_boolean |
2da42df6 AJ |
6847 | ieee_int_constant (void *p ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED, |
6848 | bfd_vma val ATTRIBUTE_UNUSED) | |
252b5132 RH |
6849 | { |
6850 | /* FIXME. */ | |
b34976b6 | 6851 | return TRUE; |
252b5132 RH |
6852 | } |
6853 | ||
6854 | /* Output a floating point constant. */ | |
6855 | ||
b34976b6 | 6856 | static bfd_boolean |
2da42df6 AJ |
6857 | ieee_float_constant (void *p ATTRIBUTE_UNUSED, |
6858 | const char *name ATTRIBUTE_UNUSED, | |
6859 | double val ATTRIBUTE_UNUSED) | |
252b5132 RH |
6860 | { |
6861 | /* FIXME. */ | |
b34976b6 | 6862 | return TRUE; |
252b5132 RH |
6863 | } |
6864 | ||
6865 | /* Output a typed constant. */ | |
6866 | ||
b34976b6 | 6867 | static bfd_boolean |
2da42df6 AJ |
6868 | ieee_typed_constant (void *p, const char *name ATTRIBUTE_UNUSED, |
6869 | bfd_vma val ATTRIBUTE_UNUSED) | |
252b5132 RH |
6870 | { |
6871 | struct ieee_handle *info = (struct ieee_handle *) p; | |
6872 | ||
6873 | /* FIXME. */ | |
6874 | ieee_pop_unused_type (info); | |
b34976b6 | 6875 | return TRUE; |
252b5132 RH |
6876 | } |
6877 | ||
6878 | /* Output a variable. */ | |
6879 | ||
b34976b6 | 6880 | static bfd_boolean |
2da42df6 AJ |
6881 | ieee_variable (void *p, const char *name, enum debug_var_kind kind, |
6882 | bfd_vma val) | |
252b5132 RH |
6883 | { |
6884 | struct ieee_handle *info = (struct ieee_handle *) p; | |
6885 | unsigned int name_indx; | |
6886 | unsigned int size; | |
b34976b6 | 6887 | bfd_boolean referencep; |
252b5132 | 6888 | unsigned int type_indx; |
b34976b6 | 6889 | bfd_boolean asn; |
252b5132 RH |
6890 | int refflag; |
6891 | ||
6892 | size = info->type_stack->type.size; | |
6893 | referencep = info->type_stack->type.referencep; | |
6894 | type_indx = ieee_pop_type (info); | |
6895 | ||
6896 | assert (! ieee_buffer_emptyp (&info->vars)); | |
6897 | if (! ieee_change_buffer (info, &info->vars)) | |
b34976b6 | 6898 | return FALSE; |
252b5132 RH |
6899 | |
6900 | name_indx = info->name_indx; | |
6901 | ++info->name_indx; | |
6902 | ||
6903 | /* Write out an NN and an ATN record for this variable. */ | |
6904 | if (! ieee_write_byte (info, (int) ieee_nn_record) | |
6905 | || ! ieee_write_number (info, name_indx) | |
6906 | || ! ieee_write_id (info, name) | |
6907 | || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum) | |
6908 | || ! ieee_write_number (info, name_indx) | |
6909 | || ! ieee_write_number (info, type_indx)) | |
b34976b6 | 6910 | return FALSE; |
252b5132 RH |
6911 | switch (kind) |
6912 | { | |
6913 | default: | |
6914 | abort (); | |
b34976b6 | 6915 | return FALSE; |
252b5132 RH |
6916 | case DEBUG_GLOBAL: |
6917 | if (! ieee_write_number (info, 8) | |
b34976b6 AM |
6918 | || ! ieee_add_range (info, FALSE, val, val + size)) |
6919 | return FALSE; | |
252b5132 | 6920 | refflag = 0; |
b34976b6 | 6921 | asn = TRUE; |
252b5132 RH |
6922 | break; |
6923 | case DEBUG_STATIC: | |
6924 | if (! ieee_write_number (info, 3) | |
b34976b6 AM |
6925 | || ! ieee_add_range (info, FALSE, val, val + size)) |
6926 | return FALSE; | |
252b5132 | 6927 | refflag = 1; |
b34976b6 | 6928 | asn = TRUE; |
252b5132 RH |
6929 | break; |
6930 | case DEBUG_LOCAL_STATIC: | |
6931 | if (! ieee_write_number (info, 3) | |
b34976b6 AM |
6932 | || ! ieee_add_range (info, FALSE, val, val + size)) |
6933 | return FALSE; | |
252b5132 | 6934 | refflag = 2; |
b34976b6 | 6935 | asn = TRUE; |
252b5132 RH |
6936 | break; |
6937 | case DEBUG_LOCAL: | |
6938 | if (! ieee_write_number (info, 1) | |
6939 | || ! ieee_write_number (info, val)) | |
b34976b6 | 6940 | return FALSE; |
252b5132 | 6941 | refflag = 2; |
b34976b6 | 6942 | asn = FALSE; |
252b5132 RH |
6943 | break; |
6944 | case DEBUG_REGISTER: | |
6945 | if (! ieee_write_number (info, 2) | |
6946 | || ! ieee_write_number (info, | |
6947 | ieee_genreg_to_regno (info->abfd, val))) | |
b34976b6 | 6948 | return FALSE; |
252b5132 | 6949 | refflag = 2; |
b34976b6 | 6950 | asn = FALSE; |
252b5132 RH |
6951 | break; |
6952 | } | |
6953 | ||
6954 | if (asn) | |
6955 | { | |
6956 | if (! ieee_write_asn (info, name_indx, val)) | |
b34976b6 | 6957 | return FALSE; |
252b5132 RH |
6958 | } |
6959 | ||
6960 | /* If this is really a reference type, then we just output it with | |
6961 | pointer type, and must now output a C++ record indicating that it | |
6962 | is really reference type. */ | |
6963 | if (referencep) | |
6964 | { | |
6965 | unsigned int nindx; | |
6966 | ||
6967 | nindx = info->name_indx; | |
6968 | ++info->name_indx; | |
6969 | ||
6970 | /* If this is a global variable, we want to output the misc | |
6971 | record in the C++ misc record block. Otherwise, we want to | |
6972 | output it just after the variable definition, which is where | |
6973 | the current buffer is. */ | |
6974 | if (refflag != 2) | |
6975 | { | |
6976 | if (! ieee_change_buffer (info, &info->cxx)) | |
b34976b6 | 6977 | return FALSE; |
252b5132 RH |
6978 | } |
6979 | ||
6980 | if (! ieee_write_byte (info, (int) ieee_nn_record) | |
6981 | || ! ieee_write_number (info, nindx) | |
6982 | || ! ieee_write_id (info, "") | |
6983 | || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum) | |
6984 | || ! ieee_write_number (info, nindx) | |
6985 | || ! ieee_write_number (info, 0) | |
6986 | || ! ieee_write_number (info, 62) | |
6987 | || ! ieee_write_number (info, 80) | |
6988 | || ! ieee_write_number (info, 3) | |
6989 | || ! ieee_write_asn (info, nindx, 'R') | |
6990 | || ! ieee_write_asn (info, nindx, refflag) | |
6991 | || ! ieee_write_atn65 (info, nindx, name)) | |
b34976b6 | 6992 | return FALSE; |
252b5132 RH |
6993 | } |
6994 | ||
b34976b6 | 6995 | return TRUE; |
252b5132 RH |
6996 | } |
6997 | ||
6998 | /* Start outputting information for a function. */ | |
6999 | ||
b34976b6 | 7000 | static bfd_boolean |
2da42df6 | 7001 | ieee_start_function (void *p, const char *name, bfd_boolean global) |
252b5132 RH |
7002 | { |
7003 | struct ieee_handle *info = (struct ieee_handle *) p; | |
b34976b6 | 7004 | bfd_boolean referencep; |
252b5132 RH |
7005 | unsigned int retindx, typeindx; |
7006 | ||
7007 | referencep = info->type_stack->type.referencep; | |
7008 | retindx = ieee_pop_type (info); | |
7009 | ||
7010 | /* Besides recording a BB4 or BB6 block, we record the type of the | |
7011 | function in the BB1 typedef block. We can't write out the full | |
7012 | type until we have seen all the parameters, so we accumulate it | |
7013 | in info->fntype and info->fnargs. */ | |
7014 | if (! ieee_buffer_emptyp (&info->fntype)) | |
7015 | { | |
7016 | /* FIXME: This might happen someday if we support nested | |
7017 | functions. */ | |
7018 | abort (); | |
7019 | } | |
7020 | ||
7021 | info->fnname = name; | |
7022 | ||
7023 | /* An attribute of 0x40 means that the push mask is unknown. */ | |
b34976b6 | 7024 | if (! ieee_define_named_type (info, name, (unsigned int) -1, 0, FALSE, TRUE, |
252b5132 RH |
7025 | &info->fntype) |
7026 | || ! ieee_write_number (info, 'x') | |
7027 | || ! ieee_write_number (info, 0x40) | |
7028 | || ! ieee_write_number (info, 0) | |
7029 | || ! ieee_write_number (info, 0) | |
7030 | || ! ieee_write_number (info, retindx)) | |
b34976b6 | 7031 | return FALSE; |
252b5132 RH |
7032 | |
7033 | typeindx = ieee_pop_type (info); | |
7034 | ||
7035 | if (! ieee_init_buffer (info, &info->fnargs)) | |
b34976b6 | 7036 | return FALSE; |
252b5132 RH |
7037 | info->fnargcount = 0; |
7038 | ||
7039 | /* If the function return value is actually a reference type, we | |
7040 | must add a record indicating that. */ | |
7041 | if (referencep) | |
7042 | { | |
7043 | unsigned int nindx; | |
7044 | ||
7045 | nindx = info->name_indx; | |
7046 | ++info->name_indx; | |
7047 | if (! ieee_change_buffer (info, &info->cxx) | |
7048 | || ! ieee_write_byte (info, (int) ieee_nn_record) | |
7049 | || ! ieee_write_number (info, nindx) | |
7050 | || ! ieee_write_id (info, "") | |
7051 | || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum) | |
7052 | || ! ieee_write_number (info, nindx) | |
7053 | || ! ieee_write_number (info, 0) | |
7054 | || ! ieee_write_number (info, 62) | |
7055 | || ! ieee_write_number (info, 80) | |
7056 | || ! ieee_write_number (info, 3) | |
7057 | || ! ieee_write_asn (info, nindx, 'R') | |
7058 | || ! ieee_write_asn (info, nindx, global ? 0 : 1) | |
7059 | || ! ieee_write_atn65 (info, nindx, name)) | |
b34976b6 | 7060 | return FALSE; |
252b5132 RH |
7061 | } |
7062 | ||
7063 | assert (! ieee_buffer_emptyp (&info->vars)); | |
7064 | if (! ieee_change_buffer (info, &info->vars)) | |
b34976b6 | 7065 | return FALSE; |
252b5132 RH |
7066 | |
7067 | /* The address is written out as the first block. */ | |
7068 | ||
7069 | ++info->block_depth; | |
7070 | ||
7071 | return (ieee_write_byte (info, (int) ieee_bb_record_enum) | |
7072 | && ieee_write_byte (info, global ? 4 : 6) | |
7073 | && ieee_write_number (info, 0) | |
7074 | && ieee_write_id (info, name) | |
7075 | && ieee_write_number (info, 0) | |
7076 | && ieee_write_number (info, typeindx)); | |
7077 | } | |
7078 | ||
7079 | /* Add a function parameter. This will normally be called before the | |
7080 | first block, so we postpone them until we see the block. */ | |
7081 | ||
b34976b6 | 7082 | static bfd_boolean |
2da42df6 AJ |
7083 | ieee_function_parameter (void *p, const char *name, enum debug_parm_kind kind, |
7084 | bfd_vma val) | |
252b5132 RH |
7085 | { |
7086 | struct ieee_handle *info = (struct ieee_handle *) p; | |
7087 | struct ieee_pending_parm *m, **pm; | |
7088 | ||
7089 | assert (info->block_depth == 1); | |
7090 | ||
7091 | m = (struct ieee_pending_parm *) xmalloc (sizeof *m); | |
7092 | memset (m, 0, sizeof *m); | |
7093 | ||
7094 | m->next = NULL; | |
7095 | m->name = name; | |
7096 | m->referencep = info->type_stack->type.referencep; | |
7097 | m->type = ieee_pop_type (info); | |
7098 | m->kind = kind; | |
7099 | m->val = val; | |
7100 | ||
7101 | for (pm = &info->pending_parms; *pm != NULL; pm = &(*pm)->next) | |
7102 | ; | |
7103 | *pm = m; | |
7104 | ||
7105 | /* Add the type to the fnargs list. */ | |
7106 | if (! ieee_change_buffer (info, &info->fnargs) | |
7107 | || ! ieee_write_number (info, m->type)) | |
b34976b6 | 7108 | return FALSE; |
252b5132 RH |
7109 | ++info->fnargcount; |
7110 | ||
b34976b6 | 7111 | return TRUE; |
252b5132 RH |
7112 | } |
7113 | ||
7114 | /* Output pending function parameters. */ | |
7115 | ||
b34976b6 | 7116 | static bfd_boolean |
2da42df6 | 7117 | ieee_output_pending_parms (struct ieee_handle *info) |
252b5132 RH |
7118 | { |
7119 | struct ieee_pending_parm *m; | |
7120 | unsigned int refcount; | |
7121 | ||
7122 | refcount = 0; | |
7123 | for (m = info->pending_parms; m != NULL; m = m->next) | |
7124 | { | |
7125 | enum debug_var_kind vkind; | |
7126 | ||
7127 | switch (m->kind) | |
7128 | { | |
7129 | default: | |
7130 | abort (); | |
b34976b6 | 7131 | return FALSE; |
252b5132 RH |
7132 | case DEBUG_PARM_STACK: |
7133 | case DEBUG_PARM_REFERENCE: | |
7134 | vkind = DEBUG_LOCAL; | |
7135 | break; | |
7136 | case DEBUG_PARM_REG: | |
7137 | case DEBUG_PARM_REF_REG: | |
7138 | vkind = DEBUG_REGISTER; | |
7139 | break; | |
7140 | } | |
7141 | ||
b34976b6 AM |
7142 | if (! ieee_push_type (info, m->type, 0, FALSE, FALSE)) |
7143 | return FALSE; | |
252b5132 RH |
7144 | info->type_stack->type.referencep = m->referencep; |
7145 | if (m->referencep) | |
7146 | ++refcount; | |
2da42df6 | 7147 | if (! ieee_variable ((void *) info, m->name, vkind, m->val)) |
b34976b6 | 7148 | return FALSE; |
252b5132 RH |
7149 | } |
7150 | ||
7151 | /* If there are any reference parameters, we need to output a | |
7152 | miscellaneous record indicating them. */ | |
7153 | if (refcount > 0) | |
7154 | { | |
7155 | unsigned int nindx, varindx; | |
7156 | ||
7157 | /* FIXME: The MRI compiler outputs the demangled function name | |
7158 | here, but we are outputting the mangled name. */ | |
7159 | nindx = info->name_indx; | |
7160 | ++info->name_indx; | |
7161 | if (! ieee_change_buffer (info, &info->vars) | |
7162 | || ! ieee_write_byte (info, (int) ieee_nn_record) | |
7163 | || ! ieee_write_number (info, nindx) | |
7164 | || ! ieee_write_id (info, "") | |
7165 | || ! ieee_write_2bytes (info, (int) ieee_atn_record_enum) | |
7166 | || ! ieee_write_number (info, nindx) | |
7167 | || ! ieee_write_number (info, 0) | |
7168 | || ! ieee_write_number (info, 62) | |
7169 | || ! ieee_write_number (info, 80) | |
7170 | || ! ieee_write_number (info, refcount + 3) | |
7171 | || ! ieee_write_asn (info, nindx, 'B') | |
7172 | || ! ieee_write_atn65 (info, nindx, info->fnname) | |
7173 | || ! ieee_write_asn (info, nindx, 0)) | |
b34976b6 | 7174 | return FALSE; |
252b5132 RH |
7175 | for (m = info->pending_parms, varindx = 1; |
7176 | m != NULL; | |
7177 | m = m->next, varindx++) | |
7178 | { | |
7179 | if (m->referencep) | |
7180 | { | |
7181 | if (! ieee_write_asn (info, nindx, varindx)) | |
b34976b6 | 7182 | return FALSE; |
252b5132 RH |
7183 | } |
7184 | } | |
7185 | } | |
7186 | ||
7187 | m = info->pending_parms; | |
7188 | while (m != NULL) | |
7189 | { | |
7190 | struct ieee_pending_parm *next; | |
7191 | ||
7192 | next = m->next; | |
7193 | free (m); | |
7194 | m = next; | |
7195 | } | |
7196 | ||
7197 | info->pending_parms = NULL; | |
7198 | ||
b34976b6 | 7199 | return TRUE; |
252b5132 RH |
7200 | } |
7201 | ||
7202 | /* Start a block. If this is the first block, we output the address | |
7203 | to finish the BB4 or BB6, and then output the function parameters. */ | |
7204 | ||
b34976b6 | 7205 | static bfd_boolean |
2da42df6 | 7206 | ieee_start_block (void *p, bfd_vma addr) |
252b5132 RH |
7207 | { |
7208 | struct ieee_handle *info = (struct ieee_handle *) p; | |
7209 | ||
7210 | if (! ieee_change_buffer (info, &info->vars)) | |
b34976b6 | 7211 | return FALSE; |
252b5132 RH |
7212 | |
7213 | if (info->block_depth == 1) | |
7214 | { | |
7215 | if (! ieee_write_number (info, addr) | |
7216 | || ! ieee_output_pending_parms (info)) | |
b34976b6 | 7217 | return FALSE; |
252b5132 RH |
7218 | } |
7219 | else | |
7220 | { | |
7221 | if (! ieee_write_byte (info, (int) ieee_bb_record_enum) | |
7222 | || ! ieee_write_byte (info, 6) | |
7223 | || ! ieee_write_number (info, 0) | |
7224 | || ! ieee_write_id (info, "") | |
7225 | || ! ieee_write_number (info, 0) | |
7226 | || ! ieee_write_number (info, 0) | |
7227 | || ! ieee_write_number (info, addr)) | |
b34976b6 | 7228 | return FALSE; |
252b5132 RH |
7229 | } |
7230 | ||
7231 | if (! ieee_start_range (info, addr)) | |
b34976b6 | 7232 | return FALSE; |
252b5132 RH |
7233 | |
7234 | ++info->block_depth; | |
7235 | ||
b34976b6 | 7236 | return TRUE; |
252b5132 RH |
7237 | } |
7238 | ||
7239 | /* End a block. */ | |
7240 | ||
b34976b6 | 7241 | static bfd_boolean |
2da42df6 | 7242 | ieee_end_block (void *p, bfd_vma addr) |
252b5132 RH |
7243 | { |
7244 | struct ieee_handle *info = (struct ieee_handle *) p; | |
7245 | ||
7246 | /* The address we are given is the end of the block, but IEEE seems | |
7247 | to want to the address of the last byte in the block, so we | |
7248 | subtract one. */ | |
7249 | if (! ieee_change_buffer (info, &info->vars) | |
7250 | || ! ieee_write_byte (info, (int) ieee_be_record_enum) | |
7251 | || ! ieee_write_number (info, addr - 1)) | |
b34976b6 | 7252 | return FALSE; |
252b5132 RH |
7253 | |
7254 | if (! ieee_end_range (info, addr)) | |
b34976b6 | 7255 | return FALSE; |
252b5132 RH |
7256 | |
7257 | --info->block_depth; | |
7258 | ||
7259 | if (addr > info->highaddr) | |
7260 | info->highaddr = addr; | |
7261 | ||
b34976b6 | 7262 | return TRUE; |
252b5132 RH |
7263 | } |
7264 | ||
7265 | /* End a function. */ | |
7266 | ||
b34976b6 | 7267 | static bfd_boolean |
2da42df6 | 7268 | ieee_end_function (void *p) |
252b5132 RH |
7269 | { |
7270 | struct ieee_handle *info = (struct ieee_handle *) p; | |
7271 | ||
7272 | assert (info->block_depth == 1); | |
7273 | ||
7274 | --info->block_depth; | |
7275 | ||
7276 | /* Now we can finish up fntype, and add it to the typdef section. | |
7277 | At this point, fntype is the 'x' type up to the argument count, | |
7278 | and fnargs is the argument types. We must add the argument | |
7279 | count, and we must add the level. FIXME: We don't record varargs | |
7280 | functions correctly. In fact, stabs debugging does not give us | |
7281 | enough information to do so. */ | |
7282 | if (! ieee_change_buffer (info, &info->fntype) | |
7283 | || ! ieee_write_number (info, info->fnargcount) | |
7284 | || ! ieee_change_buffer (info, &info->fnargs) | |
7285 | || ! ieee_write_number (info, 0)) | |
b34976b6 | 7286 | return FALSE; |
252b5132 RH |
7287 | |
7288 | /* Make sure the typdef block has been started. */ | |
7289 | if (ieee_buffer_emptyp (&info->types)) | |
7290 | { | |
7291 | if (! ieee_change_buffer (info, &info->types) | |
7292 | || ! ieee_write_byte (info, (int) ieee_bb_record_enum) | |
7293 | || ! ieee_write_byte (info, 1) | |
7294 | || ! ieee_write_number (info, 0) | |
7295 | || ! ieee_write_id (info, info->modname)) | |
b34976b6 | 7296 | return FALSE; |
252b5132 RH |
7297 | } |
7298 | ||
7299 | if (! ieee_append_buffer (info, &info->types, &info->fntype) | |
7300 | || ! ieee_append_buffer (info, &info->types, &info->fnargs)) | |
b34976b6 | 7301 | return FALSE; |
252b5132 RH |
7302 | |
7303 | info->fnname = NULL; | |
7304 | if (! ieee_init_buffer (info, &info->fntype) | |
7305 | || ! ieee_init_buffer (info, &info->fnargs)) | |
b34976b6 | 7306 | return FALSE; |
252b5132 RH |
7307 | info->fnargcount = 0; |
7308 | ||
b34976b6 | 7309 | return TRUE; |
252b5132 RH |
7310 | } |
7311 | ||
7312 | /* Record line number information. */ | |
7313 | ||
b34976b6 | 7314 | static bfd_boolean |
2da42df6 | 7315 | ieee_lineno (void *p, const char *filename, unsigned long lineno, bfd_vma addr) |
252b5132 RH |
7316 | { |
7317 | struct ieee_handle *info = (struct ieee_handle *) p; | |
7318 | ||
7319 | assert (info->filename != NULL); | |
7320 | ||
7321 | /* The HP simulator seems to get confused when more than one line is | |
7322 | listed for the same address, at least if they are in different | |
7323 | files. We handle this by always listing the last line for a | |
7324 | given address, since that seems to be the one that gdb uses. */ | |
7325 | if (info->pending_lineno_filename != NULL | |
7326 | && addr != info->pending_lineno_addr) | |
7327 | { | |
7328 | /* Make sure we have a line number block. */ | |
7329 | if (! ieee_buffer_emptyp (&info->linenos)) | |
7330 | { | |
7331 | if (! ieee_change_buffer (info, &info->linenos)) | |
b34976b6 | 7332 | return FALSE; |
252b5132 RH |
7333 | } |
7334 | else | |
7335 | { | |
7336 | info->lineno_name_indx = info->name_indx; | |
7337 | ++info->name_indx; | |
7338 | if (! ieee_change_buffer (info, &info->linenos) | |
7339 | || ! ieee_write_byte (info, (int) ieee_bb_record_enum) | |
7340 | || ! ieee_write_byte (info, 5) | |
7341 | || ! ieee_write_number (info, 0) | |
7342 | || ! ieee_write_id (info, info->filename) | |
7343 | || ! ieee_write_byte (info, (int) ieee_nn_record) | |
7344 | || ! ieee_write_number (info, info->lineno_name_indx) | |
7345 | || ! ieee_write_id (info, "")) | |
b34976b6 | 7346 | return FALSE; |
252b5132 RH |
7347 | info->lineno_filename = info->filename; |
7348 | } | |
7349 | ||
7350 | if (strcmp (info->pending_lineno_filename, info->lineno_filename) != 0) | |
7351 | { | |
7352 | if (strcmp (info->filename, info->lineno_filename) != 0) | |
7353 | { | |
7354 | /* We were not in the main file. Close the block for the | |
7355 | included file. */ | |
7356 | if (! ieee_write_byte (info, (int) ieee_be_record_enum)) | |
b34976b6 | 7357 | return FALSE; |
252b5132 RH |
7358 | if (strcmp (info->filename, info->pending_lineno_filename) == 0) |
7359 | { | |
7360 | /* We need a new NN record, and we aren't about to | |
7361 | output one. */ | |
7362 | info->lineno_name_indx = info->name_indx; | |
7363 | ++info->name_indx; | |
7364 | if (! ieee_write_byte (info, (int) ieee_nn_record) | |
7365 | || ! ieee_write_number (info, info->lineno_name_indx) | |
7366 | || ! ieee_write_id (info, "")) | |
b34976b6 | 7367 | return FALSE; |
252b5132 RH |
7368 | } |
7369 | } | |
7370 | if (strcmp (info->filename, info->pending_lineno_filename) != 0) | |
7371 | { | |
7372 | /* We are not changing to the main file. Open a block for | |
7373 | the new included file. */ | |
7374 | info->lineno_name_indx = info->name_indx; | |
7375 | ++info->name_indx; | |
7376 | if (! ieee_write_byte (info, (int) ieee_bb_record_enum) | |
7377 | || ! ieee_write_byte (info, 5) | |
7378 | || ! ieee_write_number (info, 0) | |
7379 | || ! ieee_write_id (info, info->pending_lineno_filename) | |
7380 | || ! ieee_write_byte (info, (int) ieee_nn_record) | |
7381 | || ! ieee_write_number (info, info->lineno_name_indx) | |
7382 | || ! ieee_write_id (info, "")) | |
b34976b6 | 7383 | return FALSE; |
252b5132 RH |
7384 | } |
7385 | info->lineno_filename = info->pending_lineno_filename; | |
7386 | } | |
7387 | ||
7388 | if (! ieee_write_2bytes (info, (int) ieee_atn_record_enum) | |
7389 | || ! ieee_write_number (info, info->lineno_name_indx) | |
7390 | || ! ieee_write_number (info, 0) | |
7391 | || ! ieee_write_number (info, 7) | |
7392 | || ! ieee_write_number (info, info->pending_lineno) | |
7393 | || ! ieee_write_number (info, 0) | |
7394 | || ! ieee_write_asn (info, info->lineno_name_indx, | |
7395 | info->pending_lineno_addr)) | |
b34976b6 | 7396 | return FALSE; |
252b5132 RH |
7397 | } |
7398 | ||
7399 | info->pending_lineno_filename = filename; | |
7400 | info->pending_lineno = lineno; | |
7401 | info->pending_lineno_addr = addr; | |
7402 | ||
b34976b6 | 7403 | return TRUE; |
252b5132 | 7404 | } |