gas/ecoff.c

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