![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dbxout.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 1.x] / gcc|
Return to dbxout.c CVS log | Up to [GCC 1.x] / gcc |
1.1 ! root 1: /* Output dbx-format symbol table information from GNU compiler. ! 2: Copyright (C) 1987 Free Software Foundation, Inc. ! 3: ! 4: This file is part of GNU CC. ! 5: ! 6: GNU CC is distributed in the hope that it will be useful, ! 7: but WITHOUT ANY WARRANTY. No author or distributor ! 8: accepts responsibility to anyone for the consequences of using it ! 9: or for whether it serves any particular purpose or works at all, ! 10: unless he says so in writing. Refer to the GNU CC General Public ! 11: License for full details. ! 12: ! 13: Everyone is granted permission to copy, modify and redistribute ! 14: GNU CC, but only under the conditions described in the ! 15: GNU CC General Public License. A copy of this license is ! 16: supposed to have been given to you along with GNU CC so you ! 17: can know your rights and responsibilities. It should be in a ! 18: file named COPYING. Among other things, the copyright notice ! 19: and this notice must be preserved on all copies. */ ! 20: ! 21: ! 22: /* Output dbx-format symbol table data. ! 23: This consists of many symbol table entries, each of them ! 24: a .stabs assembler pseudo-op with four operands: ! 25: a "name" which is really a description of one symbol and its type, ! 26: a "code", which is a symbol defined in stab.h whose name starts with N_, ! 27: an unused operand always 0, ! 28: and a "value" which is an address or an offset. ! 29: The name is enclosed in doublequote characters. ! 30: ! 31: Each function, variable, typedef, and structure tag ! 32: has a symbol table entry to define it. ! 33: The beginning and end of each level of name scoping within ! 34: a function are also marked by special symbol table entries. ! 35: ! 36: The "name" consists of the symbol name, a colon, a kind-of-symbol letter, ! 37: and a data type number. The data type number may be followed by ! 38: "=" and a type definition; normally this will happen the first time ! 39: the type number is mentioned. The type definition may refer to ! 40: other types by number, and those type numbers may be followed ! 41: by "=" and nested definitions. ! 42: ! 43: This can make the "name" quite long. ! 44: When a name is more than 80 characters, we split the .stabs pseudo-op ! 45: into two .stabs pseudo-ops, both sharing the same "code" and "value". ! 46: The first one is marked as continued with a double-backslash at the ! 47: end of its "name". ! 48: ! 49: The kind-of-symbol letter distinguished function names from global ! 50: variables from file-scope variables from parameters from auto ! 51: variables in memory from typedef names from register variables. ! 52: See `dbxout_symbol'. ! 53: ! 54: The "code" is mostly redundant with the kind-of-symbol letter ! 55: that goes in the "name", but not entirely: for symbols located ! 56: in static storage, the "code" says which segment the address is in, ! 57: which controls how it is relocated. ! 58: ! 59: The "value" for a symbol in static storage ! 60: is the core address of the symbol (actually, the assembler ! 61: label for the symbol). For a symbol located in a stack slot ! 62: it is the stack offset; for one in a register, the register number. ! 63: For a typedef symbol, it is zero. ! 64: ! 65: For more on data type definitions, see `dbxout_type'. */ ! 66: ! 67: #include "config.h" ! 68: #include "tree.h" ! 69: #include "rtl.h" ! 70: #include "c-tree.h" ! 71: #include <stdio.h> ! 72: #include <stab.h> ! 73: ! 74: /* Stream for writing to assembler file. */ ! 75: ! 76: static FILE *asmfile; ! 77: ! 78: enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED}; ! 79: ! 80: /* Vector recording the status of describing C data types. ! 81: When we first notice a data type (a tree node), ! 82: we assign it a number using next_type_number. ! 83: That is its index in this vector. ! 84: The vector element says whether we have yet output ! 85: the definition of the type. TYPE_XREF says we have ! 86: output it as a cross-reference only. */ ! 87: ! 88: enum typestatus *typevec; ! 89: ! 90: /* Number of elements of space allocated in `typevec'. */ ! 91: ! 92: static int typevec_len; ! 93: ! 94: /* In dbx output, each type gets a unique number. ! 95: This is the number for the next type output. ! 96: The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */ ! 97: ! 98: static int next_type_number; ! 99: ! 100: /* In dbx output, we must assign symbol-blocks id numbers ! 101: in the order in which their beginnings are encountered. ! 102: We output debugging info that refers to the beginning and ! 103: end of the ranges of code in each block ! 104: with assembler labels LBBn and LBEn, where n is the block number. ! 105: The labels are generated in final, which assigns numbers to the ! 106: blocks in the same way. */ ! 107: ! 108: static int next_block_number; ! 109: ! 110: /* These variables are for dbxout_symbol to communicate to ! 111: dbxout_finish_symbol. ! 112: current_sym_code is the symbol-type-code, a symbol N_... define in stab.h. ! 113: current_sym_value and current_sym_addr are two ways to address the ! 114: value to store in the symtab entry. ! 115: current_sym_addr if nonzero represents the value as an rtx. ! 116: If that is zero, current_sym_value is used. This is used ! 117: when the value is an offset (such as for auto variables, ! 118: register variables and parms). */ ! 119: ! 120: static int current_sym_code; ! 121: static int current_sym_value; ! 122: static rtx current_sym_addr; ! 123: ! 124: /* Number of chars of symbol-description generated so far for the ! 125: current symbol. Used by CHARS and CONTIN. */ ! 126: ! 127: static int current_sym_nchars; ! 128: ! 129: /* Report having output N chars of the current symbol-description. */ ! 130: ! 131: #define CHARS(N) (current_sym_nchars += (N)) ! 132: ! 133: /* Break the current symbol-description, generating a continuation, ! 134: if it has become long. */ ! 135: ! 136: #define CONTIN \ ! 137: do {if (current_sym_nchars > 80) dbxout_continue ();} while (0) ! 138: ! 139: void dbxout_types (); ! 140: void dbxout_tags (); ! 141: static void dbxout_type_name (); ! 142: static void dbxout_type (); ! 143: static void dbxout_type_def (); ! 144: static void dbxout_finish_symbol (); ! 145: static void dbxout_continue (); ! 146: ! 147: /* At the beginning of compilation, start writing the symbol table. ! 148: Initialize `typevec' and output the standard data types of C. */ ! 149: ! 150: void ! 151: dbxout_init (asm_file, input_file_name) ! 152: FILE *asm_file; ! 153: char *input_file_name; ! 154: { ! 155: asmfile = asm_file; ! 156: ! 157: typevec_len = 100; ! 158: typevec = (enum typestatus *) xmalloc (typevec_len * sizeof typevec[0]); ! 159: bzero (typevec, typevec_len * sizeof typevec[0]); ! 160: ! 161: fprintf (asmfile, ! 162: "Ltext:\t.stabs \"%s\",%d,0,0,Ltext\n", ! 163: input_filename, N_SO); ! 164: ! 165: next_type_number = 1; ! 166: next_block_number = 2; ! 167: ! 168: /* Make sure that types `int' and `char' have numbers 1 and 2. ! 169: Definitions of other integer types will refer to those numbers. */ ! 170: ! 171: dbxout_type_def (integer_type_node); ! 172: dbxout_type_def (char_type_node); ! 173: ! 174: /* Get all permanent types not yet gotten ! 175: and output them. */ ! 176: ! 177: dbxout_types (get_permanent_types ()); ! 178: } ! 179: ! 180: /* Continue a symbol-description that gets too big. ! 181: End one symbol table entry with a double-backslash ! 182: and start a new one, eventually producing something like ! 183: .stabs "start......\\",code,0,value ! 184: .stabs "...rest",code,0,value */ ! 185: ! 186: static void ! 187: dbxout_continue () ! 188: { ! 189: fprintf (asmfile, "\\\\"); ! 190: dbxout_finish_symbol (); ! 191: fprintf (asmfile, ".stabs \""); ! 192: current_sym_nchars = 0; ! 193: } ! 194: ! 195: /* Output a reference to a type. If the type has not yet been ! 196: described in the dbx output, output its definition now. ! 197: For a type already defined, just refer to its definition ! 198: using the type number. ! 199: ! 200: If FULL is nonzero, and the type has been described only with ! 201: a forward-reference, output the definition now. ! 202: If FULL is zero in this case, just refer to the forward-reference ! 203: using the number previously allocated. */ ! 204: ! 205: static void ! 206: dbxout_type (type, full) ! 207: tree type; ! 208: int full; ! 209: { ! 210: register tree tem; ! 211: ! 212: if (TYPE_SYMTAB_ADDRESS (type) == 0) ! 213: { ! 214: /* Type has no dbx number assigned. Assign next available number. */ ! 215: TYPE_SYMTAB_ADDRESS (type) = next_type_number++; ! 216: ! 217: /* Make sure type vector is long enough to record about this type. */ ! 218: ! 219: if (next_type_number == typevec_len) ! 220: { ! 221: typevec = (enum typestatus *) xrealloc (typevec, typevec_len * 2 * sizeof typevec[0]); ! 222: bzero (typevec + typevec_len, typevec_len * sizeof typevec[0]); ! 223: typevec_len *= 2; ! 224: } ! 225: } ! 226: ! 227: /* Output the number of this type, to refer to it. */ ! 228: fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type)); ! 229: CHARS (3); ! 230: ! 231: /* If this type's definition has been output or is now being output, ! 232: that is all. */ ! 233: ! 234: switch (typevec[TYPE_SYMTAB_ADDRESS (type)]) ! 235: { ! 236: case TYPE_UNSEEN: ! 237: break; ! 238: case TYPE_XREF: ! 239: if (! full) ! 240: return; ! 241: break; ! 242: case TYPE_DEFINED: ! 243: return; ! 244: } ! 245: ! 246: /* Output a definition now. */ ! 247: ! 248: fprintf (asmfile, "="); ! 249: CHARS (1); ! 250: ! 251: /* Mark it as defined, so that if it is self-referent ! 252: we will not get into an infinite recursion of definitions. */ ! 253: ! 254: typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_DEFINED; ! 255: ! 256: switch (TREE_CODE (type)) ! 257: { ! 258: case VOID_TYPE: ! 259: /* For a void type, just define it as itself; ie, "5=5". ! 260: This makes us consider it defined ! 261: without saying what it is. The debugger will make it ! 262: a void type when the reference is seen, and nothing will ! 263: ever override that default. */ ! 264: fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type)); ! 265: CHARS (3); ! 266: break; ! 267: ! 268: case INTEGER_TYPE: ! 269: if (type == char_type_node) ! 270: /* Output the type `char' as a subrange of itself! ! 271: I don't understand this definition, just copied it ! 272: from the output of pcc. */ ! 273: fprintf (asmfile, "r2;0;127;"); ! 274: else ! 275: /* Output other integer types as subranges of `int'. */ ! 276: fprintf (asmfile, "r1;%d;%d;", ! 277: TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)), ! 278: TREE_INT_CST_LOW (TYPE_MAX_VALUE (type))); ! 279: CHARS (25); ! 280: break; ! 281: ! 282: case REAL_TYPE: ! 283: /* This must be magic. */ ! 284: fprintf (asmfile, "r1;%d;0;", ! 285: TREE_INT_CST_LOW (size_in_bytes (type))); ! 286: CHARS (16); ! 287: break; ! 288: ! 289: case ARRAY_TYPE: ! 290: /* Output "a" followed by a range type definition ! 291: for the index type of the array ! 292: followed by a reference to the target-type. ! 293: ar1;0;N;M for an array of type M and size N. */ ! 294: fprintf (asmfile, "ar1;0;%d;", ! 295: TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))); ! 296: CHARS (17); ! 297: dbxout_type (TREE_TYPE (type), 0); ! 298: break; ! 299: ! 300: case RECORD_TYPE: ! 301: case UNION_TYPE: ! 302: /* Output a structure type. */ ! 303: if ((TYPE_NAME (type) != 0 && !full) ! 304: || TYPE_SIZE (type) == 0) ! 305: { ! 306: /* If the type is just a cross reference, output one ! 307: and mark the type as partially described. ! 308: If it later becomes defined, we will output ! 309: its real definition. */ ! 310: fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu"); ! 311: CHARS (3); ! 312: dbxout_type_name (type); ! 313: fprintf (asmfile, ":"); ! 314: typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_XREF; ! 315: break; ! 316: } ! 317: tem = size_in_bytes (type); ! 318: fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "s%d" : "u%d", ! 319: TREE_INT_CST_LOW (tem)); ! 320: CHARS (11); ! 321: for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem)) ! 322: /* Output the name, type, position (in bits), size (in bits) ! 323: of each field. */ ! 324: /* Omit here the nameless fields that are used to skip bits. */ ! 325: if (DECL_NAME (tem) != 0) ! 326: { ! 327: CONTIN; ! 328: fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem))); ! 329: CHARS (1 + strlen (IDENTIFIER_POINTER (DECL_NAME (tem)))); ! 330: dbxout_type (TREE_TYPE (tem), 0); ! 331: fprintf (asmfile, ",%d,%d;", DECL_OFFSET (tem), ! 332: TREE_INT_CST_LOW (DECL_SIZE (tem)) * DECL_SIZE_UNIT (tem)); ! 333: CHARS (23); ! 334: } ! 335: putc (';', asmfile); ! 336: CHARS (1); ! 337: break; ! 338: ! 339: case ENUMERAL_TYPE: ! 340: if ((TYPE_NAME (type) != 0 && !full) ! 341: || TYPE_SIZE (type) == 0) ! 342: { ! 343: fprintf (asmfile, "xe"); ! 344: CHARS (3); ! 345: dbxout_type_name (type); ! 346: typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_XREF; ! 347: fprintf (asmfile, ":"); ! 348: return; ! 349: } ! 350: putc ('e', asmfile); ! 351: CHARS (1); ! 352: for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem)) ! 353: { ! 354: fprintf (asmfile, "%s:%d,", IDENTIFIER_POINTER (TREE_PURPOSE (tem)), ! 355: TREE_INT_CST_LOW (TREE_VALUE (tem))); ! 356: CHARS (11 + strlen (IDENTIFIER_POINTER (TREE_PURPOSE (tem)))); ! 357: if (TREE_CHAIN (tem) != 0) ! 358: CONTIN; ! 359: } ! 360: putc (';', asmfile); ! 361: CHARS (1); ! 362: break; ! 363: ! 364: case POINTER_TYPE: ! 365: putc ('*', asmfile); ! 366: CHARS (1); ! 367: dbxout_type (TREE_TYPE (type), 0); ! 368: break; ! 369: ! 370: case FUNCTION_TYPE: ! 371: putc ('f', asmfile); ! 372: CHARS (1); ! 373: dbxout_type (TREE_TYPE (type), 0); ! 374: break; ! 375: } ! 376: } ! 377: ! 378: /* Output the name of type TYPE, with no punctuation. ! 379: Such names can be set up either by typedef declarations ! 380: or by struct, enum and union tags. */ ! 381: ! 382: static void ! 383: dbxout_type_name (type) ! 384: register tree type; ! 385: { ! 386: register char *name; ! 387: if (TYPE_NAME (type) == 0) ! 388: abort (); ! 389: if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) ! 390: name = IDENTIFIER_POINTER (TYPE_NAME (type)); ! 391: else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL) ! 392: name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))); ! 393: else ! 394: abort (); ! 395: ! 396: fprintf (asmfile, "%s", name); ! 397: CHARS (strlen (name)); ! 398: } ! 399: ! 400: /* Output a .stabs for the symbol defined by DECL, ! 401: which must be a ..._DECL node in the normal namespace. ! 402: It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL. ! 403: LOCAL is nonzero if the scope is less than the entire file. */ ! 404: ! 405: void ! 406: dbxout_symbol (decl, local) ! 407: tree decl; ! 408: int local; ! 409: { ! 410: int symcode; ! 411: int letter; ! 412: ! 413: /* If global, first output all types and all ! 414: struct, enum and union tags that have been created ! 415: and not yet output. */ ! 416: ! 417: if (local == 0) ! 418: { ! 419: dbxout_tags (gettags ()); ! 420: dbxout_types (get_permanent_types ()); ! 421: } ! 422: ! 423: current_sym_code = 0; ! 424: current_sym_value = 0; ! 425: current_sym_addr = 0; ! 426: ! 427: /* The output will always start with the symbol name, ! 428: so count that always in the length-output-so-far. */ ! 429: ! 430: current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (decl))); ! 431: ! 432: switch (TREE_CODE (decl)) ! 433: { ! 434: case CONST_DECL: ! 435: /* Enum values are defined by defining the enum type. */ ! 436: break; ! 437: ! 438: case FUNCTION_DECL: ! 439: if (TREE_EXTERNAL (decl)) ! 440: break; ! 441: if (GET_CODE (DECL_RTL (decl)) != MEM ! 442: || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF) ! 443: break; ! 444: fprintf (asmfile, ".stabs \"%s:%c", ! 445: IDENTIFIER_POINTER (DECL_NAME (decl)), ! 446: TREE_PUBLIC (decl) ? 'F' : 'f'); ! 447: ! 448: current_sym_code = N_FUN; ! 449: current_sym_addr = XEXP (DECL_RTL (decl), 0); ! 450: ! 451: if (TREE_TYPE (TREE_TYPE (decl))) ! 452: dbxout_type (TREE_TYPE (TREE_TYPE (decl)), 0); ! 453: else ! 454: dbxout_type (void_type_node, 0); ! 455: dbxout_finish_symbol (); ! 456: break; ! 457: ! 458: case TYPE_DECL: ! 459: /* Output typedef name. */ ! 460: fprintf (asmfile, ".stabs \"%s:t", ! 461: IDENTIFIER_POINTER (DECL_NAME (decl))); ! 462: ! 463: current_sym_code = N_LSYM; ! 464: ! 465: dbxout_type (TREE_TYPE (decl), 0); ! 466: dbxout_finish_symbol (); ! 467: break; ! 468: ! 469: case PARM_DECL: ! 470: /* Parm decls go in their own separate chains ! 471: and are output by dbxout_reg_parms and dbxout_parms. */ ! 472: abort (); ! 473: ! 474: case VAR_DECL: ! 475: /* Don't mention a variable that is external. ! 476: Let the file that defines it describe it. */ ! 477: if (TREE_EXTERNAL (decl)) ! 478: break; ! 479: ! 480: /* Don't mention a variable at all ! 481: if it was completely optimized into nothingness. */ ! 482: if (GET_CODE (DECL_RTL (decl)) == REG ! 483: && REGNO (DECL_RTL (decl)) == -1) ! 484: break; ! 485: ! 486: /* Ok, start a symtab entry and output the variable name. */ ! 487: fprintf (asmfile, ".stabs \"%s:", ! 488: IDENTIFIER_POINTER (DECL_NAME (decl))); ! 489: ! 490: /* The kind-of-variable letter depends on where ! 491: the variable is and on the scope of its name: ! 492: G and N_GSYM for static storage and global scope, ! 493: S for static storage and file scope, ! 494: v for static storage and local scope, ! 495: for those two, use N_LCSYM if data is in bss segment, ! 496: N_STSYM if it is in data segment, or N_FUN if in text segment. ! 497: no letter at all, and N_LSYM, for auto variable, ! 498: r and N_RSYM for register variable. */ ! 499: ! 500: if (GET_CODE (DECL_RTL (decl)) == MEM ! 501: && GET_CODE (XEXP (DECL_RTL (decl), 0)) == SYMBOL_REF) ! 502: { ! 503: if (TREE_PUBLIC (decl)) ! 504: { ! 505: letter = 'G'; ! 506: current_sym_code = N_GSYM; ! 507: } ! 508: else ! 509: { ! 510: current_sym_addr = XEXP (DECL_RTL (decl), 0); ! 511: ! 512: letter = TREE_PERMANENT (decl) ? 'S' : 'v'; ! 513: ! 514: if (!DECL_INITIAL (decl)) ! 515: current_sym_code = N_LCSYM; ! 516: else if (TREE_READONLY (decl) && ! TREE_VOLATILE (decl)) ! 517: /* This is not quite right, but it's the closest ! 518: of all the codes that Unix defines. */ ! 519: current_sym_code = N_FUN; ! 520: else ! 521: current_sym_code = N_STSYM; ! 522: } ! 523: putc (letter, asmfile); ! 524: dbxout_type (TREE_TYPE (decl), 0); ! 525: dbxout_finish_symbol (); ! 526: } ! 527: else ! 528: { ! 529: if (GET_CODE (DECL_RTL (decl)) == REG) ! 530: { ! 531: letter = 'r'; ! 532: current_sym_code = N_RSYM; ! 533: current_sym_value = DBX_REGISTER_NUMBER (REGNO (DECL_RTL (decl))); ! 534: } ! 535: else ! 536: { ! 537: letter = 0; ! 538: current_sym_code = N_LSYM; ! 539: /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))). ! 540: We want the value of that CONST_INT. */ ! 541: current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (decl), 0), 1)); ! 542: } ! 543: if (letter) putc (letter, asmfile); ! 544: dbxout_type (TREE_TYPE (decl), 0); ! 545: dbxout_finish_symbol (); ! 546: } ! 547: break; ! 548: } ! 549: } ! 550: ! 551: static void ! 552: dbxout_finish_symbol () ! 553: { ! 554: fprintf (asmfile, "\",%d,0,0,", current_sym_code); ! 555: if (current_sym_addr) ! 556: output_addr_const (asmfile, current_sym_addr); ! 557: else ! 558: fprintf (asmfile, "%d", current_sym_value); ! 559: putc ('\n', asmfile); ! 560: } ! 561: ! 562: /* Output definitions of all the decls in a chain. */ ! 563: ! 564: static void ! 565: dbxout_syms (syms) ! 566: tree syms; ! 567: { ! 568: while (syms) ! 569: { ! 570: dbxout_symbol (syms, 1); ! 571: syms = TREE_CHAIN (syms); ! 572: } ! 573: } ! 574: ! 575: /* The following two functions output definitions of function parameters. ! 576: Each parameter gets a definition locating it in the parameter list. ! 577: Each parameter that is a register variable gets a second definition ! 578: locating it in the register. ! 579: ! 580: Printing or argument lists in gdb uses the definitions that ! 581: locate in the parameter list. But reference to the variable in ! 582: expressions uses preferentially the definition as a register. */ ! 583: ! 584: /* Output definitions, referring to storage in the parmlist, ! 585: of all the parms in PARMS, which is a chain of PARM_DECL nodes. */ ! 586: ! 587: static void ! 588: dbxout_parms (parms) ! 589: tree parms; ! 590: { ! 591: for (; parms; parms = TREE_CHAIN (parms)) ! 592: { ! 593: current_sym_code = N_PSYM; ! 594: current_sym_value = DECL_OFFSET (parms) / BITS_PER_UNIT; ! 595: /* A parm declared char is really passed as an int, ! 596: so it occupies the least significant bytes. ! 597: On a big-endian machine those are not the low-numbered ones. */ ! 598: #ifdef BYTES_BIG_ENDIAN ! 599: current_sym_value += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms))) ! 600: - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))); ! 601: #endif ! 602: current_sym_addr = 0; ! 603: current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms))); ! 604: ! 605: fprintf (asmfile, ".stabs \"%s:p", ! 606: IDENTIFIER_POINTER (DECL_NAME (parms))); ! 607: dbxout_type (TREE_TYPE (parms), 0); ! 608: dbxout_finish_symbol (); ! 609: } ! 610: } ! 611: ! 612: /* Output definitions, referring to registers, ! 613: of all the parms in PARMS which are stored in registers during the function. ! 614: PARMS is a chain of PARM_DECL nodes. */ ! 615: ! 616: static void ! 617: dbxout_reg_parms (parms) ! 618: tree parms; ! 619: { ! 620: while (parms) ! 621: { ! 622: if (GET_CODE (DECL_RTL (parms)) == REG ! 623: && REGNO (DECL_RTL (parms)) >= 0) ! 624: { ! 625: current_sym_code = N_RSYM; ! 626: current_sym_value = DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms))); ! 627: current_sym_addr = 0; ! 628: current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms))); ! 629: fprintf (asmfile, ".stabs \"%s:r", ! 630: IDENTIFIER_POINTER (DECL_NAME (parms))); ! 631: dbxout_type (TREE_TYPE (parms), 0); ! 632: dbxout_finish_symbol (); ! 633: } ! 634: parms = TREE_CHAIN (parms); ! 635: } ! 636: } ! 637: ! 638: /* Given a chain of ..._TYPE nodes, all of which have names, ! 639: output definitions of those names, as typedefs. */ ! 640: ! 641: void ! 642: dbxout_types (types) ! 643: register tree types; ! 644: { ! 645: while (types) ! 646: { ! 647: if (TYPE_NAME (types) ! 648: && TREE_CODE (TYPE_NAME (types)) == TYPE_DECL) ! 649: dbxout_type_def (types); ! 650: types = TREE_CHAIN (types); ! 651: } ! 652: } ! 653: ! 654: /* Output a definition of a typedef name. ! 655: It works much like any other kind of symbol definition. */ ! 656: ! 657: static void ! 658: dbxout_type_def (type) ! 659: tree type; ! 660: { ! 661: current_sym_code = N_LSYM; ! 662: current_sym_value = 0; ! 663: current_sym_addr = 0; ! 664: current_sym_nchars = 0; ! 665: current_sym_nchars ! 666: = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))); ! 667: ! 668: fprintf (asmfile, ".stabs \"%s:t", ! 669: IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))); ! 670: dbxout_type (type, 1); ! 671: dbxout_finish_symbol (); ! 672: } ! 673: ! 674: /* Output the tags (struct, union and enum definitions with names) for a block, ! 675: given a list of them (a chain of TREE_LIST nodes) in TAGS. ! 676: We must check to include those that have been mentioned already with ! 677: only a cross-reference. */ ! 678: ! 679: void ! 680: dbxout_tags (tags) ! 681: tree tags; ! 682: { ! 683: register tree link; ! 684: for (link = tags; link; link = TREE_CHAIN (link)) ! 685: { ! 686: register tree type = TREE_VALUE (link); ! 687: if (TREE_PURPOSE (link) != 0 ! 688: && (TYPE_SYMTAB_ADDRESS (type) == 0 ! 689: || (typevec[TYPE_SYMTAB_ADDRESS (type)] != TYPE_DEFINED)) ! 690: && TYPE_SIZE (type) != 0) ! 691: { ! 692: current_sym_code = N_LSYM; ! 693: current_sym_value = 0; ! 694: current_sym_addr = 0; ! 695: current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (TREE_PURPOSE (link))); ! 696: ! 697: fprintf (asmfile, ".stabs \"%s:T", ! 698: IDENTIFIER_POINTER (TREE_PURPOSE (link))); ! 699: dbxout_type (type, 1); ! 700: dbxout_finish_symbol (); ! 701: typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_DEFINED; ! 702: } ! 703: } ! 704: } ! 705: ! 706: /* Output everything about a symbol block (that is to say, a LET_STMT node ! 707: that represents a scope level), ! 708: including recursive output of contained blocks. ! 709: ! 710: STMT is the LET_STMT node. ! 711: DEPTH is its depth within containing symbol blocks. ! 712: ARGS is usually zero; but for the outermost block of the ! 713: body of a function, it is a chain of PARM_DECLs for the function parameters. ! 714: We output definitions of all the register parms ! 715: as if they were local variables of that block. ! 716: ! 717: Actually, STMT may be several statements chained together. ! 718: We handle them all in sequence. */ ! 719: ! 720: static void ! 721: dbxout_block (stmt, depth, args) ! 722: register tree stmt; ! 723: int depth; ! 724: { ! 725: int blocknum; ! 726: ! 727: while (stmt) ! 728: { ! 729: switch (TREE_CODE (stmt)) ! 730: { ! 731: case COMPOUND_STMT: ! 732: case LOOP_STMT: ! 733: dbxout_block (STMT_BODY (stmt), depth, 0); ! 734: break; ! 735: ! 736: case IF_STMT: ! 737: dbxout_block (STMT_THEN (stmt), depth, 0); ! 738: dbxout_block (STMT_ELSE (stmt), depth, 0); ! 739: break; ! 740: ! 741: case LET_STMT: ! 742: /* In dbx format, the syms of a block come before the N_LBRAC. */ ! 743: dbxout_tags (STMT_TYPE_TAGS (stmt)); ! 744: dbxout_syms (STMT_VARS (stmt), 1); ! 745: if (args) ! 746: dbxout_reg_parms (args); ! 747: ! 748: /* Now output an N_LBRAC symbol to represent the beginning of ! 749: the block. Use the block's tree-walk order to generate ! 750: the assembler symbols LBBn and LBEn ! 751: that final will define around the code in this block. */ ! 752: if (depth > 0) ! 753: { ! 754: blocknum = next_block_number++; ! 755: fprintf (asmfile, ".stabn %d,0,0,LBB%d\n", N_LBRAC, blocknum); ! 756: } ! 757: ! 758: /* Output the interior of the block. */ ! 759: dbxout_block (STMT_BODY (stmt), depth + 1, 0); ! 760: ! 761: /* Refer to the marker for the end of the block. */ ! 762: if (depth > 0) ! 763: fprintf (asmfile, ".stabn %d,0,0,LBE%d\n", N_RBRAC, blocknum); ! 764: } ! 765: stmt = TREE_CHAIN (stmt); ! 766: } ! 767: } ! 768: ! 769: /* Output dbx data for a function definition. ! 770: This includes a definition of the function name itself (a symbol), ! 771: definitions of the parameters (locating them in the parameter list) ! 772: and then output the block that makes up the function's body ! 773: (including all the auto variables of the function). */ ! 774: ! 775: void ! 776: dbxout_function (decl) ! 777: tree decl; ! 778: { ! 779: dbxout_symbol (decl, 0); ! 780: dbxout_parms (DECL_ARGUMENTS (decl)); ! 781: dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl)); ! 782: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.