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