![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dwarfout.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 dwarfout.c CVS log | Up to [GCC 2.x] / gcc |
1.1 ! root 1: /* This file contains code written by Ron Guilmette ([email protected]) for ! 2: Network Computing Devices, August, September, October, November 1990. ! 3: ! 4: Output Dwarf format symbol table information from the GNU C compiler. ! 5: Copyright (C) 1992 Free Software Foundation, Inc. ! 6: ! 7: This file is part of GNU CC. ! 8: ! 9: GNU CC is free software; you can redistribute it and/or modify ! 10: it under the terms of the GNU General Public License as published by ! 11: the Free Software Foundation; either version 2, or (at your option) ! 12: any later version. ! 13: ! 14: GNU CC is distributed in the hope that it will be useful, ! 15: but WITHOUT ANY WARRANTY; without even the implied warranty of ! 16: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ! 17: GNU General Public License for more details. ! 18: ! 19: You should have received a copy of the GNU General Public License ! 20: along with GNU CC; see the file COPYING. If not, write to ! 21: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ ! 22: ! 23: #include "config.h" ! 24: ! 25: #ifdef DWARF_DEBUGGING_INFO ! 26: #include <stdio.h> ! 27: #include "dwarf.h" ! 28: #include "tree.h" ! 29: #include "flags.h" ! 30: #include "rtl.h" ! 31: #include "insn-config.h" ! 32: #include "reload.h" ! 33: #include "output.h" ! 34: ! 35: /* #define NDEBUG 1 */ ! 36: #include <assert.h> ! 37: ! 38: #if defined(DWARF_TIMESTAMPS) ! 39: #if defined(POSIX) ! 40: #include <time.h> ! 41: #else /* !defined(POSIX) */ ! 42: #include <sys/types.h> ! 43: #if defined(__STDC__) ! 44: extern time_t time (time_t *); ! 45: #else /* !defined(__STDC__) */ ! 46: extern time_t time (); ! 47: #endif /* !defined(__STDC__) */ ! 48: #endif /* !defined(POSIX) */ ! 49: #endif /* defined(DWARF_TIMESTAMPS) */ ! 50: ! 51: #if defined(USG) || defined(POSIX) ! 52: #include <string.h> ! 53: #else ! 54: #include <strings.h> ! 55: #define strrchr rindex ! 56: #define getcwd(s,len) getwd(s) ! 57: #endif ! 58: ! 59: /* IMPORTANT NOTE: Please see the file README.DWARF for important details ! 60: regarding the GNU implementation of Dwarf. */ ! 61: ! 62: /* NOTE: In the comments in this file, many references are made to ! 63: so called "Debugging Information Entries". For the sake of brevity, ! 64: this term is abbreviated to `DIE' throughout the remainder of this ! 65: file. */ ! 66: ! 67: /* Note that the implementation of C++ support herein is (as yet) unfinished. ! 68: If you want to try to complete it, more power to you. */ ! 69: ! 70: #if defined(__GNUC__) && (NDEBUG == 1) ! 71: #define inline static inline ! 72: #else ! 73: #define inline static ! 74: #endif ! 75: ! 76: /* How to start an assembler comment. */ ! 77: #ifndef ASM_COMMENT_START ! 78: #define ASM_COMMENT_START ";#" ! 79: #endif ! 80: ! 81: /* Define a macro which, when given a pointer to some BLOCK node, returns ! 82: a pointer to the FUNCTION_DECL node from which the given BLOCK node ! 83: was instantiated (as an inline expansion). This macro needs to be ! 84: defined properly in tree.h, however for the moment, we just fake it. */ ! 85: ! 86: #define BLOCK_INLINE_FUNCTION(block) 0 ! 87: ! 88: /* Define a macro which returns non-zero for any tagged type which is ! 89: used (directly or indirectly) in the specification of either some ! 90: function's return type or some formal parameter of some function. ! 91: We use this macro when we are operating in "terse" mode to help us ! 92: know what tagged types have to be represented in Dwarf (even in ! 93: terse mode) and which ones don't. ! 94: ! 95: A flag bit with this meaning really should be a part of the normal ! 96: GCC ..._TYPE nodes, but at the moment, there is no such bit defined ! 97: for these nodes. For now, we have to just fake it. It it safe for ! 98: us to simply return zero for all complete tagged types (which will ! 99: get forced out anyway if they were used in the specification of some ! 100: formal or return type) and non-zero for all incomplete tagged types. ! 101: */ ! 102: ! 103: #define TYPE_USED_FOR_FUNCTION(tagged_type) (TYPE_SIZE (tagged_type) == 0) ! 104: ! 105: #define BITFIELD_OFFSET_BITS(DECL) \ ! 106: ((unsigned) TREE_INT_CST_LOW (DECL_FIELD_BITPOS (DECL))) ! 107: #define BITFIELD_OFFSET_UNITS(DECL) \ ! 108: (BITFIELD_OFFSET_BITS(DECL) / (unsigned) BITS_PER_UNIT) ! 109: #define BITFIELD_OFFSET_WORDS_IN_UNITS(DECL) \ ! 110: ((BITFIELD_OFFSET_BITS(DECL) / (unsigned) BITS_PER_WORD) * UNITS_PER_WORD) ! 111: ! 112: extern int flag_traditional; ! 113: extern char *version_string; ! 114: extern char *language_string; ! 115: ! 116: /* Maximum size (in bytes) of an artificially generated label. */ ! 117: ! 118: #define MAX_ARTIFICIAL_LABEL_BYTES 30 ! 119: ! 120: /* Make sure we know the sizes of the various types dwarf can describe. ! 121: These are only defaults. If the sizes are different for your target, ! 122: you should override these values by defining the appropriate symbols ! 123: in your tm.h file. */ ! 124: ! 125: #ifndef CHAR_TYPE_SIZE ! 126: #define CHAR_TYPE_SIZE BITS_PER_UNIT ! 127: #endif ! 128: ! 129: #ifndef SHORT_TYPE_SIZE ! 130: #define SHORT_TYPE_SIZE (BITS_PER_UNIT * 2) ! 131: #endif ! 132: ! 133: #ifndef INT_TYPE_SIZE ! 134: #define INT_TYPE_SIZE BITS_PER_WORD ! 135: #endif ! 136: ! 137: #ifndef LONG_TYPE_SIZE ! 138: #define LONG_TYPE_SIZE BITS_PER_WORD ! 139: #endif ! 140: ! 141: #ifndef LONG_LONG_TYPE_SIZE ! 142: #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2) ! 143: #endif ! 144: ! 145: #ifndef WCHAR_TYPE_SIZE ! 146: #define WCHAR_TYPE_SIZE INT_TYPE_SIZE ! 147: #endif ! 148: ! 149: #ifndef WCHAR_UNSIGNED ! 150: #define WCHAR_UNSIGNED 0 ! 151: #endif ! 152: ! 153: #ifndef FLOAT_TYPE_SIZE ! 154: #define FLOAT_TYPE_SIZE BITS_PER_WORD ! 155: #endif ! 156: ! 157: #ifndef DOUBLE_TYPE_SIZE ! 158: #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) ! 159: #endif ! 160: ! 161: #ifndef LONG_DOUBLE_TYPE_SIZE ! 162: #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) ! 163: #endif ! 164: ! 165: /* Structure to keep track of source filenames. */ ! 166: ! 167: struct filename_entry { ! 168: unsigned number; ! 169: char * name; ! 170: }; ! 171: ! 172: typedef struct filename_entry filename_entry; ! 173: ! 174: /* Pointer to an array of elements, each one having the structure above. */ ! 175: ! 176: static filename_entry *filename_table; ! 177: ! 178: /* Total number of entries in the table (i.e. array) pointed to by ! 179: `filename_table'. This is the *total* and includes both used and ! 180: unused slots. */ ! 181: ! 182: static unsigned ft_entries_allocated; ! 183: ! 184: /* Number of entries in the filename_table which are actually in use. */ ! 185: ! 186: static unsigned ft_entries; ! 187: ! 188: /* Size (in elements) of increments by which we may expand the filename ! 189: table. Actually, a single hunk of space of this size should be enough ! 190: for most typical programs. */ ! 191: ! 192: #define FT_ENTRIES_INCREMENT 64 ! 193: ! 194: /* Local pointer to the name of the main input file. Initialized in ! 195: dwarfout_init. */ ! 196: ! 197: static char *primary_filename; ! 198: ! 199: /* Pointer to the most recent filename for which we produced some line info. */ ! 200: ! 201: static char *last_filename; ! 202: ! 203: /* For Dwarf output, we must assign lexical-blocks id numbers ! 204: in the order in which their beginnings are encountered. ! 205: We output Dwarf debugging info that refers to the beginnings ! 206: and ends of the ranges of code for each lexical block with ! 207: assembler labels ..Bn and ..Bn.e, where n is the block number. ! 208: The labels themselves are generated in final.c, which assigns ! 209: numbers to the blocks in the same way. */ ! 210: ! 211: static unsigned next_block_number = 2; ! 212: ! 213: /* Counter to generate unique names for DIEs. */ ! 214: ! 215: static unsigned next_unused_dienum = 1; ! 216: ! 217: /* Number of the DIE which is currently being generated. */ ! 218: ! 219: static unsigned current_dienum; ! 220: ! 221: /* Number to use for the special "pubname" label on the next DIE which ! 222: represents a function or data object defined in this compilation ! 223: unit which has "extern" linkage. */ ! 224: ! 225: static next_pubname_number = 0; ! 226: ! 227: #define NEXT_DIE_NUM pending_sibling_stack[pending_siblings-1] ! 228: ! 229: /* Pointer to a dynamically allocated list of pre-reserved and still ! 230: pending sibling DIE numbers. Note that this list will grow as needed. */ ! 231: ! 232: static unsigned *pending_sibling_stack; ! 233: ! 234: /* Counter to keep track of the number of pre-reserved and still pending ! 235: sibling DIE numbers. */ ! 236: ! 237: static unsigned pending_siblings; ! 238: ! 239: /* The currently allocated size of the above list (expressed in number of ! 240: list elements). */ ! 241: ! 242: static unsigned pending_siblings_allocated; ! 243: ! 244: /* Size (in elements) of increments by which we may expand the pending ! 245: sibling stack. Actually, a single hunk of space of this size should ! 246: be enough for most typical programs. */ ! 247: ! 248: #define PENDING_SIBLINGS_INCREMENT 64 ! 249: ! 250: /* Non-zero if we are performing our file-scope finalization pass and if ! 251: we should force out Dwarf decsriptions of any and all file-scope ! 252: tagged types which are still incomplete types. */ ! 253: ! 254: static int finalizing = 0; ! 255: ! 256: /* A pointer to the base of a list of pending types which we haven't ! 257: generated DIEs for yet, but which we will have to come back to ! 258: later on. */ ! 259: ! 260: static tree *pending_types_list; ! 261: ! 262: /* Number of elements currently allocated for the pending_types_list. */ ! 263: ! 264: static unsigned pending_types_allocated; ! 265: ! 266: /* Number of elements of pending_types_list currently in use. */ ! 267: ! 268: static unsigned pending_types; ! 269: ! 270: /* Size (in elements) of increments by which we may expand the pending ! 271: types list. Actually, a single hunk of space of this size should ! 272: be enough for most typical programs. */ ! 273: ! 274: #define PENDING_TYPES_INCREMENT 64 ! 275: ! 276: /* Pointer to an artifical RECORD_TYPE which we create in dwarfout_init. ! 277: This is used in a hack to help us get the DIEs describing types of ! 278: formal parameters to come *after* all of the DIEs describing the formal ! 279: parameters themselves. That's necessary in order to be compatible ! 280: with what the brain-dammaged svr4 SDB debugger requires. */ ! 281: ! 282: static tree fake_containing_scope; ! 283: ! 284: /* The number of the current function definition that we are generating ! 285: debugging information for. These numbers range from 1 up to the maximum ! 286: number of function definitions contained within the current compilation ! 287: unit. These numbers are used to create unique labels for various things ! 288: contained within various function definitions. */ ! 289: ! 290: static unsigned current_funcdef_number = 1; ! 291: ! 292: /* Forward declarations for functions defined in this file. */ ! 293: ! 294: static void output_type (); ! 295: static void type_attribute (); ! 296: static void output_decls_for_scope (); ! 297: static void output_decl (); ! 298: static unsigned lookup_filename (); ! 299: ! 300: /* Definitions of defaults for assembler-dependent names of various ! 301: pseudo-ops and section names. ! 302: ! 303: Theses may be overridden in your tm.h file (if necessary) for your ! 304: particular assembler. The default values provided here correspond to ! 305: what is expected by "standard" AT&T System V.4 assemblers. */ ! 306: ! 307: #ifndef FILE_ASM_OP ! 308: #define FILE_ASM_OP "\t.file" ! 309: #endif ! 310: #ifndef VERSION_ASM_OP ! 311: #define VERSION_ASM_OP "\t.version" ! 312: #endif ! 313: #ifndef SECTION_ASM_OP ! 314: #define SECTION_ASM_OP "\t.section" ! 315: #endif ! 316: #ifndef UNALIGNED_SHORT_ASM_OP ! 317: #define UNALIGNED_SHORT_ASM_OP "\t.2byte" ! 318: #endif ! 319: #ifndef UNALIGNED_INT_ASM_OP ! 320: #define UNALIGNED_INT_ASM_OP "\t.4byte" ! 321: #endif ! 322: #ifndef DEF_ASM_OP ! 323: #define DEF_ASM_OP "\t.set" ! 324: #endif ! 325: ! 326: /* This macro is already used elsewhere and has a published default. */ ! 327: #ifndef ASM_BYTE_OP ! 328: #define ASM_BYTE_OP "\t.byte" ! 329: #endif ! 330: ! 331: /* Definitions of defaults for formats and names of various special ! 332: (artificial) labels which may be generated within this file (when ! 333: the -g options is used and DWARF_DEBUGGING_INFO is in effect. ! 334: ! 335: If necessary, these may be overridden from within your tm.h file, ! 336: but typically, you should never need to override these. */ ! 337: ! 338: #ifndef TEXT_BEGIN_LABEL ! 339: #define TEXT_BEGIN_LABEL "._text_b" ! 340: #endif ! 341: #ifndef TEXT_END_LABEL ! 342: #define TEXT_END_LABEL "._text_e" ! 343: #endif ! 344: ! 345: #ifndef DATA_BEGIN_LABEL ! 346: #define DATA_BEGIN_LABEL "._data_b" ! 347: #endif ! 348: #ifndef DATA_END_LABEL ! 349: #define DATA_END_LABEL "._data_e" ! 350: #endif ! 351: ! 352: #ifndef DATA1_BEGIN_LABEL ! 353: #define DATA1_BEGIN_LABEL "._data1_b" ! 354: #endif ! 355: #ifndef DATA1_END_LABEL ! 356: #define DATA1_END_LABEL "._data1_e" ! 357: #endif ! 358: ! 359: #ifndef RODATA_BEGIN_LABEL ! 360: #define RODATA_BEGIN_LABEL "._rodata_b" ! 361: #endif ! 362: #ifndef RODATA_END_LABEL ! 363: #define RODATA_END_LABEL "._rodata_e" ! 364: #endif ! 365: ! 366: #ifndef RODATA1_BEGIN_LABEL ! 367: #define RODATA1_BEGIN_LABEL "._rodata1_b" ! 368: #endif ! 369: #ifndef RODATA1_END_LABEL ! 370: #define RODATA1_END_LABEL "._rodata1_e" ! 371: #endif ! 372: ! 373: #ifndef BSS_BEGIN_LABEL ! 374: #define BSS_BEGIN_LABEL "._bss_b" ! 375: #endif ! 376: #ifndef BSS_END_LABEL ! 377: #define BSS_END_LABEL "._bss_e" ! 378: #endif ! 379: ! 380: #ifndef LINE_BEGIN_LABEL ! 381: #define LINE_BEGIN_LABEL "._line_b" ! 382: #endif ! 383: #ifndef LINE_LAST_ENTRY_LABEL ! 384: #define LINE_LAST_ENTRY_LABEL "._line_last" ! 385: #endif ! 386: #ifndef LINE_END_LABEL ! 387: #define LINE_END_LABEL "._line_e" ! 388: #endif ! 389: ! 390: #ifndef DEBUG_BEGIN_LABEL ! 391: #define DEBUG_BEGIN_LABEL "._debug_b" ! 392: #endif ! 393: #ifndef SFNAMES_BEGIN_LABEL ! 394: #define SFNAMES_BEGIN_LABEL "._sfnames_b" ! 395: #endif ! 396: #ifndef SRCINFO_BEGIN_LABEL ! 397: #define SRCINFO_BEGIN_LABEL "._srcinfo_b" ! 398: #endif ! 399: #ifndef MACINFO_BEGIN_LABEL ! 400: #define MACINFO_BEGIN_LABEL "._macinfo_b" ! 401: #endif ! 402: ! 403: #ifndef DIE_BEGIN_LABEL_FMT ! 404: #define DIE_BEGIN_LABEL_FMT "._D%u" ! 405: #endif ! 406: #ifndef DIE_END_LABEL_FMT ! 407: #define DIE_END_LABEL_FMT "._D%u_e" ! 408: #endif ! 409: #ifndef PUB_DIE_LABEL_FMT ! 410: #define PUB_DIE_LABEL_FMT "._P%u" ! 411: #endif ! 412: #ifndef INSN_LABEL_FMT ! 413: #define INSN_LABEL_FMT "._I%u_%u" ! 414: #endif ! 415: #ifndef BLOCK_BEGIN_LABEL_FMT ! 416: #define BLOCK_BEGIN_LABEL_FMT "._B%u" ! 417: #endif ! 418: #ifndef BLOCK_END_LABEL_FMT ! 419: #define BLOCK_END_LABEL_FMT "._B%u_e" ! 420: #endif ! 421: #ifndef SS_BEGIN_LABEL_FMT ! 422: #define SS_BEGIN_LABEL_FMT "._s%u" ! 423: #endif ! 424: #ifndef SS_END_LABEL_FMT ! 425: #define SS_END_LABEL_FMT "._s%u_e" ! 426: #endif ! 427: #ifndef EE_BEGIN_LABEL_FMT ! 428: #define EE_BEGIN_LABEL_FMT "._e%u" ! 429: #endif ! 430: #ifndef EE_END_LABEL_FMT ! 431: #define EE_END_LABEL_FMT "._e%u_e" ! 432: #endif ! 433: #ifndef MT_BEGIN_LABEL_FMT ! 434: #define MT_BEGIN_LABEL_FMT "._t%u" ! 435: #endif ! 436: #ifndef MT_END_LABEL_FMT ! 437: #define MT_END_LABEL_FMT "._t%u_e" ! 438: #endif ! 439: #ifndef LOC_BEGIN_LABEL_FMT ! 440: #define LOC_BEGIN_LABEL_FMT "._l%u" ! 441: #endif ! 442: #ifndef LOC_END_LABEL_FMT ! 443: #define LOC_END_LABEL_FMT "._l%u_e" ! 444: #endif ! 445: #ifndef BOUND_BEGIN_LABEL_FMT ! 446: #define BOUND_BEGIN_LABEL_FMT "._b%u_%u_%c" ! 447: #endif ! 448: #ifndef BOUND_END_LABEL_FMT ! 449: #define BOUND_END_LABEL_FMT "._b%u_%u_%c_e" ! 450: #endif ! 451: #ifndef DERIV_BEGIN_LABEL_FMT ! 452: #define DERIV_BEGIN_LABEL_FMT "._d%u" ! 453: #endif ! 454: #ifndef DERIV_END_LABEL_FMT ! 455: #define DERIV_END_LABEL_FMT "._d%u_e" ! 456: #endif ! 457: #ifndef SL_BEGIN_LABEL_FMT ! 458: #define SL_BEGIN_LABEL_FMT "._sl%u" ! 459: #endif ! 460: #ifndef SL_END_LABEL_FMT ! 461: #define SL_END_LABEL_FMT "._sl%u_e" ! 462: #endif ! 463: #ifndef FUNC_END_LABEL_FMT ! 464: #define FUNC_END_LABEL_FMT "._f%u_e" ! 465: #endif ! 466: #ifndef TYPE_NAME_FMT ! 467: #define TYPE_NAME_FMT "._T%u" ! 468: #endif ! 469: #ifndef LINE_CODE_LABEL_FMT ! 470: #define LINE_CODE_LABEL_FMT "._LC%u" ! 471: #endif ! 472: #ifndef SFNAMES_ENTRY_LABEL_FMT ! 473: #define SFNAMES_ENTRY_LABEL_FMT "._F%u" ! 474: #endif ! 475: #ifndef LINE_ENTRY_LABEL_FMT ! 476: #define LINE_ENTRY_LABEL_FMT "._LE%u" ! 477: #endif ! 478: ! 479: /* Definitions of defaults for various types of primitive assembly language ! 480: output operations. ! 481: ! 482: If necessary, these may be overridden from within your tm.h file, ! 483: but typically, you should never need to override these. */ ! 484: ! 485: #ifndef ASM_OUTPUT_SOURCE_FILENAME ! 486: #define ASM_OUTPUT_SOURCE_FILENAME(FILE,NAME) \ ! 487: fprintf ((FILE), "%s\t\"%s\"\n", FILE_ASM_OP, NAME) ! 488: #endif ! 489: ! 490: #ifndef ASM_OUTPUT_DEF ! 491: #define ASM_OUTPUT_DEF(FILE,LABEL1,LABEL2) \ ! 492: do { fprintf ((FILE), "%s\t", DEF_ASM_OP); \ ! 493: assemble_name (FILE, LABEL1); \ ! 494: fprintf (FILE, ","); \ ! 495: assemble_name (FILE, LABEL2); \ ! 496: fprintf (FILE, "\n"); \ ! 497: } while (0) ! 498: #endif ! 499: ! 500: #ifndef ASM_DWARF_DEBUG_SECTION ! 501: #define ASM_DWARF_DEBUG_SECTION(FILE) \ ! 502: fprintf ((FILE), "%s\t.debug\n", SECTION_ASM_OP) ! 503: #endif ! 504: ! 505: #ifndef ASM_DWARF_LINE_SECTION ! 506: #define ASM_DWARF_LINE_SECTION(FILE) \ ! 507: fprintf ((FILE), "%s\t.line\n", SECTION_ASM_OP) ! 508: #endif ! 509: ! 510: #ifndef ASM_DWARF_SFNAMES_SECTION ! 511: #define ASM_DWARF_SFNAMES_SECTION(FILE) \ ! 512: fprintf ((FILE), "%s\t.debug_sfnames\n", SECTION_ASM_OP) ! 513: #endif ! 514: ! 515: #ifndef ASM_DWARF_SRCINFO_SECTION ! 516: #define ASM_DWARF_SRCINFO_SECTION(FILE) \ ! 517: fprintf ((FILE), "%s\t.debug_srcinfo\n", SECTION_ASM_OP) ! 518: #endif ! 519: ! 520: #ifndef ASM_DWARF_MACINFO_SECTION ! 521: #define ASM_DWARF_MACINFO_SECTION(FILE) \ ! 522: fprintf ((FILE), "%s\t.debug_macinfo\n", SECTION_ASM_OP) ! 523: #endif ! 524: ! 525: #ifndef ASM_DWARF_PUBNAMES_SECTION ! 526: #define ASM_DWARF_PUBNAMES_SECTION(FILE) \ ! 527: fprintf ((FILE), "%s\t.debug_pubnames\n", SECTION_ASM_OP) ! 528: #endif ! 529: ! 530: #ifndef ASM_DWARF_ARANGES_SECTION ! 531: #define ASM_DWARF_ARANGES_SECTION(FILE) \ ! 532: fprintf ((FILE), "%s\t.debug_aranges\n", SECTION_ASM_OP) ! 533: #endif ! 534: ! 535: #ifndef ASM_DWARF_TEXT_SECTION ! 536: #define ASM_DWARF_TEXT_SECTION(FILE) \ ! 537: fprintf ((FILE), "%s\t.text\n", SECTION_ASM_OP) ! 538: #endif ! 539: ! 540: #ifndef ASM_DWARF_DATA_SECTION ! 541: #define ASM_DWARF_DATA_SECTION(FILE) \ ! 542: fprintf ((FILE), "%s\t.data\n", SECTION_ASM_OP) ! 543: #endif ! 544: ! 545: #ifndef ASM_DWARF_DATA1_SECTION ! 546: #define ASM_DWARF_DATA1_SECTION(FILE) \ ! 547: fprintf ((FILE), "%s\t.data1\n", SECTION_ASM_OP) ! 548: #endif ! 549: ! 550: #ifndef ASM_DWARF_RODATA_SECTION ! 551: #define ASM_DWARF_RODATA_SECTION(FILE) \ ! 552: fprintf ((FILE), "%s\t.rodata\n", SECTION_ASM_OP) ! 553: #endif ! 554: ! 555: #ifndef ASM_DWARF_RODATA1_SECTION ! 556: #define ASM_DWARF_RODATA1_SECTION(FILE) \ ! 557: fprintf ((FILE), "%s\t.rodata1\n", SECTION_ASM_OP) ! 558: #endif ! 559: ! 560: #ifndef ASM_DWARF_BSS_SECTION ! 561: #define ASM_DWARF_BSS_SECTION(FILE) \ ! 562: fprintf ((FILE), "%s\t.bss\n", SECTION_ASM_OP) ! 563: #endif ! 564: ! 565: #ifndef ASM_DWARF_POP_SECTION ! 566: #define ASM_DWARF_POP_SECTION(FILE) \ ! 567: fprintf ((FILE), "\t.previous\n") ! 568: #endif ! 569: ! 570: #ifndef ASM_OUTPUT_DWARF_DELTA2 ! 571: #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \ ! 572: do { fprintf ((FILE), "%s\t", UNALIGNED_SHORT_ASM_OP); \ ! 573: assemble_name (FILE, LABEL1); \ ! 574: fprintf (FILE, "-"); \ ! 575: assemble_name (FILE, LABEL2); \ ! 576: fprintf (FILE, "\n"); \ ! 577: } while (0) ! 578: #endif ! 579: ! 580: #ifndef ASM_OUTPUT_DWARF_DELTA4 ! 581: #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \ ! 582: do { fprintf ((FILE), "%s\t", UNALIGNED_INT_ASM_OP); \ ! 583: assemble_name (FILE, LABEL1); \ ! 584: fprintf (FILE, "-"); \ ! 585: assemble_name (FILE, LABEL2); \ ! 586: fprintf (FILE, "\n"); \ ! 587: } while (0) ! 588: #endif ! 589: ! 590: #ifndef ASM_OUTPUT_DWARF_TAG ! 591: #define ASM_OUTPUT_DWARF_TAG(FILE,TAG) \ ! 592: fprintf ((FILE), "%s\t0x%x\t%s %s\n", UNALIGNED_SHORT_ASM_OP, \ ! 593: (unsigned) TAG, ASM_COMMENT_START, tag_name (TAG)) ! 594: #endif ! 595: ! 596: #ifndef ASM_OUTPUT_DWARF_ATTRIBUTE ! 597: #define ASM_OUTPUT_DWARF_ATTRIBUTE(FILE,ATTRIBUTE) \ ! 598: fprintf ((FILE), "%s\t0x%x\t%s %s\n", UNALIGNED_SHORT_ASM_OP, \ ! 599: (unsigned) ATTRIBUTE, ASM_COMMENT_START, attribute_name (ATTRIBUTE)) ! 600: #endif ! 601: ! 602: #ifndef ASM_OUTPUT_DWARF_STACK_OP ! 603: #define ASM_OUTPUT_DWARF_STACK_OP(FILE,OP) \ ! 604: fprintf ((FILE), "%s\t0x%x\t%s %s\n", ASM_BYTE_OP, \ ! 605: (unsigned) OP, ASM_COMMENT_START, stack_op_name (OP)) ! 606: #endif ! 607: ! 608: #ifndef ASM_OUTPUT_DWARF_FUND_TYPE ! 609: #define ASM_OUTPUT_DWARF_FUND_TYPE(FILE,FT) \ ! 610: fprintf ((FILE), "%s\t0x%x\t%s %s\n", UNALIGNED_SHORT_ASM_OP, \ ! 611: (unsigned) FT, ASM_COMMENT_START, fundamental_type_name (FT)) ! 612: #endif ! 613: ! 614: #ifndef ASM_OUTPUT_DWARF_FMT_BYTE ! 615: #define ASM_OUTPUT_DWARF_FMT_BYTE(FILE,FMT) \ ! 616: fprintf ((FILE), "%s\t0x%x\t%s %s\n", ASM_BYTE_OP, \ ! 617: (unsigned) FMT, ASM_COMMENT_START, format_byte_name (FMT)) ! 618: #endif ! 619: ! 620: #ifndef ASM_OUTPUT_DWARF_TYPE_MODIFIER ! 621: #define ASM_OUTPUT_DWARF_TYPE_MODIFIER(FILE,MOD) \ ! 622: fprintf ((FILE), "%s\t0x%x\t%s %s\n", ASM_BYTE_OP, \ ! 623: (unsigned) MOD, ASM_COMMENT_START, modifier_name (MOD)) ! 624: #endif ! 625: ! 626: #ifndef ASM_OUTPUT_DWARF_ADDR ! 627: #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \ ! 628: do { fprintf ((FILE), "%s\t", UNALIGNED_INT_ASM_OP); \ ! 629: assemble_name (FILE, LABEL); \ ! 630: fprintf (FILE, "\n"); \ ! 631: } while (0) ! 632: #endif ! 633: ! 634: #ifndef ASM_OUTPUT_DWARF_ADDR_CONST ! 635: #define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,RTX) \ ! 636: fprintf ((FILE), "%s\t", UNALIGNED_INT_ASM_OP); \ ! 637: output_addr_const ((FILE), (RTX)); \ ! 638: fputc ('\n', (FILE)) ! 639: #endif ! 640: ! 641: #ifndef ASM_OUTPUT_DWARF_REF ! 642: #define ASM_OUTPUT_DWARF_REF(FILE,LABEL) \ ! 643: do { fprintf ((FILE), "%s\t", UNALIGNED_INT_ASM_OP); \ ! 644: assemble_name (FILE, LABEL); \ ! 645: fprintf (FILE, "\n"); \ ! 646: } while (0) ! 647: #endif ! 648: ! 649: #ifndef ASM_OUTPUT_DWARF_DATA1 ! 650: #define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \ ! 651: fprintf ((FILE), "%s\t0x%x\n", ASM_BYTE_OP, VALUE) ! 652: #endif ! 653: ! 654: #ifndef ASM_OUTPUT_DWARF_DATA2 ! 655: #define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \ ! 656: fprintf ((FILE), "%s\t0x%x\n", UNALIGNED_SHORT_ASM_OP, (unsigned) VALUE) ! 657: #endif ! 658: ! 659: #ifndef ASM_OUTPUT_DWARF_DATA4 ! 660: #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \ ! 661: fprintf ((FILE), "%s\t0x%x\n", UNALIGNED_INT_ASM_OP, (unsigned) VALUE) ! 662: #endif ! 663: ! 664: #ifndef ASM_OUTPUT_DWARF_DATA8 ! 665: #define ASM_OUTPUT_DWARF_DATA8(FILE,HIGH_VALUE,LOW_VALUE) \ ! 666: do { \ ! 667: if (WORDS_BIG_ENDIAN) \ ! 668: { \ ! 669: fprintf ((FILE), "%s\t0x%x\n", UNALIGNED_INT_ASM_OP, HIGH_VALUE); \ ! 670: fprintf ((FILE), "%s\t0x%x\n", UNALIGNED_INT_ASM_OP, LOW_VALUE);\ ! 671: } \ ! 672: else \ ! 673: { \ ! 674: fprintf ((FILE), "%s\t0x%x\n", UNALIGNED_INT_ASM_OP, LOW_VALUE);\ ! 675: fprintf ((FILE), "%s\t0x%x\n", UNALIGNED_INT_ASM_OP, HIGH_VALUE); \ ! 676: } \ ! 677: } while (0) ! 678: #endif ! 679: ! 680: #ifndef ASM_OUTPUT_DWARF_STRING ! 681: #define ASM_OUTPUT_DWARF_STRING(FILE,P) \ ! 682: ASM_OUTPUT_ASCII ((FILE), P, strlen (P)+1) ! 683: #endif ! 684: ! 685: /************************ general utility functions **************************/ ! 686: ! 687: inline char * ! 688: xstrdup (s) ! 689: register char *s; ! 690: { ! 691: register char *p = (char *) xmalloc (strlen (s) + 1); ! 692: ! 693: strcpy (p, s); ! 694: return p; ! 695: } ! 696: ! 697: static char * ! 698: tag_name (tag) ! 699: register unsigned tag; ! 700: { ! 701: switch (tag) ! 702: { ! 703: case TAG_padding: return "TAG_padding"; ! 704: case TAG_array_type: return "TAG_array_type"; ! 705: case TAG_class_type: return "TAG_class_type"; ! 706: case TAG_entry_point: return "TAG_entry_point"; ! 707: case TAG_enumeration_type: return "TAG_enumeration_type"; ! 708: case TAG_formal_parameter: return "TAG_formal_parameter"; ! 709: case TAG_global_subroutine: return "TAG_global_subroutine"; ! 710: case TAG_global_variable: return "TAG_global_variable"; ! 711: case TAG_imported_declaration: return "TAG_imported_declaration"; ! 712: case TAG_label: return "TAG_label"; ! 713: case TAG_lexical_block: return "TAG_lexical_block"; ! 714: case TAG_local_variable: return "TAG_local_variable"; ! 715: case TAG_member: return "TAG_member"; ! 716: case TAG_pointer_type: return "TAG_pointer_type"; ! 717: case TAG_reference_type: return "TAG_reference_type"; ! 718: case TAG_compile_unit: return "TAG_compile_unit"; ! 719: case TAG_string_type: return "TAG_string_type"; ! 720: case TAG_structure_type: return "TAG_structure_type"; ! 721: case TAG_subroutine: return "TAG_subroutine"; ! 722: case TAG_subroutine_type: return "TAG_subroutine_type"; ! 723: case TAG_typedef: return "TAG_typedef"; ! 724: case TAG_union_type: return "TAG_union_type"; ! 725: case TAG_unspecified_parameters: return "TAG_unspecified_parameters"; ! 726: case TAG_variant: return "TAG_variant"; ! 727: case TAG_format: return "TAG_format"; ! 728: case TAG_with_stmt: return "TAG_with_stmt"; ! 729: case TAG_set_type: return "TAG_set_type"; ! 730: default: return "<unknown tag>"; ! 731: } ! 732: } ! 733: ! 734: static char * ! 735: attribute_name (attr) ! 736: register unsigned attr; ! 737: { ! 738: switch (attr) ! 739: { ! 740: case AT_sibling: return "AT_sibling"; ! 741: case AT_location: return "AT_location"; ! 742: case AT_name: return "AT_name"; ! 743: case AT_fund_type: return "AT_fund_type"; ! 744: case AT_mod_fund_type: return "AT_mod_fund_type"; ! 745: case AT_user_def_type: return "AT_user_def_type"; ! 746: case AT_mod_u_d_type: return "AT_mod_u_d_type"; ! 747: case AT_ordering: return "AT_ordering"; ! 748: case AT_subscr_data: return "AT_subscr_data"; ! 749: case AT_byte_size: return "AT_byte_size"; ! 750: case AT_bit_offset: return "AT_bit_offset"; ! 751: case AT_bit_size: return "AT_bit_size"; ! 752: case AT_element_list: return "AT_element_list"; ! 753: case AT_stmt_list: return "AT_stmt_list"; ! 754: case AT_low_pc: return "AT_low_pc"; ! 755: case AT_high_pc: return "AT_high_pc"; ! 756: case AT_language: return "AT_language"; ! 757: case AT_member: return "AT_member"; ! 758: case AT_discr: return "AT_discr"; ! 759: case AT_discr_value: return "AT_discr_value"; ! 760: case AT_visibility: return "AT_visibility"; ! 761: case AT_import: return "AT_import"; ! 762: case AT_string_length: return "AT_string_length"; ! 763: case AT_comp_dir: return "AT_comp_dir"; ! 764: case AT_producer: return "AT_producer"; ! 765: case AT_frame_base: return "AT_frame_base"; ! 766: case AT_start_scope: return "AT_start_scope"; ! 767: case AT_stride_size: return "AT_stride_size"; ! 768: case AT_src_info: return "AT_src_info"; ! 769: case AT_prototyped: return "AT_prototyped"; ! 770: case AT_const_value_block4: return "AT_const_value_block4"; ! 771: case AT_sf_names: return "AT_sf_names"; ! 772: case AT_mac_info: return "AT_mac_info"; ! 773: default: return "<unknown attribute>"; ! 774: } ! 775: } ! 776: ! 777: static char * ! 778: stack_op_name (op) ! 779: register unsigned op; ! 780: { ! 781: switch (op) ! 782: { ! 783: case OP_REG: return "OP_REG"; ! 784: case OP_BASEREG: return "OP_BASEREG"; ! 785: case OP_ADDR: return "OP_ADDR"; ! 786: case OP_CONST: return "OP_CONST"; ! 787: case OP_DEREF2: return "OP_DEREF2"; ! 788: case OP_DEREF4: return "OP_DEREF4"; ! 789: case OP_ADD: return "OP_ADD"; ! 790: default: return "<unknown stack operator>"; ! 791: } ! 792: } ! 793: ! 794: static char * ! 795: modifier_name (mod) ! 796: register unsigned mod; ! 797: { ! 798: switch (mod) ! 799: { ! 800: case MOD_pointer_to: return "MOD_pointer_to"; ! 801: case MOD_reference_to: return "MOD_reference_to"; ! 802: case MOD_const: return "MOD_const"; ! 803: case MOD_volatile: return "MOD_volatile"; ! 804: default: return "<unknown modifier>"; ! 805: } ! 806: } ! 807: ! 808: static char * ! 809: format_byte_name (fmt) ! 810: register unsigned fmt; ! 811: { ! 812: switch (fmt) ! 813: { ! 814: case FMT_FT_C_C: return "FMT_FT_C_C"; ! 815: case FMT_FT_C_X: return "FMT_FT_C_X"; ! 816: case FMT_FT_X_C: return "FMT_FT_X_C"; ! 817: case FMT_FT_X_X: return "FMT_FT_X_X"; ! 818: case FMT_UT_C_C: return "FMT_UT_C_C"; ! 819: case FMT_UT_C_X: return "FMT_UT_C_X"; ! 820: case FMT_UT_X_C: return "FMT_UT_X_C"; ! 821: case FMT_UT_X_X: return "FMT_UT_X_X"; ! 822: case FMT_ET: return "FMT_ET"; ! 823: default: return "<unknown array bound format byte>"; ! 824: } ! 825: } ! 826: static char * ! 827: fundamental_type_name (ft) ! 828: register unsigned ft; ! 829: { ! 830: switch (ft) ! 831: { ! 832: case FT_char: return "FT_char"; ! 833: case FT_signed_char: return "FT_signed_char"; ! 834: case FT_unsigned_char: return "FT_unsigned_char"; ! 835: case FT_short: return "FT_short"; ! 836: case FT_signed_short: return "FT_signed_short"; ! 837: case FT_unsigned_short: return "FT_unsigned_short"; ! 838: case FT_integer: return "FT_integer"; ! 839: case FT_signed_integer: return "FT_signed_integer"; ! 840: case FT_unsigned_integer: return "FT_unsigned_integer"; ! 841: case FT_long: return "FT_long"; ! 842: case FT_signed_long: return "FT_signed_long"; ! 843: case FT_unsigned_long: return "FT_unsigned_long"; ! 844: case FT_pointer: return "FT_pointer"; ! 845: case FT_float: return "FT_float"; ! 846: case FT_dbl_prec_float: return "FT_dbl_prec_float"; ! 847: case FT_ext_prec_float: return "FT_ext_prec_float"; ! 848: case FT_complex: return "FT_complex"; ! 849: case FT_dbl_prec_complex: return "FT_dbl_prec_complex"; ! 850: case FT_void: return "FT_void"; ! 851: case FT_boolean: return "FT_boolean"; ! 852: case FT_long_long: return "FT_long_long"; ! 853: case FT_signed_long_long: return "FT_signed_long_long"; ! 854: case FT_unsigned_long_long: return "FT_unsigned_long_long"; ! 855: default: return "<unknown fundamental type>"; ! 856: } ! 857: } ! 858: ! 859: /**************** utility functions for attribute functions ******************/ ! 860: ! 861: /* Given a pointer to a tree node for some type, return a Dwarf fundamental ! 862: type code for the given type. ! 863: ! 864: This routine must only be called for GCC type nodes that correspond to ! 865: Dwarf fundamental types. ! 866: ! 867: The current Dwarf draft specification calls for Dwarf fundamental types ! 868: to accurately reflect the fact that a given type was either a "plain" ! 869: integral type or an explicitly "signed" integral type. Unfortuantely, ! 870: we can't always do this, because GCC may already have thrown away the ! 871: information about the precise way in which the type was originally ! 872: specified, as in: ! 873: ! 874: typedef signed int field_type; ! 875: ! 876: struct s { field_type f; }; ! 877: ! 878: Since we may be stuck here without enought information to do exactly ! 879: what is called for in the Dwarf draft specification, we do the best ! 880: that we can under the circumstances and always use the "plain" integral ! 881: fundamental type codes for int, short, and long types. That's probably ! 882: good enough. The additional accuracy called for in the current DWARF ! 883: draft specification is probably never even useful in practice. */ ! 884: ! 885: static int ! 886: fundamental_type_code (type) ! 887: register tree type; ! 888: { ! 889: if (TREE_CODE (type) == ERROR_MARK) ! 890: return 0; ! 891: ! 892: switch (TREE_CODE (type)) ! 893: { ! 894: case ERROR_MARK: ! 895: return FT_void; ! 896: ! 897: case VOID_TYPE: ! 898: return FT_void; ! 899: ! 900: case INTEGER_TYPE: ! 901: /* Carefully distinguish all the standard types of C, ! 902: without messing up if the language is not C. ! 903: Note that we check only for the names that contain spaces; ! 904: other names might occur by coincidence in other languages. */ ! 905: if (TYPE_NAME (type) != 0 ! 906: && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL ! 907: && DECL_NAME (TYPE_NAME (type)) != 0 ! 908: && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE) ! 909: { ! 910: char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))); ! 911: ! 912: if (!strcmp (name, "unsigned char")) ! 913: return FT_unsigned_char; ! 914: if (!strcmp (name, "signed char")) ! 915: return FT_signed_char; ! 916: if (!strcmp (name, "unsigned int")) ! 917: return FT_unsigned_integer; ! 918: if (!strcmp (name, "short int")) ! 919: return FT_short; ! 920: if (!strcmp (name, "short unsigned int")) ! 921: return FT_unsigned_short; ! 922: if (!strcmp (name, "long int")) ! 923: return FT_long; ! 924: if (!strcmp (name, "long unsigned int")) ! 925: return FT_unsigned_long; ! 926: if (!strcmp (name, "long long int")) ! 927: return FT_long_long; /* Not grok'ed by svr4 SDB */ ! 928: if (!strcmp (name, "long long unsigned int")) ! 929: return FT_unsigned_long_long; /* Not grok'ed by svr4 SDB */ ! 930: } ! 931: ! 932: /* Most integer types will be sorted out above, however, for the ! 933: sake of special `array index' integer types, the following code ! 934: is also provided. */ ! 935: ! 936: if (TYPE_PRECISION (type) == INT_TYPE_SIZE) ! 937: return (TREE_UNSIGNED (type) ? FT_unsigned_integer : FT_integer); ! 938: ! 939: if (TYPE_PRECISION (type) == LONG_TYPE_SIZE) ! 940: return (TREE_UNSIGNED (type) ? FT_unsigned_long : FT_long); ! 941: ! 942: if (TYPE_PRECISION (type) == LONG_LONG_TYPE_SIZE) ! 943: return (TREE_UNSIGNED (type) ? FT_unsigned_long_long : FT_long_long); ! 944: ! 945: if (TYPE_PRECISION (type) == SHORT_TYPE_SIZE) ! 946: return (TREE_UNSIGNED (type) ? FT_unsigned_short : FT_short); ! 947: ! 948: if (TYPE_PRECISION (type) == CHAR_TYPE_SIZE) ! 949: return (TREE_UNSIGNED (type) ? FT_unsigned_char : FT_char); ! 950: ! 951: abort (); ! 952: ! 953: case REAL_TYPE: ! 954: /* Carefully distinguish all the standard types of C, ! 955: without messing up if the language is not C. */ ! 956: if (TYPE_NAME (type) != 0 ! 957: && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL ! 958: && DECL_NAME (TYPE_NAME (type)) != 0 ! 959: && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE) ! 960: { ! 961: char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))); ! 962: ! 963: /* Note that here we can run afowl of a serious bug in "classic" ! 964: svr4 SDB debuggers. They don't seem to understand the ! 965: FT_ext_prec_float type (even though they should). */ ! 966: ! 967: if (!strcmp (name, "long double")) ! 968: return FT_ext_prec_float; ! 969: } ! 970: ! 971: if (TYPE_PRECISION (type) == DOUBLE_TYPE_SIZE) ! 972: return FT_dbl_prec_float; ! 973: if (TYPE_PRECISION (type) == FLOAT_TYPE_SIZE) ! 974: return FT_float; ! 975: ! 976: /* Note that here we can run afowl of a serious bug in "classic" ! 977: svr4 SDB debuggers. They don't seem to understand the ! 978: FT_ext_prec_float type (even though they should). */ ! 979: ! 980: if (TYPE_PRECISION (type) == LONG_DOUBLE_TYPE_SIZE) ! 981: return FT_ext_prec_float; ! 982: abort (); ! 983: ! 984: case COMPLEX_TYPE: ! 985: return FT_complex; /* GNU FORTRAN COMPLEX type. */ ! 986: ! 987: case CHAR_TYPE: ! 988: return FT_char; /* GNU Pascal CHAR type. Not used in C. */ ! 989: ! 990: case BOOLEAN_TYPE: ! 991: return FT_boolean; /* GNU FORTRAN BOOLEAN type. */ ! 992: ! 993: default: ! 994: abort (); /* No other TREE_CODEs are Dwarf fundamental types. */ ! 995: } ! 996: return 0; ! 997: } ! 998: ! 999: /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to ! 1000: the Dwarf "root" type for the given input type. The Dwarf "root" type ! 1001: of a given type is generally the same as the given type, except that if ! 1002: the given type is a pointer or reference type, then the root type of ! 1003: the given type is the root type of the "basis" type for the pointer or ! 1004: reference type. (This definition of the "root" type is recursive.) ! 1005: Also, the root type of a `const' qualified type or a `volatile' ! 1006: qualified type is the root type of the given type without the ! 1007: qualifiers. */ ! 1008: ! 1009: static tree ! 1010: root_type (type) ! 1011: register tree type; ! 1012: { ! 1013: if (TREE_CODE (type) == ERROR_MARK) ! 1014: return error_mark_node; ! 1015: ! 1016: switch (TREE_CODE (type)) ! 1017: { ! 1018: case ERROR_MARK: ! 1019: return error_mark_node; ! 1020: ! 1021: case POINTER_TYPE: ! 1022: case REFERENCE_TYPE: ! 1023: return TYPE_MAIN_VARIANT (root_type (TREE_TYPE (type))); ! 1024: ! 1025: default: ! 1026: return TYPE_MAIN_VARIANT (type); ! 1027: } ! 1028: } ! 1029: ! 1030: /* Given a pointer to an arbitrary ..._TYPE tree node, write out a sequence ! 1031: of zero or more Dwarf "type-modifier" bytes applicable to the type. */ ! 1032: ! 1033: static void ! 1034: write_modifier_bytes (type, decl_const, decl_volatile) ! 1035: register tree type; ! 1036: register int decl_const; ! 1037: register int decl_volatile; ! 1038: { ! 1039: if (TREE_CODE (type) == ERROR_MARK) ! 1040: return; ! 1041: ! 1042: if (TYPE_READONLY (type) || decl_const) ! 1043: ASM_OUTPUT_DWARF_TYPE_MODIFIER (asm_out_file, MOD_const); ! 1044: if (TYPE_VOLATILE (type) || decl_volatile) ! 1045: ASM_OUTPUT_DWARF_TYPE_MODIFIER (asm_out_file, MOD_volatile); ! 1046: switch (TREE_CODE (type)) ! 1047: { ! 1048: case POINTER_TYPE: ! 1049: ASM_OUTPUT_DWARF_TYPE_MODIFIER (asm_out_file, MOD_pointer_to); ! 1050: write_modifier_bytes (TREE_TYPE (type), 0, 0); ! 1051: return; ! 1052: ! 1053: case REFERENCE_TYPE: ! 1054: ASM_OUTPUT_DWARF_TYPE_MODIFIER (asm_out_file, MOD_reference_to); ! 1055: write_modifier_bytes (TREE_TYPE (type), 0, 0); ! 1056: return; ! 1057: ! 1058: case ERROR_MARK: ! 1059: default: ! 1060: return; ! 1061: } ! 1062: } ! 1063: ! 1064: /* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the ! 1065: given input type is a Dwarf "fundamental" type. Otherwise return zero. */ ! 1066: ! 1067: inline int ! 1068: type_is_fundamental (type) ! 1069: register tree type; ! 1070: { ! 1071: switch (TREE_CODE (type)) ! 1072: { ! 1073: case ERROR_MARK: ! 1074: case VOID_TYPE: ! 1075: case INTEGER_TYPE: ! 1076: case REAL_TYPE: ! 1077: case COMPLEX_TYPE: ! 1078: case BOOLEAN_TYPE: ! 1079: case CHAR_TYPE: ! 1080: return 1; ! 1081: ! 1082: case SET_TYPE: ! 1083: case ARRAY_TYPE: ! 1084: case RECORD_TYPE: ! 1085: case UNION_TYPE: ! 1086: case ENUMERAL_TYPE: ! 1087: case FUNCTION_TYPE: ! 1088: case METHOD_TYPE: ! 1089: case POINTER_TYPE: ! 1090: case REFERENCE_TYPE: ! 1091: case STRING_TYPE: ! 1092: case FILE_TYPE: ! 1093: case OFFSET_TYPE: ! 1094: case LANG_TYPE: ! 1095: return 0; ! 1096: ! 1097: default: ! 1098: abort (); ! 1099: } ! 1100: return 0; ! 1101: } ! 1102: ! 1103: /* Given a pointer to some ..._TYPE tree node, generate an assembly language ! 1104: equate directive which will associate an easily remembered symbolic name ! 1105: with the current DIE. ! 1106: ! 1107: The name used is an artificial label generated from the TYPE_UID number ! 1108: associated with the given type node. The name it gets equated to is the ! 1109: symbolic label that we (previously) output at the start of the DIE that ! 1110: we are currently generating. ! 1111: ! 1112: Calling this function while generating some "type related" form of DIE ! 1113: makes it easy to later refer to the DIE which represents the given type ! 1114: simply by re-generating the alternative name from the ..._TYPE node's ! 1115: UID number. */ ! 1116: ! 1117: inline void ! 1118: equate_type_number_to_die_number (type) ! 1119: register tree type; ! 1120: { ! 1121: char type_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1122: char die_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1123: ! 1124: /* We are generating a DIE to represent the main variant of this type ! 1125: (i.e the type without any const or volatile qualifiers) so in order ! 1126: to get the equate to come out right, we need to get the main variant ! 1127: itself here. */ ! 1128: ! 1129: type = TYPE_MAIN_VARIANT (type); ! 1130: ! 1131: sprintf (type_label, TYPE_NAME_FMT, TYPE_UID (type)); ! 1132: sprintf (die_label, DIE_BEGIN_LABEL_FMT, current_dienum); ! 1133: ASM_OUTPUT_DEF (asm_out_file, type_label, die_label); ! 1134: } ! 1135: ! 1136: /* The following routine is a nice and simple transducer. It converts the ! 1137: RTL for a variable or parameter (resident in memory) into an equivalent ! 1138: Dwarf representation of a mechanism for getting the address of that same ! 1139: variable onto the top of a hypothetical "address evaluation" stack. ! 1140: ! 1141: When creating memory location descriptors, we are effectively trans- ! 1142: forming the RTL for a memory-resident object into its Dwarf postfix ! 1143: expression equivalent. This routine just recursively descends an ! 1144: RTL tree, turning it into Dwarf postfix code as it goes. */ ! 1145: ! 1146: static void ! 1147: output_mem_loc_descriptor (rtl) ! 1148: register rtx rtl; ! 1149: { ! 1150: /* Note that for a dynamically sized array, the location we will ! 1151: generate a description of here will be the lowest numbered location ! 1152: which is actually within the array. That's *not* necessarily the ! 1153: same as the zeroth element of the array. */ ! 1154: ! 1155: switch (GET_CODE (rtl)) ! 1156: { ! 1157: case SUBREG: ! 1158: ! 1159: /* The case of a subreg may arise when we have a local (register) ! 1160: variable or a formal (register) parameter which doesn't quite ! 1161: fill up an entire register. For now, just assume that it is ! 1162: legitimate to make the Dwarf info refer to the whole register ! 1163: which contains the given subreg. */ ! 1164: ! 1165: rtl = XEXP (rtl, 0); ! 1166: /* Drop thru. */ ! 1167: ! 1168: case REG: ! 1169: ! 1170: /* Whenever a register number forms a part of the description of ! 1171: the method for calculating the (dynamic) address of a memory ! 1172: resident object, Dwarf rules require the register number to ! 1173: be referred to as a "base register". This distinction is not ! 1174: based in any way upon what category of register the hardware ! 1175: believes the given register belongs to. This is strictly ! 1176: Dwarf terminology we're dealing with here. */ ! 1177: ! 1178: ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_BASEREG); ! 1179: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, ! 1180: DBX_REGISTER_NUMBER (REGNO (rtl))); ! 1181: break; ! 1182: ! 1183: case MEM: ! 1184: output_mem_loc_descriptor (XEXP (rtl, 0)); ! 1185: ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_DEREF4); ! 1186: break; ! 1187: ! 1188: case CONST: ! 1189: case SYMBOL_REF: ! 1190: ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_ADDR); ! 1191: ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, rtl); ! 1192: break; ! 1193: ! 1194: case PLUS: ! 1195: output_mem_loc_descriptor (XEXP (rtl, 0)); ! 1196: output_mem_loc_descriptor (XEXP (rtl, 1)); ! 1197: ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_ADD); ! 1198: break; ! 1199: ! 1200: case CONST_INT: ! 1201: ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_CONST); ! 1202: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, INTVAL (rtl)); ! 1203: break; ! 1204: ! 1205: default: ! 1206: abort (); ! 1207: } ! 1208: } ! 1209: ! 1210: /* Output a proper Dwarf location descriptor for a variable or parameter ! 1211: which is either allocated in a register or in a memory location. For ! 1212: a register, we just generate an OP_REG and the register number. For a ! 1213: memory location we provide a Dwarf postfix expression describing how to ! 1214: generate the (dynamic) address of the object onto the address stack. */ ! 1215: ! 1216: static void ! 1217: output_loc_descriptor (rtl) ! 1218: register rtx rtl; ! 1219: { ! 1220: switch (GET_CODE (rtl)) ! 1221: { ! 1222: case SUBREG: ! 1223: ! 1224: /* The case of a subreg may arise when we have a local (register) ! 1225: variable or a formal (register) parameter which doesn't quite ! 1226: fill up an entire register. For now, just assume that it is ! 1227: legitimate to make the Dwarf info refer to the whole register ! 1228: which contains the given subreg. */ ! 1229: ! 1230: rtl = XEXP (rtl, 0); ! 1231: /* Drop thru. */ ! 1232: ! 1233: case REG: ! 1234: ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_REG); ! 1235: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, ! 1236: DBX_REGISTER_NUMBER (REGNO (rtl))); ! 1237: break; ! 1238: ! 1239: case MEM: ! 1240: output_mem_loc_descriptor (XEXP (rtl, 0)); ! 1241: break; ! 1242: ! 1243: default: ! 1244: abort (); /* Should never happen */ ! 1245: } ! 1246: } ! 1247: ! 1248: /* Given a tree node describing an array bound (either lower or upper) ! 1249: output a representation for that bound. */ ! 1250: ! 1251: static void ! 1252: output_bound_representation (bound, dim_num, u_or_l) ! 1253: register tree bound; ! 1254: register unsigned dim_num; /* For multi-dimensional arrays. */ ! 1255: register char u_or_l; /* Designates upper or lower bound. */ ! 1256: { ! 1257: switch (TREE_CODE (bound)) ! 1258: { ! 1259: ! 1260: case ERROR_MARK: ! 1261: return; ! 1262: ! 1263: /* All fixed-bounds are represented by INTEGER_CST nodes. */ ! 1264: ! 1265: case INTEGER_CST: ! 1266: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, ! 1267: (unsigned) TREE_INT_CST_LOW (bound)); ! 1268: break; ! 1269: ! 1270: /* Dynamic bounds may be represented by NOP_EXPR nodes containing ! 1271: SAVE_EXPR nodes. */ ! 1272: ! 1273: case NOP_EXPR: ! 1274: bound = TREE_OPERAND (bound, 0); ! 1275: /* ... fall thru... */ ! 1276: ! 1277: case SAVE_EXPR: ! 1278: { ! 1279: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1280: char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1281: ! 1282: sprintf (begin_label, BOUND_BEGIN_LABEL_FMT, ! 1283: current_dienum, dim_num, u_or_l); ! 1284: ! 1285: sprintf (end_label, BOUND_END_LABEL_FMT, ! 1286: current_dienum, dim_num, u_or_l); ! 1287: ! 1288: ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label); ! 1289: ASM_OUTPUT_LABEL (asm_out_file, begin_label); ! 1290: ! 1291: /* If we are working on a bound for a dynamic dimension in C, ! 1292: the dynamic dimension in question had better have a static ! 1293: (zero) lower bound and a dynamic *upper* bound. */ ! 1294: ! 1295: if (u_or_l != 'u') ! 1296: abort (); ! 1297: ! 1298: /* If optimization is turned on, the SAVE_EXPRs that describe ! 1299: how to access the upper bound values are essentially bogus. ! 1300: They only describe (at best) how to get at these values at ! 1301: the points in the generated code right after they have just ! 1302: been computed. Worse yet, in the typical case, the upper ! 1303: bound values will not even *be* computed in the optimized ! 1304: code, so these SAVE_EXPRs are entirely bogus. ! 1305: ! 1306: In order to compensate for this fact, we check here to see ! 1307: if optimization is enabled, and if so, we effectively create ! 1308: an empty location description for the (unknown and unknowable) ! 1309: upper bound. ! 1310: ! 1311: This should not cause too much trouble for existing (stupid?) ! 1312: debuggers because they have to deal with empty upper bounds ! 1313: location descriptions anyway in order to be able to deal with ! 1314: incomplete array types. ! 1315: ! 1316: Of course an intelligent debugger (GDB?) should be able to ! 1317: comprehend that a missing upper bound specification in a ! 1318: array type used for a storage class `auto' local array variable ! 1319: indicates that the upper bound is both unknown (at compile- ! 1320: time) and unknowable (at run-time) due to optimization. ! 1321: */ ! 1322: ! 1323: if (! optimize) ! 1324: output_loc_descriptor ! 1325: (eliminate_regs (SAVE_EXPR_RTL (bound), 0, 0)); ! 1326: ! 1327: ASM_OUTPUT_LABEL (asm_out_file, end_label); ! 1328: } ! 1329: break; ! 1330: ! 1331: default: ! 1332: abort (); ! 1333: } ! 1334: } ! 1335: ! 1336: /* Recursive function to output a sequence of value/name pairs for ! 1337: enumeration constants in reversed order. This is called from ! 1338: enumeration_type_die. */ ! 1339: ! 1340: static void ! 1341: output_enumeral_list (link) ! 1342: register tree link; ! 1343: { ! 1344: if (link) ! 1345: { ! 1346: output_enumeral_list (TREE_CHAIN (link)); ! 1347: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, ! 1348: (unsigned) TREE_INT_CST_LOW (TREE_VALUE (link))); ! 1349: ASM_OUTPUT_DWARF_STRING (asm_out_file, ! 1350: IDENTIFIER_POINTER (TREE_PURPOSE (link))); ! 1351: } ! 1352: } ! 1353: ! 1354: /****************************** attributes *********************************/ ! 1355: ! 1356: /* The following routines are responsible for writing out the various types ! 1357: of Dwarf attributes (and any following data bytes associated with them). ! 1358: These routines are listed in order based on the numerical codes of their ! 1359: associated attributes. */ ! 1360: ! 1361: /* Generate an AT_sibling attribute. */ ! 1362: ! 1363: inline void ! 1364: sibling_attribute () ! 1365: { ! 1366: char label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1367: ! 1368: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_sibling); ! 1369: sprintf (label, DIE_BEGIN_LABEL_FMT, NEXT_DIE_NUM); ! 1370: ASM_OUTPUT_DWARF_REF (asm_out_file, label); ! 1371: } ! 1372: ! 1373: /* Output the form of location attributes suitable for whole variables and ! 1374: whole parameters. Note that the location attributes for struct fields ! 1375: are generated by the routine `data_member_location_attribute' below. */ ! 1376: ! 1377: static void ! 1378: location_attribute (rtl) ! 1379: register rtx rtl; ! 1380: { ! 1381: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1382: char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1383: ! 1384: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_location); ! 1385: sprintf (begin_label, LOC_BEGIN_LABEL_FMT, current_dienum); ! 1386: sprintf (end_label, LOC_END_LABEL_FMT, current_dienum); ! 1387: ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label); ! 1388: ASM_OUTPUT_LABEL (asm_out_file, begin_label); ! 1389: ! 1390: /* Handle a special case. If we are about to output a location descriptor ! 1391: for a variable or parameter which has been optimized out of existance, ! 1392: don't do that. Instead we output a zero-length location descriptor ! 1393: value as part of the location attribute. Note that we cannot simply ! 1394: suppress the entire location attribute, because the absence of a ! 1395: location attribute in certain kinds of DIEs is used to indicate some- ! 1396: thing entirely different... i.e. that the DIE represents an object ! 1397: declaration, but not a definition. So sayeth the PLSIG. */ ! 1398: ! 1399: if (((GET_CODE (rtl) != REG) || (REGNO (rtl) < FIRST_PSEUDO_REGISTER)) ! 1400: && ((GET_CODE (rtl) != SUBREG) ! 1401: || (REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER))) ! 1402: output_loc_descriptor (eliminate_regs (rtl, 0, 0)); ! 1403: ! 1404: ASM_OUTPUT_LABEL (asm_out_file, end_label); ! 1405: } ! 1406: ! 1407: /* Output the specialized form of location attribute used for data members ! 1408: of struct types. */ ! 1409: ! 1410: static void ! 1411: data_member_location_attribute (decl) ! 1412: register tree decl; ! 1413: { ! 1414: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1415: char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1416: ! 1417: if (TREE_CODE (decl) == ERROR_MARK) ! 1418: return; ! 1419: ! 1420: if (TREE_CODE (decl) != FIELD_DECL) ! 1421: abort (); ! 1422: ! 1423: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_location); ! 1424: sprintf (begin_label, LOC_BEGIN_LABEL_FMT, current_dienum); ! 1425: sprintf (end_label, LOC_END_LABEL_FMT, current_dienum); ! 1426: ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label); ! 1427: ASM_OUTPUT_LABEL (asm_out_file, begin_label); ! 1428: ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_CONST); ! 1429: ! 1430: /* This is pretty strange, but existing compilers producing DWARF ! 1431: apparently calculate the byte offset of a field differently ! 1432: depending upon whether or not it is a bit-field. If the given ! 1433: field is *not* a bit-field, then the offset is simply the ! 1434: the byte offset of the given field from the beginning of the ! 1435: struct. For bit-fields however, the offset is the offset (in ! 1436: bytes) of the beginning of the *containing word* from the ! 1437: beginning of the whole struct. */ ! 1438: ! 1439: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, ! 1440: (DECL_BIT_FIELD_TYPE (decl)) ! 1441: ? BITFIELD_OFFSET_WORDS_IN_UNITS (decl) ! 1442: : BITFIELD_OFFSET_UNITS (decl)); ! 1443: ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_ADD); ! 1444: ASM_OUTPUT_LABEL (asm_out_file, end_label); ! 1445: } ! 1446: ! 1447: /* Output an AT_const_value attribute for a variable or a parameter which ! 1448: does not have a "location" either in memory or in a register. These ! 1449: things can arise in GNU C when a constant is passed as an actual ! 1450: parameter to an inlined function. They can also arise in C++ where ! 1451: declared constants do not necessarily get memory "homes". */ ! 1452: ! 1453: static void ! 1454: const_value_attribute (rtl) ! 1455: register rtx rtl; ! 1456: { ! 1457: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1458: char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1459: ! 1460: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_const_value_block4); ! 1461: sprintf (begin_label, LOC_BEGIN_LABEL_FMT, current_dienum); ! 1462: sprintf (end_label, LOC_END_LABEL_FMT, current_dienum); ! 1463: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, end_label, begin_label); ! 1464: ASM_OUTPUT_LABEL (asm_out_file, begin_label); ! 1465: ! 1466: switch (GET_CODE (rtl)) ! 1467: { ! 1468: case CONST_INT: ! 1469: /* Note that a CONST_INT rtx could represent either an integer or ! 1470: a floating-point constant. A CONST_INT is used whenever the ! 1471: constant will fit into a single word. In all such cases, the ! 1472: original mode of the constant value is wiped out, and the ! 1473: CONST_INT rtx is assigned VOIDmode. Since we no longer have ! 1474: precise mode information for these constants, we always just ! 1475: output them using 4 bytes. */ ! 1476: ! 1477: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, (unsigned) INTVAL (rtl)); ! 1478: break; ! 1479: ! 1480: case CONST_DOUBLE: ! 1481: /* Note that a CONST_DOUBLE rtx could represent either an integer ! 1482: or a floating-point constant. A CONST_DOUBLE is used whenever ! 1483: the constant requires more than one word in order to be adequately ! 1484: represented. In all such cases, the original mode of the constant ! 1485: value is preserved as the mode of the CONST_DOUBLE rtx, but for ! 1486: simplicity we always just output CONST_DOUBLEs using 8 bytes. */ ! 1487: ! 1488: ASM_OUTPUT_DWARF_DATA8 (asm_out_file, ! 1489: (unsigned) CONST_DOUBLE_HIGH (rtl), ! 1490: (unsigned) CONST_DOUBLE_LOW (rtl)); ! 1491: break; ! 1492: ! 1493: case CONST_STRING: ! 1494: ASM_OUTPUT_DWARF_STRING (asm_out_file, XSTR (rtl, 0)); ! 1495: break; ! 1496: ! 1497: case SYMBOL_REF: ! 1498: case LABEL_REF: ! 1499: case CONST: ! 1500: ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, rtl); ! 1501: break; ! 1502: } ! 1503: ! 1504: ASM_OUTPUT_LABEL (asm_out_file, end_label); ! 1505: } ! 1506: ! 1507: /* Generate *either* an AT_location attribute or else an AT_const_value ! 1508: data attribute for a variable or a parameter. We generate the ! 1509: AT_const_value attribute only in those cases where the given ! 1510: variable or parameter does not have a true "location" either in ! 1511: memory or in a register. This can happen (for example) when a ! 1512: constant is passed as an actual argument in a call to an inline ! 1513: function. (It's possible that these things can crop up in other ! 1514: ways also.) Note that one type of constant value which can be ! 1515: passed into an inlined function is a constant pointer. This can ! 1516: happen for example if an actual argument in an inlined function ! 1517: call evaluates to a compile-time constant address. */ ! 1518: ! 1519: static void ! 1520: location_or_const_value_attribute (decl) ! 1521: register tree decl; ! 1522: { ! 1523: register rtx rtl; ! 1524: ! 1525: if (TREE_CODE (decl) == ERROR_MARK) ! 1526: return; ! 1527: ! 1528: if ((TREE_CODE (decl) != VAR_DECL) && (TREE_CODE (decl) != PARM_DECL)) ! 1529: abort (); ! 1530: ! 1531: /* It's not really clear what existing Dwarf debuggers need or expect ! 1532: as regards to location information for formal parameters. A later ! 1533: version of the Dwarf specification should resolve such issues, but ! 1534: for the time being, we assume here that debuggers want information ! 1535: about the location where the parameter was passed into the function. ! 1536: That seems to be what USL's CI5 compiler generates. Note that this ! 1537: will probably be different from the place where the parameter actual ! 1538: resides during function execution. Dwarf Version 2 will provide us ! 1539: with a means to describe that location also, but for now we can only ! 1540: describe the "passing" location. */ ! 1541: ! 1542: #if 0 /* This is probably right, but it leads to a lot of trouble. ! 1543: Fixing one problem has been exposing another, ! 1544: all of which seemed to have no ill effects before. ! 1545: Better to turn this off for now and try fix it later. */ ! 1546: rtl = (TREE_CODE (decl) == PARM_DECL) ! 1547: ? DECL_INCOMING_RTL (decl) ! 1548: : DECL_RTL (decl); ! 1549: #endif ! 1550: rtl = DECL_RTL (decl); ! 1551: ! 1552: if (rtl == NULL) ! 1553: return; ! 1554: ! 1555: switch (GET_CODE (rtl)) ! 1556: { ! 1557: case CONST_INT: ! 1558: case CONST_DOUBLE: ! 1559: case CONST_STRING: ! 1560: case SYMBOL_REF: ! 1561: case LABEL_REF: ! 1562: case CONST: ! 1563: const_value_attribute (rtl); ! 1564: break; ! 1565: ! 1566: case MEM: ! 1567: case REG: ! 1568: case SUBREG: ! 1569: location_attribute (rtl); ! 1570: break; ! 1571: ! 1572: default: ! 1573: abort (); /* Should never happen. */ ! 1574: } ! 1575: } ! 1576: ! 1577: /* Generate an AT_name attribute given some string value to be included as ! 1578: the value of the attribute. If the name is null, don't do anything. */ ! 1579: ! 1580: inline void ! 1581: name_attribute (name_string) ! 1582: register char *name_string; ! 1583: { ! 1584: if (name_string && *name_string) ! 1585: { ! 1586: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_name); ! 1587: ASM_OUTPUT_DWARF_STRING (asm_out_file, name_string); ! 1588: } ! 1589: } ! 1590: ! 1591: inline void ! 1592: fund_type_attribute (ft_code) ! 1593: register unsigned ft_code; ! 1594: { ! 1595: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_fund_type); ! 1596: ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file, ft_code); ! 1597: } ! 1598: ! 1599: static void ! 1600: mod_fund_type_attribute (type, decl_const, decl_volatile) ! 1601: register tree type; ! 1602: register int decl_const; ! 1603: register int decl_volatile; ! 1604: { ! 1605: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1606: char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1607: ! 1608: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_mod_fund_type); ! 1609: sprintf (begin_label, MT_BEGIN_LABEL_FMT, current_dienum); ! 1610: sprintf (end_label, MT_END_LABEL_FMT, current_dienum); ! 1611: ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label); ! 1612: ASM_OUTPUT_LABEL (asm_out_file, begin_label); ! 1613: write_modifier_bytes (type, decl_const, decl_volatile); ! 1614: ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file, ! 1615: fundamental_type_code (root_type (type))); ! 1616: ASM_OUTPUT_LABEL (asm_out_file, end_label); ! 1617: } ! 1618: ! 1619: inline void ! 1620: user_def_type_attribute (type) ! 1621: register tree type; ! 1622: { ! 1623: char ud_type_name[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1624: ! 1625: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_user_def_type); ! 1626: sprintf (ud_type_name, TYPE_NAME_FMT, TYPE_UID (type)); ! 1627: ASM_OUTPUT_DWARF_REF (asm_out_file, ud_type_name); ! 1628: } ! 1629: ! 1630: static void ! 1631: mod_u_d_type_attribute (type, decl_const, decl_volatile) ! 1632: register tree type; ! 1633: register int decl_const; ! 1634: register int decl_volatile; ! 1635: { ! 1636: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1637: char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1638: char ud_type_name[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1639: ! 1640: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_mod_u_d_type); ! 1641: sprintf (begin_label, MT_BEGIN_LABEL_FMT, current_dienum); ! 1642: sprintf (end_label, MT_END_LABEL_FMT, current_dienum); ! 1643: ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label); ! 1644: ASM_OUTPUT_LABEL (asm_out_file, begin_label); ! 1645: write_modifier_bytes (type, decl_const, decl_volatile); ! 1646: sprintf (ud_type_name, TYPE_NAME_FMT, TYPE_UID (root_type (type))); ! 1647: ASM_OUTPUT_DWARF_REF (asm_out_file, ud_type_name); ! 1648: ASM_OUTPUT_LABEL (asm_out_file, end_label); ! 1649: } ! 1650: ! 1651: inline void ! 1652: ordering_attribute (ordering) ! 1653: register unsigned ordering; ! 1654: { ! 1655: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_ordering); ! 1656: ASM_OUTPUT_DWARF_DATA2 (asm_out_file, ordering); ! 1657: } ! 1658: ! 1659: /* Note that the block of subscript information for an array type also ! 1660: includes information about the element type of type given array type. */ ! 1661: ! 1662: static void ! 1663: subscript_data_attribute (type) ! 1664: register tree type; ! 1665: { ! 1666: register unsigned dimension_number; ! 1667: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1668: char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1669: ! 1670: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_subscr_data); ! 1671: sprintf (begin_label, SS_BEGIN_LABEL_FMT, current_dienum); ! 1672: sprintf (end_label, SS_END_LABEL_FMT, current_dienum); ! 1673: ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label); ! 1674: ASM_OUTPUT_LABEL (asm_out_file, begin_label); ! 1675: ! 1676: /* The GNU compilers represent multidimensional array types as sequences ! 1677: of one dimensional array types whose element types are themselves array ! 1678: types. Here we squish that down, so that each multidimensional array ! 1679: type gets only one array_type DIE in the Dwarf debugging info. The ! 1680: draft Dwarf specification say that we are allowed to do this kind ! 1681: of compression in C (because there is no difference between an ! 1682: array or arrays and a multidimensional array in C) but for other ! 1683: source languages (e.g. Ada) we probably shouldn't do this. */ ! 1684: ! 1685: for (dimension_number = 0; ! 1686: TREE_CODE (type) == ARRAY_TYPE; ! 1687: type = TREE_TYPE (type), dimension_number++) ! 1688: { ! 1689: register tree domain = TYPE_DOMAIN (type); ! 1690: ! 1691: /* Arrays come in three flavors. Unspecified bounds, fixed ! 1692: bounds, and (in GNU C only) variable bounds. Handle all ! 1693: three forms here. */ ! 1694: ! 1695: if (domain) ! 1696: { ! 1697: /* We have an array type with specified bounds. */ ! 1698: ! 1699: register tree lower = TYPE_MIN_VALUE (domain); ! 1700: register tree upper = TYPE_MAX_VALUE (domain); ! 1701: ! 1702: /* Handle only fundamental types as index types for now. */ ! 1703: ! 1704: if (! type_is_fundamental (domain)) ! 1705: abort (); ! 1706: ! 1707: /* Output the representation format byte for this dimension. */ ! 1708: ! 1709: ASM_OUTPUT_DWARF_FMT_BYTE (asm_out_file, ! 1710: FMT_CODE (1, ! 1711: TREE_CODE (lower) == INTEGER_CST, ! 1712: TREE_CODE (upper) == INTEGER_CST)); ! 1713: ! 1714: /* Output the index type for this dimension. */ ! 1715: ! 1716: ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file, ! 1717: fundamental_type_code (domain)); ! 1718: ! 1719: /* Output the representation for the lower bound. */ ! 1720: ! 1721: output_bound_representation (lower, dimension_number, 'l'); ! 1722: ! 1723: /* Output the representation for the upper bound. */ ! 1724: ! 1725: output_bound_representation (upper, dimension_number, 'u'); ! 1726: } ! 1727: else ! 1728: { ! 1729: /* We have an array type with an unspecified length. For C and ! 1730: C++ we can assume that this really means that (a) the index ! 1731: type is an integral type, and (b) the lower bound is zero. ! 1732: Note that Dwarf defines the representation of an unspecified ! 1733: (upper) bound as being a zero-length location description. */ ! 1734: ! 1735: /* Output the array-bounds format byte. */ ! 1736: ! 1737: ASM_OUTPUT_DWARF_FMT_BYTE (asm_out_file, FMT_FT_C_X); ! 1738: ! 1739: /* Output the (assumed) index type. */ ! 1740: ! 1741: ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file, FT_integer); ! 1742: ! 1743: /* Output the (assumed) lower bound (constant) value. */ ! 1744: ! 1745: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0); ! 1746: ! 1747: /* Output the (empty) location description for the upper bound. */ ! 1748: ! 1749: ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0); ! 1750: } ! 1751: } ! 1752: ! 1753: /* Output the prefix byte that says that the element type is comming up. */ ! 1754: ! 1755: ASM_OUTPUT_DWARF_FMT_BYTE (asm_out_file, FMT_ET); ! 1756: ! 1757: /* Output a representation of the type of the elements of this array type. */ ! 1758: ! 1759: type_attribute (type, 0, 0); ! 1760: ! 1761: ASM_OUTPUT_LABEL (asm_out_file, end_label); ! 1762: } ! 1763: ! 1764: static void ! 1765: byte_size_attribute (tree_node) ! 1766: register tree tree_node; ! 1767: { ! 1768: register unsigned size; ! 1769: ! 1770: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_byte_size); ! 1771: switch (TREE_CODE (tree_node)) ! 1772: { ! 1773: case ERROR_MARK: ! 1774: size = 0; ! 1775: break; ! 1776: ! 1777: case ENUMERAL_TYPE: ! 1778: case RECORD_TYPE: ! 1779: case UNION_TYPE: ! 1780: size = int_size_in_bytes (tree_node); ! 1781: break; ! 1782: ! 1783: case FIELD_DECL: ! 1784: { ! 1785: register unsigned words; ! 1786: register unsigned bits; ! 1787: ! 1788: bits = TREE_INT_CST_LOW (DECL_SIZE (tree_node)); ! 1789: words = (bits + (BITS_PER_WORD-1)) / BITS_PER_WORD; ! 1790: size = words * (BITS_PER_WORD / BITS_PER_UNIT); ! 1791: } ! 1792: break; ! 1793: ! 1794: default: ! 1795: abort (); ! 1796: } ! 1797: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, size); ! 1798: } ! 1799: ! 1800: /* For a FIELD_DECL node which represents a bit field, output an attribute ! 1801: which specifies the distance in bits from the start of the *word* ! 1802: containing the given field to the first bit of the field. */ ! 1803: ! 1804: inline void ! 1805: bit_offset_attribute (decl) ! 1806: register tree decl; ! 1807: { ! 1808: assert (TREE_CODE (decl) == FIELD_DECL); /* Must be a field. */ ! 1809: assert (DECL_BIT_FIELD_TYPE (decl)); /* Must be a bit field. */ ! 1810: ! 1811: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_bit_offset); ! 1812: ASM_OUTPUT_DWARF_DATA2 (asm_out_file, ! 1813: BITFIELD_OFFSET_BITS (decl) % (unsigned) BITS_PER_WORD); ! 1814: } ! 1815: ! 1816: /* For a FIELD_DECL node which represents a bit field, output an attribute ! 1817: which specifies the length in bits of the given field. */ ! 1818: ! 1819: inline void ! 1820: bit_size_attribute (decl) ! 1821: register tree decl; ! 1822: { ! 1823: assert (TREE_CODE (decl) == FIELD_DECL); /* Must be a field. */ ! 1824: assert (DECL_BIT_FIELD_TYPE (decl)); /* Must be a bit field. */ ! 1825: ! 1826: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_bit_size); ! 1827: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, ! 1828: (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl))); ! 1829: } ! 1830: ! 1831: /* The following routine outputs the `element_list' attribute for enumeration ! 1832: type DIEs. The element_lits attribute includes the names and values of ! 1833: all of the enumeration constants associated with the given enumeration ! 1834: type. */ ! 1835: ! 1836: inline void ! 1837: element_list_attribute (element) ! 1838: register tree element; ! 1839: { ! 1840: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1841: char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1842: ! 1843: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_element_list); ! 1844: sprintf (begin_label, EE_BEGIN_LABEL_FMT, current_dienum); ! 1845: sprintf (end_label, EE_END_LABEL_FMT, current_dienum); ! 1846: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, end_label, begin_label); ! 1847: ASM_OUTPUT_LABEL (asm_out_file, begin_label); ! 1848: ! 1849: /* Here we output a list of value/name pairs for each enumeration constant ! 1850: defined for this enumeration type (as required), but we do it in REVERSE ! 1851: order. The order is the one required by the draft #5 Dwarf specification ! 1852: published by the UI/PLSIG. */ ! 1853: ! 1854: output_enumeral_list (element); /* Recursively output the whole list. */ ! 1855: ! 1856: ASM_OUTPUT_LABEL (asm_out_file, end_label); ! 1857: } ! 1858: ! 1859: /* Generate an AT_stmt_list attribute. These are normally present only in ! 1860: DIEs with a TAG_compile_unit tag. */ ! 1861: ! 1862: inline void ! 1863: stmt_list_attribute (label) ! 1864: register char *label; ! 1865: { ! 1866: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_stmt_list); ! 1867: /* Don't use ASM_OUTPUT_DWARF_DATA4 here. */ ! 1868: ASM_OUTPUT_DWARF_ADDR (asm_out_file, label); ! 1869: } ! 1870: ! 1871: /* Generate an AT_low_pc attribute for a label DIE, a lexical_block DIE or ! 1872: for a subroutine DIE. */ ! 1873: ! 1874: inline void ! 1875: low_pc_attribute (asm_low_label) ! 1876: register char *asm_low_label; ! 1877: { ! 1878: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_low_pc); ! 1879: ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_low_label); ! 1880: } ! 1881: ! 1882: /* Generate an AT_high_pc attribute for a lexical_block DIE or for a ! 1883: subroutine DIE. */ ! 1884: ! 1885: inline void ! 1886: high_pc_attribute (asm_high_label) ! 1887: register char *asm_high_label; ! 1888: { ! 1889: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_high_pc); ! 1890: ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_high_label); ! 1891: } ! 1892: ! 1893: /* Generate an AT_language attribute given a LANG value. These attributes ! 1894: are used only within TAG_compile_unit DIEs. */ ! 1895: ! 1896: inline void ! 1897: language_attribute (language_code) ! 1898: register unsigned language_code; ! 1899: { ! 1900: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_language); ! 1901: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, language_code); ! 1902: } ! 1903: ! 1904: inline void ! 1905: member_attribute (context) ! 1906: register tree context; ! 1907: { ! 1908: char label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1909: ! 1910: /* Generate this attribute only for members in C++. */ ! 1911: ! 1912: if (context != NULL ! 1913: && (TREE_CODE (context) == RECORD_TYPE ! 1914: || TREE_CODE (context) == UNION_TYPE)) ! 1915: { ! 1916: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_member); ! 1917: sprintf (label, TYPE_NAME_FMT, TYPE_UID (context)); ! 1918: ASM_OUTPUT_DWARF_REF (asm_out_file, label); ! 1919: } ! 1920: } ! 1921: ! 1922: inline void ! 1923: string_length_attribute (upper_bound) ! 1924: register tree upper_bound; ! 1925: { ! 1926: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1927: char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 1928: ! 1929: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_string_length); ! 1930: sprintf (begin_label, SL_BEGIN_LABEL_FMT, current_dienum); ! 1931: sprintf (end_label, SL_END_LABEL_FMT, current_dienum); ! 1932: ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label); ! 1933: ASM_OUTPUT_LABEL (asm_out_file, begin_label); ! 1934: output_bound_representation (upper_bound, 0, 'u'); ! 1935: ASM_OUTPUT_LABEL (asm_out_file, end_label); ! 1936: } ! 1937: ! 1938: inline void ! 1939: comp_dir_attribute (dirname) ! 1940: register char *dirname; ! 1941: { ! 1942: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_comp_dir); ! 1943: ASM_OUTPUT_DWARF_STRING (asm_out_file, dirname); ! 1944: } ! 1945: ! 1946: inline void ! 1947: sf_names_attribute (sf_names_start_label) ! 1948: register char *sf_names_start_label; ! 1949: { ! 1950: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_sf_names); ! 1951: /* Don't use ASM_OUTPUT_DWARF_DATA4 here. */ ! 1952: ASM_OUTPUT_DWARF_ADDR (asm_out_file, sf_names_start_label); ! 1953: } ! 1954: ! 1955: inline void ! 1956: src_info_attribute (src_info_start_label) ! 1957: register char *src_info_start_label; ! 1958: { ! 1959: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_src_info); ! 1960: /* Don't use ASM_OUTPUT_DWARF_DATA4 here. */ ! 1961: ASM_OUTPUT_DWARF_ADDR (asm_out_file, src_info_start_label); ! 1962: } ! 1963: ! 1964: inline void ! 1965: mac_info_attribute (mac_info_start_label) ! 1966: register char *mac_info_start_label; ! 1967: { ! 1968: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_mac_info); ! 1969: /* Don't use ASM_OUTPUT_DWARF_DATA4 here. */ ! 1970: ASM_OUTPUT_DWARF_ADDR (asm_out_file, mac_info_start_label); ! 1971: } ! 1972: ! 1973: inline void ! 1974: prototyped_attribute (func_type) ! 1975: register tree func_type; ! 1976: { ! 1977: if ((strcmp (language_string, "GNU C") == 0) ! 1978: && (TYPE_ARG_TYPES (func_type) != NULL)) ! 1979: { ! 1980: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_prototyped); ! 1981: ASM_OUTPUT_DWARF_STRING (asm_out_file, ""); ! 1982: } ! 1983: } ! 1984: ! 1985: inline void ! 1986: producer_attribute (producer) ! 1987: register char *producer; ! 1988: { ! 1989: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_producer); ! 1990: ASM_OUTPUT_DWARF_STRING (asm_out_file, producer); ! 1991: } ! 1992: ! 1993: inline void ! 1994: inline_attribute (decl) ! 1995: register tree decl; ! 1996: { ! 1997: if (TREE_INLINE (decl)) ! 1998: { ! 1999: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_inline); ! 2000: ASM_OUTPUT_DWARF_STRING (asm_out_file, ""); ! 2001: } ! 2002: } ! 2003: ! 2004: inline void ! 2005: containing_type_attribute (containing_type) ! 2006: register tree containing_type; ! 2007: { ! 2008: char label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 2009: ! 2010: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_containing_type); ! 2011: sprintf (label, TYPE_NAME_FMT, TYPE_UID (containing_type)); ! 2012: ASM_OUTPUT_DWARF_REF (asm_out_file, label); ! 2013: } ! 2014: ! 2015: /************************* end of attributes *****************************/ ! 2016: ! 2017: /********************* utility routines for DIEs *************************/ ! 2018: ! 2019: /* Many forms of DIEs contain a "type description" part. The following ! 2020: routine writes out these "type descriptor" parts. */ ! 2021: ! 2022: static void ! 2023: type_attribute (type, decl_const, decl_volatile) ! 2024: register tree type; ! 2025: register int decl_const; ! 2026: register int decl_volatile; ! 2027: { ! 2028: register enum tree_code code = TREE_CODE (type); ! 2029: register int root_type_modified; ! 2030: ! 2031: if (TREE_CODE (type) == ERROR_MARK) ! 2032: return; ! 2033: ! 2034: /* Handle a special case. For functions whose return type is void, ! 2035: we generate *no* type attribute. (Note that no object may have ! 2036: type `void', so this only applies to function return types. */ ! 2037: ! 2038: if (TREE_CODE (type) == VOID_TYPE) ! 2039: return; ! 2040: ! 2041: root_type_modified = (code == POINTER_TYPE || code == REFERENCE_TYPE ! 2042: || decl_const || decl_volatile ! 2043: || TYPE_READONLY (type) || TYPE_VOLATILE (type)); ! 2044: ! 2045: if (type_is_fundamental (root_type (type))) ! 2046: if (root_type_modified) ! 2047: mod_fund_type_attribute (type, decl_const, decl_volatile); ! 2048: else ! 2049: fund_type_attribute (fundamental_type_code (type)); ! 2050: else ! 2051: if (root_type_modified) ! 2052: mod_u_d_type_attribute (type, decl_const, decl_volatile); ! 2053: else ! 2054: user_def_type_attribute (type); ! 2055: } ! 2056: ! 2057: /* Given a tree pointer to a struct, class, union, or enum type node, return ! 2058: a pointer to the (string) tag name for the given type, or zero if the ! 2059: type was declared without a tag. */ ! 2060: ! 2061: static char * ! 2062: type_tag (type) ! 2063: register tree type; ! 2064: { ! 2065: register char *name = 0; ! 2066: ! 2067: if (TYPE_NAME (type) != 0) ! 2068: { ! 2069: register tree t = 0; ! 2070: ! 2071: /* Find the IDENTIFIER_NODE for the type name. */ ! 2072: if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) ! 2073: t = TYPE_NAME (type); ! 2074: #if 0 ! 2075: /* The g++ front end makes the TYPE_NAME of *each* tagged type point ! 2076: to a TYPE_DECL node, regardless of whether or not a `typedef' was ! 2077: involved. This is distinctly different from what the gcc front-end ! 2078: does. It always makes the TYPE_NAME for each tagged type be either ! 2079: NULL (signifying an anonymous tagged type) or else a pointer to an ! 2080: IDENTIFIER_NODE. Obviously, we would like to generate correct Dwarf ! 2081: for both C and C++, but given this inconsistancy in the TREE ! 2082: representation of tagged types for C and C++ in the GNU front-ends, ! 2083: we cannot support both languages correctly unless we introduce some ! 2084: front-end specific code here, and rms objects to that, so we can ! 2085: only generate correct Dwarf for one of these two languages. C is ! 2086: more important, so for now we'll do the right thing for C and let ! 2087: g++ go fish. */ ! 2088: ! 2089: else ! 2090: if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL) ! 2091: t = DECL_NAME (TYPE_NAME (type)); ! 2092: #endif ! 2093: /* Now get the name as a string, or invent one. */ ! 2094: if (t != 0) ! 2095: name = IDENTIFIER_POINTER (t); ! 2096: } ! 2097: ! 2098: return (name == 0 || *name == '\0') ? 0 : name; ! 2099: } ! 2100: ! 2101: inline void ! 2102: dienum_push () ! 2103: { ! 2104: /* Start by checking if the pending_sibling_stack needs to be expanded. ! 2105: If necessary, expand it. */ ! 2106: ! 2107: if (pending_siblings == pending_siblings_allocated) ! 2108: { ! 2109: pending_siblings_allocated += PENDING_SIBLINGS_INCREMENT; ! 2110: pending_sibling_stack ! 2111: = (unsigned *) xrealloc (pending_sibling_stack, ! 2112: pending_siblings_allocated * sizeof(unsigned)); ! 2113: } ! 2114: ! 2115: pending_siblings++; ! 2116: NEXT_DIE_NUM = next_unused_dienum++; ! 2117: } ! 2118: ! 2119: /* Pop the sibling stack so that the most recently pushed DIEnum becomes the ! 2120: NEXT_DIE_NUM. */ ! 2121: ! 2122: inline void ! 2123: dienum_pop () ! 2124: { ! 2125: pending_siblings--; ! 2126: } ! 2127: ! 2128: inline tree ! 2129: member_declared_type (member) ! 2130: register tree member; ! 2131: { ! 2132: return (DECL_BIT_FIELD_TYPE (member)) ! 2133: ? DECL_BIT_FIELD_TYPE (member) ! 2134: : TREE_TYPE (member); ! 2135: } ! 2136: ! 2137: /******************************* DIEs ************************************/ ! 2138: ! 2139: /* Output routines for individual types of DIEs. */ ! 2140: ! 2141: /* Note that every type of DIE (except a null DIE) gets a sibling. */ ! 2142: ! 2143: static void ! 2144: output_array_type_die (arg) ! 2145: register void *arg; ! 2146: { ! 2147: register tree type = arg; ! 2148: ! 2149: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_array_type); ! 2150: sibling_attribute (); ! 2151: equate_type_number_to_die_number (type); ! 2152: member_attribute (TYPE_CONTEXT (type)); ! 2153: ! 2154: /* I believe that we can default the array ordering. SDB will probably ! 2155: do the right things even if AT_ordering is not present. It's not ! 2156: even an issue until we start to get into multidimensional arrays ! 2157: anyway. If SDB is shown to do the wrong thing in those cases, then ! 2158: we'll have to put the AT_ordering attribute back in, but only for ! 2159: multidimensional array. (After all, we don't want to waste space ! 2160: in the .debug section now do we?) */ ! 2161: ! 2162: #if 0 ! 2163: ordering_attribute (ORD_row_major); ! 2164: #endif ! 2165: ! 2166: subscript_data_attribute (type); ! 2167: } ! 2168: ! 2169: static void ! 2170: output_set_type_die (arg) ! 2171: register void *arg; ! 2172: { ! 2173: register tree type = arg; ! 2174: ! 2175: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_set_type); ! 2176: sibling_attribute (); ! 2177: equate_type_number_to_die_number (type); ! 2178: member_attribute (TYPE_CONTEXT (type)); ! 2179: type_attribute (TREE_TYPE (type), 0, 0); ! 2180: } ! 2181: ! 2182: #if 0 ! 2183: /* Implement this when there is a GNU FORTRAN or GNU Ada front end. */ ! 2184: static void ! 2185: output_entry_point_die (arg) ! 2186: register void *arg; ! 2187: { ! 2188: register tree decl = arg; ! 2189: register tree type = TREE_TYPE (decl); ! 2190: register tree return_type = TREE_TYPE (type); ! 2191: ! 2192: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_entry_point); ! 2193: sibling_attribute (); ! 2194: dienum_push (); ! 2195: if (DECL_NAME (decl)) ! 2196: name_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); ! 2197: member_attribute (DECL_CONTEXT (decl)); ! 2198: type_attribute (return_type, 0, 0); ! 2199: } ! 2200: #endif ! 2201: ! 2202: /* Output a DIE to represent an enumeration type. Note that these DIEs ! 2203: include all of the information about the enumeration values also. ! 2204: This information is encoded into the element_list attribute. */ ! 2205: ! 2206: static void ! 2207: output_enumeration_type_die (arg) ! 2208: register void *arg; ! 2209: { ! 2210: register tree type = arg; ! 2211: ! 2212: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_enumeration_type); ! 2213: sibling_attribute (); ! 2214: equate_type_number_to_die_number (type); ! 2215: name_attribute (type_tag (type)); ! 2216: member_attribute (TYPE_CONTEXT (type)); ! 2217: ! 2218: /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the ! 2219: given enum type is incomplete, do not generate the AT_byte_size ! 2220: attribute or the AT_element_list attribute. */ ! 2221: ! 2222: if (TYPE_SIZE (type)) ! 2223: { ! 2224: byte_size_attribute (type); ! 2225: element_list_attribute (TYPE_FIELDS (type)); ! 2226: } ! 2227: } ! 2228: ! 2229: /* Output a DIE to represent either a real live formal parameter decl or ! 2230: to represent just the type of some formal parameter position in some ! 2231: function type. ! 2232: ! 2233: Note that this routine is a bit unusual because its argument may be ! 2234: either a PARM_DECL node or else some sort of a ..._TYPE node. If it's ! 2235: the formar then this function is being called to output a real live ! 2236: formal parameter declaration. If it's the latter, then this function ! 2237: is only being called to output a TAG_formal_parameter DIE to stand as ! 2238: a placeholder for some formal argument type of some subprogram type. */ ! 2239: ! 2240: static void ! 2241: output_formal_parameter_die (arg) ! 2242: register void *arg; ! 2243: { ! 2244: register tree decl = arg; ! 2245: register tree type; ! 2246: ! 2247: if (TREE_CODE (decl) == PARM_DECL) ! 2248: type = TREE_TYPE (decl); ! 2249: else ! 2250: { ! 2251: type = decl; /* we were called with a type, not a decl */ ! 2252: decl = NULL; ! 2253: } ! 2254: ! 2255: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_formal_parameter); ! 2256: sibling_attribute (); ! 2257: if (decl) ! 2258: { ! 2259: if (DECL_NAME (decl)) ! 2260: name_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); ! 2261: type_attribute (type, TREE_READONLY (decl), TREE_THIS_VOLATILE (decl)); ! 2262: location_or_const_value_attribute (decl); ! 2263: } ! 2264: else ! 2265: type_attribute (type, 0, 0); ! 2266: } ! 2267: ! 2268: /* Output a DIE to represent a declared function (either file-scope ! 2269: or block-local) which has "external linkage" (according to ANSI-C). */ ! 2270: ! 2271: static void ! 2272: output_global_subroutine_die (arg) ! 2273: register void *arg; ! 2274: { ! 2275: register tree decl = arg; ! 2276: register tree type = TREE_TYPE (decl); ! 2277: register tree return_type = TREE_TYPE (type); ! 2278: ! 2279: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_global_subroutine); ! 2280: sibling_attribute (); ! 2281: dienum_push (); ! 2282: if (DECL_NAME (decl)) ! 2283: name_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); ! 2284: inline_attribute (decl); ! 2285: prototyped_attribute (type); ! 2286: member_attribute (DECL_CONTEXT (decl)); ! 2287: type_attribute (return_type, 0, 0); ! 2288: if (!TREE_EXTERNAL (decl)) ! 2289: { ! 2290: char func_end_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 2291: ! 2292: low_pc_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); ! 2293: sprintf (func_end_label, FUNC_END_LABEL_FMT, current_funcdef_number); ! 2294: high_pc_attribute (func_end_label); ! 2295: } ! 2296: } ! 2297: ! 2298: /* Output a DIE to represent a declared data object (either file-scope ! 2299: or block-local) which has "external linkage" (according to ANSI-C). */ ! 2300: ! 2301: static void ! 2302: output_global_variable_die (arg) ! 2303: register void *arg; ! 2304: { ! 2305: register tree decl = arg; ! 2306: register tree type = TREE_TYPE (decl); ! 2307: ! 2308: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_global_variable); ! 2309: sibling_attribute (); ! 2310: if (DECL_NAME (decl)) ! 2311: name_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); ! 2312: member_attribute (DECL_CONTEXT (decl)); ! 2313: type_attribute (type, TREE_READONLY (decl), TREE_THIS_VOLATILE (decl)); ! 2314: if (!TREE_EXTERNAL (decl)) ! 2315: location_or_const_value_attribute (decl); ! 2316: } ! 2317: ! 2318: #if 0 ! 2319: /* TAG_inline_subroutine has been retired by the UI/PLSIG. We're ! 2320: now supposed to use either TAG_subroutine or TAG_global_subroutine ! 2321: (depending on whether or not the function in question has internal ! 2322: or external linkage) and we're supposed to just put in an AT_inline ! 2323: attribute. */ ! 2324: static void ! 2325: output_inline_subroutine_die (arg) ! 2326: register void *arg; ! 2327: { ! 2328: register tree decl = arg; ! 2329: register tree type = TREE_TYPE (decl); ! 2330: register tree return_type = TREE_TYPE (type); ! 2331: ! 2332: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_inline_subroutine); ! 2333: sibling_attribute (); ! 2334: dienum_push (); ! 2335: if (DECL_NAME (decl)) ! 2336: name_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); ! 2337: prototyped_attribute (type); ! 2338: member_attribute (DECL_CONTEXT (decl)); ! 2339: type_attribute (return_type, 0, 0); ! 2340: ! 2341: /* Note: For each inline function which gets an out-of-line body ! 2342: generated for it, we want to generate AT_low_pc and AT_high_pc ! 2343: attributes here for the function's out-of-line body. ! 2344: ! 2345: Unfortunately, the decision as to whether or not to generate an ! 2346: out-of-line body for any given inline function may not be made ! 2347: until we reach the end of the containing scope for the given ! 2348: inline function (because only then will it be known if the ! 2349: function was ever even called). ! 2350: ! 2351: For this reason, the output of DIEs representing file-scope inline ! 2352: functions gets delayed until a special post-pass which happens only ! 2353: after we have reached the end of the compilation unit. Because of ! 2354: this mechanism, we can always be sure (by the time we reach here) ! 2355: that TREE_ASM_WRITTEN(decl) will correctly indicate whether or not ! 2356: there was an out-of-line body generated for this inline function. ! 2357: */ ! 2358: ! 2359: if (!TREE_EXTERNAL (decl)) ! 2360: { ! 2361: if (TREE_ASM_WRITTEN (decl)) ! 2362: { ! 2363: char func_end_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 2364: ! 2365: low_pc_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); ! 2366: sprintf (func_end_label, FUNC_END_LABEL_FMT, current_funcdef_number); ! 2367: high_pc_attribute (func_end_label); ! 2368: } ! 2369: } ! 2370: } ! 2371: #endif ! 2372: ! 2373: static void ! 2374: output_label_die (arg) ! 2375: register void *arg; ! 2376: { ! 2377: register tree decl = arg; ! 2378: register rtx insn = DECL_RTL (decl); ! 2379: ! 2380: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_label); ! 2381: sibling_attribute (); ! 2382: name_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); ! 2383: ! 2384: /* When optimization is enabled (with -O) the code in jump.c and in flow.c ! 2385: may cause insns representing one of more of the user's own labels to ! 2386: be deleted. This happens whenever it is determined that a given label ! 2387: is unreachable. ! 2388: ! 2389: In such cases, we here generate an abbreviated form of a label DIE. ! 2390: This abbreviated version does *not* have a low_pc attribute. This ! 2391: should signify to the debugger that the label has been optimized away. ! 2392: ! 2393: Note that a CODE_LABEL can get deleted either by begin converted into ! 2394: a NOTE_INSN_DELETED note, or by simply having its INSN_DELETED_P flag ! 2395: set to true. We handle both cases here. ! 2396: */ ! 2397: ! 2398: if (GET_CODE (insn) == CODE_LABEL && ! INSN_DELETED_P (insn)) ! 2399: { ! 2400: char label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 2401: ! 2402: sprintf (label, INSN_LABEL_FMT, current_funcdef_number, ! 2403: (unsigned) INSN_UID (insn)); ! 2404: low_pc_attribute (label); ! 2405: } ! 2406: } ! 2407: ! 2408: static void ! 2409: output_lexical_block_die (arg) ! 2410: register void *arg; ! 2411: { ! 2412: register tree stmt = arg; ! 2413: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 2414: char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 2415: ! 2416: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_lexical_block); ! 2417: sibling_attribute (); ! 2418: dienum_push (); ! 2419: sprintf (begin_label, BLOCK_BEGIN_LABEL_FMT, next_block_number); ! 2420: low_pc_attribute (begin_label); ! 2421: sprintf (end_label, BLOCK_END_LABEL_FMT, next_block_number); ! 2422: high_pc_attribute (end_label); ! 2423: } ! 2424: ! 2425: static void ! 2426: output_inlined_subroutine_die (arg) ! 2427: register void *arg; ! 2428: { ! 2429: register tree stmt = arg; ! 2430: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 2431: char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 2432: ! 2433: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_inlined_subroutine); ! 2434: sibling_attribute (); ! 2435: dienum_push (); ! 2436: sprintf (begin_label, BLOCK_BEGIN_LABEL_FMT, next_block_number); ! 2437: low_pc_attribute (begin_label); ! 2438: sprintf (end_label, BLOCK_END_LABEL_FMT, next_block_number); ! 2439: high_pc_attribute (end_label); ! 2440: } ! 2441: ! 2442: /* Output a DIE to represent a declared data object (either file-scope ! 2443: or block-local) which has "internal linkage" (according to ANSI-C). */ ! 2444: ! 2445: static void ! 2446: output_local_variable_die (arg) ! 2447: register void *arg; ! 2448: { ! 2449: register tree decl = arg; ! 2450: register tree type = TREE_TYPE (decl); ! 2451: ! 2452: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_local_variable); ! 2453: sibling_attribute (); ! 2454: if (DECL_NAME (decl)) ! 2455: name_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); ! 2456: member_attribute (DECL_CONTEXT (decl)); ! 2457: type_attribute (type, TREE_READONLY (decl), TREE_THIS_VOLATILE (decl)); ! 2458: location_or_const_value_attribute (decl); ! 2459: } ! 2460: ! 2461: static void ! 2462: output_member_die (arg) ! 2463: register void *arg; ! 2464: { ! 2465: register tree decl = arg; ! 2466: ! 2467: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_member); ! 2468: sibling_attribute (); ! 2469: if (DECL_NAME (decl)) ! 2470: name_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); ! 2471: member_attribute (DECL_CONTEXT (decl)); ! 2472: type_attribute (member_declared_type (decl), ! 2473: TREE_READONLY (decl), TREE_THIS_VOLATILE (decl)); ! 2474: if (DECL_BIT_FIELD_TYPE (decl)) /* If this is a bit field... */ ! 2475: { ! 2476: byte_size_attribute (decl); ! 2477: bit_size_attribute (decl); ! 2478: bit_offset_attribute (decl); ! 2479: } ! 2480: data_member_location_attribute (decl); ! 2481: } ! 2482: ! 2483: #if 0 ! 2484: /* Don't generate either pointer_type DIEs or reference_type DIEs. According ! 2485: to the 4-4-90 Dwarf draft spec (just after requirement #47): ! 2486: ! 2487: These two type entries are not currently generated by any compiler. ! 2488: Since the only way to name a pointer (or reference) type is C or C++ ! 2489: is via a "typedef", an entry with the "typedef" tag is generated ! 2490: instead. ! 2491: ! 2492: We keep this code here just in case these types of DIEs may be needed ! 2493: to represent certain things in other languages (e.g. Pascal) someday. ! 2494: */ ! 2495: ! 2496: static void ! 2497: output_pointer_type_die (arg) ! 2498: register void *arg; ! 2499: { ! 2500: register tree type = arg; ! 2501: ! 2502: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_pointer_type); ! 2503: sibling_attribute (); ! 2504: equate_type_number_to_die_number (type); ! 2505: member_attribute (TYPE_CONTEXT (type)); ! 2506: type_attribute (TREE_TYPE (type), 0, 0); ! 2507: } ! 2508: ! 2509: static void ! 2510: output_reference_type_die (arg) ! 2511: register void *arg; ! 2512: { ! 2513: register tree type = arg; ! 2514: ! 2515: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_reference_type); ! 2516: sibling_attribute (); ! 2517: equate_type_number_to_die_number (type); ! 2518: member_attribute (TYPE_CONTEXT (type)); ! 2519: type_attribute (TREE_TYPE (type), 0, 0); ! 2520: } ! 2521: #endif ! 2522: ! 2523: output_ptr_to_mbr_type_die (arg) ! 2524: register void *arg; ! 2525: { ! 2526: register tree type = arg; ! 2527: ! 2528: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_ptr_to_member_type); ! 2529: sibling_attribute (); ! 2530: equate_type_number_to_die_number (type); ! 2531: member_attribute (TYPE_CONTEXT (type)); ! 2532: containing_type_attribute (TYPE_OFFSET_BASETYPE (type)); ! 2533: type_attribute (TREE_TYPE (type), 0, 0); ! 2534: } ! 2535: ! 2536: static void ! 2537: output_compile_unit_die (arg) ! 2538: register void *arg; ! 2539: { ! 2540: register char *main_input_filename = arg; ! 2541: ! 2542: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_compile_unit); ! 2543: sibling_attribute (); ! 2544: dienum_push (); ! 2545: name_attribute (main_input_filename); ! 2546: ! 2547: { ! 2548: char producer[250]; ! 2549: ! 2550: sprintf (producer, "%s %s", language_string, version_string); ! 2551: producer_attribute (producer); ! 2552: } ! 2553: ! 2554: if (strcmp (language_string, "GNU C++") == 0) ! 2555: language_attribute (LANG_C_PLUS_PLUS); ! 2556: else if (flag_traditional) ! 2557: language_attribute (LANG_C); ! 2558: else ! 2559: language_attribute (LANG_C89); ! 2560: low_pc_attribute (TEXT_BEGIN_LABEL); ! 2561: high_pc_attribute (TEXT_END_LABEL); ! 2562: if (debug_info_level >= DINFO_LEVEL_NORMAL) ! 2563: stmt_list_attribute (LINE_BEGIN_LABEL); ! 2564: last_filename = xstrdup (main_input_filename); ! 2565: ! 2566: { ! 2567: register unsigned len = 1024; ! 2568: register char *dirname = (char *) xmalloc (len + 1); ! 2569: ! 2570: /* We don't know how much space the dirname needs, ! 2571: so try bigger and bigger buffers until it fits. */ ! 2572: while (1) ! 2573: { ! 2574: getcwd (dirname, len); /* Being conservative here. */ ! 2575: if (strlen (dirname) < len - 1) /* Being conservative here. */ ! 2576: break; ! 2577: len *= 2; ! 2578: dirname = (char *) xrealloc (dirname, len + 1); ! 2579: } ! 2580: ! 2581: comp_dir_attribute (dirname); ! 2582: free (dirname); ! 2583: } ! 2584: ! 2585: if (debug_info_level >= DINFO_LEVEL_NORMAL) ! 2586: { ! 2587: sf_names_attribute (SFNAMES_BEGIN_LABEL); ! 2588: src_info_attribute (SRCINFO_BEGIN_LABEL); ! 2589: if (debug_info_level >= DINFO_LEVEL_VERBOSE) ! 2590: mac_info_attribute (MACINFO_BEGIN_LABEL); ! 2591: } ! 2592: } ! 2593: ! 2594: static void ! 2595: output_string_type_die (arg) ! 2596: register void *arg; ! 2597: { ! 2598: register tree type = arg; ! 2599: ! 2600: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_string_type); ! 2601: sibling_attribute (); ! 2602: member_attribute (TYPE_CONTEXT (type)); ! 2603: ! 2604: /* Fudge the string length attribute for now. */ ! 2605: ! 2606: string_length_attribute ( ! 2607: TYPE_MAX_VALUE (TYPE_DOMAIN (type))); ! 2608: } ! 2609: ! 2610: static void ! 2611: output_structure_type_die (arg) ! 2612: register void *arg; ! 2613: { ! 2614: register tree type = arg; ! 2615: ! 2616: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_structure_type); ! 2617: sibling_attribute (); ! 2618: equate_type_number_to_die_number (type); ! 2619: name_attribute (type_tag (type)); ! 2620: member_attribute (TYPE_CONTEXT (type)); ! 2621: ! 2622: /* If this type has been completed, then give it a byte_size attribute ! 2623: and prepare to give a list of members. Otherwise, don't do either of ! 2624: these things. In the latter case, we will not be generating a list ! 2625: of members (since we don't have any idea what they might be for an ! 2626: incomplete type). */ ! 2627: ! 2628: if (TYPE_SIZE (type)) ! 2629: { ! 2630: dienum_push (); ! 2631: byte_size_attribute (type); ! 2632: } ! 2633: } ! 2634: ! 2635: /* Output a DIE to represent a declared function (either file-scope ! 2636: or block-local) which has "internal linkage" (according to ANSI-C). */ ! 2637: ! 2638: static void ! 2639: output_local_subroutine_die (arg) ! 2640: register void *arg; ! 2641: { ! 2642: register tree decl = arg; ! 2643: register tree type = TREE_TYPE (decl); ! 2644: register tree return_type = TREE_TYPE (type); ! 2645: char func_end_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 2646: ! 2647: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_subroutine); ! 2648: sibling_attribute (); ! 2649: dienum_push (); ! 2650: if (DECL_NAME (decl)) ! 2651: name_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); ! 2652: inline_attribute (decl); ! 2653: prototyped_attribute (type); ! 2654: member_attribute (DECL_CONTEXT (decl)); ! 2655: type_attribute (return_type, 0, 0); ! 2656: ! 2657: /* Avoid getting screwed up in cases where a function was declared static ! 2658: but where no definition was ever given for it. */ ! 2659: ! 2660: if (TREE_ASM_WRITTEN (decl)) ! 2661: { ! 2662: low_pc_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); ! 2663: sprintf (func_end_label, FUNC_END_LABEL_FMT, current_funcdef_number); ! 2664: high_pc_attribute (func_end_label); ! 2665: } ! 2666: } ! 2667: ! 2668: static void ! 2669: output_subroutine_type_die (arg) ! 2670: register void *arg; ! 2671: { ! 2672: register tree type = arg; ! 2673: register tree return_type = TREE_TYPE (type); ! 2674: ! 2675: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_subroutine_type); ! 2676: sibling_attribute (); ! 2677: dienum_push (); ! 2678: equate_type_number_to_die_number (type); ! 2679: prototyped_attribute (type); ! 2680: member_attribute (TYPE_CONTEXT (type)); ! 2681: type_attribute (return_type, 0, 0); ! 2682: } ! 2683: ! 2684: static void ! 2685: output_typedef_die (arg) ! 2686: register void *arg; ! 2687: { ! 2688: register tree decl = arg; ! 2689: register tree type = TREE_TYPE (decl); ! 2690: ! 2691: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_typedef); ! 2692: sibling_attribute (); ! 2693: if (DECL_NAME (decl)) ! 2694: name_attribute (IDENTIFIER_POINTER (DECL_NAME (decl))); ! 2695: member_attribute (DECL_CONTEXT (decl)); ! 2696: type_attribute (type, TREE_READONLY (decl), TREE_THIS_VOLATILE (decl)); ! 2697: } ! 2698: ! 2699: static void ! 2700: output_union_type_die (arg) ! 2701: register void *arg; ! 2702: { ! 2703: register tree type = arg; ! 2704: ! 2705: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_union_type); ! 2706: sibling_attribute (); ! 2707: equate_type_number_to_die_number (type); ! 2708: name_attribute (type_tag (type)); ! 2709: member_attribute (TYPE_CONTEXT (type)); ! 2710: ! 2711: /* If this type has been completed, then give it a byte_size attribute ! 2712: and prepare to give a list of members. Otherwise, don't do either of ! 2713: these things. In the latter case, we will not be generating a list ! 2714: of members (since we don't have any idea what they might be for an ! 2715: incomplete type). */ ! 2716: ! 2717: if (TYPE_SIZE (type)) ! 2718: { ! 2719: dienum_push (); ! 2720: byte_size_attribute (type); ! 2721: } ! 2722: } ! 2723: ! 2724: /* Generate a special type of DIE used as a stand-in for a trailing ellipsis ! 2725: at the end of an (ANSI prototyped) formal parameters list. */ ! 2726: ! 2727: static void ! 2728: output_unspecified_parameters_die (arg) ! 2729: register void *arg; ! 2730: { ! 2731: register tree decl_or_type = arg; ! 2732: ! 2733: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_unspecified_parameters); ! 2734: sibling_attribute (); ! 2735: ! 2736: /* This kludge is here only for the sake of being compatible with what ! 2737: the USL CI5 C compiler does. The specification of Dwarf Version 1 ! 2738: doesn't say that TAG_unspecified_parameters DIEs should contain any ! 2739: attributes other than the AT_sibling attribute, but they are certainly ! 2740: allowed to contain additional attributes, and the CI5 compiler ! 2741: generates AT_name, AT_fund_type, and AT_location attributes within ! 2742: TAG_unspecified_parameters DIEs which appear in the child lists for ! 2743: DIEs representing function definitions, so we do likewise here. */ ! 2744: ! 2745: if (TREE_CODE (decl_or_type) == FUNCTION_DECL && DECL_INITIAL (decl_or_type)) ! 2746: { ! 2747: name_attribute ("..."); ! 2748: fund_type_attribute (FT_pointer); ! 2749: /* location_attribute (?); */ ! 2750: } ! 2751: } ! 2752: ! 2753: static void ! 2754: output_padded_null_die (arg) ! 2755: register void *arg; ! 2756: { ! 2757: ASM_OUTPUT_ALIGN (asm_out_file, 2); /* 2**2 == 4 */ ! 2758: } ! 2759: ! 2760: /*************************** end of DIEs *********************************/ ! 2761: ! 2762: /* Generate some type of DIE. This routine generates the generic outer ! 2763: wrapper stuff which goes around all types of DIE's (regardless of their ! 2764: TAGs. All forms of DIEs start with a DIE-specific label, followed by a ! 2765: DIE-length word, followed by the guts of the DIE itself. After the guts ! 2766: of the DIE, there must always be a terminator label for the DIE. */ ! 2767: ! 2768: static void ! 2769: output_die (die_specific_output_function, param) ! 2770: register void (*die_specific_output_function)(); ! 2771: register void *param; ! 2772: { ! 2773: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 2774: char end_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 2775: ! 2776: current_dienum = NEXT_DIE_NUM; ! 2777: NEXT_DIE_NUM = next_unused_dienum; ! 2778: ! 2779: sprintf (begin_label, DIE_BEGIN_LABEL_FMT, current_dienum); ! 2780: sprintf (end_label, DIE_END_LABEL_FMT, current_dienum); ! 2781: ! 2782: /* Write a label which will act as the name for the start of this DIE. */ ! 2783: ! 2784: ASM_OUTPUT_LABEL (asm_out_file, begin_label); ! 2785: ! 2786: /* Write the DIE-length word. */ ! 2787: ! 2788: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, end_label, begin_label); ! 2789: ! 2790: /* Fill in the guts of the DIE. */ ! 2791: ! 2792: next_unused_dienum++; ! 2793: die_specific_output_function (param); ! 2794: ! 2795: /* Write a label which will act as the name for the end of this DIE. */ ! 2796: ! 2797: ASM_OUTPUT_LABEL (asm_out_file, end_label); ! 2798: } ! 2799: ! 2800: static void ! 2801: end_sibling_chain () ! 2802: { ! 2803: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 2804: ! 2805: current_dienum = NEXT_DIE_NUM; ! 2806: NEXT_DIE_NUM = next_unused_dienum; ! 2807: ! 2808: sprintf (begin_label, DIE_BEGIN_LABEL_FMT, current_dienum); ! 2809: ! 2810: /* Write a label which will act as the name for the start of this DIE. */ ! 2811: ! 2812: ASM_OUTPUT_LABEL (asm_out_file, begin_label); ! 2813: ! 2814: /* Write the DIE-length word. */ ! 2815: ! 2816: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 4); ! 2817: ! 2818: dienum_pop (); ! 2819: } ! 2820: ! 2821: /* Generate a list of nameless TAG_formal_parameter DIEs (and perhaps a ! 2822: TAG_unspecified_parameters DIE) to represent the types of the formal ! 2823: parameters as specified in some function type specification (except ! 2824: for those which appear as part of a function *definition*). ! 2825: ! 2826: Note that we must be careful here to output all of the parameter DIEs ! 2827: *before* we output any DIEs needed to represent the types of the formal ! 2828: parameters. This keeps svr4 SDB happy because it (incorrectly) thinks ! 2829: that the first non-parameter DIE it sees ends the formal parameter list. ! 2830: */ ! 2831: ! 2832: static void ! 2833: output_formal_types (function_or_method_type) ! 2834: register tree function_or_method_type; ! 2835: { ! 2836: register tree link; ! 2837: register tree formal_type; ! 2838: register tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type); ! 2839: ! 2840: /* In the case where we are generating a formal types list for a C++ ! 2841: non-static member function type, skip over the first thing on the ! 2842: TYPE_ARG_TYPES list because it only represents the type of the ! 2843: hidden `this pointer'. The debugger should be able to figure ! 2844: out (without being explicitly told) that this non-static member ! 2845: function type takes a `this pointer' and should be able to figure ! 2846: what the type of that hidden parameter is from the AT_member ! 2847: attribute of the parent TAG_subroutine_type DIE. */ ! 2848: ! 2849: if (TREE_CODE (function_or_method_type) == METHOD_TYPE) ! 2850: first_parm_type = TREE_CHAIN (first_parm_type); ! 2851: ! 2852: /* Make our first pass over the list of formal parameter types and output ! 2853: a TAG_formal_parameter DIE for each one. */ ! 2854: ! 2855: for (link = first_parm_type; link; link = TREE_CHAIN (link)) ! 2856: { ! 2857: formal_type = TREE_VALUE (link); ! 2858: if (formal_type == void_type_node) ! 2859: break; ! 2860: ! 2861: /* Output a (nameless) DIE to represent the formal parameter itself. */ ! 2862: ! 2863: output_die (output_formal_parameter_die, formal_type); ! 2864: } ! 2865: ! 2866: /* If this function type has an ellipsis, add a TAG_unspecified_parameters ! 2867: DIE to the end of the parameter list. */ ! 2868: ! 2869: if (formal_type != void_type_node) ! 2870: output_die (output_unspecified_parameters_die, function_or_method_type); ! 2871: ! 2872: /* Make our second (and final) pass over the list of formal parameter types ! 2873: and output DIEs to represent those types (as necessary). */ ! 2874: ! 2875: for (link = TYPE_ARG_TYPES (function_or_method_type); ! 2876: link; ! 2877: link = TREE_CHAIN (link)) ! 2878: { ! 2879: formal_type = TREE_VALUE (link); ! 2880: if (formal_type == void_type_node) ! 2881: break; ! 2882: ! 2883: output_type (formal_type, function_or_method_type); ! 2884: } ! 2885: } ! 2886: ! 2887: /* Remember a type in the pending_types_list. */ ! 2888: ! 2889: static void ! 2890: pend_type (type) ! 2891: register tree type; ! 2892: { ! 2893: if (pending_types == pending_types_allocated) ! 2894: { ! 2895: pending_types_allocated += PENDING_TYPES_INCREMENT; ! 2896: pending_types_list ! 2897: = (tree *) xrealloc (pending_types_list, ! 2898: sizeof (tree) * pending_types_allocated); ! 2899: } ! 2900: pending_types_list[pending_types++] = type; ! 2901: ! 2902: /* Mark the pending type as having been output already (even though ! 2903: it hasn't been). This prevents the type from being added to the ! 2904: pending_types_list more than once. */ ! 2905: ! 2906: TREE_ASM_WRITTEN (type) = 1; ! 2907: } ! 2908: ! 2909: /* Return non-zero if it is legitimate to output DIEs to represent a ! 2910: given type while we are generating the list of child DIEs for some ! 2911: DIE associated with a given scope. ! 2912: ! 2913: This function returns non-zero if *either* of the following two conditions ! 2914: is satisfied: ! 2915: ! 2916: o the type actually belongs to the given scope (as evidenced ! 2917: by its TYPE_CONTEXT value), or ! 2918: ! 2919: o the type is anonymous, and the `scope' in question is *not* ! 2920: a RECORD_TYPE or UNION_TYPE. ! 2921: ! 2922: In theory, we should be able to generate DIEs for anonymous types ! 2923: *anywhere* (since the scope of an anonymous type is irrelevant) ! 2924: however svr4 SDB doesn't want to see other type DIEs within the ! 2925: lists of child DIEs for a TAG_structure_type or TAG_union_type DIE. ! 2926: ! 2927: Note that TYPE_CONTEXT(type) may be NULL (to indicate global scope) ! 2928: or it may point to a BLOCK node (for types local to a block), or to a ! 2929: FUNCTION_DECL node (for types local to the heading of some function ! 2930: definition), or to a FUNCTION_TYPE node (for types local to the ! 2931: prototyped parameter list of a function type specification), or to a ! 2932: RECORD_TYPE or UNION_TYPE node (in the case of C++ nested types). ! 2933: ! 2934: The `scope' parameter should likewise be NULL or should point to a ! 2935: BLOCK node, a FUNCTION_DECL node, a FUNCTION_TYPE node, a RECORD_TYPE ! 2936: node, or a UNION_TYPE node. ! 2937: ! 2938: This function is used only for deciding when to "pend" and when to ! 2939: "un-pend" types to/from the pending_types_list. ! 2940: ! 2941: Note that we sometimes make use of this "type pending" feature in a ! 2942: rather twisted way to temporarily delay the production of DIEs for the ! 2943: types of formal parameters. (We do this just to make svr4 SDB happy.) ! 2944: It order to delay the production of DIEs representing types of formal ! 2945: parameters, callers of this function supply `fake_containing_scope' as ! 2946: the `scope' parameter to this function. Given that fake_containing_scope ! 2947: is *not* the containing scope for *any* other type, the desired effect ! 2948: is achieved, i.e. output of DIEs representing types is temporarily ! 2949: suspended, and any type DIEs which would have been output otherwise ! 2950: are instead placed onto the pending_types_list. Later on, we can force ! 2951: these (temporarily pended) types to be output simply by calling ! 2952: `output_pending_types_for_scope' with an actual argument equal to the ! 2953: true scope of the types we temporarily pended. ! 2954: */ ! 2955: ! 2956: static int ! 2957: type_ok_for_scope (type, scope) ! 2958: register tree type; ! 2959: register tree scope; ! 2960: { ! 2961: return (TYPE_CONTEXT (type) == scope ! 2962: || (TYPE_NAME (type) == NULL ! 2963: && TREE_CODE (scope) != RECORD_TYPE ! 2964: && TREE_CODE (scope) != UNION_TYPE)); ! 2965: } ! 2966: ! 2967: /* Output any pending types (from the pending_types list) which we can output ! 2968: now (given the limitations of the scope that we are working on now). ! 2969: ! 2970: For each type output, remove the given type from the pending_types_list ! 2971: *before* we try to output it. ! 2972: ! 2973: Note that we have to process the list in beginning-to-end order, ! 2974: because the call made here to output_type may cause yet more types ! 2975: to be added to the end of the list, and we may have to output some ! 2976: of them too. ! 2977: */ ! 2978: ! 2979: static void ! 2980: output_pending_types_for_scope (containing_scope) ! 2981: register tree containing_scope; ! 2982: { ! 2983: register unsigned i; ! 2984: ! 2985: for (i = 0; i < pending_types; ) ! 2986: { ! 2987: register tree type = pending_types_list[i]; ! 2988: ! 2989: if (type_ok_for_scope (type, containing_scope)) ! 2990: { ! 2991: register tree *mover; ! 2992: register tree *limit; ! 2993: ! 2994: pending_types--; ! 2995: limit = &pending_types_list[pending_types]; ! 2996: for (mover = &pending_types_list[i]; mover < limit; mover++) ! 2997: *mover = *(mover+1); ! 2998: ! 2999: /* Un-mark the type as having been output already (because it ! 3000: hasn't been, really). Then call output_type to generate a ! 3001: Dwarf representation of it. */ ! 3002: ! 3003: TREE_ASM_WRITTEN (type) = 0; ! 3004: output_type (type, containing_scope); ! 3005: ! 3006: /* Don't increment the loop counter in this case because we ! 3007: have shifted all of the subsequent pending types down one ! 3008: element in the pending_types_list array. */ ! 3009: } ! 3010: else ! 3011: i++; ! 3012: } ! 3013: } ! 3014: ! 3015: static void ! 3016: output_type (type, containing_scope) ! 3017: register tree type; ! 3018: register tree containing_scope; ! 3019: { ! 3020: if (type == 0 || type == error_mark_node) ! 3021: return; ! 3022: ! 3023: /* We are going to output a DIE to represent the unqualified version of ! 3024: of this type (i.e. without any const or volatile qualifiers) so get ! 3025: the main variant (i.e. the unqualified version) of this type now. */ ! 3026: ! 3027: type = TYPE_MAIN_VARIANT (type); ! 3028: ! 3029: if (TREE_ASM_WRITTEN (type)) ! 3030: return; ! 3031: ! 3032: /* Don't generate any DIEs for this type now unless it is OK to do so ! 3033: (based upon what `type_ok_for_scope' tells us). */ ! 3034: ! 3035: if (! type_ok_for_scope (type, containing_scope)) ! 3036: { ! 3037: pend_type (type); ! 3038: return; ! 3039: } ! 3040: ! 3041: switch (TREE_CODE (type)) ! 3042: { ! 3043: case ERROR_MARK: ! 3044: break; ! 3045: ! 3046: case POINTER_TYPE: ! 3047: case REFERENCE_TYPE: ! 3048: /* For these types, all that is required is that we output a DIE ! 3049: (or a set of DIEs) to represent that "basis" type. */ ! 3050: output_type (TREE_TYPE (type), containing_scope); ! 3051: break; ! 3052: ! 3053: case OFFSET_TYPE: ! 3054: /* This code is used for C++ pointer-to-data-member types. */ ! 3055: /* Output a description of the relevant class type. */ ! 3056: output_type (TYPE_OFFSET_BASETYPE (type), containing_scope); ! 3057: /* Output a description of the type of the object pointed to. */ ! 3058: output_type (TREE_TYPE (type), containing_scope); ! 3059: /* Now output a DIE to represent this pointer-to-data-member type ! 3060: itself. */ ! 3061: output_die (output_ptr_to_mbr_type_die, type); ! 3062: break; ! 3063: ! 3064: case SET_TYPE: ! 3065: output_type (TREE_TYPE (type), containing_scope); ! 3066: output_die (output_set_type_die, type); ! 3067: break; ! 3068: ! 3069: case FILE_TYPE: ! 3070: output_type (TREE_TYPE (type), containing_scope); ! 3071: abort (); /* No way to reprsent these in Dwarf yet! */ ! 3072: break; ! 3073: ! 3074: case STRING_TYPE: ! 3075: output_type (TREE_TYPE (type), containing_scope); ! 3076: output_die (output_string_type_die, type); ! 3077: break; ! 3078: ! 3079: case FUNCTION_TYPE: ! 3080: /* Force out return type (in case it wasn't forced out already). */ ! 3081: output_type (TREE_TYPE (type), containing_scope); ! 3082: output_die (output_subroutine_type_die, type); ! 3083: output_formal_types (type); ! 3084: end_sibling_chain (); ! 3085: break; ! 3086: ! 3087: case METHOD_TYPE: ! 3088: /* Force out return type (in case it wasn't forced out already). */ ! 3089: output_type (TREE_TYPE (type), containing_scope); ! 3090: output_die (output_subroutine_type_die, type); ! 3091: output_formal_types (type); ! 3092: end_sibling_chain (); ! 3093: break; ! 3094: ! 3095: case ARRAY_TYPE: ! 3096: { ! 3097: register tree element_type; ! 3098: ! 3099: element_type = TREE_TYPE (type); ! 3100: while (TREE_CODE (element_type) == ARRAY_TYPE) ! 3101: element_type = TREE_TYPE (element_type); ! 3102: ! 3103: output_type (element_type, containing_scope); ! 3104: output_die (output_array_type_die, type); ! 3105: } ! 3106: break; ! 3107: ! 3108: case ENUMERAL_TYPE: ! 3109: case RECORD_TYPE: ! 3110: case UNION_TYPE: ! 3111: ! 3112: /* For a non-file-scope tagged type, we can always go ahead and ! 3113: output a Dwarf description of this type right now, even if ! 3114: the type in question is still incomplete, because if this ! 3115: local type *was* ever completed anywhere within its scope, ! 3116: that complete definition would already have been attached to ! 3117: this RECORD_TYPE, UNION_TYPE or ENUMERAL_TYPE node by the ! 3118: time we reach this point. That's true because of the way the ! 3119: front-end does its processing of file-scope declarations (of ! 3120: functions and class types) within which other types might be ! 3121: nested. The C and C++ front-ends always gobble up such "local ! 3122: scope" things en-mass before they try to output *any* debugging ! 3123: information for any of the stuff contained inside them and thus, ! 3124: we get the benefit here of what is (in effect) a pre-resolution ! 3125: of forward references to tagged types in local scopes. ! 3126: ! 3127: Note however that for file-scope tagged types we cannot assume ! 3128: that such pre-resolution of forward references has taken place. ! 3129: A given file-scope tagged type may appear to be incomplete when ! 3130: we reach this point, but it may yet be given a full definition ! 3131: (at file-scope) later on during compilation. In order to avoid ! 3132: generating a premature (and possibly incorrect) set of Dwarf ! 3133: DIEs for such (as yet incomplete) file-scope tagged types, we ! 3134: generate nothing at all for as-yet incomplete file-scope tagged ! 3135: types here unless we are making our special "finalization" pass ! 3136: for file-scope things at the very end of compilation. At that ! 3137: time, we will certainly know as much about each file-scope tagged ! 3138: type as we are ever going to know, so at that point in time, we ! 3139: can safely generate correct Dwarf descriptions for these file- ! 3140: scope tagged types. ! 3141: */ ! 3142: ! 3143: if (TYPE_SIZE (type) == 0 && TYPE_CONTEXT (type) == NULL && !finalizing) ! 3144: return; /* EARLY EXIT! Avoid setting TREE_ASM_WRITTEN. */ ! 3145: ! 3146: /* Prevent infinite recursion in cases where the type of some ! 3147: member of this type is expressed in terms of this type itself. */ ! 3148: ! 3149: TREE_ASM_WRITTEN (type) = 1; ! 3150: ! 3151: /* Output a DIE to represent the tagged type itself. */ ! 3152: ! 3153: switch (TREE_CODE (type)) ! 3154: { ! 3155: case ENUMERAL_TYPE: ! 3156: output_die (output_enumeration_type_die, type); ! 3157: return; /* a special case -- nothing left to do so just return */ ! 3158: ! 3159: case RECORD_TYPE: ! 3160: output_die (output_structure_type_die, type); ! 3161: break; ! 3162: ! 3163: case UNION_TYPE: ! 3164: output_die (output_union_type_die, type); ! 3165: break; ! 3166: } ! 3167: ! 3168: /* If this is not an incomplete type, output descriptions of ! 3169: each of its members. ! 3170: ! 3171: Note that as we output the DIEs necessary to represent the ! 3172: members of this record or union type, we will also be trying ! 3173: to output DIEs to represent the *types* of those members. ! 3174: However the `output_type' function (above) will specifically ! 3175: avoid generating type DIEs for member types *within* the list ! 3176: of member DIEs for this (containing) type execpt for those ! 3177: types (of members) which are explicitly marked as also being ! 3178: members of this (containing) type themselves. The g++ front- ! 3179: end can force any given type to be treated as a member of some ! 3180: other (containing) type by setting the TYPE_CONTEXT of the ! 3181: given (member) type to point to the TREE node representing the ! 3182: appropriate (containing) type. ! 3183: */ ! 3184: ! 3185: if (TYPE_SIZE (type)) ! 3186: { ! 3187: register tree member; ! 3188: ! 3189: /* First output info about the data members and type members. */ ! 3190: ! 3191: for (member = TYPE_FIELDS (type); ! 3192: member; ! 3193: member = TREE_CHAIN (member)) ! 3194: output_decl (member, type); ! 3195: ! 3196: /* Now output info about the function members (if any). */ ! 3197: ! 3198: if (TYPE_METHODS (type)) ! 3199: for (member = TREE_VEC_ELT (TYPE_METHODS (type), 0); ! 3200: member; ! 3201: member = TREE_CHAIN (member)) ! 3202: output_decl (member, type); ! 3203: ! 3204: end_sibling_chain (); /* Terminate member chain. */ ! 3205: } ! 3206: ! 3207: break; ! 3208: ! 3209: case VOID_TYPE: ! 3210: case INTEGER_TYPE: ! 3211: case REAL_TYPE: ! 3212: case COMPLEX_TYPE: ! 3213: case BOOLEAN_TYPE: ! 3214: case CHAR_TYPE: ! 3215: break; /* No DIEs needed for fundamental types. */ ! 3216: ! 3217: case LANG_TYPE: /* No Dwarf representation currently defined. */ ! 3218: break; ! 3219: ! 3220: default: ! 3221: abort (); ! 3222: } ! 3223: ! 3224: TREE_ASM_WRITTEN (type) = 1; ! 3225: } ! 3226: ! 3227: /* Output a TAG_lexical_block DIE followed by DIEs to represent all of ! 3228: the things which are local to the given block. */ ! 3229: ! 3230: static void ! 3231: output_block (stmt) ! 3232: register tree stmt; ! 3233: { ! 3234: register int have_significant_locals = 0; ! 3235: ! 3236: /* Ignore blocks never really used to make RTL. */ ! 3237: ! 3238: if (! stmt || ! TREE_USED (stmt)) ! 3239: return; ! 3240: ! 3241: /* Determine if this block contains any "significant" local declarations ! 3242: which we need to output DIEs for. */ ! 3243: ! 3244: if (BLOCK_INLINE_FUNCTION (stmt)) ! 3245: /* The outer scopes for inlinings *must* always be represented. */ ! 3246: have_significant_locals = 1; ! 3247: else ! 3248: if (debug_info_level > DINFO_LEVEL_TERSE) ! 3249: have_significant_locals = (BLOCK_VARS (stmt) != NULL); ! 3250: else ! 3251: { ! 3252: register tree decl; ! 3253: ! 3254: for (decl = BLOCK_VARS (stmt); decl; decl = TREE_CHAIN (decl)) ! 3255: if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl)) ! 3256: { ! 3257: have_significant_locals = 1; ! 3258: break; ! 3259: } ! 3260: } ! 3261: ! 3262: /* It would be a waste of space to generate a Dwarf TAG_lexical_block ! 3263: DIE for any block which contains no significant local declarations ! 3264: at all. Rather, in such cases we just call `output_decls_for_scope' ! 3265: so that any needed Dwarf info for any sub-blocks will get properly ! 3266: generated. Note that in terse mode, our definition of what constitutes ! 3267: a "significant" local declaration gets restricted to include only ! 3268: inlined function instances and local (nested) function definitions. */ ! 3269: ! 3270: if (have_significant_locals) ! 3271: { ! 3272: output_die (BLOCK_INLINE_FUNCTION (stmt) ! 3273: ? output_inlined_subroutine_die ! 3274: : output_lexical_block_die, ! 3275: stmt); ! 3276: output_decls_for_scope (stmt); ! 3277: end_sibling_chain (); ! 3278: } ! 3279: else ! 3280: output_decls_for_scope (stmt); ! 3281: } ! 3282: ! 3283: /* Output all of the decls declared within a given scope (also called ! 3284: a `binding contour') and (recursively) all of it's sub-blocks. */ ! 3285: ! 3286: static void ! 3287: output_decls_for_scope (stmt) ! 3288: register tree stmt; ! 3289: { ! 3290: /* Ignore blocks never really used to make RTL. */ ! 3291: ! 3292: if (! stmt || ! TREE_USED (stmt)) ! 3293: return; ! 3294: ! 3295: next_block_number++; ! 3296: ! 3297: /* Output the DIEs to represent all of the data objects, functions, ! 3298: typedefs, and tagged types declared directly within this block ! 3299: but not within any nested sub-blocks. */ ! 3300: ! 3301: { ! 3302: register tree decl; ! 3303: ! 3304: for (decl = BLOCK_VARS (stmt); decl; decl = TREE_CHAIN (decl)) ! 3305: output_decl (decl, stmt); ! 3306: } ! 3307: ! 3308: output_pending_types_for_scope (stmt); ! 3309: ! 3310: /* Output the DIEs to represent all sub-blocks (and the items declared ! 3311: therein) of this block. */ ! 3312: ! 3313: { ! 3314: register tree subblocks; ! 3315: ! 3316: for (subblocks = BLOCK_SUBBLOCKS (stmt); ! 3317: subblocks; ! 3318: subblocks = BLOCK_CHAIN (subblocks)) ! 3319: output_block (subblocks); ! 3320: } ! 3321: } ! 3322: ! 3323: /* Output Dwarf .debug information for a decl described by DECL. */ ! 3324: ! 3325: static void ! 3326: output_decl (decl, containing_scope) ! 3327: register tree decl; ! 3328: register tree containing_scope; ! 3329: { ! 3330: switch (TREE_CODE (decl)) ! 3331: { ! 3332: case ERROR_MARK: ! 3333: break; ! 3334: ! 3335: case CONST_DECL: ! 3336: /* The individual enumerators of an enum type get output when we ! 3337: output the Dwarf representation of the relevant enum type itself. */ ! 3338: break; ! 3339: ! 3340: case FUNCTION_DECL: ! 3341: /* If we are in terse mode, don't output any DIEs to represent ! 3342: mere external function declarations. */ ! 3343: ! 3344: if (TREE_EXTERNAL (decl) && debug_info_level <= DINFO_LEVEL_TERSE) ! 3345: break; ! 3346: ! 3347: /* Before we describe the FUNCTION_DECL itself, make sure that we ! 3348: have described its return type. */ ! 3349: ! 3350: output_type (TREE_TYPE (TREE_TYPE (decl)), containing_scope); ! 3351: ! 3352: /* If the following DIE will represent a function definition for a ! 3353: function with "extern" linkage, output a special "pubnames" DIE ! 3354: label just ahead of the actual DIE. A reference to this label ! 3355: was already generated in the .debug_pubnames section sub-entry ! 3356: for this function definition. */ ! 3357: ! 3358: if (TREE_PUBLIC (decl)) ! 3359: { ! 3360: char label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 3361: ! 3362: sprintf (label, PUB_DIE_LABEL_FMT, next_pubname_number++); ! 3363: ASM_OUTPUT_LABEL (asm_out_file, label); ! 3364: } ! 3365: ! 3366: /* Now output a DIE to represent the function itself. */ ! 3367: ! 3368: output_die (TREE_PUBLIC (decl) || TREE_EXTERNAL (decl) ! 3369: ? output_global_subroutine_die ! 3370: : output_local_subroutine_die, ! 3371: decl); ! 3372: ! 3373: /* Now output descriptions of the arguments for this function. ! 3374: This gets (unnecessarily?) complex because of the fact that ! 3375: the DECL_ARGUMENT list for a FUNCTION_DECL doesn't indicate ! 3376: cases where there was a trailing `...' at the end of the formal ! 3377: parameter list. In order to find out if there was a trailing ! 3378: ellipsis or not, we must instead look at the type associated ! 3379: with the FUNCTION_DECL. This will be a node of type FUNCTION_TYPE. ! 3380: If the chain of type nodes hanging off of this FUNCTION_TYPE node ! 3381: ends with a void_type_node then there should *not* be an ellipsis ! 3382: at the end. */ ! 3383: ! 3384: /* In the case where we are describing an external function, all ! 3385: we need to do here (and all we *can* do here) is to describe ! 3386: the *types* of its formal parameters. */ ! 3387: ! 3388: if (TREE_EXTERNAL (decl)) ! 3389: output_formal_types (TREE_TYPE (decl)); ! 3390: else ! 3391: { ! 3392: register tree arg_decls = DECL_ARGUMENTS (decl); ! 3393: ! 3394: /* In the case where the FUNCTION_DECL represents a C++ non-static ! 3395: member function, skip over the first thing on the DECL_ARGUMENTS ! 3396: chain. It only represents the hidden `this pointer' parameter ! 3397: and the debugger should know implicitly that non-static member ! 3398: functions have such a thing, and should be able to figure out ! 3399: exactly what the type of each `this pointer' is (from the ! 3400: AT_member attribute of the parent TAG_subroutine DIE) without ! 3401: being explicitly told. */ ! 3402: ! 3403: if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE) ! 3404: arg_decls = TREE_CHAIN (arg_decls); ! 3405: ! 3406: { ! 3407: register tree last_arg; ! 3408: ! 3409: last_arg = (arg_decls && TREE_CODE (arg_decls) != ERROR_MARK) ! 3410: ? tree_last (arg_decls) ! 3411: : NULL; ! 3412: ! 3413: /* Generate DIEs to represent all known formal parameters, but ! 3414: don't do it if this looks like a varargs function. A given ! 3415: function is considered to be a varargs function if (and only ! 3416: if) its last named argument is named `__builtin_va_alist'. */ ! 3417: ! 3418: if (! last_arg ! 3419: || ! DECL_NAME (last_arg) ! 3420: || strcmp (IDENTIFIER_POINTER (DECL_NAME (last_arg)), ! 3421: "__builtin_va_alist")) ! 3422: { ! 3423: register tree parm; ! 3424: ! 3425: /* WARNING! Kludge zone ahead! Here we have a special ! 3426: hack for svr4 SDB compatability. Instead of passing the ! 3427: current FUNCTION_DECL node as the second parameter (i.e. ! 3428: the `containing_scope' parameter) to `output_decl' (as ! 3429: we ought to) we instead pass a pointer to our own private ! 3430: fake_containing_scope node. That node is a RECORD_TYPE ! 3431: node which NO OTHER TYPE may ever actually be a member of. ! 3432: ! 3433: This pointer will ultimately get passed into `output_type' ! 3434: as its `containing_scope' parameter. `Output_type' will ! 3435: then perform its part in the hack... i.e. it will pend ! 3436: the type of the formal parameter onto the pending_types ! 3437: list. Later on, when we are done generating the whole ! 3438: sequence of formal parameter DIEs for this function ! 3439: definition, we will un-pend all previously pended types ! 3440: of formal parameters for this function definition. ! 3441: ! 3442: This whole kludge prevents any type DIEs from being ! 3443: mixed in with the formal parameter DIEs. That's good ! 3444: because svr4 SDB believes that the list of formal ! 3445: parameter DIEs for a function ends wherever the first ! 3446: non-formal-parameter DIE appears. Thus, we have to ! 3447: keep the formal parameter DIEs segregated. They must ! 3448: all appear (consecutively) at the start of the list of ! 3449: children for the DIE representing the function definition. ! 3450: Then (and only then) may we output any additional DIEs ! 3451: needed to represent the types of these formal parameters. ! 3452: */ ! 3453: ! 3454: for (parm = arg_decls; parm; parm = TREE_CHAIN (parm)) ! 3455: if (TREE_CODE (parm) == PARM_DECL) ! 3456: output_decl (parm, fake_containing_scope); ! 3457: ! 3458: /* Now that we have finished generating all of the DIEs to ! 3459: represent the formal parameters themselves, force out ! 3460: any DIEs needed to represent their types. We do this ! 3461: simply by un-pending all previously pended types which ! 3462: can legitimately go into the chain of children DIEs for ! 3463: the current FUNCTION_DECL. */ ! 3464: ! 3465: output_pending_types_for_scope (decl); ! 3466: } ! 3467: } ! 3468: ! 3469: /* Now try to decide if we should put an ellipsis at the end. */ ! 3470: ! 3471: { ! 3472: register int has_ellipsis = TRUE; /* default assumption */ ! 3473: register tree fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl)); ! 3474: ! 3475: if (fn_arg_types) ! 3476: { ! 3477: /* This function declaration/definition was prototyped. */ ! 3478: ! 3479: /* If the list of formal argument types ends with a ! 3480: void_type_node, then the formals list did *not* end ! 3481: with an ellipsis. */ ! 3482: ! 3483: if (TREE_VALUE (tree_last (fn_arg_types)) == void_type_node) ! 3484: has_ellipsis = FALSE; ! 3485: } ! 3486: else ! 3487: { ! 3488: /* This function declaration/definition was not prototyped. */ ! 3489: ! 3490: /* Note that all non-prototyped function *declarations* are ! 3491: assumed to represent varargs functions (until proven ! 3492: otherwise). */ ! 3493: ! 3494: if (DECL_INITIAL (decl)) /* if this is a func definition */ ! 3495: { ! 3496: if (!arg_decls) ! 3497: has_ellipsis = FALSE; /* no args == (void) */ ! 3498: else ! 3499: { ! 3500: /* For a non-prototyped function definition which ! 3501: declares one or more formal parameters, if the name ! 3502: of the first formal parameter is *not* ! 3503: __builtin_va_alist then we must assume that this ! 3504: is *not* a varargs function. */ ! 3505: ! 3506: if (DECL_NAME (arg_decls) ! 3507: && strcmp (IDENTIFIER_POINTER (DECL_NAME (arg_decls)), ! 3508: "__builtin_va_alist")) ! 3509: has_ellipsis = FALSE; ! 3510: } ! 3511: } ! 3512: } ! 3513: ! 3514: if (has_ellipsis) ! 3515: output_die (output_unspecified_parameters_die, decl); ! 3516: } ! 3517: } ! 3518: ! 3519: /* Output Dwarf info for all of the stuff within the body of the ! 3520: function (if it has one - it may be just a declaration). */ ! 3521: ! 3522: { ! 3523: register tree outer_scope = DECL_INITIAL (decl); ! 3524: ! 3525: if (outer_scope && TREE_CODE (outer_scope) != ERROR_MARK) ! 3526: { ! 3527: /* Note that here, `outer_scope' is a pointer to the outermost ! 3528: BLOCK node created to represent the body of a function. ! 3529: This outermost BLOCK actually represents the outermost ! 3530: binding contour for the function, i.e. the contour in which ! 3531: the function's formal parameters get declared. Just within ! 3532: this contour, there will be another (nested) BLOCK which ! 3533: represents the function's outermost block. We don't want ! 3534: to generate a lexical_block DIE to represent the outermost ! 3535: block of a function body, because that is not really an ! 3536: independent scope according to ANSI C rules. Rather, it is ! 3537: the same scope in which the parameters were declared and ! 3538: for Dwarf, we do not generate a TAG_lexical_block DIE for ! 3539: that scope. We must however see to it that the LABEL_DECLs ! 3540: associated with `outer_scope' get DIEs generated for them. */ ! 3541: ! 3542: { ! 3543: register tree label; ! 3544: ! 3545: for (label = BLOCK_VARS (outer_scope); ! 3546: label; ! 3547: label = TREE_CHAIN (label)) ! 3548: output_decl (label, outer_scope); ! 3549: } ! 3550: ! 3551: output_decls_for_scope (BLOCK_SUBBLOCKS (outer_scope)); ! 3552: ! 3553: /* Finally, force out any pending types which are local to the ! 3554: outermost block of this function definition. These will ! 3555: all have a TYPE_CONTEXT which points to the FUNCTION_DECL ! 3556: node itself. */ ! 3557: ! 3558: output_pending_types_for_scope (decl); ! 3559: } ! 3560: } ! 3561: ! 3562: /* Generate a terminator for the list of stuff `owned' by this ! 3563: function. */ ! 3564: ! 3565: end_sibling_chain (); ! 3566: ! 3567: break; ! 3568: ! 3569: case TYPE_DECL: ! 3570: /* If we are in terse mode, don't generate any DIEs to represent ! 3571: any actual typedefs. Note that even when we are in terse mode, ! 3572: we must still output DIEs to represent those tagged types which ! 3573: are used (directly or indirectly) in the specification of either ! 3574: a return type or a formal parameter type of some function. */ ! 3575: ! 3576: if (debug_info_level <= DINFO_LEVEL_TERSE) ! 3577: if (DECL_NAME (decl) != NULL ! 3578: || ! TYPE_USED_FOR_FUNCTION (TREE_TYPE (decl))) ! 3579: return; ! 3580: ! 3581: output_type (TREE_TYPE (decl), containing_scope); ! 3582: ! 3583: /* Note that unlike the gcc front end (which generates a NULL named ! 3584: TYPE_DECL node for each complete tagged type, each array type, ! 3585: and each function type node created) the g++ front end generates ! 3586: a *named* TYPE_DECL node for each tagged type node created. ! 3587: Unfortunately, these g++ TYPE_DECL nodes cause us to output many ! 3588: superfluous and unnecessary TAG_typedef DIEs here. When g++ is ! 3589: fixed to stop generating these superfluous named TYPE_DECL nodes, ! 3590: the superfluous TAG_typedef DIEs will likewise cease. */ ! 3591: ! 3592: if (DECL_NAME (decl)) ! 3593: /* Output a DIE to represent the typedef itself. */ ! 3594: output_die (output_typedef_die, decl); ! 3595: break; ! 3596: ! 3597: case LABEL_DECL: ! 3598: if (debug_info_level >= DINFO_LEVEL_NORMAL) ! 3599: output_die (output_label_die, decl); ! 3600: break; ! 3601: ! 3602: case VAR_DECL: ! 3603: /* If we are in terse mode, don't generate any DIEs to represent ! 3604: any variable declarations or definitions. */ ! 3605: ! 3606: if (debug_info_level <= DINFO_LEVEL_TERSE) ! 3607: break; ! 3608: ! 3609: /* Output any DIEs that are needed to specify the type of this data ! 3610: object. */ ! 3611: ! 3612: output_type (TREE_TYPE (decl), containing_scope); ! 3613: ! 3614: /* If the following DIE will represent a data object definition for a ! 3615: data object with "extern" linkage, output a special "pubnames" DIE ! 3616: label just ahead of the actual DIE. A reference to this label ! 3617: was already generated in the .debug_pubnames section sub-entry ! 3618: for this data object definition. */ ! 3619: ! 3620: if (TREE_PUBLIC (decl)) ! 3621: { ! 3622: char label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 3623: ! 3624: sprintf (label, PUB_DIE_LABEL_FMT, next_pubname_number++); ! 3625: ASM_OUTPUT_LABEL (asm_out_file, label); ! 3626: } ! 3627: ! 3628: /* Now output the DIE to represent the data object itself. */ ! 3629: ! 3630: output_die (TREE_PUBLIC (decl) || TREE_EXTERNAL (decl) ! 3631: ? output_global_variable_die : output_local_variable_die, ! 3632: decl); ! 3633: break; ! 3634: ! 3635: case FIELD_DECL: ! 3636: /* Ignore the nameless fields that are used to skip bits. */ ! 3637: if (DECL_NAME (decl) != 0) ! 3638: { ! 3639: output_type (member_declared_type (decl), containing_scope); ! 3640: output_die (output_member_die, decl); ! 3641: } ! 3642: break; ! 3643: ! 3644: case PARM_DECL: ! 3645: /* Force out the type of this formal, if it was not forced out yet. ! 3646: Note that here we can run afowl of a bug in "classic" svr4 SDB. ! 3647: It should be able to grok the presence of type DIEs within a list ! 3648: of TAG_formal_parameter DIEs, but it doesn't. */ ! 3649: ! 3650: output_type (TREE_TYPE (decl), containing_scope); ! 3651: output_die (output_formal_parameter_die, decl); ! 3652: break; ! 3653: ! 3654: default: ! 3655: abort (); ! 3656: } ! 3657: } ! 3658: ! 3659: void ! 3660: dwarfout_file_scope_decl (decl, set_finalizing) ! 3661: register tree decl; ! 3662: register int set_finalizing; ! 3663: { ! 3664: switch (TREE_CODE (decl)) ! 3665: { ! 3666: case FUNCTION_DECL: ! 3667: ! 3668: /* Ignore this FUNCTION_DECL if it refers to a builtin function. */ ! 3669: ! 3670: if (TREE_EXTERNAL (decl) && DECL_FUNCTION_CODE (decl)) ! 3671: return; ! 3672: ! 3673: /* Ignore this FUNCTION_DECL if it refers to a file-scope extern ! 3674: function declaration and if the declaration was never even ! 3675: referenced from within this entire compilation unit. We ! 3676: suppress these DIEs in order to save space in the .debug section ! 3677: (by eliminating entries which are probably useless). Note that ! 3678: we must not suppress block-local extern declarations (whether ! 3679: used or not) because that would screw-up the debugger's name ! 3680: lookup mechanism and cause it to miss things which really ought ! 3681: to be in scope at a given point. */ ! 3682: ! 3683: if (TREE_EXTERNAL (decl) && !TREE_USED (decl)) ! 3684: return; ! 3685: ! 3686: if (TREE_PUBLIC (decl) && ! TREE_EXTERNAL (decl)) ! 3687: { ! 3688: char label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 3689: ! 3690: /* Output a .debug_pubnames entry for a public function ! 3691: defined in this compilation unit. */ ! 3692: ! 3693: fputc ('\n', asm_out_file); ! 3694: ASM_DWARF_PUBNAMES_SECTION (asm_out_file); ! 3695: sprintf (label, PUB_DIE_LABEL_FMT, next_pubname_number); ! 3696: ASM_OUTPUT_DWARF_ADDR (asm_out_file, label); ! 3697: ASM_OUTPUT_DWARF_STRING (asm_out_file, ! 3698: IDENTIFIER_POINTER (DECL_NAME (decl))); ! 3699: ASM_DWARF_POP_SECTION (asm_out_file); ! 3700: } ! 3701: ! 3702: break; ! 3703: ! 3704: case VAR_DECL: ! 3705: ! 3706: /* Ignore this VAR_DECL if it refers to a file-scope extern data ! 3707: object declaration and if the declaration was never even ! 3708: referenced from within this entire compilation unit. We ! 3709: suppress these DIEs in order to save space in the .debug section ! 3710: (by eliminating entries which are probably useless). Note that ! 3711: we must not suppress block-local extern declarations (whether ! 3712: used or not) because that would screw-up the debugger's name ! 3713: lookup mechanism and cause it to miss things which really ought ! 3714: to be in scope at a given point. */ ! 3715: ! 3716: if (TREE_EXTERNAL (decl) && !TREE_USED (decl)) ! 3717: return; ! 3718: ! 3719: if (TREE_PUBLIC (decl) && ! TREE_EXTERNAL (decl)) ! 3720: { ! 3721: char label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 3722: ! 3723: if (debug_info_level >= DINFO_LEVEL_NORMAL) ! 3724: { ! 3725: /* Output a .debug_pubnames entry for a public variable ! 3726: defined in this compilation unit. */ ! 3727: ! 3728: fputc ('\n', asm_out_file); ! 3729: ASM_DWARF_PUBNAMES_SECTION (asm_out_file); ! 3730: sprintf (label, PUB_DIE_LABEL_FMT, next_pubname_number); ! 3731: ASM_OUTPUT_DWARF_ADDR (asm_out_file, label); ! 3732: ASM_OUTPUT_DWARF_STRING (asm_out_file, ! 3733: IDENTIFIER_POINTER (DECL_NAME (decl))); ! 3734: ASM_DWARF_POP_SECTION (asm_out_file); ! 3735: } ! 3736: ! 3737: if (DECL_INITIAL (decl) == NULL) ! 3738: { ! 3739: /* Output a .debug_aranges entry for a public variable ! 3740: which is tenatively defined in this compilation unit. */ ! 3741: ! 3742: fputc ('\n', asm_out_file); ! 3743: ASM_DWARF_ARANGES_SECTION (asm_out_file); ! 3744: ASM_OUTPUT_DWARF_ADDR (asm_out_file, ! 3745: IDENTIFIER_POINTER (DECL_NAME (decl))); ! 3746: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, ! 3747: (unsigned) int_size_in_bytes (TREE_TYPE (decl))); ! 3748: ASM_DWARF_POP_SECTION (asm_out_file); ! 3749: } ! 3750: } ! 3751: ! 3752: /* If we are in terse mode, don't generate any DIEs to represent ! 3753: any variable declarations or definitions. */ ! 3754: ! 3755: if (debug_info_level <= DINFO_LEVEL_TERSE) ! 3756: return; ! 3757: ! 3758: break; ! 3759: ! 3760: case TYPE_DECL: ! 3761: /* Don't generate any DIEs to represent the standard built-in types. */ ! 3762: ! 3763: if (DECL_SOURCE_LINE (decl) == 0) ! 3764: return; ! 3765: ! 3766: /* If we are in terse mode, don't generate any DIEs to represent ! 3767: any actual typedefs. Note that even when we are in terse mode, ! 3768: we must still output DIEs to represent those tagged types which ! 3769: are used (directly or indirectly) in the specification of either ! 3770: a return type or a formal parameter type of some function. */ ! 3771: ! 3772: if (debug_info_level <= DINFO_LEVEL_TERSE) ! 3773: if (DECL_NAME (decl) != NULL ! 3774: || ! TYPE_USED_FOR_FUNCTION (TREE_TYPE (decl))) ! 3775: return; ! 3776: ! 3777: break; ! 3778: ! 3779: default: ! 3780: return; ! 3781: } ! 3782: ! 3783: fputc ('\n', asm_out_file); ! 3784: ASM_DWARF_DEBUG_SECTION (asm_out_file); ! 3785: finalizing = set_finalizing; ! 3786: output_decl (decl, NULL); ! 3787: ! 3788: /* NOTE: The call above to `output_decl' may have caused one or more ! 3789: file-scope named types (i.e. tagged types) to be placed onto the ! 3790: pending_types_list. We have to get those types off of that list ! 3791: at some point, and this is the perfect time to do it. If we didn't ! 3792: take them off now, they might still be on the list when cc1 finally ! 3793: exits. That might be OK if it weren't for the fact that when we put ! 3794: types onto the pending_types_list, we set the TREE_ASM_WRITTEN flag ! 3795: for these types, and that causes them never to be output unless ! 3796: `output_pending_types_for_scope' takes them off of the list and un-sets ! 3797: their TREE_ASM_WRITTEN flags. */ ! 3798: ! 3799: output_pending_types_for_scope (NULL); ! 3800: ! 3801: /* The above call should have totally emptied the pending_types_list. */ ! 3802: ! 3803: assert (pending_types == 0); ! 3804: ! 3805: ASM_DWARF_POP_SECTION (asm_out_file); ! 3806: ! 3807: if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl) != NULL) ! 3808: current_funcdef_number++; ! 3809: } ! 3810: ! 3811: /* Output a marker (i.e. a label) for the beginning of the generated code ! 3812: for a lexical block. */ ! 3813: ! 3814: void ! 3815: dwarfout_begin_block (blocknum) ! 3816: register unsigned blocknum; ! 3817: { ! 3818: char label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 3819: ! 3820: text_section (); ! 3821: sprintf (label, BLOCK_BEGIN_LABEL_FMT, blocknum); ! 3822: ASM_OUTPUT_LABEL (asm_out_file, label); ! 3823: } ! 3824: ! 3825: /* Output a marker (i.e. a label) for the end of the generated code ! 3826: for a lexical block. */ ! 3827: ! 3828: void ! 3829: dwarfout_end_block (blocknum) ! 3830: register unsigned blocknum; ! 3831: { ! 3832: char label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 3833: ! 3834: text_section (); ! 3835: sprintf (label, BLOCK_END_LABEL_FMT, blocknum); ! 3836: ASM_OUTPUT_LABEL (asm_out_file, label); ! 3837: } ! 3838: ! 3839: /* Output a marker (i.e. a label) at a point in the assembly code which ! 3840: corresponds to a given source level label. */ ! 3841: ! 3842: void ! 3843: dwarfout_label (insn) ! 3844: register rtx insn; ! 3845: { ! 3846: if (debug_info_level >= DINFO_LEVEL_NORMAL) ! 3847: { ! 3848: char label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 3849: ! 3850: text_section (); ! 3851: sprintf (label, INSN_LABEL_FMT, current_funcdef_number, ! 3852: (unsigned) INSN_UID (insn)); ! 3853: ASM_OUTPUT_LABEL (asm_out_file, label); ! 3854: } ! 3855: } ! 3856: ! 3857: /* Output a marker (i.e. a label) for the absolute end of the generated code ! 3858: for a function definition. This gets called *after* the epilogue code ! 3859: has been generated. */ ! 3860: ! 3861: void ! 3862: dwarfout_end_epilogue () ! 3863: { ! 3864: char label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 3865: ! 3866: /* Output a label to mark the endpoint of the code generated for this ! 3867: function. */ ! 3868: ! 3869: sprintf (label, FUNC_END_LABEL_FMT, current_funcdef_number); ! 3870: ASM_OUTPUT_LABEL (asm_out_file, label); ! 3871: } ! 3872: ! 3873: static void ! 3874: shuffle_filename_entry (new_zeroth) ! 3875: register filename_entry *new_zeroth; ! 3876: { ! 3877: filename_entry temp_entry; ! 3878: register filename_entry *limit_p; ! 3879: register filename_entry *move_p; ! 3880: ! 3881: if (new_zeroth == &filename_table[0]) ! 3882: return; ! 3883: ! 3884: temp_entry = *new_zeroth; ! 3885: ! 3886: /* Shift entries up in the table to make room at [0]. */ ! 3887: ! 3888: limit_p = &filename_table[0]; ! 3889: for (move_p = new_zeroth; move_p > limit_p; move_p--) ! 3890: *move_p = *(move_p-1); ! 3891: ! 3892: /* Install the found entry at [0]. */ ! 3893: ! 3894: filename_table[0] = temp_entry; ! 3895: } ! 3896: ! 3897: /* Create a new (string) entry for the .debug_sfnames section. */ ! 3898: ! 3899: static void ! 3900: generate_new_sfname_entry () ! 3901: { ! 3902: char label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 3903: ! 3904: fputc ('\n', asm_out_file); ! 3905: ASM_DWARF_SFNAMES_SECTION (asm_out_file); ! 3906: sprintf (label, SFNAMES_ENTRY_LABEL_FMT, filename_table[0].number); ! 3907: ASM_OUTPUT_LABEL (asm_out_file, label); ! 3908: ASM_OUTPUT_DWARF_STRING (asm_out_file, ! 3909: filename_table[0].name ! 3910: ? filename_table[0].name ! 3911: : ""); ! 3912: ASM_DWARF_POP_SECTION (asm_out_file); ! 3913: } ! 3914: ! 3915: /* Lookup a filename (in the list of filenames that we know about here in ! 3916: dwarfout.c) and return its "index". The index of each (known) filename ! 3917: is just a unique number which is associated with only that one filename. ! 3918: We need such numbers for the sake of generating labels (in the ! 3919: .debug_sfnames section) and references to those unique labels (in the ! 3920: .debug_srcinfo and .debug_macinfo sections). ! 3921: ! 3922: If the filename given as an argument is not found in our current list, ! 3923: add it to the list and assign it the next available unique index number. ! 3924: ! 3925: Whatever we do (i.e. whether we find a pre-existing filename or add a new ! 3926: one), we shuffle the filename found (or added) up to the zeroth entry of ! 3927: our list of filenames (which is always searched linearly). We do this so ! 3928: as to optimize the most common case for these filename lookups within ! 3929: dwarfout.c. The most common case by far is the case where we call ! 3930: lookup_filename to lookup the very same filename that we did a lookup ! 3931: on the last time we called lookup_filename. We make sure that this ! 3932: common case is fast because such cases will constitute 99.9% of the ! 3933: lookups we ever do (in practice). ! 3934: ! 3935: If we add a new filename entry to our table, we go ahead and generate ! 3936: the corresponding entry in the .debug_sfnames section right away. ! 3937: Doing so allows us to avoid tickling an assembler bug (present in some ! 3938: m68k assemblers) which yields assembly-time errors in cases where the ! 3939: difference of two label addresses is taken and where the two labels ! 3940: are in a section *other* than the one where the difference is being ! 3941: calculated, and where at least one of the two symbol references is a ! 3942: forward reference. (This bug could be tickled by our .debug_srcinfo ! 3943: entries if we don't output their corresponding .debug_sfnames entries ! 3944: before them.) ! 3945: */ ! 3946: ! 3947: static unsigned ! 3948: lookup_filename (file_name) ! 3949: char *file_name; ! 3950: { ! 3951: register filename_entry *search_p; ! 3952: register filename_entry *limit_p = &filename_table[ft_entries]; ! 3953: ! 3954: for (search_p = filename_table; search_p < limit_p; search_p++) ! 3955: if (!strcmp (file_name, search_p->name)) ! 3956: { ! 3957: /* When we get here, we have found the filename that we were ! 3958: looking for in the filename_table. Now we want to make sure ! 3959: that it gets moved to the zero'th entry in the table (if it ! 3960: is not already there) so that subsequent attempts to find the ! 3961: same filename will find it as quickly as possible. */ ! 3962: ! 3963: shuffle_filename_entry (search_p); ! 3964: return filename_table[0].number; ! 3965: } ! 3966: ! 3967: /* We come here whenever we have a new filename which is not registered ! 3968: in the current table. Here we add it to the table. */ ! 3969: ! 3970: /* Prepare to add a new table entry by making sure there is enough space ! 3971: in the table to do so. If not, expand the current table. */ ! 3972: ! 3973: if (ft_entries == ft_entries_allocated) ! 3974: { ! 3975: ft_entries_allocated += FT_ENTRIES_INCREMENT; ! 3976: filename_table ! 3977: = (filename_entry *) ! 3978: xrealloc (filename_table, ! 3979: ft_entries_allocated * sizeof (filename_entry)); ! 3980: } ! 3981: ! 3982: /* Initially, add the new entry at the end of the filename table. */ ! 3983: ! 3984: filename_table[ft_entries].number = ft_entries; ! 3985: filename_table[ft_entries].name = xstrdup (file_name); ! 3986: ! 3987: /* Shuffle the new entry into filename_table[0]. */ ! 3988: ! 3989: shuffle_filename_entry (&filename_table[ft_entries]); ! 3990: ! 3991: if (debug_info_level >= DINFO_LEVEL_NORMAL) ! 3992: generate_new_sfname_entry (); ! 3993: ! 3994: ft_entries++; ! 3995: return filename_table[0].number; ! 3996: } ! 3997: ! 3998: static void ! 3999: generate_srcinfo_entry (line_entry_num, files_entry_num) ! 4000: unsigned line_entry_num; ! 4001: unsigned files_entry_num; ! 4002: { ! 4003: char label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 4004: ! 4005: fputc ('\n', asm_out_file); ! 4006: ASM_DWARF_SRCINFO_SECTION (asm_out_file); ! 4007: sprintf (label, LINE_ENTRY_LABEL_FMT, line_entry_num); ! 4008: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, label, LINE_BEGIN_LABEL); ! 4009: sprintf (label, SFNAMES_ENTRY_LABEL_FMT, files_entry_num); ! 4010: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, label, SFNAMES_BEGIN_LABEL); ! 4011: ASM_DWARF_POP_SECTION (asm_out_file); ! 4012: } ! 4013: ! 4014: void ! 4015: dwarfout_line (filename, line) ! 4016: register char *filename; ! 4017: register unsigned line; ! 4018: { ! 4019: if (debug_info_level >= DINFO_LEVEL_NORMAL) ! 4020: { ! 4021: char label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 4022: static unsigned last_line_entry_num = 0; ! 4023: static unsigned prev_file_entry_num = (unsigned) -1; ! 4024: register unsigned this_file_entry_num = lookup_filename (filename); ! 4025: ! 4026: text_section (); ! 4027: sprintf (label, LINE_CODE_LABEL_FMT, ++last_line_entry_num); ! 4028: ASM_OUTPUT_LABEL (asm_out_file, label); ! 4029: ! 4030: fputc ('\n', asm_out_file); ! 4031: ASM_DWARF_LINE_SECTION (asm_out_file); ! 4032: ! 4033: if (this_file_entry_num != prev_file_entry_num) ! 4034: { ! 4035: char line_entry_label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 4036: ! 4037: sprintf (line_entry_label, LINE_ENTRY_LABEL_FMT, last_line_entry_num); ! 4038: ASM_OUTPUT_LABEL (asm_out_file, line_entry_label); ! 4039: } ! 4040: ! 4041: { ! 4042: register char *tail = strrchr (filename, '/'); ! 4043: ! 4044: if (tail != NULL) ! 4045: filename = tail; ! 4046: } ! 4047: ! 4048: fprintf (asm_out_file, "%s\t%u\t%s %s:%u\n", ! 4049: UNALIGNED_INT_ASM_OP, line, ASM_COMMENT_START, ! 4050: filename, line); ! 4051: ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0xffff); ! 4052: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, label, TEXT_BEGIN_LABEL); ! 4053: ASM_DWARF_POP_SECTION (asm_out_file); ! 4054: ! 4055: if (this_file_entry_num != prev_file_entry_num) ! 4056: generate_srcinfo_entry (last_line_entry_num, this_file_entry_num); ! 4057: prev_file_entry_num = this_file_entry_num; ! 4058: } ! 4059: } ! 4060: ! 4061: /* Generate an entry in the .debug_macinfo section. */ ! 4062: ! 4063: static void ! 4064: generate_macinfo_entry (type_and_offset, string) ! 4065: register char *type_and_offset; ! 4066: register char *string; ! 4067: { ! 4068: fputc ('\n', asm_out_file); ! 4069: ASM_DWARF_MACINFO_SECTION (asm_out_file); ! 4070: fprintf (asm_out_file, "%s\t%s\n", UNALIGNED_INT_ASM_OP, type_and_offset); ! 4071: ASM_OUTPUT_DWARF_STRING (asm_out_file, string); ! 4072: ASM_DWARF_POP_SECTION (asm_out_file); ! 4073: } ! 4074: ! 4075: void ! 4076: dwarfout_start_new_source_file (filename) ! 4077: register char *filename; ! 4078: { ! 4079: char label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 4080: char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*3]; ! 4081: ! 4082: sprintf (label, SFNAMES_ENTRY_LABEL_FMT, lookup_filename (filename)); ! 4083: sprintf (type_and_offset, "0x%08x+%s-%s", ! 4084: ((unsigned) MACINFO_start << 24), label, SFNAMES_BEGIN_LABEL); ! 4085: generate_macinfo_entry (type_and_offset, ""); ! 4086: } ! 4087: ! 4088: void ! 4089: dwarfout_resume_previous_source_file (lineno) ! 4090: register unsigned lineno; ! 4091: { ! 4092: char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2]; ! 4093: ! 4094: sprintf (type_and_offset, "0x%08x+%u", ! 4095: ((unsigned) MACINFO_resume << 24), lineno); ! 4096: generate_macinfo_entry (type_and_offset, ""); ! 4097: } ! 4098: ! 4099: /* Called from check_newline in c-parse.y. The `buffer' parameter ! 4100: contains the tail part of the directive line, i.e. the part which ! 4101: is past the initial whitespace, #, whitespace, directive-name, ! 4102: whitespace part. */ ! 4103: ! 4104: void ! 4105: dwarfout_define (lineno, buffer) ! 4106: register unsigned lineno; ! 4107: register char *buffer; ! 4108: { ! 4109: static int initialized = 0; ! 4110: char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2]; ! 4111: ! 4112: if (!initialized) ! 4113: { ! 4114: dwarfout_start_new_source_file (primary_filename); ! 4115: initialized = 1; ! 4116: } ! 4117: sprintf (type_and_offset, "0x%08x+%u", ! 4118: ((unsigned) MACINFO_define << 24), lineno); ! 4119: generate_macinfo_entry (type_and_offset, buffer); ! 4120: } ! 4121: ! 4122: /* Called from check_newline in c-parse.y. The `buffer' parameter ! 4123: contains the tail part of the directive line, i.e. the part which ! 4124: is past the initial whitespace, #, whitespace, directive-name, ! 4125: whitespace part. */ ! 4126: ! 4127: void ! 4128: dwarfout_undef (lineno, buffer) ! 4129: register unsigned lineno; ! 4130: register char *buffer; ! 4131: { ! 4132: char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2]; ! 4133: ! 4134: sprintf (type_and_offset, "0x%08x+%u", ! 4135: ((unsigned) MACINFO_undef << 24), lineno); ! 4136: generate_macinfo_entry (type_and_offset, buffer); ! 4137: } ! 4138: ! 4139: /* Set up for Dwarf output at the start of compilation. */ ! 4140: ! 4141: void ! 4142: dwarfout_init (asm_out_file, main_input_filename) ! 4143: register FILE *asm_out_file; ! 4144: register char *main_input_filename; ! 4145: { ! 4146: /* Remember the name of the primary input file. */ ! 4147: ! 4148: primary_filename = main_input_filename; ! 4149: ! 4150: /* Allocate the initial hunk of the pending_sibling_stack. */ ! 4151: ! 4152: pending_sibling_stack ! 4153: = (unsigned *) ! 4154: xmalloc (PENDING_SIBLINGS_INCREMENT * sizeof (unsigned)); ! 4155: pending_siblings_allocated = PENDING_SIBLINGS_INCREMENT; ! 4156: pending_siblings = 1; ! 4157: ! 4158: /* Allocate the initial hunk of the filename_table. */ ! 4159: ! 4160: filename_table ! 4161: = (filename_entry *) ! 4162: xmalloc (FT_ENTRIES_INCREMENT * sizeof (filename_entry)); ! 4163: ft_entries_allocated = FT_ENTRIES_INCREMENT; ! 4164: ft_entries = 0; ! 4165: ! 4166: /* Allocate the initial hunk of the pending_types_list. */ ! 4167: ! 4168: pending_types_list ! 4169: = (tree *) xmalloc (PENDING_TYPES_INCREMENT * sizeof (tree)); ! 4170: pending_types_allocated = PENDING_TYPES_INCREMENT; ! 4171: pending_types = 0; ! 4172: ! 4173: /* Create an artificial RECORD_TYPE node which we can use in our hack ! 4174: to get the DIEs representing types of formal parameters to come out ! 4175: only *after* the DIEs for the formal parameters themselves. */ ! 4176: ! 4177: fake_containing_scope = make_node (RECORD_TYPE); ! 4178: ! 4179: /* Output a starting label for the .text section. */ ! 4180: ! 4181: fputc ('\n', asm_out_file); ! 4182: ASM_DWARF_TEXT_SECTION (asm_out_file); ! 4183: ASM_OUTPUT_LABEL (asm_out_file, TEXT_BEGIN_LABEL); ! 4184: ASM_DWARF_POP_SECTION (asm_out_file); ! 4185: ! 4186: /* Output a starting label for the .data section. */ ! 4187: ! 4188: fputc ('\n', asm_out_file); ! 4189: ASM_DWARF_DATA_SECTION (asm_out_file); ! 4190: ASM_OUTPUT_LABEL (asm_out_file, DATA_BEGIN_LABEL); ! 4191: ASM_DWARF_POP_SECTION (asm_out_file); ! 4192: ! 4193: /* Output a starting label for the .data1 section. */ ! 4194: ! 4195: fputc ('\n', asm_out_file); ! 4196: ASM_DWARF_DATA1_SECTION (asm_out_file); ! 4197: ASM_OUTPUT_LABEL (asm_out_file, DATA1_BEGIN_LABEL); ! 4198: ASM_DWARF_POP_SECTION (asm_out_file); ! 4199: ! 4200: /* Output a starting label for the .rodata section. */ ! 4201: ! 4202: fputc ('\n', asm_out_file); ! 4203: ASM_DWARF_RODATA_SECTION (asm_out_file); ! 4204: ASM_OUTPUT_LABEL (asm_out_file, RODATA_BEGIN_LABEL); ! 4205: ASM_DWARF_POP_SECTION (asm_out_file); ! 4206: ! 4207: /* Output a starting label for the .rodata1 section. */ ! 4208: ! 4209: fputc ('\n', asm_out_file); ! 4210: ASM_DWARF_RODATA1_SECTION (asm_out_file); ! 4211: ASM_OUTPUT_LABEL (asm_out_file, RODATA1_BEGIN_LABEL); ! 4212: ASM_DWARF_POP_SECTION (asm_out_file); ! 4213: ! 4214: /* Output a starting label for the .bss section. */ ! 4215: ! 4216: fputc ('\n', asm_out_file); ! 4217: ASM_DWARF_BSS_SECTION (asm_out_file); ! 4218: ASM_OUTPUT_LABEL (asm_out_file, BSS_BEGIN_LABEL); ! 4219: ASM_DWARF_POP_SECTION (asm_out_file); ! 4220: ! 4221: if (debug_info_level >= DINFO_LEVEL_NORMAL) ! 4222: { ! 4223: /* Output a starting label and an initial (compilation directory) ! 4224: entry for the .debug_sfnames section. The starting label will be ! 4225: referenced by the initial entry in the .debug_srcinfo section. */ ! 4226: ! 4227: fputc ('\n', asm_out_file); ! 4228: ASM_DWARF_SFNAMES_SECTION (asm_out_file); ! 4229: ASM_OUTPUT_LABEL (asm_out_file, SFNAMES_BEGIN_LABEL); ! 4230: { ! 4231: register unsigned len = 1024; ! 4232: register char *dirname = (char *) xmalloc (len + 1); ! 4233: ! 4234: /* We don't know how much space the dirname needs, ! 4235: so try bigger and bigger buffers until it fits. */ ! 4236: for (;;) ! 4237: { ! 4238: getcwd (dirname, len); /* Being conservative here. */ ! 4239: if (strlen (dirname) < len - 1) /* Being conservative here. */ ! 4240: break; ! 4241: len *= 2; ! 4242: dirname = (char *) xrealloc (dirname, len + 1); ! 4243: } ! 4244: strcat (dirname, "/"); ! 4245: ASM_OUTPUT_DWARF_STRING (asm_out_file, dirname); ! 4246: free (dirname); ! 4247: } ! 4248: ASM_DWARF_POP_SECTION (asm_out_file); ! 4249: ! 4250: if (debug_info_level >= DINFO_LEVEL_VERBOSE) ! 4251: { ! 4252: /* Output a starting label for the .debug_macinfo section. This ! 4253: label will be referenced by the AT_mac_info attribute in the ! 4254: TAG_compile_unit DIE. */ ! 4255: ! 4256: fputc ('\n', asm_out_file); ! 4257: ASM_DWARF_MACINFO_SECTION (asm_out_file); ! 4258: ASM_OUTPUT_LABEL (asm_out_file, MACINFO_BEGIN_LABEL); ! 4259: ASM_DWARF_POP_SECTION (asm_out_file); ! 4260: } ! 4261: ! 4262: /* Generate the initial entry for the .line section. */ ! 4263: ! 4264: fputc ('\n', asm_out_file); ! 4265: ASM_DWARF_LINE_SECTION (asm_out_file); ! 4266: ASM_OUTPUT_LABEL (asm_out_file, LINE_BEGIN_LABEL); ! 4267: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, LINE_END_LABEL, LINE_BEGIN_LABEL); ! 4268: ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_BEGIN_LABEL); ! 4269: ASM_DWARF_POP_SECTION (asm_out_file); ! 4270: ! 4271: /* Generate the initial entry for the .debug_srcinfo section. */ ! 4272: ! 4273: fputc ('\n', asm_out_file); ! 4274: ASM_DWARF_SRCINFO_SECTION (asm_out_file); ! 4275: ASM_OUTPUT_LABEL (asm_out_file, SRCINFO_BEGIN_LABEL); ! 4276: ASM_OUTPUT_DWARF_ADDR (asm_out_file, LINE_BEGIN_LABEL); ! 4277: ASM_OUTPUT_DWARF_ADDR (asm_out_file, SFNAMES_BEGIN_LABEL); ! 4278: ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_BEGIN_LABEL); ! 4279: ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_END_LABEL); ! 4280: #ifdef DWARF_TIMESTAMPS ! 4281: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, time (NULL)); ! 4282: #else ! 4283: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, -1); ! 4284: #endif ! 4285: ASM_DWARF_POP_SECTION (asm_out_file); ! 4286: ! 4287: /* Generate the initial entry for the .debug_pubnames section. */ ! 4288: ! 4289: fputc ('\n', asm_out_file); ! 4290: ASM_DWARF_PUBNAMES_SECTION (asm_out_file); ! 4291: ASM_OUTPUT_DWARF_ADDR (asm_out_file, DEBUG_BEGIN_LABEL); ! 4292: ASM_DWARF_POP_SECTION (asm_out_file); ! 4293: ! 4294: /* Generate the initial entry for the .debug_aranges section. */ ! 4295: ! 4296: fputc ('\n', asm_out_file); ! 4297: ASM_DWARF_ARANGES_SECTION (asm_out_file); ! 4298: ASM_OUTPUT_DWARF_ADDR (asm_out_file, DEBUG_BEGIN_LABEL); ! 4299: ASM_DWARF_POP_SECTION (asm_out_file); ! 4300: } ! 4301: ! 4302: /* Setup first DIE number == 1. */ ! 4303: NEXT_DIE_NUM = next_unused_dienum++; ! 4304: ! 4305: /* Generate the initial DIE for the .debug section. Note that the ! 4306: (string) value given in the AT_name attribute of the TAG_compile_unit ! 4307: DIE will (typically) be a relative pathname and that this pathname ! 4308: should be taken as being relative to the directory from which the ! 4309: compiler was invoked when the given (base) source file was compiled. */ ! 4310: ! 4311: fputc ('\n', asm_out_file); ! 4312: ASM_DWARF_DEBUG_SECTION (asm_out_file); ! 4313: ASM_OUTPUT_LABEL (asm_out_file, DEBUG_BEGIN_LABEL); ! 4314: output_die (output_compile_unit_die, main_input_filename); ! 4315: ASM_DWARF_POP_SECTION (asm_out_file); ! 4316: ! 4317: fputc ('\n', asm_out_file); ! 4318: } ! 4319: ! 4320: /* Output stuff that dwarf requires at the end of every file. */ ! 4321: ! 4322: void ! 4323: dwarfout_finish () ! 4324: { ! 4325: char label[MAX_ARTIFICIAL_LABEL_BYTES]; ! 4326: ! 4327: fputc ('\n', asm_out_file); ! 4328: ASM_DWARF_DEBUG_SECTION (asm_out_file); ! 4329: ! 4330: /* Mark the end of the chain of siblings which represent all file-scope ! 4331: declarations in this compilation unit. */ ! 4332: ! 4333: /* The (null) DIE which represents the terminator for the (sibling linked) ! 4334: list of file-scope items is *special*. Normally, we would just call ! 4335: end_sibling_chain at this point in order to output a word with the ! 4336: value `4' and that word would act as the terminator for the list of ! 4337: DIEs describing file-scope items. Unfortunately, if we were to simply ! 4338: do that, the label that would follow this DIE in the .debug section ! 4339: (i.e. `..D2') would *not* be properly aligned (as it must be on some ! 4340: machines) to a 4 byte boundary. ! 4341: ! 4342: In order to force the label `..D2' to get aligned to a 4 byte boundary, ! 4343: the trick used is to insert extra (otherwise useless) padding bytes ! 4344: into the (null) DIE that we know must preceed the ..D2 label in the ! 4345: .debug section. The amount of padding required can be anywhere between ! 4346: 0 and 3 bytes. The length word at the start of this DIE (i.e. the one ! 4347: with the padding) would normally contain the value 4, but now it will ! 4348: also have to include the padding bytes, so it will instead have some ! 4349: value in the range 4..7. ! 4350: ! 4351: Fortunately, the rules of Dwarf say that any DIE whose length word ! 4352: contains *any* value less than 8 should be treated as a null DIE, so ! 4353: this trick works out nicely. Clever, eh? Don't give me any credit ! 4354: (or blame). I didn't think of this scheme. I just conformed to it. ! 4355: */ ! 4356: ! 4357: output_die (output_padded_null_die, (void *)0); ! 4358: dienum_pop (); ! 4359: ! 4360: sprintf (label, DIE_BEGIN_LABEL_FMT, NEXT_DIE_NUM); ! 4361: ASM_OUTPUT_LABEL (asm_out_file, label); /* should be ..D2 */ ! 4362: ASM_DWARF_POP_SECTION (asm_out_file); ! 4363: ! 4364: /* Output a terminator label for the .text section. */ ! 4365: ! 4366: fputc ('\n', asm_out_file); ! 4367: ASM_DWARF_TEXT_SECTION (asm_out_file); ! 4368: ASM_OUTPUT_LABEL (asm_out_file, TEXT_END_LABEL); ! 4369: ASM_DWARF_POP_SECTION (asm_out_file); ! 4370: ! 4371: /* Output a terminator label for the .data section. */ ! 4372: ! 4373: fputc ('\n', asm_out_file); ! 4374: ASM_DWARF_DATA_SECTION (asm_out_file); ! 4375: ASM_OUTPUT_LABEL (asm_out_file, DATA_END_LABEL); ! 4376: ASM_DWARF_POP_SECTION (asm_out_file); ! 4377: ! 4378: /* Output a terminator label for the .data1 section. */ ! 4379: ! 4380: fputc ('\n', asm_out_file); ! 4381: ASM_DWARF_DATA1_SECTION (asm_out_file); ! 4382: ASM_OUTPUT_LABEL (asm_out_file, DATA1_END_LABEL); ! 4383: ASM_DWARF_POP_SECTION (asm_out_file); ! 4384: ! 4385: /* Output a terminator label for the .rodata section. */ ! 4386: ! 4387: fputc ('\n', asm_out_file); ! 4388: ASM_DWARF_RODATA_SECTION (asm_out_file); ! 4389: ASM_OUTPUT_LABEL (asm_out_file, RODATA_END_LABEL); ! 4390: ASM_DWARF_POP_SECTION (asm_out_file); ! 4391: ! 4392: /* Output a terminator label for the .rodata1 section. */ ! 4393: ! 4394: fputc ('\n', asm_out_file); ! 4395: ASM_DWARF_RODATA1_SECTION (asm_out_file); ! 4396: ASM_OUTPUT_LABEL (asm_out_file, RODATA1_END_LABEL); ! 4397: ASM_DWARF_POP_SECTION (asm_out_file); ! 4398: ! 4399: /* Output a terminator label for the .bss section. */ ! 4400: ! 4401: fputc ('\n', asm_out_file); ! 4402: ASM_DWARF_BSS_SECTION (asm_out_file); ! 4403: ASM_OUTPUT_LABEL (asm_out_file, BSS_END_LABEL); ! 4404: ASM_DWARF_POP_SECTION (asm_out_file); ! 4405: ! 4406: if (debug_info_level >= DINFO_LEVEL_NORMAL) ! 4407: { ! 4408: /* Output a terminating entry for the .line section. */ ! 4409: ! 4410: fputc ('\n', asm_out_file); ! 4411: ASM_DWARF_LINE_SECTION (asm_out_file); ! 4412: ASM_OUTPUT_LABEL (asm_out_file, LINE_LAST_ENTRY_LABEL); ! 4413: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0); ! 4414: ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0xffff); ! 4415: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, TEXT_END_LABEL, TEXT_BEGIN_LABEL); ! 4416: ASM_OUTPUT_LABEL (asm_out_file, LINE_END_LABEL); ! 4417: ASM_DWARF_POP_SECTION (asm_out_file); ! 4418: ! 4419: /* Output a terminating entry for the .debug_srcinfo section. */ ! 4420: ! 4421: fputc ('\n', asm_out_file); ! 4422: ASM_DWARF_SRCINFO_SECTION (asm_out_file); ! 4423: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, ! 4424: LINE_LAST_ENTRY_LABEL, LINE_BEGIN_LABEL); ! 4425: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, -1); ! 4426: ASM_DWARF_POP_SECTION (asm_out_file); ! 4427: ! 4428: if (debug_info_level >= DINFO_LEVEL_VERBOSE) ! 4429: { ! 4430: /* Output terminating entries for the .debug_macinfo section. */ ! 4431: ! 4432: dwarfout_resume_previous_source_file (0); ! 4433: ! 4434: fputc ('\n', asm_out_file); ! 4435: ASM_DWARF_MACINFO_SECTION (asm_out_file); ! 4436: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0); ! 4437: ASM_OUTPUT_DWARF_STRING (asm_out_file, ""); ! 4438: ASM_DWARF_POP_SECTION (asm_out_file); ! 4439: } ! 4440: ! 4441: /* Generate the terminating entry for the .debug_pubnames section. */ ! 4442: ! 4443: fputc ('\n', asm_out_file); ! 4444: ASM_DWARF_PUBNAMES_SECTION (asm_out_file); ! 4445: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0); ! 4446: ASM_OUTPUT_DWARF_STRING (asm_out_file, ""); ! 4447: ASM_DWARF_POP_SECTION (asm_out_file); ! 4448: ! 4449: /* Generate the terminating entries for the .debug_aranges section. ! 4450: ! 4451: Note that we want to do this only *after* we have output the end ! 4452: labels (for the various program sections) which we are going to ! 4453: refer to here. This allows us to work around a bug in the m68k ! 4454: svr4 assembler. That assembler gives bogus assembly-time errors ! 4455: if (within any given section) you try to take the difference of ! 4456: two relocatable symbols, both of which are located within some ! 4457: other section, and if one (or both?) of the symbols involved is ! 4458: being forward-referenced. By generating the .debug_aranges ! 4459: entries at this late point in the assembly output, we skirt the ! 4460: issue simply by avoiding forward-references. ! 4461: */ ! 4462: ! 4463: fputc ('\n', asm_out_file); ! 4464: ASM_DWARF_ARANGES_SECTION (asm_out_file); ! 4465: ! 4466: ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_BEGIN_LABEL); ! 4467: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, TEXT_END_LABEL, TEXT_BEGIN_LABEL); ! 4468: ! 4469: ASM_OUTPUT_DWARF_ADDR (asm_out_file, DATA_BEGIN_LABEL); ! 4470: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, DATA_END_LABEL, DATA_BEGIN_LABEL); ! 4471: ! 4472: ASM_OUTPUT_DWARF_ADDR (asm_out_file, DATA1_BEGIN_LABEL); ! 4473: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, DATA1_END_LABEL, ! 4474: DATA1_BEGIN_LABEL); ! 4475: ! 4476: ASM_OUTPUT_DWARF_ADDR (asm_out_file, RODATA_BEGIN_LABEL); ! 4477: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, RODATA_END_LABEL, ! 4478: RODATA_BEGIN_LABEL); ! 4479: ! 4480: ASM_OUTPUT_DWARF_ADDR (asm_out_file, RODATA1_BEGIN_LABEL); ! 4481: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, RODATA1_END_LABEL, ! 4482: RODATA1_BEGIN_LABEL); ! 4483: ! 4484: ASM_OUTPUT_DWARF_ADDR (asm_out_file, BSS_BEGIN_LABEL); ! 4485: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, BSS_END_LABEL, BSS_BEGIN_LABEL); ! 4486: ! 4487: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0); ! 4488: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0); ! 4489: ! 4490: ASM_DWARF_POP_SECTION (asm_out_file); ! 4491: } ! 4492: } ! 4493: ! 4494: #endif /* DWARF_DEBUGGING_INFO */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.