![[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 [Apple XNU] / GNUtools / cc|
Return to sdbout.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 ! root 1: /* Output sdb-format symbol table information from GNU compiler. ! 2: Copyright (C) 1988, 1992, 1993 Free Software Foundation, Inc. ! 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 ! 37: end of file with all top level statics occurring first before externs. ! 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. */ ! 56: #if defined(USG) && !defined(MIPS) && !defined (hpux) ! 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 (); ! 107: static void sdbout_dequeue_anonymous_types (); ! 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: ! 261: #define KNOWN_TYPE_TAG(type) TYPE_SYMTAB_POINTER (type) ! 262: ! 263: /* Set the sdb tag identifier string for TYPE to NAME. */ ! 264: ! 265: #define SET_KNOWN_TYPE_TAG(TYPE, NAME) \ ! 266: TYPE_SYMTAB_POINTER (TYPE) = (NAME) ! 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: { ! 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: ! 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)) ! 314: return TYPE_SYMTAB_ADDRESS (type); ! 315: if (link && TREE_PURPOSE (link) ! 316: && IDENTIFIER_POINTER (TREE_PURPOSE (link))) ! 317: TYPE_SYMTAB_ADDRESS (type) = IDENTIFIER_POINTER (TREE_PURPOSE (link)); ! 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. */ ! 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)) ! 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: ! 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: ! 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: } ! 428: #if 1 /* As a temporary hack, use typedef names for C++ only. */ ! 429: else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL ! 430: && TYPE_LANG_SPECIFIC (type)) ! 431: { ! 432: t = DECL_NAME (TYPE_NAME (type)); ! 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)); ! 438: } ! 439: #endif ! 440: ! 441: /* Now get the name as a string, or invent one. */ ! 442: if (t != NULL_TREE) ! 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; ! 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: ! 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); ! 508: if (size == LONG_TYPE_SIZE) ! 509: return (TREE_UNSIGNED (type) ? T_ULONG : T_LONG); ! 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: ! 537: case QUAL_UNION_TYPE: ! 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 ! 569: : (TREE_CODE (type) == QUAL_UNION_TYPE) ? T_UNION ! 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: ! 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: ! 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; ! 676: if (DECL_EXTERNAL (decl)) ! 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; ! 690: if (DECL_IGNORED_P (decl)) ! 691: return; ! 692: ! 693: /* Output typedef name. */ ! 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))); ! 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. */ ! 709: if (DECL_EXTERNAL (decl)) ! 710: return; ! 711: ! 712: /* Ignore __FUNCTION__, etc. */ ! 713: if (DECL_IGNORED_P (decl)) ! 714: return; ! 715: ! 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: ! 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); ! 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: } ! 741: else if (GET_CODE (value) == SUBREG) ! 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) ! 753: return; ! 754: regno += offset; ! 755: } ! 756: alter_subreg (DECL_RTL (decl)); ! 757: value = DECL_RTL (decl); ! 758: } ! 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; ! 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 ! 771: || TREE_CODE (type) == UNION_TYPE ! 772: || TREE_CODE (type) == QUAL_UNION_TYPE) ! 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: ! 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: ! 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 ! 817: && REGNO (XEXP (value, 0)) != HARD_FRAME_POINTER_REGNUM ! 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: } ! 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: } ! 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: ! 892: if (DECL_IGNORED_P (decl)) ! 893: return; ! 894: ! 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: ! 941: if (type && ! TREE_ASM_WRITTEN (type)) ! 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: ! 1011: case QUAL_UNION_TYPE: ! 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, ! 1026: but perhaps checking TYPE_SIZE above will fix it. */ ! 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: ! 1073: case QUAL_UNION_TYPE: ! 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) = ! 1206: eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX); ! 1207: DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX); ! 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.