contrib/binutils-2.21/gas/ecoff.c

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