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