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