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