![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to symout.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / gcc|
Return to symout.c CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 ! root 1: /* Output GDB-format symbol table information from GNU compiler. ! 2: Copyright (C) 1987, 1988 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: #include "config.h" ! 23: #include "tree.h" ! 24: #include "symseg.h" ! 25: #include "rtl.h" ! 26: #include "gdbfiles.h" ! 27: #include <stdio.h> ! 28: ! 29: /* Get N_SO from stab.h if we can expect the file to exist. */ ! 30: #ifndef NO_DBX_FORMAT ! 31: #include <stab.h> ! 32: #endif ! 33: ! 34: /* .stabs code for source file name. */ ! 35: #ifndef N_SO ! 36: #define N_SO 0x64 ! 37: #endif ! 38: ! 39: /* Unix maximum on file name length. Needed for getwd. */ ! 40: #define MAXNAMLEN 1024 ! 41: ! 42: /* Get the number to output for a reference to type TYPE. */ ! 43: #define TYPE_OUTPUT_ADDRESS(TYPE) \ ! 44: TYPE_SYMTAB_ADDRESS (TYPE_MAIN_VARIANT (TYPE)) ! 45: ! 46: /* Stream for writing symbol table file. */ ! 47: static FILE *symfile; ! 48: ! 49: /* Name of symbol table file. */ ! 50: static char *symfile_name; ! 51: ! 52: /* Stream for writing to assembler file. */ ! 53: static FILE *asmfile; ! 54: ! 55: /* Address for allocating space in symbol table file. ! 56: Changes in this variable are paired globally with writes to symfile, ! 57: but often we allocate many structures, advancing next_address, ! 58: before writing any of them. */ ! 59: static int next_address; ! 60: ! 61: /* Chain recording all the types that have been output, ! 62: giving the address-in-the-symseg of each one. */ ! 63: ! 64: struct typevec_elt ! 65: { ! 66: int address; ! 67: struct typevec_elt *next; ! 68: }; ! 69: ! 70: static struct typevec_elt *typevec; ! 71: ! 72: /* Number of types recorded so far in the chain. */ ! 73: ! 74: static int total_types; ! 75: ! 76: /* `blockvec' is a chain recording all the symbol-blocks that have been output, ! 77: giving the address-in-the-symseg of each one. */ ! 78: ! 79: struct blockvec_elt ! 80: { ! 81: int address; ! 82: struct blockvec_elt *next; ! 83: }; ! 84: ! 85: static struct blockvec_elt *blockvec; ! 86: ! 87: /* Number of blocks recorded so far in the chain. */ ! 88: ! 89: static int total_blocks; ! 90: ! 91: static void symout_range_bounds (); ! 92: static void symout_array_domain (); ! 93: static void symout_record_fields (); ! 94: static void symout_enum_values (); ! 95: static void symout_record_field_names (); ! 96: static void symout_enum_value_names (); ! 97: static int subrange_p (); ! 98: static void symout_strings_skip (); ! 99: static void symout_strings_print (); ! 100: ! 101: /* At the beginning of compilation, start writing the symbol table. ! 102: Initialize the type and block chain. ! 103: Also open and initialize the symseg file. */ ! 104: ! 105: void ! 106: symout_init (filename, asm_file, sourcename) ! 107: char *filename; ! 108: FILE *asm_file; ! 109: char *sourcename; ! 110: { ! 111: struct symbol_root buffer; ! 112: ! 113: #ifdef VMS ! 114: fatal ("Cannot write GDB debugging format on VMS"); ! 115: #endif ! 116: ! 117: asmfile = asm_file; ! 118: fprintf (asmfile, ".text 0\n.gdbbeg 0\n.gdbbeg 1\n"); ! 119: fprintf (asmfile, ! 120: "Ltext:\t.stabs \"%s\",%d,0,0,Ltext\n", ! 121: sourcename, N_SO); ! 122: fprintf (asmfile, ".data 0\nLdata:\n"); ! 123: ASM_OUTPUT_LOCAL (asmfile, "Lbss", 0); ! 124: fprintf (asmfile, ".gdbsym Ldata,%d\n", ! 125: (char *) &buffer.databeg - (char *) &buffer); ! 126: fprintf (asmfile, ".gdbsym Lbss,%d\n", ! 127: (char *) &buffer.bssbeg - (char *) &buffer); ! 128: ! 129: symfile = fopen (filename, "w"); ! 130: if (symfile == 0) ! 131: pfatal_with_name (symfile); ! 132: symfile_name = (char *) malloc (strlen (filename) + 1); ! 133: strcpy (symfile_name, filename); ! 134: ! 135: typevec = 0; ! 136: blockvec = 0; ! 137: total_types = 0; ! 138: total_blocks = 0; ! 139: ! 140: bzero (&buffer, sizeof buffer); ! 141: fwrite (&buffer, sizeof buffer, 1, symfile); ! 142: ! 143: next_address = sizeof buffer; ! 144: } ! 145: ! 146: /* Functions for outputting strings into the symbol table. ! 147: The string to be output is effectively the concatenation of ! 148: the two strings P1 and P2. Their lengths are given as S1 and S2. ! 149: If P1 or P2 is zero, that string is not used. ! 150: ! 151: A null character is output to terminate the string, ! 152: and it is followed by more nulls as padding to a word boundary. */ ! 153: ! 154: static void ! 155: symout_strings (p1, s1, p2, s2) ! 156: char *p1; ! 157: int s1; ! 158: char *p2; ! 159: int s2; ! 160: { ! 161: symout_strings_print (p1, s1, p2, s2); ! 162: symout_strings_skip (p1, s1, p2, s2); ! 163: } ! 164: ! 165: /* Like symout_strings but only output; do not update next_address. */ ! 166: ! 167: static void ! 168: symout_strings_print (p1, s1, p2, s2) ! 169: char *p1; ! 170: int s1; ! 171: char *p2; ! 172: int s2; ! 173: { ! 174: register int total; ! 175: ! 176: if (p1 && s1 == 0) ! 177: s1 = strlen (p1); ! 178: if (p2 && s2 == 0) ! 179: s2 = strlen (p2); ! 180: ! 181: if (p1) ! 182: fwrite (p1, s1, 1, symfile); ! 183: if (p2) ! 184: fwrite (p2, s2, 1, symfile); ! 185: putc (0, symfile); ! 186: ! 187: total = s1 + s2 + 1; ! 188: while (total % sizeof (int)) ! 189: { ! 190: putc (0, symfile); ! 191: total++; ! 192: } ! 193: } ! 194: ! 195: /* Like symout_strings but just update next_address; do not output. */ ! 196: ! 197: static void ! 198: symout_strings_skip (p1, s1, p2, s2) ! 199: char *p1; ! 200: int s1; ! 201: char *p2; ! 202: int s2; ! 203: { ! 204: register int total; ! 205: ! 206: if (p1 && s1 == 0) ! 207: s1 = strlen (p1); ! 208: if (p2 && s2 == 0) ! 209: s2 = strlen (p2); ! 210: ! 211: total = s1 + s2 + 1; ! 212: while (total % sizeof (int)) ! 213: total++; ! 214: ! 215: next_address += total; ! 216: } ! 217: ! 218: /* Call here to output a chain of types. ! 219: After each function, this is done first for the chain of permanent types ! 220: made during the function, and then for the chain of temporary types. ! 221: This must be done before outputting the symbols and blocks of the function. ! 222: ! 223: At the end of compilation, this is done for all the permanent types ! 224: made since the last function. ! 225: ! 226: Each permanent type is done once, at the beginning of the next function, ! 227: or at the end of the compilation if no functions follow. ! 228: Once a type has been processed here, its TYPE_SYMTAB_ADDRESS remains ! 229: set up. */ ! 230: ! 231: void ! 232: symout_types (types) ! 233: tree types; ! 234: { ! 235: struct typerec ! 236: { ! 237: int number; ! 238: int address; ! 239: int nfields; ! 240: int fields_address; ! 241: int name_address; ! 242: char *name; ! 243: char *name_prefix; ! 244: }; ! 245: ! 246: register int n_types, i; ! 247: register struct typerec *records; ! 248: register tree next; ! 249: struct type buffer; ! 250: ! 251: for (next = types, n_types = 0; ! 252: next; ! 253: next = TREE_CHAIN (next), n_types++); ! 254: ! 255: records = (struct typerec *) alloca (n_types * sizeof (struct typerec)); ! 256: ! 257: for (next = types, i = 0; ! 258: next; ! 259: next = TREE_CHAIN (next), i++) ! 260: { ! 261: register struct typevec_elt *velt ! 262: = (struct typevec_elt *) xmalloc (sizeof (struct typevec_elt)); ! 263: velt->next = typevec; ! 264: typevec = velt; ! 265: ! 266: total_types++; ! 267: ! 268: if (TYPE_NAME (next)) ! 269: { ! 270: records[i].name_address = next_address; ! 271: ! 272: if (TREE_CODE (TYPE_NAME (next)) == IDENTIFIER_NODE) ! 273: { ! 274: records[i].name = IDENTIFIER_POINTER (TYPE_NAME (next)); ! 275: switch (TREE_CODE (next)) ! 276: { ! 277: case RECORD_TYPE: ! 278: records[i].name_prefix = "struct "; ! 279: break; ! 280: ! 281: case UNION_TYPE: ! 282: records[i].name_prefix = "union "; ! 283: break; ! 284: ! 285: case ENUMERAL_TYPE: ! 286: records[i].name_prefix = "enum "; ! 287: break; ! 288: } ! 289: } ! 290: else ! 291: { ! 292: records[i].name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (next))); ! 293: records[i].name_prefix = 0; ! 294: } ! 295: symout_strings_skip (records[i].name_prefix, 0, ! 296: records[i].name, 0); ! 297: ! 298: } ! 299: else ! 300: { ! 301: records[i].name = 0; ! 302: records[i].name_address = 0; ! 303: records[i].name_prefix = 0; ! 304: } ! 305: ! 306: records[i].address = next_address; ! 307: TYPE_SYMTAB_ADDRESS (next) = next_address; ! 308: velt->address = next_address; ! 309: next_address += sizeof (struct type); ! 310: records[i].nfields = 0; ! 311: records[i].fields_address = 0; ! 312: switch (TREE_CODE (next)) ! 313: { ! 314: case ARRAY_TYPE: ! 315: records[i].nfields ! 316: = (TYPE_DOMAIN(next) ! 317: ? ! integer_zerop (TYPE_MIN_VALUE (TYPE_DOMAIN (next))) ! 318: : 0 ); ! 319: break; ! 320: ! 321: case INTEGER_TYPE: ! 322: if (subrange_p (next)) ! 323: buffer.nfields = 2; ! 324: break; ! 325: ! 326: case RECORD_TYPE: ! 327: case UNION_TYPE: ! 328: case ENUMERAL_TYPE: ! 329: records[i].nfields = list_length (TYPE_FIELDS (next)); ! 330: } ! 331: if (records[i].nfields) ! 332: records[i].fields_address = next_address; ! 333: next_address += records[i].nfields * sizeof (struct field); ! 334: } ! 335: ! 336: for (next = types, i = 0; ! 337: next; ! 338: next = TREE_CHAIN (next), i++) ! 339: { ! 340: if (records[i].name) ! 341: symout_strings_print (records[i].name_prefix, 0, ! 342: records[i].name, 0); ! 343: ! 344: if (TYPE_SIZE (next) == 0) ! 345: buffer.length = 0; ! 346: else ! 347: buffer.length ! 348: = (TREE_INT_CST_LOW (TYPE_SIZE (next)) ! 349: * TYPE_SIZE_UNIT (next) / BITS_PER_UNIT); ! 350: buffer.name = (char *) records[i].name_address; ! 351: buffer.target_type = (struct type *) (TREE_TYPE (next) ? TYPE_OUTPUT_ADDRESS (TREE_TYPE (next)) : 0); ! 352: ! 353: buffer.pointer_type = 0; ! 354: buffer.function_type = 0; ! 355: buffer.flags ! 356: = ((TREE_CODE (next) == INTEGER_TYPE || TREE_CODE (next) == ENUMERAL_TYPE) ! 357: && TREE_UNSIGNED (next)) ! 358: ? TYPE_FLAG_UNSIGNED : 0; ! 359: buffer.nfields = records[i].nfields; ! 360: buffer.fields = (struct field *) records[i].fields_address; ! 361: ! 362: switch (TREE_CODE (next)) ! 363: { ! 364: case INTEGER_TYPE: ! 365: buffer.code = TYPE_CODE_INT; ! 366: if (buffer.nfields) ! 367: buffer.code = TYPE_CODE_RANGE; ! 368: break; ! 369: ! 370: case REAL_TYPE: ! 371: buffer.code = TYPE_CODE_FLT; ! 372: break; ! 373: ! 374: case VOID_TYPE: ! 375: buffer.code = TYPE_CODE_VOID; ! 376: break; ! 377: ! 378: case POINTER_TYPE: ! 379: buffer.code = TYPE_CODE_PTR; ! 380: break; ! 381: ! 382: case ARRAY_TYPE: ! 383: if (buffer.nfields == 0) ! 384: buffer.code = TYPE_CODE_ARRAY; ! 385: else ! 386: buffer.code = TYPE_CODE_PASCAL_ARRAY; ! 387: break; ! 388: ! 389: case RECORD_TYPE: ! 390: buffer.code = TYPE_CODE_STRUCT; ! 391: break; ! 392: ! 393: case UNION_TYPE: ! 394: buffer.code = TYPE_CODE_UNION; ! 395: break; ! 396: ! 397: case FUNCTION_TYPE: ! 398: buffer.code = TYPE_CODE_FUNC; ! 399: break; ! 400: ! 401: case ENUMERAL_TYPE: ! 402: buffer.code = TYPE_CODE_ENUM; ! 403: break; ! 404: ! 405: default: ! 406: abort (); ! 407: } ! 408: ! 409: fwrite (&buffer, sizeof buffer, 1, symfile); ! 410: ! 411: switch (TREE_CODE (next)) ! 412: { ! 413: case ARRAY_TYPE: ! 414: if (buffer.nfields) ! 415: symout_array_domain (next); ! 416: break; ! 417: ! 418: case RECORD_TYPE: ! 419: case UNION_TYPE: ! 420: symout_record_fields (next); ! 421: break; ! 422: ! 423: case ENUMERAL_TYPE: ! 424: symout_enum_values (next); ! 425: break; ! 426: ! 427: case INTEGER_TYPE: ! 428: if (buffer.nfields) ! 429: symout_range_bounds (next); ! 430: } ! 431: } ! 432: ! 433: for (next = types, i = 0; ! 434: next; ! 435: next = TREE_CHAIN (next), i++) ! 436: { ! 437: switch (TREE_CODE (next)) ! 438: { ! 439: case RECORD_TYPE: ! 440: case UNION_TYPE: ! 441: symout_record_field_names (next); ! 442: break; ! 443: ! 444: case ENUMERAL_TYPE: ! 445: symout_enum_value_names (next); ! 446: break; ! 447: } ! 448: } ! 449: } ! 450: ! 451: /* Return nonzero if TYPE's range of possible values ! 452: is not the full range allowed by the number of bits it has. ! 453: TYPE is assumed to be an INTEGER_TYPE or ENUMERAL_TYPE. */ ! 454: ! 455: static int ! 456: subrange_p (type) ! 457: tree type; ! 458: { ! 459: int uns = TREE_UNSIGNED (type); ! 460: ! 461: if (TYPE_PRECISION (type) >= HOST_BITS_PER_INT) ! 462: { ! 463: if (uns) ! 464: return integer_zerop (TYPE_MIN_VALUE (type)) ! 465: && TREE_INT_CST_LOW (TYPE_MAX_VALUE (type)) == 0 ! 466: && (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (type)) ! 467: == (1 << (TYPE_PRECISION (type) - HOST_BITS_PER_INT)) - 1); ! 468: return TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)) == 0 ! 469: && TREE_INT_CST_LOW (TYPE_MAX_VALUE (type)) == 0 ! 470: && (TREE_INT_CST_HIGH (TYPE_MIN_VALUE (type)) ! 471: == (-1) << (TYPE_PRECISION (type) - 1 - HOST_BITS_PER_INT)) ! 472: && (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (type)) ! 473: == (1 << (TYPE_PRECISION (type) - 1 - HOST_BITS_PER_INT)) - 1); ! 474: } ! 475: ! 476: if (uns) ! 477: return integer_zerop (TYPE_MIN_VALUE (type)) ! 478: && (TREE_INT_CST_LOW (TYPE_MAX_VALUE (type)) ! 479: == (1 << TYPE_PRECISION (type)) - 1); ! 480: else ! 481: return (TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)) ! 482: == (-1) << (TYPE_PRECISION (type) - 1)) ! 483: && (TREE_INT_CST_LOW (TYPE_MAX_VALUE (type)) ! 484: == (1 << (TYPE_PRECISION (type) - 1)) - 1); ! 485: } ! 486: ! 487: /* Functions to output the "fields" of various kinds of types. ! 488: These assume that next_address has already been incremented to ! 489: cover these fields, and the fields of all the other types being ! 490: output in this batch; so next_address can be used to allocate ! 491: space to store field names, etc. */ ! 492: ! 493: static void ! 494: symout_array_domain (type) ! 495: tree type; ! 496: { ! 497: struct field buffer; ! 498: ! 499: buffer.bitpos = 0; ! 500: buffer.bitsize = 0; ! 501: buffer.type = (struct type *) TYPE_OUTPUT_ADDRESS (TYPE_DOMAIN (type)); ! 502: buffer.name = 0; ! 503: fwrite (&buffer, sizeof (struct field), 1, symfile); ! 504: } ! 505: ! 506: static void ! 507: symout_range_bounds (type) ! 508: tree type; ! 509: { ! 510: struct field buffer; ! 511: ! 512: buffer.bitpos = TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)); ! 513: buffer.bitsize = 0; ! 514: buffer.type = (struct type *) TYPE_OUTPUT_ADDRESS (type); ! 515: buffer.name = 0; ! 516: fwrite (&buffer, sizeof (struct field), 1, symfile); ! 517: ! 518: buffer.bitpos = TREE_INT_CST_LOW (TYPE_MAX_VALUE (type)); ! 519: buffer.bitsize = 0; ! 520: buffer.type = (struct type *) TYPE_OUTPUT_ADDRESS (type); ! 521: buffer.name = 0; ! 522: fwrite (&buffer, sizeof (struct field), 1, symfile); ! 523: } ! 524: ! 525: static void ! 526: symout_record_fields (type) ! 527: tree type; ! 528: { ! 529: struct field buffer; ! 530: register tree field; ! 531: ! 532: for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) ! 533: { ! 534: buffer.bitpos = DECL_OFFSET (field); ! 535: buffer.bitsize ! 536: = (TREE_PACKED (field) ! 537: ? TREE_INT_CST_LOW (DECL_SIZE (field)) * DECL_SIZE_UNIT (field) ! 538: : 0); ! 539: buffer.type = (struct type *) TYPE_OUTPUT_ADDRESS (TREE_TYPE (field)); ! 540: if (DECL_NAME (field)) ! 541: { ! 542: buffer.name = (char *) next_address; ! 543: symout_strings_skip (0, IDENTIFIER_LENGTH (DECL_NAME (field)), 0, 0); ! 544: } ! 545: else ! 546: buffer.name = 0; ! 547: fwrite (&buffer, sizeof (struct field), 1, symfile); ! 548: } ! 549: } ! 550: ! 551: static void ! 552: symout_enum_values (type) ! 553: tree type; ! 554: { ! 555: struct field buffer; ! 556: register tree link, value; ! 557: ! 558: for (link = TYPE_VALUES (type); link; link = TREE_CHAIN (link)) ! 559: { ! 560: value = TREE_VALUE (link); ! 561: buffer.bitpos = TREE_INT_CST_LOW (value); ! 562: buffer.bitsize = 0; ! 563: buffer.type = (struct type *) TYPE_OUTPUT_ADDRESS (type); ! 564: buffer.name = (char *) next_address; ! 565: symout_strings_skip (0, IDENTIFIER_LENGTH (TREE_PURPOSE (link)), 0, 0); ! 566: fwrite (&buffer, sizeof buffer, 1, symfile); ! 567: } ! 568: } ! 569: ! 570: /* Output field names or value names for the fields of a type. ! 571: This is called, for the types that need it, after the fields ! 572: have been output for all the types in the batch. ! 573: We do not update next_address here, because it has already been ! 574: updated for all the names in all the fields in all the types. */ ! 575: ! 576: static void ! 577: symout_record_field_names (type) ! 578: tree type; ! 579: { ! 580: register tree field; ! 581: ! 582: for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) ! 583: if (DECL_NAME (field)) ! 584: symout_strings_print (IDENTIFIER_POINTER (DECL_NAME (field)), ! 585: IDENTIFIER_LENGTH (DECL_NAME (field)), ! 586: 0, 0); ! 587: } ! 588: ! 589: static void ! 590: symout_enum_value_names (type) ! 591: tree type; ! 592: { ! 593: register tree value; ! 594: ! 595: for (value = TYPE_VALUES (type); value; value = TREE_CHAIN (value)) ! 596: symout_strings_print (IDENTIFIER_POINTER (TREE_PURPOSE (value)), ! 597: IDENTIFIER_LENGTH (TREE_PURPOSE (value)), ! 598: 0, 0); ! 599: } ! 600: ! 601: /* Output the symbols of a block, given the list of decl nodes. ! 602: Store the file addresses at which the symbols are output ! 603: into ADDR_BUFFER, a vector which has just the right length. ! 604: ! 605: If FILTER is 1, do only the private symbols in DECLS. ! 606: If FILTER is 2, do only the public ones (but no externals). ! 607: If FILTER is 0, do all (except external functions). */ ! 608: ! 609: static void ! 610: symout_block_symbols (decls, addr_buffer, filter) ! 611: tree decls; ! 612: int *addr_buffer; ! 613: int filter; ! 614: { ! 615: register tree decl; ! 616: struct symbol buffer; ! 617: register int i; ! 618: ! 619: for (decl = decls, i = 0; decl; decl = TREE_CHAIN (decl)) ! 620: { ! 621: register name_address = next_address; ! 622: ! 623: if (filter == (TREE_PUBLIC (decl) ? 1 : 2)) ! 624: continue; ! 625: ! 626: /* Do not mention external functions. ! 627: Let their own files mention them. ! 628: In the top blocks, don't mention external anything. */ ! 629: ! 630: if (TREE_EXTERNAL (decl) ! 631: && (filter || TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)) ! 632: continue; ! 633: ! 634: if (TREE_TYPE (decl) == error_mark_node) ! 635: continue; ! 636: ! 637: symout_strings (IDENTIFIER_POINTER (DECL_NAME (decl)), ! 638: IDENTIFIER_LENGTH (DECL_NAME (decl)), ! 639: 0, 0); ! 640: addr_buffer[i] = next_address; ! 641: buffer.name = (char *) name_address; ! 642: buffer.namespace = VAR_NAMESPACE; ! 643: buffer.type = (struct type *) TYPE_OUTPUT_ADDRESS (TREE_TYPE (decl)); ! 644: switch (TREE_CODE (decl)) ! 645: { ! 646: case PARM_DECL: ! 647: buffer.class = LOC_ARG; ! 648: buffer.value.value = DECL_OFFSET (decl) / BITS_PER_UNIT; ! 649: break; ! 650: ! 651: case VAR_DECL: ! 652: case RESULT_DECL: ! 653: if (TREE_STATIC (decl) || TREE_EXTERNAL (decl)) ! 654: { ! 655: if (! TREE_PUBLIC (decl) || DECL_INITIAL (decl)) ! 656: { ! 657: char *str = XSTR (XEXP (DECL_RTL (decl), 0), 0); ! 658: fprintf (asmfile, "\t.gdbsym "); ! 659: ASM_OUTPUT_LABELREF (asmfile, str); ! 660: fprintf (asmfile, ",%d\n", ! 661: next_address + (char *)&buffer.value - (char *)&buffer); ! 662: buffer.class = LOC_STATIC; ! 663: } ! 664: else ! 665: /* Uninitialized public symbols are output as .comm; ! 666: Tell GDB to get address from loader global symbol. ! 667: Also come here for symbols declared extern. */ ! 668: buffer.class = LOC_EXTERNAL; ! 669: } ! 670: else ! 671: { ! 672: if (GET_CODE (DECL_RTL (decl)) == REG) ! 673: { ! 674: buffer.class = LOC_REGISTER; ! 675: buffer.value.value = REGNO (DECL_RTL (decl)); ! 676: /* Detect vars that were optimized entirely away. */ ! 677: if (buffer.value.value == -1) ! 678: buffer.class = LOC_CONST; ! 679: } ! 680: /* Locals in memory are expected to be addressed as ! 681: (PLUS (REG ...) (CONST_INT ...)). ! 682: Bomb out if that is not so. */ ! 683: else if (GET_CODE (DECL_RTL (decl)) == MEM) ! 684: { ! 685: register rtx addr = XEXP (DECL_RTL (decl), 0); ! 686: if (GET_CODE (addr) != PLUS && GET_CODE (addr) != MINUS) ! 687: abort (); ! 688: if (GET_CODE (XEXP (addr, 1)) != CONST_INT) ! 689: abort (); ! 690: buffer.class = LOC_LOCAL; ! 691: buffer.value.value = INTVAL (XEXP (addr, 1)); ! 692: if (GET_CODE (addr) == MINUS) ! 693: buffer.value.value = - buffer.value.value; ! 694: } ! 695: else ! 696: abort (); ! 697: } ! 698: break; ! 699: ! 700: case TYPE_DECL: ! 701: buffer.class = LOC_TYPEDEF; ! 702: buffer.value.value = 0; ! 703: break; ! 704: ! 705: case CONST_DECL: ! 706: buffer.class = LOC_CONST; ! 707: buffer.value.value = TREE_INT_CST_LOW (DECL_INITIAL (decl)); ! 708: break; ! 709: ! 710: case FUNCTION_DECL: ! 711: if (DECL_INITIAL (decl)) ! 712: { ! 713: buffer.class = LOC_BLOCK; ! 714: buffer.value.value = DECL_BLOCK_SYMTAB_ADDRESS (decl); ! 715: } ! 716: else ! 717: buffer.class = LOC_EXTERNAL; ! 718: } ! 719: ! 720: fwrite (&buffer, sizeof buffer, 1, symfile); ! 721: next_address += sizeof buffer; ! 722: i++; ! 723: } ! 724: } ! 725: ! 726: /* Output the tags (struct, union and enum definitions) for a block, ! 727: given a list of them (a chain of TREE_LIST nodes) in TAGS. ! 728: Store their addresses in the file into ADDR_BUFFER. */ ! 729: ! 730: static void ! 731: symout_block_tags (tags, addr_buffer) ! 732: tree tags; ! 733: int *addr_buffer; ! 734: { ! 735: register tree tag; ! 736: struct symbol buffer; ! 737: register int i; ! 738: ! 739: for (tag = tags, i = 0; tag; tag = TREE_CHAIN (tag), i++) ! 740: { ! 741: buffer.name = (char *) next_address; ! 742: ! 743: symout_strings (IDENTIFIER_POINTER (TREE_PURPOSE (tag)), ! 744: IDENTIFIER_LENGTH (TREE_PURPOSE (tag)), ! 745: 0, 0); ! 746: addr_buffer[i] = next_address; ! 747: buffer.namespace = STRUCT_NAMESPACE; ! 748: buffer.type = (struct type *) TYPE_OUTPUT_ADDRESS (TREE_VALUE (tag)); ! 749: buffer.class = LOC_TYPEDEF; ! 750: buffer.value.value = 0; ! 751: ! 752: fwrite (&buffer, sizeof buffer, 1, symfile); ! 753: next_address += sizeof buffer; ! 754: } ! 755: } ! 756: ! 757: /* Output all the data structure for a "block" ! 758: (any binding contour). ! 759: DECLS is the chain of declarations of variables in this block. ! 760: TAGS is the list of struct, union and enum tag definitions of this block. ! 761: SUPERBLOCK_ADDRESS is the symtab file address of the containing block's ! 762: data structure. */ ! 763: ! 764: int ! 765: symout_block (decls, tags, args, superblock_address) ! 766: tree decls; ! 767: tree tags; ! 768: tree args; ! 769: int superblock_address; ! 770: { ! 771: register tree decl; ! 772: register int i; ! 773: register int *addr_buffer; ! 774: struct block buffer; ! 775: int n_decls, n_tags, n_args, total; ! 776: register struct blockvec_elt *velt; ! 777: int block_address; ! 778: ! 779: for (decl = decls, i = 0; decl; decl = TREE_CHAIN (decl)) ! 780: if (! TREE_EXTERNAL (decl) ! 781: || TREE_CODE (TREE_TYPE (decl)) != FUNCTION_TYPE) ! 782: i++; ! 783: ! 784: n_decls = i; ! 785: ! 786: for (decl = args, i = 0; decl; decl = TREE_CHAIN (decl), i++); ! 787: n_args = i; ! 788: ! 789: for (decl = tags, i = 0; decl; decl = TREE_CHAIN (decl), i++); ! 790: n_tags = i; ! 791: ! 792: total = n_decls + n_args + n_tags; ! 793: ! 794: addr_buffer = (int *) alloca (total * sizeof (int)); ! 795: ! 796: symout_block_symbols (args, addr_buffer, 0); ! 797: symout_block_symbols (decls, addr_buffer + n_args, 0); ! 798: symout_block_tags (tags, addr_buffer + n_decls + n_args); ! 799: ! 800: velt = (struct blockvec_elt *) xmalloc (sizeof (struct blockvec_elt)); ! 801: velt->next = blockvec; ! 802: velt->address = next_address; ! 803: blockvec = velt; ! 804: ! 805: buffer.startaddr = 0; ! 806: buffer.endaddr = 0; ! 807: buffer.superblock = (struct block *) superblock_address; ! 808: buffer.function = 0; ! 809: buffer.nsyms = total; ! 810: ! 811: block_address = next_address; ! 812: fwrite (&buffer, sizeof buffer - sizeof buffer.sym, 1, symfile); ! 813: next_address += sizeof buffer - sizeof buffer.sym; ! 814: ! 815: fwrite (addr_buffer, sizeof (int), total, symfile); ! 816: next_address += total * sizeof (int); ! 817: ! 818: fprintf (asmfile, "\t.gdbblock %d,%d\n", total_blocks + 2, block_address); ! 819: total_blocks++; ! 820: ! 821: return block_address; ! 822: } ! 823: ! 824: /* Walk STMT, the body of a function, and output symtab data on ! 825: all the blocks that compose it and all symbols inside them. ! 826: ARGS is a chain of decls for argument variables of the function. ! 827: SUPERBLOCK_ADDRESS is the address of symbol data for the ! 828: innermost block containing STMT; it is used for recursive calls, ! 829: and is always 0 for the outermost call (since the containing ! 830: block for a function is output later than the function). */ ! 831: ! 832: int ! 833: symout_function (stmt, args, superblock_address) ! 834: register tree stmt; ! 835: tree args; ! 836: int superblock_address; ! 837: { ! 838: int address = superblock_address; ! 839: ! 840: while (stmt) ! 841: { ! 842: switch (TREE_CODE (stmt)) ! 843: { ! 844: case COMPOUND_STMT: ! 845: case LOOP_STMT: ! 846: symout_function (STMT_BODY (stmt), 0, address); ! 847: break; ! 848: ! 849: case IF_STMT: ! 850: symout_function (STMT_THEN (stmt), 0, address); ! 851: symout_function (STMT_ELSE (stmt), 0, address); ! 852: break; ! 853: ! 854: case LET_STMT: ! 855: address = ! 856: symout_block (STMT_VARS (stmt), STMT_TYPE_TAGS (stmt), args, ! 857: superblock_address); ! 858: ! 859: symout_function (STMT_BODY (stmt), 0, address); ! 860: } ! 861: stmt = TREE_CHAIN (stmt); ! 862: } ! 863: return address; ! 864: } ! 865: ! 866: /* Output all the data structure for a top two blocks in a compilation. ! 867: The top block is for public (global) symbols; ! 868: the next one is for private (this file only) symbols. ! 869: ! 870: DECLS is the chain of declarations of variables in this block. ! 871: TAGS is the list of struct, union and enum tag definitions. */ ! 872: ! 873: void ! 874: symout_top_blocks (decls, tags) ! 875: tree decls; ! 876: tree tags; ! 877: { ! 878: register tree decl; ! 879: register int i; ! 880: register int *addr_buffer; ! 881: struct block buffer; ! 882: int n_decls, n_tags; ! 883: register struct blockvec_elt *velt; ! 884: int top_block_addr; ! 885: ! 886: /* First do the public-symbols block. */ ! 887: ! 888: for (decl = decls, i = 0; decl; decl = TREE_CHAIN (decl)) ! 889: if (TREE_PUBLIC (decl) && ! TREE_EXTERNAL (decl)) ! 890: i++; ! 891: n_decls = i; ! 892: ! 893: addr_buffer = (int *) alloca (n_decls * sizeof (int)); ! 894: ! 895: symout_block_symbols (decls, addr_buffer, 2); ! 896: ! 897: fprintf (asmfile, ".text 0\n\t.gdbend 0\n"); ! 898: fprintf (asmfile, "\t.gdbblock 0,%d\n", next_address); ! 899: ! 900: total_blocks++; ! 901: velt = (struct blockvec_elt *) xmalloc (sizeof (struct blockvec_elt)); ! 902: velt->next = blockvec; ! 903: velt->address = next_address; ! 904: blockvec = velt; ! 905: ! 906: top_block_addr = next_address; ! 907: ! 908: buffer.startaddr = 0; ! 909: buffer.endaddr = 0; ! 910: buffer.superblock = 0; ! 911: buffer.function = 0; ! 912: buffer.nsyms = n_decls;; ! 913: ! 914: fwrite (&buffer, sizeof buffer - sizeof buffer.sym, 1, symfile); ! 915: next_address += sizeof buffer - sizeof buffer.sym; ! 916: ! 917: fwrite (addr_buffer, sizeof (int), n_decls, symfile); ! 918: next_address += n_decls * sizeof (int); ! 919: ! 920: /* Next do the private-symbols block. */ ! 921: ! 922: for (decl = decls, i = 0; decl; decl = TREE_CHAIN (decl)) ! 923: if (! TREE_PUBLIC (decl) && ! TREE_EXTERNAL (decl)) ! 924: i++; ! 925: n_decls = i; ! 926: ! 927: for (decl = tags, i = 0; decl; decl = TREE_CHAIN (decl), i++); ! 928: n_tags = i; ! 929: ! 930: addr_buffer = (int *) alloca ((n_decls + n_tags) * sizeof (int)); ! 931: ! 932: symout_block_symbols (decls, addr_buffer, 1); ! 933: symout_block_tags (tags, addr_buffer + n_decls); ! 934: ! 935: fprintf (asmfile, "\t.gdbend 1\n"); ! 936: fprintf (asmfile, "\t.gdbblock 1,%d\n", next_address); ! 937: ! 938: total_blocks++; ! 939: velt = (struct blockvec_elt *) xmalloc (sizeof (struct blockvec_elt)); ! 940: velt->next = blockvec; ! 941: velt->address = next_address; ! 942: blockvec = velt; ! 943: ! 944: buffer.startaddr = 0; ! 945: buffer.endaddr = 0; ! 946: buffer.superblock = (struct block *) top_block_addr; ! 947: buffer.function = 0; ! 948: buffer.nsyms = n_decls + n_tags;; ! 949: ! 950: fwrite (&buffer, sizeof buffer - sizeof buffer.sym, 1, symfile); ! 951: next_address += sizeof buffer - sizeof buffer.sym; ! 952: ! 953: fwrite (addr_buffer, sizeof (int), n_decls + n_tags, symfile); ! 954: next_address += (n_decls + n_tags) * sizeof (int); ! 955: } ! 956: ! 957: /* Output the source-line-number information. */ ! 958: ! 959: /* Output a `struct source' for the source file described by F. ! 960: Return the address-in-the-symseg of the `struct source'. */ ! 961: ! 962: static int ! 963: symout_source_file (f) ! 964: struct gdbfile *f; ! 965: { ! 966: /* Make the `struct source' big enough for as many lines as ! 967: this file has. */ ! 968: int size = sizeof (struct source) + (f->nlines - 1) * sizeof (struct line); ! 969: struct source *buffer ! 970: = (struct source *) alloca (size); ! 971: int addr; ! 972: ! 973: /* Use zero for the line data, since assembler will store the real data. */ ! 974: bzero (buffer, size); ! 975: ! 976: /* Output the file's name as a string. The assembler doesn't know this. */ ! 977: buffer->name = (char *) next_address; ! 978: symout_strings (f->name, 0, 0, 0); ! 979: buffer->nlines = f->nlines; ! 980: ! 981: /* Write the structure. */ ! 982: addr = next_address; ! 983: fwrite (buffer, 1, size, symfile); ! 984: next_address += size; ! 985: ! 986: /* Tell assembler where to write the real line-number data. */ ! 987: fprintf (asmfile, "\t.gdblinetab %d,%d\n", ! 988: f->filenum, addr + sizeof (int)); ! 989: ! 990: return addr; ! 991: } ! 992: ! 993: /* Output the `struct sourcevector' which describes all the ! 994: source files and points a `struct source' for each one. */ ! 995: ! 996: static int ! 997: symout_sources () ! 998: { ! 999: register struct gdbfile *f; ! 1000: int nfiles = 0; ! 1001: struct sourcevector *s; ! 1002: int i; ! 1003: int size; ! 1004: int addr; ! 1005: ! 1006: /* Count number of files to determine size of the sourcevector. */ ! 1007: for (f = gdbfiles; f; f = f->next) ! 1008: ++nfiles; ! 1009: ! 1010: /* Allocate buffer for the sourcevector and record its length. */ ! 1011: size = sizeof (int) + nfiles * sizeof (struct source *); ! 1012: s = (struct sourcevector *) alloca (size); ! 1013: s->length = nfiles; ! 1014: ! 1015: /* Output a `struct source' for each file; put address into sourcevector. */ ! 1016: for (f = gdbfiles, i = 0; f; f = f->next, i++) ! 1017: s->source[i] = (struct source *) symout_source_file (f); ! 1018: ! 1019: /* Output the sourcevector. */ ! 1020: addr = next_address; ! 1021: fwrite (s, 1, size, symfile); ! 1022: next_address += size; ! 1023: return addr; ! 1024: } ! 1025: ! 1026: /* Call here at the end of compilation, after outputting all the ! 1027: blocks and symbols, to output the blockvector and typevector ! 1028: and close the symbol table file. FILETIME is source file's ! 1029: creation time. */ ! 1030: ! 1031: void ! 1032: symout_finish (filename, filetime) ! 1033: char *filename; ! 1034: int filetime; ! 1035: { ! 1036: int *blockvector = (int *) alloca ((total_blocks + 1) * sizeof (int)); ! 1037: int *typevector = (int *) alloca ((total_types + 1) * sizeof (int)); ! 1038: int now = time (0); ! 1039: register int i; ! 1040: struct symbol_root buffer; ! 1041: char dir[MAXNAMLEN]; ! 1042: ! 1043: buffer.language = language_c; ! 1044: buffer.blockvector = (struct blockvector *) next_address; ! 1045: ! 1046: /* The two blocks at the beginning of the chain ! 1047: are the file's private symbols block and public symbols block. ! 1048: They belong at the front of the blockvector, in that order. */ ! 1049: blockvector[2] = blockvec->address; ! 1050: blockvec = blockvec->next; ! 1051: blockvector[1] = blockvec->address; ! 1052: blockvec = blockvec->next; ! 1053: ! 1054: /* The rest of the blocks are in the chain in reverse order. */ ! 1055: for (i = total_blocks; i > 2; i--) ! 1056: { ! 1057: blockvector[i] = blockvec->address; ! 1058: blockvec = blockvec->next; ! 1059: } ! 1060: blockvector[0] = total_blocks; ! 1061: ! 1062: fwrite (blockvector, sizeof (int), total_blocks + 1, symfile); ! 1063: next_address += sizeof (int) * (total_blocks + 1); ! 1064: ! 1065: buffer.typevector = (struct typevector *) next_address; ! 1066: ! 1067: for (i = total_types; i > 0; i--) ! 1068: { ! 1069: typevector[i] = typevec->address; ! 1070: typevec = typevec->next; ! 1071: } ! 1072: typevector[0] = total_types; ! 1073: ! 1074: fwrite (typevector, sizeof (int), total_types + 1, symfile); ! 1075: next_address += sizeof (int) * (total_types + 1); ! 1076: ! 1077: buffer.sourcevector = (struct sourcevector *) symout_sources (); ! 1078: ! 1079: buffer.format = 1; ! 1080: buffer.textrel = 0; /* These four will be set up by linker. */ ! 1081: buffer.datarel = 0; /* Make them 0 now, which is right for */ ! 1082: buffer.bssrel = 0; /* looking at the .o file in gdb. */ ! 1083: buffer.ldsymoff = 0; ! 1084: ! 1085: buffer.version = (char *) next_address; ! 1086: symout_strings (ctime (&filetime), 0, 0, 0); ! 1087: ! 1088: buffer.compilation = (char *) next_address; ! 1089: symout_strings (ctime (&now), 0, 0, 0); ! 1090: ! 1091: buffer.filename = (char *) next_address; ! 1092: symout_strings (filename, 0, 0, 0); ! 1093: ! 1094: buffer.filedir = (char *) next_address; ! 1095: #ifdef USG ! 1096: strcpy (dir, getcwd (dir, MAXNAMLEN)); ! 1097: #else ! 1098: #ifndef VMS ! 1099: getwd (dir); ! 1100: #else ! 1101: abort (); ! 1102: #endif ! 1103: #endif ! 1104: symout_strings (dir, 0, 0, 0); ! 1105: ! 1106: fflush (symfile); ! 1107: ! 1108: if (ferror (symfile) != 0) ! 1109: fatal_io_error (symfile_name); ! 1110: ! 1111: buffer.length = next_address; ! 1112: ! 1113: if (lseek (fileno (symfile), 0, 0) < 0) ! 1114: pfatal_with_name (symfile_name); ! 1115: if (write (fileno (symfile), &buffer, sizeof buffer) < 0) ! 1116: pfatal_with_name (symfile_name); ! 1117: close (fileno (symfile)); ! 1118: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.