gas/config/obj-ecoff.c

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