1 /* prdbg.c -- Print out generic debugging information. 2 Copyright 1995, 1996, 1999, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 3 2009 Free Software Foundation, Inc. 4 Written by Ian Lance Taylor <ian@cygnus.com>. 5 Tags style generation written by Salvador E. Tropea <set@computer.org>. 6 7 This file is part of GNU Binutils. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 22 02110-1301, USA. */ 23 24 /* This file prints out the generic debugging information, by 25 supplying a set of routines to debug_write. */ 26 27 #include "sysdep.h" 28 #include <assert.h> 29 #include "bfd.h" 30 #include "libiberty.h" 31 #include "demangle.h" 32 #include "debug.h" 33 #include "budbg.h" 34 35 /* This is the structure we use as a handle for these routines. */ 36 37 struct pr_handle 38 { 39 /* File to print information to. */ 40 FILE *f; 41 /* Current indentation level. */ 42 unsigned int indent; 43 /* Type stack. */ 44 struct pr_stack *stack; 45 /* Parameter number we are about to output. */ 46 int parameter; 47 /* The following are used only by the tags code (tg_). */ 48 /* Name of the file we are using. */ 49 char *filename; 50 /* The BFD. */ 51 bfd *abfd; 52 /* The symbols table for this BFD. */ 53 asymbol **syms; 54 /* Pointer to a function to demangle symbols. */ 55 char *(*demangler) (bfd *, const char *, int); 56 }; 57 58 /* The type stack. */ 59 60 struct pr_stack 61 { 62 /* Next element on the stack. */ 63 struct pr_stack *next; 64 /* This element. */ 65 char *type; 66 /* Current visibility of fields if this is a class. */ 67 enum debug_visibility visibility; 68 /* Name of the current method we are handling. */ 69 const char *method; 70 /* The following are used only by the tags code (tg_). */ 71 /* Type for the container (struct, union, class, union class). */ 72 const char *flavor; 73 /* A comma separated list of parent classes. */ 74 char *parents; 75 /* How many parents contains parents. */ 76 int num_parents; 77 }; 78 79 static void indent (struct pr_handle *); 80 static bfd_boolean push_type (struct pr_handle *, const char *); 81 static bfd_boolean prepend_type (struct pr_handle *, const char *); 82 static bfd_boolean append_type (struct pr_handle *, const char *); 83 static bfd_boolean substitute_type (struct pr_handle *, const char *); 84 static bfd_boolean indent_type (struct pr_handle *); 85 static char *pop_type (struct pr_handle *); 86 static void print_vma (bfd_vma, char *, bfd_boolean, bfd_boolean); 87 static bfd_boolean pr_fix_visibility 88 (struct pr_handle *, enum debug_visibility); 89 static bfd_boolean pr_start_compilation_unit (void *, const char *); 90 static bfd_boolean pr_start_source (void *, const char *); 91 static bfd_boolean pr_empty_type (void *); 92 static bfd_boolean pr_void_type (void *); 93 static bfd_boolean pr_int_type (void *, unsigned int, bfd_boolean); 94 static bfd_boolean pr_float_type (void *, unsigned int); 95 static bfd_boolean pr_complex_type (void *, unsigned int); 96 static bfd_boolean pr_bool_type (void *, unsigned int); 97 static bfd_boolean pr_enum_type 98 (void *, const char *, const char **, bfd_signed_vma *); 99 static bfd_boolean pr_pointer_type (void *); 100 static bfd_boolean pr_function_type (void *, int, bfd_boolean); 101 static bfd_boolean pr_reference_type (void *); 102 static bfd_boolean pr_range_type (void *, bfd_signed_vma, bfd_signed_vma); 103 static bfd_boolean pr_array_type 104 (void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean); 105 static bfd_boolean pr_set_type (void *, bfd_boolean); 106 static bfd_boolean pr_offset_type (void *); 107 static bfd_boolean pr_method_type (void *, bfd_boolean, int, bfd_boolean); 108 static bfd_boolean pr_const_type (void *); 109 static bfd_boolean pr_volatile_type (void *); 110 static bfd_boolean pr_start_struct_type 111 (void *, const char *, unsigned int, bfd_boolean, unsigned int); 112 static bfd_boolean pr_struct_field 113 (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility); 114 static bfd_boolean pr_end_struct_type (void *); 115 static bfd_boolean pr_start_class_type 116 (void *, const char *, unsigned int, bfd_boolean, unsigned int, 117 bfd_boolean, bfd_boolean); 118 static bfd_boolean pr_class_static_member 119 (void *, const char *, const char *, enum debug_visibility); 120 static bfd_boolean pr_class_baseclass 121 (void *, bfd_vma, bfd_boolean, enum debug_visibility); 122 static bfd_boolean pr_class_start_method (void *, const char *); 123 static bfd_boolean pr_class_method_variant 124 (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean, 125 bfd_vma, bfd_boolean); 126 static bfd_boolean pr_class_static_method_variant 127 (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean); 128 static bfd_boolean pr_class_end_method (void *); 129 static bfd_boolean pr_end_class_type (void *); 130 static bfd_boolean pr_typedef_type (void *, const char *); 131 static bfd_boolean pr_tag_type 132 (void *, const char *, unsigned int, enum debug_type_kind); 133 static bfd_boolean pr_typdef (void *, const char *); 134 static bfd_boolean pr_tag (void *, const char *); 135 static bfd_boolean pr_int_constant (void *, const char *, bfd_vma); 136 static bfd_boolean pr_float_constant (void *, const char *, double); 137 static bfd_boolean pr_typed_constant (void *, const char *, bfd_vma); 138 static bfd_boolean pr_variable 139 (void *, const char *, enum debug_var_kind, bfd_vma); 140 static bfd_boolean pr_start_function (void *, const char *, bfd_boolean); 141 static bfd_boolean pr_function_parameter 142 (void *, const char *, enum debug_parm_kind, bfd_vma); 143 static bfd_boolean pr_start_block (void *, bfd_vma); 144 static bfd_boolean pr_end_block (void *, bfd_vma); 145 static bfd_boolean pr_end_function (void *); 146 static bfd_boolean pr_lineno (void *, const char *, unsigned long, bfd_vma); 147 static bfd_boolean append_parent (struct pr_handle *, const char *); 148 /* Only used by tg_ code. */ 149 static bfd_boolean tg_fix_visibility 150 (struct pr_handle *, enum debug_visibility); 151 static void find_address_in_section (bfd *, asection *, void *); 152 static void translate_addresses (bfd *, char *, FILE *, asymbol **); 153 static const char *visibility_name (enum debug_visibility); 154 /* Tags style replacements. */ 155 static bfd_boolean tg_start_compilation_unit (void *, const char *); 156 static bfd_boolean tg_start_source (void *, const char *); 157 static bfd_boolean tg_enum_type 158 (void *, const char *, const char **, bfd_signed_vma *); 159 static bfd_boolean tg_start_struct_type 160 (void *, const char *, unsigned int, bfd_boolean, unsigned int); 161 static bfd_boolean pr_struct_field 162 (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility); 163 static bfd_boolean tg_struct_field 164 (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility); 165 static bfd_boolean tg_struct_field 166 (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility); 167 static bfd_boolean tg_end_struct_type (void *); 168 static bfd_boolean tg_start_class_type 169 (void *, const char *, unsigned int, bfd_boolean, unsigned int, bfd_boolean, bfd_boolean); 170 static bfd_boolean tg_class_static_member 171 (void *, const char *, const char *, enum debug_visibility); 172 static bfd_boolean tg_class_baseclass 173 (void *, bfd_vma, bfd_boolean, enum debug_visibility); 174 static bfd_boolean tg_class_method_variant 175 (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean); 176 static bfd_boolean tg_class_static_method_variant 177 (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean); 178 static bfd_boolean tg_end_class_type (void *); 179 static bfd_boolean tg_tag_type 180 (void *, const char *, unsigned int, enum debug_type_kind); 181 static bfd_boolean tg_typdef (void *, const char *); 182 static bfd_boolean tg_tag (void *, const char *); 183 static bfd_boolean tg_int_constant (void *, const char *, bfd_vma); 184 static bfd_boolean tg_float_constant (void *, const char *, double); 185 static bfd_boolean tg_typed_constant (void *, const char *, bfd_vma); 186 static bfd_boolean tg_variable 187 (void *, const char *, enum debug_var_kind, bfd_vma); 188 static bfd_boolean tg_start_function (void *, const char *, bfd_boolean); 189 static bfd_boolean tg_function_parameter 190 (void *, const char *, enum debug_parm_kind, bfd_vma); 191 static bfd_boolean tg_start_block (void *, bfd_vma); 192 static bfd_boolean tg_end_block (void *, bfd_vma); 193 static bfd_boolean tg_lineno (void *, const char *, unsigned long, bfd_vma); 194 195 static const struct debug_write_fns pr_fns = 196 { 197 pr_start_compilation_unit, 198 pr_start_source, 199 pr_empty_type, 200 pr_void_type, 201 pr_int_type, 202 pr_float_type, 203 pr_complex_type, 204 pr_bool_type, 205 pr_enum_type, 206 pr_pointer_type, 207 pr_function_type, 208 pr_reference_type, 209 pr_range_type, 210 pr_array_type, 211 pr_set_type, 212 pr_offset_type, 213 pr_method_type, 214 pr_const_type, 215 pr_volatile_type, 216 pr_start_struct_type, 217 pr_struct_field, 218 pr_end_struct_type, 219 pr_start_class_type, 220 pr_class_static_member, 221 pr_class_baseclass, 222 pr_class_start_method, 223 pr_class_method_variant, 224 pr_class_static_method_variant, 225 pr_class_end_method, 226 pr_end_class_type, 227 pr_typedef_type, 228 pr_tag_type, 229 pr_typdef, 230 pr_tag, 231 pr_int_constant, 232 pr_float_constant, 233 pr_typed_constant, 234 pr_variable, 235 pr_start_function, 236 pr_function_parameter, 237 pr_start_block, 238 pr_end_block, 239 pr_end_function, 240 pr_lineno 241 }; 242 243 static const struct debug_write_fns tg_fns = 244 { 245 tg_start_compilation_unit, 246 tg_start_source, 247 pr_empty_type, /* Same, push_type. */ 248 pr_void_type, /* Same, push_type. */ 249 pr_int_type, /* Same, push_type. */ 250 pr_float_type, /* Same, push_type. */ 251 pr_complex_type, /* Same, push_type. */ 252 pr_bool_type, /* Same, push_type. */ 253 tg_enum_type, 254 pr_pointer_type, /* Same, changes to pointer. */ 255 pr_function_type, /* Same, push_type. */ 256 pr_reference_type, /* Same, changes to reference. */ 257 pr_range_type, /* FIXME: What's that?. */ 258 pr_array_type, /* Same, push_type. */ 259 pr_set_type, /* FIXME: What's that?. */ 260 pr_offset_type, /* FIXME: What's that?. */ 261 pr_method_type, /* Same. */ 262 pr_const_type, /* Same, changes to const. */ 263 pr_volatile_type, /* Same, changes to volatile. */ 264 tg_start_struct_type, 265 tg_struct_field, 266 tg_end_struct_type, 267 tg_start_class_type, 268 tg_class_static_member, 269 tg_class_baseclass, 270 pr_class_start_method, /* Same, remembers that's a method. */ 271 tg_class_method_variant, 272 tg_class_static_method_variant, 273 pr_class_end_method, /* Same, forgets that's a method. */ 274 tg_end_class_type, 275 pr_typedef_type, /* Same, just push type. */ 276 tg_tag_type, 277 tg_typdef, 278 tg_tag, 279 tg_int_constant, /* Untested. */ 280 tg_float_constant, /* Untested. */ 281 tg_typed_constant, /* Untested. */ 282 tg_variable, 283 tg_start_function, 284 tg_function_parameter, 285 tg_start_block, 286 tg_end_block, 287 pr_end_function, /* Same, does nothing. */ 288 tg_lineno 289 }; 290 291 /* Print out the generic debugging information recorded in dhandle. */ 292 293 bfd_boolean 294 print_debugging_info (FILE *f, void *dhandle, bfd *abfd, asymbol **syms, 295 void *demangler, bfd_boolean as_tags) 296 { 297 struct pr_handle info; 298 299 info.f = f; 300 info.indent = 0; 301 info.stack = NULL; 302 info.parameter = 0; 303 info.filename = NULL; 304 info.abfd = abfd; 305 info.syms = syms; 306 info.demangler = (char * (*)(struct bfd *, const char *, int)) demangler; 307 308 if (as_tags) 309 { 310 fputs ("!_TAG_FILE_FORMAT\t2\t/extended format/\n", f); 311 fputs ("!_TAG_FILE_SORTED\t0\t/0=unsorted, 1=sorted/\n", f); 312 fputs ("!_TAG_PROGRAM_AUTHOR\tIan Lance Taylor, Salvador E. Tropea and others\t//\n", f); 313 fputs ("!_TAG_PROGRAM_NAME\tobjdump\t/From GNU binutils/\n", f); 314 } 315 316 return as_tags ? debug_write (dhandle, &tg_fns, (void *) & info) 317 : debug_write (dhandle, &pr_fns, (void *) & info); 318 } 319 320 /* Indent to the current indentation level. */ 321 322 static void 323 indent (struct pr_handle *info) 324 { 325 unsigned int i; 326 327 for (i = 0; i < info->indent; i++) 328 putc (' ', info->f); 329 } 330 331 /* Push a type on the type stack. */ 332 333 static bfd_boolean 334 push_type (struct pr_handle *info, const char *type) 335 { 336 struct pr_stack *n; 337 338 if (type == NULL) 339 return FALSE; 340 341 n = (struct pr_stack *) xmalloc (sizeof *n); 342 memset (n, 0, sizeof *n); 343 344 n->type = xstrdup (type); 345 n->visibility = DEBUG_VISIBILITY_IGNORE; 346 n->method = NULL; 347 n->next = info->stack; 348 info->stack = n; 349 350 return TRUE; 351 } 352 353 /* Prepend a string onto the type on the top of the type stack. */ 354 355 static bfd_boolean 356 prepend_type (struct pr_handle *info, const char *s) 357 { 358 char *n; 359 360 assert (info->stack != NULL); 361 362 n = (char *) xmalloc (strlen (s) + strlen (info->stack->type) + 1); 363 sprintf (n, "%s%s", s, info->stack->type); 364 free (info->stack->type); 365 info->stack->type = n; 366 367 return TRUE; 368 } 369 370 /* Append a string to the type on the top of the type stack. */ 371 372 static bfd_boolean 373 append_type (struct pr_handle *info, const char *s) 374 { 375 unsigned int len; 376 377 if (s == NULL) 378 return FALSE; 379 380 assert (info->stack != NULL); 381 382 len = strlen (info->stack->type); 383 info->stack->type = (char *) xrealloc (info->stack->type, 384 len + strlen (s) + 1); 385 strcpy (info->stack->type + len, s); 386 387 return TRUE; 388 } 389 390 /* Append a string to the parents on the top of the type stack. */ 391 392 static bfd_boolean 393 append_parent (struct pr_handle *info, const char *s) 394 { 395 unsigned int len; 396 397 if (s == NULL) 398 return FALSE; 399 400 assert (info->stack != NULL); 401 402 len = info->stack->parents ? strlen (info->stack->parents) : 0; 403 info->stack->parents = (char *) xrealloc (info->stack->parents, 404 len + strlen (s) + 1); 405 strcpy (info->stack->parents + len, s); 406 407 return TRUE; 408 } 409 410 /* We use an underscore to indicate where the name should go in a type 411 string. This function substitutes a string for the underscore. If 412 there is no underscore, the name follows the type. */ 413 414 static bfd_boolean 415 substitute_type (struct pr_handle *info, const char *s) 416 { 417 char *u; 418 419 assert (info->stack != NULL); 420 421 u = strchr (info->stack->type, '|'); 422 if (u != NULL) 423 { 424 char *n; 425 426 n = (char *) xmalloc (strlen (info->stack->type) + strlen (s)); 427 428 memcpy (n, info->stack->type, u - info->stack->type); 429 strcpy (n + (u - info->stack->type), s); 430 strcat (n, u + 1); 431 432 free (info->stack->type); 433 info->stack->type = n; 434 435 return TRUE; 436 } 437 438 if (strchr (s, '|') != NULL 439 && (strchr (info->stack->type, '{') != NULL 440 || strchr (info->stack->type, '(') != NULL)) 441 { 442 if (! prepend_type (info, "(") 443 || ! append_type (info, ")")) 444 return FALSE; 445 } 446 447 if (*s == '\0') 448 return TRUE; 449 450 return (append_type (info, " ") 451 && append_type (info, s)); 452 } 453 454 /* Indent the type at the top of the stack by appending spaces. */ 455 456 static bfd_boolean 457 indent_type (struct pr_handle *info) 458 { 459 unsigned int i; 460 461 for (i = 0; i < info->indent; i++) 462 { 463 if (! append_type (info, " ")) 464 return FALSE; 465 } 466 467 return TRUE; 468 } 469 470 /* Pop a type from the type stack. */ 471 472 static char * 473 pop_type (struct pr_handle *info) 474 { 475 struct pr_stack *o; 476 char *ret; 477 478 assert (info->stack != NULL); 479 480 o = info->stack; 481 info->stack = o->next; 482 ret = o->type; 483 free (o); 484 485 return ret; 486 } 487 488 /* Print a VMA value into a string. */ 489 490 static void 491 print_vma (bfd_vma vma, char *buf, bfd_boolean unsignedp, bfd_boolean hexp) 492 { 493 if (sizeof (vma) <= sizeof (unsigned long)) 494 { 495 if (hexp) 496 sprintf (buf, "0x%lx", (unsigned long) vma); 497 else if (unsignedp) 498 sprintf (buf, "%lu", (unsigned long) vma); 499 else 500 sprintf (buf, "%ld", (long) vma); 501 } 502 #if BFD_HOST_64BIT_LONG_LONG 503 else if (sizeof (vma) <= sizeof (unsigned long long)) 504 { 505 #ifndef __MSVCRT__ 506 if (hexp) 507 sprintf (buf, "0x%llx", (unsigned long long) vma); 508 else if (unsignedp) 509 sprintf (buf, "%llu", (unsigned long long) vma); 510 else 511 sprintf (buf, "%lld", (long long) vma); 512 #else 513 if (hexp) 514 sprintf (buf, "0x%I64x", (unsigned long long) vma); 515 else if (unsignedp) 516 sprintf (buf, "%I64u", (unsigned long long) vma); 517 else 518 sprintf (buf, "%I64d", (long long) vma); 519 #endif 520 } 521 #endif 522 else 523 { 524 buf[0] = '0'; 525 buf[1] = 'x'; 526 sprintf_vma (buf + 2, vma); 527 } 528 } 529 530 /* Start a new compilation unit. */ 531 532 static bfd_boolean 533 pr_start_compilation_unit (void *p, const char *filename) 534 { 535 struct pr_handle *info = (struct pr_handle *) p; 536 537 assert (info->indent == 0); 538 539 fprintf (info->f, "%s:\n", filename); 540 541 return TRUE; 542 } 543 544 /* Start a source file within a compilation unit. */ 545 546 static bfd_boolean 547 pr_start_source (void *p, const char *filename) 548 { 549 struct pr_handle *info = (struct pr_handle *) p; 550 551 assert (info->indent == 0); 552 553 fprintf (info->f, " %s:\n", filename); 554 555 return TRUE; 556 } 557 558 /* Push an empty type onto the type stack. */ 559 560 static bfd_boolean 561 pr_empty_type (void *p) 562 { 563 struct pr_handle *info = (struct pr_handle *) p; 564 565 return push_type (info, "<undefined>"); 566 } 567 568 /* Push a void type onto the type stack. */ 569 570 static bfd_boolean 571 pr_void_type (void *p) 572 { 573 struct pr_handle *info = (struct pr_handle *) p; 574 575 return push_type (info, "void"); 576 } 577 578 /* Push an integer type onto the type stack. */ 579 580 static bfd_boolean 581 pr_int_type (void *p, unsigned int size, bfd_boolean unsignedp) 582 { 583 struct pr_handle *info = (struct pr_handle *) p; 584 char ab[10]; 585 586 sprintf (ab, "%sint%d", unsignedp ? "u" : "", size * 8); 587 return push_type (info, ab); 588 } 589 590 /* Push a floating type onto the type stack. */ 591 592 static bfd_boolean 593 pr_float_type (void *p, unsigned int size) 594 { 595 struct pr_handle *info = (struct pr_handle *) p; 596 char ab[10]; 597 598 if (size == 4) 599 return push_type (info, "float"); 600 else if (size == 8) 601 return push_type (info, "double"); 602 603 sprintf (ab, "float%d", size * 8); 604 return push_type (info, ab); 605 } 606 607 /* Push a complex type onto the type stack. */ 608 609 static bfd_boolean 610 pr_complex_type (void *p, unsigned int size) 611 { 612 struct pr_handle *info = (struct pr_handle *) p; 613 614 if (! pr_float_type (p, size)) 615 return FALSE; 616 617 return prepend_type (info, "complex "); 618 } 619 620 /* Push a bfd_boolean type onto the type stack. */ 621 622 static bfd_boolean 623 pr_bool_type (void *p, unsigned int size) 624 { 625 struct pr_handle *info = (struct pr_handle *) p; 626 char ab[10]; 627 628 sprintf (ab, "bool%d", size * 8); 629 630 return push_type (info, ab); 631 } 632 633 /* Push an enum type onto the type stack. */ 634 635 static bfd_boolean 636 pr_enum_type (void *p, const char *tag, const char **names, 637 bfd_signed_vma *values) 638 { 639 struct pr_handle *info = (struct pr_handle *) p; 640 unsigned int i; 641 bfd_signed_vma val; 642 643 if (! push_type (info, "enum ")) 644 return FALSE; 645 if (tag != NULL) 646 { 647 if (! append_type (info, tag) 648 || ! append_type (info, " ")) 649 return FALSE; 650 } 651 if (! append_type (info, "{ ")) 652 return FALSE; 653 654 if (names == NULL) 655 { 656 if (! append_type (info, "/* undefined */")) 657 return FALSE; 658 } 659 else 660 { 661 val = 0; 662 for (i = 0; names[i] != NULL; i++) 663 { 664 if (i > 0) 665 { 666 if (! append_type (info, ", ")) 667 return FALSE; 668 } 669 670 if (! append_type (info, names[i])) 671 return FALSE; 672 673 if (values[i] != val) 674 { 675 char ab[20]; 676 677 print_vma (values[i], ab, FALSE, FALSE); 678 if (! append_type (info, " = ") 679 || ! append_type (info, ab)) 680 return FALSE; 681 val = values[i]; 682 } 683 684 ++val; 685 } 686 } 687 688 return append_type (info, " }"); 689 } 690 691 /* Turn the top type on the stack into a pointer. */ 692 693 static bfd_boolean 694 pr_pointer_type (void *p) 695 { 696 struct pr_handle *info = (struct pr_handle *) p; 697 char *s; 698 699 assert (info->stack != NULL); 700 701 s = strchr (info->stack->type, '|'); 702 if (s != NULL && s[1] == '[') 703 return substitute_type (info, "(*|)"); 704 return substitute_type (info, "*|"); 705 } 706 707 /* Turn the top type on the stack into a function returning that type. */ 708 709 static bfd_boolean 710 pr_function_type (void *p, int argcount, bfd_boolean varargs) 711 { 712 struct pr_handle *info = (struct pr_handle *) p; 713 char **arg_types; 714 unsigned int len; 715 char *s; 716 717 assert (info->stack != NULL); 718 719 len = 10; 720 721 if (argcount <= 0) 722 { 723 arg_types = NULL; 724 len += 15; 725 } 726 else 727 { 728 int i; 729 730 arg_types = (char **) xmalloc (argcount * sizeof *arg_types); 731 for (i = argcount - 1; i >= 0; i--) 732 { 733 if (! substitute_type (info, "")) 734 return FALSE; 735 arg_types[i] = pop_type (info); 736 if (arg_types[i] == NULL) 737 return FALSE; 738 len += strlen (arg_types[i]) + 2; 739 } 740 if (varargs) 741 len += 5; 742 } 743 744 /* Now the return type is on the top of the stack. */ 745 746 s = (char *) xmalloc (len); 747 LITSTRCPY (s, "(|) ("); 748 749 if (argcount < 0) 750 strcat (s, "/* unknown */"); 751 else 752 { 753 int i; 754 755 for (i = 0; i < argcount; i++) 756 { 757 if (i > 0) 758 strcat (s, ", "); 759 strcat (s, arg_types[i]); 760 } 761 if (varargs) 762 { 763 if (i > 0) 764 strcat (s, ", "); 765 strcat (s, "..."); 766 } 767 if (argcount > 0) 768 free (arg_types); 769 } 770 771 strcat (s, ")"); 772 773 if (! substitute_type (info, s)) 774 return FALSE; 775 776 free (s); 777 778 return TRUE; 779 } 780 781 /* Turn the top type on the stack into a reference to that type. */ 782 783 static bfd_boolean 784 pr_reference_type (void *p) 785 { 786 struct pr_handle *info = (struct pr_handle *) p; 787 788 assert (info->stack != NULL); 789 790 return substitute_type (info, "&|"); 791 } 792 793 /* Make a range type. */ 794 795 static bfd_boolean 796 pr_range_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper) 797 { 798 struct pr_handle *info = (struct pr_handle *) p; 799 char abl[20], abu[20]; 800 801 assert (info->stack != NULL); 802 803 if (! substitute_type (info, "")) 804 return FALSE; 805 806 print_vma (lower, abl, FALSE, FALSE); 807 print_vma (upper, abu, FALSE, FALSE); 808 809 return (prepend_type (info, "range (") 810 && append_type (info, "):") 811 && append_type (info, abl) 812 && append_type (info, ":") 813 && append_type (info, abu)); 814 } 815 816 /* Make an array type. */ 817 818 static bfd_boolean 819 pr_array_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper, 820 bfd_boolean stringp) 821 { 822 struct pr_handle *info = (struct pr_handle *) p; 823 char *range_type; 824 char abl[20], abu[20], ab[50]; 825 826 range_type = pop_type (info); 827 if (range_type == NULL) 828 return FALSE; 829 830 if (lower == 0) 831 { 832 if (upper == -1) 833 sprintf (ab, "|[]"); 834 else 835 { 836 print_vma (upper + 1, abu, FALSE, FALSE); 837 sprintf (ab, "|[%s]", abu); 838 } 839 } 840 else 841 { 842 print_vma (lower, abl, FALSE, FALSE); 843 print_vma (upper, abu, FALSE, FALSE); 844 sprintf (ab, "|[%s:%s]", abl, abu); 845 } 846 847 if (! substitute_type (info, ab)) 848 return FALSE; 849 850 if (strcmp (range_type, "int") != 0) 851 { 852 if (! append_type (info, ":") 853 || ! append_type (info, range_type)) 854 return FALSE; 855 } 856 857 if (stringp) 858 { 859 if (! append_type (info, " /* string */")) 860 return FALSE; 861 } 862 863 return TRUE; 864 } 865 866 /* Make a set type. */ 867 868 static bfd_boolean 869 pr_set_type (void *p, bfd_boolean bitstringp) 870 { 871 struct pr_handle *info = (struct pr_handle *) p; 872 873 if (! substitute_type (info, "")) 874 return FALSE; 875 876 if (! prepend_type (info, "set { ") 877 || ! append_type (info, " }")) 878 return FALSE; 879 880 if (bitstringp) 881 { 882 if (! append_type (info, "/* bitstring */")) 883 return FALSE; 884 } 885 886 return TRUE; 887 } 888 889 /* Make an offset type. */ 890 891 static bfd_boolean 892 pr_offset_type (void *p) 893 { 894 struct pr_handle *info = (struct pr_handle *) p; 895 char *t; 896 897 if (! substitute_type (info, "")) 898 return FALSE; 899 900 t = pop_type (info); 901 if (t == NULL) 902 return FALSE; 903 904 return (substitute_type (info, "") 905 && prepend_type (info, " ") 906 && prepend_type (info, t) 907 && append_type (info, "::|")); 908 } 909 910 /* Make a method type. */ 911 912 static bfd_boolean 913 pr_method_type (void *p, bfd_boolean domain, int argcount, bfd_boolean varargs) 914 { 915 struct pr_handle *info = (struct pr_handle *) p; 916 unsigned int len; 917 char *domain_type; 918 char **arg_types; 919 char *s; 920 921 len = 10; 922 923 if (! domain) 924 domain_type = NULL; 925 else 926 { 927 if (! substitute_type (info, "")) 928 return FALSE; 929 domain_type = pop_type (info); 930 if (domain_type == NULL) 931 return FALSE; 932 if (CONST_STRNEQ (domain_type, "class ") 933 && strchr (domain_type + sizeof "class " - 1, ' ') == NULL) 934 domain_type += sizeof "class " - 1; 935 else if (CONST_STRNEQ (domain_type, "union class ") 936 && (strchr (domain_type + sizeof "union class " - 1, ' ') 937 == NULL)) 938 domain_type += sizeof "union class " - 1; 939 len += strlen (domain_type); 940 } 941 942 if (argcount <= 0) 943 { 944 arg_types = NULL; 945 len += 15; 946 } 947 else 948 { 949 int i; 950 951 arg_types = (char **) xmalloc (argcount * sizeof *arg_types); 952 for (i = argcount - 1; i >= 0; i--) 953 { 954 if (! substitute_type (info, "")) 955 return FALSE; 956 arg_types[i] = pop_type (info); 957 if (arg_types[i] == NULL) 958 return FALSE; 959 len += strlen (arg_types[i]) + 2; 960 } 961 if (varargs) 962 len += 5; 963 } 964 965 /* Now the return type is on the top of the stack. */ 966 967 s = (char *) xmalloc (len); 968 if (! domain) 969 *s = '\0'; 970 else 971 strcpy (s, domain_type); 972 strcat (s, "::| ("); 973 974 if (argcount < 0) 975 strcat (s, "/* unknown */"); 976 else 977 { 978 int i; 979 980 for (i = 0; i < argcount; i++) 981 { 982 if (i > 0) 983 strcat (s, ", "); 984 strcat (s, arg_types[i]); 985 } 986 if (varargs) 987 { 988 if (i > 0) 989 strcat (s, ", "); 990 strcat (s, "..."); 991 } 992 if (argcount > 0) 993 free (arg_types); 994 } 995 996 strcat (s, ")"); 997 998 if (! substitute_type (info, s)) 999 return FALSE; 1000 1001 free (s); 1002 1003 return TRUE; 1004 } 1005 1006 /* Make a const qualified type. */ 1007 1008 static bfd_boolean 1009 pr_const_type (void *p) 1010 { 1011 struct pr_handle *info = (struct pr_handle *) p; 1012 1013 return substitute_type (info, "const |"); 1014 } 1015 1016 /* Make a volatile qualified type. */ 1017 1018 static bfd_boolean 1019 pr_volatile_type (void *p) 1020 { 1021 struct pr_handle *info = (struct pr_handle *) p; 1022 1023 return substitute_type (info, "volatile |"); 1024 } 1025 1026 /* Start accumulating a struct type. */ 1027 1028 static bfd_boolean 1029 pr_start_struct_type (void *p, const char *tag, unsigned int id, 1030 bfd_boolean structp, unsigned int size) 1031 { 1032 struct pr_handle *info = (struct pr_handle *) p; 1033 1034 info->indent += 2; 1035 1036 if (! push_type (info, structp ? "struct " : "union ")) 1037 return FALSE; 1038 if (tag != NULL) 1039 { 1040 if (! append_type (info, tag)) 1041 return FALSE; 1042 } 1043 else 1044 { 1045 char idbuf[20]; 1046 1047 sprintf (idbuf, "%%anon%u", id); 1048 if (! append_type (info, idbuf)) 1049 return FALSE; 1050 } 1051 1052 if (! append_type (info, " {")) 1053 return FALSE; 1054 if (size != 0 || tag != NULL) 1055 { 1056 char ab[30]; 1057 1058 if (! append_type (info, " /*")) 1059 return FALSE; 1060 1061 if (size != 0) 1062 { 1063 sprintf (ab, " size %u", size); 1064 if (! append_type (info, ab)) 1065 return FALSE; 1066 } 1067 if (tag != NULL) 1068 { 1069 sprintf (ab, " id %u", id); 1070 if (! append_type (info, ab)) 1071 return FALSE; 1072 } 1073 if (! append_type (info, " */")) 1074 return FALSE; 1075 } 1076 if (! append_type (info, "\n")) 1077 return FALSE; 1078 1079 info->stack->visibility = DEBUG_VISIBILITY_PUBLIC; 1080 1081 return indent_type (info); 1082 } 1083 1084 /* Output the visibility of a field in a struct. */ 1085 1086 static bfd_boolean 1087 pr_fix_visibility (struct pr_handle *info, enum debug_visibility visibility) 1088 { 1089 const char *s = NULL; 1090 char *t; 1091 unsigned int len; 1092 1093 assert (info->stack != NULL); 1094 1095 if (info->stack->visibility == visibility) 1096 return TRUE; 1097 1098 switch (visibility) 1099 { 1100 case DEBUG_VISIBILITY_PUBLIC: 1101 s = "public"; 1102 break; 1103 case DEBUG_VISIBILITY_PRIVATE: 1104 s = "private"; 1105 break; 1106 case DEBUG_VISIBILITY_PROTECTED: 1107 s = "protected"; 1108 break; 1109 case DEBUG_VISIBILITY_IGNORE: 1110 s = "/* ignore */"; 1111 break; 1112 default: 1113 abort (); 1114 return FALSE; 1115 } 1116 1117 /* Trim off a trailing space in the struct string, to make the 1118 output look a bit better, then stick on the visibility string. */ 1119 1120 t = info->stack->type; 1121 len = strlen (t); 1122 assert (t[len - 1] == ' '); 1123 t[len - 1] = '\0'; 1124 1125 if (! append_type (info, s) 1126 || ! append_type (info, ":\n") 1127 || ! indent_type (info)) 1128 return FALSE; 1129 1130 info->stack->visibility = visibility; 1131 1132 return TRUE; 1133 } 1134 1135 /* Add a field to a struct type. */ 1136 1137 static bfd_boolean 1138 pr_struct_field (void *p, const char *name, bfd_vma bitpos, bfd_vma bitsize, 1139 enum debug_visibility visibility) 1140 { 1141 struct pr_handle *info = (struct pr_handle *) p; 1142 char ab[20]; 1143 char *t; 1144 1145 if (! substitute_type (info, name)) 1146 return FALSE; 1147 1148 if (! append_type (info, "; /* ")) 1149 return FALSE; 1150 1151 if (bitsize != 0) 1152 { 1153 print_vma (bitsize, ab, TRUE, FALSE); 1154 if (! append_type (info, "bitsize ") 1155 || ! append_type (info, ab) 1156 || ! append_type (info, ", ")) 1157 return FALSE; 1158 } 1159 1160 print_vma (bitpos, ab, TRUE, FALSE); 1161 if (! append_type (info, "bitpos ") 1162 || ! append_type (info, ab) 1163 || ! append_type (info, " */\n") 1164 || ! indent_type (info)) 1165 return FALSE; 1166 1167 t = pop_type (info); 1168 if (t == NULL) 1169 return FALSE; 1170 1171 if (! pr_fix_visibility (info, visibility)) 1172 return FALSE; 1173 1174 return append_type (info, t); 1175 } 1176 1177 /* Finish a struct type. */ 1178 1179 static bfd_boolean 1180 pr_end_struct_type (void *p) 1181 { 1182 struct pr_handle *info = (struct pr_handle *) p; 1183 char *s; 1184 1185 assert (info->stack != NULL); 1186 assert (info->indent >= 2); 1187 1188 info->indent -= 2; 1189 1190 /* Change the trailing indentation to have a close brace. */ 1191 s = info->stack->type + strlen (info->stack->type) - 2; 1192 assert (s[0] == ' ' && s[1] == ' ' && s[2] == '\0'); 1193 1194 *s++ = '}'; 1195 *s = '\0'; 1196 1197 return TRUE; 1198 } 1199 1200 /* Start a class type. */ 1201 1202 static bfd_boolean 1203 pr_start_class_type (void *p, const char *tag, unsigned int id, 1204 bfd_boolean structp, unsigned int size, 1205 bfd_boolean vptr, bfd_boolean ownvptr) 1206 { 1207 struct pr_handle *info = (struct pr_handle *) p; 1208 char *tv = NULL; 1209 1210 info->indent += 2; 1211 1212 if (vptr && ! ownvptr) 1213 { 1214 tv = pop_type (info); 1215 if (tv == NULL) 1216 return FALSE; 1217 } 1218 1219 if (! push_type (info, structp ? "class " : "union class ")) 1220 return FALSE; 1221 if (tag != NULL) 1222 { 1223 if (! append_type (info, tag)) 1224 return FALSE; 1225 } 1226 else 1227 { 1228 char idbuf[20]; 1229 1230 sprintf (idbuf, "%%anon%u", id); 1231 if (! append_type (info, idbuf)) 1232 return FALSE; 1233 } 1234 1235 if (! append_type (info, " {")) 1236 return FALSE; 1237 if (size != 0 || vptr || ownvptr || tag != NULL) 1238 { 1239 if (! append_type (info, " /*")) 1240 return FALSE; 1241 1242 if (size != 0) 1243 { 1244 char ab[20]; 1245 1246 sprintf (ab, "%u", size); 1247 if (! append_type (info, " size ") 1248 || ! append_type (info, ab)) 1249 return FALSE; 1250 } 1251 1252 if (vptr) 1253 { 1254 if (! append_type (info, " vtable ")) 1255 return FALSE; 1256 if (ownvptr) 1257 { 1258 if (! append_type (info, "self ")) 1259 return FALSE; 1260 } 1261 else 1262 { 1263 if (! append_type (info, tv) 1264 || ! append_type (info, " ")) 1265 return FALSE; 1266 } 1267 } 1268 1269 if (tag != NULL) 1270 { 1271 char ab[30]; 1272 1273 sprintf (ab, " id %u", id); 1274 if (! append_type (info, ab)) 1275 return FALSE; 1276 } 1277 1278 if (! append_type (info, " */")) 1279 return FALSE; 1280 } 1281 1282 info->stack->visibility = DEBUG_VISIBILITY_PRIVATE; 1283 1284 return (append_type (info, "\n") 1285 && indent_type (info)); 1286 } 1287 1288 /* Add a static member to a class. */ 1289 1290 static bfd_boolean 1291 pr_class_static_member (void *p, const char *name, const char *physname, 1292 enum debug_visibility visibility) 1293 { 1294 struct pr_handle *info = (struct pr_handle *) p; 1295 char *t; 1296 1297 if (! substitute_type (info, name)) 1298 return FALSE; 1299 1300 if (! prepend_type (info, "static ") 1301 || ! append_type (info, "; /* ") 1302 || ! append_type (info, physname) 1303 || ! append_type (info, " */\n") 1304 || ! indent_type (info)) 1305 return FALSE; 1306 1307 t = pop_type (info); 1308 if (t == NULL) 1309 return FALSE; 1310 1311 if (! pr_fix_visibility (info, visibility)) 1312 return FALSE; 1313 1314 return append_type (info, t); 1315 } 1316 1317 /* Add a base class to a class. */ 1318 1319 static bfd_boolean 1320 pr_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean is_virtual, 1321 enum debug_visibility visibility) 1322 { 1323 struct pr_handle *info = (struct pr_handle *) p; 1324 char *t; 1325 const char *prefix; 1326 char ab[20]; 1327 char *s, *l, *n; 1328 1329 assert (info->stack != NULL && info->stack->next != NULL); 1330 1331 if (! substitute_type (info, "")) 1332 return FALSE; 1333 1334 t = pop_type (info); 1335 if (t == NULL) 1336 return FALSE; 1337 1338 if (CONST_STRNEQ (t, "class ")) 1339 t += sizeof "class " - 1; 1340 1341 /* Push it back on to take advantage of the prepend_type and 1342 append_type routines. */ 1343 if (! push_type (info, t)) 1344 return FALSE; 1345 1346 if (is_virtual) 1347 { 1348 if (! prepend_type (info, "virtual ")) 1349 return FALSE; 1350 } 1351 1352 switch (visibility) 1353 { 1354 case DEBUG_VISIBILITY_PUBLIC: 1355 prefix = "public "; 1356 break; 1357 case DEBUG_VISIBILITY_PROTECTED: 1358 prefix = "protected "; 1359 break; 1360 case DEBUG_VISIBILITY_PRIVATE: 1361 prefix = "private "; 1362 break; 1363 default: 1364 prefix = "/* unknown visibility */ "; 1365 break; 1366 } 1367 1368 if (! prepend_type (info, prefix)) 1369 return FALSE; 1370 1371 if (bitpos != 0) 1372 { 1373 print_vma (bitpos, ab, TRUE, FALSE); 1374 if (! append_type (info, " /* bitpos ") 1375 || ! append_type (info, ab) 1376 || ! append_type (info, " */")) 1377 return FALSE; 1378 } 1379 1380 /* Now the top of the stack is something like "public A / * bitpos 1381 10 * /". The next element on the stack is something like "class 1382 xx { / * size 8 * /\n...". We want to substitute the top of the 1383 stack in before the {. */ 1384 s = strchr (info->stack->next->type, '{'); 1385 assert (s != NULL); 1386 --s; 1387 1388 /* If there is already a ':', then we already have a baseclass, and 1389 we must append this one after a comma. */ 1390 for (l = info->stack->next->type; l != s; l++) 1391 if (*l == ':') 1392 break; 1393 if (! prepend_type (info, l == s ? " : " : ", ")) 1394 return FALSE; 1395 1396 t = pop_type (info); 1397 if (t == NULL) 1398 return FALSE; 1399 1400 n = (char *) xmalloc (strlen (info->stack->type) + strlen (t) + 1); 1401 memcpy (n, info->stack->type, s - info->stack->type); 1402 strcpy (n + (s - info->stack->type), t); 1403 strcat (n, s); 1404 1405 free (info->stack->type); 1406 info->stack->type = n; 1407 1408 free (t); 1409 1410 return TRUE; 1411 } 1412 1413 /* Start adding a method to a class. */ 1414 1415 static bfd_boolean 1416 pr_class_start_method (void *p, const char *name) 1417 { 1418 struct pr_handle *info = (struct pr_handle *) p; 1419 1420 assert (info->stack != NULL); 1421 info->stack->method = name; 1422 return TRUE; 1423 } 1424 1425 /* Add a variant to a method. */ 1426 1427 static bfd_boolean 1428 pr_class_method_variant (void *p, const char *physname, 1429 enum debug_visibility visibility, 1430 bfd_boolean constp, bfd_boolean volatilep, 1431 bfd_vma voffset, bfd_boolean context) 1432 { 1433 struct pr_handle *info = (struct pr_handle *) p; 1434 char *method_type; 1435 char *context_type; 1436 1437 assert (info->stack != NULL); 1438 assert (info->stack->next != NULL); 1439 1440 /* Put the const and volatile qualifiers on the type. */ 1441 if (volatilep) 1442 { 1443 if (! append_type (info, " volatile")) 1444 return FALSE; 1445 } 1446 if (constp) 1447 { 1448 if (! append_type (info, " const")) 1449 return FALSE; 1450 } 1451 1452 /* Stick the name of the method into its type. */ 1453 if (! substitute_type (info, 1454 (context 1455 ? info->stack->next->next->method 1456 : info->stack->next->method))) 1457 return FALSE; 1458 1459 /* Get the type. */ 1460 method_type = pop_type (info); 1461 if (method_type == NULL) 1462 return FALSE; 1463 1464 /* Pull off the context type if there is one. */ 1465 if (! context) 1466 context_type = NULL; 1467 else 1468 { 1469 context_type = pop_type (info); 1470 if (context_type == NULL) 1471 return FALSE; 1472 } 1473 1474 /* Now the top of the stack is the class. */ 1475 1476 if (! pr_fix_visibility (info, visibility)) 1477 return FALSE; 1478 1479 if (! append_type (info, method_type) 1480 || ! append_type (info, " /* ") 1481 || ! append_type (info, physname) 1482 || ! append_type (info, " ")) 1483 return FALSE; 1484 if (context || voffset != 0) 1485 { 1486 char ab[20]; 1487 1488 if (context) 1489 { 1490 if (! append_type (info, "context ") 1491 || ! append_type (info, context_type) 1492 || ! append_type (info, " ")) 1493 return FALSE; 1494 } 1495 print_vma (voffset, ab, TRUE, FALSE); 1496 if (! append_type (info, "voffset ") 1497 || ! append_type (info, ab)) 1498 return FALSE; 1499 } 1500 1501 return (append_type (info, " */;\n") 1502 && indent_type (info)); 1503 } 1504 1505 /* Add a static variant to a method. */ 1506 1507 static bfd_boolean 1508 pr_class_static_method_variant (void *p, const char *physname, 1509 enum debug_visibility visibility, 1510 bfd_boolean constp, bfd_boolean volatilep) 1511 { 1512 struct pr_handle *info = (struct pr_handle *) p; 1513 char *method_type; 1514 1515 assert (info->stack != NULL); 1516 assert (info->stack->next != NULL); 1517 assert (info->stack->next->method != NULL); 1518 1519 /* Put the const and volatile qualifiers on the type. */ 1520 if (volatilep) 1521 { 1522 if (! append_type (info, " volatile")) 1523 return FALSE; 1524 } 1525 if (constp) 1526 { 1527 if (! append_type (info, " const")) 1528 return FALSE; 1529 } 1530 1531 /* Mark it as static. */ 1532 if (! prepend_type (info, "static ")) 1533 return FALSE; 1534 1535 /* Stick the name of the method into its type. */ 1536 if (! substitute_type (info, info->stack->next->method)) 1537 return FALSE; 1538 1539 /* Get the type. */ 1540 method_type = pop_type (info); 1541 if (method_type == NULL) 1542 return FALSE; 1543 1544 /* Now the top of the stack is the class. */ 1545 1546 if (! pr_fix_visibility (info, visibility)) 1547 return FALSE; 1548 1549 return (append_type (info, method_type) 1550 && append_type (info, " /* ") 1551 && append_type (info, physname) 1552 && append_type (info, " */;\n") 1553 && indent_type (info)); 1554 } 1555 1556 /* Finish up a method. */ 1557 1558 static bfd_boolean 1559 pr_class_end_method (void *p) 1560 { 1561 struct pr_handle *info = (struct pr_handle *) p; 1562 1563 info->stack->method = NULL; 1564 return TRUE; 1565 } 1566 1567 /* Finish up a class. */ 1568 1569 static bfd_boolean 1570 pr_end_class_type (void *p) 1571 { 1572 return pr_end_struct_type (p); 1573 } 1574 1575 /* Push a type on the stack using a typedef name. */ 1576 1577 static bfd_boolean 1578 pr_typedef_type (void *p, const char *name) 1579 { 1580 struct pr_handle *info = (struct pr_handle *) p; 1581 1582 return push_type (info, name); 1583 } 1584 1585 /* Push a type on the stack using a tag name. */ 1586 1587 static bfd_boolean 1588 pr_tag_type (void *p, const char *name, unsigned int id, 1589 enum debug_type_kind kind) 1590 { 1591 struct pr_handle *info = (struct pr_handle *) p; 1592 const char *t, *tag; 1593 char idbuf[20]; 1594 1595 switch (kind) 1596 { 1597 case DEBUG_KIND_STRUCT: 1598 t = "struct "; 1599 break; 1600 case DEBUG_KIND_UNION: 1601 t = "union "; 1602 break; 1603 case DEBUG_KIND_ENUM: 1604 t = "enum "; 1605 break; 1606 case DEBUG_KIND_CLASS: 1607 t = "class "; 1608 break; 1609 case DEBUG_KIND_UNION_CLASS: 1610 t = "union class "; 1611 break; 1612 default: 1613 abort (); 1614 return FALSE; 1615 } 1616 1617 if (! push_type (info, t)) 1618 return FALSE; 1619 if (name != NULL) 1620 tag = name; 1621 else 1622 { 1623 sprintf (idbuf, "%%anon%u", id); 1624 tag = idbuf; 1625 } 1626 1627 if (! append_type (info, tag)) 1628 return FALSE; 1629 if (name != NULL && kind != DEBUG_KIND_ENUM) 1630 { 1631 sprintf (idbuf, " /* id %u */", id); 1632 if (! append_type (info, idbuf)) 1633 return FALSE; 1634 } 1635 1636 return TRUE; 1637 } 1638 1639 /* Output a typedef. */ 1640 1641 static bfd_boolean 1642 pr_typdef (void *p, const char *name) 1643 { 1644 struct pr_handle *info = (struct pr_handle *) p; 1645 char *s; 1646 1647 if (! substitute_type (info, name)) 1648 return FALSE; 1649 1650 s = pop_type (info); 1651 if (s == NULL) 1652 return FALSE; 1653 1654 indent (info); 1655 fprintf (info->f, "typedef %s;\n", s); 1656 1657 free (s); 1658 1659 return TRUE; 1660 } 1661 1662 /* Output a tag. The tag should already be in the string on the 1663 stack, so all we have to do here is print it out. */ 1664 1665 static bfd_boolean 1666 pr_tag (void *p, const char *name ATTRIBUTE_UNUSED) 1667 { 1668 struct pr_handle *info = (struct pr_handle *) p; 1669 char *t; 1670 1671 t = pop_type (info); 1672 if (t == NULL) 1673 return FALSE; 1674 1675 indent (info); 1676 fprintf (info->f, "%s;\n", t); 1677 1678 free (t); 1679 1680 return TRUE; 1681 } 1682 1683 /* Output an integer constant. */ 1684 1685 static bfd_boolean 1686 pr_int_constant (void *p, const char *name, bfd_vma val) 1687 { 1688 struct pr_handle *info = (struct pr_handle *) p; 1689 char ab[20]; 1690 1691 indent (info); 1692 print_vma (val, ab, FALSE, FALSE); 1693 fprintf (info->f, "const int %s = %s;\n", name, ab); 1694 return TRUE; 1695 } 1696 1697 /* Output a floating point constant. */ 1698 1699 static bfd_boolean 1700 pr_float_constant (void *p, const char *name, double val) 1701 { 1702 struct pr_handle *info = (struct pr_handle *) p; 1703 1704 indent (info); 1705 fprintf (info->f, "const double %s = %g;\n", name, val); 1706 return TRUE; 1707 } 1708 1709 /* Output a typed constant. */ 1710 1711 static bfd_boolean 1712 pr_typed_constant (void *p, const char *name, bfd_vma val) 1713 { 1714 struct pr_handle *info = (struct pr_handle *) p; 1715 char *t; 1716 char ab[20]; 1717 1718 t = pop_type (info); 1719 if (t == NULL) 1720 return FALSE; 1721 1722 indent (info); 1723 print_vma (val, ab, FALSE, FALSE); 1724 fprintf (info->f, "const %s %s = %s;\n", t, name, ab); 1725 1726 free (t); 1727 1728 return TRUE; 1729 } 1730 1731 /* Output a variable. */ 1732 1733 static bfd_boolean 1734 pr_variable (void *p, const char *name, enum debug_var_kind kind, 1735 bfd_vma val) 1736 { 1737 struct pr_handle *info = (struct pr_handle *) p; 1738 char *t; 1739 char ab[20]; 1740 1741 if (! substitute_type (info, name)) 1742 return FALSE; 1743 1744 t = pop_type (info); 1745 if (t == NULL) 1746 return FALSE; 1747 1748 indent (info); 1749 switch (kind) 1750 { 1751 case DEBUG_STATIC: 1752 case DEBUG_LOCAL_STATIC: 1753 fprintf (info->f, "static "); 1754 break; 1755 case DEBUG_REGISTER: 1756 fprintf (info->f, "register "); 1757 break; 1758 default: 1759 break; 1760 } 1761 print_vma (val, ab, TRUE, TRUE); 1762 fprintf (info->f, "%s /* %s */;\n", t, ab); 1763 1764 free (t); 1765 1766 return TRUE; 1767 } 1768 1769 /* Start outputting a function. */ 1770 1771 static bfd_boolean 1772 pr_start_function (void *p, const char *name, bfd_boolean global) 1773 { 1774 struct pr_handle *info = (struct pr_handle *) p; 1775 char *t; 1776 1777 if (! substitute_type (info, name)) 1778 return FALSE; 1779 1780 t = pop_type (info); 1781 if (t == NULL) 1782 return FALSE; 1783 1784 indent (info); 1785 if (! global) 1786 fprintf (info->f, "static "); 1787 fprintf (info->f, "%s (", t); 1788 1789 info->parameter = 1; 1790 1791 return TRUE; 1792 } 1793 1794 /* Output a function parameter. */ 1795 1796 static bfd_boolean 1797 pr_function_parameter (void *p, const char *name, 1798 enum debug_parm_kind kind, bfd_vma val) 1799 { 1800 struct pr_handle *info = (struct pr_handle *) p; 1801 char *t; 1802 char ab[20]; 1803 1804 if (kind == DEBUG_PARM_REFERENCE 1805 || kind == DEBUG_PARM_REF_REG) 1806 { 1807 if (! pr_reference_type (p)) 1808 return FALSE; 1809 } 1810 1811 if (! substitute_type (info, name)) 1812 return FALSE; 1813 1814 t = pop_type (info); 1815 if (t == NULL) 1816 return FALSE; 1817 1818 if (info->parameter != 1) 1819 fprintf (info->f, ", "); 1820 1821 if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG) 1822 fprintf (info->f, "register "); 1823 1824 print_vma (val, ab, TRUE, TRUE); 1825 fprintf (info->f, "%s /* %s */", t, ab); 1826 1827 free (t); 1828 1829 ++info->parameter; 1830 1831 return TRUE; 1832 } 1833 1834 /* Start writing out a block. */ 1835 1836 static bfd_boolean 1837 pr_start_block (void *p, bfd_vma addr) 1838 { 1839 struct pr_handle *info = (struct pr_handle *) p; 1840 char ab[20]; 1841 1842 if (info->parameter > 0) 1843 { 1844 fprintf (info->f, ")\n"); 1845 info->parameter = 0; 1846 } 1847 1848 indent (info); 1849 print_vma (addr, ab, TRUE, TRUE); 1850 fprintf (info->f, "{ /* %s */\n", ab); 1851 1852 info->indent += 2; 1853 1854 return TRUE; 1855 } 1856 1857 /* Write out line number information. */ 1858 1859 static bfd_boolean 1860 pr_lineno (void *p, const char *filename, unsigned long lineno, bfd_vma addr) 1861 { 1862 struct pr_handle *info = (struct pr_handle *) p; 1863 char ab[20]; 1864 1865 indent (info); 1866 print_vma (addr, ab, TRUE, TRUE); 1867 fprintf (info->f, "/* file %s line %lu addr %s */\n", filename, lineno, ab); 1868 1869 return TRUE; 1870 } 1871 1872 /* Finish writing out a block. */ 1873 1874 static bfd_boolean 1875 pr_end_block (void *p, bfd_vma addr) 1876 { 1877 struct pr_handle *info = (struct pr_handle *) p; 1878 char ab[20]; 1879 1880 info->indent -= 2; 1881 1882 indent (info); 1883 print_vma (addr, ab, TRUE, TRUE); 1884 fprintf (info->f, "} /* %s */\n", ab); 1885 1886 return TRUE; 1887 } 1888 1889 /* Finish writing out a function. */ 1890 1891 static bfd_boolean 1892 pr_end_function (void *p ATTRIBUTE_UNUSED) 1893 { 1894 return TRUE; 1895 } 1896 1897 /* Tags style generation functions start here. */ 1898 1899 /* Variables for address to line translation. */ 1900 static bfd_vma pc; 1901 static const char *filename; 1902 static const char *functionname; 1903 static unsigned int line; 1904 static bfd_boolean found; 1905 1906 /* Look for an address in a section. This is called via 1907 bfd_map_over_sections. */ 1908 1909 static void 1910 find_address_in_section (bfd *abfd, asection *section, void *data) 1911 { 1912 bfd_vma vma; 1913 bfd_size_type size; 1914 asymbol **syms = (asymbol **) data; 1915 1916 if (found) 1917 return; 1918 1919 if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0) 1920 return; 1921 1922 vma = bfd_get_section_vma (abfd, section); 1923 if (pc < vma) 1924 return; 1925 1926 size = bfd_get_section_size (section); 1927 if (pc >= vma + size) 1928 return; 1929 1930 found = bfd_find_nearest_line (abfd, section, syms, pc - vma, 1931 &filename, &functionname, &line); 1932 } 1933 1934 static void 1935 translate_addresses (bfd *abfd, char *addr_hex, FILE *f, asymbol **syms) 1936 { 1937 pc = bfd_scan_vma (addr_hex, NULL, 16); 1938 found = FALSE; 1939 bfd_map_over_sections (abfd, find_address_in_section, syms); 1940 1941 if (! found) 1942 fprintf (f, "??"); 1943 else 1944 fprintf (f, "%u", line); 1945 } 1946 1947 /* Start a new compilation unit. */ 1948 1949 static bfd_boolean 1950 tg_start_compilation_unit (void * p, const char *fname ATTRIBUTE_UNUSED) 1951 { 1952 struct pr_handle *info = (struct pr_handle *) p; 1953 1954 free (info->filename); 1955 /* Should it be relative? best way to do it here?. */ 1956 info->filename = strdup (fname); 1957 1958 return TRUE; 1959 } 1960 1961 /* Start a source file within a compilation unit. */ 1962 1963 static bfd_boolean 1964 tg_start_source (void *p, const char *fname) 1965 { 1966 struct pr_handle *info = (struct pr_handle *) p; 1967 1968 free (info->filename); 1969 /* Should it be relative? best way to do it here?. */ 1970 info->filename = strdup (fname); 1971 1972 return TRUE; 1973 } 1974 1975 /* Push an enum type onto the type stack. */ 1976 1977 static bfd_boolean 1978 tg_enum_type (void *p, const char *tag, const char **names, 1979 bfd_signed_vma *values) 1980 { 1981 struct pr_handle *info = (struct pr_handle *) p; 1982 unsigned int i; 1983 const char *name; 1984 char ab[20]; 1985 1986 if (! pr_enum_type (p, tag, names, values)) 1987 return FALSE; 1988 1989 name = tag ? tag : "unknown"; 1990 /* Generate an entry for the enum. */ 1991 if (tag) 1992 fprintf (info->f, "%s\t%s\t0;\"\tkind:e\ttype:%s\n", tag, 1993 info->filename, info->stack->type); 1994 1995 /* Generate entries for the values. */ 1996 if (names != NULL) 1997 { 1998 for (i = 0; names[i] != NULL; i++) 1999 { 2000 print_vma (values[i], ab, FALSE, FALSE); 2001 fprintf (info->f, "%s\t%s\t0;\"\tkind:g\tenum:%s\tvalue:%s\n", 2002 names[i], info->filename, name, ab); 2003 } 2004 } 2005 2006 return TRUE; 2007 } 2008 2009 /* Start accumulating a struct type. */ 2010 2011 static bfd_boolean 2012 tg_start_struct_type (void *p, const char *tag, unsigned int id, 2013 bfd_boolean structp, 2014 unsigned int size ATTRIBUTE_UNUSED) 2015 { 2016 struct pr_handle *info = (struct pr_handle *) p; 2017 const char *name; 2018 char idbuf[20]; 2019 2020 if (tag != NULL) 2021 name = tag; 2022 else 2023 { 2024 name = idbuf; 2025 sprintf (idbuf, "%%anon%u", id); 2026 } 2027 2028 if (! push_type (info, name)) 2029 return FALSE; 2030 2031 info->stack->flavor = structp ? "struct" : "union"; 2032 2033 fprintf (info->f, "%s\t%s\t0;\"\tkind:%c\n", name, info->filename, 2034 info->stack->flavor[0]); 2035 2036 info->stack->visibility = DEBUG_VISIBILITY_PUBLIC; 2037 2038 return indent_type (info); 2039 } 2040 2041 /* Output the visibility of a field in a struct. */ 2042 2043 static bfd_boolean 2044 tg_fix_visibility (struct pr_handle *info, enum debug_visibility visibility) 2045 { 2046 assert (info->stack != NULL); 2047 2048 if (info->stack->visibility == visibility) 2049 return TRUE; 2050 2051 assert (info->stack->visibility != DEBUG_VISIBILITY_IGNORE); 2052 2053 info->stack->visibility = visibility; 2054 2055 return TRUE; 2056 } 2057 2058 /* Add a field to a struct type. */ 2059 2060 static bfd_boolean 2061 tg_struct_field (void *p, const char *name, bfd_vma bitpos ATTRIBUTE_UNUSED, 2062 bfd_vma bitsize ATTRIBUTE_UNUSED, 2063 enum debug_visibility visibility) 2064 { 2065 struct pr_handle *info = (struct pr_handle *) p; 2066 char *t; 2067 2068 t = pop_type (info); 2069 if (t == NULL) 2070 return FALSE; 2071 2072 if (! tg_fix_visibility (info, visibility)) 2073 return FALSE; 2074 2075 /* It happens, a bug? */ 2076 if (! name[0]) 2077 return TRUE; 2078 2079 fprintf (info->f, "%s\t%s\t0;\"\tkind:m\ttype:%s\t%s:%s\taccess:%s\n", 2080 name, info->filename, t, info->stack->flavor, info->stack->type, 2081 visibility_name (visibility)); 2082 2083 return TRUE; 2084 } 2085 2086 /* Finish a struct type. */ 2087 2088 static bfd_boolean 2089 tg_end_struct_type (void *p ATTRIBUTE_UNUSED) 2090 { 2091 assert (((struct pr_handle *) p)->stack != NULL); 2092 2093 return TRUE; 2094 } 2095 2096 /* Start a class type. */ 2097 2098 static bfd_boolean 2099 tg_start_class_type (void *p, const char *tag, unsigned int id, 2100 bfd_boolean structp, unsigned int size, 2101 bfd_boolean vptr, bfd_boolean ownvptr) 2102 { 2103 struct pr_handle *info = (struct pr_handle *) p; 2104 char *tv = NULL; 2105 const char *name; 2106 2107 info->indent += 2; 2108 2109 if (vptr && ! ownvptr) 2110 { 2111 tv = pop_type (info); 2112 if (tv == NULL) 2113 return FALSE; 2114 } 2115 2116 if (tag != NULL) 2117 name = tag; 2118 else 2119 { 2120 char idbuf[20]; 2121 2122 sprintf (idbuf, "%%anon%u", id); 2123 name = idbuf; 2124 } 2125 2126 if (! push_type (info, name)) 2127 return FALSE; 2128 2129 info->stack->flavor = structp ? "class" : "union class"; 2130 info->stack->parents = NULL; 2131 info->stack->num_parents = 0; 2132 2133 if (size != 0 || vptr || ownvptr || tag != NULL) 2134 { 2135 if (vptr) 2136 { 2137 if (! append_type (info, " vtable ")) 2138 return FALSE; 2139 if (ownvptr) 2140 { 2141 if (! append_type (info, "self ")) 2142 return FALSE; 2143 } 2144 else 2145 { 2146 if (! append_type (info, tv) 2147 || ! append_type (info, " ")) 2148 return FALSE; 2149 } 2150 } 2151 } 2152 2153 info->stack->visibility = DEBUG_VISIBILITY_PRIVATE; 2154 2155 return TRUE; 2156 } 2157 2158 /* Add a static member to a class. */ 2159 2160 static bfd_boolean 2161 tg_class_static_member (void *p, const char *name, 2162 const char *physname ATTRIBUTE_UNUSED, 2163 enum debug_visibility visibility) 2164 { 2165 struct pr_handle *info = (struct pr_handle *) p; 2166 char *t; 2167 int len_var, len_class; 2168 char *full_name; 2169 2170 len_var = strlen (name); 2171 len_class = strlen (info->stack->next->type); 2172 full_name = (char *) xmalloc (len_var + len_class + 3); 2173 if (! full_name) 2174 return FALSE; 2175 sprintf (full_name, "%s::%s", info->stack->next->type, name); 2176 2177 if (! substitute_type (info, full_name)) 2178 return FALSE; 2179 2180 if (! prepend_type (info, "static ")) 2181 return FALSE; 2182 2183 t = pop_type (info); 2184 if (t == NULL) 2185 return FALSE; 2186 2187 if (! tg_fix_visibility (info, visibility)) 2188 return FALSE; 2189 2190 fprintf (info->f, "%s\t%s\t0;\"\tkind:x\ttype:%s\tclass:%s\taccess:%s\n", 2191 name, info->filename, t, info->stack->type, 2192 visibility_name (visibility)); 2193 free (t); 2194 free (full_name); 2195 2196 return TRUE; 2197 } 2198 2199 /* Add a base class to a class. */ 2200 2201 static bfd_boolean 2202 tg_class_baseclass (void *p, bfd_vma bitpos ATTRIBUTE_UNUSED, 2203 bfd_boolean is_virtual, enum debug_visibility visibility) 2204 { 2205 struct pr_handle *info = (struct pr_handle *) p; 2206 char *t; 2207 const char *prefix; 2208 2209 assert (info->stack != NULL && info->stack->next != NULL); 2210 2211 t = pop_type (info); 2212 if (t == NULL) 2213 return FALSE; 2214 2215 if (CONST_STRNEQ (t, "class ")) 2216 t += sizeof "class " - 1; 2217 2218 /* Push it back on to take advantage of the prepend_type and 2219 append_type routines. */ 2220 if (! push_type (info, t)) 2221 return FALSE; 2222 2223 if (is_virtual) 2224 { 2225 if (! prepend_type (info, "virtual ")) 2226 return FALSE; 2227 } 2228 2229 switch (visibility) 2230 { 2231 case DEBUG_VISIBILITY_PUBLIC: 2232 prefix = "public "; 2233 break; 2234 case DEBUG_VISIBILITY_PROTECTED: 2235 prefix = "protected "; 2236 break; 2237 case DEBUG_VISIBILITY_PRIVATE: 2238 prefix = "private "; 2239 break; 2240 default: 2241 prefix = "/* unknown visibility */ "; 2242 break; 2243 } 2244 2245 if (! prepend_type (info, prefix)) 2246 return FALSE; 2247 2248 t = pop_type (info); 2249 if (t == NULL) 2250 return FALSE; 2251 2252 if (info->stack->num_parents && ! append_parent (info, ", ")) 2253 return FALSE; 2254 2255 if (! append_parent (info, t)) 2256 return FALSE; 2257 info->stack->num_parents++; 2258 2259 free (t); 2260 2261 return TRUE; 2262 } 2263 2264 /* Add a variant to a method. */ 2265 2266 static bfd_boolean 2267 tg_class_method_variant (void *p, const char *physname ATTRIBUTE_UNUSED, 2268 enum debug_visibility visibility, 2269 bfd_boolean constp, bfd_boolean volatilep, 2270 bfd_vma voffset ATTRIBUTE_UNUSED, 2271 bfd_boolean context) 2272 { 2273 struct pr_handle *info = (struct pr_handle *) p; 2274 char *method_type; 2275 char *context_type; 2276 char *method_name; 2277 2278 assert (info->stack != NULL); 2279 assert (info->stack->next != NULL); 2280 2281 /* Put the const and volatile qualifiers on the type. */ 2282 if (volatilep) 2283 { 2284 if (! append_type (info, " volatile")) 2285 return FALSE; 2286 } 2287 if (constp) 2288 { 2289 if (! append_type (info, " const")) 2290 return FALSE; 2291 } 2292 2293 method_name = strdup (context ? info->stack->next->next->method 2294 : info->stack->next->method); 2295 2296 /* Stick the name of the method into its type. */ 2297 if (! substitute_type (info, method_name)) 2298 return FALSE; 2299 2300 /* Get the type. */ 2301 method_type = pop_type (info); 2302 if (method_type == NULL) 2303 return FALSE; 2304 2305 /* Pull off the context type if there is one. */ 2306 if (! context) 2307 context_type = NULL; 2308 else 2309 { 2310 context_type = pop_type (info); 2311 if (context_type == NULL) 2312 return FALSE; 2313 } 2314 2315 /* Now the top of the stack is the class. */ 2316 if (! tg_fix_visibility (info, visibility)) 2317 return FALSE; 2318 2319 fprintf (info->f, "%s\t%s\t0;\"\tkind:p\ttype:%s\tclass:%s\n", 2320 method_name, info->filename, method_type, info->stack->type); 2321 free (method_type); 2322 free (method_name); 2323 free (context_type); 2324 2325 return TRUE; 2326 } 2327 2328 /* Add a static variant to a method. */ 2329 2330 static bfd_boolean 2331 tg_class_static_method_variant (void *p, 2332 const char *physname ATTRIBUTE_UNUSED, 2333 enum debug_visibility visibility, 2334 bfd_boolean constp, bfd_boolean volatilep) 2335 { 2336 struct pr_handle *info = (struct pr_handle *) p; 2337 char *method_type; 2338 char *method_name; 2339 2340 assert (info->stack != NULL); 2341 assert (info->stack->next != NULL); 2342 assert (info->stack->next->method != NULL); 2343 2344 /* Put the const and volatile qualifiers on the type. */ 2345 if (volatilep) 2346 { 2347 if (! append_type (info, " volatile")) 2348 return FALSE; 2349 } 2350 if (constp) 2351 { 2352 if (! append_type (info, " const")) 2353 return FALSE; 2354 } 2355 2356 /* Mark it as static. */ 2357 if (! prepend_type (info, "static ")) 2358 return FALSE; 2359 2360 method_name = strdup (info->stack->next->method); 2361 /* Stick the name of the method into its type. */ 2362 if (! substitute_type (info, info->stack->next->method)) 2363 return FALSE; 2364 2365 /* Get the type. */ 2366 method_type = pop_type (info); 2367 if (method_type == NULL) 2368 return FALSE; 2369 2370 /* Now the top of the stack is the class. */ 2371 if (! tg_fix_visibility (info, visibility)) 2372 return FALSE; 2373 2374 fprintf (info->f, "%s\t%s\t0;\"\tkind:p\ttype:%s\tclass:%s\taccess:%s\n", 2375 method_name, info->filename, method_type, info->stack->type, 2376 visibility_name (visibility)); 2377 free (method_type); 2378 free (method_name); 2379 2380 return TRUE; 2381 } 2382 2383 /* Finish up a class. */ 2384 2385 static bfd_boolean 2386 tg_end_class_type (void *p) 2387 { 2388 struct pr_handle *info = (struct pr_handle *) p; 2389 2390 fprintf (info->f, "%s\t%s\t0;\"\tkind:c\ttype:%s", info->stack->type, 2391 info->filename, info->stack->flavor); 2392 if (info->stack->num_parents) 2393 { 2394 fprintf (info->f, "\tinherits:%s", info->stack->parents); 2395 free (info->stack->parents); 2396 } 2397 fputc ('\n', info->f); 2398 2399 return tg_end_struct_type (p); 2400 } 2401 2402 /* Push a type on the stack using a tag name. */ 2403 2404 static bfd_boolean 2405 tg_tag_type (void *p, const char *name, unsigned int id, 2406 enum debug_type_kind kind) 2407 { 2408 struct pr_handle *info = (struct pr_handle *) p; 2409 const char *t, *tag; 2410 char idbuf[20]; 2411 2412 switch (kind) 2413 { 2414 case DEBUG_KIND_STRUCT: 2415 t = "struct "; 2416 break; 2417 case DEBUG_KIND_UNION: 2418 t = "union "; 2419 break; 2420 case DEBUG_KIND_ENUM: 2421 t = "enum "; 2422 break; 2423 case DEBUG_KIND_CLASS: 2424 t = "class "; 2425 break; 2426 case DEBUG_KIND_UNION_CLASS: 2427 t = "union class "; 2428 break; 2429 default: 2430 abort (); 2431 return FALSE; 2432 } 2433 2434 if (! push_type (info, t)) 2435 return FALSE; 2436 if (name != NULL) 2437 tag = name; 2438 else 2439 { 2440 sprintf (idbuf, "%%anon%u", id); 2441 tag = idbuf; 2442 } 2443 2444 if (! append_type (info, tag)) 2445 return FALSE; 2446 2447 return TRUE; 2448 } 2449 2450 /* Output a typedef. */ 2451 2452 static bfd_boolean 2453 tg_typdef (void *p, const char *name) 2454 { 2455 struct pr_handle *info = (struct pr_handle *) p; 2456 char *s; 2457 2458 s = pop_type (info); 2459 if (s == NULL) 2460 return FALSE; 2461 2462 fprintf (info->f, "%s\t%s\t0;\"\tkind:t\ttype:%s\n", name, 2463 info->filename, s); 2464 2465 free (s); 2466 2467 return TRUE; 2468 } 2469 2470 /* Output a tag. The tag should already be in the string on the 2471 stack, so all we have to do here is print it out. */ 2472 2473 static bfd_boolean 2474 tg_tag (void *p ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED) 2475 { 2476 struct pr_handle *info = (struct pr_handle *) p; 2477 char *t; 2478 2479 t = pop_type (info); 2480 if (t == NULL) 2481 return FALSE; 2482 free (t); 2483 2484 return TRUE; 2485 } 2486 2487 /* Output an integer constant. */ 2488 2489 static bfd_boolean 2490 tg_int_constant (void *p, const char *name, bfd_vma val) 2491 { 2492 struct pr_handle *info = (struct pr_handle *) p; 2493 char ab[20]; 2494 2495 indent (info); 2496 print_vma (val, ab, FALSE, FALSE); 2497 fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const int\tvalue:%s\n", 2498 name, info->filename, ab); 2499 return TRUE; 2500 } 2501 2502 /* Output a floating point constant. */ 2503 2504 static bfd_boolean 2505 tg_float_constant (void *p, const char *name, double val) 2506 { 2507 struct pr_handle *info = (struct pr_handle *) p; 2508 2509 indent (info); 2510 fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const double\tvalue:%g\n", 2511 name, info->filename, val); 2512 return TRUE; 2513 } 2514 2515 /* Output a typed constant. */ 2516 2517 static bfd_boolean 2518 tg_typed_constant (void *p, const char *name, bfd_vma val) 2519 { 2520 struct pr_handle *info = (struct pr_handle *) p; 2521 char *t; 2522 char ab[20]; 2523 2524 t = pop_type (info); 2525 if (t == NULL) 2526 return FALSE; 2527 2528 indent (info); 2529 print_vma (val, ab, FALSE, FALSE); 2530 fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const %s\tvalue:%s\n", 2531 name, info->filename, t, ab); 2532 2533 free (t); 2534 2535 return TRUE; 2536 } 2537 2538 /* Output a variable. */ 2539 2540 static bfd_boolean 2541 tg_variable (void *p, const char *name, enum debug_var_kind kind, 2542 bfd_vma val ATTRIBUTE_UNUSED) 2543 { 2544 struct pr_handle *info = (struct pr_handle *) p; 2545 char *t, *dname, *from_class; 2546 2547 t = pop_type (info); 2548 if (t == NULL) 2549 return FALSE; 2550 2551 dname = NULL; 2552 if (info->demangler) 2553 dname = info->demangler (info->abfd, name, DMGL_ANSI | DMGL_PARAMS); 2554 2555 from_class = NULL; 2556 if (dname != NULL) 2557 { 2558 char *sep; 2559 sep = strstr (dname, "::"); 2560 if (sep) 2561 { 2562 *sep = 0; 2563 name = sep + 2; 2564 from_class = dname; 2565 } 2566 else 2567 /* Obscure types as vts and type_info nodes. */ 2568 name = dname; 2569 } 2570 2571 fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:%s", name, info->filename, t); 2572 2573 switch (kind) 2574 { 2575 case DEBUG_STATIC: 2576 case DEBUG_LOCAL_STATIC: 2577 fprintf (info->f, "\tfile:"); 2578 break; 2579 case DEBUG_REGISTER: 2580 fprintf (info->f, "\tregister:"); 2581 break; 2582 default: 2583 break; 2584 } 2585 2586 if (from_class) 2587 fprintf (info->f, "\tclass:%s", from_class); 2588 2589 if (dname) 2590 free (dname); 2591 2592 fprintf (info->f, "\n"); 2593 2594 free (t); 2595 2596 return TRUE; 2597 } 2598 2599 /* Start outputting a function. */ 2600 2601 static bfd_boolean 2602 tg_start_function (void *p, const char *name, bfd_boolean global) 2603 { 2604 struct pr_handle *info = (struct pr_handle *) p; 2605 char *dname; 2606 2607 if (! global) 2608 info->stack->flavor = "static"; 2609 else 2610 info->stack->flavor = NULL; 2611 2612 dname = NULL; 2613 if (info->demangler) 2614 dname = info->demangler (info->abfd, name, DMGL_ANSI | DMGL_PARAMS); 2615 2616 if (! substitute_type (info, dname ? dname : name)) 2617 return FALSE; 2618 2619 info->stack->method = NULL; 2620 if (dname != NULL) 2621 { 2622 char *sep; 2623 sep = strstr (dname, "::"); 2624 if (sep) 2625 { 2626 info->stack->method = dname; 2627 *sep = 0; 2628 name = sep + 2; 2629 } 2630 else 2631 { 2632 info->stack->method = ""; 2633 name = dname; 2634 } 2635 sep = strchr (name, '('); 2636 if (sep) 2637 *sep = 0; 2638 /* Obscure functions as type_info function. */ 2639 } 2640 2641 info->stack->parents = strdup (name); 2642 2643 if (! info->stack->method && ! append_type (info, "(")) 2644 return FALSE; 2645 2646 info->parameter = 1; 2647 2648 return TRUE; 2649 } 2650 2651 /* Output a function parameter. */ 2652 2653 static bfd_boolean 2654 tg_function_parameter (void *p, const char *name, enum debug_parm_kind kind, 2655 bfd_vma val ATTRIBUTE_UNUSED) 2656 { 2657 struct pr_handle *info = (struct pr_handle *) p; 2658 char *t; 2659 2660 if (kind == DEBUG_PARM_REFERENCE 2661 || kind == DEBUG_PARM_REF_REG) 2662 { 2663 if (! pr_reference_type (p)) 2664 return FALSE; 2665 } 2666 2667 if (! substitute_type (info, name)) 2668 return FALSE; 2669 2670 t = pop_type (info); 2671 if (t == NULL) 2672 return FALSE; 2673 2674 if (! info->stack->method) 2675 { 2676 if (info->parameter != 1 && ! append_type (info, ", ")) 2677 return FALSE; 2678 2679 if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG) 2680 if (! append_type (info, "register ")) 2681 return FALSE; 2682 2683 if (! append_type (info, t)) 2684 return FALSE; 2685 } 2686 2687 free (t); 2688 2689 ++info->parameter; 2690 2691 return TRUE; 2692 } 2693 2694 /* Start writing out a block. */ 2695 2696 static bfd_boolean 2697 tg_start_block (void *p, bfd_vma addr) 2698 { 2699 struct pr_handle *info = (struct pr_handle *) p; 2700 char ab[20], kind, *partof; 2701 char *t; 2702 bfd_boolean local; 2703 2704 if (info->parameter > 0) 2705 { 2706 info->parameter = 0; 2707 2708 /* Delayed name. */ 2709 fprintf (info->f, "%s\t%s\t", info->stack->parents, info->filename); 2710 free (info->stack->parents); 2711 2712 print_vma (addr, ab, TRUE, TRUE); 2713 translate_addresses (info->abfd, ab, info->f, info->syms); 2714 local = info->stack->flavor != NULL; 2715 if (info->stack->method && *info->stack->method) 2716 { 2717 kind = 'm'; 2718 partof = (char *) info->stack->method; 2719 } 2720 else 2721 { 2722 kind = 'f'; 2723 partof = NULL; 2724 if (! info->stack->method && ! append_type (info, ")")) 2725 return FALSE; 2726 } 2727 t = pop_type (info); 2728 if (t == NULL) 2729 return FALSE; 2730 fprintf (info->f, ";\"\tkind:%c\ttype:%s", kind, t); 2731 if (local) 2732 fputs ("\tfile:", info->f); 2733 if (partof) 2734 { 2735 fprintf (info->f, "\tclass:%s", partof); 2736 free (partof); 2737 } 2738 fputc ('\n', info->f); 2739 } 2740 2741 return TRUE; 2742 } 2743 2744 /* Write out line number information. */ 2745 2746 static bfd_boolean 2747 tg_lineno (void *p ATTRIBUTE_UNUSED, const char *fname ATTRIBUTE_UNUSED, 2748 unsigned long lineno ATTRIBUTE_UNUSED, 2749 bfd_vma addr ATTRIBUTE_UNUSED) 2750 { 2751 return TRUE; 2752 } 2753 2754 /* Finish writing out a block. */ 2755 2756 static bfd_boolean 2757 tg_end_block (void *p ATTRIBUTE_UNUSED, bfd_vma addr ATTRIBUTE_UNUSED) 2758 { 2759 return TRUE; 2760 } 2761 2762 /* Convert the visibility value into a human readable name. */ 2763 2764 static const char * 2765 visibility_name (enum debug_visibility visibility) 2766 { 2767 const char *s; 2768 2769 switch (visibility) 2770 { 2771 case DEBUG_VISIBILITY_PUBLIC: 2772 s = "public"; 2773 break; 2774 case DEBUG_VISIBILITY_PRIVATE: 2775 s = "private"; 2776 break; 2777 case DEBUG_VISIBILITY_PROTECTED: 2778 s = "protected"; 2779 break; 2780 case DEBUG_VISIBILITY_IGNORE: 2781 s = "/* ignore */"; 2782 break; 2783 default: 2784 abort (); 2785 return FALSE; 2786 } 2787 return s; 2788 } 2789