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