![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sdbout.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to sdbout.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Output sdb-format symbol table information from GNU compiler. 1.1.1.6 ! root 2: Copyright (C) 1988, 1992, 1993 Free Software Foundation, Inc. 1.1 root 3: 4: This file is part of GNU CC. 5: 6: GNU CC is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU CC is distributed in the hope that it will be useful, 12: but WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14: GNU General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU CC; see the file COPYING. If not, write to 18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ 19: 20: /* [email protected] says: 21: I modified the struct.c example and have a nm of a .o resulting from the 22: AT&T C compiler. From the example below I would conclude the following: 23: 24: 1. All .defs from structures are emitted as scanned. The example below 25: clearly shows the symbol table entries for BoxRec2 are after the first 26: function. 27: 28: 2. All functions and their locals (including statics) are emitted as scanned. 29: 30: 3. All nested unnamed union and structure .defs must be emitted before 31: the structure in which they are nested. The AT&T assembler is a 32: one pass beast as far as symbolics are concerned. 33: 34: 4. All structure .defs are emitted before the typedefs that refer to them. 35: 36: 5. All top level static and external variable definitions are moved to the 1.1.1.3 root 37: end of file with all top level statics occurring first before externs. 1.1 root 38: 39: 6. All undefined references are at the end of the file. 40: */ 41: 42: #include "config.h" 43: 44: #ifdef SDB_DEBUGGING_INFO 45: 46: #include "tree.h" 47: #include "rtl.h" 48: #include <stdio.h> 49: #include "regs.h" 50: #include "flags.h" 51: #include "insn-config.h" 52: #include "reload.h" 53: 54: /* Mips systems use the SDB functions to dump out symbols, but 55: do not supply usable syms.h include files. */ 1.1.1.4 root 56: #if defined(USG) && !defined(MIPS) && !defined (hpux) 1.1 root 57: #include <syms.h> 58: /* Use T_INT if we don't have T_VOID. */ 59: #ifndef T_VOID 60: #define T_VOID T_INT 61: #endif 62: #else /* not USG, or MIPS */ 63: #include "gsyms.h" 64: #endif /* not USG, or MIPS */ 65: 66: /* #include <storclass.h> used to be this instead of syms.h. */ 67: 68: /* 1 if PARM is passed to this function in memory. */ 69: 70: #define PARM_PASSED_IN_MEMORY(PARM) \ 71: (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM) 72: 73: /* A C expression for the integer offset value of an automatic variable 74: (C_AUTO) having address X (an RTX). */ 75: #ifndef DEBUGGER_AUTO_OFFSET 76: #define DEBUGGER_AUTO_OFFSET(X) \ 77: (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0) 78: #endif 79: 80: /* A C expression for the integer offset value of an argument (C_ARG) 81: having address X (an RTX). The nominal offset is OFFSET. */ 82: #ifndef DEBUGGER_ARG_OFFSET 83: #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET) 84: #endif 85: 86: /* Line number of beginning of current function, minus one. 87: Negative means not in a function or not using sdb. */ 88: 89: int sdb_begin_function_line = -1; 90: 91: /* Counter to generate unique "names" for nameless struct members. */ 92: 93: static int unnamed_struct_number = 0; 94: 95: extern FILE *asm_out_file; 96: 97: extern tree current_function_decl; 98: 99: void sdbout_init (); 100: void sdbout_symbol (); 101: void sdbout_types(); 102: 103: static void sdbout_typedefs (); 104: static void sdbout_syms (); 105: static void sdbout_one_type (); 106: static void sdbout_queue_anonymous_type (); 1.1.1.2 root 107: static void sdbout_dequeue_anonymous_types (); 1.1 root 108: static int plain_type_1 (); 109: 110: /* Define the default sizes for various types. */ 111: 112: #ifndef CHAR_TYPE_SIZE 113: #define CHAR_TYPE_SIZE BITS_PER_UNIT 114: #endif 115: 116: #ifndef SHORT_TYPE_SIZE 117: #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2)) 118: #endif 119: 120: #ifndef INT_TYPE_SIZE 121: #define INT_TYPE_SIZE BITS_PER_WORD 122: #endif 123: 124: #ifndef LONG_TYPE_SIZE 125: #define LONG_TYPE_SIZE BITS_PER_WORD 126: #endif 127: 128: #ifndef LONG_LONG_TYPE_SIZE 129: #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2) 130: #endif 131: 132: #ifndef FLOAT_TYPE_SIZE 133: #define FLOAT_TYPE_SIZE BITS_PER_WORD 134: #endif 135: 136: #ifndef DOUBLE_TYPE_SIZE 137: #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) 138: #endif 139: 140: #ifndef LONG_DOUBLE_TYPE_SIZE 141: #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) 142: #endif 143: 144: /* Random macros describing parts of SDB data. */ 145: 146: /* Put something here if lines get too long */ 147: #define CONTIN 148: 149: /* Default value of delimiter is ";". */ 150: #ifndef SDB_DELIM 151: #define SDB_DELIM ";" 152: #endif 153: 154: /* Maximum number of dimensions the assembler will allow. */ 155: #ifndef SDB_MAX_DIM 156: #define SDB_MAX_DIM 4 157: #endif 158: 159: #ifndef PUT_SDB_SCL 160: #define PUT_SDB_SCL(a) fprintf(asm_out_file, "\t.scl\t%d%s", (a), SDB_DELIM) 161: #endif 162: 163: #ifndef PUT_SDB_INT_VAL 164: #define PUT_SDB_INT_VAL(a) fprintf (asm_out_file, "\t.val\t%d%s", (a), SDB_DELIM) 165: #endif 166: 167: #ifndef PUT_SDB_VAL 168: #define PUT_SDB_VAL(a) \ 169: ( fputs ("\t.val\t", asm_out_file), \ 170: output_addr_const (asm_out_file, (a)), \ 171: fprintf (asm_out_file, SDB_DELIM)) 172: #endif 173: 174: #ifndef PUT_SDB_DEF 175: #define PUT_SDB_DEF(a) \ 176: do { fprintf (asm_out_file, "\t.def\t"); \ 177: ASM_OUTPUT_LABELREF (asm_out_file, a); \ 178: fprintf (asm_out_file, SDB_DELIM); } while (0) 179: #endif 180: 181: #ifndef PUT_SDB_PLAIN_DEF 182: #define PUT_SDB_PLAIN_DEF(a) fprintf(asm_out_file,"\t.def\t.%s%s",a, SDB_DELIM) 183: #endif 184: 185: #ifndef PUT_SDB_ENDEF 186: #define PUT_SDB_ENDEF fputs("\t.endef\n", asm_out_file) 187: #endif 188: 189: #ifndef PUT_SDB_TYPE 190: #define PUT_SDB_TYPE(a) fprintf(asm_out_file, "\t.type\t0%o%s", a, SDB_DELIM) 191: #endif 192: 193: #ifndef PUT_SDB_SIZE 194: #define PUT_SDB_SIZE(a) fprintf(asm_out_file, "\t.size\t%d%s", a, SDB_DELIM) 195: #endif 196: 197: #ifndef PUT_SDB_START_DIM 198: #define PUT_SDB_START_DIM fprintf(asm_out_file, "\t.dim\t") 199: #endif 200: 201: #ifndef PUT_SDB_NEXT_DIM 202: #define PUT_SDB_NEXT_DIM(a) fprintf(asm_out_file, "%d,", a) 203: #endif 204: 205: #ifndef PUT_SDB_LAST_DIM 206: #define PUT_SDB_LAST_DIM(a) fprintf(asm_out_file, "%d%s", a, SDB_DELIM) 207: #endif 208: 209: #ifndef PUT_SDB_TAG 210: #define PUT_SDB_TAG(a) \ 211: do { fprintf (asm_out_file, "\t.tag\t"); \ 212: ASM_OUTPUT_LABELREF (asm_out_file, a); \ 213: fprintf (asm_out_file, SDB_DELIM); } while (0) 214: #endif 215: 216: #ifndef PUT_SDB_BLOCK_START 217: #define PUT_SDB_BLOCK_START(LINE) \ 218: fprintf (asm_out_file, \ 219: "\t.def\t.bb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n", \ 220: SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM) 221: #endif 222: 223: #ifndef PUT_SDB_BLOCK_END 224: #define PUT_SDB_BLOCK_END(LINE) \ 225: fprintf (asm_out_file, \ 226: "\t.def\t.eb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n", \ 227: SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM) 228: #endif 229: 230: #ifndef PUT_SDB_FUNCTION_START 231: #define PUT_SDB_FUNCTION_START(LINE) \ 232: fprintf (asm_out_file, \ 233: "\t.def\t.bf%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \ 234: SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM) 235: #endif 236: 237: #ifndef PUT_SDB_FUNCTION_END 238: #define PUT_SDB_FUNCTION_END(LINE) \ 239: fprintf (asm_out_file, \ 240: "\t.def\t.ef%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \ 241: SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM) 242: #endif 243: 244: #ifndef PUT_SDB_EPILOGUE_END 245: #define PUT_SDB_EPILOGUE_END(NAME) \ 246: do { fprintf (asm_out_file, "\t.def\t"); \ 247: ASM_OUTPUT_LABELREF (asm_out_file, NAME); \ 248: fprintf (asm_out_file, \ 249: "%s\t.val\t.%s\t.scl\t-1%s\t.endef\n", \ 250: SDB_DELIM, SDB_DELIM, SDB_DELIM); } while (0) 251: #endif 252: 253: #ifndef SDB_GENERATE_FAKE 254: #define SDB_GENERATE_FAKE(BUFFER, NUMBER) \ 255: sprintf ((BUFFER), ".%dfake", (NUMBER)); 256: #endif 257: 258: /* Return the sdb tag identifier string for TYPE 259: if TYPE has already been defined; otherwise return a null pointer. */ 260: 1.1.1.6 ! root 261: #define KNOWN_TYPE_TAG(type) TYPE_SYMTAB_POINTER (type) 1.1 root 262: 263: /* Set the sdb tag identifier string for TYPE to NAME. */ 264: 265: #define SET_KNOWN_TYPE_TAG(TYPE, NAME) \ 1.1.1.6 ! root 266: TYPE_SYMTAB_POINTER (TYPE) = (NAME) 1.1 root 267: 268: /* Return the name (a string) of the struct, union or enum tag 269: described by the TREE_LIST node LINK. This is 0 for an anonymous one. */ 270: 271: #define TAG_NAME(link) \ 272: (((link) && TREE_PURPOSE ((link)) \ 273: && IDENTIFIER_POINTER (TREE_PURPOSE ((link)))) \ 274: ? IDENTIFIER_POINTER (TREE_PURPOSE ((link))) : (char *) 0) 275: 276: /* Ensure we don't output a negative line number. */ 277: #define MAKE_LINE_SAFE(line) \ 278: if (line <= sdb_begin_function_line) line = sdb_begin_function_line + 1 279: 280: /* Set up for SDB output at the start of compilation. */ 281: 282: void 283: sdbout_init (asm_file, input_file_name, syms) 284: FILE *asm_file; 285: char *input_file_name; 286: tree syms; 287: { 1.1.1.6 ! root 288: #ifdef RMS_QUICK_HACK_1 ! 289: tree t; ! 290: for (t = syms; t; t = TREE_CHAIN (t)) ! 291: if (DECL_NAME (t) && IDENTIFIER_POINTER (DECL_NAME (t)) != 0 ! 292: && !strcmp (IDENTIFIER_POINTER (DECL_NAME (t)), "__vtbl_ptr_type")) ! 293: sdbout_symbol (t, 0); ! 294: #endif ! 295: 1.1 root 296: #if 0 /* Nothing need be output for the predefined types. */ 297: /* Get all permanent types that have typedef names, 298: and output them all, except for those already output. */ 299: 300: sdbout_typedefs (syms); 301: #endif 302: } 303: 304: #if 0 305: 306: /* return the tag identifier for type 307: */ 308: 309: char * 310: tag_of_ru_type (type,link) 311: tree type,link; 312: { 313: if (TYPE_SYMTAB_ADDRESS (type)) 1.1.1.6 ! root 314: return TYPE_SYMTAB_ADDRESS (type); 1.1 root 315: if (link && TREE_PURPOSE (link) 316: && IDENTIFIER_POINTER (TREE_PURPOSE (link))) 1.1.1.6 ! root 317: TYPE_SYMTAB_ADDRESS (type) = IDENTIFIER_POINTER (TREE_PURPOSE (link)); 1.1 root 318: else 319: return (char *) TYPE_SYMTAB_ADDRESS (type); 320: } 321: #endif 322: 323: /* Return a unique string to name an anonymous type. */ 324: 325: static char * 326: gen_fake_label () 327: { 328: char label[10]; 329: char *labelstr; 330: SDB_GENERATE_FAKE (label, unnamed_struct_number); 331: unnamed_struct_number++; 332: labelstr = (char *) permalloc (strlen (label) + 1); 333: strcpy (labelstr, label); 334: return labelstr; 335: } 336: 337: /* Return the number which describes TYPE for SDB. 338: For pointers, etc., this function is recursive. 339: Each record, union or enumeral type must already have had a 340: tag number output. */ 341: 342: /* The number is given by d6d5d4d3d2d1bbbb 343: where bbbb is 4 bit basic type, and di indicate one of notype,ptr,fn,array. 344: Thus, char *foo () has bbbb=T_CHAR 345: d1=D_FCN 346: d2=D_PTR 347: N_BTMASK= 017 1111 basic type field. 348: N_TSHIFT= 2 derived type shift 349: N_BTSHFT= 4 Basic type shift */ 350: 351: /* Produce the number that describes a pointer, function or array type. 352: PREV is the number describing the target, value or element type. 353: DT_type describes how to transform that type. */ 1.1.1.5 root 354: #define PUSH_DERIVED_LEVEL(DT_type,PREV) \ 355: ((((PREV) & ~(int)N_BTMASK) << (int)N_TSHIFT) \ 356: | ((int)DT_type << (int)N_BTSHFT) \ 357: | ((PREV) & (int)N_BTMASK)) 1.1 root 358: 359: /* Number of elements used in sdb_dims. */ 360: static int sdb_n_dims = 0; 361: 362: /* Table of array dimensions of current type. */ 363: static int sdb_dims[SDB_MAX_DIM]; 364: 365: /* Size of outermost array currently being processed. */ 366: static int sdb_type_size = -1; 367: 368: static int 369: plain_type (type) 370: tree type; 371: { 372: int val = plain_type_1 (type); 373: 374: /* If we have already saved up some array dimensions, print them now. */ 375: if (sdb_n_dims > 0) 376: { 377: int i; 378: PUT_SDB_START_DIM; 379: for (i = sdb_n_dims - 1; i > 0; i--) 380: PUT_SDB_NEXT_DIM (sdb_dims[i]); 381: PUT_SDB_LAST_DIM (sdb_dims[0]); 382: sdb_n_dims = 0; 383: 384: sdb_type_size = int_size_in_bytes (type); 385: /* Don't kill sdb if type is not laid out or has variable size. */ 386: if (sdb_type_size < 0) 387: sdb_type_size = 0; 388: } 389: /* If we have computed the size of an array containing this type, 390: print it now. */ 391: if (sdb_type_size >= 0) 392: { 393: PUT_SDB_SIZE (sdb_type_size); 394: sdb_type_size = -1; 395: } 396: return val; 397: } 398: 1.1.1.4 root 399: static int 400: template_name_p (name) 401: tree name; 402: { 403: register char *ptr = IDENTIFIER_POINTER (name); 404: while (*ptr && *ptr != '<') 405: ptr++; 406: 407: return *ptr != '\0'; 408: } 409: 1.1 root 410: static void 411: sdbout_record_type_name (type) 412: tree type; 413: { 414: char *name = 0; 415: int no_name; 416: 417: if (KNOWN_TYPE_TAG (type)) 418: return; 419: 420: if (TYPE_NAME (type) != 0) 421: { 422: tree t = 0; 423: /* Find the IDENTIFIER_NODE for the type name. */ 424: if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 425: { 426: t = TYPE_NAME (type); 427: } 1.1.1.5 root 428: #if 1 /* As a temporary hack, use typedef names for C++ only. */ 1.1 root 429: else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 430: && TYPE_LANG_SPECIFIC (type)) 431: { 432: t = DECL_NAME (TYPE_NAME (type)); 1.1.1.4 root 433: /* The DECL_NAME for templates includes "<>", which breaks 434: most assemblers. Use its assembler name instead, which 435: has been mangled into being safe. */ 436: if (t && template_name_p (t)) 437: t = DECL_ASSEMBLER_NAME (TYPE_NAME (type)); 1.1 root 438: } 439: #endif 440: 441: /* Now get the name as a string, or invent one. */ 1.1.1.4 root 442: if (t != NULL_TREE) 1.1 root 443: name = IDENTIFIER_POINTER (t); 444: } 445: 446: no_name = (name == 0 || *name == 0); 447: if (no_name) 448: name = gen_fake_label (); 449: 450: SET_KNOWN_TYPE_TAG (type, name); 451: #ifdef SDB_ALLOW_FORWARD_REFERENCES 452: if (no_name) 453: sdbout_queue_anonymous_type (type); 454: #endif 455: } 456: 457: static int 458: plain_type_1 (type) 459: tree type; 460: { 461: if (type == 0) 462: type = void_type_node; 463: if (type == error_mark_node) 464: type = integer_type_node; 465: type = TYPE_MAIN_VARIANT (type); 466: 467: switch (TREE_CODE (type)) 468: { 469: case VOID_TYPE: 470: return T_VOID; 471: case INTEGER_TYPE: 472: { 473: int size = int_size_in_bytes (type) * BITS_PER_UNIT; 1.1.1.5 root 474: 475: /* Carefully distinguish all the standard types of C, 476: without messing up if the language is not C. 477: Note that we check only for the names that contain spaces; 478: other names might occur by coincidence in other languages. */ 479: if (TYPE_NAME (type) != 0 480: && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 481: && DECL_NAME (TYPE_NAME (type)) != 0 482: && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE) 483: { 484: char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))); 485: 486: if (!strcmp (name, "unsigned char")) 487: return T_UCHAR; 488: if (!strcmp (name, "signed char")) 489: return T_CHAR; 490: if (!strcmp (name, "unsigned int")) 491: return T_UINT; 492: if (!strcmp (name, "short int")) 493: return T_SHORT; 494: if (!strcmp (name, "short unsigned int")) 495: return T_USHORT; 496: if (!strcmp (name, "long int")) 497: return T_LONG; 498: if (!strcmp (name, "long unsigned int")) 499: return T_ULONG; 500: } 501: 1.1 root 502: if (size == CHAR_TYPE_SIZE) 503: return (TREE_UNSIGNED (type) ? T_UCHAR : T_CHAR); 504: if (size == SHORT_TYPE_SIZE) 505: return (TREE_UNSIGNED (type) ? T_USHORT : T_SHORT); 506: if (size == INT_TYPE_SIZE) 507: return (TREE_UNSIGNED (type) ? T_UINT : T_INT); 1.1.1.4 root 508: if (size == LONG_TYPE_SIZE) 509: return (TREE_UNSIGNED (type) ? T_ULONG : T_LONG); 1.1 root 510: return 0; 511: } 512: 513: case REAL_TYPE: 514: { 515: int size = int_size_in_bytes (type) * BITS_PER_UNIT; 516: if (size == FLOAT_TYPE_SIZE) 517: return T_FLOAT; 518: if (size == DOUBLE_TYPE_SIZE) 519: return T_DOUBLE; 520: return 0; 521: } 522: 523: case ARRAY_TYPE: 524: { 525: int m; 526: m = plain_type_1 (TREE_TYPE (type)); 527: if (sdb_n_dims < SDB_MAX_DIM) 528: sdb_dims[sdb_n_dims++] 529: = (TYPE_DOMAIN (type) 530: ? TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) + 1 531: : 0); 532: return PUSH_DERIVED_LEVEL (DT_ARY, m); 533: } 534: 535: case RECORD_TYPE: 536: case UNION_TYPE: 1.1.1.5 root 537: case QUAL_UNION_TYPE: 1.1 root 538: case ENUMERAL_TYPE: 539: { 540: char *tag; 541: #ifdef SDB_ALLOW_FORWARD_REFERENCES 542: sdbout_record_type_name (type); 543: #endif 544: #ifndef SDB_ALLOW_UNKNOWN_REFERENCES 545: if ((TREE_ASM_WRITTEN (type) && KNOWN_TYPE_TAG (type) != 0) 546: #ifdef SDB_ALLOW_FORWARD_REFERENCES 547: || TYPE_MODE (type) != VOIDmode 548: #endif 549: ) 550: #endif 551: { 552: /* Output the referenced structure tag name 553: only if the .def has already been finished. 554: At least on 386, the Unix assembler 555: cannot handle forward references to tags. */ 556: /* But the 88100, it requires them, sigh... */ 557: /* And the MIPS requires unknown refs as well... */ 558: tag = KNOWN_TYPE_TAG (type); 559: PUT_SDB_TAG (tag); 560: /* These 3 lines used to follow the close brace. 561: However, a size of 0 without a tag implies a tag of 0, 562: so if we don't know a tag, we can't mention the size. */ 563: sdb_type_size = int_size_in_bytes (type); 564: if (sdb_type_size < 0) 565: sdb_type_size = 0; 566: } 567: return ((TREE_CODE (type) == RECORD_TYPE) ? T_STRUCT 568: : (TREE_CODE (type) == UNION_TYPE) ? T_UNION 1.1.1.5 root 569: : (TREE_CODE (type) == QUAL_UNION_TYPE) ? T_UNION 1.1 root 570: : T_ENUM); 571: } 572: case POINTER_TYPE: 573: case REFERENCE_TYPE: 574: { 575: int m = plain_type_1 (TREE_TYPE (type)); 576: return PUSH_DERIVED_LEVEL (DT_PTR, m); 577: } 578: case FUNCTION_TYPE: 579: case METHOD_TYPE: 580: { 581: int m = plain_type_1 (TREE_TYPE (type)); 582: return PUSH_DERIVED_LEVEL (DT_FCN, m); 583: } 584: default: 585: return 0; 586: } 587: } 588: 589: /* Output the symbols defined in block number DO_BLOCK. 590: Set NEXT_BLOCK_NUMBER to 0 before calling. 591: 592: This function works by walking the tree structure of blocks, 593: counting blocks until it finds the desired block. */ 594: 595: static int do_block = 0; 596: 597: static int next_block_number; 598: 599: static void 600: sdbout_block (block) 601: register tree block; 602: { 603: while (block) 604: { 605: /* Ignore blocks never expanded or otherwise marked as real. */ 606: if (TREE_USED (block)) 607: { 608: /* When we reach the specified block, output its symbols. */ 609: if (next_block_number == do_block) 610: { 611: sdbout_syms (BLOCK_VARS (block)); 612: } 613: 614: /* If we are past the specified block, stop the scan. */ 615: if (next_block_number > do_block) 616: return; 617: 618: next_block_number++; 619: 620: /* Scan the blocks within this block. */ 621: sdbout_block (BLOCK_SUBBLOCKS (block)); 622: } 623: 624: block = BLOCK_CHAIN (block); 625: } 626: } 627: 628: /* Call sdbout_symbol on each decl in the chain SYMS. */ 629: 630: static void 631: sdbout_syms (syms) 632: tree syms; 633: { 634: while (syms) 635: { 636: if (TREE_CODE (syms) != LABEL_DECL) 637: sdbout_symbol (syms, 1); 638: syms = TREE_CHAIN (syms); 639: } 640: } 641: 642: /* Output SDB information for a symbol described by DECL. 643: LOCAL is nonzero if the symbol is not file-scope. */ 644: 645: void 646: sdbout_symbol (decl, local) 647: tree decl; 648: int local; 649: { 650: int letter = 0; 651: tree type = TREE_TYPE (decl); 652: tree context = NULL_TREE; 653: rtx value; 654: int regno = -1; 655: char *name; 656: 657: sdbout_one_type (type); 658: 1.1.1.3 root 659: #if 0 /* This loses when functions are marked to be ignored, 660: which happens in the C++ front end. */ 661: if (DECL_IGNORED_P (decl)) 662: return; 663: #endif 664: 1.1 root 665: switch (TREE_CODE (decl)) 666: { 667: case CONST_DECL: 668: /* Enum values are defined by defining the enum type. */ 669: return; 670: 671: case FUNCTION_DECL: 672: /* Don't mention a nested function under its parent. */ 673: context = decl_function_context (decl); 674: if (context == current_function_decl) 675: return; 1.1.1.4 root 676: if (DECL_EXTERNAL (decl)) 1.1 root 677: return; 678: if (GET_CODE (DECL_RTL (decl)) != MEM 679: || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF) 680: return; 681: PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); 682: PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0)); 683: PUT_SDB_SCL (TREE_PUBLIC (decl) ? C_EXT : C_STAT); 684: break; 685: 686: case TYPE_DECL: 687: /* Done with tagged types. */ 688: if (DECL_NAME (decl) == 0) 689: return; 1.1.1.3 root 690: if (DECL_IGNORED_P (decl)) 691: return; 1.1 root 692: 693: /* Output typedef name. */ 1.1.1.4 root 694: if (template_name_p (DECL_NAME (decl))) 695: PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); 696: else 697: PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (decl))); 1.1 root 698: PUT_SDB_SCL (C_TPDEF); 699: break; 700: 701: case PARM_DECL: 702: /* Parm decls go in their own separate chains 703: and are output by sdbout_reg_parms and sdbout_parms. */ 704: abort (); 705: 706: case VAR_DECL: 707: /* Don't mention a variable that is external. 708: Let the file that defines it describe it. */ 1.1.1.4 root 709: if (DECL_EXTERNAL (decl)) 1.1 root 710: return; 711: 1.1.1.3 root 712: /* Ignore __FUNCTION__, etc. */ 713: if (DECL_IGNORED_P (decl)) 714: return; 715: 1.1 root 716: /* If there was an error in the declaration, don't dump core 717: if there is no RTL associated with the variable doesn't 718: exist. */ 719: if (DECL_RTL (decl) == 0) 720: return; 721: 1.1.1.4 root 722: DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX); 723: #ifdef LEAF_REG_REMAP 724: if (leaf_function) 725: leaf_renumber_regs_insn (DECL_RTL (decl)); 726: #endif 727: value = DECL_RTL (decl); 1.1 root 728: 729: /* Don't mention a variable at all 730: if it was completely optimized into nothingness. 731: 732: If DECL was from an inline function, then its rtl 733: is not identically the rtl that was used in this 734: particular compilation. */ 735: if (GET_CODE (value) == REG) 736: { 737: regno = REGNO (DECL_RTL (decl)); 738: if (regno >= FIRST_PSEUDO_REGISTER) 739: return; 740: } 1.1.1.4 root 741: else if (GET_CODE (value) == SUBREG) 1.1 root 742: { 743: int offset = 0; 744: while (GET_CODE (value) == SUBREG) 745: { 746: offset += SUBREG_WORD (value); 747: value = SUBREG_REG (value); 748: } 749: if (GET_CODE (value) == REG) 750: { 751: regno = REGNO (value); 752: if (regno >= FIRST_PSEUDO_REGISTER) 1.1.1.4 root 753: return; 754: regno += offset; 1.1 root 755: } 1.1.1.4 root 756: alter_subreg (DECL_RTL (decl)); 757: value = DECL_RTL (decl); 1.1 root 758: } 1.1.1.6 ! root 759: /* Don't output anything if an auto variable ! 760: gets RTL that is static. ! 761: GAS version 2.2 can't handle such output. */ ! 762: else if (GET_CODE (value) == MEM && CONSTANT_P (XEXP (value, 0)) ! 763: && ! TREE_STATIC (decl)) ! 764: return; 1.1 root 765: 766: /* Emit any structure, union, or enum type that has not been output. 767: This occurs for tag-less structs (et al) used to declare variables 768: within functions. */ 769: if (TREE_CODE (type) == ENUMERAL_TYPE 770: || TREE_CODE (type) == RECORD_TYPE 1.1.1.5 root 771: || TREE_CODE (type) == UNION_TYPE 772: || TREE_CODE (type) == QUAL_UNION_TYPE) 1.1 root 773: { 774: if (TYPE_SIZE (type) != 0 /* not a forward reference */ 775: && KNOWN_TYPE_TAG (type) == 0) /* not yet declared */ 776: sdbout_one_type (type); 777: } 778: 779: /* Defer SDB information for top-level initialized variables! */ 780: if (! local 781: && GET_CODE (value) == MEM 782: && DECL_INITIAL (decl)) 783: return; 784: 1.1.1.4 root 785: /* C++ in 2.3 makes nameless symbols. That will be fixed later. 786: For now, avoid crashing. */ 787: if (DECL_NAME (decl) == NULL_TREE) 788: return; 789: 1.1 root 790: /* Record the name for, starting a symtab entry. */ 791: name = IDENTIFIER_POINTER (DECL_NAME (decl)); 792: 793: if (GET_CODE (value) == MEM 794: && GET_CODE (XEXP (value, 0)) == SYMBOL_REF) 795: { 796: PUT_SDB_DEF (name); 797: if (TREE_PUBLIC (decl)) 798: { 799: PUT_SDB_VAL (XEXP (value, 0)); 800: PUT_SDB_SCL (C_EXT); 801: } 802: else 803: { 804: PUT_SDB_VAL (XEXP (value, 0)); 805: PUT_SDB_SCL (C_STAT); 806: } 807: } 808: else if (regno >= 0) 809: { 810: PUT_SDB_DEF (name); 811: PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (regno)); 812: PUT_SDB_SCL (C_REG); 813: } 814: else if (GET_CODE (value) == MEM 815: && (GET_CODE (XEXP (value, 0)) == MEM 816: || (GET_CODE (XEXP (value, 0)) == REG 1.1.1.6 ! root 817: && REGNO (XEXP (value, 0)) != HARD_FRAME_POINTER_REGNUM 1.1 root 818: && REGNO (XEXP (value, 0)) != STACK_POINTER_REGNUM))) 819: /* If the value is indirect by memory or by a register 820: that isn't the frame pointer 821: then it means the object is variable-sized and address through 822: that register or stack slot. COFF has no way to represent this 823: so all we can do is output the variable as a pointer. */ 824: { 825: PUT_SDB_DEF (name); 826: if (GET_CODE (XEXP (value, 0)) == REG) 827: { 828: PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (XEXP (value, 0)))); 829: PUT_SDB_SCL (C_REG); 830: } 831: else 832: { 833: /* DECL_RTL looks like (MEM (MEM (PLUS (REG...) 834: (CONST_INT...)))). 835: We want the value of that CONST_INT. */ 836: /* Encore compiler hates a newline in a macro arg, it seems. */ 837: PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET 838: (XEXP (XEXP (value, 0), 0))); 839: PUT_SDB_SCL (C_AUTO); 840: } 841: 842: type = build_pointer_type (TREE_TYPE (decl)); 843: } 844: else if (GET_CODE (value) == MEM 845: && GET_CODE (XEXP (value, 0)) == PLUS 846: && GET_CODE (XEXP (XEXP (value, 0), 0)) == REG 847: && GET_CODE (XEXP (XEXP (value, 0), 1)) == CONST_INT) 848: { 849: /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))). 850: We want the value of that CONST_INT. */ 851: PUT_SDB_DEF (name); 852: PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET (XEXP (value, 0))); 853: PUT_SDB_SCL (C_AUTO); 854: } 1.1.1.2 root 855: else if (GET_CODE (value) == MEM && GET_CODE (XEXP (value, 0)) == CONST) 856: { 857: /* Handle an obscure case which can arise when optimizing and 858: when there are few available registers. (This is *always* 859: the case for i386/i486 targets). The DECL_RTL looks like 860: (MEM (CONST ...)) even though this variable is a local `auto' 861: or a local `register' variable. In effect, what has happened 862: is that the reload pass has seen that all assignments and 863: references for one such a local variable can be replaced by 864: equivalent assignments and references to some static storage 865: variable, thereby avoiding the need for a register. In such 866: cases we're forced to lie to debuggers and tell them that 867: this variable was itself `static'. */ 868: PUT_SDB_DEF (name); 869: PUT_SDB_VAL (XEXP (XEXP (value, 0), 0)); 870: PUT_SDB_SCL (C_STAT); 871: } 1.1 root 872: else 873: { 874: /* It is something we don't know how to represent for SDB. */ 875: return; 876: } 877: break; 878: } 879: PUT_SDB_TYPE (plain_type (type)); 880: PUT_SDB_ENDEF; 881: } 882: 883: /* Output SDB information for a top-level initialized variable 884: that has been delayed. */ 885: 886: void 887: sdbout_toplevel_data (decl) 888: tree decl; 889: { 890: tree type = TREE_TYPE (decl); 891: 1.1.1.3 root 892: if (DECL_IGNORED_P (decl)) 893: return; 894: 1.1 root 895: if (! (TREE_CODE (decl) == VAR_DECL 896: && GET_CODE (DECL_RTL (decl)) == MEM 897: && DECL_INITIAL (decl))) 898: abort (); 899: 900: PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); 901: PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0)); 902: if (TREE_PUBLIC (decl)) 903: { 904: PUT_SDB_SCL (C_EXT); 905: } 906: else 907: { 908: PUT_SDB_SCL (C_STAT); 909: } 910: PUT_SDB_TYPE (plain_type (type)); 911: PUT_SDB_ENDEF; 912: } 913: 914: #ifdef SDB_ALLOW_FORWARD_REFERENCES 915: 916: /* Machinery to record and output anonymous types. */ 917: 918: static tree anonymous_types; 919: 920: static void 921: sdbout_queue_anonymous_type (type) 922: tree type; 923: { 924: anonymous_types = saveable_tree_cons (NULL_TREE, type, anonymous_types); 925: } 926: 927: static void 928: sdbout_dequeue_anonymous_types () 929: { 930: register tree types, link; 931: 932: while (anonymous_types) 933: { 934: types = nreverse (anonymous_types); 935: anonymous_types = NULL_TREE; 936: 937: for (link = types; link; link = TREE_CHAIN (link)) 938: { 939: register tree type = TREE_VALUE (link); 940: 1.1.1.2 root 941: if (type && ! TREE_ASM_WRITTEN (type)) 1.1 root 942: sdbout_one_type (type); 943: } 944: } 945: } 946: 947: #endif 948: 949: /* Given a chain of ..._TYPE nodes, all of which have names, 950: output definitions of those names, as typedefs. */ 951: 952: void 953: sdbout_types (types) 954: register tree types; 955: { 956: register tree link; 957: 958: for (link = types; link; link = TREE_CHAIN (link)) 959: sdbout_one_type (link); 960: 961: #ifdef SDB_ALLOW_FORWARD_REFERENCES 962: sdbout_dequeue_anonymous_types (); 963: #endif 964: } 965: 966: static void 967: sdbout_type (type) 968: tree type; 969: { 970: register tree tem; 971: if (type == error_mark_node) 972: type = integer_type_node; 973: PUT_SDB_TYPE (plain_type (type)); 974: } 975: 976: /* Output types of the fields of type TYPE, if they are structs. 977: 978: Formerly did not chase through pointer types, since that could be circular. 979: They must come before TYPE, since forward refs are not allowed. 980: Now [email protected] says to try them. */ 981: 982: static void 983: sdbout_field_types (type) 984: tree type; 985: { 986: tree tail; 987: for (tail = TYPE_FIELDS (type); tail; tail = TREE_CHAIN (tail)) 988: if (TREE_CODE (TREE_TYPE (tail)) == POINTER_TYPE) 989: sdbout_one_type (TREE_TYPE (TREE_TYPE (tail))); 990: else 991: sdbout_one_type (TREE_TYPE (tail)); 992: } 993: 994: /* Use this to put out the top level defined record and union types 995: for later reference. If this is a struct with a name, then put that 996: name out. Other unnamed structs will have .xxfake labels generated so 997: that they may be referred to later. 998: The label will be stored in the KNOWN_TYPE_TAG slot of a type. 999: It may NOT be called recursively. */ 1000: 1001: static void 1002: sdbout_one_type (type) 1003: tree type; 1004: { 1005: text_section (); 1006: 1007: switch (TREE_CODE (type)) 1008: { 1009: case RECORD_TYPE: 1010: case UNION_TYPE: 1.1.1.5 root 1011: case QUAL_UNION_TYPE: 1.1 root 1012: case ENUMERAL_TYPE: 1013: type = TYPE_MAIN_VARIANT (type); 1014: /* Don't output a type twice. */ 1015: if (TREE_ASM_WRITTEN (type)) 1016: /* James said test TREE_ASM_BEING_WRITTEN here. */ 1017: return; 1018: 1019: /* Output nothing if type is not yet defined. */ 1020: if (TYPE_SIZE (type) == 0) 1021: return; 1022: 1023: TREE_ASM_WRITTEN (type) = 1; 1024: #if 1 1025: /* This is reputed to cause trouble with the following case, 1.1.1.4 root 1026: but perhaps checking TYPE_SIZE above will fix it. */ 1.1 root 1027: 1028: /* Here is a test case: 1029: 1030: struct foo { 1031: struct badstr *bbb; 1032: } forwardref; 1033: 1034: typedef struct intermediate { 1035: int aaaa; 1036: } intermediate_ref; 1037: 1038: typedef struct badstr { 1039: int ccccc; 1040: } badtype; */ 1041: 1042: #if 0 1043: TREE_ASM_BEING_WRITTEN (type) = 1; 1044: #endif 1045: /* This change, which ought to make better output, 1046: used to make the COFF assembler unhappy. 1047: Changes involving KNOWN_TYPE_TAG may fix the problem. */ 1048: /* Before really doing anything, output types we want to refer to. */ 1049: /* Note that in version 1 the following two lines 1050: are not used if forward references are in use. */ 1051: if (TREE_CODE (type) != ENUMERAL_TYPE) 1052: sdbout_field_types (type); 1053: #if 0 1054: TREE_ASM_WRITTEN (type) = 1; 1055: #endif 1056: #endif 1057: 1058: /* Output a structure type. */ 1059: { 1060: int size = int_size_in_bytes (type); 1061: int member_scl; 1062: tree tem; 1063: int i, n_baseclasses = 0; 1064: 1065: /* Record the type tag, but not in its permanent place just yet. */ 1066: sdbout_record_type_name (type); 1067: 1068: PUT_SDB_DEF (KNOWN_TYPE_TAG (type)); 1069: 1070: switch (TREE_CODE (type)) 1071: { 1072: case UNION_TYPE: 1.1.1.5 root 1073: case QUAL_UNION_TYPE: 1.1 root 1074: PUT_SDB_SCL (C_UNTAG); 1075: PUT_SDB_TYPE (T_UNION); 1076: member_scl = C_MOU; 1077: break; 1078: 1079: case RECORD_TYPE: 1080: PUT_SDB_SCL (C_STRTAG); 1081: PUT_SDB_TYPE (T_STRUCT); 1082: member_scl = C_MOS; 1083: break; 1084: 1085: case ENUMERAL_TYPE: 1086: PUT_SDB_SCL (C_ENTAG); 1087: PUT_SDB_TYPE (T_ENUM); 1088: member_scl = C_MOE; 1089: break; 1090: } 1091: 1092: PUT_SDB_SIZE (size); 1093: PUT_SDB_ENDEF; 1094: 1095: /* Print out the base class information with fields 1096: named after the types they hold. */ 1097: if (TYPE_BINFO (type) 1098: && TYPE_BINFO_BASETYPES (type)) 1099: n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type)); 1100: for (i = 0; i < n_baseclasses; i++) 1101: { 1102: tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i); 1103: tree child_type = BINFO_TYPE (child); 1104: tree child_type_name; 1105: if (TYPE_NAME (child_type) == 0) 1106: continue; 1107: if (TREE_CODE (TYPE_NAME (child_type)) == IDENTIFIER_NODE) 1108: child_type_name = TYPE_NAME (child_type); 1109: else if (TREE_CODE (TYPE_NAME (child_type)) == TYPE_DECL) 1110: child_type_name = DECL_NAME (TYPE_NAME (child_type)); 1111: else 1112: continue; 1113: 1114: CONTIN; 1115: PUT_SDB_DEF (IDENTIFIER_POINTER (child_type_name)); 1116: PUT_SDB_INT_VAL (TREE_INT_CST_LOW (BINFO_OFFSET (child))); 1117: PUT_SDB_SCL (member_scl); 1118: sdbout_type (BINFO_TYPE (child)); 1119: PUT_SDB_ENDEF; 1120: } 1121: 1122: /* output the individual fields */ 1123: 1124: if (TREE_CODE (type) == ENUMERAL_TYPE) 1125: for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem)) 1126: { 1127: PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem))); 1128: PUT_SDB_INT_VAL (TREE_INT_CST_LOW (TREE_VALUE (tem))); 1129: PUT_SDB_SCL (C_MOE); 1130: PUT_SDB_TYPE (T_MOE); 1131: PUT_SDB_ENDEF; 1132: } 1133: 1134: else /* record or union type */ 1135: for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem)) 1136: /* Output the name, type, position (in bits), size (in bits) 1137: of each field. */ 1138: 1139: /* Omit here the nameless fields that are used to skip bits. 1140: Also omit fields with variable size or position. 1141: Also omit non FIELD_DECL nodes that GNU C++ may put here. */ 1142: if (TREE_CODE (tem) == FIELD_DECL 1143: && DECL_NAME (tem) != 0 1144: && TREE_CODE (DECL_SIZE (tem)) == INTEGER_CST 1145: && TREE_CODE (DECL_FIELD_BITPOS (tem)) == INTEGER_CST) 1146: { 1147: CONTIN; 1148: PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (tem))); 1149: if (DECL_BIT_FIELD_TYPE (tem)) 1150: { 1151: PUT_SDB_INT_VAL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem))); 1152: PUT_SDB_SCL (C_FIELD); 1153: sdbout_type (DECL_BIT_FIELD_TYPE (tem)); 1154: PUT_SDB_SIZE (TREE_INT_CST_LOW (DECL_SIZE (tem))); 1155: } 1156: else 1157: { 1158: PUT_SDB_INT_VAL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)) 1159: / BITS_PER_UNIT); 1160: PUT_SDB_SCL (member_scl); 1161: sdbout_type (TREE_TYPE (tem)); 1162: } 1163: PUT_SDB_ENDEF; 1164: } 1165: /* output end of a structure,union, or enumeral definition */ 1166: 1167: PUT_SDB_PLAIN_DEF ("eos"); 1168: PUT_SDB_INT_VAL (size); 1169: PUT_SDB_SCL (C_EOS); 1170: PUT_SDB_TAG (KNOWN_TYPE_TAG (type)); 1171: PUT_SDB_SIZE (size); 1172: PUT_SDB_ENDEF; 1173: break; 1174: } 1175: } 1176: } 1177: 1178: /* The following two functions output definitions of function parameters. 1179: Each parameter gets a definition locating it in the parameter list. 1180: Each parameter that is a register variable gets a second definition 1181: locating it in the register. 1182: 1183: Printing or argument lists in gdb uses the definitions that 1184: locate in the parameter list. But reference to the variable in 1185: expressions uses preferentially the definition as a register. */ 1186: 1187: /* Output definitions, referring to storage in the parmlist, 1188: of all the parms in PARMS, which is a chain of PARM_DECL nodes. */ 1189: 1190: static void 1191: sdbout_parms (parms) 1192: tree parms; 1193: { 1194: for (; parms; parms = TREE_CHAIN (parms)) 1195: if (DECL_NAME (parms)) 1196: { 1197: int current_sym_value = 0; 1198: char *name = IDENTIFIER_POINTER (DECL_NAME (parms)); 1199: 1200: if (name == 0 || *name == 0) 1201: name = gen_fake_label (); 1202: 1203: /* Perform any necessary register eliminations on the parameter's rtl, 1204: so that the debugging output will be accurate. */ 1205: DECL_INCOMING_RTL (parms) = 1.1.1.4 root 1206: eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX); 1207: DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX); 1.1 root 1208: 1209: if (PARM_PASSED_IN_MEMORY (parms)) 1210: { 1211: rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0); 1212: tree type; 1213: 1214: /* ??? Here we assume that the parm address is indexed 1215: off the frame pointer or arg pointer. 1216: If that is not true, we produce meaningless results, 1217: but do not crash. */ 1218: if (GET_CODE (addr) == PLUS 1219: && GET_CODE (XEXP (addr, 1)) == CONST_INT) 1220: current_sym_value = INTVAL (XEXP (addr, 1)); 1221: else 1222: current_sym_value = 0; 1223: 1224: if (GET_CODE (DECL_RTL (parms)) == REG 1225: && REGNO (DECL_RTL (parms)) >= 0 1226: && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER) 1227: type = DECL_ARG_TYPE (parms); 1228: else 1229: { 1230: int original_sym_value = current_sym_value; 1231: 1232: /* This is the case where the parm is passed as an int or 1233: double and it is converted to a char, short or float 1234: and stored back in the parmlist. In this case, describe 1235: the parm with the variable's declared type, and adjust 1236: the address if the least significant bytes (which we are 1237: using) are not the first ones. */ 1238: #if BYTES_BIG_ENDIAN 1239: if (TREE_TYPE (parms) != DECL_ARG_TYPE (parms)) 1240: current_sym_value += 1241: (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms))) 1242: - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))); 1243: #endif 1244: if (GET_CODE (DECL_RTL (parms)) == MEM 1245: && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS 1246: && (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) 1247: == CONST_INT) 1248: && (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) 1249: == current_sym_value)) 1250: type = TREE_TYPE (parms); 1251: else 1252: { 1253: current_sym_value = original_sym_value; 1254: type = DECL_ARG_TYPE (parms); 1255: } 1256: } 1257: 1258: PUT_SDB_DEF (name); 1259: PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value, addr)); 1260: PUT_SDB_SCL (C_ARG); 1261: PUT_SDB_TYPE (plain_type (type)); 1262: PUT_SDB_ENDEF; 1263: } 1264: else if (GET_CODE (DECL_RTL (parms)) == REG) 1265: { 1266: rtx best_rtl; 1267: /* Parm passed in registers and lives in registers or nowhere. */ 1268: 1269: /* If parm lives in a register, use that register; 1270: pretend the parm was passed there. It would be more consistent 1271: to describe the register where the parm was passed, 1272: but in practice that register usually holds something else. */ 1273: if (REGNO (DECL_RTL (parms)) >= 0 1274: && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER) 1275: best_rtl = DECL_RTL (parms); 1276: /* If the parm lives nowhere, 1277: use the register where it was passed. */ 1278: else 1279: best_rtl = DECL_INCOMING_RTL (parms); 1280: 1281: PUT_SDB_DEF (name); 1282: PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (best_rtl))); 1283: PUT_SDB_SCL (C_REGPARM); 1284: PUT_SDB_TYPE (plain_type (TREE_TYPE (parms), 0)); 1285: PUT_SDB_ENDEF; 1286: } 1287: else if (GET_CODE (DECL_RTL (parms)) == MEM 1288: && XEXP (DECL_RTL (parms), 0) != const0_rtx) 1289: { 1290: /* Parm was passed in registers but lives on the stack. */ 1291: 1292: /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))), 1293: in which case we want the value of that CONST_INT, 1294: or (MEM (REG ...)) or (MEM (MEM ...)), 1295: in which case we use a value of zero. */ 1296: if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG 1297: || GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM) 1298: current_sym_value = 0; 1299: else 1300: current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)); 1301: 1302: /* Again, this assumes the offset is based on the arg pointer. */ 1303: PUT_SDB_DEF (name); 1304: PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value, 1305: XEXP (DECL_RTL (parms), 0))); 1306: PUT_SDB_SCL (C_ARG); 1307: PUT_SDB_TYPE (plain_type (TREE_TYPE (parms), 0)); 1308: PUT_SDB_ENDEF; 1309: } 1310: } 1311: } 1312: 1313: /* Output definitions for the places where parms live during the function, 1314: when different from where they were passed, when the parms were passed 1315: in memory. 1316: 1317: It is not useful to do this for parms passed in registers 1318: that live during the function in different registers, because it is 1319: impossible to look in the passed register for the passed value, 1320: so we use the within-the-function register to begin with. 1321: 1322: PARMS is a chain of PARM_DECL nodes. */ 1323: 1324: static void 1325: sdbout_reg_parms (parms) 1326: tree parms; 1327: { 1328: for (; parms; parms = TREE_CHAIN (parms)) 1329: if (DECL_NAME (parms)) 1330: { 1331: char *name = IDENTIFIER_POINTER (DECL_NAME (parms)); 1332: 1333: /* Report parms that live in registers during the function 1334: but were passed in memory. */ 1335: if (GET_CODE (DECL_RTL (parms)) == REG 1336: && REGNO (DECL_RTL (parms)) >= 0 1337: && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER 1338: && PARM_PASSED_IN_MEMORY (parms)) 1339: { 1340: if (name == 0 || *name == 0) 1341: name = gen_fake_label (); 1342: PUT_SDB_DEF (name); 1343: PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms)))); 1344: PUT_SDB_SCL (C_REG); 1345: PUT_SDB_TYPE (plain_type (TREE_TYPE (parms), 0)); 1346: PUT_SDB_ENDEF; 1347: } 1348: /* Report parms that live in memory but not where they were passed. */ 1349: else if (GET_CODE (DECL_RTL (parms)) == MEM 1350: && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS 1351: && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT 1352: && PARM_PASSED_IN_MEMORY (parms) 1353: && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms))) 1354: { 1355: #if 0 /* ??? It is not clear yet what should replace this. */ 1356: int offset = DECL_OFFSET (parms) / BITS_PER_UNIT; 1357: /* A parm declared char is really passed as an int, 1358: so it occupies the least significant bytes. 1359: On a big-endian machine those are not the low-numbered ones. */ 1360: #if BYTES_BIG_ENDIAN 1361: if (offset != -1 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms)) 1362: offset += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms))) 1363: - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))); 1364: #endif 1365: if (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) != offset) {...} 1366: #endif 1367: { 1368: if (name == 0 || *name == 0) 1369: name = gen_fake_label (); 1370: PUT_SDB_DEF (name); 1371: PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET 1372: (XEXP (DECL_RTL (parms), 0))); 1373: PUT_SDB_SCL (C_AUTO); 1374: PUT_SDB_TYPE (plain_type (TREE_TYPE (parms))); 1375: PUT_SDB_ENDEF; 1376: } 1377: } 1378: } 1379: } 1380: 1381: /* Describe the beginning of an internal block within a function. 1382: Also output descriptions of variables defined in this block. 1383: 1384: N is the number of the block, by order of beginning, counting from 1, 1385: and not counting the outermost (function top-level) block. 1386: The blocks match the BLOCKs in DECL_INITIAL (current_function_decl), 1387: if the count starts at 0 for the outermost one. */ 1388: 1389: void 1390: sdbout_begin_block (file, line, n) 1391: FILE *file; 1392: int line; 1393: int n; 1394: { 1395: tree decl = current_function_decl; 1396: MAKE_LINE_SAFE (line); 1397: PUT_SDB_BLOCK_START (line - sdb_begin_function_line); 1398: if (n == 1) 1399: { 1400: /* Include the outermost BLOCK's variables in block 1. */ 1401: next_block_number = 0; 1402: do_block = 0; 1403: sdbout_block (DECL_INITIAL (decl)); 1404: } 1405: /* If -g1, suppress all the internal symbols of functions 1406: except for arguments. */ 1407: if (debug_info_level != DINFO_LEVEL_TERSE) 1408: { 1409: next_block_number = 0; 1410: do_block = n; 1411: sdbout_block (DECL_INITIAL (decl)); 1412: } 1413: 1414: #ifdef SDB_ALLOW_FORWARD_REFERENCES 1415: sdbout_dequeue_anonymous_types (); 1416: #endif 1417: } 1418: 1419: /* Describe the end line-number of an internal block within a function. */ 1420: 1421: void 1422: sdbout_end_block (file, line) 1423: FILE *file; 1424: int line; 1425: { 1426: MAKE_LINE_SAFE (line); 1427: PUT_SDB_BLOCK_END (line - sdb_begin_function_line); 1428: } 1429: 1430: /* Output sdb info for the current function name. 1431: Called from assemble_start_function. */ 1432: 1433: void 1434: sdbout_mark_begin_function () 1435: { 1436: sdbout_symbol (current_function_decl, 0); 1437: } 1438: 1439: /* Called at beginning of function body (after prologue). 1440: Record the function's starting line number, so we can output 1441: relative line numbers for the other lines. 1442: Describe beginning of outermost block. 1443: Also describe the parameter list. */ 1444: 1445: void 1446: sdbout_begin_function (line) 1447: int line; 1448: { 1449: sdb_begin_function_line = line - 1; 1450: PUT_SDB_FUNCTION_START (line); 1451: sdbout_parms (DECL_ARGUMENTS (current_function_decl)); 1452: sdbout_reg_parms (DECL_ARGUMENTS (current_function_decl)); 1453: } 1454: 1455: /* Called at end of function (before epilogue). 1456: Describe end of outermost block. */ 1457: 1458: void 1459: sdbout_end_function (line) 1460: int line; 1461: { 1462: #ifdef SDB_ALLOW_FORWARD_REFERENCES 1463: sdbout_dequeue_anonymous_types (); 1464: #endif 1465: 1466: MAKE_LINE_SAFE (line); 1467: PUT_SDB_FUNCTION_END (line - sdb_begin_function_line); 1468: 1469: /* Indicate we are between functions, for line-number output. */ 1470: sdb_begin_function_line = -1; 1471: } 1472: 1473: /* Output sdb info for the absolute end of a function. 1474: Called after the epilogue is output. */ 1475: 1476: void 1477: sdbout_end_epilogue () 1478: { 1479: char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)); 1480: PUT_SDB_EPILOGUE_END (name); 1481: } 1482: 1483: /* Output sdb info for the given label. Called only if LABEL_NAME (insn) 1484: is present. */ 1485: 1486: void 1487: sdbout_label (insn) 1488: register rtx insn; 1489: { 1490: PUT_SDB_DEF (LABEL_NAME (insn)); 1491: PUT_SDB_VAL (insn); 1492: PUT_SDB_SCL (C_LABEL); 1493: PUT_SDB_TYPE (T_NULL); 1494: PUT_SDB_ENDEF; 1495: } 1496: 1497: #endif /* SDB_DEBUGGING_INFO */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.