gcc/mips-tfile.c

   1 /* Update the symbol table (the .T file) in a MIPS object to
   2    contain debugging information specified by the GNU compiler
   3    in the form of comments (the mips assembler does not support
   4    assembly access to debug information).
   5    Contributed by:  Michael Meissner, meissner@osf.org
   6    Copyright (C) 1991 Free Software Foundation, Inc.
   7
   8 This file is part of GNU CC.
   9
  10 GNU CC is free software; you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation; either version 2, or (at your option)
  13 any later version.
  14
  15 GNU CC is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GNU CC; see the file COPYING.  If not, write to
  22 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  23
  24 \f
  25 /* Here is a brief description of the MIPS ECOFF symbol table.  The
  26    MIPS symbol table has the following pieces:
  27
  28         Symbolic Header
  29             |
  30             +-- Auxiliary Symbols
  31             |
  32             +-- Dense number table
  33             |
  34             +-- Optimizer Symbols
  35             |
  36             +-- External Strings
  37             |
  38             +-- External Symbols
  39             |
  40             +-- Relative file descriptors
  41             |
  42             +-- File table
  43                     |
  44                     +-- Procedure table
  45                     |
  46                     +-- Line number table
  47                     |
  48                     +-- Local Strings
  49                     |
  50                     +-- Local Symbols
  51
  52    The symbolic header points to each of the other tables, and also
  53    contains the number of entries.  It also contains a magic number
  54    and MIPS compiler version number, such as 2.0.
  55
  56    The auxiliary table is a series of 32 bit integers, that are
  57    referenced as needed from the local symbol table.  Unlike standard
  58    COFF, the aux.  information does not follow the symbol that uses
  59    it, but rather is a separate table.  In theory, this would allow
  60    the MIPS compilers to collapse duplicate aux. entries, but I've not
  61    noticed this happening with the 1.31 compiler suite.  The different
  62    types of aux. entries are:
  63
  64     1)  dnLow: Low bound on array dimension.
  65
  66     2)  dnHigh: High bound on array dimension.
  67
  68     3)  isym: Index to the local symbol which is the start of the
  69         function for the end of function first aux. entry.
  70
  71     4)  width: Width of structures and bitfields.
  72
  73     5)  count: Count of ranges for variant part.
  74
  75     6)  rndx: A relative index into the symbol table.  The relative
  76         index field has two parts: rfd which is a pointer into the
  77         relative file index table or ST_RFDESCAPE which says the next
  78         aux. entry is the file number, and index: which is the pointer
  79         into the local symbol within a given file table.  This is for
  80         things like references to types defined in another file.
  81
  82     7)  Type information: This is like the COFF type bits, except it
  83         is 32 bits instead of 16; they still have room to add new
  84         basic types; and they can handle more than 6 levels of array,
  85         pointer, function, etc.  Each type information field contains
  86         the following structure members:
  87
  88             a)  fBitfield: a bit that says this is a bitfield, and the
  89                 size in bits follows as the next aux. entry.
  90
  91             b)  continued: a bit that says the next aux. entry is a
  92                 continuation of the current type information (in case
  93                 there are more than 6 levels of array/ptr/function).
  94
  95             c)  bt: an integer containing the base type before adding
  96                 array, pointer, function, etc. qualifiers.  The
  97                 current base types that I have documentation for are:
  98
  99                         btNil           -- undefined
 100                         btAdr           -- address - integer same size as ptr
 101                         btChar          -- character
 102                         btUChar         -- unsigned character
 103                         btShort         -- short
 104                         btUShort        -- unsigned short
 105                         btInt           -- int
 106                         btUInt          -- unsigned int
 107                         btLong          -- long
 108                         btULong         -- unsigned long
 109                         btFloat         -- float (real)
 110                         btDouble        -- Double (real)
 111                         btStruct        -- Structure (Record)
 112                         btUnion         -- Union (variant)
 113                         btEnum          -- Enumerated
 114                         btTypedef       -- defined via a typedef isymRef
 115                         btRange         -- subrange of int
 116                         btSet           -- pascal sets
 117                         btComplex       -- fortran complex
 118                         btDComplex      -- fortran double complex
 119                         btIndirect      -- forward or unnamed typedef
 120                         btFixedDec      -- Fixed Decimal
 121                         btFloatDec      -- Float Decimal
 122                         btString        -- Varying Length Character String
 123                         btBit           -- Aligned Bit String
 124                         btPicture       -- Picture
 125                         btVoid          -- Void (MIPS cc revision >= 2.00)
 126
 127             d)  tq0 - tq5: type qualifier fields as needed.  The
 128                 current type qualifier fields I have documentation for
 129                 are:
 130
 131                         tqNil           -- no more qualifiers
 132                         tqPtr           -- pointer
 133                         tqProc          -- procedure
 134                         tqArray         -- array
 135                         tqFar           -- 8086 far pointers
 136                         tqVol           -- volatile
 137
 138
 139    The dense number table is used in the front ends, and disappears by
 140    the time the .o is created.
 141
 142    With the 1.31 compiler suite, the optimization symbols don't seem
 143    to be used as far as I can tell.
 144
 145    The linker is the first entity that creates the relative file
 146    descriptor table, and I believe it is used so that the individual
 147    file table pointers don't have to be rewritten when the objects are
 148    merged together into the program file.
 149
 150    Unlike COFF, the basic symbol & string tables are split into
 151    external and local symbols/strings.  The relocation information
 152    only goes off of the external symbol table, and the debug
 153    information only goes off of the internal symbol table.  The
 154    external symbols can have links to an appropriate file index and
 155    symbol within the file to give it the appropriate type information.
 156    Because of this, the external symbols are actually larger than the
 157    internal symbols (to contain the link information), and contain the
 158    local symbol structure as a member, though this member is not the
 159    first member of the external symbol structure (!).  I suspect this
 160    split is to make strip easier to deal with.
 161
 162    Each file table has offsets for where the line numbers, local
 163    strings, local symbols, and procedure table starts from within the
 164    global tables, and the indexs are reset to 0 for each of those
 165    tables for the file.
 166
 167    The procedure table contains the binary equivalents of the .ent
 168    (start of the function address), .frame (what register is the
 169    virtual frame pointer, constant offset from the register to obtain
 170    the VFP, and what register holds the return address), .mask/.fmask
 171    (bitmask of saved registers, and where the first register is stored
 172    relative to the VFP) assembler directives.  It also contains the
 173    low and high bounds of the line numbers if debugging is turned on.
 174
 175    The line number table is a compressed form of the normal COFF line
 176    table.  Each line number entry is either 1 or 3 bytes long, and
 177    contains a signed delta from the previous line, and an unsigned
 178    count of the number of instructions this statement takes.
 179
 180    The local symbol table contains the following fields:
 181
 182     1)  iss: index to the local string table giving the name of the
 183         symbol.
 184
 185     2)  value: value of the symbol (address, register number, etc.).
 186
 187     3)  st: symbol type.  The current symbol types are:
 188
 189             stNil         -- Nuthin' special
 190             stGlobal      -- external symbol
 191             stStatic      -- static
 192             stParam       -- procedure argument
 193             stLocal       -- local variable
 194             stLabel       -- label
 195             stProc        -- External Procedure
 196             stBlock       -- beginning of block
 197             stEnd         -- end (of anything)
 198             stMember      -- member (of anything)
 199             stTypedef     -- type definition
 200             stFile        -- file name
 201             stRegReloc    -- register relocation
 202             stForward     -- forwarding address
 203             stStaticProc  -- Static procedure
 204             stConstant    -- const
 205
 206     4)  sc: storage class.  The current storage classes are:
 207
 208             scText        -- text symbol
 209             scData        -- initialized data symbol
 210             scBss         -- un-initialized data symbol
 211             scRegister    -- value of symbol is register number
 212             scAbs         -- value of symbol is absolute
 213             scUndefined   -- who knows?
 214             scCdbLocal    -- variable's value is IN se->va.??
 215             scBits        -- this is a bit field
 216             scCdbSystem   -- value is IN debugger's address space
 217             scRegImage    -- register value saved on stack
 218             scInfo        -- symbol contains debugger information
 219             scUserStruct  -- addr in struct user for current process
 220             scSData       -- load time only small data
 221             scSBss        -- load time only small common
 222             scRData       -- load time only read only data
 223             scVar         -- Var parameter (fortranpascal)
 224             scCommon      -- common variable
 225             scSCommon     -- small common
 226             scVarRegister -- Var parameter in a register
 227             scVariant     -- Variant record
 228             scSUndefined  -- small undefined(external) data
 229             scInit        -- .init section symbol
 230
 231     5)  index: pointer to a local symbol or aux. entry.
 232
 233
 234
 235    For the following program:
 236
 237         #include <stdio.h>
 238
 239         main(){
 240                 printf("Hello World!\n");
 241                 return 0;
 242         }
 243
 244    Mips-tdump produces the following information:
 245
 246    Global file header:
 247        magic number             0x162
 248        # sections               2
 249        timestamp                645311799, Wed Jun 13 17:16:39 1990
 250        symbolic header offset   284
 251        symbolic header size     96
 252        optional header          56
 253        flags                    0x0
 254
 255    Symbolic header, magic number = 0x7009, vstamp = 1.31:
 256
 257        Info                      Offset      Number       Bytes
 258        ====                      ======      ======      =====
 259
 260        Line numbers                 380           4           4 [13]
 261        Dense numbers                  0           0           0
 262        Procedures Tables            384           1          52
 263        Local Symbols                436          16         192
 264        Optimization Symbols           0           0           0
 265        Auxiliary Symbols            628          39         156
 266        Local Strings                784          80          80
 267        External Strings             864         144         144
 268        File Tables                 1008           2         144
 269        Relative Files                 0           0           0
 270        External Symbols            1152          20         320
 271
 272    File #0, "hello2.c"
 273
 274        Name index  = 1          Readin      = No
 275        Merge       = No         Endian      = LITTLE
 276        Debug level = G2         Language    = C
 277        Adr         = 0x00000000
 278
 279        Info                       Start      Number        Size      Offset
 280        ====                       =====      ======        ====      ======
 281        Local strings                  0          15          15         784
 282        Local symbols                  0           6          72         436
 283        Line numbers                   0          13          13         380
 284        Optimization symbols           0           0           0           0
 285        Procedures                     0           1          52         384
 286        Auxiliary symbols              0          14          56         628
 287        Relative Files                 0           0           0           0
 288
 289     There are 6 local symbols, starting at 436
 290
 291         Symbol# 0: "hello2.c"
 292             End+1 symbol  = 6
 293             String index  = 1
 294             Storage class = Text        Index  = 6
 295             Symbol type   = File        Value  = 0
 296
 297         Symbol# 1: "main"
 298             End+1 symbol  = 5
 299             Type          = int
 300             String index  = 10
 301             Storage class = Text        Index  = 12
 302             Symbol type   = Proc        Value  = 0
 303
 304         Symbol# 2: ""
 305             End+1 symbol  = 4
 306             String index  = 0
 307             Storage class = Text        Index  = 4
 308             Symbol type   = Block       Value  = 8
 309
 310         Symbol# 3: ""
 311             First symbol  = 2
 312             String index  = 0
 313             Storage class = Text        Index  = 2
 314             Symbol type   = End         Value  = 28
 315
 316         Symbol# 4: "main"
 317             First symbol  = 1
 318             String index  = 10
 319             Storage class = Text        Index  = 1
 320             Symbol type   = End         Value  = 52
 321
 322         Symbol# 5: "hello2.c"
 323             First symbol  = 0
 324             String index  = 1
 325             Storage class = Text        Index  = 0
 326             Symbol type   = End         Value  = 0
 327
 328     There are 14 auxiliary table entries, starting at 628.
 329
 330         * #0               0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 331         * #1              24, [  24/      0], [ 6 0:0 0:0:0:0:0:0]
 332         * #2               8, [   8/      0], [ 2 0:0 0:0:0:0:0:0]
 333         * #3              16, [  16/      0], [ 4 0:0 0:0:0:0:0:0]
 334         * #4              24, [  24/      0], [ 6 0:0 0:0:0:0:0:0]
 335         * #5              32, [  32/      0], [ 8 0:0 0:0:0:0:0:0]
 336         * #6              40, [  40/      0], [10 0:0 0:0:0:0:0:0]
 337         * #7              44, [  44/      0], [11 0:0 0:0:0:0:0:0]
 338         * #8              12, [  12/      0], [ 3 0:0 0:0:0:0:0:0]
 339         * #9              20, [  20/      0], [ 5 0:0 0:0:0:0:0:0]
 340         * #10             28, [  28/      0], [ 7 0:0 0:0:0:0:0:0]
 341         * #11             36, [  36/      0], [ 9 0:0 0:0:0:0:0:0]
 342           #12              5, [   5/      0], [ 1 1:0 0:0:0:0:0:0]
 343           #13             24, [  24/      0], [ 6 0:0 0:0:0:0:0:0]
 344
 345     There are 1 procedure descriptor entries, starting at 0.
 346
 347         Procedure descriptor 0:
 348             Name index   = 10          Name          = "main"
 349             .mask 0x80000000,-4        .fmask 0x00000000,0
 350             .frame $29,24,$31
 351             Opt. start   = -1          Symbols start = 1
 352             First line # = 3           Last line #   = 6
 353             Line Offset  = 0           Address       = 0x00000000
 354
 355         There are 4 bytes holding line numbers, starting at 380.
 356             Line           3,   delta     0,   count  2
 357             Line           4,   delta     1,   count  3
 358             Line           5,   delta     1,   count  2
 359             Line           6,   delta     1,   count  6
 360
 361    File #1, "/usr/include/stdio.h"
 362
 363     Name index  = 1          Readin      = No
 364     Merge       = Yes        Endian      = LITTLE
 365     Debug level = G2         Language    = C
 366     Adr         = 0x00000000
 367
 368     Info                       Start      Number        Size      Offset
 369     ====                       =====      ======        ====      ======
 370     Local strings                 15          65          65         799
 371     Local symbols                  6          10         120         508
 372     Line numbers                   0           0           0         380
 373     Optimization symbols           0           0           0           0
 374     Procedures                     1           0           0         436
 375     Auxiliary symbols             14          25         100         684
 376     Relative Files                 0           0           0           0
 377
 378     There are 10 local symbols, starting at 442
 379
 380         Symbol# 0: "/usr/include/stdio.h"
 381             End+1 symbol  = 10
 382             String index  = 1
 383             Storage class = Text        Index  = 10
 384             Symbol type   = File        Value  = 0
 385
 386         Symbol# 1: "_iobuf"
 387             End+1 symbol  = 9
 388             String index  = 22
 389             Storage class = Info        Index  = 9
 390             Symbol type   = Block       Value  = 20
 391
 392         Symbol# 2: "_cnt"
 393             Type          = int
 394             String index  = 29
 395             Storage class = Info        Index  = 4
 396             Symbol type   = Member      Value  = 0
 397
 398         Symbol# 3: "_ptr"
 399             Type          = ptr to char
 400             String index  = 34
 401             Storage class = Info        Index  = 15
 402             Symbol type   = Member      Value  = 32
 403
 404         Symbol# 4: "_base"
 405             Type          = ptr to char
 406             String index  = 39
 407             Storage class = Info        Index  = 16
 408             Symbol type   = Member      Value  = 64
 409
 410         Symbol# 5: "_bufsiz"
 411             Type          = int
 412             String index  = 45
 413             Storage class = Info        Index  = 4
 414             Symbol type   = Member      Value  = 96
 415
 416         Symbol# 6: "_flag"
 417             Type          = short
 418             String index  = 53
 419             Storage class = Info        Index  = 3
 420             Symbol type   = Member      Value  = 128
 421
 422         Symbol# 7: "_file"
 423             Type          = char
 424             String index  = 59
 425             Storage class = Info        Index  = 2
 426             Symbol type   = Member      Value  = 144
 427
 428         Symbol# 8: ""
 429             First symbol  = 1
 430             String index  = 0
 431             Storage class = Info        Index  = 1
 432             Symbol type   = End         Value  = 0
 433
 434         Symbol# 9: "/usr/include/stdio.h"
 435             First symbol  = 0
 436             String index  = 1
 437             Storage class = Text        Index  = 0
 438             Symbol type   = End         Value  = 0
 439
 440     There are 25 auxiliary table entries, starting at 642.
 441
 442         * #14             -1, [4095/1048575], [63 1:1 f:f:f:f:f:f]
 443           #15          65544, [   8/     16], [ 2 0:0 1:0:0:0:0:0]
 444           #16          65544, [   8/     16], [ 2 0:0 1:0:0:0:0:0]
 445         * #17         196656, [  48/     48], [12 0:0 3:0:0:0:0:0]
 446         * #18           8191, [4095/      1], [63 1:1 0:0:0:0:f:1]
 447         * #19              1, [   1/      0], [ 0 1:0 0:0:0:0:0:0]
 448         * #20          20479, [4095/      4], [63 1:1 0:0:0:0:f:4]
 449         * #21              1, [   1/      0], [ 0 1:0 0:0:0:0:0:0]
 450         * #22              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 451         * #23              2, [   2/      0], [ 0 0:1 0:0:0:0:0:0]
 452         * #24            160, [ 160/      0], [40 0:0 0:0:0:0:0:0]
 453         * #25              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 454         * #26              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 455         * #27              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 456         * #28              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 457         * #29              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 458         * #30              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 459         * #31              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 460         * #32              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 461         * #33              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 462         * #34              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 463         * #35              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 464         * #36              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 465         * #37              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 466         * #38              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 467
 468     There are 0 procedure descriptor entries, starting at 1.
 469
 470    There are 20 external symbols, starting at 1152
 471
 472         Symbol# 0: "_iob"
 473             Type          = array [3 {160}] of struct _iobuf { ifd = 1, index = 1 }
 474             String index  = 0           Ifd    = 1
 475             Storage class = Nil         Index  = 17
 476             Symbol type   = Global      Value  = 60
 477
 478         Symbol# 1: "fopen"
 479             String index  = 5           Ifd    = 1
 480             Storage class = Nil         Index  = 1048575
 481             Symbol type   = Proc        Value  = 0
 482
 483         Symbol# 2: "fdopen"
 484             String index  = 11          Ifd    = 1
 485             Storage class = Nil         Index  = 1048575
 486             Symbol type   = Proc        Value  = 0
 487
 488         Symbol# 3: "freopen"
 489             String index  = 18          Ifd    = 1
 490             Storage class = Nil         Index  = 1048575
 491             Symbol type   = Proc        Value  = 0
 492
 493         Symbol# 4: "popen"
 494             String index  = 26          Ifd    = 1
 495             Storage class = Nil         Index  = 1048575
 496             Symbol type   = Proc        Value  = 0
 497
 498         Symbol# 5: "tmpfile"
 499             String index  = 32          Ifd    = 1
 500             Storage class = Nil         Index  = 1048575
 501             Symbol type   = Proc        Value  = 0
 502
 503         Symbol# 6: "ftell"
 504             String index  = 40          Ifd    = 1
 505             Storage class = Nil         Index  = 1048575
 506             Symbol type   = Proc        Value  = 0
 507
 508         Symbol# 7: "rewind"
 509             String index  = 46          Ifd    = 1
 510             Storage class = Nil         Index  = 1048575
 511             Symbol type   = Proc        Value  = 0
 512
 513         Symbol# 8: "setbuf"
 514             String index  = 53          Ifd    = 1
 515             Storage class = Nil         Index  = 1048575
 516             Symbol type   = Proc        Value  = 0
 517
 518         Symbol# 9: "setbuffer"
 519             String index  = 60          Ifd    = 1
 520             Storage class = Nil         Index  = 1048575
 521             Symbol type   = Proc        Value  = 0
 522
 523         Symbol# 10: "setlinebuf"
 524             String index  = 70          Ifd    = 1
 525             Storage class = Nil         Index  = 1048575
 526             Symbol type   = Proc        Value  = 0
 527
 528         Symbol# 11: "fgets"
 529             String index  = 81          Ifd    = 1
 530             Storage class = Nil         Index  = 1048575
 531             Symbol type   = Proc        Value  = 0
 532
 533         Symbol# 12: "gets"
 534             String index  = 87          Ifd    = 1
 535             Storage class = Nil         Index  = 1048575
 536             Symbol type   = Proc        Value  = 0
 537
 538         Symbol# 13: "ctermid"
 539             String index  = 92          Ifd    = 1
 540             Storage class = Nil         Index  = 1048575
 541             Symbol type   = Proc        Value  = 0
 542
 543         Symbol# 14: "cuserid"
 544             String index  = 100         Ifd    = 1
 545             Storage class = Nil         Index  = 1048575
 546             Symbol type   = Proc        Value  = 0
 547
 548         Symbol# 15: "tempnam"
 549             String index  = 108         Ifd    = 1
 550             Storage class = Nil         Index  = 1048575
 551             Symbol type   = Proc        Value  = 0
 552
 553         Symbol# 16: "tmpnam"
 554             String index  = 116         Ifd    = 1
 555             Storage class = Nil         Index  = 1048575
 556             Symbol type   = Proc        Value  = 0
 557
 558         Symbol# 17: "sprintf"
 559             String index  = 123         Ifd    = 1
 560             Storage class = Nil         Index  = 1048575
 561             Symbol type   = Proc        Value  = 0
 562
 563         Symbol# 18: "main"
 564             Type          = int
 565             String index  = 131         Ifd    = 0
 566             Storage class = Text        Index  = 1
 567             Symbol type   = Proc        Value  = 0
 568
 569         Symbol# 19: "printf"
 570             String index  = 136         Ifd    = 0
 571             Storage class = Undefined   Index  = 1048575
 572             Symbol type   = Proc        Value  = 0
 573
 574    The following auxiliary table entries were unused:
 575
 576     #0               0  0x00000000  void
 577     #2               8  0x00000008  char
 578     #3              16  0x00000010  short
 579     #4              24  0x00000018  int
 580     #5              32  0x00000020  long
 581     #6              40  0x00000028  float
 582     #7              44  0x0000002c  double
 583     #8              12  0x0000000c  unsigned char
 584     #9              20  0x00000014  unsigned short
 585     #10             28  0x0000001c  unsigned int
 586     #11             36  0x00000024  unsigned long
 587     #14              0  0x00000000  void
 588     #15             24  0x00000018  int
 589     #19             32  0x00000020  long
 590     #20             40  0x00000028  float
 591     #21             44  0x0000002c  double
 592     #22             12  0x0000000c  unsigned char
 593     #23             20  0x00000014  unsigned short
 594     #24             28  0x0000001c  unsigned int
 595     #25             36  0x00000024  unsigned long
 596     #26             48  0x00000030  struct no name { ifd = -1, index = 1048575 }
 597
 598 */
 599 \f
 600
 601 #include <stdio.h>
 602 #include "gvarargs.h"
 603 #include "config.h"
 604
 605 #ifndef __SABER__
 606 #define saber_stop()
 607 #endif
 608
 609 #ifndef __LINE__
 610 #define __LINE__ 0
 611 #endif
 612
 613 #ifdef __STDC__
 614 typedef void *PTR_T;
 615 typedef const void *CPTR_T;
 616 #define __proto(x) x
 617 #else
 618
 619 #if defined(_STDIO_H_) || defined(__STDIO_H__)          /* Ultrix 4.0, SGI */
 620 typedef void *PTR_T;
 621 typedef void *CPTR_T;
 622
 623 #else
 624 typedef char *PTR_T;                                    /* Ultrix 3.1 */
 625 typedef char *CPTR_T;
 626 #endif
 627
 628 #define __proto(x) ()
 629 #define const
 630 #endif
 631
 632 /* Do to size_t being defined in sys/types.h and different
 633    in stddef.h, we have to do this by hand.....  Note, these
 634    types are correct for MIPS based systems, and may not be
 635    correct for other systems.  Ultrix 4.0 and Silicon Graphics
 636    have this fixed, but since the following is correct, and
 637    the fact that including stddef.h gets you GCC's version
 638    instead of the standard one it's not worth it to fix it.  */
 639
 640 #define Size_t          unsigned int
 641 #define Ptrdiff_t       int
 642
 643 /* The following might be called from obstack or malloc,
 644    so they can't be static.  */
 645
 646 extern void     pfatal_with_name
 647                                 __proto((char *));
 648 extern void     fancy_abort     __proto((void));
 649        void     botch           __proto((const char *));
 650 extern PTR_T    xmalloc         __proto((Size_t));
 651 extern PTR_T    xcalloc         __proto((Size_t, Size_t));
 652 extern PTR_T    xrealloc        __proto((PTR_T, Size_t));
 653 extern void     xfree           __proto((PTR_T));
 654
 655 extern void     fatal();        /* can't use prototypes here */
 656 extern void     error();
 657
 658 \f
 659 #ifndef MIPS_DEBUGGING_INFO
 660
 661 static int       line_number;
 662 static int       cur_line_start;
 663 static int       debug;
 664 static int       had_errors;
 665 static char     *progname;
 666 static char     *input_name;
 667
 668 int
 669 main ()
 670 {
 671   fprintf (stderr, "Mips-tfile should only be run on a MIPS computer!\n");
 672   exit (1);
 673 }
 674
 675 #else                           /* MIPS_DEBUGGING defined */
 676 \f
 677
 678 #include <sys/types.h>
 679 #include <a.out.h>
 680 #include <string.h>
 681 #include <ctype.h>
 682 #include <fcntl.h>
 683 #include <errno.h>
 684 #include <signal.h>
 685 #include <sys/stat.h>
 686
 687 #if defined (USG) || defined (NO_STAB_H)
 688 #include "gstab.h"  /* If doing DBX on sysV, use our own stab.h.  */
 689 #else
 690 #include <stab.h>  /* On BSD, use the system's stab.h.  */
 691 #endif /* not USG */
 692
 693 #ifdef __GNU_STAB__
 694 #define STAB_CODE_TYPE enum __stab_debug_code
 695 #else
 696 #define STAB_CODE_TYPE int
 697 #endif
 698
 699 #ifdef _OSF_SOURCE
 700 #define HAS_STDLIB_H
 701 #define HAS_UNISTD_H
 702 #endif
 703
 704 #ifdef HAS_STDLIB_H
 705 #include <stdlib.h>
 706 #endif
 707
 708 #ifdef HAS_UNISTD_H
 709 #include <unistd.h>
 710 #endif
 711
 712 #ifndef errno
 713 extern int errno;                       /* MIPS errno.h doesn't declare this */
 714 #endif
 715
 716 #ifndef MALLOC_CHECK
 717 #ifdef  __SABER__
 718 #define MALLOC_CHECK
 719 #endif
 720 #endif
 721
 722 #define IS_ASM_IDENT(ch) \
 723   (isalnum (ch) || (ch) == '_' || (ch) == '.' || (ch) == '$')
 724
 725 \f
 726 /* Redefinition of of storage classes as an enumeration for better
 727    debugging.  */
 728
 729 typedef enum sc {
 730   sc_Nil         = scNil,         /* no storage class */
 731   sc_Text        = scText,        /* text symbol */
 732   sc_Data        = scData,        /* initialized data symbol */
 733   sc_Bss         = scBss,         /* un-initialized data symbol */
 734   sc_Register    = scRegister,    /* value of symbol is register number */
 735   sc_Abs         = scAbs,         /* value of symbol is absolute */
 736   sc_Undefined   = scUndefined,   /* who knows? */
 737   sc_CdbLocal    = scCdbLocal,    /* variable's value is IN se->va.?? */
 738   sc_Bits        = scBits,        /* this is a bit field */
 739   sc_CdbSystem   = scCdbSystem,   /* value is IN CDB's address space */
 740   sc_RegImage    = scRegImage,    /* register value saved on stack */
 741   sc_Info        = scInfo,        /* symbol contains debugger information */
 742   sc_UserStruct  = scUserStruct,  /* addr in struct user for current process */
 743   sc_SData       = scSData,       /* load time only small data */
 744   sc_SBss        = scSBss,        /* load time only small common */
 745   sc_RData       = scRData,       /* load time only read only data */
 746   sc_Var         = scVar,         /* Var parameter (fortran,pascal) */
 747   sc_Common      = scCommon,      /* common variable */
 748   sc_SCommon     = scSCommon,     /* small common */
 749   sc_VarRegister = scVarRegister, /* Var parameter in a register */
 750   sc_Variant     = scVariant,     /* Variant record */
 751   sc_SUndefined  = scSUndefined,  /* small undefined(external) data */
 752   sc_Init        = scInit,        /* .init section symbol */
 753   sc_Max         = scMax          /* Max storage class+1 */
 754 } sc_t;
 755
 756 /* Redefinition of symbol type.  */
 757
 758 typedef enum st {
 759   st_Nil        = stNil,        /* Nuthin' special */
 760   st_Global     = stGlobal,     /* external symbol */
 761   st_Static     = stStatic,     /* static */
 762   st_Param      = stParam,      /* procedure argument */
 763   st_Local      = stLocal,      /* local variable */
 764   st_Label      = stLabel,      /* label */
 765   st_Proc       = stProc,       /*     "      "  Procedure */
 766   st_Block      = stBlock,      /* beginning of block */
 767   st_End        = stEnd,        /* end (of anything) */
 768   st_Member     = stMember,     /* member (of anything  - struct/union/enum */
 769   st_Typedef    = stTypedef,    /* type definition */
 770   st_File       = stFile,       /* file name */
 771   st_RegReloc   = stRegReloc,   /* register relocation */
 772   st_Forward    = stForward,    /* forwarding address */
 773   st_StaticProc = stStaticProc, /* load time only static procs */
 774   st_Constant   = stConstant,   /* const */
 775   st_Str        = stStr,        /* string */
 776   st_Number     = stNumber,     /* pure number (ie. 4 NOR 2+2) */
 777   st_Expr       = stExpr,       /* 2+2 vs. 4 */
 778   st_Type       = stType,       /* post-coercion SER */
 779   st_Max        = stMax         /* max type+1 */
 780 } st_t;
 781
 782 /* Redefinition of type qualifiers.  */
 783
 784 typedef enum tq {
 785   tq_Nil        = tqNil,        /* bt is what you see */
 786   tq_Ptr        = tqPtr,        /* pointer */
 787   tq_Proc       = tqProc,       /* procedure */
 788   tq_Array      = tqArray,      /* duh */
 789   tq_Far        = tqFar,        /* longer addressing - 8086/8 land */
 790   tq_Vol        = tqVol,        /* volatile */
 791   tq_Max        = tqMax         /* Max type qualifier+1 */
 792 } tq_t;
 793
 794 /* Redefinition of basic types.  */
 795
 796 typedef enum bt {
 797   bt_Nil        = btNil,        /* undefined */
 798   bt_Adr        = btAdr,        /* address - integer same size as pointer */
 799   bt_Char       = btChar,       /* character */
 800   bt_UChar      = btUChar,      /* unsigned character */
 801   bt_Short      = btShort,      /* short */
 802   bt_UShort     = btUShort,     /* unsigned short */
 803   bt_Int        = btInt,        /* int */
 804   bt_UInt       = btUInt,       /* unsigned int */
 805   bt_Long       = btLong,       /* long */
 806   bt_ULong      = btULong,      /* unsigned long */
 807   bt_Float      = btFloat,      /* float (real) */
 808   bt_Double     = btDouble,     /* Double (real) */
 809   bt_Struct     = btStruct,     /* Structure (Record) */
 810   bt_Union      = btUnion,      /* Union (variant) */
 811   bt_Enum       = btEnum,       /* Enumerated */
 812   bt_Typedef    = btTypedef,    /* defined via a typedef, isymRef points */
 813   bt_Range      = btRange,      /* subrange of int */
 814   bt_Set        = btSet,        /* pascal sets */
 815   bt_Complex    = btComplex,    /* fortran complex */
 816   bt_DComplex   = btDComplex,   /* fortran double complex */
 817   bt_Indirect   = btIndirect,   /* forward or unnamed typedef */
 818   bt_FixedDec   = btFixedDec,   /* Fixed Decimal */
 819   bt_FloatDec   = btFloatDec,   /* Float Decimal */
 820   bt_String     = btString,     /* Varying Length Character String */
 821   bt_Bit        = btBit,        /* Aligned Bit String */
 822   bt_Picture    = btPicture,    /* Picture */
 823
 824 #ifdef btVoid
 825   bt_Void       = btVoid,       /* Void */
 826 #else
 827 #define bt_Void bt_Nil
 828 #endif
 829
 830   bt_Max        = btMax         /* Max basic type+1 */
 831 } bt_t;
 832
 833 \f
 834
 835 /* Basic COFF storage classes.  */
 836 enum coff_storage {
 837   C_EFCN        = -1,
 838   C_NULL        = 0,
 839   C_AUTO        = 1,
 840   C_EXT         = 2,
 841   C_STAT        = 3,
 842   C_REG         = 4,
 843   C_EXTDEF      = 5,
 844   C_LABEL       = 6,
 845   C_ULABEL      = 7,
 846   C_MOS         = 8,
 847   C_ARG         = 9,
 848   C_STRTAG      = 10,
 849   C_MOU         = 11,
 850   C_UNTAG       = 12,
 851   C_TPDEF       = 13,
 852   C_USTATIC     = 14,
 853   C_ENTAG       = 15,
 854   C_MOE         = 16,
 855   C_REGPARM     = 17,
 856   C_FIELD       = 18,
 857   C_BLOCK       = 100,
 858   C_FCN         = 101,
 859   C_EOS         = 102,
 860   C_FILE        = 103,
 861   C_LINE        = 104,
 862   C_ALIAS       = 105,
 863   C_HIDDEN      = 106,
 864   C_MAX         = 107
 865 } coff_storage_t;
 866
 867 /* Regular COFF fundamental type.  */
 868 typedef enum coff_type {
 869   T_NULL        = 0,
 870   T_ARG         = 1,
 871   T_CHAR        = 2,
 872   T_SHORT       = 3,
 873   T_INT         = 4,
 874   T_LONG        = 5,
 875   T_FLOAT       = 6,
 876   T_DOUBLE      = 7,
 877   T_STRUCT      = 8,
 878   T_UNION       = 9,
 879   T_ENUM        = 10,
 880   T_MOE         = 11,
 881   T_UCHAR       = 12,
 882   T_USHORT      = 13,
 883   T_UINT        = 14,
 884   T_ULONG       = 15,
 885   T_MAX         = 16
 886 } coff_type_t;
 887
 888 /* Regular COFF derived types.  */
 889 typedef enum coff_dt {
 890   DT_NON        = 0,
 891   DT_PTR        = 1,
 892   DT_FCN        = 2,
 893   DT_ARY        = 3,
 894   DT_MAX        = 4
 895 } coff_dt_t;
 896
 897 #define N_BTMASK        017     /* bitmask to isolate basic type */
 898 #define N_TMASK         003     /* bitmask to isolate derived type */
 899 #define N_BT_SHIFT      4       /* # bits to shift past basic type */
 900 #define N_TQ_SHIFT      2       /* # bits to shift derived types */
 901 #define N_TQ            6       /* # of type qualifiers */
 902
 903 /* States for whether to hash type or not.  */
 904 typedef enum hash_state {
 905   hash_no       = 0,            /* don't hash type */
 906   hash_yes      = 1,            /* ok to hash type, or use previous hash */
 907   hash_record   = 2             /* ok to record hash, but don't use prev. */
 908 } hash_state_t;
 909
 910
 911 /* Types of different sized allocation requests.  */
 912 enum alloc_type {
 913   alloc_type_none,              /* dummy value */
 914   alloc_type_scope,             /* nested scopes linked list */
 915   alloc_type_vlinks,            /* glue linking pages in varray */
 916   alloc_type_shash,             /* string hash element */
 917   alloc_type_thash,             /* type hash element */
 918   alloc_type_tag,               /* struct/union/tag element */
 919   alloc_type_forward,           /* element to hold unknown tag */
 920   alloc_type_thead,             /* head of type hash list */
 921   alloc_type_varray,            /* general varray allocation */
 922   alloc_type_last               /* last+1 element for array bounds */
 923 };
 924
 925 \f
 926 #define WORD_ALIGN(x)  (((x) + 3) & ~3)
 927 #define DWORD_ALIGN(x) (((x) + 7) & ~7)
 928
 929
 930 /* Structures to provide n-number of virtual arrays, each of which can
 931    grow linearly, and which are written in the object file as sequential
 932    pages.  On systems with a BSD malloc that define USE_MALLOC, the
 933    MAX_CLUSTER_PAGES should be 1 less than a power of two, since malloc
 934    adds it's overhead, and rounds up to the next power of 2.  Pages are
 935    linked together via a linked list.
 936
 937    If PAGE_SIZE is > 4096, the string length in the shash_t structure
 938    can't be represented (assuming there are strings > 4096 bytes).  */
 939
 940 #ifndef PAGE_SIZE
 941 #define PAGE_SIZE 4096          /* size of varray pages */
 942 #endif
 943
 944 #define PAGE_USIZE ((Size_t)PAGE_SIZE)
 945
 946
 947 #ifndef MAX_CLUSTER_PAGES       /* # pages to get from system */
 948 #ifndef USE_MALLOC              /* in one memory request */
 949 #define MAX_CLUSTER_PAGES 64
 950 #else
 951 #define MAX_CLUSTER_PAGES 63
 952 #endif
 953 #endif
 954
 955
 956 /* Linked list connecting separate page allocations.  */
 957 typedef struct vlinks {
 958   struct vlinks *prev;          /* previous set of pages */
 959   struct vlinks *next;          /* next set of pages */
 960   union  page   *datum;         /* start of page */
 961   unsigned long  start_index;   /* starting index # of page */
 962 } vlinks_t;
 963
 964
 965 /* Virtual array header.  */
 966 typedef struct varray {
 967   vlinks_t      *first;                 /* first page link */
 968   vlinks_t      *last;                  /* last page link */
 969   unsigned long  num_allocated;         /* # objects allocated */
 970   unsigned short object_size;           /* size in bytes of each object */
 971   unsigned short objects_per_page;      /* # objects that can fit on a page */
 972   unsigned short objects_last_page;     /* # objects allocated on last page */
 973 } varray_t;
 974
 975 #ifndef MALLOC_CHECK
 976 #define OBJECTS_PER_PAGE(type) (PAGE_SIZE / sizeof (type))
 977 #else
 978 #define OBJECTS_PER_PAGE(type) ((sizeof (type) > 1) ? 1 : PAGE_SIZE)
 979 #endif
 980
 981 #define INIT_VARRAY(type) {     /* macro to initialize a varray */      \
 982   (vlinks_t *)0,                /* first */                             \
 983   (vlinks_t *)0,                /* last */                              \
 984   0,                            /* num_allocated */                     \
 985   sizeof (type),                /* object_size */                       \
 986   OBJECTS_PER_PAGE (type),      /* objects_per_page */                  \
 987   OBJECTS_PER_PAGE (type),      /* objects_last_page */                 \
 988 }
 989
 990 /* Master type for indexes within the symbol table. */
 991 typedef unsigned long symint_t;
 992
 993
 994 /* Linked list support for nested scopes (file, block, structure, etc.).  */
 995 typedef struct scope {
 996   struct scope  *prev;          /* previous scope level */
 997   struct scope  *free;          /* free list pointer */
 998   SYMR          *lsym;          /* pointer to local symbol node */
 999   symint_t       lnumber;       /* lsym index */
1000   st_t           type;          /* type of the node */
1001 } scope_t;
1002
1003
1004 /* Forward reference list for tags referenced, but not yet defined.  */
1005 typedef struct forward {
1006   struct forward *next;         /* next forward reference */
1007   struct forward *free;         /* free list pointer */
1008   AUXU           *ifd_ptr;      /* pointer to store file index */
1009   AUXU           *index_ptr;    /* pointer to store symbol index */
1010   AUXU           *type_ptr;     /* pointer to munge type info */
1011 } forward_t;
1012
1013
1014 /* Linked list support for tags.  The first tag in the list is always
1015    the current tag for that block.  */
1016 typedef struct tag {
1017   struct tag     *free;         /* free list pointer */
1018   struct shash   *hash_ptr;     /* pointer to the hash table head */
1019   struct tag     *same_name;    /* tag with same name in outer scope */
1020   struct tag     *same_block;   /* next tag defined in the same block.  */
1021   struct forward *forward_ref;  /* list of forward references */
1022   bt_t            basic_type;   /* bt_Struct, bt_Union, or bt_Enum */
1023   symint_t        ifd;          /* file # tag defined in */
1024   symint_t        index;        /* index within file's local symbols */
1025 } tag_t;
1026
1027
1028 /* Head of a block's linked list of tags.  */
1029 typedef struct thead {
1030   struct thead  *prev;          /* previous block */
1031   struct thead  *free;          /* free list pointer */
1032   struct tag    *first_tag;     /* first tag in block defined */
1033 } thead_t;
1034
1035
1036 /* Union containing pointers to each the small structures which are freed up.  */
1037 typedef union small_free {
1038   scope_t       *f_scope;       /* scope structure */
1039   thead_t       *f_thead;       /* tag head structure */
1040   tag_t         *f_tag;         /* tag element structure */
1041   forward_t     *f_forward;     /* forward tag reference */
1042 } small_free_t;
1043
1044
1045 /* String hash table support.  The size of the hash table must fit
1046    within a page.  */
1047
1048 #ifndef SHASH_SIZE
1049 #define SHASH_SIZE 1009
1050 #endif
1051
1052 #define HASH_LEN_MAX ((1 << 12) - 1)    /* Max length we can store */
1053
1054 typedef struct shash {
1055   struct shash  *next;          /* next hash value */
1056   char          *string;        /* string we are hashing */
1057   symint_t       len;           /* string length */
1058   symint_t       index;         /* index within string table */
1059   EXTR          *esym_ptr;      /* global symbol pointer */
1060   SYMR          *sym_ptr;       /* local symbol pointer */
1061   SYMR          *end_ptr;       /* symbol pointer to end block */
1062   tag_t         *tag_ptr;       /* tag pointer */
1063   PDR           *proc_ptr;      /* procedure descriptor pointer */
1064 } shash_t;
1065
1066
1067 /* Type hash table support.  The size of the hash table must fit
1068    within a page with the other extended file descriptor information.
1069    Because unique types which are hashed are fewer in number than
1070    strings, we use a smaller hash value.  */
1071
1072 #ifndef THASH_SIZE
1073 #define THASH_SIZE 113
1074 #endif
1075
1076 typedef struct thash {
1077   struct thash  *next;          /* next hash value */
1078   AUXU           type;          /* type we are hashing */
1079   symint_t       index;         /* index within string table */
1080 } thash_t;
1081
1082
1083 /* Extended file descriptor that contains all of the support necessary
1084    to add things to each file separately.  */
1085 typedef struct efdr {
1086   FDR            fdr;           /* File header to be written out */
1087   FDR           *orig_fdr;      /* original file header */
1088   char          *name;          /* filename */
1089   int            name_len;      /* length of the filename */
1090   symint_t       void_type;     /* aux. pointer to 'void' type */
1091   symint_t       int_type;      /* aux. pointer to 'int' type */
1092   scope_t       *cur_scope;     /* current nested scopes */
1093   symint_t       file_index;    /* current file number */
1094   int            nested_scopes; /* # nested scopes */
1095   varray_t       strings;       /* local strings */
1096   varray_t       symbols;       /* local symbols */
1097   varray_t       procs;         /* procedures */
1098   varray_t       aux_syms;      /* auxiliary symbols */
1099   struct efdr   *next_file;     /* next file descriptor */
1100                                 /* string/type hash tables */
1101   shash_t      **shash_head;    /* string hash table */
1102   thash_t       *thash_head[THASH_SIZE];
1103 } efdr_t;
1104
1105 /* Pre-initialized extended file structure.  */
1106 static efdr_t init_file =
1107 {
1108   {                     /* FDR structure */
1109     0,                  /* adr:         memory address of beginning of file */
1110     0,                  /* rss:         file name (of source, if known) */
1111     0,                  /* issBase:     file's string space */
1112     0,                  /* cbSs:        number of bytes in the ss */
1113     0,                  /* isymBase:    beginning of symbols */
1114     0,                  /* csym:        count file's of symbols */
1115     0,                  /* ilineBase:   file's line symbols */
1116     0,                  /* cline:       count of file's line symbols */
1117     0,                  /* ioptBase:    file's optimization entries */
1118     0,                  /* copt:        count of file's optimization entries */
1119     0,                  /* ipdFirst:    start of procedures for this file */
1120     0,                  /* cpd:         count of procedures for this file */
1121     0,                  /* iauxBase:    file's auxiliary entries */
1122     0,                  /* caux:        count of file's auxiliary entries */
1123     0,                  /* rfdBase:     index into the file indirect table */
1124     0,                  /* crfd:        count file indirect entries */
1125     langC,              /* lang:        language for this file */
1126     1,                  /* fMerge:      whether this file can be merged */
1127     0,                  /* fReadin:     true if read in (not just created) */
1128 #if BYTES_BIG_ENDIAN
1129     1,                  /* fBigendian:  if 1, compiled on big endian machine */
1130 #else
1131     0,                  /* fBigendian:  if 1, compiled on big endian machine */
1132 #endif
1133     GLEVEL_2,           /* glevel:      level this file was compiled with */
1134     0,                  /* reserved:    reserved for future use */
1135     0,                  /* cbLineOffset: byte offset from header for this file ln's */
1136     0,                  /* cbLine:      size of lines for this file */
1137   },
1138
1139   (FDR *)0,             /* orig_fdr:    original file header pointer */
1140   (char *)0,            /* name:        pointer to filename */
1141   0,                    /* name_len:    length of filename */
1142   0,                    /* void_type:   ptr to aux node for void type */
1143   0,                    /* int_type:    ptr to aux node for int type */
1144   (scope_t *)0,         /* cur_scope:   current scope being processed */
1145   0,                    /* file_index:  current file # */
1146   0,                    /* nested_scopes: # nested scopes */
1147   INIT_VARRAY (char),   /* strings:     local string varray */
1148   INIT_VARRAY (SYMR),   /* symbols:     local symbols varray */
1149   INIT_VARRAY (PDR),    /* procs:       procedure varray */
1150   INIT_VARRAY (AUXU),   /* aux_syms:    auxiliary symbols varray */
1151
1152   (struct efdr *)0,     /* next_file:   next file structure */
1153
1154   (shash_t **)0,        /* shash_head:  string hash table */
1155   { 0 },                /* thash_head:  type hash table */
1156 };
1157
1158
1159 static efdr_t *first_file;                      /* first file descriptor */
1160 static efdr_t **last_file_ptr = &first_file;    /* file descriptor tail */
1161
1162
1163 /* Union of various things that are held in pages.  */
1164 typedef union page {
1165   char          byte    [ PAGE_SIZE ];
1166   unsigned char ubyte   [ PAGE_SIZE ];
1167   efdr_t        file    [ PAGE_SIZE / sizeof (efdr_t)    ];
1168   FDR           ofile   [ PAGE_SIZE / sizeof (FDR)       ];
1169   PDR           proc    [ PAGE_SIZE / sizeof (PDR)       ];
1170   SYMR          sym     [ PAGE_SIZE / sizeof (SYMR)      ];
1171   EXTR          esym    [ PAGE_SIZE / sizeof (EXTR)      ];
1172   AUXU          aux     [ PAGE_SIZE / sizeof (AUXU)      ];
1173   DNR           dense   [ PAGE_SIZE / sizeof (DNR)       ];
1174   scope_t       scope   [ PAGE_SIZE / sizeof (scope_t)   ];
1175   vlinks_t      vlinks  [ PAGE_SIZE / sizeof (vlinks_t)  ];
1176   shash_t       shash   [ PAGE_SIZE / sizeof (shash_t)   ];
1177   thash_t       thash   [ PAGE_SIZE / sizeof (thash_t)   ];
1178   tag_t         tag     [ PAGE_SIZE / sizeof (tag_t)     ];
1179   forward_t     forward [ PAGE_SIZE / sizeof (forward_t) ];
1180   thead_t       thead   [ PAGE_SIZE / sizeof (thead_t)   ];
1181 } page_t;
1182
1183
1184 /* Structure holding allocation information for small sized structures.  */
1185 typedef struct alloc_info {
1186   char          *alloc_name;    /* name of this allocation type (must be first) */
1187   page_t        *cur_page;      /* current page being allocated from */
1188   small_free_t   free_list;     /* current free list if any */
1189   int            unallocated;   /* number of elements unallocated on page */
1190   int            total_alloc;   /* total number of allocations */
1191   int            total_free;    /* total number of frees */
1192   int            total_pages;   /* total number of pages allocated */
1193 } alloc_info_t;
1194
1195 /* Type information collected together.  */
1196 typedef struct type_info {
1197   bt_t        basic_type;               /* basic type */
1198   coff_type_t orig_type;                /* original COFF-based type */
1199   int         num_tq;                   /* # type qualifiers */
1200   int         num_dims;                 /* # dimensions */
1201   int         num_sizes;                /* # sizes */
1202   int         extra_sizes;              /* # extra sizes not tied with dims */
1203   tag_t *     tag_ptr;                  /* tag pointer */
1204   int         bitfield;                 /* symbol is a bitfield */
1205   int         unknown_tag;              /* this is an unknown tag */
1206   tq_t        type_qualifiers[N_TQ];    /* type qualifiers (ptr, func, array)*/
1207   symint_t    dimensions     [N_TQ];    /* dimensions for each array */
1208   symint_t    sizes          [N_TQ+2];  /* sizes of each array slice + size of
1209                                            struct/union/enum + bitfield size */
1210 } type_info_t;
1211
1212 /* Pre-initialized type_info struct.  */
1213 static type_info_t type_info_init = {
1214   bt_Nil,                               /* basic type */
1215   T_NULL,                               /* original COFF-based type */
1216   0,                                    /* # type qualifiers */
1217   0,                                    /* # dimensions */
1218   0,                                    /* # sizes */
1219   0,                                    /* sizes not tied with dims */
1220   NULL,                                 /* ptr to tag */
1221   0,                                    /* bitfield */
1222   0,                                    /* unknown tag */
1223   {                                     /* type qualifiers */
1224     tq_Nil,
1225     tq_Nil,
1226     tq_Nil,
1227     tq_Nil,
1228     tq_Nil,
1229     tq_Nil,
1230   },
1231   {                                     /* dimensions */
1232     0,
1233     0,
1234     0,
1235     0,
1236     0,
1237     0
1238   },
1239   {                                     /* sizes */
1240     0,
1241     0,
1242     0,
1243     0,
1244     0,
1245     0,
1246     0,
1247     0,
1248   },
1249 };
1250
1251
1252 /* Global virtual arrays & hash table for external strings as well as
1253    for the tags table and global tables for file descriptors, and
1254    dense numbers.  */
1255
1256 static varray_t file_desc       = INIT_VARRAY (efdr_t);
1257 static varray_t dense_num       = INIT_VARRAY (DNR);
1258 static varray_t tag_strings     = INIT_VARRAY (char);
1259 static varray_t ext_strings     = INIT_VARRAY (char);
1260 static varray_t ext_symbols     = INIT_VARRAY (EXTR);
1261
1262 static shash_t  *orig_str_hash[SHASH_SIZE];
1263 static shash_t  *ext_str_hash [SHASH_SIZE];
1264 static shash_t  *tag_hash     [SHASH_SIZE];
1265
1266 /* Static types for int and void.  Also, remember the last function's
1267    type (which is set up when we encounter the declaration for the
1268    function, and used when the end block for the function is emitted.  */
1269
1270 static type_info_t int_type_info;
1271 static type_info_t void_type_info;
1272 static type_info_t last_func_type_info;
1273 static EXTR       *last_func_eptr;
1274
1275
1276 /* Convert COFF basic type to ECOFF basic type.  The T_NULL type
1277    really should use bt_Void, but this causes the current ecoff GDB to
1278    issue unsupported type messages, and the Ultrix 4.00 dbx (aka MIPS
1279    2.0) doesn't understand it, even though the compiler generates it.
1280    Maybe this will be fixed in 2.10 or 2.20 of the MIPS compiler
1281    suite, but for now go with what works.  */
1282
1283 static bt_t map_coff_types[ (int)T_MAX ] = {
1284   bt_Nil,                       /* T_NULL */
1285   bt_Nil,                       /* T_ARG */
1286   bt_Char,                      /* T_CHAR */
1287   bt_Short,                     /* T_SHORT */
1288   bt_Int,                       /* T_INT */
1289   bt_Long,                      /* T_LONG */
1290   bt_Float,                     /* T_FLOAT */
1291   bt_Double,                    /* T_DOUBLE */
1292   bt_Struct,                    /* T_STRUCT */
1293   bt_Union,                     /* T_UNION */
1294   bt_Enum,                      /* T_ENUM */
1295   bt_Enum,                      /* T_MOE */
1296   bt_UChar,                     /* T_UCHAR */
1297   bt_UShort,                    /* T_USHORT */
1298   bt_UInt,                      /* T_UINT */
1299   bt_ULong                      /* T_ULONG */
1300 };
1301
1302 /* Convert COFF storage class to ECOFF storage class.  */
1303 static sc_t map_coff_storage[ (int)C_MAX ] = {
1304   sc_Nil,                       /*   0: C_NULL */
1305   sc_Abs,                       /*   1: C_AUTO    auto var */
1306   sc_Undefined,                 /*   2: C_EXT     external */
1307   sc_Data,                      /*   3: C_STAT    static */
1308   sc_Register,                  /*   4: C_REG     register */
1309   sc_Undefined,                 /*   5: C_EXTDEF  ??? */
1310   sc_Text,                      /*   6: C_LABEL   label */
1311   sc_Text,                      /*   7: C_ULABEL  user label */
1312   sc_Info,                      /*   8: C_MOS     member of struct */
1313   sc_Abs,                       /*   9: C_ARG     argument */
1314   sc_Info,                      /*  10: C_STRTAG  struct tag */
1315   sc_Info,                      /*  11: C_MOU     member of union */
1316   sc_Info,                      /*  12: C_UNTAG   union tag */
1317   sc_Info,                      /*  13: C_TPDEF   typedef */
1318   sc_Data,                      /*  14: C_USTATIC ??? */
1319   sc_Info,                      /*  15: C_ENTAG   enum tag */
1320   sc_Info,                      /*  16: C_MOE     member of enum */
1321   sc_Register,                  /*  17: C_REGPARM register parameter */
1322   sc_Bits,                      /*  18; C_FIELD   bitfield */
1323   sc_Nil,                       /*  19 */
1324   sc_Nil,                       /*  20 */
1325   sc_Nil,                       /*  21 */
1326   sc_Nil,                       /*  22 */
1327   sc_Nil,                       /*  23 */
1328   sc_Nil,                       /*  24 */
1329   sc_Nil,                       /*  25 */
1330   sc_Nil,                       /*  26 */
1331   sc_Nil,                       /*  27 */
1332   sc_Nil,                       /*  28 */
1333   sc_Nil,                       /*  29 */
1334   sc_Nil,                       /*  30 */
1335   sc_Nil,                       /*  31 */
1336   sc_Nil,                       /*  32 */
1337   sc_Nil,                       /*  33 */
1338   sc_Nil,                       /*  34 */
1339   sc_Nil,                       /*  35 */
1340   sc_Nil,                       /*  36 */
1341   sc_Nil,                       /*  37 */
1342   sc_Nil,                       /*  38 */
1343   sc_Nil,                       /*  39 */
1344   sc_Nil,                       /*  40 */
1345   sc_Nil,                       /*  41 */
1346   sc_Nil,                       /*  42 */
1347   sc_Nil,                       /*  43 */
1348   sc_Nil,                       /*  44 */
1349   sc_Nil,                       /*  45 */
1350   sc_Nil,                       /*  46 */
1351   sc_Nil,                       /*  47 */
1352   sc_Nil,                       /*  48 */
1353   sc_Nil,                       /*  49 */
1354   sc_Nil,                       /*  50 */
1355   sc_Nil,                       /*  51 */
1356   sc_Nil,                       /*  52 */
1357   sc_Nil,                       /*  53 */
1358   sc_Nil,                       /*  54 */
1359   sc_Nil,                       /*  55 */
1360   sc_Nil,                       /*  56 */
1361   sc_Nil,                       /*  57 */
1362   sc_Nil,                       /*  58 */
1363   sc_Nil,                       /*  59 */
1364   sc_Nil,                       /*  60 */
1365   sc_Nil,                       /*  61 */
1366   sc_Nil,                       /*  62 */
1367   sc_Nil,                       /*  63 */
1368   sc_Nil,                       /*  64 */
1369   sc_Nil,                       /*  65 */
1370   sc_Nil,                       /*  66 */
1371   sc_Nil,                       /*  67 */
1372   sc_Nil,                       /*  68 */
1373   sc_Nil,                       /*  69 */
1374   sc_Nil,                       /*  70 */
1375   sc_Nil,                       /*  71 */
1376   sc_Nil,                       /*  72 */
1377   sc_Nil,                       /*  73 */
1378   sc_Nil,                       /*  74 */
1379   sc_Nil,                       /*  75 */
1380   sc_Nil,                       /*  76 */
1381   sc_Nil,                       /*  77 */
1382   sc_Nil,                       /*  78 */
1383   sc_Nil,                       /*  79 */
1384   sc_Nil,                       /*  80 */
1385   sc_Nil,                       /*  81 */
1386   sc_Nil,                       /*  82 */
1387   sc_Nil,                       /*  83 */
1388   sc_Nil,                       /*  84 */
1389   sc_Nil,                       /*  85 */
1390   sc_Nil,                       /*  86 */
1391   sc_Nil,                       /*  87 */
1392   sc_Nil,                       /*  88 */
1393   sc_Nil,                       /*  89 */
1394   sc_Nil,                       /*  90 */
1395   sc_Nil,                       /*  91 */
1396   sc_Nil,                       /*  92 */
1397   sc_Nil,                       /*  93 */
1398   sc_Nil,                       /*  94 */
1399   sc_Nil,                       /*  95 */
1400   sc_Nil,                       /*  96 */
1401   sc_Nil,                       /*  97 */
1402   sc_Nil,                       /*  98 */
1403   sc_Nil,                       /*  99 */
1404   sc_Text,                      /* 100: C_BLOCK  block start/end */
1405   sc_Text,                      /* 101: C_FCN    function start/end */
1406   sc_Info,                      /* 102: C_EOS    end of struct/union/enum */
1407   sc_Nil,                       /* 103: C_FILE   file start */
1408   sc_Nil,                       /* 104: C_LINE   line number */
1409   sc_Nil,                       /* 105: C_ALIAS  combined type info */
1410   sc_Nil,                       /* 106: C_HIDDEN ??? */
1411 };
1412
1413 /* Convert COFF storage class to ECOFF symbol type.  */
1414 static st_t map_coff_sym_type[ (int)C_MAX ] = {
1415   st_Nil,                       /*   0: C_NULL */
1416   st_Local,                     /*   1: C_AUTO    auto var */
1417   st_Global,                    /*   2: C_EXT     external */
1418   st_Static,                    /*   3: C_STAT    static */
1419   st_Local,                     /*   4: C_REG     register */
1420   st_Global,                    /*   5: C_EXTDEF  ??? */
1421   st_Label,                     /*   6: C_LABEL   label */
1422   st_Label,                     /*   7: C_ULABEL  user label */
1423   st_Member,                    /*   8: C_MOS     member of struct */
1424   st_Param,                     /*   9: C_ARG     argument */
1425   st_Block,                     /*  10: C_STRTAG  struct tag */
1426   st_Member,                    /*  11: C_MOU     member of union */
1427   st_Block,                     /*  12: C_UNTAG   union tag */
1428   st_Typedef,                   /*  13: C_TPDEF   typedef */
1429   st_Static,                    /*  14: C_USTATIC ??? */
1430   st_Block,                     /*  15: C_ENTAG   enum tag */
1431   st_Member,                    /*  16: C_MOE     member of enum */
1432   st_Param,                     /*  17: C_REGPARM register parameter */
1433   st_Member,                    /*  18; C_FIELD   bitfield */
1434   st_Nil,                       /*  19 */
1435   st_Nil,                       /*  20 */
1436   st_Nil,                       /*  21 */
1437   st_Nil,                       /*  22 */
1438   st_Nil,                       /*  23 */
1439   st_Nil,                       /*  24 */
1440   st_Nil,                       /*  25 */
1441   st_Nil,                       /*  26 */
1442   st_Nil,                       /*  27 */
1443   st_Nil,                       /*  28 */
1444   st_Nil,                       /*  29 */
1445   st_Nil,                       /*  30 */
1446   st_Nil,                       /*  31 */
1447   st_Nil,                       /*  32 */
1448   st_Nil,                       /*  33 */
1449   st_Nil,                       /*  34 */
1450   st_Nil,                       /*  35 */
1451   st_Nil,                       /*  36 */
1452   st_Nil,                       /*  37 */
1453   st_Nil,                       /*  38 */
1454   st_Nil,                       /*  39 */
1455   st_Nil,                       /*  40 */
1456   st_Nil,                       /*  41 */
1457   st_Nil,                       /*  42 */
1458   st_Nil,                       /*  43 */
1459   st_Nil,                       /*  44 */
1460   st_Nil,                       /*  45 */
1461   st_Nil,                       /*  46 */
1462   st_Nil,                       /*  47 */
1463   st_Nil,                       /*  48 */
1464   st_Nil,                       /*  49 */
1465   st_Nil,                       /*  50 */
1466   st_Nil,                       /*  51 */
1467   st_Nil,                       /*  52 */
1468   st_Nil,                       /*  53 */
1469   st_Nil,                       /*  54 */
1470   st_Nil,                       /*  55 */
1471   st_Nil,                       /*  56 */
1472   st_Nil,                       /*  57 */
1473   st_Nil,                       /*  58 */
1474   st_Nil,                       /*  59 */
1475   st_Nil,                       /*  60 */
1476   st_Nil,                       /*  61 */
1477   st_Nil,                       /*  62 */
1478   st_Nil,                       /*  63 */
1479   st_Nil,                       /*  64 */
1480   st_Nil,                       /*  65 */
1481   st_Nil,                       /*  66 */
1482   st_Nil,                       /*  67 */
1483   st_Nil,                       /*  68 */
1484   st_Nil,                       /*  69 */
1485   st_Nil,                       /*  70 */
1486   st_Nil,                       /*  71 */
1487   st_Nil,                       /*  72 */
1488   st_Nil,                       /*  73 */
1489   st_Nil,                       /*  74 */
1490   st_Nil,                       /*  75 */
1491   st_Nil,                       /*  76 */
1492   st_Nil,                       /*  77 */
1493   st_Nil,                       /*  78 */
1494   st_Nil,                       /*  79 */
1495   st_Nil,                       /*  80 */
1496   st_Nil,                       /*  81 */
1497   st_Nil,                       /*  82 */
1498   st_Nil,                       /*  83 */
1499   st_Nil,                       /*  84 */
1500   st_Nil,                       /*  85 */
1501   st_Nil,                       /*  86 */
1502   st_Nil,                       /*  87 */
1503   st_Nil,                       /*  88 */
1504   st_Nil,                       /*  89 */
1505   st_Nil,                       /*  90 */
1506   st_Nil,                       /*  91 */
1507   st_Nil,                       /*  92 */
1508   st_Nil,                       /*  93 */
1509   st_Nil,                       /*  94 */
1510   st_Nil,                       /*  95 */
1511   st_Nil,                       /*  96 */
1512   st_Nil,                       /*  97 */
1513   st_Nil,                       /*  98 */
1514   st_Nil,                       /*  99 */
1515   st_Block,                     /* 100: C_BLOCK  block start/end */
1516   st_Proc,                      /* 101: C_FCN    function start/end */
1517   st_End,                       /* 102: C_EOS    end of struct/union/enum */
1518   st_File,                      /* 103: C_FILE   file start */
1519   st_Nil,                       /* 104: C_LINE   line number */
1520   st_Nil,                       /* 105: C_ALIAS  combined type info */
1521   st_Nil,                       /* 106: C_HIDDEN ??? */
1522 };
1523
1524 /* Map COFF derived types to ECOFF type qualifiers.  */
1525 static tq_t map_coff_derived_type[ (int)DT_MAX ] = {
1526   tq_Nil,                       /* 0: DT_NON    no more qualifiers */
1527   tq_Ptr,                       /* 1: DT_PTR    pointer */
1528   tq_Proc,                      /* 2: DT_FCN    function */
1529   tq_Array,                     /* 3: DT_ARY    array */
1530 };
1531
1532
1533 /* Keep track of different sized allocation requests.  */
1534 static alloc_info_t alloc_counts[ (int)alloc_type_last ];
1535
1536 \f
1537 /* Pointers and such to the original symbol table that is read in.  */
1538 static struct filehdr orig_file_header;         /* global object file header */
1539
1540 static HDRR      orig_sym_hdr;                  /* symbolic header on input */
1541 static char     *orig_linenum;                  /* line numbers */
1542 static DNR      *orig_dense;                    /* dense numbers */
1543 static PDR      *orig_procs;                    /* procedures */
1544 static SYMR     *orig_local_syms;               /* local symbols */
1545 static OPTR     *orig_opt_syms;                 /* optimization symbols */
1546 static AUXU     *orig_aux_syms;                 /* auxiliary symbols */
1547 static char     *orig_local_strs;               /* local strings */
1548 static char     *orig_ext_strs;                 /* external strings */
1549 static FDR      *orig_files;                    /* file descriptors */
1550 static symint_t *orig_rfds;                     /* relative file desc's */
1551 static EXTR     *orig_ext_syms;                 /* external symbols */
1552
1553 /* Macros to convert an index into a given object within the original
1554    symbol table.  */
1555 #define CHECK(num,max,str) \
1556   (((unsigned long)num > (unsigned long)max) ? out_of_bounds (num, max, str, __LINE__) : 0)
1557
1558 #define ORIG_LINENUM(index)     (CHECK ((index), orig_sym_hdr.cbLine,    "line#"), (index) + orig_linenum)
1559 #define ORIG_DENSE(index)       (CHECK ((index), orig_sym_hdr.idnMax,    "dense"), (index) + orig_dense)
1560 #define ORIG_PROCS(index)       (CHECK ((index), orig_sym_hdr.ipdMax,    "procs"), (index) + orig_procs)
1561 #define ORIG_FILES(index)       (CHECK ((index), orig_sym_hdr.ifdMax,    "funcs"), (index) + orig_files)
1562 #define ORIG_LSYMS(index)       (CHECK ((index), orig_sym_hdr.isymMax,   "lsyms"), (index) + orig_local_syms)
1563 #define ORIG_LSTRS(index)       (CHECK ((index), orig_sym_hdr.issMax,    "lstrs"), (index) + orig_local_strs)
1564 #define ORIG_ESYMS(index)       (CHECK ((index), orig_sym_hdr.iextMax,   "esyms"), (index) + orig_ext_syms)
1565 #define ORIG_ESTRS(index)       (CHECK ((index), orig_sym_hdr.issExtMax, "estrs"), (index) + orig_ext_strs)
1566 #define ORIG_OPT(index)         (CHECK ((index), orig_sym_hdr.ioptMax,   "opt"),   (index) + orig_opt_syms)
1567 #define ORIG_AUX(index)         (CHECK ((index), orig_sym_hdr.iauxMax,   "aux"),   (index) + orig_aux_syms)
1568 #define ORIG_RFDS(index)        (CHECK ((index), orig_sym_hdr.crfd,      "rfds"),  (index) + orig_rfds)
1569
1570 /* Various other statics.  */
1571 static HDRR     symbolic_header;                /* symbolic header */
1572 static efdr_t  *cur_file_ptr    = (efdr_t *) 0; /* current file desc. header */
1573 static PDR     *cur_proc_ptr    = (PDR *) 0;    /* current procedure header */
1574 static SYMR    *cur_oproc_begin = (SYMR *) 0;   /* original proc. sym begin info */
1575 static SYMR    *cur_oproc_end   = (SYMR *) 0;   /* original proc. sym end info */
1576 static PDR     *cur_oproc_ptr   = (PDR *) 0;    /* current original procedure*/
1577 static thead_t *cur_tag_head    = (thead_t *)0; /* current tag head */
1578 static long     file_offset     = 0;            /* current file offset */
1579 static long     max_file_offset = 0;            /* maximum file offset */
1580 static FILE    *object_stream   = (FILE *)0;    /* file desc. to output .o */
1581 static FILE    *obj_in_stream   = (FILE *)0;    /* file desc. to input .o */
1582 static char    *progname        = (char *)0;    /* program name for errors */
1583 static char    *input_name      = "stdin";      /* name of input file */
1584 static char    *object_name     = (char *)0;    /* tmp. name of object file */
1585 static char    *obj_in_name     = (char *)0;    /* name of input object file */
1586 static char    *cur_line_start  = (char *)0;    /* current line read in */
1587 static char    *cur_line_ptr    = (char *)0;    /* ptr within current line */
1588 static unsigned cur_line_nbytes = 0;            /* # bytes for current line */
1589 static unsigned cur_line_alloc  = 0;            /* # bytes total in buffer */
1590 static long     line_number     = 0;            /* current input line number */
1591 static int      debug           = 0;            /* trace functions */
1592 static int      version         = 0;            /* print version # */
1593 static int      had_errors      = 0;            /* != 0 if errors were found */
1594 static int      rename_output   = 0;            /* != 0 if rename output file*/
1595 static int      delete_input    = 0;            /* != 0 if delete input after done */
1596 static int      stabs_seen      = 0;            /* != 0 if stabs have been seen */
1597
1598
1599 /* Pseudo symbol to use when putting stabs into the symbol table.  */
1600 #ifndef STABS_SYMBOL
1601 #define STABS_SYMBOL "@stabs"
1602 #endif
1603
1604 static char stabs_symbol[] = STABS_SYMBOL;
1605
1606 \f
1607 /* Forward reference for functions.  See the definition for more details.  */
1608
1609 #ifndef STATIC
1610 #define STATIC static
1611 #endif
1612
1613 STATIC int      out_of_bounds   __proto((symint_t, symint_t, const char *, int));
1614
1615 STATIC shash_t *hash_string     __proto((const char *,
1616                                          Ptrdiff_t,
1617                                          shash_t **,
1618                                          symint_t *));
1619
1620 STATIC symint_t add_string      __proto((varray_t *,
1621                                          shash_t **,
1622                                          const char *,
1623                                          const char *,
1624                                          shash_t **));
1625
1626 STATIC symint_t add_local_symbol
1627                                 __proto((const char *,
1628                                          const char *,
1629                                          st_t,
1630                                          sc_t,
1631                                          symint_t,
1632                                          symint_t));
1633
1634 STATIC symint_t add_ext_symbol  __proto((const char *,
1635                                          const char *,
1636                                          st_t,
1637                                          sc_t,
1638                                          long,
1639                                          symint_t,
1640                                          int));
1641
1642 STATIC symint_t add_aux_sym_symint
1643                                 __proto((symint_t));
1644
1645 STATIC symint_t add_aux_sym_rndx
1646                                 __proto((int, symint_t));
1647
1648 STATIC symint_t add_aux_sym_tir __proto((type_info_t *,
1649                                          hash_state_t,
1650                                          thash_t **));
1651
1652 STATIC tag_t *  get_tag         __proto((const char *,
1653                                          const char *,
1654                                          symint_t,
1655                                          bt_t));
1656
1657 STATIC void     add_unknown_tag __proto((tag_t *));
1658
1659 STATIC void     add_procedure   __proto((const char *,
1660                                          const char *));
1661
1662 STATIC void     add_file        __proto((const char *,
1663                                          const char *));
1664
1665 STATIC void     add_bytes       __proto((varray_t *,
1666                                          char *,
1667                                          Size_t));
1668
1669 STATIC void     add_varray_page __proto((varray_t *));
1670
1671 STATIC void     update_headers  __proto((void));
1672
1673 STATIC void     write_varray    __proto((varray_t *, off_t, const char *));
1674 STATIC void     write_object    __proto((void));
1675 STATIC char    *st_to_string    __proto((st_t));
1676 STATIC char    *sc_to_string    __proto((sc_t));
1677 STATIC char    *read_line       __proto((void));
1678 STATIC void     parse_input     __proto((void));
1679 STATIC void     mark_stabs      __proto((const char *));
1680 STATIC void     parse_begin     __proto((const char *));
1681 STATIC void     parse_bend      __proto((const char *));
1682 STATIC void     parse_def       __proto((const char *));
1683 STATIC void     parse_end       __proto((const char *));
1684 STATIC void     parse_ent       __proto((const char *));
1685 STATIC void     parse_file      __proto((const char *));
1686 STATIC void     parse_stabs_common
1687                                 __proto((const char *, const char *, const char *));
1688 STATIC void     parse_stabs     __proto((const char *));
1689 STATIC void     parse_stabn     __proto((const char *));
1690 STATIC page_t  *read_seek       __proto((Size_t, off_t, const char *));
1691 STATIC void     copy_object     __proto((void));
1692
1693 STATIC void     catch_signal    __proto((int));
1694 STATIC page_t  *allocate_page   __proto((void));
1695
1696 STATIC page_t  *allocate_multiple_pages
1697                                 __proto((Size_t));
1698
1699 STATIC void     free_multiple_pages
1700                                 __proto((page_t *, Size_t));
1701
1702 #ifndef MALLOC_CHECK
1703 STATIC page_t  *allocate_cluster
1704                                 __proto((Size_t));
1705 #endif
1706
1707 STATIC forward_t *allocate_forward      __proto((void));
1708 STATIC scope_t   *allocate_scope        __proto((void));
1709 STATIC shash_t   *allocate_shash        __proto((void));
1710 STATIC tag_t     *allocate_tag          __proto((void));
1711 STATIC thash_t   *allocate_thash        __proto((void));
1712 STATIC thead_t   *allocate_thead        __proto((void));
1713 STATIC vlinks_t  *allocate_vlinks       __proto((void));
1714
1715 STATIC void       free_forward          __proto((forward_t *));
1716 STATIC void       free_scope            __proto((scope_t *));
1717 STATIC void       free_tag              __proto((tag_t *));
1718 STATIC void       free_thead            __proto((thead_t *));
1719
1720 extern char  *sbrk                      __proto((int));
1721 extern PTR_T  malloc                    __proto((Size_t));
1722 extern PTR_T  calloc                    __proto((Size_t, Size_t));
1723 extern PTR_T  realloc                   __proto((PTR_T, Size_t));
1724 extern void   free                      __proto((PTR_T));
1725 extern char  *mktemp                    __proto((char *));
1726 extern long   strtol                    __proto((const char *, char **, int));
1727
1728 extern char *optarg;
1729 extern int   optind;
1730 extern int   opterr;
1731 extern char *version_string;
1732 extern char *sys_siglist[NSIG + 1];
1733
1734 #ifndef SEEK_SET        /* Symbolic constants for the "fseek" function: */
1735 #define SEEK_SET 0      /* Set file pointer to offset */
1736 #define SEEK_CUR 1      /* Set file pointer to its current value plus offset */
1737 #define SEEK_END 2      /* Set file pointer to the size of the file plus offset */
1738 #endif
1739
1740 \f
1741 /* List of assembler pseudo ops and beginning sequences that need
1742    special actions.  Someday, this should be a hash table, and such,
1743    but for now a linear list of names and calls to memcmp will
1744    do...... */
1745
1746 typedef struct _pseudo_ops {
1747   const char *name;                     /* pseudo-op in ascii */
1748   int len;                              /* length of name to compare */
1749   void (*func) __proto((const char *)); /* function to handle line */
1750 } pseudo_ops_t;
1751
1752 static pseudo_ops_t pseudo_ops[] = {
1753   { "#.def",    sizeof("#.def")-1,      parse_def },
1754   { "#.begin",  sizeof("#.begin")-1,    parse_begin },
1755   { "#.bend",   sizeof("#.bend")-1,     parse_bend },
1756   { ".end",     sizeof(".end")-1,       parse_end },
1757   { ".ent",     sizeof(".ent")-1,       parse_ent },
1758   { ".file",    sizeof(".file")-1,      parse_file },
1759   { "#.stabs",  sizeof("#.stabs")-1,    parse_stabs },
1760   { "#.stabn",  sizeof("#.stabn")-1,    parse_stabn },
1761   { ".stabs",   sizeof(".stabs")-1,     parse_stabs },
1762   { ".stabn",   sizeof(".stabn")-1,     parse_stabn },
1763   { "#@stabs",  sizeof("#@stabs")-1,    mark_stabs },
1764 };
1765
1766 \f
1767 /* Add a page to a varray object.  */
1768
1769 STATIC void
1770 add_varray_page (vp)
1771      varray_t *vp;                              /* varray to add page to */
1772 {
1773   vlinks_t *new_links = allocate_vlinks ();
1774
1775 #ifdef MALLOC_CHECK
1776   if (vp->object_size > 1)
1777     new_links->datum = (page_t *) xcalloc (1, vp->object_size);
1778   else
1779 #endif
1780     new_links->datum = allocate_page ();
1781
1782   alloc_counts[ (int)alloc_type_varray ].total_alloc++;
1783   alloc_counts[ (int)alloc_type_varray ].total_pages++;
1784
1785   new_links->start_index = vp->num_allocated;
1786   vp->objects_last_page = 0;
1787
1788   if (vp->first == (vlinks_t *)0)               /* first allocation? */
1789     vp->first = vp->last = new_links;
1790   else
1791     {                                           /* 2nd or greater allocation */
1792       new_links->prev = vp->last;
1793       vp->last->next = new_links;
1794       vp->last = new_links;
1795     }
1796 }
1797
1798 \f
1799 /* Compute hash code (from tree.c) */
1800
1801 #define HASHBITS 30
1802
1803 STATIC shash_t *
1804 hash_string (text, hash_len, hash_tbl, ret_hash_index)
1805      const char *text;                  /* ptr to text to hash */
1806      Ptrdiff_t hash_len;                /* length of the text */
1807      shash_t **hash_tbl;                /* hash table */
1808      symint_t *ret_hash_index;          /* ptr to store hash index */
1809 {
1810   register unsigned long hi;
1811   register Ptrdiff_t i;
1812   register shash_t *ptr;
1813   register int first_ch = *text;
1814
1815   hi = hash_len;
1816   for (i = 0; i < hash_len; i++)
1817     hi = ((hi & 0x003fffff) * 613) + (text[i] & 0xff);
1818
1819   hi &= (1 << HASHBITS) - 1;
1820   hi %= SHASH_SIZE;
1821
1822   if (ret_hash_index != (symint_t *)0)
1823     *ret_hash_index = hi;
1824
1825   for (ptr = hash_tbl[hi]; ptr != (shash_t *)0; ptr = ptr->next)
1826     if (hash_len == ptr->len
1827         && first_ch == ptr->string[0]
1828         && memcmp ((CPTR_T) text, (CPTR_T) ptr->string, hash_len) == 0)
1829       break;
1830
1831   return ptr;
1832 }
1833
1834 \f
1835 /* Add a string (and null pad) to one of the string tables.  A
1836    consequence of hashing strings, is that we don't let strings
1837    cross page boundaries.  The extra nulls will be ignored.  */
1838
1839 STATIC symint_t
1840 add_string (vp, hash_tbl, start, end_p1, ret_hash)
1841      varray_t *vp;                      /* string virtual array */
1842      shash_t **hash_tbl;                /* ptr to hash table */
1843      const char *start;                 /* 1st byte in string */
1844      const char *end_p1;                /* 1st byte after string */
1845      shash_t **ret_hash;                /* return hash pointer */
1846 {
1847   register Ptrdiff_t len = end_p1 - start;
1848   register shash_t *hash_ptr;
1849   symint_t hi;
1850
1851   if (len >= PAGE_USIZE)
1852     fatal ("String too big (%ld bytes)", (long) len);
1853
1854   hash_ptr = hash_string (start, len, hash_tbl, &hi);
1855   if (hash_ptr == (shash_t *)0)
1856     {
1857       register char *p;
1858
1859       if (vp->objects_last_page + len >= PAGE_USIZE)
1860         {
1861           vp->num_allocated =
1862             ((vp->num_allocated + PAGE_USIZE - 1) / PAGE_USIZE) * PAGE_USIZE;
1863           add_varray_page (vp);
1864         }
1865
1866       hash_ptr = allocate_shash ();
1867       hash_ptr->next = hash_tbl[hi];
1868       hash_tbl[hi] = hash_ptr;
1869
1870       hash_ptr->len = len;
1871       hash_ptr->index = vp->num_allocated;
1872       hash_ptr->string = p =
1873         & vp->last->datum->byte[ vp->objects_last_page ];
1874
1875       vp->objects_last_page += len+1;
1876       vp->num_allocated += len+1;
1877
1878       while (len-- > 0)
1879         *p++ = *start++;
1880
1881       *p = '\0';
1882     }
1883
1884   if (ret_hash != (shash_t **)0)
1885     *ret_hash = hash_ptr;
1886
1887   return hash_ptr->index;
1888 }
1889
1890 \f
1891 /* Add a local symbol.  */
1892
1893 STATIC symint_t
1894 add_local_symbol (str_start, str_end_p1, type, storage, value, indx)
1895      const char *str_start;             /* first byte in string */
1896      const char *str_end_p1;            /* first byte after string */
1897      st_t type;                         /* symbol type */
1898      sc_t storage;                      /* storage class */
1899      symint_t value;                    /* value of symbol */
1900      symint_t indx;                     /* index to local/aux. syms */
1901 {
1902   register symint_t ret;
1903   register SYMR *psym;
1904   register scope_t *pscope;
1905   register thead_t *ptag_head;
1906   register tag_t *ptag;
1907   register tag_t *ptag_next;
1908   register varray_t *vp = &cur_file_ptr->symbols;
1909   register int scope_delta = 0;
1910   shash_t *hash_ptr = (shash_t *)0;
1911
1912   if (vp->objects_last_page == vp->objects_per_page)
1913     add_varray_page (vp);
1914
1915   psym = &vp->last->datum->sym[ vp->objects_last_page++ ];
1916
1917   psym->value = value;
1918   psym->st = (unsigned) type;
1919   psym->sc = (unsigned) storage;
1920   psym->index = indx;
1921   psym->iss = (str_start == (const char *)0)
1922                 ? 0
1923                 : add_string (&cur_file_ptr->strings,
1924                               &cur_file_ptr->shash_head[0],
1925                               str_start,
1926                               str_end_p1,
1927                               &hash_ptr);
1928
1929   ret = vp->num_allocated++;
1930
1931   if (MIPS_IS_STAB(psym))
1932     return ret;
1933
1934   /* Save the symbol within the hash table if this is a static
1935      item, and it has a name.  */
1936   if (hash_ptr != (shash_t *)0
1937       && (type == st_Global || type == st_Static || type == st_Label
1938           || type == st_Proc || type == st_StaticProc))
1939     hash_ptr->sym_ptr = psym;
1940
1941   /* push or pop a scope if appropriate.  */
1942   switch (type)
1943     {
1944     default:
1945       break;
1946
1947     case st_File:                       /* beginning of file */
1948     case st_Proc:                       /* procedure */
1949     case st_StaticProc:                 /* static procedure */
1950     case st_Block:                      /* begin scope */
1951       pscope = allocate_scope ();
1952       pscope->prev = cur_file_ptr->cur_scope;
1953       pscope->lsym = psym;
1954       pscope->lnumber = ret;
1955       pscope->type = type;
1956       cur_file_ptr->cur_scope = pscope;
1957
1958       if (type != st_File)
1959         scope_delta = 1;
1960
1961       /* For every block type except file, struct, union, or
1962          enumeration blocks, push a level on the tag stack.  We omit
1963          file types, so that tags can span file boundaries.  */
1964       if (type != st_File && storage != sc_Info)
1965         {
1966           ptag_head = allocate_thead ();
1967           ptag_head->first_tag = 0;
1968           ptag_head->prev = cur_tag_head;
1969           cur_tag_head = ptag_head;
1970         }
1971       break;
1972
1973     case st_End:
1974       pscope = cur_file_ptr->cur_scope;
1975       if (pscope == (scope_t *)0)
1976         error ("internal error, too many st_End's");
1977
1978       else
1979         {
1980           st_t begin_type = (st_t) pscope->lsym->st;
1981
1982           if (begin_type != st_File)
1983             scope_delta = -1;
1984
1985           /* Except for file, structure, union, or enumeration end
1986              blocks remove all tags created within this scope.  */
1987           if (begin_type != st_File && storage != sc_Info)
1988             {
1989               ptag_head = cur_tag_head;
1990               cur_tag_head = ptag_head->prev;
1991
1992               for (ptag = ptag_head->first_tag;
1993                    ptag != (tag_t *)0;
1994                    ptag = ptag_next)
1995                 {
1996                   if (ptag->forward_ref != (forward_t *)0)
1997                     add_unknown_tag (ptag);
1998
1999                   ptag_next = ptag->same_block;
2000                   ptag->hash_ptr->tag_ptr = ptag->same_name;
2001                   free_tag (ptag);
2002                 }
2003
2004               free_thead (ptag_head);
2005             }
2006
2007           cur_file_ptr->cur_scope = pscope->prev;
2008           psym->index = pscope->lnumber;        /* blk end gets begin sym # */
2009
2010           if (storage != sc_Info)
2011             psym->iss = pscope->lsym->iss;      /* blk end gets same name */
2012
2013           if (begin_type == st_File || begin_type == st_Block)
2014             pscope->lsym->index = ret+1; /* block begin gets next sym # */
2015
2016           /* Functions push two or more aux words as follows:
2017              1st word: index+1 of the end symbol
2018              2nd word: type of the function (plus any aux words needed).
2019              Also, tie the external pointer back to the function begin symbol.  */
2020           else
2021             {
2022               symint_t type;
2023               pscope->lsym->index = add_aux_sym_symint (ret+1);
2024               type = add_aux_sym_tir (&last_func_type_info,
2025                                       hash_no,
2026                                       &cur_file_ptr->thash_head[0]);
2027               if (last_func_eptr)
2028                 {
2029                   last_func_eptr->ifd = cur_file_ptr->file_index;
2030                   last_func_eptr->asym.index = type;
2031                 }
2032             }
2033
2034           free_scope (pscope);
2035         }
2036     }
2037
2038   cur_file_ptr->nested_scopes += scope_delta;
2039
2040   if (debug && type != st_File
2041       && (debug > 2 || type == st_Block || type == st_End
2042           || type == st_Proc || type == st_StaticProc))
2043     {
2044       char *sc_str = sc_to_string (storage);
2045       char *st_str = st_to_string (type);
2046       int depth = cur_file_ptr->nested_scopes + (scope_delta < 0);
2047
2048       fprintf (stderr,
2049                "\tlsym\tv= %10ld, depth= %2d, sc= %-12s",
2050                value, depth, sc_str);
2051
2052       if (str_start && str_end_p1 - str_start > 0)
2053         fprintf (stderr, " st= %-11s name= %.*s\n", st_str, str_end_p1 - str_start, str_start);
2054       else
2055         {
2056           Size_t len = strlen (st_str);
2057           fprintf (stderr, " st= %.*s\n", len-1, st_str);
2058         }
2059     }
2060
2061   return ret;
2062 }
2063
2064 \f
2065 /* Add an external symbol.  */
2066
2067 STATIC symint_t
2068 add_ext_symbol (str_start, str_end_p1, type, storage, value, indx, ifd)
2069      const char *str_start;             /* first byte in string */
2070      const char *str_end_p1;            /* first byte after string */
2071      st_t type;                         /* symbol type */
2072      sc_t storage;                      /* storage class */
2073      long value;                        /* value of symbol */
2074      symint_t indx;                     /* index to local/aux. syms */
2075      int ifd;                           /* file index */
2076 {
2077   register EXTR *psym;
2078   register varray_t *vp = &ext_symbols;
2079   shash_t *hash_ptr = (shash_t *)0;
2080
2081   if (debug > 1)
2082     {
2083       char *sc_str = sc_to_string (storage);
2084       char *st_str = st_to_string (type);
2085
2086       fprintf (stderr,
2087                "\tesym\tv= %10ld, ifd= %2d, sc= %-12s",
2088                value, ifd, sc_str);
2089
2090       if (str_start && str_end_p1 - str_start > 0)
2091         fprintf (stderr, " st= %-11s name= %.*s\n", st_str, str_end_p1 - str_start, str_start);
2092       else
2093         fprintf (stderr, " st= %s\n", st_str);
2094     }
2095
2096   if (vp->objects_last_page == vp->objects_per_page)
2097     add_varray_page (vp);
2098
2099   psym = &vp->last->datum->esym[ vp->objects_last_page++ ];
2100
2101   psym->ifd = ifd;
2102   psym->asym.value = value;
2103   psym->asym.st    = (unsigned) type;
2104   psym->asym.sc    = (unsigned) storage;
2105   psym->asym.index = indx;
2106   psym->asym.iss   = (str_start == (const char *)0)
2107                         ? 0
2108                         : add_string (&ext_strings,
2109                                       &ext_str_hash[0],
2110                                       str_start,
2111                                       str_end_p1,
2112                                       &hash_ptr);
2113
2114   hash_ptr->esym_ptr = psym;
2115   return vp->num_allocated++;
2116 }
2117
2118 \f
2119 /* Add an auxiliary symbol (passing a symint).  */
2120
2121 STATIC symint_t
2122 add_aux_sym_symint (aux_word)
2123      symint_t aux_word;         /* auxiliary information word */
2124 {
2125   register AUXU *aux_ptr;
2126   register efdr_t *file_ptr = cur_file_ptr;
2127   register varray_t *vp = &file_ptr->aux_syms;
2128
2129   if (vp->objects_last_page == vp->objects_per_page)
2130     add_varray_page (vp);
2131
2132   aux_ptr = &vp->last->datum->aux[ vp->objects_last_page++ ];
2133   aux_ptr->isym = aux_word;
2134
2135   return vp->num_allocated++;
2136 }
2137
2138
2139 /* Add an auxiliary symbol (passing a file/symbol index combo).  */
2140
2141 STATIC symint_t
2142 add_aux_sym_rndx (file_index, sym_index)
2143      int file_index;
2144      symint_t sym_index;
2145 {
2146   register AUXU *aux_ptr;
2147   register efdr_t *file_ptr = cur_file_ptr;
2148   register varray_t *vp = &file_ptr->aux_syms;
2149
2150   if (vp->objects_last_page == vp->objects_per_page)
2151     add_varray_page (vp);
2152
2153   aux_ptr = &vp->last->datum->aux[ vp->objects_last_page++ ];
2154   aux_ptr->rndx.rfd   = file_index;
2155   aux_ptr->rndx.index = sym_index;
2156
2157   return vp->num_allocated++;
2158 }
2159
2160 \f
2161 /* Add an auxiliary symbol (passing the basic type and possibly
2162    type qualifiers).  */
2163
2164 STATIC symint_t
2165 add_aux_sym_tir (t, state, hash_tbl)
2166      type_info_t *t;            /* current type information */
2167      hash_state_t state;        /* whether to hash type or not */
2168      thash_t **hash_tbl;        /* pointer to hash table to use */
2169 {
2170   register AUXU *aux_ptr;
2171   register efdr_t *file_ptr = cur_file_ptr;
2172   register varray_t *vp = &file_ptr->aux_syms;
2173   static AUXU init_aux;
2174   symint_t ret;
2175   int i;
2176   AUXU aux;
2177
2178   aux = init_aux;
2179   aux.ti.bt = (int) t->basic_type;
2180   aux.ti.continued = 0;
2181   aux.ti.fBitfield = t->bitfield;
2182
2183   aux.ti.tq0 = (int) t->type_qualifiers[0];
2184   aux.ti.tq1 = (int) t->type_qualifiers[1];
2185   aux.ti.tq2 = (int) t->type_qualifiers[2];
2186   aux.ti.tq3 = (int) t->type_qualifiers[3];
2187   aux.ti.tq4 = (int) t->type_qualifiers[4];
2188   aux.ti.tq5 = (int) t->type_qualifiers[5];
2189
2190
2191   /* For anything that adds additional information, we must not hash,
2192      so check here, and reset our state. */
2193
2194   if (state != hash_no
2195       && (t->type_qualifiers[0] == tq_Array
2196           || t->type_qualifiers[1] == tq_Array
2197           || t->type_qualifiers[2] == tq_Array
2198           || t->type_qualifiers[3] == tq_Array
2199           || t->type_qualifiers[4] == tq_Array
2200           || t->type_qualifiers[5] == tq_Array
2201           || t->basic_type == bt_Struct
2202           || t->basic_type == bt_Union
2203           || t->basic_type == bt_Enum
2204           || t->bitfield
2205           || t->num_dims > 0))
2206     state = hash_no;
2207
2208   /* See if we can hash this type, and save some space, but some types
2209      can't be hashed (because they contain arrays or continuations),
2210      and others can be put into the hash list, but cannot use existing
2211      types because other aux entries precede this one.  */
2212
2213   if (state != hash_no)
2214     {
2215       register thash_t *hash_ptr;
2216       register symint_t hi;
2217
2218       hi = aux.isym & ((1 << HASHBITS) - 1);
2219       hi %= THASH_SIZE;
2220
2221       for (hash_ptr = hash_tbl[hi];
2222            hash_ptr != (thash_t *)0;
2223            hash_ptr = hash_ptr->next)
2224         {
2225           if (aux.isym == hash_ptr->type.isym)
2226             break;
2227         }
2228
2229       if (hash_ptr != (thash_t *)0 && state == hash_yes)
2230         return hash_ptr->index;
2231
2232       if (hash_ptr == (thash_t *)0)
2233         {
2234           hash_ptr = allocate_thash ();
2235           hash_ptr->next = hash_tbl[hi];
2236           hash_ptr->type = aux;
2237           hash_ptr->index = vp->num_allocated;
2238           hash_tbl[hi] = hash_ptr;
2239         }
2240     }
2241
2242   /* Everything is set up, add the aux symbol. */
2243   if (vp->objects_last_page == vp->objects_per_page)
2244     add_varray_page (vp);
2245
2246   aux_ptr = &vp->last->datum->aux[ vp->objects_last_page++ ];
2247   *aux_ptr = aux;
2248
2249   ret = vp->num_allocated++;
2250
2251   /* Add bitfield length if it exists.
2252
2253      NOTE:  Mips documentation claims bitfield goes at the end of the
2254      AUX record, but the DECstation compiler emits it here.
2255      (This would only make a difference for enum bitfields.)
2256
2257      Also note:  We use the last size given since gcc may emit 2
2258      for an enum bitfield.  */
2259
2260   if (t->bitfield)
2261     (void) add_aux_sym_symint ((symint_t)t->sizes[t->num_sizes-1]);
2262
2263
2264   /* Add tag information if needed.  Structure, union, and enum
2265      references add 2 aux symbols: a [file index, symbol index]
2266      pointer to the structure type, and the current file index.  */
2267
2268   if (t->basic_type == bt_Struct
2269       || t->basic_type == bt_Union
2270       || t->basic_type == bt_Enum)
2271     {
2272       register symint_t file_index = t->tag_ptr->ifd;
2273       register symint_t sym_index  = t->tag_ptr->index;
2274
2275       if (t->unknown_tag)
2276         {
2277           (void) add_aux_sym_rndx (ST_RFDESCAPE, sym_index);
2278           (void) add_aux_sym_symint ((symint_t)-1);
2279         }
2280       else if (sym_index != indexNil)
2281         {
2282           (void) add_aux_sym_rndx (ST_RFDESCAPE, sym_index);
2283           (void) add_aux_sym_symint (file_index);
2284         }
2285       else
2286         {
2287           register forward_t *forward_ref = allocate_forward ();
2288
2289           forward_ref->type_ptr = aux_ptr;
2290           forward_ref->next = t->tag_ptr->forward_ref;
2291           t->tag_ptr->forward_ref = forward_ref;
2292
2293           (void) add_aux_sym_rndx (ST_RFDESCAPE, sym_index);
2294           forward_ref->index_ptr
2295             = &vp->last->datum->aux[ vp->objects_last_page - 1];
2296
2297           (void) add_aux_sym_symint (file_index);
2298           forward_ref->ifd_ptr
2299             = &vp->last->datum->aux[ vp->objects_last_page - 1];
2300         }
2301     }
2302
2303   /* Add information about array bounds if they exist.  */
2304   for (i = 0; i < t->num_dims; i++)
2305     {
2306       (void) add_aux_sym_rndx (ST_RFDESCAPE,
2307                                cur_file_ptr->int_type);
2308
2309       (void) add_aux_sym_symint (cur_file_ptr->file_index);     /* file index*/
2310       (void) add_aux_sym_symint ((symint_t)0);                  /* low bound */
2311       (void) add_aux_sym_symint (t->dimensions[i] - 1);         /* high bound*/
2312       (void) add_aux_sym_symint ((t->dimensions[i] == 0)        /* stride */
2313                               ? 0
2314                               : (t->sizes[i] * 8) / t->dimensions[i]);
2315     };
2316
2317   /* NOTE:  Mips documentation claism that the bitfield width goes here.
2318      But it needs to be emitted earlier. */
2319
2320   return ret;
2321 }
2322
2323 \f
2324 /* Add a tag to the tag table (unless it already exists).  */
2325
2326 STATIC tag_t *
2327 get_tag (tag_start, tag_end_p1, index, basic_type)
2328      const char *tag_start;             /* 1st byte of tag name */
2329      const char *tag_end_p1;            /* 1st byte after tag name */
2330      symint_t index;                    /* index of tag start block */
2331      bt_t basic_type;                   /* bt_Struct, bt_Union, or bt_Enum */
2332 {
2333   shash_t *hash_ptr;
2334   tag_t *tag_ptr;
2335   hash_ptr = hash_string (tag_start,
2336                           tag_end_p1 - tag_start,
2337                           &tag_hash[0],
2338                           (symint_t *)0);
2339
2340   if (hash_ptr != (shash_t *)0
2341       && hash_ptr->tag_ptr != (tag_t *)0)
2342   {
2343     tag_ptr = hash_ptr->tag_ptr;
2344     if (index != indexNil)
2345       {
2346         tag_ptr->basic_type = basic_type;
2347         tag_ptr->ifd        = cur_file_ptr->file_index;
2348         tag_ptr->index      = index;
2349       }
2350     return tag_ptr;
2351   }
2352
2353   (void) add_string (&tag_strings,
2354                      &tag_hash[0],
2355                      tag_start,
2356                      tag_end_p1,
2357                      &hash_ptr);
2358
2359   tag_ptr = allocate_tag ();
2360   tag_ptr->forward_ref  = (forward_t *) 0;
2361   tag_ptr->hash_ptr     = hash_ptr;
2362   tag_ptr->same_name    = hash_ptr->tag_ptr;
2363   tag_ptr->basic_type   = basic_type;
2364   tag_ptr->index        = index;
2365   tag_ptr->ifd          = (index == indexNil) ? -1 : cur_file_ptr->file_index;
2366   tag_ptr->same_block   = cur_tag_head->first_tag;
2367
2368   cur_tag_head->first_tag = tag_ptr;
2369   hash_ptr->tag_ptr       = tag_ptr;
2370
2371   return tag_ptr;
2372 }
2373
2374 \f
2375 /* Add an unknown {struct, union, enum} tag.  */
2376
2377 STATIC void
2378 add_unknown_tag (ptag)
2379      tag_t      *ptag;          /* pointer to tag information */
2380 {
2381   shash_t *hash_ptr     = ptag->hash_ptr;
2382   char *name_start      = hash_ptr->string;
2383   char *name_end_p1     = name_start + hash_ptr->len;
2384   forward_t *f_next     = ptag->forward_ref;
2385   forward_t *f_cur;
2386   int sym_index;
2387   int file_index        = cur_file_ptr->file_index;
2388
2389   if (debug > 1)
2390     {
2391       char *agg_type    = "{unknown aggregate type}";
2392       switch (ptag->basic_type)
2393         {
2394         case bt_Struct: agg_type = "struct";    break;
2395         case bt_Union:  agg_type = "union";     break;
2396         case bt_Enum:   agg_type = "enum";      break;
2397         default:                                break;
2398         }
2399
2400       fprintf (stderr, "unknown %s %.*s found\n", agg_type,
2401                hash_ptr->len, name_start);
2402     }
2403
2404   sym_index = add_local_symbol (name_start,
2405                                 name_end_p1,
2406                                 st_Block,
2407                                 sc_Info,
2408                                 (symint_t)0,
2409                                 (symint_t)0);
2410
2411   (void) add_local_symbol (name_start,
2412                            name_end_p1,
2413                            st_End,
2414                            sc_Info,
2415                            (symint_t)0,
2416                            (symint_t)0);
2417
2418   while (f_next != (forward_t *)0)
2419     {
2420       f_cur  = f_next;
2421       f_next = f_next->next;
2422
2423       f_cur->ifd_ptr->isym = file_index;
2424       f_cur->index_ptr->rndx.index = sym_index;
2425
2426       free_forward (f_cur);
2427     }
2428
2429   return;
2430 }
2431
2432 \f
2433 /* Add a procedure to the current file's list of procedures, and record
2434    this is the current procedure.  If the assembler created a PDR for
2435    this procedure, use that to initialize the current PDR.  */
2436
2437 STATIC void
2438 add_procedure (func_start, func_end_p1)
2439      const char *func_start;            /* 1st byte of func name */
2440      const char *func_end_p1;           /* 1st byte after func name */
2441 {
2442   register PDR *new_proc_ptr;
2443   register efdr_t *file_ptr = cur_file_ptr;
2444   register varray_t *vp = &file_ptr->procs;
2445   register symint_t value = 0;
2446   register st_t proc_type = st_Proc;
2447   register shash_t *shash_ptr = hash_string (func_start,
2448                                             func_end_p1 - func_start,
2449                                             &orig_str_hash[0],
2450                                             (symint_t *)0);
2451
2452   if (debug)
2453     fputc ('\n', stderr);
2454
2455   if (vp->objects_last_page == vp->objects_per_page)
2456     add_varray_page (vp);
2457
2458   cur_proc_ptr = new_proc_ptr = &vp->last->datum->proc[ vp->objects_last_page++ ];
2459
2460   vp->num_allocated++;
2461
2462
2463   /* Did the assembler create this procedure?  If so, get the PDR information.  */
2464   cur_oproc_ptr = (PDR *)0;
2465   if (shash_ptr != (shash_t *)0)
2466     {
2467       register PDR *old_proc_ptr = shash_ptr->proc_ptr;
2468       register SYMR *sym_ptr = shash_ptr->sym_ptr;
2469
2470       if (old_proc_ptr != (PDR *)0
2471           && sym_ptr != (SYMR *)0
2472           && ((st_t)sym_ptr->st == st_Proc || (st_t)sym_ptr->st == st_StaticProc))
2473         {
2474           cur_oproc_begin = sym_ptr;
2475           cur_oproc_end = shash_ptr->end_ptr;
2476           value = sym_ptr->value;
2477
2478           cur_oproc_ptr = old_proc_ptr;
2479           proc_type = (st_t)sym_ptr->st;
2480           *new_proc_ptr = *old_proc_ptr;        /* initialize */
2481         }
2482     }
2483
2484   if (cur_oproc_ptr == (PDR *)0)
2485     error ("Did not find a PDR block for %.*s", func_end_p1 - func_start, func_start);
2486
2487   /* Determine the start of symbols. */
2488   new_proc_ptr->isym = file_ptr->symbols.num_allocated;
2489
2490   /* Push the start of the function.  */
2491   (void) add_local_symbol (func_start, func_end_p1,
2492                            proc_type, sc_Text,
2493                            value,
2494                            (symint_t)0);
2495 }
2496
2497 \f
2498 /* Add a new filename, and set up all of the file relative
2499    virtual arrays (strings, symbols, aux syms, etc.).  Record
2500    where the current file structure lives.  */
2501
2502 STATIC void
2503 add_file (file_start, file_end_p1)
2504      const char *file_start;            /* first byte in string */
2505      const char *file_end_p1;           /* first byte after string */
2506 {
2507   static char zero_bytes[2] = { '\0', '\0' };
2508
2509   register Ptrdiff_t len = file_end_p1 - file_start;
2510   register int first_ch = *file_start;
2511   register efdr_t *file_ptr;
2512
2513   if (debug)
2514     fprintf (stderr, "\tfile\t%.*s\n", len, file_start);
2515
2516   /* See if the file has already been created.  */
2517   for (file_ptr = first_file;
2518        file_ptr != (efdr_t *)0;
2519        file_ptr = file_ptr->next_file)
2520     {
2521       if (first_ch == file_ptr->name[0]
2522           && file_ptr->name[len] == '\0'
2523           && memcmp ((CPTR_T) file_start, (CPTR_T) file_ptr->name, len) == 0)
2524         {
2525           cur_file_ptr = file_ptr;
2526           break;
2527         }
2528     }
2529
2530   /* If this is a new file, create it. */
2531   if (file_ptr == (efdr_t *)0)
2532     {
2533       if (file_desc.objects_last_page == file_desc.objects_per_page)
2534         add_varray_page (&file_desc);
2535
2536       file_ptr = cur_file_ptr =
2537         &file_desc.last->datum->file[ file_desc.objects_last_page++ ];
2538       *file_ptr = init_file;
2539
2540       file_ptr->file_index = file_desc.num_allocated++;
2541
2542       /* Allocate the string hash table.  */
2543       file_ptr->shash_head = (shash_t **) allocate_page ();
2544
2545       /* Make sure 0 byte in string table is null  */
2546       add_string (&file_ptr->strings,
2547                   &file_ptr->shash_head[0],
2548                   &zero_bytes[0],
2549                   &zero_bytes[0],
2550                   (shash_t **)0);
2551
2552       if (file_end_p1 - file_start > PAGE_USIZE-2)
2553         fatal ("Filename goes over one page boundary.");
2554
2555       /* Push the start of the filename. We assume that the filename
2556          will be stored at string offset 1.  */
2557       (void) add_local_symbol (file_start, file_end_p1, st_File, sc_Text,
2558                                (symint_t)0, (symint_t)0);
2559       file_ptr->fdr.rss = 1;
2560       file_ptr->name = &file_ptr->strings.last->datum->byte[1];
2561       file_ptr->name_len = file_end_p1 - file_start;
2562
2563       /* Update the linked list of file descriptors.  */
2564       *last_file_ptr = file_ptr;
2565       last_file_ptr = &file_ptr->next_file;
2566
2567       /* Add void & int types to the file (void should be first to catch
2568          errant 0's within the index fields).  */
2569       file_ptr->void_type = add_aux_sym_tir (&void_type_info,
2570                                              hash_yes,
2571                                              &cur_file_ptr->thash_head[0]);
2572
2573       file_ptr->int_type = add_aux_sym_tir (&int_type_info,
2574                                             hash_yes,
2575                                             &cur_file_ptr->thash_head[0]);
2576     }
2577 }
2578
2579 \f
2580 /* Add a stream of random bytes to a varray.  */
2581
2582 STATIC void
2583 add_bytes (vp, input_ptr, nitems)
2584      varray_t *vp;                      /* virtual array to add too */
2585      char *input_ptr;                   /* start of the bytes */
2586      Size_t nitems;                     /* # items to move */
2587 {
2588   register Size_t move_items;
2589   register Size_t move_bytes;
2590   register char *ptr;
2591
2592   while (nitems > 0)
2593     {
2594       if (vp->objects_last_page >= vp->objects_per_page)
2595         add_varray_page (vp);
2596
2597       ptr = &vp->last->datum->byte[ vp->objects_last_page * vp->object_size ];
2598       move_items = vp->objects_per_page - vp->objects_last_page;
2599       if (move_items > nitems)
2600         move_items = nitems;
2601
2602       move_bytes = move_items * vp->object_size;
2603       nitems -= move_items;
2604
2605       if (move_bytes >= 32)
2606         {
2607           (void) memcpy ((PTR_T) ptr, (CPTR_T) input_ptr, move_bytes);
2608           input_ptr += move_bytes;
2609         }
2610       else
2611         {
2612           while (move_bytes-- > 0)
2613             *ptr++ = *input_ptr++;
2614         }
2615     }
2616 }
2617
2618 \f
2619 /* Convert storage class to string.  */
2620
2621 STATIC char *
2622 sc_to_string(storage_class)
2623      sc_t storage_class;
2624 {
2625   switch(storage_class)
2626     {
2627     case sc_Nil:         return "Nil,";
2628     case sc_Text:        return "Text,";
2629     case sc_Data:        return "Data,";
2630     case sc_Bss:         return "Bss,";
2631     case sc_Register:    return "Register,";
2632     case sc_Abs:         return "Abs,";
2633     case sc_Undefined:   return "Undefined,";
2634     case sc_CdbLocal:    return "CdbLocal,";
2635     case sc_Bits:        return "Bits,";
2636     case sc_CdbSystem:   return "CdbSystem,";
2637     case sc_RegImage:    return "RegImage,";
2638     case sc_Info:        return "Info,";
2639     case sc_UserStruct:  return "UserStruct,";
2640     case sc_SData:       return "SData,";
2641     case sc_SBss:        return "SBss,";
2642     case sc_RData:       return "RData,";
2643     case sc_Var:         return "Var,";
2644     case sc_Common:      return "Common,";
2645     case sc_SCommon:     return "SCommon,";
2646     case sc_VarRegister: return "VarRegister,";
2647     case sc_Variant:     return "Variant,";
2648     case sc_SUndefined:  return "SUndefined,";
2649     case sc_Init:        return "Init,";
2650     case sc_Max:         return "Max,";
2651     }
2652
2653   return "???,";
2654 }
2655
2656 \f
2657 /* Convert symbol type to string.  */
2658
2659 STATIC char *
2660 st_to_string(symbol_type)
2661      st_t symbol_type;
2662 {
2663   switch(symbol_type)
2664     {
2665     case st_Nil:        return "Nil,";
2666     case st_Global:     return "Global,";
2667     case st_Static:     return "Static,";
2668     case st_Param:      return "Param,";
2669     case st_Local:      return "Local,";
2670     case st_Label:      return "Label,";
2671     case st_Proc:       return "Proc,";
2672     case st_Block:      return "Block,";
2673     case st_End:        return "End,";
2674     case st_Member:     return "Member,";
2675     case st_Typedef:    return "Typedef,";
2676     case st_File:       return "File,";
2677     case st_RegReloc:   return "RegReloc,";
2678     case st_Forward:    return "Forward,";
2679     case st_StaticProc: return "StaticProc,";
2680     case st_Constant:   return "Constant,";
2681     case st_Str:        return "String,";
2682     case st_Number:     return "Number,";
2683     case st_Expr:       return "Expr,";
2684     case st_Type:       return "Type,";
2685     case st_Max:        return "Max,";
2686     }
2687
2688   return "???,";
2689 }
2690
2691 \f
2692 /* Read a line from standard input, and return the start of the buffer
2693    (which is grows if the line is too big).  We split lines at the
2694    semi-colon, and return each logical line indpendently.  */
2695
2696 STATIC char *
2697 read_line __proto((void))
2698 {
2699   static   int line_split_p     = 0;
2700   register int string_p         = 0;
2701   register int comment_p        = 0;
2702   register int ch;
2703   register char *ptr;
2704
2705   if (cur_line_start == (char *)0)
2706     {                           /* allocate initial page */
2707       cur_line_start = (char *) allocate_page ();
2708       cur_line_alloc = PAGE_SIZE;
2709     }
2710
2711   if (!line_split_p)
2712     line_number++;
2713
2714   line_split_p = 0;
2715   cur_line_nbytes = 0;
2716
2717   for (ptr = cur_line_start; (ch = getchar ()) != EOF; *ptr++ = ch)
2718     {
2719       if (++cur_line_nbytes >= cur_line_alloc-1)
2720         {
2721           register int num_pages = cur_line_alloc / PAGE_SIZE;
2722           register char *old_buffer = cur_line_start;
2723
2724           cur_line_alloc += PAGE_SIZE;
2725           cur_line_start = (char *) allocate_multiple_pages (num_pages+1);
2726           memcpy (cur_line_start, old_buffer, num_pages * PAGE_SIZE);
2727
2728           ptr = cur_line_start + cur_line_nbytes - 1;
2729         }
2730
2731       if (ch == '\n')
2732         {
2733           *ptr++ = '\n';
2734           *ptr = '\0';
2735           cur_line_ptr = cur_line_start;
2736           return cur_line_ptr;
2737         }
2738
2739       else if (ch == '\0')
2740         error ("Null character found in input");
2741
2742       else if (!comment_p)
2743         {
2744           if (ch == '"')
2745             string_p = !string_p;
2746
2747           else if (ch == '#')
2748             comment_p++;
2749
2750           else if (ch == ';')
2751             {
2752               line_split_p = 1;
2753               *ptr++ = '\n';
2754               *ptr = '\0';
2755               cur_line_ptr = cur_line_start;
2756               return cur_line_ptr;
2757             }
2758         }
2759     }
2760
2761   if (ferror (stdin))
2762     pfatal_with_name (input_name);
2763
2764   cur_line_ptr = (char *)0;
2765   return (char *)0;
2766 }
2767
2768 \f
2769 /* Parse #.begin directives which have a label as the first argument
2770    which gives the location of the start of the block.  */
2771
2772 STATIC void
2773 parse_begin (start)
2774      const char *start;                 /* start of directive */
2775 {
2776   const char *end_p1;                   /* end of label */
2777   int ch;
2778   shash_t *hash_ptr;                    /* hash pointer to lookup label */
2779
2780   if (cur_file_ptr == (efdr_t *)0)
2781     {
2782       error ("#.begin directive without a preceding .file directive");
2783       return;
2784     }
2785
2786   if (cur_proc_ptr == (PDR *)0)
2787     {
2788       error ("#.begin directive without a preceding .ent directive");
2789       return;
2790     }
2791
2792   for (end_p1 = start; (ch = *end_p1) != '\0' && !isspace (ch); end_p1++)
2793     ;
2794
2795   hash_ptr = hash_string (start,
2796                           end_p1 - start,
2797                           &orig_str_hash[0],
2798                           (symint_t *)0);
2799
2800   if (hash_ptr == (shash_t *)0)
2801     {
2802       error ("Label %.*s not found for #.begin", end_p1 - start, start);
2803       return;
2804     }
2805
2806   if (cur_oproc_begin == (SYMR *)0)
2807     {
2808       error ("Procedure table %.*s not found for #.begin", end_p1 - start, start);
2809       return;
2810     }
2811
2812   (void) add_local_symbol ((const char *)0, (const char *)0,
2813                            st_Block, sc_Text,
2814                            (symint_t)hash_ptr->sym_ptr->value - cur_oproc_begin->value,
2815                            (symint_t)0);
2816 }
2817
2818 \f
2819 /* Parse #.bend directives which have a label as the first argument
2820    which gives the location of the end of the block.  */
2821
2822 STATIC void
2823 parse_bend (start)
2824      const char *start;                 /* start of directive */
2825 {
2826   const char *end_p1;                   /* end of label */
2827   int ch;
2828   shash_t *hash_ptr;                    /* hash pointer to lookup label */
2829
2830   if (cur_file_ptr == (efdr_t *)0)
2831     {
2832       error ("#.begin directive without a preceding .file directive");
2833       return;
2834     }
2835
2836   if (cur_proc_ptr == (PDR *)0)
2837     {
2838       error ("#.bend directive without a preceding .ent directive");
2839       return;
2840     }
2841
2842   for (end_p1 = start; (ch = *end_p1) != '\0' && !isspace (ch); end_p1++)
2843     ;
2844
2845   hash_ptr = hash_string (start,
2846                           end_p1 - start,
2847                           &orig_str_hash[0],
2848                           (symint_t *)0);
2849
2850   if (hash_ptr == (shash_t *)0)
2851     {
2852       error ("Label %.*s not found for #.bend", end_p1 - start, start);
2853       return;
2854     }
2855
2856   if (cur_oproc_begin == (SYMR *)0)
2857     {
2858       error ("Procedure table %.*s not found for #.bend", end_p1 - start, start);
2859       return;
2860     }
2861
2862   (void) add_local_symbol ((const char *)0, (const char *)0,
2863                            st_End, sc_Text,
2864                            (symint_t)hash_ptr->sym_ptr->value - cur_oproc_begin->value,
2865                            (symint_t)0);
2866 }
2867
2868 \f
2869 /* Parse #.def directives, which are contain standard COFF subdirectives
2870    to describe the debugging format.  These subdirectives include:
2871
2872         .scl    specify storage class
2873         .val    specify a value
2874         .endef  specify end of COFF directives
2875         .type   specify the type
2876         .size   specify the size of an array
2877         .dim    specify an array dimension
2878         .tag    specify a tag for a struct, union, or enum.  */
2879
2880 STATIC void
2881 parse_def (name_start)
2882      const char *name_start;                    /* start of directive */
2883 {
2884   const char *dir_start;                        /* start of current directive*/
2885   const char *dir_end_p1;                       /* end+1 of current directive*/
2886   const char *arg_start;                        /* start of current argument */
2887   const char *arg_end_p1;                       /* end+1 of current argument */
2888   const char *name_end_p1;                      /* end+1 of label */
2889   const char *tag_start   = (const char *)0;    /* start of tag name */
2890   const char *tag_end_p1  = (const char *)0;    /* end+1 of tag name */
2891   sc_t storage_class      = sc_Nil;
2892   st_t symbol_type        = st_Nil;
2893   type_info_t t;
2894   EXTR *eptr              = (EXTR *)0;          /* ext. sym equivalent to def*/
2895   int is_function         = 0;                  /* != 0 if function */
2896   symint_t value          = 0;
2897   symint_t index          = cur_file_ptr->void_type;
2898   int error_line          = 0;
2899   symint_t arg_number;
2900   symint_t temp_array[ N_TQ ];
2901   int arg_was_number;
2902   int ch, i;
2903   Ptrdiff_t len;
2904
2905   static int inside_enumeration = 0;            /* is this an enumeration? */
2906
2907
2908   /* Initialize the type information.  */
2909   t = type_info_init;
2910
2911
2912   /* Search for the end of the name being defined.  */
2913   for (name_end_p1 = name_start; (ch = *name_end_p1) != ';'; name_end_p1++)
2914     {
2915       if (ch == '\0' || isspace (ch))
2916         {
2917           error_line = __LINE__;
2918           saber_stop ();
2919           goto bomb_out;
2920         }
2921     }
2922
2923   /* Parse the remaining subdirectives now.  */
2924   dir_start = name_end_p1+1;
2925   for (;;)
2926     {
2927       while ((ch = *dir_start) == ' ' || ch == '\t')
2928         ++dir_start;
2929
2930       if (ch != '.')
2931         {
2932           error_line = __LINE__;
2933           saber_stop ();
2934           goto bomb_out;
2935         }
2936
2937       /* Are we done? */
2938       if (dir_start[1] == 'e'
2939           && memcmp (dir_start, ".endef", sizeof (".endef")-1) == 0)
2940         break;
2941
2942       /* Pick up the subdirective now */
2943       for (dir_end_p1 = dir_start+1;
2944            (ch = *dir_end_p1) != ' ' && ch != '\t';
2945            dir_end_p1++)
2946         {
2947           if (ch == '\0' || isspace (ch))
2948             {
2949               error_line = __LINE__;
2950               saber_stop ();
2951               goto bomb_out;
2952             }
2953         }
2954
2955       /* Pick up the subdirective argument now.  */
2956       arg_was_number = arg_number = 0;
2957       arg_end_p1 = (const char *)0;
2958       arg_start = dir_end_p1+1;
2959       ch = *arg_start;
2960       while (ch == ' ' || ch == '\t')
2961         ch = *++arg_start;
2962
2963       if (isdigit (ch) || ch == '-' || ch == '+')
2964         {
2965           int ch2;
2966           arg_number = strtol (arg_start, (char **) &arg_end_p1, 0);
2967           if (arg_end_p1 != arg_start || (ch2 = *arg_end_p1 != ';') || ch2 != ',')
2968             arg_was_number++;
2969         }
2970
2971       else if (ch == '\0' || isspace (ch))
2972         {
2973           error_line = __LINE__;
2974           saber_stop ();
2975           goto bomb_out;
2976         }
2977
2978       if (!arg_was_number)
2979         for (arg_end_p1 = arg_start+1; (ch = *arg_end_p1) != ';'; arg_end_p1++)
2980           {
2981             if (ch == '\0' || isspace (ch))
2982               {
2983                 error_line = __LINE__;
2984                 saber_stop ();
2985                 goto bomb_out;
2986               }
2987           }
2988
2989
2990       /* Classify the directives now.  */
2991       len = dir_end_p1 - dir_start;
2992       switch (dir_start[1])
2993         {
2994         default:
2995           error_line = __LINE__;
2996           saber_stop ();
2997           goto bomb_out;
2998
2999         case 'd':
3000           if (len == sizeof (".dim")-1
3001               && memcmp (dir_start, ".dim", sizeof (".dim")-1) == 0
3002               && arg_was_number)
3003             {
3004               symint_t *t_ptr = &temp_array[ N_TQ-1 ];
3005
3006               *t_ptr = arg_number;
3007               while (*arg_end_p1 == ',' && arg_was_number)
3008                 {
3009                   arg_start = arg_end_p1+1;
3010                   ch = *arg_start;
3011                   while (ch == ' ' || ch == '\t')
3012                     ch = *++arg_start;
3013
3014                   arg_was_number = 0;
3015                   if (isdigit (ch) || ch == '-' || ch == '+')
3016                     {
3017                       int ch2;
3018                       arg_number = strtol (arg_start, (char **) &arg_end_p1, 0);
3019                       if (arg_end_p1 != arg_start || (ch2 = *arg_end_p1 != ';') || ch2 != ',')
3020                         arg_was_number++;
3021
3022                       if (t_ptr == &temp_array[0])
3023                         {
3024                           error_line = __LINE__;
3025                           saber_stop ();
3026                           goto bomb_out;
3027                         }
3028
3029                       *--t_ptr = arg_number;
3030                     }
3031                 }
3032
3033               /* Reverse order of dimensions.  */
3034               while (t_ptr <= &temp_array[ N_TQ-1 ])
3035                 {
3036                   if (t.num_dims >= N_TQ-1)
3037                     {
3038                       error_line = __LINE__;
3039                       saber_stop ();
3040                       goto bomb_out;
3041                     }
3042
3043                   t.dimensions[ t.num_dims++ ] = *t_ptr++;
3044                 }
3045               break;
3046             }
3047           else
3048             {
3049               error_line = __LINE__;
3050               saber_stop ();
3051               goto bomb_out;
3052             }
3053
3054
3055         case 's':
3056           if (len == sizeof (".scl")-1
3057               && memcmp (dir_start, ".scl", sizeof (".scl")-1) == 0
3058               && arg_was_number
3059               && arg_number < ((symint_t) C_MAX))
3060             {
3061               /* If the symbol is a static or external, we have
3062                  already gotten the appropriate type and class, so
3063                  make sure we don't override those values.  This is
3064                  needed because there are some type and classes that
3065                  are not in COFF, such as short data, etc.  */
3066               if (symbol_type == st_Nil)
3067                 {
3068                   symbol_type   = map_coff_sym_type[arg_number];
3069                   storage_class = map_coff_storage [arg_number];
3070                 }
3071               break;
3072             }
3073
3074           else if (len == sizeof (".size")-1
3075                    && memcmp (dir_start, ".size", sizeof (".size")-1) == 0
3076                    && arg_was_number)
3077             {
3078               symint_t *t_ptr = &temp_array[ N_TQ-1 ];
3079
3080               *t_ptr = arg_number;
3081               while (*arg_end_p1 == ',' && arg_was_number)
3082                 {
3083                   arg_start = arg_end_p1+1;
3084                   ch = *arg_start;
3085                   while (ch == ' ' || ch == '\t')
3086                     ch = *++arg_start;
3087
3088                   arg_was_number = 0;
3089                   if (isdigit (ch) || ch == '-' || ch == '+')
3090                     {
3091                       int ch2;
3092                       arg_number = strtol (arg_start, (char **) &arg_end_p1, 0);
3093                       if (arg_end_p1 != arg_start || (ch2 = *arg_end_p1 != ';') || ch2 != ',')
3094                         arg_was_number++;
3095
3096                       if (t_ptr == &temp_array[0])
3097                         {
3098                           error_line = __LINE__;
3099                           saber_stop ();
3100                           goto bomb_out;
3101                         }
3102
3103                       *--t_ptr = arg_number;
3104                     }
3105                 }
3106
3107               /* Reverse order of sizes.  */
3108               while (t_ptr <= &temp_array[ N_TQ-1 ])
3109                 {
3110                   if (t.num_sizes >= N_TQ-1)
3111                     {
3112                       error_line = __LINE__;
3113                       saber_stop ();
3114                       goto bomb_out;
3115                     }
3116
3117                   t.sizes[ t.num_sizes++ ] = *t_ptr++;
3118                 }
3119               break;
3120             }
3121
3122           else
3123             {
3124               error_line = __LINE__;
3125               saber_stop ();
3126               goto bomb_out;
3127             }
3128
3129
3130         case 't':
3131           if (len == sizeof (".type")-1
3132               && memcmp (dir_start, ".type", sizeof (".type")-1) == 0
3133               && arg_was_number)
3134             {
3135               tq_t *tq_ptr = &t.type_qualifiers[0];
3136
3137               t.orig_type = (coff_type_t) (arg_number & N_BTMASK);
3138               t.basic_type = map_coff_types [(int)t.orig_type];
3139               for (i = N_TQ-1; i >= 0; i--)
3140                 {
3141                   int dt = (arg_number >> ((i * N_TQ_SHIFT) + N_BT_SHIFT)
3142                             & N_TMASK);
3143
3144                   if (dt != (int)DT_NON)
3145                     *tq_ptr++ = map_coff_derived_type [dt];
3146                 }
3147
3148               /* If this is a function, ignore it, so that we don't get
3149                  two entries (one from the .ent, and one for the .def
3150                  that precedes it).  Save the type information so that
3151                  the end block can properly add it after the begin block
3152                  index.  For MIPS knows what reason, we must strip off
3153                  the function type at this point.  */
3154               if (tq_ptr != &t.type_qualifiers[0] && tq_ptr[-1] == tq_Proc)
3155                 {
3156                   is_function = 1;
3157                   tq_ptr[-1] = tq_Nil;
3158                 }
3159
3160               break;
3161             }
3162
3163           else if (len == sizeof (".tag")-1
3164               && memcmp (dir_start, ".tag", sizeof (".tag")-1) == 0)
3165             {
3166               tag_start = arg_start;
3167               tag_end_p1 = arg_end_p1;
3168               break;
3169             }
3170
3171           else
3172             {
3173               error_line = __LINE__;
3174               saber_stop ();
3175               goto bomb_out;
3176             }
3177
3178
3179         case 'v':
3180           if (len == sizeof (".val")-1
3181               && memcmp (dir_start, ".val", sizeof (".val")-1) == 0)
3182             {
3183               if (arg_was_number)
3184                 value = arg_number;
3185
3186               /* If the value is not an integer value, it must be the
3187                  name of a static or global item.  Look up the name in
3188                  the original symbol table to pick up the storage
3189                  class, symbol type, etc.  */
3190               else
3191                 {
3192                   shash_t *orig_hash_ptr;       /* hash within orig sym table*/
3193                   shash_t *ext_hash_ptr;        /* hash within ext. sym table*/
3194
3195                   ext_hash_ptr = hash_string (arg_start,
3196                                               arg_end_p1 - arg_start,
3197                                               &ext_str_hash[0],
3198                                               (symint_t *)0);
3199
3200                   if (ext_hash_ptr != (shash_t *)0
3201                       && ext_hash_ptr->esym_ptr != (EXTR *)0)
3202                     eptr = ext_hash_ptr->esym_ptr;
3203
3204                   orig_hash_ptr = hash_string (arg_start,
3205                                                arg_end_p1 - arg_start,
3206                                                &orig_str_hash[0],
3207                                                (symint_t *)0);
3208
3209                   if ((orig_hash_ptr == (shash_t *)0
3210                        || orig_hash_ptr->sym_ptr == (SYMR *)0)
3211                       && eptr == (EXTR *)0)
3212                     {
3213                       fprintf (stderr, "warning, %.*s not found in original or external symbol tables, value defaults to 0\n",
3214                                arg_end_p1 - arg_start,
3215                                arg_start);
3216                       value = 0;
3217                     }
3218                   else
3219                     {
3220                       SYMR *ptr = (orig_hash_ptr != (shash_t *)0
3221                                    && orig_hash_ptr->sym_ptr != (SYMR *)0)
3222                                         ? orig_hash_ptr->sym_ptr
3223                                         : &eptr->asym;
3224
3225                       symbol_type = (st_t) ptr->st;
3226                       storage_class = (sc_t) ptr->sc;
3227                       value = ptr->value;
3228                     }
3229                 }
3230               break;
3231             }
3232           else
3233             {
3234               error_line = __LINE__;
3235               saber_stop ();
3236               goto bomb_out;
3237             }
3238         }
3239
3240       /* Set up to find next directive.  */
3241       dir_start = arg_end_p1 + 1;
3242     }
3243
3244
3245   t.extra_sizes = (tag_start != (char *)0);
3246   if (t.num_dims > 0)
3247     {
3248       int diff = t.num_dims - t.num_sizes;
3249       int i = t.num_dims - 1;
3250       int j;
3251
3252       if (t.num_sizes != 1 || diff < 0)
3253         {
3254           error_line = __LINE__;
3255           saber_stop ();
3256           goto bomb_out;
3257         }
3258
3259       /* If this is an array, make sure the same number of dimensions
3260          and sizes were passed, creating extra sizes for multiply
3261          dimensioned arrays if not passed.  */
3262
3263       t.extra_sizes = 0;
3264       if (diff)
3265         {
3266           for (j = (sizeof (t.sizes) / sizeof (t.sizes[0])) - 1; j >= 0; j--)
3267             t.sizes[ j ] = ((j-diff) >= 0) ? t.sizes[ j-diff ] : 0;
3268
3269           t.num_sizes = i + 1;
3270           for ( i--; i >= 0; i-- )
3271             t.sizes[ i ] = t.sizes[ i+1 ] / t.dimensions[ i+1 ];
3272         }
3273     }
3274
3275   else if (symbol_type == st_Member && t.num_sizes - t.extra_sizes == 1)
3276     { /* Is this a bitfield?  This is indicated by a structure memeber
3277          having a size field that isn't an array.  */
3278
3279       t.bitfield = 1;
3280     }
3281
3282
3283   /* Except for enumeration members & begin/ending of scopes, put the
3284      type word in the aux. symbol table.  */
3285
3286   if (symbol_type == st_Block || symbol_type == st_End)
3287     index = 0;
3288
3289   else if (inside_enumeration)
3290     index = cur_file_ptr->void_type;
3291
3292   else
3293     {
3294       if (t.basic_type == bt_Struct
3295           || t.basic_type == bt_Union
3296           || t.basic_type == bt_Enum)
3297         {
3298           if (tag_start == (char *)0)
3299             {
3300               error ("No tag specified for %.*s",
3301                      name_end_p1 - name_start,
3302                      name_start);
3303               return;
3304             }
3305
3306           t.tag_ptr = get_tag (tag_start, tag_end_p1,  (symint_t)indexNil,
3307                                t.basic_type);
3308         }
3309
3310       if (is_function)
3311         {
3312           last_func_type_info = t;
3313           last_func_eptr = eptr;
3314           return;
3315         }
3316
3317       index = add_aux_sym_tir (&t,
3318                                hash_yes,
3319                                &cur_file_ptr->thash_head[0]);
3320     }
3321
3322
3323   /* If this is an external or static symbol, update the appropriate
3324      external symbol.  */
3325
3326   if (eptr != (EXTR *)0
3327       && (eptr->asym.index == indexNil || cur_proc_ptr == (PDR *)0))
3328     {
3329       eptr->ifd = cur_file_ptr->file_index;
3330       eptr->asym.index = index;
3331     }
3332
3333
3334   /* Do any last minute adjustments that are necessary.  */
3335   switch (symbol_type)
3336     {
3337     default:
3338       break;
3339
3340
3341       /* For the beginning of structs, unions, and enumerations, the
3342          size info needs to be passed in the value field.  */
3343
3344     case st_Block:
3345       if (t.num_sizes - t.num_dims - t.extra_sizes != 1)
3346         {
3347           error_line = __LINE__;
3348           saber_stop ();
3349           goto bomb_out;
3350         }
3351
3352       else
3353         value = t.sizes[0];
3354
3355       inside_enumeration = (t.orig_type == T_ENUM);
3356       break;
3357
3358
3359       /* For the end of structs, unions, and enumerations, omit the
3360          name which is always ".eos".  This needs to be done last, so
3361          that any error reporting above gives the correct name.  */
3362
3363     case st_End:
3364       name_start = name_end_p1 = (const char *)0;
3365       value = inside_enumeration = 0;
3366       break;
3367
3368
3369       /* Members of structures and unions that aren't bitfields, need
3370          to adjust the value from a byte offset to a bit offset.
3371          Members of enumerations do not have the value adjusted, and
3372          can be distinguished by index == indexNil.  For enumerations,
3373          update the maximum enumeration value.  */
3374
3375     case st_Member:
3376       if (!t.bitfield && !inside_enumeration)
3377         value *= 8;
3378
3379       break;
3380     }
3381
3382
3383   /* Add the symbol, except for global symbols outside of functions,
3384      for which the external symbol table is fine enough.  */
3385
3386   if (eptr == (EXTR *)0
3387       || eptr->asym.st == (int)st_Nil
3388       || cur_proc_ptr != (PDR *)0)
3389     {
3390       symint_t isym = add_local_symbol (name_start, name_end_p1,
3391                                         symbol_type, storage_class,
3392                                         value,
3393                                         index);
3394
3395       /* deal with struct, union, and enum tags.  */
3396       if (symbol_type == st_Block)
3397         {
3398           /* Create or update the tag information.  */
3399           tag_t *tag_ptr = get_tag (name_start,
3400                                     name_end_p1,
3401                                     isym,
3402                                     t.basic_type);
3403
3404           /* If there are any forward references, fill in the appropriate
3405              file and symbol indexes.  */
3406
3407           symint_t file_index  = cur_file_ptr->file_index;
3408           forward_t *f_next = tag_ptr->forward_ref;
3409           forward_t *f_cur;
3410
3411           while (f_next != (forward_t *)0)
3412             {
3413               f_cur  = f_next;
3414               f_next = f_next->next;
3415
3416               f_cur->ifd_ptr->isym = file_index;
3417               f_cur->index_ptr->rndx.index = isym;
3418
3419               free_forward (f_cur);
3420             }
3421
3422           tag_ptr->forward_ref = (forward_t *)0;
3423         }
3424     }
3425
3426   /* Normal return  */
3427   return;
3428
3429   /* Error return, issue message.  */
3430 bomb_out:
3431   if (error_line)
3432     error ("compiler error, badly formed #.def (internal line # = %d)", error_line);
3433   else
3434     error ("compiler error, badly formed #.def");
3435
3436   return;
3437 }
3438
3439 \f
3440 /* Parse .end directives.  */
3441
3442 STATIC void
3443 parse_end (start)
3444      const char *start;                 /* start of directive */
3445 {
3446   register const char *start_func, *end_func_p1;
3447   register int ch;
3448   register symint_t value;
3449   register FDR *orig_fdr;
3450
3451   if (cur_file_ptr == (efdr_t *)0)
3452     {
3453       error (".end directive without a preceding .file directive");
3454       return;
3455     }
3456
3457   if (cur_proc_ptr == (PDR *)0)
3458     {
3459       error (".end directive without a preceding .ent directive");
3460       return;
3461     }
3462
3463   /* Get the function name, skipping whitespace.  */
3464   for (start_func = start; isspace (*start_func); start_func++)
3465     ;
3466
3467   ch = *start_func;
3468   if (!IS_ASM_IDENT (ch))
3469     {
3470       error (".end directive has no name");
3471       return;
3472     }
3473
3474   for (end_func_p1 = start_func; IS_ASM_IDENT (ch); ch = *++end_func_p1)
3475     ;
3476
3477
3478   /* Get the value field for creating the end from the original object
3479      file (which we find by locating the procedure start, and using the
3480      pointer to the end+1 block and backing up.  The index points to a
3481      two word aux. symbol, whose first word is the index of the end
3482      symbol, and the second word is the type of the function return
3483      value.  */
3484
3485   orig_fdr = cur_file_ptr->orig_fdr;
3486   value = 0;
3487   if (orig_fdr != (FDR *)0 && cur_oproc_end != (SYMR *)0)
3488     value = cur_oproc_end->value;
3489
3490   else
3491     error ("Cannot find .end block for %.*s", end_func_p1 - start_func, start_func);
3492
3493   (void) add_local_symbol (start_func, end_func_p1,
3494                            st_End, sc_Text,
3495                            value,
3496                            (symint_t)0);
3497
3498   cur_proc_ptr = cur_oproc_ptr = (PDR *)0;
3499 }
3500
3501 \f
3502 /* Parse .ent directives.  */
3503
3504 STATIC void
3505 parse_ent (start)
3506      const char *start;                 /* start of directive */
3507 {
3508   register const char *start_func, *end_func_p1;
3509   register int ch;
3510
3511   if (cur_file_ptr == (efdr_t *)0)
3512     {
3513       error (".ent directive without a preceding .file directive");
3514       return;
3515     }
3516
3517   if (cur_proc_ptr != (PDR *)0)
3518     {
3519       error ("second .ent directive found before .end directive");
3520       return;
3521     }
3522
3523   for (start_func = start; isspace (*start_func); start_func++)
3524     ;
3525
3526   ch = *start_func;
3527   if (!IS_ASM_IDENT (ch))
3528     {
3529       error (".ent directive has no name");
3530       return;
3531     }
3532
3533   for (end_func_p1 = start_func; IS_ASM_IDENT (ch); ch = *++end_func_p1)
3534     ;
3535
3536   (void) add_procedure (start_func, end_func_p1);
3537 }
3538
3539 \f
3540 /* Parse .file directives.  */
3541
3542 STATIC void
3543 parse_file (start)
3544      const char *start;                 /* start of directive */
3545 {
3546   char *p;
3547   register char *start_name, *end_name_p1;
3548
3549   (void) strtol (start, &p, 0);
3550   if (start == p
3551       || (start_name = strchr (p, '"')) == (char *)0
3552       || (end_name_p1 = strrchr (++start_name, '"')) == (char *)0)
3553     {
3554       error ("Illegal .file directive");
3555       return;
3556     }
3557
3558   if (cur_proc_ptr != (PDR *)0)
3559     {
3560       error ("No way to handle .file within .ent/.end section");
3561       return;
3562     }
3563
3564   add_file (start_name, end_name_p1);
3565 }
3566
3567 \f
3568 /* Make sure the @stabs symbol is emitted.  */
3569
3570 static void
3571 mark_stabs (start)
3572      const char *start;                 /* Start of directive (ignored) */
3573 {
3574   if (!stabs_seen)
3575     {
3576       /* Add a dummy @stabs dymbol. */
3577       stabs_seen = 1;
3578       (void) add_local_symbol (stabs_symbol,
3579                                stabs_symbol + sizeof (stabs_symbol),
3580                                stNil, scInfo, -1, MIPS_MARK_STAB(0));
3581
3582     }
3583 }
3584
3585 \f
3586 /* Parse .stabs directives.
3587
3588    .stabs directives have five fields:
3589         "string"        a string, encoding the type information.
3590         code            a numeric code, defined in <stab.h>
3591         0               a zero
3592         0               a zero or line number
3593         value           a numeric value or an address.
3594
3595     If the value is relocatable, we transform this into:
3596         iss             points as an index into string space
3597         value           value from lookup of the name
3598         st              st from lookup of the name
3599         sc              sc from lookup of the name
3600         index           code|CODE_MASK
3601
3602     If the value is not relocatable, we transform this into:
3603         iss             points as an index into string space
3604         value           value
3605         st              st_Nil
3606         sc              sc_Nil
3607         index           code|CODE_MASK
3608
3609     .stabn directives have four fields (string is null):
3610         code            a numeric code, defined in <stab.h>
3611         0               a zero
3612         0               a zero or a line number
3613         value           a numeric value or an address.  */
3614
3615 STATIC void
3616 parse_stabs_common (string_start, string_end, rest)
3617      const char *string_start;          /* start of string or NULL */
3618      const char *string_end;            /* end+1 of string or NULL */
3619      const char *rest;                  /* rest of the directive. */
3620 {
3621   efdr_t *save_file_ptr = cur_file_ptr;
3622   symint_t code;
3623   symint_t value;
3624   char *p;
3625   st_t st;
3626   sc_t sc;
3627   int ch;
3628
3629   if (stabs_seen == 0)
3630     mark_stabs ("");
3631
3632   /* Read code from stabs.  */
3633   if (!isdigit (*rest))
3634     {
3635       error ("Illegal .stabs/.stabn directive, code is non-numeric");
3636       return;
3637     }
3638
3639   code = strtol (rest, &p, 0);
3640
3641   /* Line number stabs are handled differently, since they have two values,
3642      the line number and the address of the label.  We use the index field
3643      (aka code) to hold the line number, and the value field to hold the
3644      address.  The symbol type is st_Label, which should be different from
3645      the other stabs, so that gdb can recognize it.  */
3646
3647   if (code == (int)N_SLINE)
3648     {
3649       SYMR *sym_ptr;
3650       shash_t *shash_ptr;
3651
3652       /* Skip ,0, */
3653       if (p[0] != ',' || p[1] != '0' || p[2] != ',' || !isdigit (p[3]))
3654         {
3655           error ("Illegal line number .stabs/.stabn directive");
3656           return;
3657         }
3658
3659       code = strtol (p+3, &p, 0);
3660       ch = *++p;
3661       if (code <= 0 || p[-1] != ',' || isdigit (ch) || !IS_ASM_IDENT (ch))
3662         {
3663           error ("Illegal line number .stabs/.stabn directive");
3664           return;
3665         }
3666
3667       shash_ptr = hash_string (p,
3668                                strlen (p) - 1,
3669                                &orig_str_hash[0],
3670                                (symint_t *)0);
3671
3672       if (shash_ptr == (shash_t *)0
3673           || (sym_ptr = shash_ptr->sym_ptr) == (SYMR *)0)
3674         {
3675           error ("Illegal .stabs/.stabn directive, value not found");
3676           return;
3677         }
3678
3679       if ((st_t) sym_ptr->st != st_Label)
3680         {
3681           error ("Illegal line number .stabs/.stabn directive");
3682           return;
3683         }
3684
3685       st = st_Label;
3686       sc = (sc_t) sym_ptr->sc;
3687       value = sym_ptr->value;
3688     }
3689   else
3690     {
3691       /* Skip ,0,0, */
3692       if (p[0] != ',' || p[1] != '0' || p[2] != ',' || p[3] != '0' || p[4] != ',')
3693         {
3694           error ("Illegal .stabs/.stabn directive, mandatory 0 isn't");
3695           return;
3696         }
3697
3698       p += 5;
3699       ch = *p;
3700       if (!IS_ASM_IDENT (ch) && ch != '-')
3701         {
3702           error ("Illegal .stabs/.stabn directive, bad character");
3703           return;
3704         }
3705
3706       if (isdigit (ch) || ch == '-')
3707         {
3708           st = st_Nil;
3709           sc = sc_Nil;
3710           value = strtol (p, &p, 0);
3711           if (*p != '\n')
3712             {
3713               error ("Illegal .stabs/.stabn directive, stuff after numeric value");
3714               return;
3715             }
3716         }
3717       else if (!IS_ASM_IDENT (ch))
3718         {
3719           error ("Illegal .stabs/.stabn directive, bad character");
3720           return;
3721         }
3722       else
3723         {
3724           SYMR *sym_ptr;
3725           shash_t *shash_ptr = hash_string (p,
3726                                             strlen (p) - 1,
3727                                             &orig_str_hash[0],
3728                                             (symint_t *)0);
3729
3730           if (shash_ptr == (shash_t *)0
3731               || (sym_ptr = shash_ptr->sym_ptr) == (SYMR *)0)
3732             {
3733               error ("Illegal .stabs/.stabn directive, value not found");
3734               return;
3735             }
3736
3737           /* Traditionally, N_LBRAC and N_RBRAC are *not* relocated. */
3738           if (code == (int)N_LBRAC || code == (int)N_RBRAC)
3739             {
3740               sc = scNil;
3741               st = stNil;
3742             }
3743           else
3744             {
3745               sc = (sc_t) sym_ptr->sc;
3746               st = (st_t) sym_ptr->st;
3747             }
3748           value = sym_ptr->value;
3749         }
3750       code = MIPS_MARK_STAB(code);
3751     }
3752
3753   (void) add_local_symbol (string_start, string_end, st, sc, value, code);
3754   /* Restore normal file type.  */
3755   cur_file_ptr = save_file_ptr;
3756 }
3757
3758
3759 STATIC void
3760 parse_stabs (start)
3761      const char *start;                 /* start of directive */
3762 {
3763   const char *end = strchr (start+1, '"');
3764
3765   if (*start != '"' || end == (const char *)0 || end[1] != ',')
3766     {
3767       error ("Illegal .stabs directive, no string");
3768       return;
3769     }
3770
3771   parse_stabs_common (start+1, end, end+2);
3772 }
3773
3774
3775 STATIC void
3776 parse_stabn (start)
3777      const char *start;                 /* start of directive */
3778 {
3779   parse_stabs_common ((const char *)0, (const char *)0, start);
3780 }
3781
3782 \f
3783 /* Parse the input file, and write the lines to the output file
3784    if needed.  */
3785
3786 STATIC void
3787 parse_input __proto((void))
3788 {
3789   register char *p;
3790   register int i;
3791   register thead_t *ptag_head;
3792   register tag_t *ptag;
3793   register tag_t *ptag_next;
3794
3795   if (debug)
3796     fprintf (stderr, "\tinput\n");
3797
3798   /* Add a dummy scope block around the entire compilation unit for
3799      structures defined outside of blocks.  */
3800   ptag_head = allocate_thead ();
3801   ptag_head->first_tag = 0;
3802   ptag_head->prev = cur_tag_head;
3803   cur_tag_head = ptag_head;
3804
3805   while ((p = read_line ()) != (char *)0)
3806     {
3807       /* Skip leading blanks */
3808       while (isspace (*p))
3809         p++;
3810
3811       /* See if it's a directive we handle.  If so, dispatch handler.  */
3812       for (i = 0; i < sizeof (pseudo_ops) / sizeof (pseudo_ops[0]); i++)
3813         if (memcmp (p, pseudo_ops[i].name, pseudo_ops[i].len) == 0
3814             && isspace (p[pseudo_ops[i].len]))
3815           {
3816             p += pseudo_ops[i].len;     /* skip to first argument */
3817             while (isspace (*p))
3818               p++;
3819
3820             (*pseudo_ops[i].func)( p );
3821             break;
3822           }
3823     }
3824
3825   /* Process any tags at global level.  */
3826   ptag_head = cur_tag_head;
3827   cur_tag_head = ptag_head->prev;
3828
3829   for (ptag = ptag_head->first_tag;
3830        ptag != (tag_t *)0;
3831        ptag = ptag_next)
3832     {
3833       if (ptag->forward_ref != (forward_t *)0)
3834         add_unknown_tag (ptag);
3835
3836       ptag_next = ptag->same_block;
3837       ptag->hash_ptr->tag_ptr = ptag->same_name;
3838       free_tag (ptag);
3839     }
3840
3841   free_thead (ptag_head);
3842
3843 }
3844
3845 \f
3846 /* Update the global headers with the final offsets in preparation
3847    to write out the .T file.  */
3848
3849 STATIC void
3850 update_headers __proto((void))
3851 {
3852   register symint_t i;
3853   register efdr_t *file_ptr;
3854
3855   /* Set up the symbolic header.  */
3856   file_offset = sizeof (symbolic_header) + orig_file_header.f_symptr;
3857   symbolic_header.magic = orig_sym_hdr.magic;
3858   symbolic_header.vstamp = orig_sym_hdr.vstamp;
3859
3860   /* Set up global counts.  */
3861   symbolic_header.issExtMax = ext_strings.num_allocated;
3862   symbolic_header.idnMax    = dense_num.num_allocated;
3863   symbolic_header.ifdMax    = file_desc.num_allocated;
3864   symbolic_header.iextMax   = ext_symbols.num_allocated;
3865   symbolic_header.ilineMax  = orig_sym_hdr.ilineMax;
3866   symbolic_header.ioptMax   = orig_sym_hdr.ioptMax;
3867   symbolic_header.cbLine    = orig_sym_hdr.cbLine;
3868   symbolic_header.crfd      = orig_sym_hdr.crfd;
3869
3870
3871   /* Loop through each file, figuring out how many local syms,
3872      line numbers, etc. there are.  Also, put out end symbol
3873      for the filename.  */
3874
3875   for (file_ptr = first_file;
3876        file_ptr != (efdr_t *)0;
3877        file_ptr = file_ptr->next_file)
3878     {
3879       cur_file_ptr = file_ptr;
3880       (void) add_local_symbol ((const char *)0, (const char *)0,
3881                                st_End, sc_Text,
3882                                (symint_t)0,
3883                                (symint_t)0);
3884
3885       file_ptr->fdr.cpd = file_ptr->procs.num_allocated;
3886       file_ptr->fdr.ipdFirst = symbolic_header.ipdMax;
3887       symbolic_header.ipdMax += file_ptr->fdr.cpd;
3888
3889       file_ptr->fdr.csym = file_ptr->symbols.num_allocated;
3890       file_ptr->fdr.isymBase = symbolic_header.isymMax;
3891       symbolic_header.isymMax += file_ptr->fdr.csym;
3892
3893       file_ptr->fdr.caux = file_ptr->aux_syms.num_allocated;
3894       file_ptr->fdr.iauxBase = symbolic_header.iauxMax;
3895       symbolic_header.iauxMax += file_ptr->fdr.caux;
3896
3897       file_ptr->fdr.cbSs = file_ptr->strings.num_allocated;
3898       file_ptr->fdr.issBase = symbolic_header.issMax;
3899       symbolic_header.issMax += file_ptr->fdr.cbSs;
3900     }
3901
3902
3903   i = WORD_ALIGN (symbolic_header.cbLine);      /* line numbers */
3904   if (i > 0)
3905     {
3906       symbolic_header.cbLineOffset = file_offset;
3907       file_offset += i;
3908     }
3909
3910   i = symbolic_header.ioptMax;                  /* optimization symbols */
3911   if (((long) i) > 0)
3912     {
3913       symbolic_header.cbOptOffset = file_offset;
3914       file_offset += i * sizeof (OPTR);
3915     }
3916
3917   i = symbolic_header.idnMax;                   /* dense numbers */
3918   if (i > 0)
3919     {
3920       symbolic_header.cbDnOffset = file_offset;
3921       file_offset += i * sizeof (DNR);
3922     }
3923
3924   i = symbolic_header.ipdMax;                   /* procedure tables */
3925   if (i > 0)
3926     {
3927       symbolic_header.cbPdOffset = file_offset;
3928       file_offset += i * sizeof (PDR);
3929     }
3930
3931   i = symbolic_header.isymMax;                  /* local symbols */
3932   if (i > 0)
3933     {
3934       symbolic_header.cbSymOffset = file_offset;
3935       file_offset += i * sizeof (SYMR);
3936     }
3937
3938   i = symbolic_header.iauxMax;                  /* aux syms. */
3939   if (i > 0)
3940     {
3941       symbolic_header.cbAuxOffset = file_offset;
3942       file_offset += i * sizeof (TIR);
3943     }
3944
3945   i = WORD_ALIGN (symbolic_header.issMax);      /* local strings */
3946   if (i > 0)
3947     {
3948       symbolic_header.cbSsOffset = file_offset;
3949       file_offset += i;
3950     }
3951
3952   i = WORD_ALIGN (symbolic_header.issExtMax);   /* external strings */
3953   if (i > 0)
3954     {
3955       symbolic_header.cbSsExtOffset = file_offset;
3956       file_offset += i;
3957     }
3958
3959   i = symbolic_header.ifdMax;                   /* file tables */
3960   if (i > 0)
3961     {
3962       symbolic_header.cbFdOffset = file_offset;
3963       file_offset += i * sizeof (FDR);
3964     }
3965
3966   i = symbolic_header.crfd;                     /* relative file descriptors */
3967   if (i > 0)
3968     {
3969       symbolic_header.cbRfdOffset = file_offset;
3970       file_offset += i * sizeof (symint_t);
3971     }
3972
3973   i = symbolic_header.iextMax;                  /* external symbols */
3974   if (i > 0)
3975     {
3976       symbolic_header.cbExtOffset = file_offset;
3977       file_offset += i * sizeof (EXTR);
3978     }
3979 }
3980
3981 \f
3982 /* Write out a varray at a given location.  */
3983
3984 STATIC void
3985 write_varray (vp, offset, str)
3986      varray_t *vp;                      /* virtual array */
3987      off_t offset;                      /* offset to write varray to */
3988      const char *str;                   /* string to print out when tracing */
3989 {
3990   int num_write, sys_write;
3991   vlinks_t *ptr;
3992
3993   if (vp->num_allocated == 0)
3994     return;
3995
3996   if (debug)
3997     fprintf (stderr, "\twarray\tvp = 0x%.8x, offset = %7u, size = %7u, %s\n",
3998              vp, offset, vp->num_allocated * vp->object_size, str);
3999
4000   if (file_offset != offset
4001       && fseek (object_stream, (long)offset, SEEK_SET) < 0)
4002     pfatal_with_name (object_name);
4003
4004   for (ptr = vp->first; ptr != (vlinks_t *)0; ptr = ptr->next)
4005     {
4006       num_write = (ptr->next == (vlinks_t *)0)
4007         ? vp->objects_last_page * vp->object_size
4008         : vp->objects_per_page  * vp->object_size;
4009
4010       sys_write = fwrite ((PTR_T) ptr->datum, 1, num_write, object_stream);
4011       if (sys_write <= 0)
4012         pfatal_with_name (object_name);
4013
4014       else if (sys_write != num_write)
4015         fatal ("Wrote %d bytes to %s, system returned %d",
4016                num_write,
4017                object_name,
4018                sys_write);
4019
4020       file_offset += num_write;
4021     }
4022 }
4023
4024 \f
4025 /* Write out the symbol table in the object file.  */
4026
4027 STATIC void
4028 write_object __proto((void))
4029 {
4030   int sys_write;
4031   efdr_t *file_ptr;
4032   off_t offset;
4033
4034   if (debug)
4035     fprintf (stderr, "\n\twrite\tvp = 0x%.8x, offset = %7u, size = %7u, %s\n",
4036              (PTR_T *) &symbolic_header, 0, sizeof (symbolic_header),
4037              "symbolic header");
4038
4039   sys_write = fwrite ((PTR_T) &symbolic_header,
4040                       1,
4041                       sizeof (symbolic_header),
4042                       object_stream);
4043
4044   if (sys_write < 0)
4045     pfatal_with_name (object_name);
4046
4047   else if (sys_write != sizeof (symbolic_header))
4048     fatal ("Wrote %d bytes to %s, system returned %d",
4049            sizeof (symbolic_header),
4050            object_name,
4051            sys_write);
4052
4053
4054   file_offset = sizeof (symbolic_header) + orig_file_header.f_symptr;
4055
4056   if (symbolic_header.cbLine > 0)               /* line numbers */
4057     {
4058       long sys_write;
4059
4060       if (file_offset != symbolic_header.cbLineOffset
4061           && fseek (object_stream, symbolic_header.cbLineOffset, SEEK_SET) != 0)
4062         pfatal_with_name (object_name);
4063
4064       if (debug)
4065         fprintf (stderr, "\twrite\tvp = 0x%.8x, offset = %7u, size = %7u, %s\n",
4066                  (PTR_T *) &orig_linenum, symbolic_header.cbLineOffset,
4067                  symbolic_header.cbLine, "Line numbers");
4068
4069       sys_write = fwrite ((PTR_T) orig_linenum,
4070                           1,
4071                           symbolic_header.cbLine,
4072                           object_stream);
4073
4074       if (sys_write <= 0)
4075         pfatal_with_name (object_name);
4076
4077       else if (sys_write != symbolic_header.cbLine)
4078         fatal ("Wrote %d bytes to %s, system returned %d",
4079                symbolic_header.cbLine,
4080                object_name,
4081                sys_write);
4082
4083       file_offset = symbolic_header.cbLineOffset + symbolic_header.cbLine;
4084     }
4085
4086   if (symbolic_header.ioptMax > 0)              /* optimization symbols */
4087     {
4088       long sys_write;
4089       long num_write = symbolic_header.ioptMax * sizeof (OPTR);
4090
4091       if (file_offset != symbolic_header.cbOptOffset
4092           && fseek (object_stream, symbolic_header.cbOptOffset, SEEK_SET) != 0)
4093         pfatal_with_name (object_name);
4094
4095       if (debug)
4096         fprintf (stderr, "\twrite\tvp = 0x%.8x, offset = %7u, size = %7u, %s\n",
4097                  (PTR_T *) &orig_opt_syms, symbolic_header.cbOptOffset,
4098                  num_write, "Optimizer symbols");
4099
4100       sys_write = fwrite ((PTR_T) orig_opt_syms,
4101                           1,
4102                           num_write,
4103                           object_stream);
4104
4105       if (sys_write <= 0)
4106         pfatal_with_name (object_name);
4107
4108       else if (sys_write != num_write)
4109         fatal ("Wrote %d bytes to %s, system returned %d",
4110                num_write,
4111                object_name,
4112                sys_write);
4113
4114       file_offset = symbolic_header.cbOptOffset + num_write;
4115     }
4116
4117   if (symbolic_header.idnMax > 0)               /* dense numbers */
4118     write_varray (&dense_num, (off_t)symbolic_header.cbDnOffset, "Dense numbers");
4119
4120   if (symbolic_header.ipdMax > 0)               /* procedure tables */
4121     {
4122       offset = symbolic_header.cbPdOffset;
4123       for (file_ptr = first_file;
4124            file_ptr != (efdr_t *)0;
4125            file_ptr = file_ptr->next_file)
4126         {
4127           write_varray (&file_ptr->procs, offset, "Procedure tables");
4128           offset = file_offset;
4129         }
4130     }
4131
4132   if (symbolic_header.isymMax > 0)              /* local symbols */
4133     {
4134       offset = symbolic_header.cbSymOffset;
4135       for (file_ptr = first_file;
4136            file_ptr != (efdr_t *)0;
4137            file_ptr = file_ptr->next_file)
4138         {
4139           write_varray (&file_ptr->symbols, offset, "Local symbols");
4140           offset = file_offset;
4141         }
4142     }
4143
4144   if (symbolic_header.iauxMax > 0)              /* aux symbols */
4145     {
4146       offset = symbolic_header.cbAuxOffset;
4147       for (file_ptr = first_file;
4148            file_ptr != (efdr_t *)0;
4149            file_ptr = file_ptr->next_file)
4150         {
4151           write_varray (&file_ptr->aux_syms, offset, "Aux. symbols");
4152           offset = file_offset;
4153         }
4154     }
4155
4156   if (symbolic_header.issMax > 0)               /* local strings */
4157     {
4158       offset = symbolic_header.cbSsOffset;
4159       for (file_ptr = first_file;
4160            file_ptr != (efdr_t *)0;
4161            file_ptr = file_ptr->next_file)
4162         {
4163           write_varray (&file_ptr->strings, offset, "Local strings");
4164           offset = file_offset;
4165         }
4166     }
4167
4168   if (symbolic_header.issExtMax > 0)            /* external strings */
4169     write_varray (&ext_strings, symbolic_header.cbSsExtOffset, "External strings");
4170
4171   if (symbolic_header.ifdMax > 0)               /* file tables */
4172     {
4173       offset = symbolic_header.cbFdOffset;
4174       if (file_offset != offset
4175           && fseek (object_stream, (long)offset, SEEK_SET) < 0)
4176         pfatal_with_name (object_name);
4177
4178       file_offset = offset;
4179       for (file_ptr = first_file;
4180            file_ptr != (efdr_t *)0;
4181            file_ptr = file_ptr->next_file)
4182         {
4183           if (debug)
4184             fprintf (stderr, "\twrite\tvp = 0x%.8x, offset = %7u, size = %7u, %s\n",
4185                      (PTR_T *) &file_ptr->fdr, file_offset, sizeof (FDR), "File header");
4186
4187           sys_write = fwrite (&file_ptr->fdr,
4188                               1,
4189                               sizeof (FDR),
4190                               object_stream);
4191
4192           if (sys_write < 0)
4193             pfatal_with_name (object_name);
4194
4195           else if (sys_write != sizeof (FDR))
4196             fatal ("Wrote %d bytes to %s, system returned %d",
4197                    sizeof (FDR),
4198                    object_name,
4199                    sys_write);
4200
4201           file_offset = offset += sizeof (FDR);
4202         }
4203     }
4204
4205   if (symbolic_header.crfd > 0)                 /* relative file descriptors */
4206     {
4207       long sys_write;
4208       symint_t num_write = symbolic_header.crfd * sizeof (symint_t);
4209
4210       if (file_offset != symbolic_header.cbRfdOffset
4211           && fseek (object_stream, symbolic_header.cbRfdOffset, SEEK_SET) != 0)
4212         pfatal_with_name (object_name);
4213
4214       if (debug)
4215         fprintf (stderr, "\twrite\tvp = 0x%.8x, offset = %7u, size = %7u, %s\n",
4216                  (PTR_T *) &orig_rfds, symbolic_header.cbRfdOffset,
4217                  num_write, "Relative file descriptors");
4218
4219       sys_write = fwrite (orig_rfds,
4220                           1,
4221                           num_write,
4222                           object_stream);
4223
4224       if (sys_write <= 0)
4225         pfatal_with_name (object_name);
4226
4227       else if (sys_write != num_write)
4228         fatal ("Wrote %d bytes to %s, system returned %d",
4229                num_write,
4230                object_name,
4231                sys_write);
4232
4233       file_offset = symbolic_header.cbRfdOffset + num_write;
4234     }
4235
4236   if (symbolic_header.issExtMax > 0)            /* external symbols */
4237     write_varray (&ext_symbols, (off_t)symbolic_header.cbExtOffset, "External symbols");
4238
4239   if (fclose (object_stream) != 0)
4240     pfatal_with_name (object_name);
4241 }
4242
4243 \f
4244 /* Read some bytes at a specified location, and return a pointer.  */
4245
4246 STATIC page_t *
4247 read_seek (size, offset, str)
4248      Size_t size;               /* # bytes to read */
4249      off_t offset;              /* offset to read at */
4250      const char *str;           /* name for tracing */
4251 {
4252   page_t *ptr;
4253   long sys_read = 0;
4254
4255   if (size == 0)                /* nothing to read */
4256     return (page_t *)0;
4257
4258   if (debug)
4259     fprintf (stderr, "\trseek\tsize = %7u, offset = %7u, currently at %7u, %s\n",
4260              size, offset, file_offset, str);
4261
4262 #ifndef MALLOC_CHECK
4263   ptr = allocate_multiple_pages ((size + PAGE_USIZE - 1) / PAGE_USIZE);
4264 #else
4265   ptr = (page_t *) xcalloc (1, size);
4266 #endif
4267
4268   /* If we need to seek, and the distance is nearby, just do some reads,
4269      to speed things up.  */
4270   if (file_offset != offset)
4271     {
4272       symint_t difference = offset - file_offset;
4273
4274       if (difference < 8)
4275         {
4276           char small_buffer[8];
4277
4278           sys_read = fread (small_buffer, 1, difference, obj_in_stream);
4279           if (sys_read <= 0)
4280             pfatal_with_name (obj_in_name);
4281
4282           if (sys_read != difference)
4283             fatal ("Wanted to read %d bytes from %s, system returned %d",
4284                    size,
4285                    obj_in_name,
4286                    sys_read);
4287         }
4288       else if (fseek (obj_in_stream, offset, SEEK_SET) < 0)
4289         pfatal_with_name (obj_in_name);
4290     }
4291
4292   sys_read = fread ((PTR_T)ptr, 1, size, obj_in_stream);
4293   if (sys_read <= 0)
4294     pfatal_with_name (obj_in_name);
4295
4296   if (sys_read != size)
4297     fatal ("Wanted to read %d bytes from %s, system returned %d",
4298            size,
4299            obj_in_name,
4300            sys_read);
4301
4302   file_offset = offset + size;
4303
4304   if (file_offset > max_file_offset)
4305     max_file_offset = file_offset;
4306
4307   return ptr;
4308 }
4309
4310 \f
4311 /* Read the existing object file (and copy to the output object file
4312    if it is different from the input object file), and remove the old
4313    symbol table.  */
4314
4315 STATIC void
4316 copy_object __proto((void))
4317 {
4318   char buffer[ PAGE_SIZE ];
4319   register int sys_read;
4320   register int remaining;
4321   register int num_write;
4322   register int sys_write;
4323   register int fd, es;
4324   register int delete_ifd = 0;
4325   register int *remap_file_number;
4326   struct stat stat_buf;
4327
4328   if (debug)
4329     fprintf (stderr, "\tcopy\n");
4330
4331   if (fstat (fileno (obj_in_stream), &stat_buf) != 0
4332       || fseek (obj_in_stream, 0L, SEEK_SET) != 0)
4333     pfatal_with_name (obj_in_name);
4334
4335   sys_read = fread ((PTR_T) &orig_file_header,
4336                     1,
4337                     sizeof (struct filehdr),
4338                     obj_in_stream);
4339
4340   if (sys_read < 0)
4341     pfatal_with_name (obj_in_name);
4342
4343   else if (sys_read == 0 && feof (obj_in_stream))
4344     return;                     /* create a .T file sans file header */
4345
4346   else if (sys_read < sizeof (struct filehdr))
4347     fatal ("Wanted to read %d bytes from %s, system returned %d",
4348            sizeof (struct filehdr),
4349            obj_in_name,
4350            sys_read);
4351
4352
4353   if (orig_file_header.f_nsyms != sizeof (HDRR))
4354     fatal ("%s symbolic header wrong size (%d bytes, should be %d)",
4355            input_name, orig_file_header.f_nsyms, sizeof (HDRR));
4356
4357
4358   /* Read in the current symbolic header.  */
4359   if (fseek (obj_in_stream, (long) orig_file_header.f_symptr, SEEK_SET) != 0)
4360     pfatal_with_name (input_name);
4361
4362   sys_read = fread ((PTR_T) &orig_sym_hdr,
4363                     1,
4364                     sizeof (orig_sym_hdr),
4365                     obj_in_stream);
4366
4367   if (sys_read < 0)
4368     pfatal_with_name (object_name);
4369
4370   else if (sys_read < sizeof (struct filehdr))
4371     fatal ("Wanted to read %d bytes from %s, system returned %d",
4372            sizeof (struct filehdr),
4373            obj_in_name,
4374            sys_read);
4375
4376
4377   /* Read in each of the sections if they exist in the object file.
4378      We read things in in the order the mips assembler creates the
4379      sections, so in theory no extra seeks are done.
4380
4381      For simplicity sake, round each read up to a page boundary,
4382      we may want to revisit this later.... */
4383
4384   file_offset =  orig_file_header.f_symptr + sizeof (struct filehdr);
4385
4386   if (orig_sym_hdr.cbLine > 0)                  /* line numbers */
4387     orig_linenum = (char *) read_seek ((Size_t)orig_sym_hdr.cbLine,
4388                                        orig_sym_hdr.cbLineOffset,
4389                                        "Line numbers");
4390
4391   if (orig_sym_hdr.ipdMax > 0)                  /* procedure tables */
4392     orig_procs = (PDR *) read_seek ((Size_t)orig_sym_hdr.ipdMax * sizeof (PDR),
4393                                     orig_sym_hdr.cbPdOffset,
4394                                     "Procedure tables");
4395
4396   if (orig_sym_hdr.isymMax > 0)                 /* local symbols */
4397     orig_local_syms = (SYMR *) read_seek ((Size_t)orig_sym_hdr.isymMax * sizeof (SYMR),
4398                                           orig_sym_hdr.cbSymOffset,
4399                                           "Local symbols");
4400
4401   if (orig_sym_hdr.iauxMax > 0)                 /* aux symbols */
4402     orig_aux_syms = (AUXU *) read_seek ((Size_t)orig_sym_hdr.iauxMax * sizeof (AUXU),
4403                                         orig_sym_hdr.cbAuxOffset,
4404                                         "Aux. symbols");
4405
4406   if (orig_sym_hdr.issMax > 0)                  /* local strings */
4407     orig_local_strs = (char *) read_seek ((Size_t)orig_sym_hdr.issMax,
4408                                           orig_sym_hdr.cbSsOffset,
4409                                           "Local strings");
4410
4411   if (orig_sym_hdr.issExtMax > 0)               /* external strings */
4412     orig_ext_strs = (char *) read_seek ((Size_t)orig_sym_hdr.issExtMax,
4413                                         orig_sym_hdr.cbSsExtOffset,
4414                                         "External strings");
4415
4416   if (orig_sym_hdr.ifdMax > 0)                  /* file tables */
4417     orig_files = (FDR *) read_seek ((Size_t)orig_sym_hdr.ifdMax * sizeof (FDR),
4418                                     orig_sym_hdr.cbFdOffset,
4419                                     "File tables");
4420
4421   if (orig_sym_hdr.crfd > 0)                    /* relative file descriptors */
4422     orig_rfds = (symint_t *) read_seek ((Size_t)orig_sym_hdr.crfd * sizeof (symint_t),
4423                                         orig_sym_hdr.cbRfdOffset,
4424                                         "Relative file descriptors");
4425
4426   if (orig_sym_hdr.issExtMax > 0)               /* external symbols */
4427     orig_ext_syms = (EXTR *) read_seek ((Size_t)orig_sym_hdr.iextMax * sizeof (EXTR),
4428                                         orig_sym_hdr.cbExtOffset,
4429                                         "External symbols");
4430
4431   if (orig_sym_hdr.idnMax > 0)                  /* dense numbers */
4432     {
4433       orig_dense = (DNR *) read_seek ((Size_t)orig_sym_hdr.idnMax * sizeof (DNR),
4434                                       orig_sym_hdr.cbDnOffset,
4435                                       "Dense numbers");
4436
4437       add_bytes (&dense_num, (char *) orig_dense, (Size_t)orig_sym_hdr.idnMax);
4438     }
4439
4440   if (orig_sym_hdr.ioptMax > 0)                 /* opt symbols */
4441     orig_opt_syms = (OPTR *) read_seek ((Size_t)orig_sym_hdr.ioptMax * sizeof (OPTR),
4442                                         orig_sym_hdr.cbOptOffset,
4443                                         "Optimizer symbols");
4444
4445
4446
4447   /* Abort if the symbol table is not last.  */
4448   if (max_file_offset != stat_buf.st_size)
4449     fatal ("Symbol table is not last (symbol table ends at %ld, .o ends at %ld",
4450            max_file_offset,
4451            stat_buf.st_size);
4452
4453
4454   /* If the first original file descriptor is a dummy which the assembler
4455      put out, but there are no symbols in it, skip it now.  */
4456   if (orig_sym_hdr.ifdMax > 1
4457       && orig_files->csym == 2
4458       && orig_files->caux == 0)
4459     {
4460       char *filename = orig_local_strs + (orig_files->issBase + orig_files->rss);
4461       char *suffix = strrchr (filename, '.');
4462
4463       if (suffix != (char *)0 && strcmp (suffix, ".s") == 0)
4464         delete_ifd = 1;
4465     }
4466
4467
4468   /* Create array to map original file numbers to the new file numbers
4469      (in case there are duplicate filenames, we collapse them into one
4470      file section, the MIPS assembler may or may not collapse them).  */
4471
4472   remap_file_number = (int *) alloca (sizeof (int) * orig_sym_hdr.ifdMax);
4473
4474   for (fd = delete_ifd; fd < orig_sym_hdr.ifdMax; fd++)
4475     {
4476       register FDR *fd_ptr = ORIG_FILES (fd);
4477       register char *filename = ORIG_LSTRS (fd_ptr->issBase + fd_ptr->rss);
4478
4479       /* file support itself.  */
4480       add_file (filename, filename + strlen (filename));
4481       remap_file_number[fd] = cur_file_ptr->file_index;
4482     }
4483
4484   if (delete_ifd > 0)           /* just in case */
4485     remap_file_number[0] = remap_file_number[1];
4486
4487
4488   /* Loop, adding each of the external symbols.  These must be in
4489      order or otherwise we would have to change the relocation
4490      entries.  We don't just call add_bytes, because we need to have
4491      the names put into the external hash table.  We set the type to
4492      'void' for now, and parse_def will fill in the correct type if it
4493      is in the symbol table.  We must add the external symbols before
4494      the locals, since the locals do lookups against the externals.  */
4495
4496   if (debug)
4497     fprintf (stderr, "\tehash\n");
4498
4499   for (es = 0; es < orig_sym_hdr.iextMax; es++)
4500     {
4501       register EXTR *eptr = orig_ext_syms + es;
4502       register char *ename = ORIG_ESTRS (eptr->asym.iss);
4503       register unsigned ifd = eptr->ifd;
4504
4505       (void) add_ext_symbol (ename,
4506                              ename + strlen (ename),
4507                              (st_t) eptr->asym.st,
4508                              (sc_t) eptr->asym.sc,
4509                              eptr->asym.value,
4510                              (symint_t)((eptr->asym.index == indexNil) ? indexNil : 0),
4511                              (ifd < orig_sym_hdr.ifdMax) ? remap_file_number[ ifd ] : ifd);
4512     }
4513
4514
4515   /* For each of the files in the object file, copy the symbols, and such
4516      into the varrays for the new object file.  */
4517
4518   for (fd = delete_ifd; fd < orig_sym_hdr.ifdMax; fd++)
4519     {
4520       register FDR *fd_ptr = ORIG_FILES (fd);
4521       register char *filename = ORIG_LSTRS (fd_ptr->issBase + fd_ptr->rss);
4522       register SYMR *sym_start;
4523       register SYMR *sym;
4524       register SYMR *sym_end_p1;
4525       register PDR *proc_start;
4526       register PDR *proc;
4527       register PDR *proc_end_p1;
4528
4529       /* file support itself.  */
4530       add_file (filename, filename + strlen (filename));
4531       cur_file_ptr->orig_fdr = fd_ptr;
4532
4533       /* Copy stuff that's just passed through (such as line #'s) */
4534       cur_file_ptr->fdr.adr          = fd_ptr->adr;
4535       cur_file_ptr->fdr.ilineBase    = fd_ptr->ilineBase;
4536       cur_file_ptr->fdr.cline        = fd_ptr->cline;
4537       cur_file_ptr->fdr.rfdBase      = fd_ptr->rfdBase;
4538       cur_file_ptr->fdr.crfd         = fd_ptr->crfd;
4539       cur_file_ptr->fdr.cbLineOffset = fd_ptr->cbLineOffset;
4540       cur_file_ptr->fdr.cbLine       = fd_ptr->cbLine;
4541       cur_file_ptr->fdr.fMerge       = fd_ptr->fMerge;
4542       cur_file_ptr->fdr.fReadin      = fd_ptr->fReadin;
4543       cur_file_ptr->fdr.glevel       = fd_ptr->glevel;
4544
4545       if (debug)
4546         fprintf (stderr, "\thash\tstart, filename %s\n", filename);
4547
4548       /* For each of the static and global symbols defined, add them
4549          to the hash table of original symbols, so we can look up
4550          their values.  */
4551
4552       sym_start = ORIG_LSYMS (fd_ptr->isymBase);
4553       sym_end_p1 = sym_start + fd_ptr->csym;
4554       for (sym = sym_start; sym < sym_end_p1; sym++)
4555         {
4556           switch ((st_t) sym->st)
4557             {
4558             default:
4559               break;
4560
4561             case st_Global:
4562             case st_Static:
4563             case st_Label:
4564             case st_Proc:
4565             case st_StaticProc:
4566               {
4567                 auto symint_t hash_index;
4568                 register char *str = ORIG_LSTRS (fd_ptr->issBase + sym->iss);
4569                 register Size_t len = strlen (str);
4570                 register shash_t *shash_ptr = hash_string (str,
4571                                                            (Ptrdiff_t)len,
4572                                                            &orig_str_hash[0],
4573                                                            &hash_index);
4574
4575                 if (shash_ptr != (shash_t *)0)
4576                   error ("internal error, %s is already in original symbol table", str);
4577
4578                 else
4579                   {
4580                     shash_ptr = allocate_shash ();
4581                     shash_ptr->next = orig_str_hash[hash_index];
4582                     orig_str_hash[hash_index] = shash_ptr;
4583
4584                     shash_ptr->len = len;
4585                     shash_ptr->index = indexNil;
4586                     shash_ptr->string = str;
4587                     shash_ptr->sym_ptr = sym;
4588                   }
4589               }
4590               break;
4591
4592             case st_End:
4593               if ((sc_t) sym->sc == sc_Text)
4594                 {
4595                   register char *str = ORIG_LSTRS (fd_ptr->issBase + sym->iss);
4596
4597                   if (*str != '\0')
4598                     {
4599                       register Size_t len = strlen (str);
4600                       register shash_t *shash_ptr = hash_string (str,
4601                                                                  (Ptrdiff_t)len,
4602                                                                  &orig_str_hash[0],
4603                                                                  (symint_t *)0);
4604
4605                       if (shash_ptr != (shash_t *)0)
4606                         shash_ptr->end_ptr = sym;
4607                     }
4608                 }
4609               break;
4610
4611             }
4612         }
4613
4614       if (debug)
4615         {
4616           fprintf (stderr, "\thash\tdone,  filename %s\n", filename);
4617           fprintf (stderr, "\tproc\tstart, filename %s\n", filename);
4618         }
4619
4620       /* Go through each of the procedures in this file, and add the
4621          procedure pointer to the hash entry for the given name.  */
4622
4623       proc_start = ORIG_PROCS (fd_ptr->ipdFirst);
4624       proc_end_p1 = proc_start + fd_ptr->cpd;
4625       for (proc = proc_start; proc < proc_end_p1; proc++)
4626         {
4627           register SYMR *proc_sym = ORIG_LSYMS (fd_ptr->isymBase + proc->isym);
4628           register char *str = ORIG_LSTRS (fd_ptr->issBase + proc_sym->iss);
4629           register Size_t len = strlen (str);
4630           register shash_t *shash_ptr = hash_string (str,
4631                                                      (Ptrdiff_t)len,
4632                                                      &orig_str_hash[0],
4633                                                      (symint_t *)0);
4634
4635           if (shash_ptr == (shash_t *)0)
4636             error ("internal error, function %s is not in original symbol table", str);
4637
4638           else
4639             shash_ptr->proc_ptr = proc;
4640         }
4641
4642       if (debug)
4643         fprintf (stderr, "\tproc\tdone,  filename %s\n", filename);
4644
4645     }
4646   cur_file_ptr = first_file;
4647
4648
4649   /* Copy all of the object file up to the symbol table.  Originally
4650      we were going to use ftruncate, but that doesn't seem to work
4651      on Ultrix 3.1.... */
4652
4653   if (fseek (obj_in_stream, (long)0, SEEK_SET) != 0)
4654     pfatal_with_name (obj_in_name);
4655
4656   if (fseek (object_stream, (long)0, SEEK_SET) != 0)
4657     pfatal_with_name (object_name);
4658
4659   for (remaining = orig_file_header.f_symptr;
4660        remaining > 0;
4661        remaining -= num_write)
4662     {
4663       num_write = (remaining <= sizeof (buffer)) ? remaining : sizeof (buffer);
4664       sys_read = fread ((PTR_T) buffer, 1, num_write, obj_in_stream);
4665       if (sys_read <= 0)
4666         pfatal_with_name (obj_in_name);
4667
4668       else if (sys_read != num_write)
4669         fatal ("Wanted to read %d bytes from %s, system returned %d",
4670                num_write,
4671                obj_in_name,
4672                sys_read);
4673
4674       sys_write = fwrite (buffer, 1, num_write, object_stream);
4675       if (sys_write <= 0)
4676         pfatal_with_name (object_name);
4677
4678       else if (sys_write != num_write)
4679         fatal ("Wrote %d bytes to %s, system returned %d",
4680                num_write,
4681                object_name,
4682                sys_write);
4683     }
4684 }
4685
4686 \f
4687 /* Ye olde main program.  */
4688
4689 int
4690 main (argc, argv)
4691      int argc;
4692      char *argv[];
4693 {
4694   int iflag = 0;
4695   char *p = strrchr (argv[0], '/');
4696   char *num_end;
4697   int option;
4698   int i;
4699
4700   progname = (p != 0) ? p+1 : argv[0];
4701
4702   (void) signal (SIGSEGV, catch_signal);
4703   (void) signal (SIGBUS,  catch_signal);
4704   (void) signal (SIGABRT, catch_signal);
4705
4706 #if !defined(__SABER__) && !defined(lint)
4707   if (sizeof (efdr_t) > PAGE_USIZE)
4708     fatal ("Efdr_t has a sizeof %d bytes, when it should be less than %d",
4709            sizeof (efdr_t),
4710            PAGE_USIZE);
4711
4712   if (sizeof (page_t) != PAGE_USIZE)
4713     fatal ("Page_t has a sizeof %d bytes, when it should be %d",
4714            sizeof (page_t),
4715            PAGE_USIZE);
4716
4717 #endif
4718
4719   alloc_counts[ alloc_type_none    ].alloc_name = "none";
4720   alloc_counts[ alloc_type_scope   ].alloc_name = "scope";
4721   alloc_counts[ alloc_type_vlinks  ].alloc_name = "vlinks";
4722   alloc_counts[ alloc_type_shash   ].alloc_name = "shash";
4723   alloc_counts[ alloc_type_thash   ].alloc_name = "thash";
4724   alloc_counts[ alloc_type_tag     ].alloc_name = "tag";
4725   alloc_counts[ alloc_type_forward ].alloc_name = "forward";
4726   alloc_counts[ alloc_type_thead   ].alloc_name = "thead";
4727   alloc_counts[ alloc_type_varray  ].alloc_name = "varray";
4728
4729   int_type_info  = type_info_init;
4730   int_type_info.basic_type = bt_Int;
4731
4732   void_type_info = type_info_init;
4733   void_type_info.basic_type = bt_Void;
4734
4735   while ((option = getopt (argc, argv, "d:i:I:o:v")) != EOF)
4736     switch (option)
4737       {
4738       default:
4739         had_errors++;
4740         break;
4741
4742       case 'd':
4743         debug = strtol (optarg, &num_end, 0);
4744         if ((unsigned)debug > 4 || num_end == optarg)
4745           had_errors++;
4746
4747         break;
4748
4749       case 'I':
4750         if (rename_output || obj_in_name != (char *)0)
4751           had_errors++;
4752         else
4753           rename_output = 1;
4754
4755         /* fall through to 'i' case.  */
4756
4757       case 'i':
4758         if (obj_in_name == (char *)0)
4759           {
4760             obj_in_name = optarg;
4761             iflag++;
4762           }
4763         else
4764           had_errors++;
4765         break;
4766
4767       case 'o':
4768         if (object_name == (char *)0)
4769           object_name = optarg;
4770         else
4771           had_errors++;
4772         break;
4773
4774       case 'v':
4775         version++;
4776         break;
4777       }
4778
4779   if (obj_in_name == (char *)0 && optind <= argc - 2)
4780     obj_in_name = argv[--argc];
4781
4782   if (object_name == (char *)0 && optind <= argc - 2)
4783     object_name = argv[--argc];
4784
4785   /* If there is an output name, but no input name use
4786      the same file for both, deleting the name between
4787      opening it for input and opening it for output.  */
4788   if (obj_in_name == (char *)0 && object_name != (char *)0)
4789     {
4790       obj_in_name = object_name;
4791       delete_input = 1;
4792     }
4793
4794   if (object_name == (char *)0 || had_errors || optind != argc - 1)
4795     {
4796       fprintf (stderr, "Calling Sequence:\n");
4797       fprintf (stderr, "\tmips-tfile [-d <num>] [-v] [-i <o-in-file>] -o <o-out-file> <s-file> (or)\n");
4798       fprintf (stderr, "\tmips-tfile [-d <num>] [-v] [-I <o-in-file>] -o <o-out-file> <s-file> (or)\n");
4799       fprintf (stderr, "\tmips-tfile [-d <num>] [-v] <s-file> <o-in-file> <o-out-file>\n");
4800       fprintf (stderr, "\n");
4801       fprintf (stderr, "Debug levels are:\n");
4802       fprintf (stderr, "    1\tGeneral debug + trace functions/blocks.\n");
4803       fprintf (stderr, "    2\tDebug level 1 + trace externals.\n");
4804       fprintf (stderr, "    3\tDebug level 2 + trace all symbols.\n");
4805       fprintf (stderr, "    4\tDebug level 3 + trace memory allocations.\n");
4806       return 1;
4807     }
4808
4809
4810   if (version)
4811     {
4812       fprintf (stderr, "mips-tfile version %s", version_string);
4813 #ifdef TARGET_VERSION
4814       TARGET_VERSION;
4815 #endif
4816       fputc ('\n', stderr);
4817     }
4818
4819   if (obj_in_name == (char *)0)
4820     obj_in_name = object_name;
4821
4822   if (rename_output && rename (object_name, obj_in_name) != 0)
4823     {
4824       char *buffer = (char *) allocate_multiple_pages (4);
4825       int len;
4826       int len2;
4827       int in_fd;
4828       int out_fd;
4829
4830       /* Rename failed, copy input file */
4831       in_fd = open (object_name, O_RDONLY, 0666);
4832       if (in_fd < 0)
4833         pfatal_with_name (object_name);
4834
4835       out_fd = open (obj_in_name, O_WRONLY | O_CREAT | O_TRUNC, 0666);
4836       if (out_fd < 0)
4837         pfatal_with_name (obj_in_name);
4838
4839       while ((len = read (in_fd, buffer, 4*PAGE_SIZE)) > 0)
4840         {
4841           len2 = write (out_fd, buffer, len);
4842           if (len2 < 0)
4843             pfatal_with_name (object_name);
4844
4845           if (len != len2)
4846             fatal ("wrote %d bytes to %s, expected to write %d", len2, obj_in_name, len);
4847         }
4848
4849       free_multiple_pages ((page_t *)buffer, 4);
4850
4851       if (len < 0)
4852         pfatal_with_name (object_name);
4853
4854       if (close (in_fd) < 0)
4855         pfatal_with_name (object_name);
4856
4857       if (close (out_fd) < 0)
4858         pfatal_with_name (obj_in_name);
4859     }
4860
4861   /* Must open input before output, since the output may be the same file, and
4862      we need to get the input handle before truncating it.  */
4863   obj_in_stream = fopen (obj_in_name, "r");
4864   if (obj_in_stream == (FILE *)0)
4865     pfatal_with_name (obj_in_name);
4866
4867   if (delete_input && unlink (obj_in_name) != 0)
4868     pfatal_with_name (obj_in_name);
4869
4870   object_stream = fopen (object_name, "w");
4871   if (object_stream == (FILE *)0)
4872     pfatal_with_name (object_name);
4873
4874   if (strcmp (argv[optind], "-") != 0)
4875     {
4876       input_name = argv[optind];
4877       if (freopen (argv[optind], "r", stdin) != stdin)
4878         pfatal_with_name (argv[optind]);
4879     }
4880
4881   copy_object ();                       /* scan & copy object file */
4882   parse_input ();                       /* scan all of input */
4883
4884   update_headers ();                    /* write out tfile */
4885   write_object ();
4886
4887   if (debug)
4888     {
4889       fprintf (stderr, "\n\tAllocation summary:\n\n");
4890       for (i = (int)alloc_type_none; i < (int)alloc_type_last; i++)
4891         if (alloc_counts[i].total_alloc)
4892           {
4893             fprintf (stderr,
4894                      "\t%s\t%5d allocation(s), %5d free(s), %2d page(s)\n",
4895                      alloc_counts[i].alloc_name,
4896                      alloc_counts[i].total_alloc,
4897                      alloc_counts[i].total_free,
4898                      alloc_counts[i].total_pages);
4899           }
4900     }
4901
4902   return (had_errors) ? 1 : 0;
4903 }
4904
4905 \f
4906 /* Catch a signal and exit without dumping core.  */
4907
4908 STATIC void
4909 catch_signal (signum)
4910      int signum;
4911 {
4912   (void) signal (signum, SIG_DFL);      /* just in case... */
4913   fatal (sys_siglist[signum]);
4914 }
4915
4916 /* Print a fatal error message.  NAME is the text.
4917    Also include a system error message based on `errno'.  */
4918
4919 void
4920 pfatal_with_name (msg)
4921      char *msg;
4922 {
4923   int save_errno = errno;               /* just in case.... */
4924   if (line_number > 0)
4925     fprintf (stderr, "%s, %s:%ld ", progname, input_name, line_number);
4926   else
4927     fprintf (stderr, "%s:", progname);
4928
4929   errno = save_errno;
4930   if (errno == 0)
4931     fprintf (stderr, "[errno = 0] %s\n", msg);
4932   else
4933     perror (msg);
4934
4935   exit (1);
4936 }
4937
4938 \f
4939 /* Procedure to abort with an out of bounds error message.  It has
4940    type int, so it can be used with an ?: expression within the
4941    ORIG_xxx macros, but the function never returns.  */
4942
4943 static int
4944 out_of_bounds (index, max, str, prog_line)
4945      symint_t index;            /* index that is out of bounds */
4946      symint_t max;              /* maximum index */
4947      const char *str;           /* string to print out */
4948      int prog_line;             /* line number within mips-tfile.c */
4949 {
4950   if (index < max)              /* just in case */
4951     return 0;
4952
4953   fprintf (stderr, "%s, %s:%ld index %u is out of bounds for %s, max is %u, mips-tfile.c line# %d\n",
4954            progname, input_name, line_number, index, str, max, prog_line);
4955
4956   exit (1);
4957   return 0;                     /* turn off warning messages */
4958 }
4959
4960 \f
4961 /* Allocate a cluster of pages.  USE_MALLOC says that malloc does not
4962    like sbrk's behind it's back (or sbrk isn't available).  If we use
4963    sbrk, we assume it gives us zeroed pages.  */
4964
4965 #ifndef MALLOC_CHECK
4966 #ifdef USE_MALLOC
4967
4968 STATIC page_t *
4969 allocate_cluster (npages)
4970      Size_t npages;
4971 {
4972   register page_t *value = (page_t *) calloc (npages, PAGE_USIZE);
4973
4974   if (value == 0)
4975     fatal ("Virtual memory exhausted.");
4976
4977   if (debug > 3)
4978     fprintf (stderr, "\talloc\tnpages = %d, value = 0x%.8x\n", npages, value);
4979
4980   return value;
4981 }
4982
4983 #else /* USE_MALLOC */
4984
4985 STATIC page_t *
4986 allocate_cluster (npages)
4987      Size_t npages;
4988 {
4989   register page_t *ptr = (page_t *) sbrk (0);   /* current sbreak */
4990   unsigned long offset = ((unsigned long) ptr) & (PAGE_SIZE - 1);
4991
4992   if (offset != 0)                      /* align to a page boundary */
4993     {
4994       if (sbrk (PAGE_USIZE - offset) == (char *)-1)
4995         pfatal_with_name ("allocate_cluster");
4996
4997       ptr = (page_t *) (((char *)ptr) + PAGE_SIZE - offset);
4998     }
4999
5000   if (sbrk (npages * PAGE_USIZE) == (char *)-1)
5001     pfatal_with_name ("allocate_cluster");
5002
5003   if (debug > 3)
5004     fprintf (stderr, "\talloc\tnpages = %d, value = 0x%.8x\n", npages, ptr);
5005
5006   return ptr;
5007 }
5008
5009 #endif /* USE_MALLOC */
5010
5011
5012 static page_t   *cluster_ptr    = NULL;
5013 static unsigned  pages_left     = 0;
5014
5015 #endif /* MALLOC_CHECK */
5016
5017
5018 /* Allocate some pages (which is initialized to 0).  */
5019
5020 STATIC page_t *
5021 allocate_multiple_pages (npages)
5022      Size_t npages;
5023 {
5024 #ifndef MALLOC_CHECK
5025   if (pages_left == 0 && npages < MAX_CLUSTER_PAGES)
5026     {
5027       pages_left = MAX_CLUSTER_PAGES;
5028       cluster_ptr = allocate_cluster (MAX_CLUSTER_PAGES);
5029     }
5030
5031   if (npages <= pages_left)
5032     {
5033       page_t *ptr = cluster_ptr;
5034       cluster_ptr += npages;
5035       pages_left -= npages;
5036       return ptr;
5037     }
5038
5039   return allocate_cluster (npages);
5040
5041 #else   /* MALLOC_CHECK */
5042   return (page_t *) xcalloc (npages, PAGE_SIZE);
5043
5044 #endif  /* MALLOC_CHECK */
5045 }
5046
5047
5048 /* Release some pages.  */
5049
5050 STATIC void
5051 free_multiple_pages (page_ptr, npages)
5052      page_t *page_ptr;
5053      Size_t npages;
5054 {
5055 #ifndef MALLOC_CHECK
5056   if (pages_left == 0)
5057     {
5058       cluster_ptr = page_ptr;
5059       pages_left = npages;
5060     }
5061
5062   else if ((page_ptr + npages) == cluster_ptr)
5063     {
5064       cluster_ptr -= npages;
5065       pages_left += npages;
5066     }
5067
5068   /* otherwise the page is not freed.  If more than call is
5069      done, we probably should worry about it, but at present,
5070      the free pages is done right after an allocate.  */
5071
5072 #else   /* MALLOC_CHECK */
5073   free ((char *) page_ptr);
5074
5075 #endif  /* MALLOC_CHECK */
5076 }
5077
5078
5079 /* Allocate one page (which is initialized to 0).  */
5080
5081 STATIC page_t *
5082 allocate_page __proto((void))
5083 {
5084 #ifndef MALLOC_CHECK
5085   if (pages_left == 0)
5086     {
5087       pages_left = MAX_CLUSTER_PAGES;
5088       cluster_ptr = allocate_cluster (MAX_CLUSTER_PAGES);
5089     }
5090
5091   pages_left--;
5092   return cluster_ptr++;
5093
5094 #else   /* MALLOC_CHECK */
5095   return (page_t *) xcalloc (1, PAGE_SIZE);
5096
5097 #endif  /* MALLOC_CHECK */
5098 }
5099
5100 \f
5101 /* Allocate scoping information.  */
5102
5103 STATIC scope_t *
5104 allocate_scope __proto((void))
5105 {
5106   register scope_t *ptr;
5107   static scope_t initial_scope;
5108
5109 #ifndef MALLOC_CHECK
5110   ptr = alloc_counts[ (int)alloc_type_scope ].free_list.f_scope;
5111   if (ptr != (scope_t *)0)
5112     alloc_counts[ (int)alloc_type_scope ].free_list.f_scope = ptr->free;
5113
5114   else
5115     {
5116       register int unallocated  = alloc_counts[ (int)alloc_type_scope ].unallocated;
5117       register page_t *cur_page = alloc_counts[ (int)alloc_type_scope ].cur_page;
5118
5119       if (unallocated == 0)
5120         {
5121           unallocated = PAGE_SIZE / sizeof (scope_t);
5122           alloc_counts[ (int)alloc_type_scope ].cur_page = cur_page = allocate_page ();
5123           alloc_counts[ (int)alloc_type_scope ].total_pages++;
5124         }
5125
5126       ptr = &cur_page->scope[ --unallocated ];
5127       alloc_counts[ (int)alloc_type_scope ].unallocated = unallocated;
5128     }
5129
5130 #else
5131   ptr = (scope_t *) xmalloc (sizeof (scope_t));
5132
5133 #endif
5134
5135   alloc_counts[ (int)alloc_type_scope ].total_alloc++;
5136   *ptr = initial_scope;
5137   return ptr;
5138 }
5139
5140 /* Free scoping information.  */
5141
5142 STATIC void
5143 free_scope (ptr)
5144      scope_t *ptr;
5145 {
5146   alloc_counts[ (int)alloc_type_scope ].total_free++;
5147
5148 #ifndef MALLOC_CHECK
5149   ptr->free = alloc_counts[ (int)alloc_type_scope ].free_list.f_scope;
5150   alloc_counts[ (int)alloc_type_scope ].free_list.f_scope = ptr;
5151
5152 #else
5153   xfree ((PTR_T) ptr);
5154 #endif
5155
5156 }
5157
5158 \f
5159 /* Allocate links for pages in a virtual array.  */
5160
5161 STATIC vlinks_t *
5162 allocate_vlinks __proto((void))
5163 {
5164   register vlinks_t *ptr;
5165   static vlinks_t initial_vlinks;
5166
5167 #ifndef MALLOC_CHECK
5168   register int unallocated      = alloc_counts[ (int)alloc_type_vlinks ].unallocated;
5169   register page_t *cur_page     = alloc_counts[ (int)alloc_type_vlinks ].cur_page;
5170
5171   if (unallocated == 0)
5172     {
5173       unallocated = PAGE_SIZE / sizeof (vlinks_t);
5174       alloc_counts[ (int)alloc_type_vlinks ].cur_page = cur_page = allocate_page ();
5175       alloc_counts[ (int)alloc_type_vlinks ].total_pages++;
5176     }
5177
5178   ptr = &cur_page->vlinks[ --unallocated ];
5179   alloc_counts[ (int)alloc_type_vlinks ].unallocated = unallocated;
5180
5181 #else
5182   ptr = (vlinks_t *) xmalloc (sizeof (vlinks_t));
5183
5184 #endif
5185
5186   alloc_counts[ (int)alloc_type_vlinks ].total_alloc++;
5187   *ptr = initial_vlinks;
5188   return ptr;
5189 }
5190
5191 \f
5192 /* Allocate string hash buckets.  */
5193
5194 STATIC shash_t *
5195 allocate_shash __proto((void))
5196 {
5197   register shash_t *ptr;
5198   static shash_t initial_shash;
5199
5200 #ifndef MALLOC_CHECK
5201   register int unallocated      = alloc_counts[ (int)alloc_type_shash ].unallocated;
5202   register page_t *cur_page     = alloc_counts[ (int)alloc_type_shash ].cur_page;
5203
5204   if (unallocated == 0)
5205     {
5206       unallocated = PAGE_SIZE / sizeof (shash_t);
5207       alloc_counts[ (int)alloc_type_shash ].cur_page = cur_page = allocate_page ();
5208       alloc_counts[ (int)alloc_type_shash ].total_pages++;
5209     }
5210
5211   ptr = &cur_page->shash[ --unallocated ];
5212   alloc_counts[ (int)alloc_type_shash ].unallocated = unallocated;
5213
5214 #else
5215   ptr = (shash_t *) xmalloc (sizeof (shash_t));
5216
5217 #endif
5218
5219   alloc_counts[ (int)alloc_type_shash ].total_alloc++;
5220   *ptr = initial_shash;
5221   return ptr;
5222 }
5223
5224 \f
5225 /* Allocate type hash buckets.  */
5226
5227 STATIC thash_t *
5228 allocate_thash __proto((void))
5229 {
5230   register thash_t *ptr;
5231   static thash_t initial_thash;
5232
5233 #ifndef MALLOC_CHECK
5234   register int unallocated      = alloc_counts[ (int)alloc_type_thash ].unallocated;
5235   register page_t *cur_page     = alloc_counts[ (int)alloc_type_thash ].cur_page;
5236
5237   if (unallocated == 0)
5238     {
5239       unallocated = PAGE_SIZE / sizeof (thash_t);
5240       alloc_counts[ (int)alloc_type_thash ].cur_page = cur_page = allocate_page ();
5241       alloc_counts[ (int)alloc_type_thash ].total_pages++;
5242     }
5243
5244   ptr = &cur_page->thash[ --unallocated ];
5245   alloc_counts[ (int)alloc_type_thash ].unallocated = unallocated;
5246
5247 #else
5248   ptr = (thash_t *) xmalloc (sizeof (thash_t));
5249
5250 #endif
5251
5252   alloc_counts[ (int)alloc_type_thash ].total_alloc++;
5253   *ptr = initial_thash;
5254   return ptr;
5255 }
5256
5257 \f
5258 /* Allocate structure, union, or enum tag information.  */
5259
5260 STATIC tag_t *
5261 allocate_tag __proto((void))
5262 {
5263   register tag_t *ptr;
5264   static tag_t initial_tag;
5265
5266 #ifndef MALLOC_CHECK
5267   ptr = alloc_counts[ (int)alloc_type_tag ].free_list.f_tag;
5268   if (ptr != (tag_t *)0)
5269     alloc_counts[ (int)alloc_type_tag ].free_list.f_tag = ptr->free;
5270
5271   else
5272     {
5273       register int unallocated  = alloc_counts[ (int)alloc_type_tag ].unallocated;
5274       register page_t *cur_page = alloc_counts[ (int)alloc_type_tag ].cur_page;
5275
5276       if (unallocated == 0)
5277         {
5278           unallocated = PAGE_SIZE / sizeof (tag_t);
5279           alloc_counts[ (int)alloc_type_tag ].cur_page = cur_page = allocate_page ();
5280           alloc_counts[ (int)alloc_type_tag ].total_pages++;
5281         }
5282
5283       ptr = &cur_page->tag[ --unallocated ];
5284       alloc_counts[ (int)alloc_type_tag ].unallocated = unallocated;
5285     }
5286
5287 #else
5288   ptr = (tag_t *) xmalloc (sizeof (tag_t));
5289
5290 #endif
5291
5292   alloc_counts[ (int)alloc_type_tag ].total_alloc++;
5293   *ptr = initial_tag;
5294   return ptr;
5295 }
5296
5297 /* Free scoping information.  */
5298
5299 STATIC void
5300 free_tag (ptr)
5301      tag_t *ptr;
5302 {
5303   alloc_counts[ (int)alloc_type_tag ].total_free++;
5304
5305 #ifndef MALLOC_CHECK
5306   ptr->free = alloc_counts[ (int)alloc_type_tag ].free_list.f_tag;
5307   alloc_counts[ (int)alloc_type_tag ].free_list.f_tag = ptr;
5308
5309 #else
5310   xfree ((PTR_T) ptr);
5311 #endif
5312
5313 }
5314
5315 \f
5316 /* Allocate forward reference to a yet unknown tag.  */
5317
5318 STATIC forward_t *
5319 allocate_forward __proto((void))
5320 {
5321   register forward_t *ptr;
5322   static forward_t initial_forward;
5323
5324 #ifndef MALLOC_CHECK
5325   ptr = alloc_counts[ (int)alloc_type_forward ].free_list.f_forward;
5326   if (ptr != (forward_t *)0)
5327     alloc_counts[ (int)alloc_type_forward ].free_list.f_forward = ptr->free;
5328
5329   else
5330     {
5331       register int unallocated  = alloc_counts[ (int)alloc_type_forward ].unallocated;
5332       register page_t *cur_page = alloc_counts[ (int)alloc_type_forward ].cur_page;
5333
5334       if (unallocated == 0)
5335         {
5336           unallocated = PAGE_SIZE / sizeof (forward_t);
5337           alloc_counts[ (int)alloc_type_forward ].cur_page = cur_page = allocate_page ();
5338           alloc_counts[ (int)alloc_type_forward ].total_pages++;
5339         }
5340
5341       ptr = &cur_page->forward[ --unallocated ];
5342       alloc_counts[ (int)alloc_type_forward ].unallocated = unallocated;
5343     }
5344
5345 #else
5346   ptr = (forward_t *) xmalloc (sizeof (forward_t));
5347
5348 #endif
5349
5350   alloc_counts[ (int)alloc_type_forward ].total_alloc++;
5351   *ptr = initial_forward;
5352   return ptr;
5353 }
5354
5355 /* Free scoping information.  */
5356
5357 STATIC void
5358 free_forward (ptr)
5359      forward_t *ptr;
5360 {
5361   alloc_counts[ (int)alloc_type_forward ].total_free++;
5362
5363 #ifndef MALLOC_CHECK
5364   ptr->free = alloc_counts[ (int)alloc_type_forward ].free_list.f_forward;
5365   alloc_counts[ (int)alloc_type_forward ].free_list.f_forward = ptr;
5366
5367 #else
5368   xfree ((PTR_T) ptr);
5369 #endif
5370
5371 }
5372
5373 \f
5374 /* Allocate head of type hash list.  */
5375
5376 STATIC thead_t *
5377 allocate_thead __proto((void))
5378 {
5379   register thead_t *ptr;
5380   static thead_t initial_thead;
5381
5382 #ifndef MALLOC_CHECK
5383   ptr = alloc_counts[ (int)alloc_type_thead ].free_list.f_thead;
5384   if (ptr != (thead_t *)0)
5385     alloc_counts[ (int)alloc_type_thead ].free_list.f_thead = ptr->free;
5386
5387   else
5388     {
5389       register int unallocated  = alloc_counts[ (int)alloc_type_thead ].unallocated;
5390       register page_t *cur_page = alloc_counts[ (int)alloc_type_thead ].cur_page;
5391
5392       if (unallocated == 0)
5393         {
5394           unallocated = PAGE_SIZE / sizeof (thead_t);
5395           alloc_counts[ (int)alloc_type_thead ].cur_page = cur_page = allocate_page ();
5396           alloc_counts[ (int)alloc_type_thead ].total_pages++;
5397         }
5398
5399       ptr = &cur_page->thead[ --unallocated ];
5400       alloc_counts[ (int)alloc_type_thead ].unallocated = unallocated;
5401     }
5402
5403 #else
5404   ptr = (thead_t *) xmalloc (sizeof (thead_t));
5405
5406 #endif
5407
5408   alloc_counts[ (int)alloc_type_thead ].total_alloc++;
5409   *ptr = initial_thead;
5410   return ptr;
5411 }
5412
5413 /* Free scoping information.  */
5414
5415 STATIC void
5416 free_thead (ptr)
5417      thead_t *ptr;
5418 {
5419   alloc_counts[ (int)alloc_type_thead ].total_free++;
5420
5421 #ifndef MALLOC_CHECK
5422   ptr->free = (thead_t *) alloc_counts[ (int)alloc_type_thead ].free_list.f_thead;
5423   alloc_counts[ (int)alloc_type_thead ].free_list.f_thead = ptr;
5424
5425 #else
5426   xfree ((PTR_T) ptr);
5427 #endif
5428
5429 }
5430
5431 #endif /* MIPS_DEBUGGING_INFO *?
5432
5433 \f
5434 /* Output an error message and exit */
5435
5436 /*VARARGS*/
5437 void
5438 fatal (va_alist)
5439      va_dcl
5440 {
5441   va_list ap;
5442   char *format;
5443
5444   if (line_number > 0)
5445     fprintf (stderr, "%s, %s:%ld ", progname, input_name, line_number);
5446   else
5447     fprintf (stderr, "%s:", progname);
5448
5449   va_start(ap);
5450   format = va_arg (ap, char *);
5451   vfprintf (stderr, format, ap);
5452   va_end (ap);
5453   fprintf (stderr, "\n");
5454   if (line_number > 0)
5455     fprintf (stderr, "line:\t%s\n", cur_line_start);
5456
5457   saber_stop ();
5458   exit (1);
5459 }
5460
5461 /*VARARGS*/
5462 void
5463 error (va_alist)
5464      va_dcl
5465 {
5466   va_list ap;
5467   char *format;
5468
5469   if (line_number > 0)
5470     fprintf (stderr, "%s, %s:%ld ", progname, input_name, line_number);
5471   else
5472     fprintf (stderr, "%s:", progname);
5473
5474   va_start(ap);
5475   format = va_arg (ap, char *);
5476   vfprintf (stderr, format, ap);
5477   fprintf (stderr, "\n");
5478   if (line_number > 0)
5479     fprintf (stderr, "line:\t%s\n", cur_line_start);
5480
5481   had_errors++;
5482   va_end (ap);
5483
5484   saber_stop ();
5485 }
5486
5487 /* More 'friendly' abort that prints the line and file.
5488    config.h can #define abort fancy_abort if you like that sort of thing.  */
5489
5490 void
5491 fancy_abort ()
5492 {
5493   fatal ("Internal abort.");
5494 }
5495 \f
5496
5497 /* When `malloc.c' is compiled with `rcheck' defined,
5498    it calls this function to report clobberage.  */
5499
5500 void
5501 botch (s)
5502      const char *s;
5503 {
5504   fatal (s);
5505 }
5506
5507 /* Same as `malloc' but report error if no memory available.  */
5508
5509 PTR_T
5510 xmalloc (size)
5511      Size_t size;
5512 {
5513   register PTR_T value = malloc (size);
5514   if (value == 0)
5515     fatal ("Virtual memory exhausted.");
5516
5517   if (debug > 3)
5518     fprintf (stderr, "\tmalloc\tptr = 0x%.8x, size = %10u\n", value, size);
5519
5520   return value;
5521 }
5522
5523 /* Same as `calloc' but report error if no memory available.  */
5524
5525 PTR_T
5526 xcalloc (size1, size2)
5527      Size_t size1, size2;
5528 {
5529   register PTR_T value = calloc (size1, size2);
5530   if (value == 0)
5531     fatal ("Virtual memory exhausted.");
5532
5533   if (debug > 3)
5534     fprintf (stderr, "\tcalloc\tptr = 0x%.8x, size1 = %10u, size2 = %10u [%u]\n",
5535              value, size1, size2, size1+size2);
5536
5537   return value;
5538 }
5539
5540 /* Same as `realloc' but report error if no memory available.  */
5541
5542 PTR_T
5543 xrealloc (ptr, size)
5544      PTR_T ptr;
5545      Size_t size;
5546 {
5547   register PTR_T result = realloc (ptr, size);
5548   if (!result)
5549     fatal ("Virtual memory exhausted.");
5550
5551   if (debug > 3)
5552     fprintf (stderr, "\trealloc\tptr = 0x%.8x, size = %10u, orig = 0x%.8x\n",
5553              result, size, ptr);
5554
5555   return result;
5556 }
5557
5558 void
5559 xfree (ptr)
5560      PTR_T ptr;
5561 {
5562   if (debug > 3)
5563     fprintf (stderr, "\tfree\tptr = 0x%.8x\n", ptr);
5564
5565   free (ptr);
5566 }