contrib/binutils-2.17/gas/ecoff.c

   1 /* ECOFF debugging support.
   2    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
   3    2003, 2004, 2005
   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 2, 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 \f
1510 /* Add a page to a varray object.  */
1511
1512 static void
1513 add_varray_page (varray_t *vp /* varray to add page to */)
1514 {
1515   vlinks_t *new_links = allocate_vlinks ();
1516
1517 #ifdef MALLOC_CHECK
1518   if (vp->object_size > 1)
1519     new_links->datum = (page_type *) xcalloc (1, vp->object_size);
1520   else
1521 #endif
1522     new_links->datum = allocate_page ();
1523
1524   alloc_counts[(int) alloc_type_varray].total_alloc++;
1525   alloc_counts[(int) alloc_type_varray].total_pages++;
1526
1527   new_links->start_index = vp->num_allocated;
1528   vp->objects_last_page = 0;
1529
1530   if (vp->first == (vlinks_t *) NULL)           /* first allocation? */
1531     vp->first = vp->last = new_links;
1532   else
1533     {                                           /* 2nd or greater allocation */
1534       new_links->prev = vp->last;
1535       vp->last->next = new_links;
1536       vp->last = new_links;
1537     }
1538 }
1539 \f
1540 /* Add a string (and null pad) to one of the string tables.  */
1541
1542 static symint_t
1543 add_string (varray_t *vp,                       /* string obstack */
1544             struct hash_control *hash_tbl,      /* ptr to hash table */
1545             const char *str,                    /* string */
1546             shash_t **ret_hash                  /* return hash pointer */)
1547 {
1548   register unsigned long len = strlen (str);
1549   register shash_t *hash_ptr;
1550
1551   if (len >= PAGE_USIZE)
1552     as_fatal (_("string too big (%lu bytes)"), len);
1553
1554   hash_ptr = (shash_t *) hash_find (hash_tbl, str);
1555   if (hash_ptr == (shash_t *) NULL)
1556     {
1557       register const char *err;
1558
1559       if (vp->objects_last_page + len >= PAGE_USIZE)
1560         {
1561           vp->num_allocated =
1562             ((vp->num_allocated + PAGE_USIZE - 1) / PAGE_USIZE) * PAGE_USIZE;
1563           add_varray_page (vp);
1564         }
1565
1566       hash_ptr = allocate_shash ();
1567       hash_ptr->indx = vp->num_allocated;
1568
1569       hash_ptr->string = &vp->last->datum->byte[vp->objects_last_page];
1570
1571       vp->objects_last_page += len + 1;
1572       vp->num_allocated += len + 1;
1573
1574       strcpy (hash_ptr->string, str);
1575
1576       err = hash_insert (hash_tbl, str, (char *) hash_ptr);
1577       if (err)
1578         as_fatal (_("inserting \"%s\" into string hash table: %s"),
1579                   str, err);
1580     }
1581
1582   if (ret_hash != (shash_t **) NULL)
1583     *ret_hash = hash_ptr;
1584
1585   return hash_ptr->indx;
1586 }
1587 \f
1588 /* Add debugging information for a symbol.  */
1589
1590 static localsym_t *
1591 add_ecoff_symbol (const char *str,      /* symbol name */
1592                   st_t type,            /* symbol type */
1593                   sc_t storage,         /* storage class */
1594                   symbolS *sym_value,   /* associated symbol.  */
1595                   bfd_vma addend,       /* addend to sym_value.  */
1596                   symint_t value,       /* value of symbol */
1597                   symint_t indx         /* index to local/aux. syms */)
1598 {
1599   localsym_t *psym;
1600   register scope_t *pscope;
1601   register thead_t *ptag_head;
1602   register tag_t *ptag;
1603   register tag_t *ptag_next;
1604   register varray_t *vp;
1605   register int scope_delta = 0;
1606   shash_t *hash_ptr = (shash_t *) NULL;
1607
1608   if (cur_file_ptr == (efdr_t *) NULL)
1609     as_fatal (_("no current file pointer"));
1610
1611   vp = &cur_file_ptr->symbols;
1612
1613   if (vp->objects_last_page == vp->objects_per_page)
1614     add_varray_page (vp);
1615
1616   psym = &vp->last->datum->sym[vp->objects_last_page++];
1617
1618   if (str == (const char *) NULL && sym_value != (symbolS *) NULL)
1619     psym->name = S_GET_NAME (sym_value);
1620   else
1621     psym->name = str;
1622   psym->as_sym = sym_value;
1623   if (sym_value != (symbolS *) NULL)
1624     symbol_get_obj (sym_value)->ecoff_symbol = psym;
1625   psym->addend = addend;
1626   psym->file_ptr = cur_file_ptr;
1627   psym->proc_ptr = cur_proc_ptr;
1628   psym->begin_ptr = (localsym_t *) NULL;
1629   psym->index_ptr = (aux_t *) NULL;
1630   psym->forward_ref = (forward_t *) NULL;
1631   psym->sym_index = -1;
1632   memset (&psym->ecoff_sym, 0, sizeof (EXTR));
1633   psym->ecoff_sym.asym.value = value;
1634   psym->ecoff_sym.asym.st = (unsigned) type;
1635   psym->ecoff_sym.asym.sc = (unsigned) storage;
1636   psym->ecoff_sym.asym.index = indx;
1637
1638   /* If there is an associated symbol, we wait until the end of the
1639      assembly before deciding where to put the name (it may be just an
1640      external symbol).  Otherwise, this is just a debugging symbol and
1641      the name should go with the current file.  */
1642   if (sym_value == (symbolS *) NULL)
1643     psym->ecoff_sym.asym.iss = ((str == (const char *) NULL)
1644                                 ? 0
1645                                 : add_string (&cur_file_ptr->strings,
1646                                               cur_file_ptr->str_hash,
1647                                               str,
1648                                               &hash_ptr));
1649
1650   ++vp->num_allocated;
1651
1652   if (ECOFF_IS_STAB (&psym->ecoff_sym.asym))
1653     return psym;
1654
1655   /* Save the symbol within the hash table if this is a static
1656      item, and it has a name.  */
1657   if (hash_ptr != (shash_t *) NULL
1658       && (type == st_Global || type == st_Static || type == st_Label
1659           || type == st_Proc || type == st_StaticProc))
1660     hash_ptr->sym_ptr = psym;
1661
1662   /* push or pop a scope if appropriate.  */
1663   switch (type)
1664     {
1665     default:
1666       break;
1667
1668     case st_File:                       /* beginning of file */
1669     case st_Proc:                       /* procedure */
1670     case st_StaticProc:                 /* static procedure */
1671     case st_Block:                      /* begin scope */
1672       pscope = allocate_scope ();
1673       pscope->prev = cur_file_ptr->cur_scope;
1674       pscope->lsym = psym;
1675       pscope->type = type;
1676       cur_file_ptr->cur_scope = pscope;
1677
1678       if (type != st_File)
1679         scope_delta = 1;
1680
1681       /* For every block type except file, struct, union, or
1682          enumeration blocks, push a level on the tag stack.  We omit
1683          file types, so that tags can span file boundaries.  */
1684       if (type != st_File && storage != sc_Info)
1685         {
1686           ptag_head = allocate_thead ();
1687           ptag_head->first_tag = 0;
1688           ptag_head->prev = cur_tag_head;
1689           cur_tag_head = ptag_head;
1690         }
1691       break;
1692
1693     case st_End:
1694       pscope = cur_file_ptr->cur_scope;
1695       if (pscope == (scope_t *) NULL)
1696         as_fatal (_("too many st_End's"));
1697       else
1698         {
1699           st_t begin_type = (st_t) pscope->lsym->ecoff_sym.asym.st;
1700
1701           psym->begin_ptr = pscope->lsym;
1702
1703           if (begin_type != st_File)
1704             scope_delta = -1;
1705
1706           /* Except for file, structure, union, or enumeration end
1707              blocks remove all tags created within this scope.  */
1708           if (begin_type != st_File && storage != sc_Info)
1709             {
1710               ptag_head = cur_tag_head;
1711               cur_tag_head = ptag_head->prev;
1712
1713               for (ptag = ptag_head->first_tag;
1714                    ptag != (tag_t *) NULL;
1715                    ptag = ptag_next)
1716                 {
1717                   if (ptag->forward_ref != (forward_t *) NULL)
1718                     add_unknown_tag (ptag);
1719
1720                   ptag_next = ptag->same_block;
1721                   ptag->hash_ptr->tag_ptr = ptag->same_name;
1722                   free_tag (ptag);
1723                 }
1724
1725               free_thead (ptag_head);
1726             }
1727
1728           cur_file_ptr->cur_scope = pscope->prev;
1729
1730           /* block begin gets next sym #.  This is set when we know
1731              the symbol index value.  */
1732
1733           /* Functions push two or more aux words as follows:
1734              1st word: index+1 of the end symbol (filled in later).
1735              2nd word: type of the function (plus any aux words needed).
1736              Also, tie the external pointer back to the function begin symbol.  */
1737           if (begin_type != st_File && begin_type != st_Block)
1738             {
1739               symint_t ty;
1740               varray_t *svp = &cur_file_ptr->aux_syms;
1741
1742               pscope->lsym->ecoff_sym.asym.index = add_aux_sym_symint (0);
1743               pscope->lsym->index_ptr =
1744                 &svp->last->datum->aux[svp->objects_last_page - 1];
1745               ty = add_aux_sym_tir (&last_func_type_info,
1746                                     hash_no,
1747                                     &cur_file_ptr->thash_head[0]);
1748
1749 /* This seems to be unnecessary.  I'm not even sure what it is
1750  * intended to do.  It's from mips-tfile.
1751  *            if (last_func_sym_value != (symbolS *) NULL)
1752  *              {
1753  *                last_func_sym_value->ifd = cur_file_ptr->file_index;
1754  *                last_func_sym_value->index = ty;
1755  *              }
1756  */
1757             }
1758
1759           free_scope (pscope);
1760         }
1761     }
1762
1763   cur_file_ptr->nested_scopes += scope_delta;
1764
1765 #ifdef ECOFF_DEBUG
1766   if (debug && type != st_File
1767       && (debug > 2 || type == st_Block || type == st_End
1768           || type == st_Proc || type == st_StaticProc))
1769     {
1770       char *sc_str = sc_to_string (storage);
1771       char *st_str = st_to_string (type);
1772       int depth = cur_file_ptr->nested_scopes + (scope_delta < 0);
1773
1774       fprintf (stderr,
1775                "\tlsym\tv= %10ld, depth= %2d, sc= %-12s",
1776                value, depth, sc_str);
1777
1778       if (str_start && str_end_p1 - str_start > 0)
1779         fprintf (stderr, " st= %-11s name= %.*s\n",
1780                  st_str, str_end_p1 - str_start, str_start);
1781       else
1782         {
1783           unsigned long len = strlen (st_str);
1784           fprintf (stderr, " st= %.*s\n", len - 1, st_str);
1785         }
1786     }
1787 #endif
1788
1789   return psym;
1790 }
1791 \f
1792 /* Add an auxiliary symbol (passing a symint).  This is actually used
1793    for integral aux types, not just symints.  */
1794
1795 static symint_t
1796 add_aux_sym_symint (symint_t aux_word /* auxiliary information word */)
1797 {
1798   register varray_t *vp;
1799   register aux_t *aux_ptr;
1800
1801   if (cur_file_ptr == (efdr_t *) NULL)
1802     as_fatal (_("no current file pointer"));
1803
1804   vp = &cur_file_ptr->aux_syms;
1805
1806   if (vp->objects_last_page == vp->objects_per_page)
1807     add_varray_page (vp);
1808
1809   aux_ptr = &vp->last->datum->aux[vp->objects_last_page++];
1810   aux_ptr->type = aux_isym;
1811   aux_ptr->data.isym = aux_word;
1812
1813   return vp->num_allocated++;
1814 }
1815
1816 /* Add an auxiliary symbol (passing a file/symbol index combo).  */
1817
1818 static symint_t
1819 add_aux_sym_rndx (int file_index, symint_t sym_index)
1820 {
1821   register varray_t *vp;
1822   register aux_t *aux_ptr;
1823
1824   if (cur_file_ptr == (efdr_t *) NULL)
1825     as_fatal (_("no current file pointer"));
1826
1827   vp = &cur_file_ptr->aux_syms;
1828
1829   if (vp->objects_last_page == vp->objects_per_page)
1830     add_varray_page (vp);
1831
1832   aux_ptr = &vp->last->datum->aux[vp->objects_last_page++];
1833   aux_ptr->type = aux_rndx;
1834   aux_ptr->data.rndx.rfd   = file_index;
1835   aux_ptr->data.rndx.index = sym_index;
1836
1837   return vp->num_allocated++;
1838 }
1839 \f
1840 /* Add an auxiliary symbol (passing the basic type and possibly
1841    type qualifiers).  */
1842
1843 static symint_t
1844 add_aux_sym_tir (type_info_t *t,        /* current type information */
1845                  hash_state_t state,    /* whether to hash type or not */
1846                  thash_t **hash_tbl     /* pointer to hash table to use */)
1847 {
1848   register varray_t *vp;
1849   register aux_t *aux_ptr;
1850   static AUXU init_aux;
1851   symint_t ret;
1852   int i;
1853   AUXU aux;
1854
1855   if (cur_file_ptr == (efdr_t *) NULL)
1856     as_fatal (_("no current file pointer"));
1857
1858   vp = &cur_file_ptr->aux_syms;
1859
1860   aux = init_aux;
1861   aux.ti.bt = (int) t->basic_type;
1862   aux.ti.continued = 0;
1863   aux.ti.fBitfield = t->bitfield;
1864
1865   aux.ti.tq0 = (int) t->type_qualifiers[0];
1866   aux.ti.tq1 = (int) t->type_qualifiers[1];
1867   aux.ti.tq2 = (int) t->type_qualifiers[2];
1868   aux.ti.tq3 = (int) t->type_qualifiers[3];
1869   aux.ti.tq4 = (int) t->type_qualifiers[4];
1870   aux.ti.tq5 = (int) t->type_qualifiers[5];
1871
1872   /* For anything that adds additional information, we must not hash,
1873      so check here, and reset our state.  */
1874
1875   if (state != hash_no
1876       && (t->type_qualifiers[0] == tq_Array
1877           || t->type_qualifiers[1] == tq_Array
1878           || t->type_qualifiers[2] == tq_Array
1879           || t->type_qualifiers[3] == tq_Array
1880           || t->type_qualifiers[4] == tq_Array
1881           || t->type_qualifiers[5] == tq_Array
1882           || t->basic_type == bt_Struct
1883           || t->basic_type == bt_Union
1884           || t->basic_type == bt_Enum
1885           || t->bitfield
1886           || t->num_dims > 0))
1887     state = hash_no;
1888
1889   /* See if we can hash this type, and save some space, but some types
1890      can't be hashed (because they contain arrays or continuations),
1891      and others can be put into the hash list, but cannot use existing
1892      types because other aux entries precede this one.  */
1893
1894   if (state != hash_no)
1895     {
1896       register thash_t *hash_ptr;
1897       register symint_t hi;
1898
1899       hi = aux.isym & ((1 << HASHBITS) - 1);
1900       hi %= THASH_SIZE;
1901
1902       for (hash_ptr = hash_tbl[hi];
1903            hash_ptr != (thash_t *)0;
1904            hash_ptr = hash_ptr->next)
1905         {
1906           if (aux.isym == hash_ptr->type.isym)
1907             break;
1908         }
1909
1910       if (hash_ptr != (thash_t *) NULL && state == hash_yes)
1911         return hash_ptr->indx;
1912
1913       if (hash_ptr == (thash_t *) NULL)
1914         {
1915           hash_ptr = allocate_thash ();
1916           hash_ptr->next = hash_tbl[hi];
1917           hash_ptr->type = aux;
1918           hash_ptr->indx = vp->num_allocated;
1919           hash_tbl[hi] = hash_ptr;
1920         }
1921     }
1922
1923   /* Everything is set up, add the aux symbol.  */
1924   if (vp->objects_last_page == vp->objects_per_page)
1925     add_varray_page (vp);
1926
1927   aux_ptr = &vp->last->datum->aux[vp->objects_last_page++];
1928   aux_ptr->type = aux_tir;
1929   aux_ptr->data = aux;
1930
1931   ret = vp->num_allocated++;
1932
1933   /* Add bitfield length if it exists.
1934
1935      NOTE:  Mips documentation claims bitfield goes at the end of the
1936      AUX record, but the DECstation compiler emits it here.
1937      (This would only make a difference for enum bitfields.)
1938
1939      Also note:  We use the last size given since gcc may emit 2
1940      for an enum bitfield.  */
1941
1942   if (t->bitfield)
1943     (void) add_aux_sym_symint ((symint_t) t->sizes[t->num_sizes - 1]);
1944
1945   /* Add tag information if needed.  Structure, union, and enum
1946      references add 2 aux symbols: a [file index, symbol index]
1947      pointer to the structure type, and the current file index.  */
1948
1949   if (t->basic_type == bt_Struct
1950       || t->basic_type == bt_Union
1951       || t->basic_type == bt_Enum)
1952     {
1953       register symint_t file_index = t->tag_ptr->ifd;
1954       register localsym_t *sym = t->tag_ptr->sym;
1955       register forward_t *forward_ref = allocate_forward ();
1956
1957       if (sym != (localsym_t *) NULL)
1958         {
1959           forward_ref->next = sym->forward_ref;
1960           sym->forward_ref = forward_ref;
1961         }
1962       else
1963         {
1964           forward_ref->next = t->tag_ptr->forward_ref;
1965           t->tag_ptr->forward_ref = forward_ref;
1966         }
1967
1968       (void) add_aux_sym_rndx (ST_RFDESCAPE, indexNil);
1969       forward_ref->index_ptr
1970         = &vp->last->datum->aux[vp->objects_last_page - 1];
1971
1972       (void) add_aux_sym_symint (file_index);
1973       forward_ref->ifd_ptr
1974         = &vp->last->datum->aux[vp->objects_last_page - 1];
1975     }
1976
1977   /* Add information about array bounds if they exist.  */
1978   for (i = 0; i < t->num_dims; i++)
1979     {
1980       (void) add_aux_sym_rndx (ST_RFDESCAPE,
1981                                cur_file_ptr->int_type);
1982
1983       (void) add_aux_sym_symint (cur_file_ptr->file_index);     /* file index*/
1984       (void) add_aux_sym_symint ((symint_t) 0);                 /* low bound */
1985       (void) add_aux_sym_symint (t->dimensions[i] - 1);         /* high bound*/
1986       (void) add_aux_sym_symint ((t->dimensions[i] == 0)        /* stride */
1987                                  ? 0
1988                                  : (t->sizes[i] * 8) / t->dimensions[i]);
1989     };
1990
1991   /* NOTE:  Mips documentation claims that the bitfield width goes here.
1992      But it needs to be emitted earlier.  */
1993
1994   return ret;
1995 }
1996 \f
1997 /* Add a tag to the tag table (unless it already exists).  */
1998
1999 static tag_t *
2000 get_tag (const char *tag,       /* tag name */
2001          localsym_t *sym,       /* tag start block */
2002          bt_t basic_type        /* bt_Struct, bt_Union, or bt_Enum */)
2003 {
2004   shash_t *hash_ptr;
2005   const char *err;
2006   tag_t *tag_ptr;
2007
2008   if (cur_file_ptr == (efdr_t *) NULL)
2009     as_fatal (_("no current file pointer"));
2010
2011   hash_ptr = (shash_t *) hash_find (tag_hash, tag);
2012
2013   if (hash_ptr != (shash_t *) NULL
2014       && hash_ptr->tag_ptr != (tag_t *) NULL)
2015     {
2016       tag_ptr = hash_ptr->tag_ptr;
2017       if (sym != (localsym_t *) NULL)
2018         {
2019           tag_ptr->basic_type = basic_type;
2020           tag_ptr->ifd        = cur_file_ptr->file_index;
2021           tag_ptr->sym        = sym;
2022         }
2023       return tag_ptr;
2024     }
2025
2026   if (hash_ptr == (shash_t *) NULL)
2027     {
2028       char *perm;
2029
2030       perm = xstrdup (tag);
2031       hash_ptr = allocate_shash ();
2032       err = hash_insert (tag_hash, perm, (char *) hash_ptr);
2033       if (err)
2034         as_fatal (_("inserting \"%s\" into tag hash table: %s"),
2035                   tag, err);
2036       hash_ptr->string = perm;
2037     }
2038
2039   tag_ptr = allocate_tag ();
2040   tag_ptr->forward_ref  = (forward_t *) NULL;
2041   tag_ptr->hash_ptr     = hash_ptr;
2042   tag_ptr->same_name    = hash_ptr->tag_ptr;
2043   tag_ptr->basic_type   = basic_type;
2044   tag_ptr->sym          = sym;
2045   tag_ptr->ifd          = ((sym == (localsym_t *) NULL)
2046                            ? (symint_t) -1
2047                            : cur_file_ptr->file_index);
2048   tag_ptr->same_block   = cur_tag_head->first_tag;
2049
2050   cur_tag_head->first_tag = tag_ptr;
2051   hash_ptr->tag_ptr       = tag_ptr;
2052
2053   return tag_ptr;
2054 }
2055 \f
2056 /* Add an unknown {struct, union, enum} tag.  */
2057
2058 static void
2059 add_unknown_tag (tag_t *ptag /* pointer to tag information */)
2060 {
2061   shash_t *hash_ptr     = ptag->hash_ptr;
2062   char *name            = hash_ptr->string;
2063   localsym_t *sym;
2064   forward_t **pf;
2065
2066 #ifdef ECOFF_DEBUG
2067   if (debug > 1)
2068     {
2069       char *agg_type = "{unknown aggregate type}";
2070       switch (ptag->basic_type)
2071         {
2072         case bt_Struct: agg_type = "struct";    break;
2073         case bt_Union:  agg_type = "union";     break;
2074         case bt_Enum:   agg_type = "enum";      break;
2075         default:                                break;
2076         }
2077
2078       fprintf (stderr, "unknown %s %.*s found\n", agg_type,
2079                hash_ptr->len, name_start);
2080     }
2081 #endif
2082
2083   sym = add_ecoff_symbol (name,
2084                           st_Block,
2085                           sc_Info,
2086                           (symbolS *) NULL,
2087                           (bfd_vma) 0,
2088                           (symint_t) 0,
2089                           (symint_t) 0);
2090
2091   (void) add_ecoff_symbol (name,
2092                            st_End,
2093                            sc_Info,
2094                            (symbolS *) NULL,
2095                            (bfd_vma) 0,
2096                            (symint_t) 0,
2097                            (symint_t) 0);
2098
2099   for (pf = &sym->forward_ref; *pf != (forward_t *) NULL; pf = &(*pf)->next)
2100     ;
2101   *pf = ptag->forward_ref;
2102 }
2103 \f
2104 /* Add a procedure to the current file's list of procedures, and record
2105    this is the current procedure.  */
2106
2107 static void
2108 add_procedure (char *func /* func name */)
2109 {
2110   register varray_t *vp;
2111   register proc_t *new_proc_ptr;
2112   symbolS *sym;
2113
2114 #ifdef ECOFF_DEBUG
2115   if (debug)
2116     fputc ('\n', stderr);
2117 #endif
2118
2119   if (cur_file_ptr == (efdr_t *) NULL)
2120     as_fatal (_("no current file pointer"));
2121
2122   vp = &cur_file_ptr->procs;
2123
2124   if (vp->objects_last_page == vp->objects_per_page)
2125     add_varray_page (vp);
2126
2127   cur_proc_ptr = new_proc_ptr = &vp->last->datum->proc[vp->objects_last_page++];
2128
2129   if (first_proc_ptr == (proc_t *) NULL)
2130     first_proc_ptr = new_proc_ptr;
2131
2132   vp->num_allocated++;
2133
2134   new_proc_ptr->pdr.isym = -1;
2135   new_proc_ptr->pdr.iline = -1;
2136   new_proc_ptr->pdr.lnLow = -1;
2137   new_proc_ptr->pdr.lnHigh = -1;
2138
2139   /* Set the BSF_FUNCTION flag for the symbol.  */
2140   sym = symbol_find_or_make (func);
2141   symbol_get_bfdsym (sym)->flags |= BSF_FUNCTION;
2142
2143   /* Push the start of the function.  */
2144   new_proc_ptr->sym = add_ecoff_symbol ((const char *) NULL, st_Proc, sc_Text,
2145                                         sym, (bfd_vma) 0, (symint_t) 0,
2146                                         (symint_t) 0);
2147
2148   ++proc_cnt;
2149
2150   /* Fill in the linenos preceding the .ent, if any.  */
2151   if (noproc_lineno != (lineno_list_t *) NULL)
2152     {
2153       lineno_list_t *l;
2154
2155       for (l = noproc_lineno; l != (lineno_list_t *) NULL; l = l->next)
2156         l->proc = new_proc_ptr;
2157       *last_lineno_ptr = noproc_lineno;
2158       while (*last_lineno_ptr != NULL)
2159         {
2160           last_lineno = *last_lineno_ptr;
2161           last_lineno_ptr = &last_lineno->next;
2162         }
2163       noproc_lineno = (lineno_list_t *) NULL;
2164     }
2165 }
2166
2167 symbolS *
2168 ecoff_get_cur_proc_sym (void)
2169 {
2170   return (cur_proc_ptr ? cur_proc_ptr->sym->as_sym : NULL);
2171 }
2172 \f
2173 /* Add a new filename, and set up all of the file relative
2174    virtual arrays (strings, symbols, aux syms, etc.).  Record
2175    where the current file structure lives.  */
2176
2177 static void
2178 add_file (const char *file_name, int indx ATTRIBUTE_UNUSED, int fake)
2179 {
2180   register int first_ch;
2181   register efdr_t *fil_ptr;
2182
2183 #ifdef ECOFF_DEBUG
2184   if (debug)
2185     fprintf (stderr, "\tfile\t%.*s\n", len, file_start);
2186 #endif
2187
2188   /* If the file name is NULL, then no .file symbol appeared, and we
2189      want to use the actual file name.  */
2190   if (file_name == (const char *) NULL)
2191     {
2192       char *file;
2193
2194       if (first_file != (efdr_t *) NULL)
2195         as_fatal (_("fake .file after real one"));
2196       as_where (&file, (unsigned int *) NULL);
2197       file_name = (const char *) file;
2198
2199       /* Automatically generate ECOFF debugging information, since I
2200          think that's what other ECOFF assemblers do.  We don't do
2201          this if we see a .file directive with a string, since that
2202          implies that some sort of debugging information is being
2203          provided.  */
2204       if (! symbol_table_frozen && debug_type == DEBUG_UNSPECIFIED)
2205         debug_type = DEBUG_ECOFF;
2206     }
2207   else if (debug_type == DEBUG_UNSPECIFIED)
2208     debug_type = DEBUG_NONE;
2209
2210 #ifndef NO_LISTING
2211   if (listing)
2212     listing_source_file (file_name);
2213 #endif
2214
2215   current_stabs_filename = file_name;
2216
2217   /* If we're creating stabs, then we don't actually make a new FDR.
2218      Instead, we just create a stabs symbol.  */
2219   if (stabs_seen)
2220     {
2221       (void) add_ecoff_symbol (file_name, st_Nil, sc_Nil,
2222                                symbol_new ("L0\001", now_seg,
2223                                            (valueT) frag_now_fix (),
2224                                            frag_now),
2225                                (bfd_vma) 0, 0, ECOFF_MARK_STAB (N_SOL));
2226       return;
2227     }
2228
2229   first_ch = *file_name;
2230
2231   /* FIXME: We can't safely merge files which have line number
2232      information (fMerge will be zero in this case).  Otherwise, we
2233      get incorrect line number debugging info.  See for instance
2234      ecoff_build_lineno, which will end up setting all file->fdr.*
2235      fields multiple times, resulting in incorrect debug info.  In
2236      order to make this work right, all line number and symbol info
2237      for the same source file has to be adjacent in the object file,
2238      so that a single file descriptor can be used to point to them.
2239      This would require maintaining file specific lists of line
2240      numbers and symbols for each file, so that they can be merged
2241      together (or output together) when two .file pseudo-ops are
2242      merged into one file descriptor.  */
2243
2244   /* See if the file has already been created.  */
2245   for (fil_ptr = first_file;
2246        fil_ptr != (efdr_t *) NULL;
2247        fil_ptr = fil_ptr->next_file)
2248     {
2249       if (first_ch == fil_ptr->name[0]
2250           && strcmp (file_name, fil_ptr->name) == 0
2251           && fil_ptr->fdr.fMerge)
2252         {
2253           cur_file_ptr = fil_ptr;
2254           if (! fake)
2255             cur_file_ptr->fake = 0;
2256           break;
2257         }
2258     }
2259
2260   /* If this is a new file, create it.  */
2261   if (fil_ptr == (efdr_t *) NULL)
2262     {
2263       if (file_desc.objects_last_page == file_desc.objects_per_page)
2264         add_varray_page (&file_desc);
2265
2266       fil_ptr = cur_file_ptr =
2267         &file_desc.last->datum->file[file_desc.objects_last_page++];
2268       *fil_ptr = init_file;
2269
2270       fil_ptr->file_index = current_file_idx++;
2271       ++file_desc.num_allocated;
2272
2273       fil_ptr->fake = fake;
2274
2275       /* Allocate the string hash table.  */
2276       fil_ptr->str_hash = hash_new ();
2277
2278       /* Make sure 0 byte in string table is null  */
2279       add_string (&fil_ptr->strings,
2280                   fil_ptr->str_hash,
2281                   "",
2282                   (shash_t **)0);
2283
2284       if (strlen (file_name) > PAGE_USIZE - 2)
2285         as_fatal (_("filename goes over one page boundary"));
2286
2287       /* Push the start of the filename. We assume that the filename
2288          will be stored at string offset 1.  */
2289       (void) add_ecoff_symbol (file_name, st_File, sc_Text,
2290                                (symbolS *) NULL, (bfd_vma) 0,
2291                                (symint_t) 0, (symint_t) 0);
2292       fil_ptr->fdr.rss = 1;
2293       fil_ptr->name = &fil_ptr->strings.last->datum->byte[1];
2294
2295       /* Update the linked list of file descriptors.  */
2296       *last_file_ptr = fil_ptr;
2297       last_file_ptr = &fil_ptr->next_file;
2298
2299       /* Add void & int types to the file (void should be first to catch
2300          errant 0's within the index fields).  */
2301       fil_ptr->void_type = add_aux_sym_tir (&void_type_info,
2302                                             hash_yes,
2303                                             &cur_file_ptr->thash_head[0]);
2304
2305       fil_ptr->int_type = add_aux_sym_tir (&int_type_info,
2306                                            hash_yes,
2307                                            &cur_file_ptr->thash_head[0]);
2308     }
2309 }
2310
2311 /* This function is called when the assembler notices a preprocessor
2312    directive switching to a new file.  This will not happen in
2313    compiler output, only in hand coded assembler.  */
2314
2315 void
2316 ecoff_new_file (const char *name, int appfile ATTRIBUTE_UNUSED)
2317 {
2318   if (cur_file_ptr != NULL && strcmp (cur_file_ptr->name, name) == 0)
2319     return;
2320   add_file (name, 0, 0);
2321
2322   /* This is a hand coded assembler file, so automatically turn on
2323      debugging information.  */
2324   if (debug_type == DEBUG_UNSPECIFIED)
2325     debug_type = DEBUG_ECOFF;
2326 }
2327 \f
2328 #ifdef ECOFF_DEBUG
2329
2330 /* Convert storage class to string.  */
2331
2332 static char *
2333 sc_to_string (storage_class)
2334      sc_t storage_class;
2335 {
2336   switch (storage_class)
2337     {
2338     case sc_Nil:         return "Nil,";
2339     case sc_Text:        return "Text,";
2340     case sc_Data:        return "Data,";
2341     case sc_Bss:         return "Bss,";
2342     case sc_Register:    return "Register,";
2343     case sc_Abs:         return "Abs,";
2344     case sc_Undefined:   return "Undefined,";
2345     case sc_CdbLocal:    return "CdbLocal,";
2346     case sc_Bits:        return "Bits,";
2347     case sc_CdbSystem:   return "CdbSystem,";
2348     case sc_RegImage:    return "RegImage,";
2349     case sc_Info:        return "Info,";
2350     case sc_UserStruct:  return "UserStruct,";
2351     case sc_SData:       return "SData,";
2352     case sc_SBss:        return "SBss,";
2353     case sc_RData:       return "RData,";
2354     case sc_Var:         return "Var,";
2355     case sc_Common:      return "Common,";
2356     case sc_SCommon:     return "SCommon,";
2357     case sc_VarRegister: return "VarRegister,";
2358     case sc_Variant:     return "Variant,";
2359     case sc_SUndefined:  return "SUndefined,";
2360     case sc_Init:        return "Init,";
2361     case sc_Max:         return "Max,";
2362     }
2363
2364   return "???,";
2365 }
2366
2367 #endif /* DEBUG */
2368 \f
2369 #ifdef ECOFF_DEBUG
2370
2371 /* Convert symbol type to string.  */
2372
2373 static char *
2374 st_to_string (symbol_type)
2375      st_t symbol_type;
2376 {
2377   switch (symbol_type)
2378     {
2379     case st_Nil:        return "Nil,";
2380     case st_Global:     return "Global,";
2381     case st_Static:     return "Static,";
2382     case st_Param:      return "Param,";
2383     case st_Local:      return "Local,";
2384     case st_Label:      return "Label,";
2385     case st_Proc:       return "Proc,";
2386     case st_Block:      return "Block,";
2387     case st_End:        return "End,";
2388     case st_Member:     return "Member,";
2389     case st_Typedef:    return "Typedef,";
2390     case st_File:       return "File,";
2391     case st_RegReloc:   return "RegReloc,";
2392     case st_Forward:    return "Forward,";
2393     case st_StaticProc: return "StaticProc,";
2394     case st_Constant:   return "Constant,";
2395     case st_Str:        return "String,";
2396     case st_Number:     return "Number,";
2397     case st_Expr:       return "Expr,";
2398     case st_Type:       return "Type,";
2399     case st_Max:        return "Max,";
2400     }
2401
2402   return "???,";
2403 }
2404
2405 #endif /* DEBUG */
2406 \f
2407 /* Parse .begin directives which have a label as the first argument
2408    which gives the location of the start of the block.  */
2409
2410 void
2411 ecoff_directive_begin (int ignore ATTRIBUTE_UNUSED)
2412 {
2413   char *name;
2414   char name_end;
2415
2416   if (cur_file_ptr == (efdr_t *) NULL)
2417     {
2418       as_warn (_(".begin directive without a preceding .file directive"));
2419       demand_empty_rest_of_line ();
2420       return;
2421     }
2422
2423   if (cur_proc_ptr == (proc_t *) NULL)
2424     {
2425       as_warn (_(".begin directive without a preceding .ent directive"));
2426       demand_empty_rest_of_line ();
2427       return;
2428     }
2429
2430   name = input_line_pointer;
2431   name_end = get_symbol_end ();
2432
2433   (void) add_ecoff_symbol ((const char *) NULL, st_Block, sc_Text,
2434                            symbol_find_or_make (name),
2435                            (bfd_vma) 0, (symint_t) 0, (symint_t) 0);
2436
2437   *input_line_pointer = name_end;
2438
2439   /* The line number follows, but we don't use it.  */
2440   (void) get_absolute_expression ();
2441   demand_empty_rest_of_line ();
2442 }
2443 \f
2444 /* Parse .bend directives which have a label as the first argument
2445    which gives the location of the end of the block.  */
2446
2447 void
2448 ecoff_directive_bend (int ignore ATTRIBUTE_UNUSED)
2449 {
2450   char *name;
2451   char name_end;
2452   symbolS *endsym;
2453
2454   if (cur_file_ptr == (efdr_t *) NULL)
2455     {
2456       as_warn (_(".bend directive without a preceding .file directive"));
2457       demand_empty_rest_of_line ();
2458       return;
2459     }
2460
2461   if (cur_proc_ptr == (proc_t *) NULL)
2462     {
2463       as_warn (_(".bend directive without a preceding .ent directive"));
2464       demand_empty_rest_of_line ();
2465       return;
2466     }
2467
2468   name = input_line_pointer;
2469   name_end = get_symbol_end ();
2470
2471   /* The value is the distance between the .bend directive and the
2472      corresponding symbol.  We fill in the offset when we write out
2473      the symbol.  */
2474   endsym = symbol_find (name);
2475   if (endsym == (symbolS *) NULL)
2476     as_warn (_(".bend directive names unknown symbol"));
2477   else
2478     (void) add_ecoff_symbol ((const char *) NULL, st_End, sc_Text, endsym,
2479                              (bfd_vma) 0, (symint_t) 0, (symint_t) 0);
2480
2481   *input_line_pointer = name_end;
2482
2483   /* The line number follows, but we don't use it.  */
2484   (void) get_absolute_expression ();
2485   demand_empty_rest_of_line ();
2486 }
2487 \f
2488 /* COFF debugging information is provided as a series of directives
2489    (.def, .scl, etc.).  We build up information as we read the
2490    directives in the following static variables, and file it away when
2491    we reach the .endef directive.  */
2492 static char *coff_sym_name;
2493 static type_info_t coff_type;
2494 static sc_t coff_storage_class;
2495 static st_t coff_symbol_typ;
2496 static int coff_is_function;
2497 static char *coff_tag;
2498 static valueT coff_value;
2499 static symbolS *coff_sym_value;
2500 static bfd_vma coff_sym_addend;
2501 static int coff_inside_enumeration;
2502
2503 /* Handle a .def directive: start defining a symbol.  */
2504
2505 void
2506 ecoff_directive_def (int ignore ATTRIBUTE_UNUSED)
2507 {
2508   char *name;
2509   char name_end;
2510
2511   ecoff_debugging_seen = 1;
2512
2513   SKIP_WHITESPACE ();
2514
2515   name = input_line_pointer;
2516   name_end = get_symbol_end ();
2517
2518   if (coff_sym_name != (char *) NULL)
2519     as_warn (_(".def pseudo-op used inside of .def/.endef; ignored"));
2520   else if (*name == '\0')
2521     as_warn (_("empty symbol name in .def; ignored"));
2522   else
2523     {
2524       if (coff_sym_name != (char *) NULL)
2525         free (coff_sym_name);
2526       if (coff_tag != (char *) NULL)
2527         free (coff_tag);
2528
2529       coff_sym_name = xstrdup (name);
2530       coff_type = type_info_init;
2531       coff_storage_class = sc_Nil;
2532       coff_symbol_typ = st_Nil;
2533       coff_is_function = 0;
2534       coff_tag = (char *) NULL;
2535       coff_value = 0;
2536       coff_sym_value = (symbolS *) NULL;
2537       coff_sym_addend = 0;
2538     }
2539
2540   *input_line_pointer = name_end;
2541
2542   demand_empty_rest_of_line ();
2543 }
2544
2545 /* Handle a .dim directive, used to give dimensions for an array.  The
2546    arguments are comma separated numbers.  mips-tfile assumes that
2547    there will not be more than 6 dimensions, and gdb won't read any
2548    more than that anyhow, so I will also make that assumption.  */
2549
2550 void
2551 ecoff_directive_dim (int ignore ATTRIBUTE_UNUSED)
2552 {
2553   int dimens[N_TQ];
2554   int i;
2555
2556   if (coff_sym_name == (char *) NULL)
2557     {
2558       as_warn (_(".dim pseudo-op used outside of .def/.endef; ignored"));
2559       demand_empty_rest_of_line ();
2560       return;
2561     }
2562
2563   for (i = 0; i < N_TQ; i++)
2564     {
2565       SKIP_WHITESPACE ();
2566       dimens[i] = get_absolute_expression ();
2567       if (*input_line_pointer == ',')
2568         ++input_line_pointer;
2569       else
2570         {
2571           if (*input_line_pointer != '\n'
2572               && *input_line_pointer != ';')
2573             as_warn (_("badly formed .dim directive"));
2574           break;
2575         }
2576     }
2577
2578   if (i == N_TQ)
2579     --i;
2580
2581   /* The dimensions are stored away in reverse order.  */
2582   for (; i >= 0; i--)
2583     {
2584       if (coff_type.num_dims >= N_TQ)
2585         {
2586           as_warn (_("too many .dim entries"));
2587           break;
2588         }
2589       coff_type.dimensions[coff_type.num_dims] = dimens[i];
2590       ++coff_type.num_dims;
2591     }
2592
2593   demand_empty_rest_of_line ();
2594 }
2595
2596 /* Handle a .scl directive, which sets the COFF storage class of the
2597    symbol.  */
2598
2599 void
2600 ecoff_directive_scl (int ignore ATTRIBUTE_UNUSED)
2601 {
2602   long val;
2603
2604   if (coff_sym_name == (char *) NULL)
2605     {
2606       as_warn (_(".scl pseudo-op used outside of .def/.endef; ignored"));
2607       demand_empty_rest_of_line ();
2608       return;
2609     }
2610
2611   val = get_absolute_expression ();
2612
2613   coff_symbol_typ = map_coff_sym_type[val];
2614   coff_storage_class = map_coff_storage[val];
2615
2616   demand_empty_rest_of_line ();
2617 }
2618
2619 /* Handle a .size directive.  For some reason mips-tfile.c thinks that
2620    .size can have multiple arguments.  We humor it, although gcc will
2621    never generate more than one argument.  */
2622
2623 void
2624 ecoff_directive_size (int ignore ATTRIBUTE_UNUSED)
2625 {
2626   int sizes[N_TQ];
2627   int i;
2628
2629   if (coff_sym_name == (char *) NULL)
2630     {
2631       as_warn (_(".size pseudo-op used outside of .def/.endef; ignored"));
2632       demand_empty_rest_of_line ();
2633       return;
2634     }
2635
2636   for (i = 0; i < N_TQ; i++)
2637     {
2638       SKIP_WHITESPACE ();
2639       sizes[i] = get_absolute_expression ();
2640       if (*input_line_pointer == ',')
2641         ++input_line_pointer;
2642       else
2643         {
2644           if (*input_line_pointer != '\n'
2645               && *input_line_pointer != ';')
2646             as_warn (_("badly formed .size directive"));
2647           break;
2648         }
2649     }
2650
2651   if (i == N_TQ)
2652     --i;
2653
2654   /* The sizes are stored away in reverse order.  */
2655   for (; i >= 0; i--)
2656     {
2657       if (coff_type.num_sizes >= N_TQ)
2658         {
2659           as_warn (_("too many .size entries"));
2660           break;
2661         }
2662       coff_type.sizes[coff_type.num_sizes] = sizes[i];
2663       ++coff_type.num_sizes;
2664     }
2665
2666   demand_empty_rest_of_line ();
2667 }
2668
2669 /* Handle the .type directive, which gives the COFF type of the
2670    symbol.  */
2671
2672 void
2673 ecoff_directive_type (int ignore ATTRIBUTE_UNUSED)
2674 {
2675   long val;
2676   tq_t *tq_ptr;
2677   tq_t *tq_shft;
2678
2679   if (coff_sym_name == (char *) NULL)
2680     {
2681       as_warn (_(".type pseudo-op used outside of .def/.endef; ignored"));
2682       demand_empty_rest_of_line ();
2683       return;
2684     }
2685
2686   val = get_absolute_expression ();
2687
2688   coff_type.orig_type = BTYPE (val);
2689   coff_type.basic_type = map_coff_types[coff_type.orig_type];
2690
2691   tq_ptr = &coff_type.type_qualifiers[N_TQ];
2692   while (val & ~N_BTMASK)
2693     {
2694       if (tq_ptr == &coff_type.type_qualifiers[0])
2695         {
2696           /* FIXME: We could handle this by setting the continued bit.
2697              There would still be a limit: the .type argument can not
2698              be infinite.  */
2699           as_warn (_("the type of %s is too complex; it will be simplified"),
2700                    coff_sym_name);
2701           break;
2702         }
2703       if (ISPTR (val))
2704         *--tq_ptr = tq_Ptr;
2705       else if (ISFCN (val))
2706         *--tq_ptr = tq_Proc;
2707       else if (ISARY (val))
2708         *--tq_ptr = tq_Array;
2709       else
2710         as_fatal (_("Unrecognized .type argument"));
2711
2712       val = DECREF (val);
2713     }
2714
2715   tq_shft = &coff_type.type_qualifiers[0];
2716   while (tq_ptr != &coff_type.type_qualifiers[N_TQ])
2717     *tq_shft++ = *tq_ptr++;
2718
2719   if (tq_shft != &coff_type.type_qualifiers[0] && tq_shft[-1] == tq_Proc)
2720     {
2721       /* If this is a function, ignore it, so that we don't get two
2722          entries (one from the .ent, and one for the .def that
2723          precedes it).  Save the type information so that the end
2724          block can properly add it after the begin block index.  For
2725          MIPS knows what reason, we must strip off the function type
2726          at this point.  */
2727       coff_is_function = 1;
2728       tq_shft[-1] = tq_Nil;
2729     }
2730
2731   while (tq_shft != &coff_type.type_qualifiers[N_TQ])
2732     *tq_shft++ = tq_Nil;
2733
2734   demand_empty_rest_of_line ();
2735 }
2736
2737 /* Handle the .tag directive, which gives the name of a structure,
2738    union or enum.  */
2739
2740 void
2741 ecoff_directive_tag (int ignore ATTRIBUTE_UNUSED)
2742 {
2743   char *name;
2744   char name_end;
2745
2746   if (coff_sym_name == (char *) NULL)
2747     {
2748       as_warn (_(".tag pseudo-op used outside of .def/.endef; ignored"));
2749       demand_empty_rest_of_line ();
2750       return;
2751     }
2752
2753   name = input_line_pointer;
2754   name_end = get_symbol_end ();
2755
2756   coff_tag = xstrdup (name);
2757
2758   *input_line_pointer = name_end;
2759
2760   demand_empty_rest_of_line ();
2761 }
2762
2763 /* Handle the .val directive, which gives the value of the symbol.  It
2764    may be the name of a static or global symbol.  */
2765
2766 void
2767 ecoff_directive_val (int ignore ATTRIBUTE_UNUSED)
2768 {
2769   expressionS exp;
2770
2771   if (coff_sym_name == (char *) NULL)
2772     {
2773       as_warn (_(".val pseudo-op used outside of .def/.endef; ignored"));
2774       demand_empty_rest_of_line ();
2775       return;
2776     }
2777
2778   expression (&exp);
2779   if (exp.X_op != O_constant && exp.X_op != O_symbol)
2780     {
2781       as_bad (_(".val expression is too copmlex"));
2782       demand_empty_rest_of_line ();
2783       return;
2784     }
2785
2786   if (exp.X_op == O_constant)
2787     coff_value = exp.X_add_number;
2788   else
2789     {
2790       coff_sym_value = exp.X_add_symbol;
2791       coff_sym_addend = exp.X_add_number;
2792     }
2793
2794   demand_empty_rest_of_line ();
2795 }
2796
2797 /* Handle the .endef directive, which terminates processing of COFF
2798    debugging information for a symbol.  */
2799
2800 void
2801 ecoff_directive_endef (int ignore ATTRIBUTE_UNUSED)
2802 {
2803   char *name;
2804   symint_t indx;
2805   localsym_t *sym;
2806
2807   demand_empty_rest_of_line ();
2808
2809   if (coff_sym_name == (char *) NULL)
2810     {
2811       as_warn (_(".endef pseudo-op used before .def; ignored"));
2812       return;
2813     }
2814
2815   name = coff_sym_name;
2816   coff_sym_name = (char *) NULL;
2817
2818   /* If the symbol is a static or external, we have already gotten the
2819      appropriate type and class, so make sure we don't override those
2820      values.  This is needed because there are some type and classes
2821      that are not in COFF, such as short data, etc.  */
2822   if (coff_sym_value != (symbolS *) NULL)
2823     {
2824       coff_symbol_typ = st_Nil;
2825       coff_storage_class = sc_Nil;
2826     }
2827
2828   coff_type.extra_sizes = coff_tag != (char *) NULL;
2829   if (coff_type.num_dims > 0)
2830     {
2831       int diff = coff_type.num_dims - coff_type.num_sizes;
2832       int i = coff_type.num_dims - 1;
2833       int j;
2834
2835       if (coff_type.num_sizes != 1 || diff < 0)
2836         {
2837           as_warn (_("bad COFF debugging information"));
2838           return;
2839         }
2840
2841       /* If this is an array, make sure the same number of dimensions
2842          and sizes were passed, creating extra sizes for multiply
2843          dimensioned arrays if not passed.  */
2844       coff_type.extra_sizes = 0;
2845       if (diff)
2846         {
2847           j = (sizeof (coff_type.sizes) / sizeof (coff_type.sizes[0])) - 1;
2848           while (j >= 0)
2849             {
2850               coff_type.sizes[j] = (((j - diff) >= 0)
2851                                     ? coff_type.sizes[j - diff]
2852                                     : 0);
2853               j--;
2854             }
2855
2856           coff_type.num_sizes = i + 1;
2857           for (i--; i >= 0; i--)
2858             coff_type.sizes[i] = (coff_type.dimensions[i + 1] == 0
2859                                   ? 0
2860                                   : (coff_type.sizes[i + 1]
2861                                      / coff_type.dimensions[i + 1]));
2862         }
2863     }
2864   else if (coff_symbol_typ == st_Member
2865            && coff_type.num_sizes - coff_type.extra_sizes == 1)
2866     {
2867       /* Is this a bitfield?  This is indicated by a structure member
2868          having a size field that isn't an array.  */
2869       coff_type.bitfield = 1;
2870     }
2871
2872   /* Except for enumeration members & begin/ending of scopes, put the
2873      type word in the aux. symbol table.  */
2874   if (coff_symbol_typ == st_Block || coff_symbol_typ == st_End)
2875     indx = 0;
2876   else if (coff_inside_enumeration)
2877     indx = cur_file_ptr->void_type;
2878   else
2879     {
2880       if (coff_type.basic_type == bt_Struct
2881           || coff_type.basic_type == bt_Union
2882           || coff_type.basic_type == bt_Enum)
2883         {
2884           if (coff_tag == (char *) NULL)
2885             {
2886               as_warn (_("no tag specified for %s"), name);
2887               return;
2888             }
2889
2890           coff_type.tag_ptr = get_tag (coff_tag, (localsym_t *) NULL,
2891                                        coff_type.basic_type);
2892         }
2893
2894       if (coff_is_function)
2895         {
2896           last_func_type_info = coff_type;
2897           last_func_sym_value = coff_sym_value;
2898           return;
2899         }
2900
2901       indx = add_aux_sym_tir (&coff_type,
2902                               hash_yes,
2903                               &cur_file_ptr->thash_head[0]);
2904     }
2905
2906   /* Do any last minute adjustments that are necessary.  */
2907   switch (coff_symbol_typ)
2908     {
2909     default:
2910       break;
2911
2912       /* For the beginning of structs, unions, and enumerations, the
2913          size info needs to be passed in the value field.  */
2914     case st_Block:
2915       if (coff_type.num_sizes - coff_type.num_dims - coff_type.extra_sizes
2916           != 1)
2917         {
2918           as_warn (_("bad COFF debugging information"));
2919           return;
2920         }
2921       else
2922         coff_value = coff_type.sizes[0];
2923
2924       coff_inside_enumeration = (coff_type.orig_type == T_ENUM);
2925       break;
2926
2927       /* For the end of structs, unions, and enumerations, omit the
2928          name which is always ".eos".  This needs to be done last, so
2929          that any error reporting above gives the correct name.  */
2930     case st_End:
2931       free (name);
2932       name = (char *) NULL;
2933       coff_value = 0;
2934       coff_inside_enumeration = 0;
2935       break;
2936
2937       /* Members of structures and unions that aren't bitfields, need
2938          to adjust the value from a byte offset to a bit offset.
2939          Members of enumerations do not have the value adjusted, and
2940          can be distinguished by indx == indexNil.  For enumerations,
2941          update the maximum enumeration value.  */
2942     case st_Member:
2943       if (! coff_type.bitfield && ! coff_inside_enumeration)
2944         coff_value *= 8;
2945
2946       break;
2947     }
2948
2949   /* Add the symbol.  */
2950   sym = add_ecoff_symbol (name,
2951                           coff_symbol_typ,
2952                           coff_storage_class,
2953                           coff_sym_value,
2954                           coff_sym_addend,
2955                           (symint_t) coff_value,
2956                           indx);
2957
2958   /* deal with struct, union, and enum tags.  */
2959   if (coff_symbol_typ == st_Block)
2960     {
2961       /* Create or update the tag information.  */
2962       tag_t *tag_ptr = get_tag (name,
2963                                 sym,
2964                                 coff_type.basic_type);
2965       forward_t **pf;
2966
2967       /* Remember any forward references.  */
2968       for (pf = &sym->forward_ref;
2969            *pf != (forward_t *) NULL;
2970            pf = &(*pf)->next)
2971         ;
2972       *pf = tag_ptr->forward_ref;
2973       tag_ptr->forward_ref = (forward_t *) NULL;
2974     }
2975 }
2976 \f
2977 /* Parse .end directives.  */
2978
2979 void
2980 ecoff_directive_end (int ignore ATTRIBUTE_UNUSED)
2981 {
2982   char *name;
2983   char name_end;
2984   symbolS *ent;
2985
2986   if (cur_file_ptr == (efdr_t *) NULL)
2987     {
2988       as_warn (_(".end directive without a preceding .file directive"));
2989       demand_empty_rest_of_line ();
2990       return;
2991     }
2992
2993   if (cur_proc_ptr == (proc_t *) NULL)
2994     {
2995       as_warn (_(".end directive without a preceding .ent directive"));
2996       demand_empty_rest_of_line ();
2997       return;
2998     }
2999
3000   name = input_line_pointer;
3001   name_end = get_symbol_end ();
3002
3003   if (name == input_line_pointer)
3004     {
3005       as_warn (_(".end directive has no name"));
3006       *input_line_pointer = name_end;
3007       demand_empty_rest_of_line ();
3008       return;
3009     }
3010
3011   /* The value is the distance between the .end directive and the
3012      corresponding symbol.  We create a fake symbol to hold the
3013      current location, and put in the offset when we write out the
3014      symbol.  */
3015   ent = symbol_find (name);
3016   if (ent == (symbolS *) NULL)
3017     as_warn (_(".end directive names unknown symbol"));
3018   else
3019     (void) add_ecoff_symbol ((const char *) NULL, st_End, sc_Text,
3020                              symbol_new ("L0\001", now_seg,
3021                                          (valueT) frag_now_fix (),
3022                                          frag_now),
3023                              (bfd_vma) 0, (symint_t) 0, (symint_t) 0);
3024
3025   cur_proc_ptr = (proc_t *) NULL;
3026
3027   *input_line_pointer = name_end;
3028   demand_empty_rest_of_line ();
3029 }
3030 \f
3031 /* Parse .ent directives.  */
3032
3033 void
3034 ecoff_directive_ent (int ignore ATTRIBUTE_UNUSED)
3035 {
3036   char *name;
3037   char name_end;
3038
3039   if (cur_file_ptr == (efdr_t *) NULL)
3040     add_file ((const char *) NULL, 0, 1);
3041
3042   if (cur_proc_ptr != (proc_t *) NULL)
3043     {
3044       as_warn (_("second .ent directive found before .end directive"));
3045       demand_empty_rest_of_line ();
3046       return;
3047     }
3048
3049   name = input_line_pointer;
3050   name_end = get_symbol_end ();
3051
3052   if (name == input_line_pointer)
3053     {
3054       as_warn (_(".ent directive has no name"));
3055       *input_line_pointer = name_end;
3056       demand_empty_rest_of_line ();
3057       return;
3058     }
3059
3060   add_procedure (name);
3061
3062   *input_line_pointer = name_end;
3063
3064   /* The .ent directive is sometimes followed by a number.  I'm not
3065      really sure what the number means.  I don't see any way to store
3066      the information in the PDR.  The Irix 4 assembler seems to ignore
3067      the information.  */
3068   SKIP_WHITESPACE ();
3069   if (*input_line_pointer == ',')
3070     {
3071       ++input_line_pointer;
3072       SKIP_WHITESPACE ();
3073     }
3074   if (ISDIGIT (*input_line_pointer)
3075       || *input_line_pointer == '-')
3076     (void) get_absolute_expression ();
3077
3078   demand_empty_rest_of_line ();
3079 }
3080 \f
3081 /* Parse .extern directives.  */
3082
3083 void
3084 ecoff_directive_extern (int ignore ATTRIBUTE_UNUSED)
3085 {
3086   char *name;
3087   int c;
3088   symbolS *symbolp;
3089   valueT size;
3090
3091   name = input_line_pointer;
3092   c = get_symbol_end ();
3093   symbolp = symbol_find_or_make (name);
3094   *input_line_pointer = c;
3095
3096   S_SET_EXTERNAL (symbolp);
3097
3098   if (*input_line_pointer == ',')
3099     ++input_line_pointer;
3100   size = get_absolute_expression ();
3101
3102   symbol_get_obj (symbolp)->ecoff_extern_size = size;
3103 }
3104 \f
3105 /* Parse .file directives.  */
3106
3107 void
3108 ecoff_directive_file (int ignore ATTRIBUTE_UNUSED)
3109 {
3110   int indx;
3111   char *name;
3112   int len;
3113
3114   if (cur_proc_ptr != (proc_t *) NULL)
3115     {
3116       as_warn (_("no way to handle .file within .ent/.end section"));
3117       demand_empty_rest_of_line ();
3118       return;
3119     }
3120
3121   indx = (int) get_absolute_expression ();
3122
3123   /* FIXME: we don't have to save the name here.  */
3124   name = demand_copy_C_string (&len);
3125
3126   add_file (name, indx - 1, 0);
3127
3128   demand_empty_rest_of_line ();
3129 }
3130 \f
3131 /* Parse .fmask directives.  */
3132
3133 void
3134 ecoff_directive_fmask (int ignore ATTRIBUTE_UNUSED)
3135 {
3136   long val;
3137
3138   if (cur_proc_ptr == (proc_t *) NULL)
3139     {
3140       as_warn (_(".fmask outside of .ent"));
3141       demand_empty_rest_of_line ();
3142       return;
3143     }
3144
3145   if (get_absolute_expression_and_terminator (&val) != ',')
3146     {
3147       as_warn (_("bad .fmask directive"));
3148       --input_line_pointer;
3149       demand_empty_rest_of_line ();
3150       return;
3151     }
3152
3153   cur_proc_ptr->pdr.fregmask = val;
3154   cur_proc_ptr->pdr.fregoffset = get_absolute_expression ();
3155
3156   demand_empty_rest_of_line ();
3157 }
3158 \f
3159 /* Parse .frame directives.  */
3160
3161 void
3162 ecoff_directive_frame (int ignore ATTRIBUTE_UNUSED)
3163 {
3164   long val;
3165
3166   if (cur_proc_ptr == (proc_t *) NULL)
3167     {
3168       as_warn (_(".frame outside of .ent"));
3169       demand_empty_rest_of_line ();
3170       return;
3171     }
3172
3173   cur_proc_ptr->pdr.framereg = tc_get_register (1);
3174
3175   SKIP_WHITESPACE ();
3176   if (*input_line_pointer++ != ','
3177       || get_absolute_expression_and_terminator (&val) != ',')
3178     {
3179       as_warn (_("bad .frame directive"));
3180       --input_line_pointer;
3181       demand_empty_rest_of_line ();
3182       return;
3183     }
3184
3185   cur_proc_ptr->pdr.frameoffset = val;
3186
3187   cur_proc_ptr->pdr.pcreg = tc_get_register (0);
3188
3189   /* Alpha-OSF1 adds "the offset of saved $a0 from $sp", according to
3190      Sandro.  I don't yet know where this value should be stored, if
3191      anywhere.  Don't call demand_empty_rest_of_line ().  */
3192   s_ignore (42);
3193 }
3194 \f
3195 /* Parse .mask directives.  */
3196
3197 void
3198 ecoff_directive_mask (int ignore ATTRIBUTE_UNUSED)
3199 {
3200   long val;
3201
3202   if (cur_proc_ptr == (proc_t *) NULL)
3203     {
3204       as_warn (_(".mask outside of .ent"));
3205       demand_empty_rest_of_line ();
3206       return;
3207     }
3208
3209   if (get_absolute_expression_and_terminator (&val) != ',')
3210     {
3211       as_warn (_("bad .mask directive"));
3212       --input_line_pointer;
3213       demand_empty_rest_of_line ();
3214       return;
3215     }
3216
3217   cur_proc_ptr->pdr.regmask = val;
3218   cur_proc_ptr->pdr.regoffset = get_absolute_expression ();
3219
3220   demand_empty_rest_of_line ();
3221 }
3222 \f
3223 /* Parse .loc directives.  */
3224
3225 void
3226 ecoff_directive_loc (int ignore ATTRIBUTE_UNUSED)
3227 {
3228   lineno_list_t *list;
3229   symint_t lineno;
3230
3231   if (cur_file_ptr == (efdr_t *) NULL)
3232     {
3233       as_warn (_(".loc before .file"));
3234       demand_empty_rest_of_line ();
3235       return;
3236     }
3237
3238   if (now_seg != text_section)
3239     {
3240       as_warn (_(".loc outside of .text"));
3241       demand_empty_rest_of_line ();
3242       return;
3243     }
3244
3245   /* Skip the file number.  */
3246   SKIP_WHITESPACE ();
3247   get_absolute_expression ();
3248   SKIP_WHITESPACE ();
3249
3250   lineno = get_absolute_expression ();
3251
3252 #ifndef NO_LISTING
3253   if (listing)
3254     listing_source_line (lineno);
3255 #endif
3256
3257   /* If we're building stabs, then output a special label rather than
3258      ECOFF line number info.  */
3259   if (stabs_seen)
3260     {
3261       (void) add_ecoff_symbol ((char *) NULL, st_Label, sc_Text,
3262                                symbol_new ("L0\001", now_seg,
3263                                            (valueT) frag_now_fix (),
3264                                            frag_now),
3265                                (bfd_vma) 0, 0, lineno);
3266       return;
3267     }
3268
3269   list = allocate_lineno_list ();
3270
3271   list->next = (lineno_list_t *) NULL;
3272   list->file = cur_file_ptr;
3273   list->proc = cur_proc_ptr;
3274   list->frag = frag_now;
3275   list->paddr = frag_now_fix ();
3276   list->lineno = lineno;
3277
3278   /* We don't want to merge files which have line numbers.  */
3279   cur_file_ptr->fdr.fMerge = 0;
3280
3281   /* A .loc directive will sometimes appear before a .ent directive,
3282      which means that cur_proc_ptr will be NULL here.  Arrange to
3283      patch this up.  */
3284   if (cur_proc_ptr == (proc_t *) NULL)
3285     {
3286       lineno_list_t **pl;
3287
3288       pl = &noproc_lineno;
3289       while (*pl != (lineno_list_t *) NULL)
3290         pl = &(*pl)->next;
3291       *pl = list;
3292     }
3293   else
3294     {
3295       last_lineno = list;
3296       *last_lineno_ptr = list;
3297       last_lineno_ptr = &list->next;
3298     }
3299 }
3300
3301 /* The MIPS assembler sometimes inserts nop instructions in the
3302    instruction stream.  When this happens, we must patch up the .loc
3303    information so that it points to the instruction after the nop.  */
3304
3305 void
3306 ecoff_fix_loc (fragS *old_frag, unsigned long old_frag_offset)
3307 {
3308   if (last_lineno != NULL
3309       && last_lineno->frag == old_frag
3310       && last_lineno->paddr == old_frag_offset)
3311     {
3312       last_lineno->frag = frag_now;
3313       last_lineno->paddr = frag_now_fix ();
3314     }
3315 }
3316 \f
3317 /* Make sure the @stabs symbol is emitted.  */
3318
3319 static void
3320 mark_stabs (int ignore ATTRIBUTE_UNUSED)
3321 {
3322   if (! stabs_seen)
3323     {
3324       /* Add a dummy @stabs dymbol.  */
3325       stabs_seen = 1;
3326       (void) add_ecoff_symbol (stabs_symbol, stNil, scInfo,
3327                                (symbolS *) NULL,
3328                                (bfd_vma) 0, (symint_t) -1,
3329                                ECOFF_MARK_STAB (0));
3330     }
3331 }
3332 \f
3333 /* Parse .weakext directives.  */
3334 #ifndef TC_MIPS
3335 /* For TC_MIPS use the version in tc-mips.c.  */
3336 void
3337 ecoff_directive_weakext (int ignore ATTRIBUTE_UNUSED)
3338 {
3339   char *name;
3340   int c;
3341   symbolS *symbolP;
3342   expressionS exp;
3343
3344   name = input_line_pointer;
3345   c = get_symbol_end ();
3346   symbolP = symbol_find_or_make (name);
3347   *input_line_pointer = c;
3348
3349   SKIP_WHITESPACE ();
3350
3351   if (*input_line_pointer == ',')
3352     {
3353       if (S_IS_DEFINED (symbolP))
3354         {
3355           as_bad (_("symbol `%s' is already defined"),
3356                   S_GET_NAME (symbolP));
3357           ignore_rest_of_line ();
3358           return;
3359         }
3360
3361       ++input_line_pointer;
3362       SKIP_WHITESPACE ();
3363       if (! is_end_of_line[(unsigned char) *input_line_pointer])
3364         {
3365           expression (&exp);
3366           if (exp.X_op != O_symbol)
3367             {
3368               as_bad (_("bad .weakext directive"));
3369               ignore_rest_of_line ();
3370               return;
3371             }
3372           symbol_set_value_expression (symbolP, &exp);
3373         }
3374     }
3375
3376   S_SET_WEAK (symbolP);
3377
3378   demand_empty_rest_of_line ();
3379 }
3380 #endif /* not TC_MIPS */
3381 \f
3382 /* Handle .stabs directives.  The actual parsing routine is done by a
3383    generic routine.  This routine is called via OBJ_PROCESS_STAB.
3384    When this is called, input_line_pointer will be pointing at the
3385    value field of the stab.
3386
3387    .stabs directives have five fields:
3388         "string"        a string, encoding the type information.
3389         code            a numeric code, defined in <stab.h>
3390         0               a zero
3391         desc            a zero or line number
3392         value           a numeric value or an address.
3393
3394     If the value is relocatable, we transform this into:
3395         iss             points as an index into string space
3396         value           value from lookup of the name
3397         st              st from lookup of the name
3398         sc              sc from lookup of the name
3399         index           code|CODE_MASK
3400
3401     If the value is not relocatable, we transform this into:
3402         iss             points as an index into string space
3403         value           value
3404         st              st_Nil
3405         sc              sc_Nil
3406         index           code|CODE_MASK
3407
3408     .stabn directives have four fields (string is null):
3409         code            a numeric code, defined in <stab.h>
3410         0               a zero
3411         desc            a zero or a line number
3412         value           a numeric value or an address.  */
3413
3414 void
3415 ecoff_stab (segT sec ATTRIBUTE_UNUSED,
3416             int what,
3417             const char *string,
3418             int type,
3419             int other,
3420             int desc)
3421 {
3422   efdr_t *save_file_ptr = cur_file_ptr;
3423   symbolS *sym;
3424   symint_t value;
3425   bfd_vma addend;
3426   st_t st;
3427   sc_t sc;
3428   symint_t indx;
3429   localsym_t *hold = NULL;
3430
3431   ecoff_debugging_seen = 1;
3432
3433   /* We don't handle .stabd.  */
3434   if (what != 's' && what != 'n')
3435     {
3436       as_bad (_(".stab%c is not supported"), what);
3437       return;
3438     }
3439
3440   /* A .stabn uses a null name, not an empty string.  */
3441   if (what == 'n')
3442     string = NULL;
3443
3444   /* We ignore the other field.  */
3445   if (other != 0)
3446     as_warn (_(".stab%c: ignoring non-zero other field"), what);
3447
3448   /* Make sure we have a current file.  */
3449   if (cur_file_ptr == (efdr_t *) NULL)
3450     {
3451       add_file ((const char *) NULL, 0, 1);
3452       save_file_ptr = cur_file_ptr;
3453     }
3454
3455   /* For stabs in ECOFF, the first symbol must be @stabs.  This is a
3456      signal to gdb.  */
3457   if (stabs_seen == 0)
3458     mark_stabs (0);
3459
3460   /* Line number stabs are handled differently, since they have two
3461      values, the line number and the address of the label.  We use the
3462      index field (aka desc) to hold the line number, and the value
3463      field to hold the address.  The symbol type is st_Label, which
3464      should be different from the other stabs, so that gdb can
3465      recognize it.  */
3466   if (type == N_SLINE)
3467     {
3468       SYMR dummy_symr;
3469       char *name;
3470       char name_end;
3471
3472 #ifndef NO_LISTING
3473       if (listing)
3474         listing_source_line ((unsigned int) desc);
3475 #endif
3476
3477       dummy_symr.index = desc;
3478       if (dummy_symr.index != desc)
3479         {
3480           as_warn (_("line number (%d) for .stab%c directive cannot fit in index field (20 bits)"),
3481                    desc, what);
3482           return;
3483         }
3484
3485       name = input_line_pointer;
3486       name_end = get_symbol_end ();
3487
3488       sym = symbol_find_or_make (name);
3489       *input_line_pointer = name_end;
3490
3491       value = 0;
3492       addend = 0;
3493       st = st_Label;
3494       sc = sc_Text;
3495       indx = desc;
3496     }
3497   else
3498     {
3499 #ifndef NO_LISTING
3500       if (listing && (type == N_SO || type == N_SOL))
3501         listing_source_file (string);
3502 #endif
3503
3504       if (ISDIGIT (*input_line_pointer)
3505           || *input_line_pointer == '-'
3506           || *input_line_pointer == '+')
3507         {
3508           st = st_Nil;
3509           sc = sc_Nil;
3510           sym = (symbolS *) NULL;
3511           value = get_absolute_expression ();
3512           addend = 0;
3513         }
3514       else if (! is_name_beginner ((unsigned char) *input_line_pointer))
3515         {
3516           as_warn (_("illegal .stab%c directive, bad character"), what);
3517           return;
3518         }
3519       else
3520         {
3521           expressionS exp;
3522
3523           sc = sc_Nil;
3524           st = st_Nil;
3525
3526           expression (&exp);
3527           if (exp.X_op == O_constant)
3528             {
3529               sym = NULL;
3530               value = exp.X_add_number;
3531               addend = 0;
3532             }
3533           else if (exp.X_op == O_symbol)
3534             {
3535               sym = exp.X_add_symbol;
3536               value = 0;
3537               addend = exp.X_add_number;
3538             }
3539           else
3540             {
3541               sym = make_expr_symbol (&exp);
3542               value = 0;
3543               addend = 0;
3544             }
3545         }
3546
3547       indx = ECOFF_MARK_STAB (type);
3548     }
3549
3550   /* Don't store the stabs symbol we are creating as the type of the
3551      ECOFF symbol.  We want to compute the type of the ECOFF symbol
3552      independently.  */
3553   if (sym != (symbolS *) NULL)
3554     hold = symbol_get_obj (sym)->ecoff_symbol;
3555
3556   (void) add_ecoff_symbol (string, st, sc, sym, addend, value, indx);
3557
3558   if (sym != (symbolS *) NULL)
3559     symbol_get_obj (sym)->ecoff_symbol = hold;
3560
3561   /* Restore normal file type.  */
3562   cur_file_ptr = save_file_ptr;
3563 }
3564 \f
3565 /* Frob an ECOFF symbol.  Small common symbols go into a special
3566    .scommon section rather than bfd_com_section.  */
3567
3568 void
3569 ecoff_frob_symbol (symbolS *sym)
3570 {
3571   if (S_IS_COMMON (sym)
3572       && S_GET_VALUE (sym) > 0
3573       && S_GET_VALUE (sym) <= bfd_get_gp_size (stdoutput))
3574     {
3575       static asection scom_section;
3576       static asymbol scom_symbol;
3577
3578       /* We must construct a fake section similar to bfd_com_section
3579          but with the name .scommon.  */
3580       if (scom_section.name == NULL)
3581         {
3582           scom_section = bfd_com_section;
3583           scom_section.name = ".scommon";
3584           scom_section.output_section = &scom_section;
3585           scom_section.symbol = &scom_symbol;
3586           scom_section.symbol_ptr_ptr = &scom_section.symbol;
3587           scom_symbol = *bfd_com_section.symbol;
3588           scom_symbol.name = ".scommon";
3589           scom_symbol.section = &scom_section;
3590         }
3591       S_SET_SEGMENT (sym, &scom_section);
3592     }
3593
3594   /* Double check weak symbols.  */
3595   if (S_IS_WEAK (sym))
3596     {
3597       if (S_IS_COMMON (sym))
3598         as_bad (_("symbol `%s' can not be both weak and common"),
3599                 S_GET_NAME (sym));
3600     }
3601 }
3602 \f
3603 /* Add bytes to the symbolic information buffer.  */
3604
3605 static char *
3606 ecoff_add_bytes (char **buf,
3607                  char **bufend,
3608                  char *bufptr,
3609                  unsigned long need)
3610 {
3611   unsigned long at;
3612   unsigned long want;
3613
3614   at = bufptr - *buf;
3615   need -= *bufend - bufptr;
3616   if (need < PAGE_SIZE)
3617     need = PAGE_SIZE;
3618   want = (*bufend - *buf) + need;
3619   *buf = xrealloc (*buf, want);
3620   *bufend = *buf + want;
3621   return *buf + at;
3622 }
3623
3624 /* Adjust the symbolic information buffer to the alignment required
3625    for the ECOFF target debugging information.  */
3626
3627 static unsigned long
3628 ecoff_padding_adjust (const struct ecoff_debug_swap *backend,
3629                       char **buf,
3630                       char **bufend,
3631                       unsigned long offset,
3632                       char **bufptrptr)
3633 {
3634   bfd_size_type align;
3635
3636   align = backend->debug_align;
3637   if ((offset & (align - 1)) != 0)
3638     {
3639       unsigned long add;
3640
3641       add = align - (offset & (align - 1));
3642       if ((unsigned long) (*bufend - (*buf + offset)) < add)
3643         (void) ecoff_add_bytes (buf, bufend, *buf + offset, add);
3644       memset (*buf + offset, 0, add);
3645       offset += add;
3646       if (bufptrptr != (char **) NULL)
3647         *bufptrptr = *buf + offset;
3648     }
3649
3650   return offset;
3651 }
3652
3653 /* Build the line number information.  */
3654
3655 static unsigned long
3656 ecoff_build_lineno (const struct ecoff_debug_swap *backend,
3657                     char **buf,
3658                     char **bufend,
3659                     unsigned long offset,
3660                     long *linecntptr)
3661 {
3662   char *bufptr;
3663   register lineno_list_t *l;
3664   lineno_list_t *last;
3665   efdr_t *file;
3666   proc_t *proc;
3667   unsigned long c;
3668   long iline;
3669   long totcount;
3670   lineno_list_t first;
3671   lineno_list_t *local_first_lineno = first_lineno;
3672
3673   if (linecntptr != (long *) NULL)
3674     *linecntptr = 0;
3675
3676   bufptr = *buf + offset;
3677
3678   file = (efdr_t *) NULL;
3679   proc = (proc_t *) NULL;
3680   last = (lineno_list_t *) NULL;
3681   c = offset;
3682   iline = 0;
3683   totcount = 0;
3684
3685   /* FIXME?  Now that MIPS embedded-PIC is gone, it may be safe to
3686      remove this code.  */
3687   /* For some reason the address of the first procedure is ignored
3688      when reading line numbers.  This doesn't matter if the address of
3689      the first procedure is 0, but when gcc is generating MIPS
3690      embedded PIC code, it will put strings in the .text section
3691      before the first procedure.  We cope by inserting a dummy line if
3692      the address of the first procedure is not 0.  Hopefully this
3693      won't screw things up too badly.
3694
3695      Don't do this for ECOFF assembly source line numbers.  They work
3696      without this extra attention.  */
3697   if (debug_type != DEBUG_ECOFF
3698       && first_proc_ptr != (proc_t *) NULL
3699       && local_first_lineno != (lineno_list_t *) NULL
3700       && ((S_GET_VALUE (first_proc_ptr->sym->as_sym)
3701            + bfd_get_section_vma (stdoutput,
3702                                   S_GET_SEGMENT (first_proc_ptr->sym->as_sym)))
3703           != 0))
3704     {
3705       first.file = local_first_lineno->file;
3706       first.proc = local_first_lineno->proc;
3707       first.frag = &zero_address_frag;
3708       first.paddr = 0;
3709       first.lineno = 0;
3710
3711       first.next = local_first_lineno;
3712       local_first_lineno = &first;
3713     }
3714
3715   for (l = local_first_lineno; l != (lineno_list_t *) NULL; l = l->next)
3716     {
3717       long count;
3718       long delta;
3719
3720       /* Get the offset to the memory address of the next line number
3721          (in words).  Do this first, so that we can skip ahead to the
3722          next useful line number entry.  */
3723       if (l->next == (lineno_list_t *) NULL)
3724         {
3725           /* We want a count of zero, but it will be decremented
3726              before it is used.  */
3727           count = 1;
3728         }
3729       else if (l->next->frag->fr_address + l->next->paddr
3730                > l->frag->fr_address + l->paddr)
3731         {
3732           count = ((l->next->frag->fr_address + l->next->paddr
3733                     - (l->frag->fr_address + l->paddr))
3734                    >> 2);
3735         }
3736       else
3737         {
3738           /* Don't change last, so we still get the right delta.  */
3739           continue;
3740         }
3741
3742       if (l->file != file || l->proc != proc)
3743         {
3744           if (l->proc != proc && proc != (proc_t *) NULL)
3745             proc->pdr.lnHigh = last->lineno;
3746           if (l->file != file && file != (efdr_t *) NULL)
3747             {
3748               file->fdr.cbLine = c - file->fdr.cbLineOffset;
3749               file->fdr.cline = totcount + count;
3750               if (linecntptr != (long *) NULL)
3751                 *linecntptr += totcount + count;
3752               totcount = 0;
3753             }
3754
3755           if (l->file != file)
3756             {
3757               efdr_t *last_file = file;
3758
3759               file = l->file;
3760               if (last_file != (efdr_t *) NULL)
3761                 file->fdr.ilineBase
3762                   = last_file->fdr.ilineBase + last_file->fdr.cline;
3763               else
3764                 file->fdr.ilineBase = 0;
3765               file->fdr.cbLineOffset = c;
3766             }
3767           if (l->proc != proc)
3768             {
3769               proc = l->proc;
3770               if (proc != (proc_t *) NULL)
3771                 {
3772                   proc->pdr.lnLow = l->lineno;
3773                   proc->pdr.cbLineOffset = c - file->fdr.cbLineOffset;
3774                   proc->pdr.iline = totcount;
3775                 }
3776             }
3777
3778           last = (lineno_list_t *) NULL;
3779         }
3780
3781       totcount += count;
3782
3783       /* Get the offset to this line number.  */
3784       if (last == (lineno_list_t *) NULL)
3785         delta = 0;
3786       else
3787         delta = l->lineno - last->lineno;
3788
3789       /* Put in the offset to this line number.  */
3790       while (delta != 0)
3791         {
3792           int setcount;
3793
3794           /* 1 is added to each count read.  */
3795           --count;
3796           /* We can only adjust the word count by up to 15 words at a
3797              time.  */
3798           if (count <= 0x0f)
3799             {
3800               setcount = count;
3801               count = 0;
3802             }
3803           else
3804             {
3805               setcount = 0x0f;
3806               count -= 0x0f;
3807             }
3808           if (delta >= -7 && delta <= 7)
3809             {
3810               if (bufptr >= *bufend)
3811                 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1);
3812               *bufptr++ = setcount + (delta << 4);
3813               delta = 0;
3814               ++c;
3815             }
3816           else
3817             {
3818               int set;
3819
3820               if (*bufend - bufptr < 3)
3821                 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 3);
3822               *bufptr++ = setcount + (8 << 4);
3823               if (delta < -0x8000)
3824                 {
3825                   set = -0x8000;
3826                   delta += 0x8000;
3827                 }
3828               else if (delta > 0x7fff)
3829                 {
3830                   set = 0x7fff;
3831                   delta -= 0x7fff;
3832                 }
3833               else
3834                 {
3835                   set = delta;
3836                   delta = 0;
3837                 }
3838               *bufptr++ = set >> 8;
3839               *bufptr++ = set & 0xffff;
3840               c += 3;
3841             }
3842         }
3843
3844       /* Finish adjusting the count.  */
3845       while (count > 0)
3846         {
3847           if (bufptr >= *bufend)
3848             bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1);
3849           /* 1 is added to each count read.  */
3850           --count;
3851           if (count > 0x0f)
3852             {
3853               *bufptr++ = 0x0f;
3854               count -= 0x0f;
3855             }
3856           else
3857             {
3858               *bufptr++ = count;
3859               count = 0;
3860             }
3861           ++c;
3862         }
3863
3864       ++iline;
3865       last = l;
3866     }
3867
3868   if (proc != (proc_t *) NULL)
3869     proc->pdr.lnHigh = last->lineno;
3870   if (file != (efdr_t *) NULL)
3871     {
3872       file->fdr.cbLine = c - file->fdr.cbLineOffset;
3873       file->fdr.cline = totcount;
3874     }
3875
3876   if (linecntptr != (long *) NULL)
3877     *linecntptr += totcount;
3878
3879   c = ecoff_padding_adjust (backend, buf, bufend, c, &bufptr);
3880
3881   return c;
3882 }
3883
3884 /* Build and swap out the symbols.  */
3885
3886 static unsigned long
3887 ecoff_build_symbols (const struct ecoff_debug_swap *backend,
3888                      char **buf,
3889                      char **bufend,
3890                      unsigned long offset)
3891 {
3892   const bfd_size_type external_sym_size = backend->external_sym_size;
3893   void (* const swap_sym_out) (bfd *, const SYMR *, PTR)
3894     = backend->swap_sym_out;
3895   char *sym_out;
3896   long isym;
3897   vlinks_t *file_link;
3898
3899   sym_out = *buf + offset;
3900
3901   isym = 0;
3902
3903   /* The symbols are stored by file.  */
3904   for (file_link = file_desc.first;
3905        file_link != (vlinks_t *) NULL;
3906        file_link = file_link->next)
3907     {
3908       int ifilesym;
3909       int fil_cnt;
3910       efdr_t *fil_ptr;
3911       efdr_t *fil_end;
3912
3913       if (file_link->next == (vlinks_t *) NULL)
3914         fil_cnt = file_desc.objects_last_page;
3915       else
3916         fil_cnt = file_desc.objects_per_page;
3917       fil_ptr = file_link->datum->file;
3918       fil_end = fil_ptr + fil_cnt;
3919       for (; fil_ptr < fil_end; fil_ptr++)
3920         {
3921           vlinks_t *sym_link;
3922
3923           fil_ptr->fdr.isymBase = isym;
3924           ifilesym = isym;
3925           for (sym_link = fil_ptr->symbols.first;
3926                sym_link != (vlinks_t *) NULL;
3927                sym_link = sym_link->next)
3928             {
3929               int sym_cnt;
3930               localsym_t *sym_ptr;
3931               localsym_t *sym_end;
3932
3933               if (sym_link->next == (vlinks_t *) NULL)
3934                 sym_cnt = fil_ptr->symbols.objects_last_page;
3935               else
3936                 sym_cnt = fil_ptr->symbols.objects_per_page;
3937               sym_ptr = sym_link->datum->sym;
3938               sym_end = sym_ptr + sym_cnt;
3939               for (; sym_ptr < sym_end; sym_ptr++)
3940                 {
3941                   int local;
3942                   symbolS *as_sym;
3943                   forward_t *f;
3944
3945                   know (sym_ptr->file_ptr == fil_ptr);
3946
3947                   /* If there is no associated gas symbol, then this
3948                      is a pure debugging symbol.  We have already
3949                      added the name (if any) to fil_ptr->strings.
3950                      Otherwise we must decide whether this is an
3951                      external or a local symbol (actually, it may be
3952                      both if the local provides additional debugging
3953                      information for the external).  */
3954                   local = 1;
3955                   as_sym = sym_ptr->as_sym;
3956                   if (as_sym != (symbolS *) NULL)
3957                     {
3958                       symint_t indx;
3959
3960                       /* The value of a block start symbol is the
3961                          offset from the start of the procedure.  For
3962                          other symbols we just use the gas value (but
3963                          we must offset it by the vma of the section,
3964                          just as BFD does, because BFD will not see
3965                          this value).  */
3966                       if (sym_ptr->ecoff_sym.asym.st == (int) st_Block
3967                           && sym_ptr->ecoff_sym.asym.sc == (int) sc_Text)
3968                         {
3969                           symbolS *begin_sym;
3970
3971                           know (sym_ptr->proc_ptr != (proc_t *) NULL);
3972                           begin_sym = sym_ptr->proc_ptr->sym->as_sym;
3973                           if (S_GET_SEGMENT (as_sym)
3974                               != S_GET_SEGMENT (begin_sym))
3975                             as_warn (_(".begin/.bend in different segments"));
3976                           sym_ptr->ecoff_sym.asym.value =
3977                             S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym);
3978                         }
3979                       else
3980                         sym_ptr->ecoff_sym.asym.value =
3981                           (S_GET_VALUE (as_sym)
3982                            + bfd_get_section_vma (stdoutput,
3983                                                   S_GET_SEGMENT (as_sym))
3984                            + sym_ptr->addend);
3985
3986                       sym_ptr->ecoff_sym.weakext = S_IS_WEAK (as_sym);
3987
3988                       /* Set st_Proc to st_StaticProc for local
3989                          functions.  */
3990                       if (sym_ptr->ecoff_sym.asym.st == st_Proc
3991                           && S_IS_DEFINED (as_sym)
3992                           && ! S_IS_EXTERNAL (as_sym)
3993                           && ! S_IS_WEAK (as_sym))
3994                         sym_ptr->ecoff_sym.asym.st = st_StaticProc;
3995
3996                       /* Get the type and storage class based on where
3997                          the symbol actually wound up.  Traditionally,
3998                          N_LBRAC and N_RBRAC are *not* relocated.  */
3999                       indx = sym_ptr->ecoff_sym.asym.index;
4000                       if (sym_ptr->ecoff_sym.asym.st == st_Nil
4001                           && sym_ptr->ecoff_sym.asym.sc == sc_Nil
4002                           && (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym)
4003                               || ((ECOFF_UNMARK_STAB (indx) != N_LBRAC)
4004                                   && (ECOFF_UNMARK_STAB (indx) != N_RBRAC))))
4005                         {
4006                           segT seg;
4007                           const char *segname;
4008                           st_t st;
4009                           sc_t sc;
4010
4011                           seg = S_GET_SEGMENT (as_sym);
4012                           segname = segment_name (seg);
4013
4014                           if (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym)
4015                               && (S_IS_EXTERNAL (as_sym)
4016                                   || S_IS_WEAK (as_sym)
4017                                   || ! S_IS_DEFINED (as_sym)))
4018                             {
4019                               if ((symbol_get_bfdsym (as_sym)->flags
4020                                    & BSF_FUNCTION) != 0)
4021                                 st = st_Proc;
4022                               else
4023                                 st = st_Global;
4024                             }
4025                           else if (seg == text_section)
4026                             st = st_Label;
4027                           else
4028                             st = st_Static;
4029
4030                           if (! S_IS_DEFINED (as_sym))
4031                             {
4032                               valueT s;
4033
4034                               s = symbol_get_obj (as_sym)->ecoff_extern_size;
4035                               if (s == 0
4036                                   || s > bfd_get_gp_size (stdoutput))
4037                                 sc = sc_Undefined;
4038                               else
4039                                 {
4040                                   sc = sc_SUndefined;
4041                                   sym_ptr->ecoff_sym.asym.value = s;
4042                                 }
4043 #ifdef S_SET_SIZE
4044                               S_SET_SIZE (as_sym, s);
4045 #endif
4046                             }
4047                           else if (S_IS_COMMON (as_sym))
4048                             {
4049                               if (S_GET_VALUE (as_sym) > 0
4050                                   && (S_GET_VALUE (as_sym)
4051                                       <= bfd_get_gp_size (stdoutput)))
4052                                 sc = sc_SCommon;
4053                               else
4054                                 sc = sc_Common;
4055                             }
4056                           else if (seg == text_section)
4057                             sc = sc_Text;
4058                           else if (seg == data_section)
4059                             sc = sc_Data;
4060                           else if (strcmp (segname, ".rdata") == 0
4061                                    || strcmp (segname, ".rodata") == 0)
4062                             sc = sc_RData;
4063                           else if (strcmp (segname, ".sdata") == 0)
4064                             sc = sc_SData;
4065                           else if (seg == bss_section)
4066                             sc = sc_Bss;
4067                           else if (strcmp (segname, ".sbss") == 0)
4068                             sc = sc_SBss;
4069                           else if (seg == &bfd_abs_section)
4070                             sc = sc_Abs;
4071                           else
4072                             {
4073                               /* This must be a user named section.
4074                                  This is not possible in ECOFF, but it
4075                                  is in ELF.  */
4076                               sc = sc_Data;
4077                             }
4078
4079                           sym_ptr->ecoff_sym.asym.st = (int) st;
4080                           sym_ptr->ecoff_sym.asym.sc = (int) sc;
4081                         }
4082
4083                       /* This is just an external symbol if it is
4084                          outside a procedure and it has a type.
4085                          FIXME: g++ will generate symbols which have
4086                          different names in the debugging information
4087                          than the actual symbol.  Should we handle
4088                          them here?  */
4089                       if ((S_IS_EXTERNAL (as_sym)
4090                            || S_IS_WEAK (as_sym)
4091                            || ! S_IS_DEFINED (as_sym))
4092                           && sym_ptr->proc_ptr == (proc_t *) NULL
4093                           && sym_ptr->ecoff_sym.asym.st != (int) st_Nil
4094                           && ! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym))
4095                         local = 0;
4096
4097                       /* This is just an external symbol if it is a
4098                          common symbol.  */
4099                       if (S_IS_COMMON (as_sym))
4100                         local = 0;
4101
4102                       /* If an st_end symbol has an associated gas
4103                          symbol, then it is a local label created for
4104                          a .bend or .end directive.  Stabs line
4105                          numbers will have \001 in the names.  */
4106                       if (local
4107                           && sym_ptr->ecoff_sym.asym.st != st_End
4108                           && strchr (sym_ptr->name, '\001') == 0)
4109                         sym_ptr->ecoff_sym.asym.iss =
4110                           add_string (&fil_ptr->strings,
4111                                       fil_ptr->str_hash,
4112                                       sym_ptr->name,
4113                                       (shash_t **) NULL);
4114                     }
4115
4116                   /* We now know the index of this symbol; fill in
4117                      locations that have been waiting for that
4118                      information.  */
4119                   if (sym_ptr->begin_ptr != (localsym_t *) NULL)
4120                     {
4121                       localsym_t *begin_ptr;
4122                       st_t begin_type;
4123
4124                       know (local);
4125                       begin_ptr = sym_ptr->begin_ptr;
4126                       know (begin_ptr->sym_index != -1);
4127                       sym_ptr->ecoff_sym.asym.index = begin_ptr->sym_index;
4128                       if (sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
4129                         sym_ptr->ecoff_sym.asym.iss =
4130                           begin_ptr->ecoff_sym.asym.iss;
4131
4132                       begin_type = begin_ptr->ecoff_sym.asym.st;
4133                       if (begin_type == st_File
4134                           || begin_type == st_Block)
4135                         {
4136                           begin_ptr->ecoff_sym.asym.index =
4137                             isym - ifilesym + 1;
4138                           (*swap_sym_out) (stdoutput,
4139                                            &begin_ptr->ecoff_sym.asym,
4140                                            (*buf
4141                                             + offset
4142                                             + (begin_ptr->sym_index
4143                                                * external_sym_size)));
4144                         }
4145                       else
4146                         {
4147                           know (begin_ptr->index_ptr != (aux_t *) NULL);
4148                           begin_ptr->index_ptr->data.isym =
4149                             isym - ifilesym + 1;
4150                         }
4151
4152                       /* The value of the symbol marking the end of a
4153                          procedure is the size of the procedure.  The
4154                          value of the symbol marking the end of a
4155                          block is the offset from the start of the
4156                          procedure to the block.  */
4157                       if (begin_type == st_Proc
4158                           || begin_type == st_StaticProc)
4159                         {
4160                           know (as_sym != (symbolS *) NULL);
4161                           know (begin_ptr->as_sym != (symbolS *) NULL);
4162                           if (S_GET_SEGMENT (as_sym)
4163                               != S_GET_SEGMENT (begin_ptr->as_sym))
4164                             as_warn (_(".begin/.bend in different segments"));
4165                           sym_ptr->ecoff_sym.asym.value =
4166                             (S_GET_VALUE (as_sym)
4167                              - S_GET_VALUE (begin_ptr->as_sym));
4168
4169                           /* If the size is odd, this is probably a
4170                              mips16 function; force it to be even.  */
4171                           if ((sym_ptr->ecoff_sym.asym.value & 1) != 0)
4172                             ++sym_ptr->ecoff_sym.asym.value;
4173
4174 #ifdef S_SET_SIZE
4175                           S_SET_SIZE (begin_ptr->as_sym,
4176                                       sym_ptr->ecoff_sym.asym.value);
4177 #endif
4178                         }
4179                       else if (begin_type == st_Block
4180                                && sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
4181                         {
4182                           symbolS *begin_sym;
4183
4184                           know (as_sym != (symbolS *) NULL);
4185                           know (sym_ptr->proc_ptr != (proc_t *) NULL);
4186                           begin_sym = sym_ptr->proc_ptr->sym->as_sym;
4187                           if (S_GET_SEGMENT (as_sym)
4188                               != S_GET_SEGMENT (begin_sym))
4189                             as_warn (_(".begin/.bend in different segments"));
4190                           sym_ptr->ecoff_sym.asym.value =
4191                             S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym);
4192                         }
4193                     }
4194
4195                   for (f = sym_ptr->forward_ref;
4196                        f != (forward_t *) NULL;
4197                        f = f->next)
4198                     {
4199                       know (local);
4200                       f->ifd_ptr->data.isym = fil_ptr->file_index;
4201                       f->index_ptr->data.rndx.index = isym - ifilesym;
4202                     }
4203
4204                   if (local)
4205                     {
4206                       if ((bfd_size_type)(*bufend - sym_out) < external_sym_size)
4207                         sym_out = ecoff_add_bytes (buf, bufend,
4208                                                    sym_out,
4209                                                    external_sym_size);
4210                       (*swap_sym_out) (stdoutput, &sym_ptr->ecoff_sym.asym,
4211                                        sym_out);
4212                       sym_out += external_sym_size;
4213
4214                       sym_ptr->sym_index = isym;
4215
4216                       if (sym_ptr->proc_ptr != (proc_t *) NULL
4217                           && sym_ptr->proc_ptr->sym == sym_ptr)
4218                         sym_ptr->proc_ptr->pdr.isym = isym - ifilesym;
4219
4220                       ++isym;
4221                     }
4222
4223                   /* Record the local symbol index and file number in
4224                      case this is an external symbol.  Note that this
4225                      destroys the asym.index field.  */
4226                   if (as_sym != (symbolS *) NULL
4227                       && symbol_get_obj (as_sym)->ecoff_symbol == sym_ptr)
4228                     {
4229                       if ((sym_ptr->ecoff_sym.asym.st == st_Proc
4230                            || sym_ptr->ecoff_sym.asym.st == st_StaticProc)
4231                           && local)
4232                         sym_ptr->ecoff_sym.asym.index = isym - ifilesym - 1;
4233                       sym_ptr->ecoff_sym.ifd = fil_ptr->file_index;
4234
4235                       /* Don't try to merge an FDR which has an
4236                          external symbol attached to it.  */
4237                       if (S_IS_EXTERNAL (as_sym) || S_IS_WEAK (as_sym))
4238                         fil_ptr->fdr.fMerge = 0;
4239                     }
4240                 }
4241             }
4242           fil_ptr->fdr.csym = isym - fil_ptr->fdr.isymBase;
4243         }
4244     }
4245
4246   return offset + isym * external_sym_size;
4247 }
4248
4249 /* Swap out the procedure information.  */
4250
4251 static unsigned long
4252 ecoff_build_procs (const struct ecoff_debug_swap *backend,
4253                    char **buf,
4254                    char **bufend,
4255                    unsigned long offset)
4256 {
4257   const bfd_size_type external_pdr_size = backend->external_pdr_size;
4258   void (* const swap_pdr_out) (bfd *, const PDR *, PTR)
4259     = backend->swap_pdr_out;
4260   char *pdr_out;
4261   long iproc;
4262   vlinks_t *file_link;
4263
4264   pdr_out = *buf + offset;
4265
4266   iproc = 0;
4267
4268   /* The procedures are stored by file.  */
4269   for (file_link = file_desc.first;
4270        file_link != (vlinks_t *) NULL;
4271        file_link = file_link->next)
4272     {
4273       int fil_cnt;
4274       efdr_t *fil_ptr;
4275       efdr_t *fil_end;
4276
4277       if (file_link->next == (vlinks_t *) NULL)
4278         fil_cnt = file_desc.objects_last_page;
4279       else
4280         fil_cnt = file_desc.objects_per_page;
4281       fil_ptr = file_link->datum->file;
4282       fil_end = fil_ptr + fil_cnt;
4283       for (; fil_ptr < fil_end; fil_ptr++)
4284         {
4285           vlinks_t *proc_link;
4286           int first;
4287
4288           fil_ptr->fdr.ipdFirst = iproc;
4289           first = 1;
4290           for (proc_link = fil_ptr->procs.first;
4291                proc_link != (vlinks_t *) NULL;
4292                proc_link = proc_link->next)
4293             {
4294               int prc_cnt;
4295               proc_t *proc_ptr;
4296               proc_t *proc_end;
4297
4298               if (proc_link->next == (vlinks_t *) NULL)
4299                 prc_cnt = fil_ptr->procs.objects_last_page;
4300               else
4301                 prc_cnt = fil_ptr->procs.objects_per_page;
4302               proc_ptr = proc_link->datum->proc;
4303               proc_end = proc_ptr + prc_cnt;
4304               for (; proc_ptr < proc_end; proc_ptr++)
4305                 {
4306                   symbolS *adr_sym;
4307                   unsigned long adr;
4308
4309                   adr_sym = proc_ptr->sym->as_sym;
4310                   adr = (S_GET_VALUE (adr_sym)
4311                          + bfd_get_section_vma (stdoutput,
4312                                                 S_GET_SEGMENT (adr_sym)));
4313                   if (first)
4314                     {
4315                       /* This code used to force the adr of the very
4316                          first fdr to be 0.  However, the native tools
4317                          don't do that, and I can't remember why it
4318                          used to work that way, so I took it out.  */
4319                       fil_ptr->fdr.adr = adr;
4320                       first = 0;
4321                     }
4322                   proc_ptr->pdr.adr = adr - fil_ptr->fdr.adr;
4323                   if ((bfd_size_type)(*bufend - pdr_out) < external_pdr_size)
4324                     pdr_out = ecoff_add_bytes (buf, bufend,
4325                                                pdr_out,
4326                                                external_pdr_size);
4327                   (*swap_pdr_out) (stdoutput, &proc_ptr->pdr, pdr_out);
4328                   pdr_out += external_pdr_size;
4329                   ++iproc;
4330                 }
4331             }
4332           fil_ptr->fdr.cpd = iproc - fil_ptr->fdr.ipdFirst;
4333         }
4334     }
4335
4336   return offset + iproc * external_pdr_size;
4337 }
4338
4339 /* Swap out the aux information.  */
4340
4341 static unsigned long
4342 ecoff_build_aux (const struct ecoff_debug_swap *backend,
4343                  char **buf,
4344                  char **bufend,
4345                  unsigned long offset)
4346 {
4347   int bigendian;
4348   union aux_ext *aux_out;
4349   long iaux;
4350   vlinks_t *file_link;
4351
4352   bigendian = bfd_big_endian (stdoutput);
4353
4354   aux_out = (union aux_ext *) (*buf + offset);
4355
4356   iaux = 0;
4357
4358   /* The aux entries are stored by file.  */
4359   for (file_link = file_desc.first;
4360        file_link != (vlinks_t *) NULL;
4361        file_link = file_link->next)
4362     {
4363       int fil_cnt;
4364       efdr_t *fil_ptr;
4365       efdr_t *fil_end;
4366
4367       if (file_link->next == (vlinks_t *) NULL)
4368         fil_cnt = file_desc.objects_last_page;
4369       else
4370         fil_cnt = file_desc.objects_per_page;
4371       fil_ptr = file_link->datum->file;
4372       fil_end = fil_ptr + fil_cnt;
4373       for (; fil_ptr < fil_end; fil_ptr++)
4374         {
4375           vlinks_t *aux_link;
4376
4377           fil_ptr->fdr.fBigendian = bigendian;
4378           fil_ptr->fdr.iauxBase = iaux;
4379           for (aux_link = fil_ptr->aux_syms.first;
4380                aux_link != (vlinks_t *) NULL;
4381                aux_link = aux_link->next)
4382             {
4383               int aux_cnt;
4384               aux_t *aux_ptr;
4385               aux_t *aux_end;
4386
4387               if (aux_link->next == (vlinks_t *) NULL)
4388                 aux_cnt = fil_ptr->aux_syms.objects_last_page;
4389               else
4390                 aux_cnt = fil_ptr->aux_syms.objects_per_page;
4391               aux_ptr = aux_link->datum->aux;
4392               aux_end = aux_ptr + aux_cnt;
4393               for (; aux_ptr < aux_end; aux_ptr++)
4394                 {
4395                   if ((unsigned long) (*bufend - (char *) aux_out)
4396                       < sizeof (union aux_ext))
4397                     aux_out = ((union aux_ext *)
4398                                ecoff_add_bytes (buf, bufend,
4399                                                 (char *) aux_out,
4400                                                 sizeof (union aux_ext)));
4401                   switch (aux_ptr->type)
4402                     {
4403                     case aux_tir:
4404                       (*backend->swap_tir_out) (bigendian,
4405                                                 &aux_ptr->data.ti,
4406                                                 &aux_out->a_ti);
4407                       break;
4408                     case aux_rndx:
4409                       (*backend->swap_rndx_out) (bigendian,
4410                                                  &aux_ptr->data.rndx,
4411                                                  &aux_out->a_rndx);
4412                       break;
4413                     case aux_dnLow:
4414                       AUX_PUT_DNLOW (bigendian, aux_ptr->data.dnLow,
4415                                      aux_out);
4416                       break;
4417                     case aux_dnHigh:
4418                       AUX_PUT_DNHIGH (bigendian, aux_ptr->data.dnHigh,
4419                                       aux_out);
4420                       break;
4421                     case aux_isym:
4422                       AUX_PUT_ISYM (bigendian, aux_ptr->data.isym,
4423                                     aux_out);
4424                       break;
4425                     case aux_iss:
4426                       AUX_PUT_ISS (bigendian, aux_ptr->data.iss,
4427                                    aux_out);
4428                       break;
4429                     case aux_width:
4430                       AUX_PUT_WIDTH (bigendian, aux_ptr->data.width,
4431                                      aux_out);
4432                       break;
4433                     case aux_count:
4434                       AUX_PUT_COUNT (bigendian, aux_ptr->data.count,
4435                                      aux_out);
4436                       break;
4437                     }
4438
4439                   ++aux_out;
4440                   ++iaux;
4441                 }
4442             }
4443           fil_ptr->fdr.caux = iaux - fil_ptr->fdr.iauxBase;
4444         }
4445     }
4446
4447   return ecoff_padding_adjust (backend, buf, bufend,
4448                                offset + iaux * sizeof (union aux_ext),
4449                                (char **) NULL);
4450 }
4451
4452 /* Copy out the strings from a varray_t.  This returns the number of
4453    bytes copied, rather than the new offset.  */
4454
4455 static unsigned long
4456 ecoff_build_strings (char **buf,
4457                      char **bufend,
4458                      unsigned long offset,
4459                      varray_t *vp)
4460 {
4461   unsigned long istr;
4462   char *str_out;
4463   vlinks_t *str_link;
4464
4465   str_out = *buf + offset;
4466
4467   istr = 0;
4468
4469   for (str_link = vp->first;
4470        str_link != (vlinks_t *) NULL;
4471        str_link = str_link->next)
4472     {
4473       unsigned long str_cnt;
4474
4475       if (str_link->next == (vlinks_t *) NULL)
4476         str_cnt = vp->objects_last_page;
4477       else
4478         str_cnt = vp->objects_per_page;
4479
4480       if ((unsigned long)(*bufend - str_out) < str_cnt)
4481         str_out = ecoff_add_bytes (buf, bufend, str_out, str_cnt);
4482
4483       memcpy (str_out, str_link->datum->byte, str_cnt);
4484       str_out += str_cnt;
4485       istr += str_cnt;
4486     }
4487
4488   return istr;
4489 }
4490
4491 /* Dump out the local strings.  */
4492
4493 static unsigned long
4494 ecoff_build_ss (const struct ecoff_debug_swap *backend,
4495                 char **buf,
4496                 char **bufend,
4497                 unsigned long offset)
4498 {
4499   long iss;
4500   vlinks_t *file_link;
4501
4502   iss = 0;
4503
4504   for (file_link = file_desc.first;
4505        file_link != (vlinks_t *) NULL;
4506        file_link = file_link->next)
4507     {
4508       int fil_cnt;
4509       efdr_t *fil_ptr;
4510       efdr_t *fil_end;
4511
4512       if (file_link->next == (vlinks_t *) NULL)
4513         fil_cnt = file_desc.objects_last_page;
4514       else
4515         fil_cnt = file_desc.objects_per_page;
4516       fil_ptr = file_link->datum->file;
4517       fil_end = fil_ptr + fil_cnt;
4518       for (; fil_ptr < fil_end; fil_ptr++)
4519         {
4520           long ss_cnt;
4521
4522           fil_ptr->fdr.issBase = iss;
4523           ss_cnt = ecoff_build_strings (buf, bufend, offset + iss,
4524                                         &fil_ptr->strings);
4525           fil_ptr->fdr.cbSs = ss_cnt;
4526           iss += ss_cnt;
4527         }
4528     }
4529
4530   return ecoff_padding_adjust (backend, buf, bufend, offset + iss,
4531                                (char **) NULL);
4532 }
4533
4534 /* Swap out the file descriptors.  */
4535
4536 static unsigned long
4537 ecoff_build_fdr (const struct ecoff_debug_swap *backend,
4538                  char **buf,
4539                  char **bufend,
4540                  unsigned long offset)
4541 {
4542   const bfd_size_type external_fdr_size = backend->external_fdr_size;
4543   void (* const swap_fdr_out) (bfd *, const FDR *, PTR)
4544     = backend->swap_fdr_out;
4545   long ifile;
4546   char *fdr_out;
4547   vlinks_t *file_link;
4548
4549   ifile = 0;
4550
4551   fdr_out = *buf + offset;
4552
4553   for (file_link = file_desc.first;
4554        file_link != (vlinks_t *) NULL;
4555        file_link = file_link->next)
4556     {
4557       int fil_cnt;
4558       efdr_t *fil_ptr;
4559       efdr_t *fil_end;
4560
4561       if (file_link->next == (vlinks_t *) NULL)
4562         fil_cnt = file_desc.objects_last_page;
4563       else
4564         fil_cnt = file_desc.objects_per_page;
4565       fil_ptr = file_link->datum->file;
4566       fil_end = fil_ptr + fil_cnt;
4567       for (; fil_ptr < fil_end; fil_ptr++)
4568         {
4569           if ((bfd_size_type)(*bufend - fdr_out) < external_fdr_size)
4570             fdr_out = ecoff_add_bytes (buf, bufend, fdr_out,
4571                                        external_fdr_size);
4572           (*swap_fdr_out) (stdoutput, &fil_ptr->fdr, fdr_out);
4573           fdr_out += external_fdr_size;
4574           ++ifile;
4575         }
4576     }
4577
4578   return offset + ifile * external_fdr_size;
4579 }
4580
4581 /* Set up the external symbols.  These are supposed to be handled by
4582    the backend.  This routine just gets the right information and
4583    calls a backend function to deal with it.  */
4584
4585 static void
4586 ecoff_setup_ext (void)
4587 {
4588   register symbolS *sym;
4589
4590   for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
4591     {
4592       if (symbol_get_obj (sym)->ecoff_symbol == NULL)
4593         continue;
4594
4595       /* If this is a local symbol, then force the fields to zero.  */
4596       if (! S_IS_EXTERNAL (sym)
4597           && ! S_IS_WEAK (sym)
4598           && S_IS_DEFINED (sym))
4599         {
4600           struct localsym *lsym;
4601
4602           lsym = symbol_get_obj (sym)->ecoff_symbol;
4603           lsym->ecoff_sym.asym.value = 0;
4604           lsym->ecoff_sym.asym.st = (int) st_Nil;
4605           lsym->ecoff_sym.asym.sc = (int) sc_Nil;
4606           lsym->ecoff_sym.asym.index = indexNil;
4607         }
4608
4609       obj_ecoff_set_ext (sym, &symbol_get_obj (sym)->ecoff_symbol->ecoff_sym);
4610     }
4611 }
4612
4613 /* Build the ECOFF debugging information.  */
4614
4615 unsigned long
4616 ecoff_build_debug (HDRR *hdr,
4617                    char **bufp,
4618                    const struct ecoff_debug_swap *backend)
4619 {
4620   const bfd_size_type external_pdr_size = backend->external_pdr_size;
4621   tag_t *ptag;
4622   tag_t *ptag_next;
4623   efdr_t *fil_ptr;
4624   int end_warning;
4625   efdr_t *hold_file_ptr;
4626   proc_t *hold_proc_ptr;
4627   symbolS *sym;
4628   char *buf;
4629   char *bufend;
4630   unsigned long offset;
4631
4632   /* Make sure we have a file.  */
4633   if (first_file == (efdr_t *) NULL)
4634     add_file ((const char *) NULL, 0, 1);
4635
4636   /* Handle any top level tags.  */
4637   for (ptag = top_tag_head->first_tag;
4638        ptag != (tag_t *) NULL;
4639        ptag = ptag_next)
4640     {
4641       if (ptag->forward_ref != (forward_t *) NULL)
4642         add_unknown_tag (ptag);
4643
4644       ptag_next = ptag->same_block;
4645       ptag->hash_ptr->tag_ptr = ptag->same_name;
4646       free_tag (ptag);
4647     }
4648
4649   free_thead (top_tag_head);
4650
4651   /* Look through the symbols.  Add debugging information for each
4652      symbol that has not already received it.  */
4653   hold_file_ptr = cur_file_ptr;
4654   hold_proc_ptr = cur_proc_ptr;
4655   cur_proc_ptr = (proc_t *) NULL;
4656   for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
4657     {
4658       if (symbol_get_obj (sym)->ecoff_symbol != NULL
4659           || symbol_get_obj (sym)->ecoff_file == (efdr_t *) NULL
4660           || (symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) != 0)
4661         continue;
4662
4663       cur_file_ptr = symbol_get_obj (sym)->ecoff_file;
4664       add_ecoff_symbol ((const char *) NULL, st_Nil, sc_Nil, sym,
4665                         (bfd_vma) 0, S_GET_VALUE (sym), indexNil);
4666     }
4667   cur_proc_ptr = hold_proc_ptr;
4668   cur_file_ptr = hold_file_ptr;
4669
4670   /* Output an ending symbol for all the files.  We have to do this
4671      here for the last file, so we may as well do it for all of the
4672      files.  */
4673   end_warning = 0;
4674   for (fil_ptr = first_file;
4675        fil_ptr != (efdr_t *) NULL;
4676        fil_ptr = fil_ptr->next_file)
4677     {
4678       cur_file_ptr = fil_ptr;
4679       while (cur_file_ptr->cur_scope != (scope_t *) NULL
4680              && cur_file_ptr->cur_scope->prev != (scope_t *) NULL)
4681         {
4682           cur_file_ptr->cur_scope = cur_file_ptr->cur_scope->prev;
4683           if (! end_warning && ! cur_file_ptr->fake)
4684             {
4685               as_warn (_("missing .end or .bend at end of file"));
4686               end_warning = 1;
4687             }
4688         }
4689       if (cur_file_ptr->cur_scope != (scope_t *) NULL)
4690         (void) add_ecoff_symbol ((const char *) NULL,
4691                                  st_End, sc_Text,
4692                                  (symbolS *) NULL,
4693                                  (bfd_vma) 0,
4694                                  (symint_t) 0,
4695                                  (symint_t) 0);
4696     }
4697
4698   /* Build the symbolic information.  */
4699   offset = 0;
4700   buf = xmalloc (PAGE_SIZE);
4701   bufend = buf + PAGE_SIZE;
4702
4703   /* Build the line number information.  */
4704   hdr->cbLineOffset = offset;
4705   offset = ecoff_build_lineno (backend, &buf, &bufend, offset,
4706                                &hdr->ilineMax);
4707   hdr->cbLine = offset - hdr->cbLineOffset;
4708
4709   /* We don't use dense numbers at all.  */
4710   hdr->idnMax = 0;
4711   hdr->cbDnOffset = 0;
4712
4713   /* We can't build the PDR table until we have built the symbols,
4714      because a PDR contains a symbol index.  However, we set aside
4715      space at this point.  */
4716   hdr->ipdMax = proc_cnt;
4717   hdr->cbPdOffset = offset;
4718   if ((bfd_size_type)(bufend - (buf + offset)) < proc_cnt * external_pdr_size)
4719     (void) ecoff_add_bytes (&buf, &bufend, buf + offset,
4720                             proc_cnt * external_pdr_size);
4721   offset += proc_cnt * external_pdr_size;
4722
4723   /* Build the local symbols.  */
4724   hdr->cbSymOffset = offset;
4725   offset = ecoff_build_symbols (backend, &buf, &bufend, offset);
4726   hdr->isymMax = (offset - hdr->cbSymOffset) / backend->external_sym_size;
4727
4728   /* Building the symbols initializes the symbol index in the PDR's.
4729      Now we can swap out the PDR's.  */
4730   (void) ecoff_build_procs (backend, &buf, &bufend, hdr->cbPdOffset);
4731
4732   /* We don't use optimization symbols.  */
4733   hdr->ioptMax = 0;
4734   hdr->cbOptOffset = 0;
4735
4736   /* Swap out the auxiliary type information.  */
4737   hdr->cbAuxOffset = offset;
4738   offset = ecoff_build_aux (backend, &buf, &bufend, offset);
4739   hdr->iauxMax = (offset - hdr->cbAuxOffset) / sizeof (union aux_ext);
4740
4741   /* Copy out the local strings.  */
4742   hdr->cbSsOffset = offset;
4743   offset = ecoff_build_ss (backend, &buf, &bufend, offset);
4744   hdr->issMax = offset - hdr->cbSsOffset;
4745
4746   /* We don't use relative file descriptors.  */
4747   hdr->crfd = 0;
4748   hdr->cbRfdOffset = 0;
4749
4750   /* Swap out the file descriptors.  */
4751   hdr->cbFdOffset = offset;
4752   offset = ecoff_build_fdr (backend, &buf, &bufend, offset);
4753   hdr->ifdMax = (offset - hdr->cbFdOffset) / backend->external_fdr_size;
4754
4755   /* Set up the external symbols, which are handled by the BFD back
4756      end.  */
4757   hdr->issExtMax = 0;
4758   hdr->cbSsExtOffset = 0;
4759   hdr->iextMax = 0;
4760   hdr->cbExtOffset = 0;
4761   ecoff_setup_ext ();
4762
4763   know ((offset & (backend->debug_align - 1)) == 0);
4764
4765   /* FIXME: This value should be determined from the .verstamp directive,
4766      with reasonable defaults in config files.  */
4767 #ifdef TC_ALPHA
4768   hdr->vstamp = 0x030b;
4769 #else
4770   hdr->vstamp = 0x020b;
4771 #endif
4772
4773   *bufp = buf;
4774   return offset;
4775 }
4776 \f
4777 /* Allocate a cluster of pages.  */
4778
4779 #ifndef MALLOC_CHECK
4780
4781 static page_type *
4782 allocate_cluster (unsigned long npages)
4783 {
4784   register page_type *value = (page_type *) xmalloc (npages * PAGE_USIZE);
4785
4786 #ifdef ECOFF_DEBUG
4787   if (debug > 3)
4788     fprintf (stderr, "\talloc\tnpages = %d, value = 0x%.8x\n", npages, value);
4789 #endif
4790
4791   memset (value, 0, npages * PAGE_USIZE);
4792
4793   return value;
4794 }
4795
4796 static page_type *cluster_ptr = NULL;
4797 static unsigned long pages_left = 0;
4798
4799 #endif /* MALLOC_CHECK */
4800
4801 /* Allocate one page (which is initialized to 0).  */
4802
4803 static page_type *
4804 allocate_page (void)
4805 {
4806 #ifndef MALLOC_CHECK
4807
4808   if (pages_left == 0)
4809     {
4810       pages_left = MAX_CLUSTER_PAGES;
4811       cluster_ptr = allocate_cluster (pages_left);
4812     }
4813
4814   pages_left--;
4815   return cluster_ptr++;
4816
4817 #else /* MALLOC_CHECK */
4818
4819   page_type *ptr;
4820
4821   ptr = xmalloc (PAGE_USIZE);
4822   memset (ptr, 0, PAGE_USIZE);
4823   return ptr;
4824
4825 #endif /* MALLOC_CHECK */
4826 }
4827 \f
4828 /* Allocate scoping information.  */
4829
4830 static scope_t *
4831 allocate_scope (void)
4832 {
4833   register scope_t *ptr;
4834   static scope_t initial_scope;
4835
4836 #ifndef MALLOC_CHECK
4837
4838   ptr = alloc_counts[(int) alloc_type_scope].free_list.f_scope;
4839   if (ptr != (scope_t *) NULL)
4840     alloc_counts[(int) alloc_type_scope].free_list.f_scope = ptr->free;
4841   else
4842     {
4843       register int unallocated  = alloc_counts[(int) alloc_type_scope].unallocated;
4844       register page_type *cur_page      = alloc_counts[(int) alloc_type_scope].cur_page;
4845
4846       if (unallocated == 0)
4847         {
4848           unallocated = PAGE_SIZE / sizeof (scope_t);
4849           alloc_counts[(int) alloc_type_scope].cur_page = cur_page = allocate_page ();
4850           alloc_counts[(int) alloc_type_scope].total_pages++;
4851         }
4852
4853       ptr = &cur_page->scope[--unallocated];
4854       alloc_counts[(int) alloc_type_scope].unallocated = unallocated;
4855     }
4856
4857 #else
4858
4859   ptr = (scope_t *) xmalloc (sizeof (scope_t));
4860
4861 #endif
4862
4863   alloc_counts[(int) alloc_type_scope].total_alloc++;
4864   *ptr = initial_scope;
4865   return ptr;
4866 }
4867
4868 /* Free scoping information.  */
4869
4870 static void
4871 free_scope (scope_t *ptr)
4872 {
4873   alloc_counts[(int) alloc_type_scope].total_free++;
4874
4875 #ifndef MALLOC_CHECK
4876   ptr->free = alloc_counts[(int) alloc_type_scope].free_list.f_scope;
4877   alloc_counts[(int) alloc_type_scope].free_list.f_scope = ptr;
4878 #else
4879   free ((PTR) ptr);
4880 #endif
4881 }
4882 \f
4883 /* Allocate links for pages in a virtual array.  */
4884
4885 static vlinks_t *
4886 allocate_vlinks (void)
4887 {
4888   register vlinks_t *ptr;
4889   static vlinks_t initial_vlinks;
4890
4891 #ifndef MALLOC_CHECK
4892
4893   register int unallocated = alloc_counts[(int) alloc_type_vlinks].unallocated;
4894   register page_type *cur_page = alloc_counts[(int) alloc_type_vlinks].cur_page;
4895
4896   if (unallocated == 0)
4897     {
4898       unallocated = PAGE_SIZE / sizeof (vlinks_t);
4899       alloc_counts[(int) alloc_type_vlinks].cur_page = cur_page = allocate_page ();
4900       alloc_counts[(int) alloc_type_vlinks].total_pages++;
4901     }
4902
4903   ptr = &cur_page->vlinks[--unallocated];
4904   alloc_counts[(int) alloc_type_vlinks].unallocated = unallocated;
4905
4906 #else
4907
4908   ptr = (vlinks_t *) xmalloc (sizeof (vlinks_t));
4909
4910 #endif
4911
4912   alloc_counts[(int) alloc_type_vlinks].total_alloc++;
4913   *ptr = initial_vlinks;
4914   return ptr;
4915 }
4916 \f
4917 /* Allocate string hash buckets.  */
4918
4919 static shash_t *
4920 allocate_shash (void)
4921 {
4922   register shash_t *ptr;
4923   static shash_t initial_shash;
4924
4925 #ifndef MALLOC_CHECK
4926
4927   register int unallocated = alloc_counts[(int) alloc_type_shash].unallocated;
4928   register page_type *cur_page = alloc_counts[(int) alloc_type_shash].cur_page;
4929
4930   if (unallocated == 0)
4931     {
4932       unallocated = PAGE_SIZE / sizeof (shash_t);
4933       alloc_counts[(int) alloc_type_shash].cur_page = cur_page = allocate_page ();
4934       alloc_counts[(int) alloc_type_shash].total_pages++;
4935     }
4936
4937   ptr = &cur_page->shash[--unallocated];
4938   alloc_counts[(int) alloc_type_shash].unallocated = unallocated;
4939
4940 #else
4941
4942   ptr = (shash_t *) xmalloc (sizeof (shash_t));
4943
4944 #endif
4945
4946   alloc_counts[(int) alloc_type_shash].total_alloc++;
4947   *ptr = initial_shash;
4948   return ptr;
4949 }
4950 \f
4951 /* Allocate type hash buckets.  */
4952
4953 static thash_t *
4954 allocate_thash (void)
4955 {
4956   register thash_t *ptr;
4957   static thash_t initial_thash;
4958
4959 #ifndef MALLOC_CHECK
4960
4961   register int unallocated = alloc_counts[(int) alloc_type_thash].unallocated;
4962   register page_type *cur_page = alloc_counts[(int) alloc_type_thash].cur_page;
4963
4964   if (unallocated == 0)
4965     {
4966       unallocated = PAGE_SIZE / sizeof (thash_t);
4967       alloc_counts[(int) alloc_type_thash].cur_page = cur_page = allocate_page ();
4968       alloc_counts[(int) alloc_type_thash].total_pages++;
4969     }
4970
4971   ptr = &cur_page->thash[--unallocated];
4972   alloc_counts[(int) alloc_type_thash].unallocated = unallocated;
4973
4974 #else
4975
4976   ptr = (thash_t *) xmalloc (sizeof (thash_t));
4977
4978 #endif
4979
4980   alloc_counts[(int) alloc_type_thash].total_alloc++;
4981   *ptr = initial_thash;
4982   return ptr;
4983 }
4984 \f
4985 /* Allocate structure, union, or enum tag information.  */
4986
4987 static tag_t *
4988 allocate_tag (void)
4989 {
4990   register tag_t *ptr;
4991   static tag_t initial_tag;
4992
4993 #ifndef MALLOC_CHECK
4994
4995   ptr = alloc_counts[(int) alloc_type_tag].free_list.f_tag;
4996   if (ptr != (tag_t *) NULL)
4997     alloc_counts[(int) alloc_type_tag].free_list.f_tag = ptr->free;
4998   else
4999     {
5000       register int unallocated = alloc_counts[(int) alloc_type_tag].unallocated;
5001       register page_type *cur_page = alloc_counts[(int) alloc_type_tag].cur_page;
5002
5003       if (unallocated == 0)
5004         {
5005           unallocated = PAGE_SIZE / sizeof (tag_t);
5006           alloc_counts[(int) alloc_type_tag].cur_page = cur_page = allocate_page ();
5007           alloc_counts[(int) alloc_type_tag].total_pages++;
5008         }
5009
5010       ptr = &cur_page->tag[--unallocated];
5011       alloc_counts[(int) alloc_type_tag].unallocated = unallocated;
5012     }
5013
5014 #else
5015
5016   ptr = (tag_t *) xmalloc (sizeof (tag_t));
5017
5018 #endif
5019
5020   alloc_counts[(int) alloc_type_tag].total_alloc++;
5021   *ptr = initial_tag;
5022   return ptr;
5023 }
5024
5025 /* Free scoping information.  */
5026
5027 static void
5028 free_tag (tag_t *ptr)
5029 {
5030   alloc_counts[(int) alloc_type_tag].total_free++;
5031
5032 #ifndef MALLOC_CHECK
5033   ptr->free = alloc_counts[(int) alloc_type_tag].free_list.f_tag;
5034   alloc_counts[(int) alloc_type_tag].free_list.f_tag = ptr;
5035 #else
5036   free ((PTR_T) ptr);
5037 #endif
5038 }
5039 \f
5040 /* Allocate forward reference to a yet unknown tag.  */
5041
5042 static forward_t *
5043 allocate_forward (void)
5044 {
5045   register forward_t *ptr;
5046   static forward_t initial_forward;
5047
5048 #ifndef MALLOC_CHECK
5049
5050   register int unallocated = alloc_counts[(int) alloc_type_forward].unallocated;
5051   register page_type *cur_page = alloc_counts[(int) alloc_type_forward].cur_page;
5052
5053   if (unallocated == 0)
5054     {
5055       unallocated = PAGE_SIZE / sizeof (forward_t);
5056       alloc_counts[(int) alloc_type_forward].cur_page = cur_page = allocate_page ();
5057       alloc_counts[(int) alloc_type_forward].total_pages++;
5058     }
5059
5060   ptr = &cur_page->forward[--unallocated];
5061   alloc_counts[(int) alloc_type_forward].unallocated = unallocated;
5062
5063 #else
5064
5065   ptr = (forward_t *) xmalloc (sizeof (forward_t));
5066
5067 #endif
5068
5069   alloc_counts[(int) alloc_type_forward].total_alloc++;
5070   *ptr = initial_forward;
5071   return ptr;
5072 }
5073 \f
5074 /* Allocate head of type hash list.  */
5075
5076 static thead_t *
5077 allocate_thead (void)
5078 {
5079   register thead_t *ptr;
5080   static thead_t initial_thead;
5081
5082 #ifndef MALLOC_CHECK
5083
5084   ptr = alloc_counts[(int) alloc_type_thead].free_list.f_thead;
5085   if (ptr != (thead_t *) NULL)
5086     alloc_counts[(int) alloc_type_thead].free_list.f_thead = ptr->free;
5087   else
5088     {
5089       register int unallocated = alloc_counts[(int) alloc_type_thead].unallocated;
5090       register page_type *cur_page = alloc_counts[(int) alloc_type_thead].cur_page;
5091
5092       if (unallocated == 0)
5093         {
5094           unallocated = PAGE_SIZE / sizeof (thead_t);
5095           alloc_counts[(int) alloc_type_thead].cur_page = cur_page = allocate_page ();
5096           alloc_counts[(int) alloc_type_thead].total_pages++;
5097         }
5098
5099       ptr = &cur_page->thead[--unallocated];
5100       alloc_counts[(int) alloc_type_thead].unallocated = unallocated;
5101     }
5102
5103 #else
5104
5105   ptr = (thead_t *) xmalloc (sizeof (thead_t));
5106
5107 #endif
5108
5109   alloc_counts[(int) alloc_type_thead].total_alloc++;
5110   *ptr = initial_thead;
5111   return ptr;
5112 }
5113
5114 /* Free scoping information.  */
5115
5116 static void
5117 free_thead (thead_t *ptr)
5118 {
5119   alloc_counts[(int) alloc_type_thead].total_free++;
5120
5121 #ifndef MALLOC_CHECK
5122   ptr->free = (thead_t *) alloc_counts[(int) alloc_type_thead].free_list.f_thead;
5123   alloc_counts[(int) alloc_type_thead].free_list.f_thead = ptr;
5124 #else
5125   free ((PTR_T) ptr);
5126 #endif
5127 }
5128 \f
5129 static lineno_list_t *
5130 allocate_lineno_list (void)
5131 {
5132   register lineno_list_t *ptr;
5133   static lineno_list_t initial_lineno_list;
5134
5135 #ifndef MALLOC_CHECK
5136
5137   register int unallocated = alloc_counts[(int) alloc_type_lineno].unallocated;
5138   register page_type *cur_page = alloc_counts[(int) alloc_type_lineno].cur_page;
5139
5140   if (unallocated == 0)
5141     {
5142       unallocated = PAGE_SIZE / sizeof (lineno_list_t);
5143       alloc_counts[(int) alloc_type_lineno].cur_page = cur_page = allocate_page ();
5144       alloc_counts[(int) alloc_type_lineno].total_pages++;
5145     }
5146
5147   ptr = &cur_page->lineno[--unallocated];
5148   alloc_counts[(int) alloc_type_lineno].unallocated = unallocated;
5149
5150 #else
5151
5152   ptr = (lineno_list_t *) xmalloc (sizeof (lineno_list_t));
5153
5154 #endif
5155
5156   alloc_counts[(int) alloc_type_lineno].total_alloc++;
5157   *ptr = initial_lineno_list;
5158   return ptr;
5159 }
5160
5161 void
5162 ecoff_set_gp_prolog_size (int sz)
5163 {
5164   if (cur_proc_ptr == 0)
5165     return;
5166
5167   cur_proc_ptr->pdr.gp_prologue = sz;
5168   if (cur_proc_ptr->pdr.gp_prologue != sz)
5169     {
5170       as_warn (_("GP prologue size exceeds field size, using 0 instead"));
5171       cur_proc_ptr->pdr.gp_prologue = 0;
5172     }
5173
5174   cur_proc_ptr->pdr.gp_used = 1;
5175 }
5176
5177 int
5178 ecoff_no_current_file (void)
5179 {
5180   return cur_file_ptr == (efdr_t *) NULL;
5181 }
5182
5183 void
5184 ecoff_generate_asm_lineno (void)
5185 {
5186   unsigned int lineno;
5187   char *filename;
5188   lineno_list_t *list;
5189
5190   as_where (&filename, &lineno);
5191
5192   if (current_stabs_filename == (char *) NULL
5193       || strcmp (current_stabs_filename, filename))
5194     add_file (filename, 0, 1);
5195
5196   list = allocate_lineno_list ();
5197
5198   list->next = (lineno_list_t *) NULL;
5199   list->file = cur_file_ptr;
5200   list->proc = cur_proc_ptr;
5201   list->frag = frag_now;
5202   list->paddr = frag_now_fix ();
5203   list->lineno = lineno;
5204
5205   /* We don't want to merge files which have line numbers.  */
5206   cur_file_ptr->fdr.fMerge = 0;
5207
5208   /* A .loc directive will sometimes appear before a .ent directive,
5209      which means that cur_proc_ptr will be NULL here.  Arrange to
5210      patch this up.  */
5211   if (cur_proc_ptr == (proc_t *) NULL)
5212     {
5213       lineno_list_t **pl;
5214
5215       pl = &noproc_lineno;
5216       while (*pl != (lineno_list_t *) NULL)
5217         pl = &(*pl)->next;
5218       *pl = list;
5219     }
5220   else
5221     {
5222       last_lineno = list;
5223       *last_lineno_ptr = list;
5224       last_lineno_ptr = &list->next;
5225     }
5226 }
5227
5228 #else
5229
5230 void
5231 ecoff_generate_asm_lineno (void)
5232 {
5233 }
5234
5235 #endif /* ECOFF_DEBUGGING */