gas/ecoff.c

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