gas/ecoff.c

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