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