gas/ecoff.c

   1 /* ECOFF debugging support.
   2    Copyright (C) 1993, 94, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.
   4    This file was put together by Ian Lance Taylor <ian@cygnus.com>.  A
   5    good deal of it comes directly from mips-tfile.c, by Michael
   6    Meissner <meissner@osf.org>.
   7
   8    This file is part of GAS.
   9
  10    GAS is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2, or (at your option)
  13    any later version.
  14
  15    GAS is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with GAS; see the file COPYING.  If not, write to the Free
  22    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  23    02111-1307, USA.  */
  24
  25 #include "as.h"
  26
  27 /* This file is compiled conditionally for those targets which use
  28    ECOFF debugging information (e.g., MIPS ECOFF, MIPS ELF, Alpha
  29    ECOFF).  */
  30
  31 #include "ecoff.h"
  32
  33 #ifdef ECOFF_DEBUGGING
  34
  35 #include "coff/internal.h"
  36 #include "coff/symconst.h"
  37 #include "aout/stab_gnu.h"
  38
  39 #include <ctype.h>
  40
  41 /* Why isn't this in coff/sym.h?  */
  42 #define ST_RFDESCAPE 0xfff
  43
  44 /* This file constructs the information used by the ECOFF debugging
  45    format.  It just builds a large block of data.
  46
  47    We support both ECOFF style debugging and stabs debugging (the
  48    stabs symbols are encapsulated in ECOFF symbols).  This should let
  49    us handle anything the compiler might throw at us.  */
  50
  51 /* Here is a brief description of the MIPS ECOFF symbol table, by
  52    Michael Meissner.  The MIPS symbol table has the following pieces:
  53
  54         Symbolic Header
  55             |
  56             +-- Auxiliary Symbols
  57             |
  58             +-- Dense number table
  59             |
  60             +-- Optimizer Symbols
  61             |
  62             +-- External Strings
  63             |
  64             +-- External Symbols
  65             |
  66             +-- Relative file descriptors
  67             |
  68             +-- File table
  69                     |
  70                     +-- Procedure table
  71                     |
  72                     +-- Line number table
  73                     |
  74                     +-- Local Strings
  75                     |
  76                     +-- Local Symbols
  77
  78    The symbolic header points to each of the other tables, and also
  79    contains the number of entries.  It also contains a magic number
  80    and MIPS compiler version number, such as 2.0.
  81
  82    The auxiliary table is a series of 32 bit integers, that are
  83    referenced as needed from the local symbol table.  Unlike standard
  84    COFF, the aux.  information does not follow the symbol that uses
  85    it, but rather is a separate table.  In theory, this would allow
  86    the MIPS compilers to collapse duplicate aux. entries, but I've not
  87    noticed this happening with the 1.31 compiler suite.  The different
  88    types of aux. entries are:
  89
  90     1)  dnLow: Low bound on array dimension.
  91
  92     2)  dnHigh: High bound on array dimension.
  93
  94     3)  isym: Index to the local symbol which is the start of the
  95         function for the end of function first aux. entry.
  96
  97     4)  width: Width of structures and bitfields.
  98
  99     5)  count: Count of ranges for variant part.
 100
 101     6)  rndx: A relative index into the symbol table.  The relative
 102         index field has two parts: rfd which is a pointer into the
 103         relative file index table or ST_RFDESCAPE which says the next
 104         aux. entry is the file number, and index: which is the pointer
 105         into the local symbol within a given file table.  This is for
 106         things like references to types defined in another file.
 107
 108     7)  Type information: This is like the COFF type bits, except it
 109         is 32 bits instead of 16; they still have room to add new
 110         basic types; and they can handle more than 6 levels of array,
 111         pointer, function, etc.  Each type information field contains
 112         the following structure members:
 113
 114             a)  fBitfield: a bit that says this is a bitfield, and the
 115                 size in bits follows as the next aux. entry.
 116
 117             b)  continued: a bit that says the next aux. entry is a
 118                 continuation of the current type information (in case
 119                 there are more than 6 levels of array/ptr/function).
 120
 121             c)  bt: an integer containing the base type before adding
 122                 array, pointer, function, etc. qualifiers.  The
 123                 current base types that I have documentation for are:
 124
 125                         btNil           -- undefined
 126                         btAdr           -- address - integer same size as ptr
 127                         btChar          -- character
 128                         btUChar         -- unsigned character
 129                         btShort         -- short
 130                         btUShort        -- unsigned short
 131                         btInt           -- int
 132                         btUInt          -- unsigned int
 133                         btLong          -- long
 134                         btULong         -- unsigned long
 135                         btFloat         -- float (real)
 136                         btDouble        -- Double (real)
 137                         btStruct        -- Structure (Record)
 138                         btUnion         -- Union (variant)
 139                         btEnum          -- Enumerated
 140                         btTypedef       -- defined via a typedef isymRef
 141                         btRange         -- subrange of int
 142                         btSet           -- pascal sets
 143                         btComplex       -- fortran complex
 144                         btDComplex      -- fortran double complex
 145                         btIndirect      -- forward or unnamed typedef
 146                         btFixedDec      -- Fixed Decimal
 147                         btFloatDec      -- Float Decimal
 148                         btString        -- Varying Length Character String
 149                         btBit           -- Aligned Bit String
 150                         btPicture       -- Picture
 151                         btVoid          -- Void (MIPS cc revision >= 2.00)
 152
 153             d)  tq0 - tq5: type qualifier fields as needed.  The
 154                 current type qualifier fields I have documentation for
 155                 are:
 156
 157                         tqNil           -- no more qualifiers
 158                         tqPtr           -- pointer
 159                         tqProc          -- procedure
 160                         tqArray         -- array
 161                         tqFar           -- 8086 far pointers
 162                         tqVol           -- volatile
 163
 164    The dense number table is used in the front ends, and disappears by
 165    the time the .o is created.
 166
 167    With the 1.31 compiler suite, the optimization symbols don't seem
 168    to be used as far as I can tell.
 169
 170    The linker is the first entity that creates the relative file
 171    descriptor table, and I believe it is used so that the individual
 172    file table pointers don't have to be rewritten when the objects are
 173    merged together into the program file.
 174
 175    Unlike COFF, the basic symbol & string tables are split into
 176    external and local symbols/strings.  The relocation information
 177    only goes off of the external symbol table, and the debug
 178    information only goes off of the internal symbol table.  The
 179    external symbols can have links to an appropriate file index and
 180    symbol within the file to give it the appropriate type information.
 181    Because of this, the external symbols are actually larger than the
 182    internal symbols (to contain the link information), and contain the
 183    local symbol structure as a member, though this member is not the
 184    first member of the external symbol structure (!).  I suspect this
 185    split is to make strip easier to deal with.
 186
 187    Each file table has offsets for where the line numbers, local
 188    strings, local symbols, and procedure table starts from within the
 189    global tables, and the indexs are reset to 0 for each of those
 190    tables for the file.
 191
 192    The procedure table contains the binary equivalents of the .ent
 193    (start of the function address), .frame (what register is the
 194    virtual frame pointer, constant offset from the register to obtain
 195    the VFP, and what register holds the return address), .mask/.fmask
 196    (bitmask of saved registers, and where the first register is stored
 197    relative to the VFP) assembler directives.  It also contains the
 198    low and high bounds of the line numbers if debugging is turned on.
 199
 200    The line number table is a compressed form of the normal COFF line
 201    table.  Each line number entry is either 1 or 3 bytes long, and
 202    contains a signed delta from the previous line, and an unsigned
 203    count of the number of instructions this statement takes.
 204
 205    The local symbol table contains the following fields:
 206
 207     1)  iss: index to the local string table giving the name of the
 208         symbol.
 209
 210     2)  value: value of the symbol (address, register number, etc.).
 211
 212     3)  st: symbol type.  The current symbol types are:
 213
 214             stNil         -- Nuthin' special
 215             stGlobal      -- external symbol
 216             stStatic      -- static
 217             stParam       -- procedure argument
 218             stLocal       -- local variable
 219             stLabel       -- label
 220             stProc        -- External Procedure
 221             stBlock       -- beginning of block
 222             stEnd         -- end (of anything)
 223             stMember      -- member (of anything)
 224             stTypedef     -- type definition
 225             stFile        -- file name
 226             stRegReloc    -- register relocation
 227             stForward     -- forwarding address
 228             stStaticProc  -- Static procedure
 229             stConstant    -- const
 230
 231     4)  sc: storage class.  The current storage classes are:
 232
 233             scText        -- text symbol
 234             scData        -- initialized data symbol
 235             scBss         -- un-initialized data symbol
 236             scRegister    -- value of symbol is register number
 237             scAbs         -- value of symbol is absolute
 238             scUndefined   -- who knows?
 239             scCdbLocal    -- variable's value is IN se->va.??
 240             scBits        -- this is a bit field
 241             scCdbSystem   -- value is IN debugger's address space
 242             scRegImage    -- register value saved on stack
 243             scInfo        -- symbol contains debugger information
 244             scUserStruct  -- addr in struct user for current process
 245             scSData       -- load time only small data
 246             scSBss        -- load time only small common
 247             scRData       -- load time only read only data
 248             scVar         -- Var parameter (fortranpascal)
 249             scCommon      -- common variable
 250             scSCommon     -- small common
 251             scVarRegister -- Var parameter in a register
 252             scVariant     -- Variant record
 253             scSUndefined  -- small undefined(external) data
 254             scInit        -- .init section symbol
 255
 256     5)  index: pointer to a local symbol or aux. entry.
 257
 258    For the following program:
 259
 260         #include <stdio.h>
 261
 262         main(){
 263                 printf("Hello World!\n");
 264                 return 0;
 265         }
 266
 267    Mips-tdump produces the following information:
 268
 269    Global file header:
 270        magic number             0x162
 271        # sections               2
 272        timestamp                645311799, Wed Jun 13 17:16:39 1990
 273        symbolic header offset   284
 274        symbolic header size     96
 275        optional header          56
 276        flags                    0x0
 277
 278    Symbolic header, magic number = 0x7009, vstamp = 1.31:
 279
 280        Info                      Offset      Number       Bytes
 281        ====                      ======      ======      =====
 282
 283        Line numbers                 380           4           4 [13]
 284        Dense numbers                  0           0           0
 285        Procedures Tables            384           1          52
 286        Local Symbols                436          16         192
 287        Optimization Symbols           0           0           0
 288        Auxiliary Symbols            628          39         156
 289        Local Strings                784          80          80
 290        External Strings             864         144         144
 291        File Tables                 1008           2         144
 292        Relative Files                 0           0           0
 293        External Symbols            1152          20         320
 294
 295    File #0, "hello2.c"
 296
 297        Name index  = 1          Readin      = No
 298        Merge       = No         Endian      = LITTLE
 299        Debug level = G2         Language    = C
 300        Adr         = 0x00000000
 301
 302        Info                       Start      Number        Size      Offset
 303        ====                       =====      ======        ====      ======
 304        Local strings                  0          15          15         784
 305        Local symbols                  0           6          72         436
 306        Line numbers                   0          13          13         380
 307        Optimization symbols           0           0           0           0
 308        Procedures                     0           1          52         384
 309        Auxiliary symbols              0          14          56         628
 310        Relative Files                 0           0           0           0
 311
 312     There are 6 local symbols, starting at 436
 313
 314         Symbol# 0: "hello2.c"
 315             End+1 symbol  = 6
 316             String index  = 1
 317             Storage class = Text        Index  = 6
 318             Symbol type   = File        Value  = 0
 319
 320         Symbol# 1: "main"
 321             End+1 symbol  = 5
 322             Type          = int
 323             String index  = 10
 324             Storage class = Text        Index  = 12
 325             Symbol type   = Proc        Value  = 0
 326
 327         Symbol# 2: ""
 328             End+1 symbol  = 4
 329             String index  = 0
 330             Storage class = Text        Index  = 4
 331             Symbol type   = Block       Value  = 8
 332
 333         Symbol# 3: ""
 334             First symbol  = 2
 335             String index  = 0
 336             Storage class = Text        Index  = 2
 337             Symbol type   = End         Value  = 28
 338
 339         Symbol# 4: "main"
 340             First symbol  = 1
 341             String index  = 10
 342             Storage class = Text        Index  = 1
 343             Symbol type   = End         Value  = 52
 344
 345         Symbol# 5: "hello2.c"
 346             First symbol  = 0
 347             String index  = 1
 348             Storage class = Text        Index  = 0
 349             Symbol type   = End         Value  = 0
 350
 351     There are 14 auxiliary table entries, starting at 628.
 352
 353         * #0               0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 354         * #1              24, [  24/      0], [ 6 0:0 0:0:0:0:0:0]
 355         * #2               8, [   8/      0], [ 2 0:0 0:0:0:0:0:0]
 356         * #3              16, [  16/      0], [ 4 0:0 0:0:0:0:0:0]
 357         * #4              24, [  24/      0], [ 6 0:0 0:0:0:0:0:0]
 358         * #5              32, [  32/      0], [ 8 0:0 0:0:0:0:0:0]
 359         * #6              40, [  40/      0], [10 0:0 0:0:0:0:0:0]
 360         * #7              44, [  44/      0], [11 0:0 0:0:0:0:0:0]
 361         * #8              12, [  12/      0], [ 3 0:0 0:0:0:0:0:0]
 362         * #9              20, [  20/      0], [ 5 0:0 0:0:0:0:0:0]
 363         * #10             28, [  28/      0], [ 7 0:0 0:0:0:0:0:0]
 364         * #11             36, [  36/      0], [ 9 0:0 0:0:0:0:0:0]
 365           #12              5, [   5/      0], [ 1 1:0 0:0:0:0:0:0]
 366           #13             24, [  24/      0], [ 6 0:0 0:0:0:0:0:0]
 367
 368     There are 1 procedure descriptor entries, starting at 0.
 369
 370         Procedure descriptor 0:
 371             Name index   = 10          Name          = "main"
 372             .mask 0x80000000,-4        .fmask 0x00000000,0
 373             .frame $29,24,$31
 374             Opt. start   = -1          Symbols start = 1
 375             First line # = 3           Last line #   = 6
 376             Line Offset  = 0           Address       = 0x00000000
 377
 378         There are 4 bytes holding line numbers, starting at 380.
 379             Line           3,   delta     0,   count  2
 380             Line           4,   delta     1,   count  3
 381             Line           5,   delta     1,   count  2
 382             Line           6,   delta     1,   count  6
 383
 384    File #1, "/usr/include/stdio.h"
 385
 386     Name index  = 1          Readin      = No
 387     Merge       = Yes        Endian      = LITTLE
 388     Debug level = G2         Language    = C
 389     Adr         = 0x00000000
 390
 391     Info                       Start      Number        Size      Offset
 392     ====                       =====      ======        ====      ======
 393     Local strings                 15          65          65         799
 394     Local symbols                  6          10         120         508
 395     Line numbers                   0           0           0         380
 396     Optimization symbols           0           0           0           0
 397     Procedures                     1           0           0         436
 398     Auxiliary symbols             14          25         100         684
 399     Relative Files                 0           0           0           0
 400
 401     There are 10 local symbols, starting at 442
 402
 403         Symbol# 0: "/usr/include/stdio.h"
 404             End+1 symbol  = 10
 405             String index  = 1
 406             Storage class = Text        Index  = 10
 407             Symbol type   = File        Value  = 0
 408
 409         Symbol# 1: "_iobuf"
 410             End+1 symbol  = 9
 411             String index  = 22
 412             Storage class = Info        Index  = 9
 413             Symbol type   = Block       Value  = 20
 414
 415         Symbol# 2: "_cnt"
 416             Type          = int
 417             String index  = 29
 418             Storage class = Info        Index  = 4
 419             Symbol type   = Member      Value  = 0
 420
 421         Symbol# 3: "_ptr"
 422             Type          = ptr to char
 423             String index  = 34
 424             Storage class = Info        Index  = 15
 425             Symbol type   = Member      Value  = 32
 426
 427         Symbol# 4: "_base"
 428             Type          = ptr to char
 429             String index  = 39
 430             Storage class = Info        Index  = 16
 431             Symbol type   = Member      Value  = 64
 432
 433         Symbol# 5: "_bufsiz"
 434             Type          = int
 435             String index  = 45
 436             Storage class = Info        Index  = 4
 437             Symbol type   = Member      Value  = 96
 438
 439         Symbol# 6: "_flag"
 440             Type          = short
 441             String index  = 53
 442             Storage class = Info        Index  = 3
 443             Symbol type   = Member      Value  = 128
 444
 445         Symbol# 7: "_file"
 446             Type          = char
 447             String index  = 59
 448             Storage class = Info        Index  = 2
 449             Symbol type   = Member      Value  = 144
 450
 451         Symbol# 8: ""
 452             First symbol  = 1
 453             String index  = 0
 454             Storage class = Info        Index  = 1
 455             Symbol type   = End         Value  = 0
 456
 457         Symbol# 9: "/usr/include/stdio.h"
 458             First symbol  = 0
 459             String index  = 1
 460             Storage class = Text        Index  = 0
 461             Symbol type   = End         Value  = 0
 462
 463     There are 25 auxiliary table entries, starting at 642.
 464
 465         * #14             -1, [4095/1048575], [63 1:1 f:f:f:f:f:f]
 466           #15          65544, [   8/     16], [ 2 0:0 1:0:0:0:0:0]
 467           #16          65544, [   8/     16], [ 2 0:0 1:0:0:0:0:0]
 468         * #17         196656, [  48/     48], [12 0:0 3:0:0:0:0:0]
 469         * #18           8191, [4095/      1], [63 1:1 0:0:0:0:f:1]
 470         * #19              1, [   1/      0], [ 0 1:0 0:0:0:0:0:0]
 471         * #20          20479, [4095/      4], [63 1:1 0:0:0:0:f:4]
 472         * #21              1, [   1/      0], [ 0 1:0 0:0:0:0:0:0]
 473         * #22              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 474         * #23              2, [   2/      0], [ 0 0:1 0:0:0:0:0:0]
 475         * #24            160, [ 160/      0], [40 0:0 0:0:0:0:0:0]
 476         * #25              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 477         * #26              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 478         * #27              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 479         * #28              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 480         * #29              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 481         * #30              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 482         * #31              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 483         * #32              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 484         * #33              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 485         * #34              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 486         * #35              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 487         * #36              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 488         * #37              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 489         * #38              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
 490
 491     There are 0 procedure descriptor entries, starting at 1.
 492
 493    There are 20 external symbols, starting at 1152
 494
 495         Symbol# 0: "_iob"
 496             Type          = array [3 {160}] of struct _iobuf { ifd = 1, index = 1 }
 497             String index  = 0           Ifd    = 1
 498             Storage class = Nil         Index  = 17
 499             Symbol type   = Global      Value  = 60
 500
 501         Symbol# 1: "fopen"
 502             String index  = 5           Ifd    = 1
 503             Storage class = Nil         Index  = 1048575
 504             Symbol type   = Proc        Value  = 0
 505
 506         Symbol# 2: "fdopen"
 507             String index  = 11          Ifd    = 1
 508             Storage class = Nil         Index  = 1048575
 509             Symbol type   = Proc        Value  = 0
 510
 511         Symbol# 3: "freopen"
 512             String index  = 18          Ifd    = 1
 513             Storage class = Nil         Index  = 1048575
 514             Symbol type   = Proc        Value  = 0
 515
 516         Symbol# 4: "popen"
 517             String index  = 26          Ifd    = 1
 518             Storage class = Nil         Index  = 1048575
 519             Symbol type   = Proc        Value  = 0
 520
 521         Symbol# 5: "tmpfile"
 522             String index  = 32          Ifd    = 1
 523             Storage class = Nil         Index  = 1048575
 524             Symbol type   = Proc        Value  = 0
 525
 526         Symbol# 6: "ftell"
 527             String index  = 40          Ifd    = 1
 528             Storage class = Nil         Index  = 1048575
 529             Symbol type   = Proc        Value  = 0
 530
 531         Symbol# 7: "rewind"
 532             String index  = 46          Ifd    = 1
 533             Storage class = Nil         Index  = 1048575
 534             Symbol type   = Proc        Value  = 0
 535
 536         Symbol# 8: "setbuf"
 537             String index  = 53          Ifd    = 1
 538             Storage class = Nil         Index  = 1048575
 539             Symbol type   = Proc        Value  = 0
 540
 541         Symbol# 9: "setbuffer"
 542             String index  = 60          Ifd    = 1
 543             Storage class = Nil         Index  = 1048575
 544             Symbol type   = Proc        Value  = 0
 545
 546         Symbol# 10: "setlinebuf"
 547             String index  = 70          Ifd    = 1
 548             Storage class = Nil         Index  = 1048575
 549             Symbol type   = Proc        Value  = 0
 550
 551         Symbol# 11: "fgets"
 552             String index  = 81          Ifd    = 1
 553             Storage class = Nil         Index  = 1048575
 554             Symbol type   = Proc        Value  = 0
 555
 556         Symbol# 12: "gets"
 557             String index  = 87          Ifd    = 1
 558             Storage class = Nil         Index  = 1048575
 559             Symbol type   = Proc        Value  = 0
 560
 561         Symbol# 13: "ctermid"
 562             String index  = 92          Ifd    = 1
 563             Storage class = Nil         Index  = 1048575
 564             Symbol type   = Proc        Value  = 0
 565
 566         Symbol# 14: "cuserid"
 567             String index  = 100         Ifd    = 1
 568             Storage class = Nil         Index  = 1048575
 569             Symbol type   = Proc        Value  = 0
 570
 571         Symbol# 15: "tempnam"
 572             String index  = 108         Ifd    = 1
 573             Storage class = Nil         Index  = 1048575
 574             Symbol type   = Proc        Value  = 0
 575
 576         Symbol# 16: "tmpnam"
 577             String index  = 116         Ifd    = 1
 578             Storage class = Nil         Index  = 1048575
 579             Symbol type   = Proc        Value  = 0
 580
 581         Symbol# 17: "sprintf"
 582             String index  = 123         Ifd    = 1
 583             Storage class = Nil         Index  = 1048575
 584             Symbol type   = Proc        Value  = 0
 585
 586         Symbol# 18: "main"
 587             Type          = int
 588             String index  = 131         Ifd    = 0
 589             Storage class = Text        Index  = 1
 590             Symbol type   = Proc        Value  = 0
 591
 592         Symbol# 19: "printf"
 593             String index  = 136         Ifd    = 0
 594             Storage class = Undefined   Index  = 1048575
 595             Symbol type   = Proc        Value  = 0
 596
 597    The following auxiliary table entries were unused:
 598
 599     #0               0  0x00000000  void
 600     #2               8  0x00000008  char
 601     #3              16  0x00000010  short
 602     #4              24  0x00000018  int
 603     #5              32  0x00000020  long
 604     #6              40  0x00000028  float
 605     #7              44  0x0000002c  double
 606     #8              12  0x0000000c  unsigned char
 607     #9              20  0x00000014  unsigned short
 608     #10             28  0x0000001c  unsigned int
 609     #11             36  0x00000024  unsigned long
 610     #14              0  0x00000000  void
 611     #15             24  0x00000018  int
 612     #19             32  0x00000020  long
 613     #20             40  0x00000028  float
 614     #21             44  0x0000002c  double
 615     #22             12  0x0000000c  unsigned char
 616     #23             20  0x00000014  unsigned short
 617     #24             28  0x0000001c  unsigned int
 618     #25             36  0x00000024  unsigned long
 619     #26             48  0x00000030  struct no name { ifd = -1, index = 1048575 }
 620 */
 621 \f
 622 /* Redefinition of of storage classes as an enumeration for better
 623    debugging.  */
 624
 625 typedef enum sc {
 626   sc_Nil         = scNil,         /* no storage class */
 627   sc_Text        = scText,        /* text symbol */
 628   sc_Data        = scData,        /* initialized data symbol */
 629   sc_Bss         = scBss,         /* un-initialized data symbol */
 630   sc_Register    = scRegister,    /* value of symbol is register number */
 631   sc_Abs         = scAbs,         /* value of symbol is absolute */
 632   sc_Undefined   = scUndefined,   /* who knows? */
 633   sc_CdbLocal    = scCdbLocal,    /* variable's value is IN se->va.?? */
 634   sc_Bits        = scBits,        /* this is a bit field */
 635   sc_CdbSystem   = scCdbSystem,   /* value is IN CDB's address space */
 636   sc_RegImage    = scRegImage,    /* register value saved on stack */
 637   sc_Info        = scInfo,        /* symbol contains debugger information */
 638   sc_UserStruct  = scUserStruct,  /* addr in struct user for current process */
 639   sc_SData       = scSData,       /* load time only small data */
 640   sc_SBss        = scSBss,        /* load time only small common */
 641   sc_RData       = scRData,       /* load time only read only data */
 642   sc_Var         = scVar,         /* Var parameter (fortran,pascal) */
 643   sc_Common      = scCommon,      /* common variable */
 644   sc_SCommon     = scSCommon,     /* small common */
 645   sc_VarRegister = scVarRegister, /* Var parameter in a register */
 646   sc_Variant     = scVariant,     /* Variant record */
 647   sc_SUndefined  = scSUndefined,  /* small undefined(external) data */
 648   sc_Init        = scInit,        /* .init section symbol */
 649   sc_Max         = scMax          /* Max storage class+1 */
 650 } sc_t;
 651
 652 /* Redefinition of symbol type.  */
 653
 654 typedef enum st {
 655   st_Nil        = stNil,        /* Nuthin' special */
 656   st_Global     = stGlobal,     /* external symbol */
 657   st_Static     = stStatic,     /* static */
 658   st_Param      = stParam,      /* procedure argument */
 659   st_Local      = stLocal,      /* local variable */
 660   st_Label      = stLabel,      /* label */
 661   st_Proc       = stProc,       /*     "      "  Procedure */
 662   st_Block      = stBlock,      /* beginning of block */
 663   st_End        = stEnd,        /* end (of anything) */
 664   st_Member     = stMember,     /* member (of anything  - struct/union/enum */
 665   st_Typedef    = stTypedef,    /* type definition */
 666   st_File       = stFile,       /* file name */
 667   st_RegReloc   = stRegReloc,   /* register relocation */
 668   st_Forward    = stForward,    /* forwarding address */
 669   st_StaticProc = stStaticProc, /* load time only static procs */
 670   st_Constant   = stConstant,   /* const */
 671   st_Str        = stStr,        /* string */
 672   st_Number     = stNumber,     /* pure number (ie. 4 NOR 2+2) */
 673   st_Expr       = stExpr,       /* 2+2 vs. 4 */
 674   st_Type       = stType,       /* post-coercion SER */
 675   st_Max        = stMax         /* max type+1 */
 676 } st_t;
 677
 678 /* Redefinition of type qualifiers.  */
 679
 680 typedef enum tq {
 681   tq_Nil        = tqNil,        /* bt is what you see */
 682   tq_Ptr        = tqPtr,        /* pointer */
 683   tq_Proc       = tqProc,       /* procedure */
 684   tq_Array      = tqArray,      /* duh */
 685   tq_Far        = tqFar,        /* longer addressing - 8086/8 land */
 686   tq_Vol        = tqVol,        /* volatile */
 687   tq_Max        = tqMax         /* Max type qualifier+1 */
 688 } tq_t;
 689
 690 /* Redefinition of basic types.  */
 691
 692 typedef enum bt {
 693   bt_Nil        = btNil,        /* undefined */
 694   bt_Adr        = btAdr,        /* address - integer same size as pointer */
 695   bt_Char       = btChar,       /* character */
 696   bt_UChar      = btUChar,      /* unsigned character */
 697   bt_Short      = btShort,      /* short */
 698   bt_UShort     = btUShort,     /* unsigned short */
 699   bt_Int        = btInt,        /* int */
 700   bt_UInt       = btUInt,       /* unsigned int */
 701   bt_Long       = btLong,       /* long */
 702   bt_ULong      = btULong,      /* unsigned long */
 703   bt_Float      = btFloat,      /* float (real) */
 704   bt_Double     = btDouble,     /* Double (real) */
 705   bt_Struct     = btStruct,     /* Structure (Record) */
 706   bt_Union      = btUnion,      /* Union (variant) */
 707   bt_Enum       = btEnum,       /* Enumerated */
 708   bt_Typedef    = btTypedef,    /* defined via a typedef, isymRef points */
 709   bt_Range      = btRange,      /* subrange of int */
 710   bt_Set        = btSet,        /* pascal sets */
 711   bt_Complex    = btComplex,    /* fortran complex */
 712   bt_DComplex   = btDComplex,   /* fortran double complex */
 713   bt_Indirect   = btIndirect,   /* forward or unnamed typedef */
 714   bt_FixedDec   = btFixedDec,   /* Fixed Decimal */
 715   bt_FloatDec   = btFloatDec,   /* Float Decimal */
 716   bt_String     = btString,     /* Varying Length Character String */
 717   bt_Bit        = btBit,        /* Aligned Bit String */
 718   bt_Picture    = btPicture,    /* Picture */
 719   bt_Void       = btVoid,       /* Void */
 720   bt_Max        = btMax         /* Max basic type+1 */
 721 } bt_t;
 722
 723 #define N_TQ itqMax
 724
 725 /* States for whether to hash type or not.  */
 726 typedef enum hash_state {
 727   hash_no       = 0,            /* Don't hash type */
 728   hash_yes      = 1,            /* OK to hash type, or use previous hash */
 729   hash_record   = 2             /* OK to record hash, but don't use prev.  */
 730 } hash_state_t;
 731
 732 /* Types of different sized allocation requests.  */
 733 enum alloc_type {
 734   alloc_type_none,              /* dummy value */
 735   alloc_type_scope,             /* nested scopes linked list */
 736   alloc_type_vlinks,            /* glue linking pages in varray */
 737   alloc_type_shash,             /* string hash element */
 738   alloc_type_thash,             /* type hash element */
 739   alloc_type_tag,               /* struct/union/tag element */
 740   alloc_type_forward,           /* element to hold unknown tag */
 741   alloc_type_thead,             /* head of type hash list */
 742   alloc_type_varray,            /* general varray allocation */
 743   alloc_type_lineno,            /* line number list */
 744   alloc_type_last               /* last+1 element for array bounds */
 745 };
 746
 747 /* Types of auxiliary type information.  */
 748 enum aux_type {
 749   aux_tir,                      /* TIR type information */
 750   aux_rndx,                     /* relative index into symbol table */
 751   aux_dnLow,                    /* low dimension */
 752   aux_dnHigh,                   /* high dimension */
 753   aux_isym,                     /* symbol table index (end of proc) */
 754   aux_iss,                      /* index into string space (not used) */
 755   aux_width,                    /* width for non-default sized struc fields */
 756   aux_count                     /* count of ranges for variant arm */
 757 };
 758 \f
 759 /* Structures to provide n-number of virtual arrays, each of which can
 760    grow linearly, and which are written in the object file as
 761    sequential pages.  On systems with a BSD malloc, the
 762    MAX_CLUSTER_PAGES should be 1 less than a power of two, since
 763    malloc adds it's overhead, and rounds up to the next power of 2.
 764    Pages are linked together via a linked list.
 765
 766    If PAGE_SIZE is > 4096, the string length in the shash_t structure
 767    can't be represented (assuming there are strings > 4096 bytes).  */
 768
 769 /* FIXME: Yes, there can be such strings while emitting C++ class debug
 770    info.  Templates are the offender here, the test case in question
 771    having a mangled class name of
 772
 773      t7rb_tree4Z4xkeyZt4pair2ZC4xkeyZt7xsocket1Z4UserZt9select1st2Zt4pair\
 774      2ZC4xkeyZt7xsocket1Z4UserZ4xkeyZt4less1Z4xkey
 775
 776    Repeat that a couple dozen times while listing the class members and
 777    you've got strings over 4k.  Hack around this for now by increasing
 778    the page size.  A proper solution would abandon this structure scheme
 779    certainly for very large strings, and possibly entirely.  */
 780
 781 #ifndef PAGE_SIZE
 782 #define PAGE_SIZE (8*1024)      /* size of varray pages */
 783 #endif
 784
 785 #define PAGE_USIZE ((unsigned long) PAGE_SIZE)
 786
 787 #ifndef MAX_CLUSTER_PAGES       /* # pages to get from system */
 788 #define MAX_CLUSTER_PAGES 63
 789 #endif
 790
 791 /* Linked list connecting separate page allocations.  */
 792 typedef struct vlinks {
 793   struct vlinks *prev;          /* previous set of pages */
 794   struct vlinks *next;          /* next set of pages */
 795   union  page   *datum;         /* start of page */
 796   unsigned long  start_index;   /* starting index # of page */
 797 } vlinks_t;
 798
 799 /* Virtual array header.  */
 800 typedef struct varray {
 801   vlinks_t      *first;                 /* first page link */
 802   vlinks_t      *last;                  /* last page link */
 803   unsigned long  num_allocated;         /* # objects allocated */
 804   unsigned short object_size;           /* size in bytes of each object */
 805   unsigned short objects_per_page;      /* # objects that can fit on a page */
 806   unsigned short objects_last_page;     /* # objects allocated on last page */
 807 } varray_t;
 808
 809 #ifndef MALLOC_CHECK
 810 #define OBJECTS_PER_PAGE(type) (PAGE_SIZE / sizeof (type))
 811 #else
 812 #define OBJECTS_PER_PAGE(type) ((sizeof (type) > 1) ? 1 : PAGE_SIZE)
 813 #endif
 814
 815 #define INIT_VARRAY(type) {     /* macro to initialize a varray */      \
 816   (vlinks_t *)0,                /* first */                             \
 817   (vlinks_t *)0,                /* last */                              \
 818   0,                            /* num_allocated */                     \
 819   sizeof (type),                /* object_size */                       \
 820   OBJECTS_PER_PAGE (type),      /* objects_per_page */                  \
 821   OBJECTS_PER_PAGE (type),      /* objects_last_page */                 \
 822 }
 823
 824 /* Master type for indexes within the symbol table.  */
 825 typedef unsigned long symint_t;
 826
 827 /* Linked list support for nested scopes (file, block, structure, etc.).  */
 828 typedef struct scope {
 829   struct scope  *prev;          /* previous scope level */
 830   struct scope  *free;          /* free list pointer */
 831   struct localsym *lsym;        /* pointer to local symbol node */
 832   st_t           type;          /* type of the node */
 833 } scope_t;
 834
 835 /* For a local symbol we store a gas symbol as well as the debugging
 836    information we generate.  The gas symbol will be NULL if this is
 837    only a debugging symbol.  */
 838 typedef struct localsym {
 839   const char *name;             /* symbol name */
 840   symbolS *as_sym;              /* symbol as seen by gas */
 841   bfd_vma addend;               /* addend to as_sym value */
 842   struct efdr *file_ptr;        /* file pointer */
 843   struct ecoff_proc *proc_ptr;  /* proc pointer */
 844   struct localsym *begin_ptr;   /* symbol at start of block */
 845   struct ecoff_aux *index_ptr;  /* index value to be filled in */
 846   struct forward *forward_ref;  /* forward references to this symbol */
 847   long sym_index;               /* final symbol index */
 848   EXTR ecoff_sym;               /* ECOFF debugging symbol */
 849 } localsym_t;
 850
 851 /* For aux information we keep the type and the data.  */
 852 typedef struct ecoff_aux {
 853   enum aux_type type;           /* aux type */
 854   AUXU data;                    /* aux data */
 855 } aux_t;
 856
 857 /* For a procedure we store the gas symbol as well as the PDR
 858    debugging information.  */
 859 typedef struct ecoff_proc {
 860   localsym_t *sym;              /* associated symbol */
 861   PDR pdr;                      /* ECOFF debugging info */
 862 } proc_t;
 863
 864 /* Number of proc_t structures allocated.  */
 865 static unsigned long proc_cnt;
 866
 867 /* Forward reference list for tags referenced, but not yet defined.  */
 868 typedef struct forward {
 869   struct forward *next;         /* next forward reference */
 870   struct forward *free;         /* free list pointer */
 871   aux_t          *ifd_ptr;      /* pointer to store file index */
 872   aux_t          *index_ptr;    /* pointer to store symbol index */
 873 } forward_t;
 874
 875 /* Linked list support for tags.  The first tag in the list is always
 876    the current tag for that block.  */
 877 typedef struct tag {
 878   struct tag     *free;         /* free list pointer */
 879   struct shash   *hash_ptr;     /* pointer to the hash table head */
 880   struct tag     *same_name;    /* tag with same name in outer scope */
 881   struct tag     *same_block;   /* next tag defined in the same block.  */
 882   struct forward *forward_ref;  /* list of forward references */
 883   bt_t            basic_type;   /* bt_Struct, bt_Union, or bt_Enum */
 884   symint_t        ifd;          /* file # tag defined in */
 885   localsym_t     *sym;          /* file's local symbols */
 886 } tag_t;
 887
 888 /* Head of a block's linked list of tags.  */
 889 typedef struct thead {
 890   struct thead  *prev;          /* previous block */
 891   struct thead  *free;          /* free list pointer */
 892   struct tag    *first_tag;     /* first tag in block defined */
 893 } thead_t;
 894
 895 /* Union containing pointers to each the small structures which are freed up.  */
 896 typedef union small_free {
 897   scope_t       *f_scope;       /* scope structure */
 898   thead_t       *f_thead;       /* tag head structure */
 899   tag_t         *f_tag;         /* tag element structure */
 900   forward_t     *f_forward;     /* forward tag reference */
 901 } small_free_t;
 902
 903 /* String hash table entry.  */
 904
 905 typedef struct shash {
 906   char          *string;        /* string we are hashing */
 907   symint_t       indx;          /* index within string table */
 908   EXTR          *esym_ptr;      /* global symbol pointer */
 909   localsym_t    *sym_ptr;       /* local symbol pointer */
 910   localsym_t    *end_ptr;       /* symbol pointer to end block */
 911   tag_t         *tag_ptr;       /* tag pointer */
 912   proc_t        *proc_ptr;      /* procedure descriptor pointer */
 913 } shash_t;
 914
 915 /* Type hash table support.  The size of the hash table must fit
 916    within a page with the other extended file descriptor information.
 917    Because unique types which are hashed are fewer in number than
 918    strings, we use a smaller hash value.  */
 919
 920 #define HASHBITS 30
 921
 922 #ifndef THASH_SIZE
 923 #define THASH_SIZE 113
 924 #endif
 925
 926 typedef struct thash {
 927   struct thash  *next;          /* next hash value */
 928   AUXU           type;          /* type we are hashing */
 929   symint_t       indx;          /* index within string table */
 930 } thash_t;
 931
 932 /* Extended file descriptor that contains all of the support necessary
 933    to add things to each file separately.  */
 934 typedef struct efdr {
 935   FDR            fdr;           /* File header to be written out */
 936   FDR           *orig_fdr;      /* original file header */
 937   char          *name;          /* filename */
 938   int            fake;          /* whether this is faked .file */
 939   symint_t       void_type;     /* aux. pointer to 'void' type */
 940   symint_t       int_type;      /* aux. pointer to 'int' type */
 941   scope_t       *cur_scope;     /* current nested scopes */
 942   symint_t       file_index;    /* current file number */
 943   int            nested_scopes; /* # nested scopes */
 944   varray_t       strings;       /* local strings */
 945   varray_t       symbols;       /* local symbols */
 946   varray_t       procs;         /* procedures */
 947   varray_t       aux_syms;      /* auxiliary symbols */
 948   struct efdr   *next_file;     /* next file descriptor */
 949                                 /* string/type hash tables */
 950   struct hash_control *str_hash;        /* string hash table */
 951   thash_t       *thash_head[THASH_SIZE];
 952 } efdr_t;
 953
 954 /* Pre-initialized extended file structure.  */
 955 static const efdr_t init_file =
 956 {
 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;
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_NONE)
2221         debug_type = DEBUG_ECOFF;
2222     }
2223
2224 #ifndef NO_LISTING
2225   if (listing)
2226     listing_source_file (file_name);
2227 #endif
2228
2229   current_stabs_filename = file_name;
2230
2231   /* If we're creating stabs, then we don't actually make a new FDR.
2232      Instead, we just create a stabs symbol.  */
2233   if (stabs_seen)
2234     {
2235       (void) add_ecoff_symbol (file_name, st_Nil, sc_Nil,
2236                                symbol_new ("L0\001", now_seg,
2237                                            (valueT) frag_now_fix (),
2238                                            frag_now),
2239                                (bfd_vma) 0, 0, ECOFF_MARK_STAB (N_SOL));
2240       return;
2241     }
2242
2243   first_ch = *file_name;
2244
2245   /* FIXME: We can't safely merge files which have line number
2246      information (fMerge will be zero in this case).  Otherwise, we
2247      get incorrect line number debugging info.  See for instance
2248      ecoff_build_lineno, which will end up setting all file->fdr.*
2249      fields multiple times, resulting in incorrect debug info.  In
2250      order to make this work right, all line number and symbol info
2251      for the same source file has to be adjacent in the object file,
2252      so that a single file descriptor can be used to point to them.
2253      This would require maintaining file specific lists of line
2254      numbers and symbols for each file, so that they can be merged
2255      together (or output together) when two .file pseudo-ops are
2256      merged into one file descriptor.  */
2257
2258   /* See if the file has already been created.  */
2259   for (fil_ptr = first_file;
2260        fil_ptr != (efdr_t *) NULL;
2261        fil_ptr = fil_ptr->next_file)
2262     {
2263       if (first_ch == fil_ptr->name[0]
2264           && strcmp (file_name, fil_ptr->name) == 0
2265           && fil_ptr->fdr.fMerge)
2266         {
2267           cur_file_ptr = fil_ptr;
2268           if (! fake)
2269             cur_file_ptr->fake = 0;
2270           break;
2271         }
2272     }
2273
2274   /* If this is a new file, create it.  */
2275   if (fil_ptr == (efdr_t *) NULL)
2276     {
2277       if (file_desc.objects_last_page == file_desc.objects_per_page)
2278         add_varray_page (&file_desc);
2279
2280       fil_ptr = cur_file_ptr =
2281         &file_desc.last->datum->file[file_desc.objects_last_page++];
2282       *fil_ptr = init_file;
2283
2284       fil_ptr->file_index = current_file_idx++;
2285       ++file_desc.num_allocated;
2286
2287       fil_ptr->fake = fake;
2288
2289       /* Allocate the string hash table.  */
2290       fil_ptr->str_hash = hash_new ();
2291
2292       /* Make sure 0 byte in string table is null  */
2293       add_string (&fil_ptr->strings,
2294                   fil_ptr->str_hash,
2295                   "",
2296                   (shash_t **)0);
2297
2298       if (strlen (file_name) > PAGE_USIZE - 2)
2299         as_fatal (_("Filename goes over one page boundary."));
2300
2301       /* Push the start of the filename. We assume that the filename
2302          will be stored at string offset 1.  */
2303       (void) add_ecoff_symbol (file_name, st_File, sc_Text,
2304                                (symbolS *) NULL, (bfd_vma) 0,
2305                                (symint_t) 0, (symint_t) 0);
2306       fil_ptr->fdr.rss = 1;
2307       fil_ptr->name = &fil_ptr->strings.last->datum->byte[1];
2308
2309       /* Update the linked list of file descriptors.  */
2310       *last_file_ptr = fil_ptr;
2311       last_file_ptr = &fil_ptr->next_file;
2312
2313       /* Add void & int types to the file (void should be first to catch
2314          errant 0's within the index fields).  */
2315       fil_ptr->void_type = add_aux_sym_tir (&void_type_info,
2316                                             hash_yes,
2317                                             &cur_file_ptr->thash_head[0]);
2318
2319       fil_ptr->int_type = add_aux_sym_tir (&int_type_info,
2320                                            hash_yes,
2321                                            &cur_file_ptr->thash_head[0]);
2322     }
2323 }
2324
2325 /* This function is called when the assembler notices a preprocessor
2326    directive switching to a new file.  This will not happen in
2327    compiler output, only in hand coded assembler.  */
2328
2329 void
2330 ecoff_new_file (name)
2331      const char *name;
2332 {
2333   if (cur_file_ptr != NULL && strcmp (cur_file_ptr->name, name) == 0)
2334     return;
2335   add_file (name, 0, 0);
2336
2337   /* This is a hand coded assembler file, so automatically turn on
2338      debugging information.  */
2339   if (debug_type == DEBUG_NONE)
2340     debug_type = DEBUG_ECOFF;
2341 }
2342 \f
2343 #ifdef ECOFF_DEBUG
2344
2345 /* Convert storage class to string.  */
2346
2347 static char *
2348 sc_to_string (storage_class)
2349      sc_t storage_class;
2350 {
2351   switch (storage_class)
2352     {
2353     case sc_Nil:         return "Nil,";
2354     case sc_Text:        return "Text,";
2355     case sc_Data:        return "Data,";
2356     case sc_Bss:         return "Bss,";
2357     case sc_Register:    return "Register,";
2358     case sc_Abs:         return "Abs,";
2359     case sc_Undefined:   return "Undefined,";
2360     case sc_CdbLocal:    return "CdbLocal,";
2361     case sc_Bits:        return "Bits,";
2362     case sc_CdbSystem:   return "CdbSystem,";
2363     case sc_RegImage:    return "RegImage,";
2364     case sc_Info:        return "Info,";
2365     case sc_UserStruct:  return "UserStruct,";
2366     case sc_SData:       return "SData,";
2367     case sc_SBss:        return "SBss,";
2368     case sc_RData:       return "RData,";
2369     case sc_Var:         return "Var,";
2370     case sc_Common:      return "Common,";
2371     case sc_SCommon:     return "SCommon,";
2372     case sc_VarRegister: return "VarRegister,";
2373     case sc_Variant:     return "Variant,";
2374     case sc_SUndefined:  return "SUndefined,";
2375     case sc_Init:        return "Init,";
2376     case sc_Max:         return "Max,";
2377     }
2378
2379   return "???,";
2380 }
2381
2382 #endif /* DEBUG */
2383 \f
2384 #ifdef ECOFF_DEBUG
2385
2386 /* Convert symbol type to string.  */
2387
2388 static char *
2389 st_to_string (symbol_type)
2390      st_t symbol_type;
2391 {
2392   switch (symbol_type)
2393     {
2394     case st_Nil:        return "Nil,";
2395     case st_Global:     return "Global,";
2396     case st_Static:     return "Static,";
2397     case st_Param:      return "Param,";
2398     case st_Local:      return "Local,";
2399     case st_Label:      return "Label,";
2400     case st_Proc:       return "Proc,";
2401     case st_Block:      return "Block,";
2402     case st_End:        return "End,";
2403     case st_Member:     return "Member,";
2404     case st_Typedef:    return "Typedef,";
2405     case st_File:       return "File,";
2406     case st_RegReloc:   return "RegReloc,";
2407     case st_Forward:    return "Forward,";
2408     case st_StaticProc: return "StaticProc,";
2409     case st_Constant:   return "Constant,";
2410     case st_Str:        return "String,";
2411     case st_Number:     return "Number,";
2412     case st_Expr:       return "Expr,";
2413     case st_Type:       return "Type,";
2414     case st_Max:        return "Max,";
2415     }
2416
2417   return "???,";
2418 }
2419
2420 #endif /* DEBUG */
2421 \f
2422 /* Parse .begin directives which have a label as the first argument
2423    which gives the location of the start of the block.  */
2424
2425 void
2426 ecoff_directive_begin (ignore)
2427      int ignore;
2428 {
2429   char *name;
2430   char name_end;
2431
2432   if (cur_file_ptr == (efdr_t *) NULL)
2433     {
2434       as_warn (_(".begin directive without a preceding .file directive"));
2435       demand_empty_rest_of_line ();
2436       return;
2437     }
2438
2439   if (cur_proc_ptr == (proc_t *) NULL)
2440     {
2441       as_warn (_(".begin directive without a preceding .ent directive"));
2442       demand_empty_rest_of_line ();
2443       return;
2444     }
2445
2446   name = input_line_pointer;
2447   name_end = get_symbol_end ();
2448
2449   (void) add_ecoff_symbol ((const char *) NULL, st_Block, sc_Text,
2450                            symbol_find_or_make (name),
2451                            (bfd_vma) 0, (symint_t) 0, (symint_t) 0);
2452
2453   *input_line_pointer = name_end;
2454
2455   /* The line number follows, but we don't use it.  */
2456   (void) get_absolute_expression ();
2457   demand_empty_rest_of_line ();
2458 }
2459 \f
2460 /* Parse .bend directives which have a label as the first argument
2461    which gives the location of the end of the block.  */
2462
2463 void
2464 ecoff_directive_bend (ignore)
2465      int ignore;
2466 {
2467   char *name;
2468   char name_end;
2469   symbolS *endsym;
2470
2471   if (cur_file_ptr == (efdr_t *) NULL)
2472     {
2473       as_warn (_(".bend directive without a preceding .file directive"));
2474       demand_empty_rest_of_line ();
2475       return;
2476     }
2477
2478   if (cur_proc_ptr == (proc_t *) NULL)
2479     {
2480       as_warn (_(".bend directive without a preceding .ent directive"));
2481       demand_empty_rest_of_line ();
2482       return;
2483     }
2484
2485   name = input_line_pointer;
2486   name_end = get_symbol_end ();
2487
2488   /* The value is the distance between the .bend directive and the
2489      corresponding symbol.  We fill in the offset when we write out
2490      the symbol.  */
2491   endsym = symbol_find (name);
2492   if (endsym == (symbolS *) NULL)
2493     as_warn (_(".bend directive names unknown symbol"));
2494   else
2495     (void) add_ecoff_symbol ((const char *) NULL, st_End, sc_Text, endsym,
2496                              (bfd_vma) 0, (symint_t) 0, (symint_t) 0);
2497
2498   *input_line_pointer = name_end;
2499
2500   /* The line number follows, but we don't use it.  */
2501   (void) get_absolute_expression ();
2502   demand_empty_rest_of_line ();
2503 }
2504 \f
2505 /* COFF debugging information is provided as a series of directives
2506    (.def, .scl, etc.).  We build up information as we read the
2507    directives in the following static variables, and file it away when
2508    we reach the .endef directive.  */
2509 static char *coff_sym_name;
2510 static type_info_t coff_type;
2511 static sc_t coff_storage_class;
2512 static st_t coff_symbol_typ;
2513 static int coff_is_function;
2514 static char *coff_tag;
2515 static valueT coff_value;
2516 static symbolS *coff_sym_value;
2517 static bfd_vma coff_sym_addend;
2518 static int coff_inside_enumeration;
2519
2520 /* Handle a .def directive: start defining a symbol.  */
2521
2522 void
2523 ecoff_directive_def (ignore)
2524      int ignore;
2525 {
2526   char *name;
2527   char name_end;
2528
2529   ecoff_debugging_seen = 1;
2530
2531   SKIP_WHITESPACE ();
2532
2533   name = input_line_pointer;
2534   name_end = get_symbol_end ();
2535
2536   if (coff_sym_name != (char *) NULL)
2537     as_warn (_(".def pseudo-op used inside of .def/.endef; ignored"));
2538   else if (*name == '\0')
2539     as_warn (_("Empty symbol name in .def; ignored"));
2540   else
2541     {
2542       if (coff_sym_name != (char *) NULL)
2543         free (coff_sym_name);
2544       if (coff_tag != (char *) NULL)
2545         free (coff_tag);
2546       coff_sym_name = (char *) xmalloc ((unsigned long) (strlen (name) + 1));
2547       strcpy (coff_sym_name, name);
2548       coff_type = type_info_init;
2549       coff_storage_class = sc_Nil;
2550       coff_symbol_typ = st_Nil;
2551       coff_is_function = 0;
2552       coff_tag = (char *) NULL;
2553       coff_value = 0;
2554       coff_sym_value = (symbolS *) NULL;
2555       coff_sym_addend = 0;
2556     }
2557
2558   *input_line_pointer = name_end;
2559
2560   demand_empty_rest_of_line ();
2561 }
2562
2563 /* Handle a .dim directive, used to give dimensions for an array.  The
2564    arguments are comma separated numbers.  mips-tfile assumes that
2565    there will not be more than 6 dimensions, and gdb won't read any
2566    more than that anyhow, so I will also make that assumption.  */
2567
2568 void
2569 ecoff_directive_dim (ignore)
2570      int ignore;
2571 {
2572   int dimens[N_TQ];
2573   int i;
2574
2575   if (coff_sym_name == (char *) NULL)
2576     {
2577       as_warn (_(".dim pseudo-op used outside of .def/.endef; ignored"));
2578       demand_empty_rest_of_line ();
2579       return;
2580     }
2581
2582   for (i = 0; i < N_TQ; i++)
2583     {
2584       SKIP_WHITESPACE ();
2585       dimens[i] = get_absolute_expression ();
2586       if (*input_line_pointer == ',')
2587         ++input_line_pointer;
2588       else
2589         {
2590           if (*input_line_pointer != '\n'
2591               && *input_line_pointer != ';')
2592             as_warn (_("Badly formed .dim directive"));
2593           break;
2594         }
2595     }
2596
2597   if (i == N_TQ)
2598     --i;
2599
2600   /* The dimensions are stored away in reverse order.  */
2601   for (; i >= 0; i--)
2602     {
2603       if (coff_type.num_dims >= N_TQ)
2604         {
2605           as_warn (_("Too many .dim entries"));
2606           break;
2607         }
2608       coff_type.dimensions[coff_type.num_dims] = dimens[i];
2609       ++coff_type.num_dims;
2610     }
2611
2612   demand_empty_rest_of_line ();
2613 }
2614
2615 /* Handle a .scl directive, which sets the COFF storage class of the
2616    symbol.  */
2617
2618 void
2619 ecoff_directive_scl (ignore)
2620      int ignore;
2621 {
2622   long val;
2623
2624   if (coff_sym_name == (char *) NULL)
2625     {
2626       as_warn (_(".scl pseudo-op used outside of .def/.endef; ignored"));
2627       demand_empty_rest_of_line ();
2628       return;
2629     }
2630
2631   val = get_absolute_expression ();
2632
2633   coff_symbol_typ = map_coff_sym_type[val];
2634   coff_storage_class = map_coff_storage[val];
2635
2636   demand_empty_rest_of_line ();
2637 }
2638
2639 /* Handle a .size directive.  For some reason mips-tfile.c thinks that
2640    .size can have multiple arguments.  We humor it, although gcc will
2641    never generate more than one argument.  */
2642
2643 void
2644 ecoff_directive_size (ignore)
2645      int ignore;
2646 {
2647   int sizes[N_TQ];
2648   int i;
2649
2650   if (coff_sym_name == (char *) NULL)
2651     {
2652       as_warn (_(".size pseudo-op used outside of .def/.endef; ignored"));
2653       demand_empty_rest_of_line ();
2654       return;
2655     }
2656
2657   for (i = 0; i < N_TQ; i++)
2658     {
2659       SKIP_WHITESPACE ();
2660       sizes[i] = get_absolute_expression ();
2661       if (*input_line_pointer == ',')
2662         ++input_line_pointer;
2663       else
2664         {
2665           if (*input_line_pointer != '\n'
2666               && *input_line_pointer != ';')
2667             as_warn (_("Badly formed .size directive"));
2668           break;
2669         }
2670     }
2671
2672   if (i == N_TQ)
2673     --i;
2674
2675   /* The sizes are stored away in reverse order.  */
2676   for (; i >= 0; i--)
2677     {
2678       if (coff_type.num_sizes >= N_TQ)
2679         {
2680           as_warn (_("Too many .size entries"));
2681           break;
2682         }
2683       coff_type.sizes[coff_type.num_sizes] = sizes[i];
2684       ++coff_type.num_sizes;
2685     }
2686
2687   demand_empty_rest_of_line ();
2688 }
2689
2690 /* Handle the .type directive, which gives the COFF type of the
2691    symbol.  */
2692
2693 void
2694 ecoff_directive_type (ignore)
2695      int ignore;
2696 {
2697   long val;
2698   tq_t *tq_ptr;
2699   tq_t *tq_shft;
2700
2701   if (coff_sym_name == (char *) NULL)
2702     {
2703       as_warn (_(".type pseudo-op used outside of .def/.endef; ignored"));
2704       demand_empty_rest_of_line ();
2705       return;
2706     }
2707
2708   val = get_absolute_expression ();
2709
2710   coff_type.orig_type = BTYPE (val);
2711   coff_type.basic_type = map_coff_types[coff_type.orig_type];
2712
2713   tq_ptr = &coff_type.type_qualifiers[N_TQ];
2714   while (val & ~N_BTMASK)
2715     {
2716       if (tq_ptr == &coff_type.type_qualifiers[0])
2717         {
2718           /* FIXME: We could handle this by setting the continued bit.
2719              There would still be a limit: the .type argument can not
2720              be infinite.  */
2721           as_warn (_("The type of %s is too complex; it will be simplified"),
2722                    coff_sym_name);
2723           break;
2724         }
2725       if (ISPTR (val))
2726         *--tq_ptr = tq_Ptr;
2727       else if (ISFCN (val))
2728         *--tq_ptr = tq_Proc;
2729       else if (ISARY (val))
2730         *--tq_ptr = tq_Array;
2731       else
2732         as_fatal (_("Unrecognized .type argument"));
2733
2734       val = DECREF (val);
2735     }
2736
2737   tq_shft = &coff_type.type_qualifiers[0];
2738   while (tq_ptr != &coff_type.type_qualifiers[N_TQ])
2739     *tq_shft++ = *tq_ptr++;
2740
2741   if (tq_shft != &coff_type.type_qualifiers[0] && tq_shft[-1] == tq_Proc)
2742     {
2743       /* If this is a function, ignore it, so that we don't get two
2744          entries (one from the .ent, and one for the .def that
2745          precedes it).  Save the type information so that the end
2746          block can properly add it after the begin block index.  For
2747          MIPS knows what reason, we must strip off the function type
2748          at this point.  */
2749       coff_is_function = 1;
2750       tq_shft[-1] = tq_Nil;
2751     }
2752
2753   while (tq_shft != &coff_type.type_qualifiers[N_TQ])
2754     *tq_shft++ = tq_Nil;
2755
2756   demand_empty_rest_of_line ();
2757 }
2758
2759 /* Handle the .tag directive, which gives the name of a structure,
2760    union or enum.  */
2761
2762 void
2763 ecoff_directive_tag (ignore)
2764      int ignore;
2765 {
2766   char *name;
2767   char name_end;
2768
2769   if (coff_sym_name == (char *) NULL)
2770     {
2771       as_warn (_(".tag pseudo-op used outside of .def/.endef; ignored"));
2772       demand_empty_rest_of_line ();
2773       return;
2774     }
2775
2776   name = input_line_pointer;
2777   name_end = get_symbol_end ();
2778
2779   coff_tag = (char *) xmalloc ((unsigned long) (strlen (name) + 1));
2780   strcpy (coff_tag, name);
2781
2782   *input_line_pointer = name_end;
2783
2784   demand_empty_rest_of_line ();
2785 }
2786
2787 /* Handle the .val directive, which gives the value of the symbol.  It
2788    may be the name of a static or global symbol.  */
2789
2790 void
2791 ecoff_directive_val (ignore)
2792      int ignore;
2793 {
2794   expressionS exp;
2795
2796   if (coff_sym_name == (char *) NULL)
2797     {
2798       as_warn (_(".val pseudo-op used outside of .def/.endef; ignored"));
2799       demand_empty_rest_of_line ();
2800       return;
2801     }
2802
2803   expression (&exp);
2804   if (exp.X_op != O_constant && exp.X_op != O_symbol)
2805     {
2806       as_bad (_(".val expression is too copmlex"));
2807       demand_empty_rest_of_line ();
2808       return;
2809     }
2810
2811   if (exp.X_op == O_constant)
2812     coff_value = exp.X_add_number;
2813   else
2814     {
2815       coff_sym_value = exp.X_add_symbol;
2816       coff_sym_addend = exp.X_add_number;
2817     }
2818
2819   demand_empty_rest_of_line ();
2820 }
2821
2822 /* Handle the .endef directive, which terminates processing of COFF
2823    debugging information for a symbol.  */
2824
2825 void
2826 ecoff_directive_endef (ignore)
2827      int ignore;
2828 {
2829   char *name;
2830   symint_t indx;
2831   localsym_t *sym;
2832
2833   demand_empty_rest_of_line ();
2834
2835   if (coff_sym_name == (char *) NULL)
2836     {
2837       as_warn (_(".endef pseudo-op used before .def; ignored"));
2838       return;
2839     }
2840
2841   name = coff_sym_name;
2842   coff_sym_name = (char *) NULL;
2843
2844   /* If the symbol is a static or external, we have already gotten the
2845      appropriate type and class, so make sure we don't override those
2846      values.  This is needed because there are some type and classes
2847      that are not in COFF, such as short data, etc.  */
2848   if (coff_sym_value != (symbolS *) NULL)
2849     {
2850       coff_symbol_typ = st_Nil;
2851       coff_storage_class = sc_Nil;
2852     }
2853
2854   coff_type.extra_sizes = coff_tag != (char *) NULL;
2855   if (coff_type.num_dims > 0)
2856     {
2857       int diff = coff_type.num_dims - coff_type.num_sizes;
2858       int i = coff_type.num_dims - 1;
2859       int j;
2860
2861       if (coff_type.num_sizes != 1 || diff < 0)
2862         {
2863           as_warn (_("Bad COFF debugging info"));
2864           return;
2865         }
2866
2867       /* If this is an array, make sure the same number of dimensions
2868          and sizes were passed, creating extra sizes for multiply
2869          dimensioned arrays if not passed.  */
2870       coff_type.extra_sizes = 0;
2871       if (diff)
2872         {
2873           j = (sizeof (coff_type.sizes) / sizeof (coff_type.sizes[0])) - 1;
2874           while (j >= 0)
2875             {
2876               coff_type.sizes[j] = (((j - diff) >= 0)
2877                                     ? coff_type.sizes[j - diff]
2878                                     : 0);
2879               j--;
2880             }
2881
2882           coff_type.num_sizes = i + 1;
2883           for (i--; i >= 0; i--)
2884             coff_type.sizes[i] = (coff_type.dimensions[i + 1] == 0
2885                                   ? 0
2886                                   : (coff_type.sizes[i + 1]
2887                                      / coff_type.dimensions[i + 1]));
2888         }
2889     }
2890   else if (coff_symbol_typ == st_Member
2891            && coff_type.num_sizes - coff_type.extra_sizes == 1)
2892     {
2893       /* Is this a bitfield?  This is indicated by a structure memeber
2894          having a size field that isn't an array.  */
2895       coff_type.bitfield = 1;
2896     }
2897
2898   /* Except for enumeration members & begin/ending of scopes, put the
2899      type word in the aux. symbol table.  */
2900   if (coff_symbol_typ == st_Block || coff_symbol_typ == st_End)
2901     indx = 0;
2902   else if (coff_inside_enumeration)
2903     indx = cur_file_ptr->void_type;
2904   else
2905     {
2906       if (coff_type.basic_type == bt_Struct
2907           || coff_type.basic_type == bt_Union
2908           || coff_type.basic_type == bt_Enum)
2909         {
2910           if (coff_tag == (char *) NULL)
2911             {
2912               as_warn (_("No tag specified for %s"), name);
2913               return;
2914             }
2915
2916           coff_type.tag_ptr = get_tag (coff_tag, (localsym_t *) NULL,
2917                                        coff_type.basic_type);
2918         }
2919
2920       if (coff_is_function)
2921         {
2922           last_func_type_info = coff_type;
2923           last_func_sym_value = coff_sym_value;
2924           return;
2925         }
2926
2927       indx = add_aux_sym_tir (&coff_type,
2928                               hash_yes,
2929                               &cur_file_ptr->thash_head[0]);
2930     }
2931
2932   /* Do any last minute adjustments that are necessary.  */
2933   switch (coff_symbol_typ)
2934     {
2935     default:
2936       break;
2937
2938       /* For the beginning of structs, unions, and enumerations, the
2939          size info needs to be passed in the value field.  */
2940     case st_Block:
2941       if (coff_type.num_sizes - coff_type.num_dims - coff_type.extra_sizes
2942           != 1)
2943         {
2944           as_warn (_("Bad COFF debugging information"));
2945           return;
2946         }
2947       else
2948         coff_value = coff_type.sizes[0];
2949
2950       coff_inside_enumeration = (coff_type.orig_type == T_ENUM);
2951       break;
2952
2953       /* For the end of structs, unions, and enumerations, omit the
2954          name which is always ".eos".  This needs to be done last, so
2955          that any error reporting above gives the correct name.  */
2956     case st_End:
2957       free (name);
2958       name = (char *) NULL;
2959       coff_value = 0;
2960       coff_inside_enumeration = 0;
2961       break;
2962
2963       /* Members of structures and unions that aren't bitfields, need
2964          to adjust the value from a byte offset to a bit offset.
2965          Members of enumerations do not have the value adjusted, and
2966          can be distinguished by indx == indexNil.  For enumerations,
2967          update the maximum enumeration value.  */
2968     case st_Member:
2969       if (! coff_type.bitfield && ! coff_inside_enumeration)
2970         coff_value *= 8;
2971
2972       break;
2973     }
2974
2975   /* Add the symbol.  */
2976   sym = add_ecoff_symbol (name,
2977                           coff_symbol_typ,
2978                           coff_storage_class,
2979                           coff_sym_value,
2980                           coff_sym_addend,
2981                           (symint_t) coff_value,
2982                           indx);
2983
2984   /* deal with struct, union, and enum tags.  */
2985   if (coff_symbol_typ == st_Block)
2986     {
2987       /* Create or update the tag information.  */
2988       tag_t *tag_ptr = get_tag (name,
2989                                 sym,
2990                                 coff_type.basic_type);
2991       forward_t **pf;
2992
2993       /* Remember any forward references.  */
2994       for (pf = &sym->forward_ref;
2995            *pf != (forward_t *) NULL;
2996            pf = &(*pf)->next)
2997         ;
2998       *pf = tag_ptr->forward_ref;
2999       tag_ptr->forward_ref = (forward_t *) NULL;
3000     }
3001 }
3002 \f
3003 /* Parse .end directives.  */
3004
3005 void
3006 ecoff_directive_end (ignore)
3007      int ignore;
3008 {
3009   char *name;
3010   char name_end;
3011   register int ch;
3012   symbolS *ent;
3013
3014   if (cur_file_ptr == (efdr_t *) NULL)
3015     {
3016       as_warn (_(".end directive without a preceding .file directive"));
3017       demand_empty_rest_of_line ();
3018       return;
3019     }
3020
3021   if (cur_proc_ptr == (proc_t *) NULL)
3022     {
3023       as_warn (_(".end directive without a preceding .ent directive"));
3024       demand_empty_rest_of_line ();
3025       return;
3026     }
3027
3028   name = input_line_pointer;
3029   name_end = get_symbol_end ();
3030
3031   ch = *name;
3032   if (! is_name_beginner (ch))
3033     {
3034       as_warn (_(".end directive has no name"));
3035       *input_line_pointer = name_end;
3036       demand_empty_rest_of_line ();
3037       return;
3038     }
3039
3040   /* The value is the distance between the .end directive and the
3041      corresponding symbol.  We create a fake symbol to hold the
3042      current location, and put in the offset when we write out the
3043      symbol.  */
3044   ent = symbol_find (name);
3045   if (ent == (symbolS *) NULL)
3046     as_warn (_(".end directive names unknown symbol"));
3047   else
3048     (void) add_ecoff_symbol ((const char *) NULL, st_End, sc_Text,
3049                              symbol_new ("L0\001", now_seg,
3050                                          (valueT) frag_now_fix (),
3051                                          frag_now),
3052                              (bfd_vma) 0, (symint_t) 0, (symint_t) 0);
3053
3054   cur_proc_ptr = (proc_t *) NULL;
3055
3056   *input_line_pointer = name_end;
3057   demand_empty_rest_of_line ();
3058 }
3059 \f
3060 /* Parse .ent directives.  */
3061
3062 void
3063 ecoff_directive_ent (ignore)
3064      int ignore;
3065 {
3066   char *name;
3067   char name_end;
3068   register int ch;
3069
3070   if (cur_file_ptr == (efdr_t *) NULL)
3071     add_file ((const char *) NULL, 0, 1);
3072
3073   if (cur_proc_ptr != (proc_t *) NULL)
3074     {
3075       as_warn (_("second .ent directive found before .end directive"));
3076       demand_empty_rest_of_line ();
3077       return;
3078     }
3079
3080   name = input_line_pointer;
3081   name_end = get_symbol_end ();
3082
3083   ch = *name;
3084   if (! is_name_beginner (ch))
3085     {
3086       as_warn (_(".ent directive has no name"));
3087       *input_line_pointer = name_end;
3088       demand_empty_rest_of_line ();
3089       return;
3090     }
3091
3092   add_procedure (name);
3093
3094   *input_line_pointer = name_end;
3095
3096   /* The .ent directive is sometimes followed by a number.  I'm not
3097      really sure what the number means.  I don't see any way to store
3098      the information in the PDR.  The Irix 4 assembler seems to ignore
3099      the information.  */
3100   SKIP_WHITESPACE ();
3101   if (*input_line_pointer == ',')
3102     {
3103       ++input_line_pointer;
3104       SKIP_WHITESPACE ();
3105     }
3106   if (isdigit ((unsigned char) *input_line_pointer)
3107       || *input_line_pointer == '-')
3108     (void) get_absolute_expression ();
3109
3110   demand_empty_rest_of_line ();
3111 }
3112 \f
3113 /* Parse .extern directives.  */
3114
3115 void
3116 ecoff_directive_extern (ignore)
3117      int ignore;
3118 {
3119   char *name;
3120   int c;
3121   symbolS *symbolp;
3122   valueT size;
3123
3124   name = input_line_pointer;
3125   c = get_symbol_end ();
3126   symbolp = symbol_find_or_make (name);
3127   *input_line_pointer = c;
3128
3129   S_SET_EXTERNAL (symbolp);
3130
3131   if (*input_line_pointer == ',')
3132     ++input_line_pointer;
3133   size = get_absolute_expression ();
3134
3135   symbol_get_obj (symbolp)->ecoff_extern_size = size;
3136 }
3137 \f
3138 /* Parse .file directives.  */
3139
3140 void
3141 ecoff_directive_file (ignore)
3142      int ignore;
3143 {
3144   int indx;
3145   char *name;
3146   int len;
3147
3148   if (cur_proc_ptr != (proc_t *) NULL)
3149     {
3150       as_warn (_("No way to handle .file within .ent/.end section"));
3151       demand_empty_rest_of_line ();
3152       return;
3153     }
3154
3155   indx = (int) get_absolute_expression ();
3156
3157   /* FIXME: we don't have to save the name here.  */
3158   name = demand_copy_C_string (&len);
3159
3160   add_file (name, indx - 1, 0);
3161
3162   demand_empty_rest_of_line ();
3163 }
3164 \f
3165 /* Parse .fmask directives.  */
3166
3167 void
3168 ecoff_directive_fmask (ignore)
3169      int ignore;
3170 {
3171   long val;
3172
3173   if (cur_proc_ptr == (proc_t *) NULL)
3174     {
3175       as_warn (_(".fmask outside of .ent"));
3176       demand_empty_rest_of_line ();
3177       return;
3178     }
3179
3180   if (get_absolute_expression_and_terminator (&val) != ',')
3181     {
3182       as_warn (_("Bad .fmask directive"));
3183       --input_line_pointer;
3184       demand_empty_rest_of_line ();
3185       return;
3186     }
3187
3188   cur_proc_ptr->pdr.fregmask = val;
3189   cur_proc_ptr->pdr.fregoffset = get_absolute_expression ();
3190
3191   demand_empty_rest_of_line ();
3192 }
3193 \f
3194 /* Parse .frame directives.  */
3195
3196 void
3197 ecoff_directive_frame (ignore)
3198      int ignore;
3199 {
3200   long val;
3201
3202   if (cur_proc_ptr == (proc_t *) NULL)
3203     {
3204       as_warn (_(".frame outside of .ent"));
3205       demand_empty_rest_of_line ();
3206       return;
3207     }
3208
3209   cur_proc_ptr->pdr.framereg = tc_get_register (1);
3210
3211   SKIP_WHITESPACE ();
3212   if (*input_line_pointer++ != ','
3213       || get_absolute_expression_and_terminator (&val) != ',')
3214     {
3215       as_warn (_("Bad .frame directive"));
3216       --input_line_pointer;
3217       demand_empty_rest_of_line ();
3218       return;
3219     }
3220
3221   cur_proc_ptr->pdr.frameoffset = val;
3222
3223   cur_proc_ptr->pdr.pcreg = tc_get_register (0);
3224
3225 #if 0
3226   /* Alpha-OSF1 adds "the offset of saved $a0 from $sp", according to
3227      Sandro.  I don't yet know where this value should be stored, if
3228      anywhere.  */
3229   demand_empty_rest_of_line ();
3230 #else
3231   s_ignore (42);
3232 #endif
3233 }
3234 \f
3235 /* Parse .mask directives.  */
3236
3237 void
3238 ecoff_directive_mask (ignore)
3239      int ignore;
3240 {
3241   long val;
3242
3243   if (cur_proc_ptr == (proc_t *) NULL)
3244     {
3245       as_warn (_(".mask outside of .ent"));
3246       demand_empty_rest_of_line ();
3247       return;
3248     }
3249
3250   if (get_absolute_expression_and_terminator (&val) != ',')
3251     {
3252       as_warn (_("Bad .mask directive"));
3253       --input_line_pointer;
3254       demand_empty_rest_of_line ();
3255       return;
3256     }
3257
3258   cur_proc_ptr->pdr.regmask = val;
3259   cur_proc_ptr->pdr.regoffset = get_absolute_expression ();
3260
3261   demand_empty_rest_of_line ();
3262 }
3263 \f
3264 /* Parse .loc directives.  */
3265
3266 void
3267 ecoff_directive_loc (ignore)
3268      int ignore;
3269 {
3270   lineno_list_t *list;
3271   symint_t lineno;
3272
3273   if (cur_file_ptr == (efdr_t *) NULL)
3274     {
3275       as_warn (_(".loc before .file"));
3276       demand_empty_rest_of_line ();
3277       return;
3278     }
3279
3280   if (now_seg != text_section)
3281     {
3282       as_warn (_(".loc outside of .text"));
3283       demand_empty_rest_of_line ();
3284       return;
3285     }
3286
3287   /* Skip the file number.  */
3288   SKIP_WHITESPACE ();
3289   get_absolute_expression ();
3290   SKIP_WHITESPACE ();
3291
3292   lineno = get_absolute_expression ();
3293
3294 #ifndef NO_LISTING
3295   if (listing)
3296     listing_source_line (lineno);
3297 #endif
3298
3299   /* If we're building stabs, then output a special label rather than
3300      ECOFF line number info.  */
3301   if (stabs_seen)
3302     {
3303       (void) add_ecoff_symbol ((char *) NULL, st_Label, sc_Text,
3304                                symbol_new ("L0\001", now_seg,
3305                                            (valueT) frag_now_fix (),
3306                                            frag_now),
3307                                (bfd_vma) 0, 0, lineno);
3308       return;
3309     }
3310
3311   list = allocate_lineno_list ();
3312
3313   list->next = (lineno_list_t *) NULL;
3314   list->file = cur_file_ptr;
3315   list->proc = cur_proc_ptr;
3316   list->frag = frag_now;
3317   list->paddr = frag_now_fix ();
3318   list->lineno = lineno;
3319
3320   /* We don't want to merge files which have line numbers.  */
3321   cur_file_ptr->fdr.fMerge = 0;
3322
3323   /* A .loc directive will sometimes appear before a .ent directive,
3324      which means that cur_proc_ptr will be NULL here.  Arrange to
3325      patch this up.  */
3326   if (cur_proc_ptr == (proc_t *) NULL)
3327     {
3328       lineno_list_t **pl;
3329
3330       pl = &noproc_lineno;
3331       while (*pl != (lineno_list_t *) NULL)
3332         pl = &(*pl)->next;
3333       *pl = list;
3334     }
3335   else
3336     {
3337       last_lineno = list;
3338       *last_lineno_ptr = list;
3339       last_lineno_ptr = &list->next;
3340     }
3341 }
3342
3343 /* The MIPS assembler sometimes inserts nop instructions in the
3344    instruction stream.  When this happens, we must patch up the .loc
3345    information so that it points to the instruction after the nop.  */
3346
3347 void
3348 ecoff_fix_loc (old_frag, old_frag_offset)
3349      fragS *old_frag;
3350      unsigned long old_frag_offset;
3351 {
3352   if (last_lineno != NULL
3353       && last_lineno->frag == old_frag
3354       && last_lineno->paddr == old_frag_offset)
3355     {
3356       last_lineno->frag = frag_now;
3357       last_lineno->paddr = frag_now_fix ();
3358     }
3359 }
3360 \f
3361 /* Make sure the @stabs symbol is emitted.  */
3362
3363 static void
3364 mark_stabs (ignore)
3365      int ignore;
3366 {
3367   if (! stabs_seen)
3368     {
3369       /* Add a dummy @stabs dymbol.  */
3370       stabs_seen = 1;
3371       (void) add_ecoff_symbol (stabs_symbol, stNil, scInfo,
3372                                (symbolS *) NULL,
3373                                (bfd_vma) 0, (symint_t) -1,
3374                                ECOFF_MARK_STAB (0));
3375     }
3376 }
3377 \f
3378 /* Parse .weakext directives.  */
3379 #ifndef TC_MIPS
3380 /* For TC_MIPS use the version in tc-mips.c.  */
3381 void
3382 ecoff_directive_weakext (ignore)
3383      int ignore;
3384 {
3385   char *name;
3386   int c;
3387   symbolS *symbolP;
3388   expressionS exp;
3389
3390   name = input_line_pointer;
3391   c = get_symbol_end ();
3392   symbolP = symbol_find_or_make (name);
3393   *input_line_pointer = c;
3394
3395   SKIP_WHITESPACE ();
3396
3397   if (*input_line_pointer == ',')
3398     {
3399       if (S_IS_DEFINED (symbolP))
3400         {
3401           as_bad (_("Ignoring attempt to redefine symbol `%s'."),
3402                   S_GET_NAME (symbolP));
3403           ignore_rest_of_line ();
3404           return;
3405         }
3406
3407       ++input_line_pointer;
3408       SKIP_WHITESPACE ();
3409       if (! is_end_of_line[(unsigned char) *input_line_pointer])
3410         {
3411           expression (&exp);
3412           if (exp.X_op != O_symbol)
3413             {
3414               as_bad (_("bad .weakext directive"));
3415               ignore_rest_of_line ();
3416               return;
3417             }
3418           symbol_set_value_expression (symbolP, &exp);
3419         }
3420     }
3421
3422   S_SET_WEAK (symbolP);
3423
3424   demand_empty_rest_of_line ();
3425 }
3426 #endif /* not TC_MIPS */
3427 \f
3428 /* Handle .stabs directives.  The actual parsing routine is done by a
3429    generic routine.  This routine is called via OBJ_PROCESS_STAB.
3430    When this is called, input_line_pointer will be pointing at the
3431    value field of the stab.
3432
3433    .stabs directives have five fields:
3434         "string"        a string, encoding the type information.
3435         code            a numeric code, defined in <stab.h>
3436         0               a zero
3437         desc            a zero or line number
3438         value           a numeric value or an address.
3439
3440     If the value is relocatable, we transform this into:
3441         iss             points as an index into string space
3442         value           value from lookup of the name
3443         st              st from lookup of the name
3444         sc              sc from lookup of the name
3445         index           code|CODE_MASK
3446
3447     If the value is not relocatable, we transform this into:
3448         iss             points as an index into string space
3449         value           value
3450         st              st_Nil
3451         sc              sc_Nil
3452         index           code|CODE_MASK
3453
3454     .stabn directives have four fields (string is null):
3455         code            a numeric code, defined in <stab.h>
3456         0               a zero
3457         desc            a zero or a line number
3458         value           a numeric value or an address.  */
3459
3460 void
3461 ecoff_stab (sec, what, string, type, other, desc)
3462      segT sec;
3463      int what;
3464      const char *string;
3465      int type;
3466      int other;
3467      int desc;
3468 {
3469   efdr_t *save_file_ptr = cur_file_ptr;
3470   symbolS *sym;
3471   symint_t value;
3472   bfd_vma addend;
3473   st_t st;
3474   sc_t sc;
3475   symint_t indx;
3476   localsym_t *hold = NULL;
3477
3478   ecoff_debugging_seen = 1;
3479
3480   /* We don't handle .stabd.  */
3481   if (what != 's' && what != 'n')
3482     {
3483       as_bad (_(".stab%c is not supported"), what);
3484       return;
3485     }
3486
3487   /* A .stabn uses a null name, not an empty string.  */
3488   if (what == 'n')
3489     string = NULL;
3490
3491   /* We ignore the other field.  */
3492   if (other != 0)
3493     as_warn (_(".stab%c: ignoring non-zero other field"), what);
3494
3495   /* Make sure we have a current file.  */
3496   if (cur_file_ptr == (efdr_t *) NULL)
3497     {
3498       add_file ((const char *) NULL, 0, 1);
3499       save_file_ptr = cur_file_ptr;
3500     }
3501
3502   /* For stabs in ECOFF, the first symbol must be @stabs.  This is a
3503      signal to gdb.  */
3504   if (stabs_seen == 0)
3505     mark_stabs (0);
3506
3507   /* Line number stabs are handled differently, since they have two
3508      values, the line number and the address of the label.  We use the
3509      index field (aka desc) to hold the line number, and the value
3510      field to hold the address.  The symbol type is st_Label, which
3511      should be different from the other stabs, so that gdb can
3512      recognize it.  */
3513   if (type == N_SLINE)
3514     {
3515       SYMR dummy_symr;
3516       char *name;
3517       char name_end;
3518
3519 #ifndef NO_LISTING
3520       if (listing)
3521         listing_source_line ((unsigned int) desc);
3522 #endif
3523
3524       dummy_symr.index = desc;
3525       if (dummy_symr.index != desc)
3526         {
3527           as_warn (_("Line number (%d) for .stab%c directive cannot fit in index field (20 bits)"),
3528                    desc, what);
3529           return;
3530         }
3531
3532       name = input_line_pointer;
3533       name_end = get_symbol_end ();
3534
3535       sym = symbol_find_or_make (name);
3536       *input_line_pointer = name_end;
3537
3538       value = 0;
3539       addend = 0;
3540       st = st_Label;
3541       sc = sc_Text;
3542       indx = desc;
3543     }
3544   else
3545     {
3546 #ifndef NO_LISTING
3547       if (listing && (type == N_SO || type == N_SOL))
3548         listing_source_file (string);
3549 #endif
3550
3551       if (isdigit ((unsigned char) *input_line_pointer)
3552           || *input_line_pointer == '-'
3553           || *input_line_pointer == '+')
3554         {
3555           st = st_Nil;
3556           sc = sc_Nil;
3557           sym = (symbolS *) NULL;
3558           value = get_absolute_expression ();
3559           addend = 0;
3560         }
3561       else if (! is_name_beginner ((unsigned char) *input_line_pointer))
3562         {
3563           as_warn (_("Illegal .stab%c directive, bad character"), what);
3564           return;
3565         }
3566       else
3567         {
3568           expressionS exp;
3569
3570           sc = sc_Nil;
3571           st = st_Nil;
3572
3573           expression (&exp);
3574           if (exp.X_op == O_constant)
3575             {
3576               sym = NULL;
3577               value = exp.X_add_number;
3578               addend = 0;
3579             }
3580           else if (exp.X_op == O_symbol)
3581             {
3582               sym = exp.X_add_symbol;
3583               value = 0;
3584               addend = exp.X_add_number;
3585             }
3586           else
3587             {
3588               sym = make_expr_symbol (&exp);
3589               value = 0;
3590               addend = 0;
3591             }
3592         }
3593
3594       indx = ECOFF_MARK_STAB (type);
3595     }
3596
3597   /* Don't store the stabs symbol we are creating as the type of the
3598      ECOFF symbol.  We want to compute the type of the ECOFF symbol
3599      independently.  */
3600   if (sym != (symbolS *) NULL)
3601     hold = symbol_get_obj (sym)->ecoff_symbol;
3602
3603   (void) add_ecoff_symbol (string, st, sc, sym, addend, value, indx);
3604
3605   if (sym != (symbolS *) NULL)
3606     symbol_get_obj (sym)->ecoff_symbol = hold;
3607
3608   /* Restore normal file type.  */
3609   cur_file_ptr = save_file_ptr;
3610 }
3611 \f
3612 /* Frob an ECOFF symbol.  Small common symbols go into a special
3613    .scommon section rather than bfd_com_section.  */
3614
3615 void
3616 ecoff_frob_symbol (sym)
3617      symbolS *sym;
3618 {
3619   if (S_IS_COMMON (sym)
3620       && S_GET_VALUE (sym) > 0
3621       && S_GET_VALUE (sym) <= bfd_get_gp_size (stdoutput))
3622     {
3623       static asection scom_section;
3624       static asymbol scom_symbol;
3625
3626       /* We must construct a fake section similar to bfd_com_section
3627          but with the name .scommon.  */
3628       if (scom_section.name == NULL)
3629         {
3630           scom_section = bfd_com_section;
3631           scom_section.name = ".scommon";
3632           scom_section.output_section = &scom_section;
3633           scom_section.symbol = &scom_symbol;
3634           scom_section.symbol_ptr_ptr = &scom_section.symbol;
3635           scom_symbol = *bfd_com_section.symbol;
3636           scom_symbol.name = ".scommon";
3637           scom_symbol.section = &scom_section;
3638         }
3639       S_SET_SEGMENT (sym, &scom_section);
3640     }
3641
3642   /* Double check weak symbols.  */
3643   if (S_IS_WEAK (sym))
3644     {
3645       if (S_IS_COMMON (sym))
3646         as_bad (_("Symbol `%s' can not be both weak and common"),
3647                 S_GET_NAME (sym));
3648     }
3649 }
3650 \f
3651 /* Add bytes to the symbolic information buffer.  */
3652
3653 static char *
3654 ecoff_add_bytes (buf, bufend, bufptr, need)
3655      char **buf;
3656      char **bufend;
3657      char *bufptr;
3658      unsigned long need;
3659 {
3660   unsigned long at;
3661   unsigned long want;
3662
3663   at = bufptr - *buf;
3664   need -= *bufend - bufptr;
3665   if (need < PAGE_SIZE)
3666     need = PAGE_SIZE;
3667   want = (*bufend - *buf) + need;
3668   *buf = xrealloc (*buf, want);
3669   *bufend = *buf + want;
3670   return *buf + at;
3671 }
3672
3673 /* Adjust the symbolic information buffer to the alignment required
3674    for the ECOFF target debugging information.  */
3675
3676 static unsigned long
3677 ecoff_padding_adjust (backend, buf, bufend, offset, bufptrptr)
3678      const struct ecoff_debug_swap *backend;
3679      char **buf;
3680      char **bufend;
3681      unsigned long offset;
3682      char **bufptrptr;
3683 {
3684   bfd_size_type align;
3685
3686   align = backend->debug_align;
3687   if ((offset & (align - 1)) != 0)
3688     {
3689       unsigned long add;
3690
3691       add = align - (offset & (align - 1));
3692       if (*bufend - (*buf + offset) < add)
3693         (void) ecoff_add_bytes (buf, bufend, *buf + offset, add);
3694       memset (*buf + offset, 0, add);
3695       offset += add;
3696       if (bufptrptr != (char **) NULL)
3697         *bufptrptr = *buf + offset;
3698     }
3699
3700   return offset;
3701 }
3702
3703 /* Build the line number information.  */
3704
3705 static unsigned long
3706 ecoff_build_lineno (backend, buf, bufend, offset, linecntptr)
3707      const struct ecoff_debug_swap *backend;
3708      char **buf;
3709      char **bufend;
3710      unsigned long offset;
3711      long *linecntptr;
3712 {
3713   char *bufptr;
3714   register lineno_list_t *l;
3715   lineno_list_t *last;
3716   efdr_t *file;
3717   proc_t *proc;
3718   unsigned long c;
3719   long iline;
3720   long totcount;
3721   lineno_list_t first;
3722   lineno_list_t *local_first_lineno = first_lineno;
3723
3724   if (linecntptr != (long *) NULL)
3725     *linecntptr = 0;
3726
3727   bufptr = *buf + offset;
3728
3729   file = (efdr_t *) NULL;
3730   proc = (proc_t *) NULL;
3731   last = (lineno_list_t *) NULL;
3732   c = offset;
3733   iline = 0;
3734   totcount = 0;
3735
3736   /* For some reason the address of the first procedure is ignored
3737      when reading line numbers.  This doesn't matter if the address of
3738      the first procedure is 0, but when gcc is generating MIPS
3739      embedded PIC code, it will put strings in the .text section
3740      before the first procedure.  We cope by inserting a dummy line if
3741      the address of the first procedure is not 0.  Hopefully this
3742      won't screw things up too badly.
3743
3744      Don't do this for ECOFF assembly source line numbers.  They work
3745      without this extra attention.  */
3746   if (debug_type != DEBUG_ECOFF
3747       && first_proc_ptr != (proc_t *) NULL
3748       && local_first_lineno != (lineno_list_t *) NULL
3749       && ((S_GET_VALUE (first_proc_ptr->sym->as_sym)
3750            + bfd_get_section_vma (stdoutput,
3751                                   S_GET_SEGMENT (first_proc_ptr->sym->as_sym)))
3752           != 0))
3753     {
3754       first.file = local_first_lineno->file;
3755       first.proc = local_first_lineno->proc;
3756       first.frag = &zero_address_frag;
3757       first.paddr = 0;
3758       first.lineno = 0;
3759
3760       first.next = local_first_lineno;
3761       local_first_lineno = &first;
3762     }
3763
3764   for (l = local_first_lineno; l != (lineno_list_t *) NULL; l = l->next)
3765     {
3766       long count;
3767       long delta;
3768
3769       /* Get the offset to the memory address of the next line number
3770          (in words).  Do this first, so that we can skip ahead to the
3771          next useful line number entry.  */
3772       if (l->next == (lineno_list_t *) NULL)
3773         {
3774           /* We want a count of zero, but it will be decremented
3775              before it is used.  */
3776           count = 1;
3777         }
3778       else if (l->next->frag->fr_address + l->next->paddr
3779                > l->frag->fr_address + l->paddr)
3780         {
3781           count = ((l->next->frag->fr_address + l->next->paddr
3782                     - (l->frag->fr_address + l->paddr))
3783                    >> 2);
3784         }
3785       else
3786         {
3787           /* Don't change last, so we still get the right delta.  */
3788           continue;
3789         }
3790
3791       if (l->file != file || l->proc != proc)
3792         {
3793           if (l->proc != proc && proc != (proc_t *) NULL)
3794             proc->pdr.lnHigh = last->lineno;
3795           if (l->file != file && file != (efdr_t *) NULL)
3796             {
3797               file->fdr.cbLine = c - file->fdr.cbLineOffset;
3798               file->fdr.cline = totcount + count;
3799               if (linecntptr != (long *) NULL)
3800                 *linecntptr += totcount + count;
3801               totcount = 0;
3802             }
3803
3804           if (l->file != file)
3805             {
3806               efdr_t *last_file = file;
3807
3808               file = l->file;
3809               if (last_file != (efdr_t *) NULL)
3810                 file->fdr.ilineBase
3811                   = last_file->fdr.ilineBase + last_file->fdr.cline;
3812               else
3813                 file->fdr.ilineBase = 0;
3814               file->fdr.cbLineOffset = c;
3815             }
3816           if (l->proc != proc)
3817             {
3818               proc = l->proc;
3819               if (proc != (proc_t *) NULL)
3820                 {
3821                   proc->pdr.lnLow = l->lineno;
3822                   proc->pdr.cbLineOffset = c - file->fdr.cbLineOffset;
3823                   proc->pdr.iline = totcount;
3824                 }
3825             }
3826
3827           last = (lineno_list_t *) NULL;
3828         }
3829
3830       totcount += count;
3831
3832       /* Get the offset to this line number.  */
3833       if (last == (lineno_list_t *) NULL)
3834         delta = 0;
3835       else
3836         delta = l->lineno - last->lineno;
3837
3838       /* Put in the offset to this line number.  */
3839       while (delta != 0)
3840         {
3841           int setcount;
3842
3843           /* 1 is added to each count read.  */
3844           --count;
3845           /* We can only adjust the word count by up to 15 words at a
3846              time.  */
3847           if (count <= 0x0f)
3848             {
3849               setcount = count;
3850               count = 0;
3851             }
3852           else
3853             {
3854               setcount = 0x0f;
3855               count -= 0x0f;
3856             }
3857           if (delta >= -7 && delta <= 7)
3858             {
3859               if (bufptr >= *bufend)
3860                 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1);
3861               *bufptr++ = setcount + (delta << 4);
3862               delta = 0;
3863               ++c;
3864             }
3865           else
3866             {
3867               int set;
3868
3869               if (*bufend - bufptr < 3)
3870                 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 3);
3871               *bufptr++ = setcount + (8 << 4);
3872               if (delta < -0x8000)
3873                 {
3874                   set = -0x8000;
3875                   delta += 0x8000;
3876                 }
3877               else if (delta > 0x7fff)
3878                 {
3879                   set = 0x7fff;
3880                   delta -= 0x7fff;
3881                 }
3882               else
3883                 {
3884                   set = delta;
3885                   delta = 0;
3886                 }
3887               *bufptr++ = set >> 8;
3888               *bufptr++ = set & 0xffff;
3889               c += 3;
3890             }
3891         }
3892
3893       /* Finish adjusting the count.  */
3894       while (count > 0)
3895         {
3896           if (bufptr >= *bufend)
3897             bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1);
3898           /* 1 is added to each count read.  */
3899           --count;
3900           if (count > 0x0f)
3901             {
3902               *bufptr++ = 0x0f;
3903               count -= 0x0f;
3904             }
3905           else
3906             {
3907               *bufptr++ = count;
3908               count = 0;
3909             }
3910           ++c;
3911         }
3912
3913       ++iline;
3914       last = l;
3915     }
3916
3917   if (proc != (proc_t *) NULL)
3918     proc->pdr.lnHigh = last->lineno;
3919   if (file != (efdr_t *) NULL)
3920     {
3921       file->fdr.cbLine = c - file->fdr.cbLineOffset;
3922       file->fdr.cline = totcount;
3923     }
3924
3925   if (linecntptr != (long *) NULL)
3926     *linecntptr += totcount;
3927
3928   c = ecoff_padding_adjust (backend, buf, bufend, c, &bufptr);
3929
3930   return c;
3931 }
3932
3933 /* Build and swap out the symbols.  */
3934
3935 static unsigned long
3936 ecoff_build_symbols (backend, buf, bufend, offset)
3937      const struct ecoff_debug_swap *backend;
3938      char **buf;
3939      char **bufend;
3940      unsigned long offset;
3941 {
3942   const bfd_size_type external_sym_size = backend->external_sym_size;
3943   void (* const swap_sym_out) PARAMS ((bfd *, const SYMR *, PTR))
3944     = backend->swap_sym_out;
3945   char *sym_out;
3946   long isym;
3947   vlinks_t *file_link;
3948
3949   sym_out = *buf + offset;
3950
3951   isym = 0;
3952
3953   /* The symbols are stored by file.  */
3954   for (file_link = file_desc.first;
3955        file_link != (vlinks_t *) NULL;
3956        file_link = file_link->next)
3957     {
3958       int ifilesym;
3959       int fil_cnt;
3960       efdr_t *fil_ptr;
3961       efdr_t *fil_end;
3962
3963       if (file_link->next == (vlinks_t *) NULL)
3964         fil_cnt = file_desc.objects_last_page;
3965       else
3966         fil_cnt = file_desc.objects_per_page;
3967       fil_ptr = file_link->datum->file;
3968       fil_end = fil_ptr + fil_cnt;
3969       for (; fil_ptr < fil_end; fil_ptr++)
3970         {
3971           vlinks_t *sym_link;
3972
3973           fil_ptr->fdr.isymBase = isym;
3974           ifilesym = isym;
3975           for (sym_link = fil_ptr->symbols.first;
3976                sym_link != (vlinks_t *) NULL;
3977                sym_link = sym_link->next)
3978             {
3979               int sym_cnt;
3980               localsym_t *sym_ptr;
3981               localsym_t *sym_end;
3982
3983               if (sym_link->next == (vlinks_t *) NULL)
3984                 sym_cnt = fil_ptr->symbols.objects_last_page;
3985               else
3986                 sym_cnt = fil_ptr->symbols.objects_per_page;
3987               sym_ptr = sym_link->datum->sym;
3988               sym_end = sym_ptr + sym_cnt;
3989               for (; sym_ptr < sym_end; sym_ptr++)
3990                 {
3991                   int local;
3992                   symbolS *as_sym;
3993                   forward_t *f;
3994
3995                   know (sym_ptr->file_ptr == fil_ptr);
3996
3997                   /* If there is no associated gas symbol, then this
3998                      is a pure debugging symbol.  We have already
3999                      added the name (if any) to fil_ptr->strings.
4000                      Otherwise we must decide whether this is an
4001                      external or a local symbol (actually, it may be
4002                      both if the local provides additional debugging
4003                      information for the external).  */
4004                   local = 1;
4005                   as_sym = sym_ptr->as_sym;
4006                   if (as_sym != (symbolS *) NULL)
4007                     {
4008                       symint_t indx;
4009
4010                       /* The value of a block start symbol is the
4011                          offset from the start of the procedure.  For
4012                          other symbols we just use the gas value (but
4013                          we must offset it by the vma of the section,
4014                          just as BFD does, because BFD will not see
4015                          this value).  */
4016                       if (sym_ptr->ecoff_sym.asym.st == (int) st_Block
4017                           && sym_ptr->ecoff_sym.asym.sc == (int) sc_Text)
4018                         {
4019                           symbolS *begin_sym;
4020
4021                           know (sym_ptr->proc_ptr != (proc_t *) NULL);
4022                           begin_sym = sym_ptr->proc_ptr->sym->as_sym;
4023                           if (S_GET_SEGMENT (as_sym)
4024                               != S_GET_SEGMENT (begin_sym))
4025                             as_warn (_(".begin/.bend in different segments"));
4026                           sym_ptr->ecoff_sym.asym.value =
4027                             S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym);
4028                         }
4029                       else
4030                         sym_ptr->ecoff_sym.asym.value =
4031                           (S_GET_VALUE (as_sym)
4032                            + bfd_get_section_vma (stdoutput,
4033                                                   S_GET_SEGMENT (as_sym))
4034                            + sym_ptr->addend);
4035
4036                       sym_ptr->ecoff_sym.weakext = S_IS_WEAK (as_sym);
4037
4038                       /* Set st_Proc to st_StaticProc for local
4039                          functions.  */
4040                       if (sym_ptr->ecoff_sym.asym.st == st_Proc
4041                           && S_IS_DEFINED (as_sym)
4042                           && ! S_IS_EXTERNAL (as_sym)
4043                           && ! S_IS_WEAK (as_sym))
4044                         sym_ptr->ecoff_sym.asym.st = st_StaticProc;
4045
4046                       /* Get the type and storage class based on where
4047                          the symbol actually wound up.  Traditionally,
4048                          N_LBRAC and N_RBRAC are *not* relocated.  */
4049                       indx = sym_ptr->ecoff_sym.asym.index;
4050                       if (sym_ptr->ecoff_sym.asym.st == st_Nil
4051                           && sym_ptr->ecoff_sym.asym.sc == sc_Nil
4052                           && (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym)
4053                               || ((ECOFF_UNMARK_STAB (indx) != N_LBRAC)
4054                                   && (ECOFF_UNMARK_STAB (indx) != N_RBRAC))))
4055                         {
4056                           segT seg;
4057                           const char *segname;
4058                           st_t st;
4059                           sc_t sc;
4060
4061                           seg = S_GET_SEGMENT (as_sym);
4062                           segname = segment_name (seg);
4063
4064                           if (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym)
4065                               && (S_IS_EXTERNAL (as_sym)
4066                                   || S_IS_WEAK (as_sym)
4067                                   || ! S_IS_DEFINED (as_sym)))
4068                             {
4069                               if ((symbol_get_bfdsym (as_sym)->flags
4070                                    & BSF_FUNCTION) != 0)
4071                                 st = st_Proc;
4072                               else
4073                                 st = st_Global;
4074                             }
4075                           else if (seg == text_section)
4076                             st = st_Label;
4077                           else
4078                             st = st_Static;
4079
4080                           if (! S_IS_DEFINED (as_sym))
4081                             {
4082                               valueT s;
4083
4084                               s = symbol_get_obj (as_sym)->ecoff_extern_size;
4085                               if (s == 0
4086                                   || s > bfd_get_gp_size (stdoutput))
4087                                 sc = sc_Undefined;
4088                               else
4089                                 {
4090                                   sc = sc_SUndefined;
4091                                   sym_ptr->ecoff_sym.asym.value = s;
4092                                 }
4093 #ifdef S_SET_SIZE
4094                               S_SET_SIZE (as_sym, s);
4095 #endif
4096                             }
4097                           else if (S_IS_COMMON (as_sym))
4098                             {
4099                               if (S_GET_VALUE (as_sym) > 0
4100                                   && (S_GET_VALUE (as_sym)
4101                                       <= bfd_get_gp_size (stdoutput)))
4102                                 sc = sc_SCommon;
4103                               else
4104                                 sc = sc_Common;
4105                             }
4106                           else if (seg == text_section)
4107                             sc = sc_Text;
4108                           else if (seg == data_section)
4109                             sc = sc_Data;
4110                           else if (strcmp (segname, ".rdata") == 0
4111                                    || strcmp (segname, ".rodata") == 0)
4112                             sc = sc_RData;
4113                           else if (strcmp (segname, ".sdata") == 0)
4114                             sc = sc_SData;
4115                           else if (seg == bss_section)
4116                             sc = sc_Bss;
4117                           else if (strcmp (segname, ".sbss") == 0)
4118                             sc = sc_SBss;
4119                           else if (seg == &bfd_abs_section)
4120                             sc = sc_Abs;
4121                           else
4122                             {
4123                               /* This must be a user named section.
4124                                  This is not possible in ECOFF, but it
4125                                  is in ELF.  */
4126                               sc = sc_Data;
4127                             }
4128
4129                           sym_ptr->ecoff_sym.asym.st = (int) st;
4130                           sym_ptr->ecoff_sym.asym.sc = (int) sc;
4131                         }
4132
4133                       /* This is just an external symbol if it is
4134                          outside a procedure and it has a type.
4135                          FIXME: g++ will generate symbols which have
4136                          different names in the debugging information
4137                          than the actual symbol.  Should we handle
4138                          them here?  */
4139                       if ((S_IS_EXTERNAL (as_sym)
4140                            || S_IS_WEAK (as_sym)
4141                            || ! S_IS_DEFINED (as_sym))
4142                           && sym_ptr->proc_ptr == (proc_t *) NULL
4143                           && sym_ptr->ecoff_sym.asym.st != (int) st_Nil
4144                           && ! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym))
4145                         local = 0;
4146
4147                       /* This is just an external symbol if it is a
4148                          common symbol.  */
4149                       if (S_IS_COMMON (as_sym))
4150                         local = 0;
4151
4152                       /* If an st_end symbol has an associated gas
4153                          symbol, then it is a local label created for
4154                          a .bend or .end directive.  Stabs line
4155                          numbers will have \001 in the names.  */
4156                       if (local
4157                           && sym_ptr->ecoff_sym.asym.st != st_End
4158                           && strchr (sym_ptr->name, '\001') == 0)
4159                         sym_ptr->ecoff_sym.asym.iss =
4160                           add_string (&fil_ptr->strings,
4161                                       fil_ptr->str_hash,
4162                                       sym_ptr->name,
4163                                       (shash_t **) NULL);
4164                     }
4165
4166                   /* We now know the index of this symbol; fill in
4167                      locations that have been waiting for that
4168                      information.  */
4169                   if (sym_ptr->begin_ptr != (localsym_t *) NULL)
4170                     {
4171                       localsym_t *begin_ptr;
4172                       st_t begin_type;
4173
4174                       know (local);
4175                       begin_ptr = sym_ptr->begin_ptr;
4176                       know (begin_ptr->sym_index != -1);
4177                       sym_ptr->ecoff_sym.asym.index = begin_ptr->sym_index;
4178                       if (sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
4179                         sym_ptr->ecoff_sym.asym.iss =
4180                           begin_ptr->ecoff_sym.asym.iss;
4181
4182                       begin_type = begin_ptr->ecoff_sym.asym.st;
4183                       if (begin_type == st_File
4184                           || begin_type == st_Block)
4185                         {
4186                           begin_ptr->ecoff_sym.asym.index =
4187                             isym - ifilesym + 1;
4188                           (*swap_sym_out) (stdoutput,
4189                                            &begin_ptr->ecoff_sym.asym,
4190                                            (*buf
4191                                             + offset
4192                                             + (begin_ptr->sym_index
4193                                                * external_sym_size)));
4194                         }
4195                       else
4196                         {
4197                           know (begin_ptr->index_ptr != (aux_t *) NULL);
4198                           begin_ptr->index_ptr->data.isym =
4199                             isym - ifilesym + 1;
4200                         }
4201
4202                       /* The value of the symbol marking the end of a
4203                          procedure is the size of the procedure.  The
4204                          value of the symbol marking the end of a
4205                          block is the offset from the start of the
4206                          procedure to the block.  */
4207                       if (begin_type == st_Proc
4208                           || begin_type == st_StaticProc)
4209                         {
4210                           know (as_sym != (symbolS *) NULL);
4211                           know (begin_ptr->as_sym != (symbolS *) NULL);
4212                           if (S_GET_SEGMENT (as_sym)
4213                               != S_GET_SEGMENT (begin_ptr->as_sym))
4214                             as_warn (_(".begin/.bend in different segments"));
4215                           sym_ptr->ecoff_sym.asym.value =
4216                             (S_GET_VALUE (as_sym)
4217                              - S_GET_VALUE (begin_ptr->as_sym));
4218
4219                           /* If the size is odd, this is probably a
4220                              mips16 function; force it to be even.  */
4221                           if ((sym_ptr->ecoff_sym.asym.value & 1) != 0)
4222                             ++sym_ptr->ecoff_sym.asym.value;
4223
4224 #ifdef S_SET_SIZE
4225                           S_SET_SIZE (begin_ptr->as_sym,
4226                                       sym_ptr->ecoff_sym.asym.value);
4227 #endif
4228                         }
4229                       else if (begin_type == st_Block
4230                                && sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
4231                         {
4232                           symbolS *begin_sym;
4233
4234                           know (as_sym != (symbolS *) NULL);
4235                           know (sym_ptr->proc_ptr != (proc_t *) NULL);
4236                           begin_sym = sym_ptr->proc_ptr->sym->as_sym;
4237                           if (S_GET_SEGMENT (as_sym)
4238                               != S_GET_SEGMENT (begin_sym))
4239                             as_warn (_(".begin/.bend in different segments"));
4240                           sym_ptr->ecoff_sym.asym.value =
4241                             S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym);
4242                         }
4243                     }
4244
4245                   for (f = sym_ptr->forward_ref;
4246                        f != (forward_t *) NULL;
4247                        f = f->next)
4248                     {
4249                       know (local);
4250                       f->ifd_ptr->data.isym = fil_ptr->file_index;
4251                       f->index_ptr->data.rndx.index = isym - ifilesym;
4252                     }
4253
4254                   if (local)
4255                     {
4256                       if (*bufend - sym_out < external_sym_size)
4257                         sym_out = ecoff_add_bytes (buf, bufend,
4258                                                    sym_out,
4259                                                    external_sym_size);
4260                       (*swap_sym_out) (stdoutput, &sym_ptr->ecoff_sym.asym,
4261                                        sym_out);
4262                       sym_out += external_sym_size;
4263
4264                       sym_ptr->sym_index = isym;
4265
4266                       if (sym_ptr->proc_ptr != (proc_t *) NULL
4267                           && sym_ptr->proc_ptr->sym == sym_ptr)
4268                         sym_ptr->proc_ptr->pdr.isym = isym - ifilesym;
4269
4270                       ++isym;
4271                     }
4272
4273                   /* Record the local symbol index and file number in
4274                      case this is an external symbol.  Note that this
4275                      destroys the asym.index field.  */
4276                   if (as_sym != (symbolS *) NULL
4277                       && symbol_get_obj (as_sym)->ecoff_symbol == sym_ptr)
4278                     {
4279                       if ((sym_ptr->ecoff_sym.asym.st == st_Proc
4280                            || sym_ptr->ecoff_sym.asym.st == st_StaticProc)
4281                           && local)
4282                         sym_ptr->ecoff_sym.asym.index = isym - ifilesym - 1;
4283                       sym_ptr->ecoff_sym.ifd = fil_ptr->file_index;
4284
4285                       /* Don't try to merge an FDR which has an
4286                          external symbol attached to it.  */
4287                       if (S_IS_EXTERNAL (as_sym) || S_IS_WEAK (as_sym))
4288                         fil_ptr->fdr.fMerge = 0;
4289                     }
4290                 }
4291             }
4292           fil_ptr->fdr.csym = isym - fil_ptr->fdr.isymBase;
4293         }
4294     }
4295
4296   return offset + isym * external_sym_size;
4297 }
4298
4299 /* Swap out the procedure information.  */
4300
4301 static unsigned long
4302 ecoff_build_procs (backend, buf, bufend, offset)
4303      const struct ecoff_debug_swap *backend;
4304      char **buf;
4305      char **bufend;
4306      unsigned long offset;
4307 {
4308   const bfd_size_type external_pdr_size = backend->external_pdr_size;
4309   void (* const swap_pdr_out) PARAMS ((bfd *, const PDR *, PTR))
4310     = backend->swap_pdr_out;
4311   char *pdr_out;
4312   long iproc;
4313   vlinks_t *file_link;
4314
4315   pdr_out = *buf + offset;
4316
4317   iproc = 0;
4318
4319   /* The procedures are stored by file.  */
4320   for (file_link = file_desc.first;
4321        file_link != (vlinks_t *) NULL;
4322        file_link = file_link->next)
4323     {
4324       int fil_cnt;
4325       efdr_t *fil_ptr;
4326       efdr_t *fil_end;
4327
4328       if (file_link->next == (vlinks_t *) NULL)
4329         fil_cnt = file_desc.objects_last_page;
4330       else
4331         fil_cnt = file_desc.objects_per_page;
4332       fil_ptr = file_link->datum->file;
4333       fil_end = fil_ptr + fil_cnt;
4334       for (; fil_ptr < fil_end; fil_ptr++)
4335         {
4336           vlinks_t *proc_link;
4337           int first;
4338
4339           fil_ptr->fdr.ipdFirst = iproc;
4340           first = 1;
4341           for (proc_link = fil_ptr->procs.first;
4342                proc_link != (vlinks_t *) NULL;
4343                proc_link = proc_link->next)
4344             {
4345               int prc_cnt;
4346               proc_t *proc_ptr;
4347               proc_t *proc_end;
4348
4349               if (proc_link->next == (vlinks_t *) NULL)
4350                 prc_cnt = fil_ptr->procs.objects_last_page;
4351               else
4352                 prc_cnt = fil_ptr->procs.objects_per_page;
4353               proc_ptr = proc_link->datum->proc;
4354               proc_end = proc_ptr + prc_cnt;
4355               for (; proc_ptr < proc_end; proc_ptr++)
4356                 {
4357                   symbolS *adr_sym;
4358                   unsigned long adr;
4359
4360                   adr_sym = proc_ptr->sym->as_sym;
4361                   adr = (S_GET_VALUE (adr_sym)
4362                          + bfd_get_section_vma (stdoutput,
4363                                                 S_GET_SEGMENT (adr_sym)));
4364                   if (first)
4365                     {
4366                       /* This code used to force the adr of the very
4367                          first fdr to be 0.  However, the native tools
4368                          don't do that, and I can't remember why it
4369                          used to work that way, so I took it out.  */
4370                       fil_ptr->fdr.adr = adr;
4371                       first = 0;
4372                     }
4373                   proc_ptr->pdr.adr = adr - fil_ptr->fdr.adr;
4374                   if (*bufend - pdr_out < external_pdr_size)
4375                     pdr_out = ecoff_add_bytes (buf, bufend,
4376                                                pdr_out,
4377                                                external_pdr_size);
4378                   (*swap_pdr_out) (stdoutput, &proc_ptr->pdr, pdr_out);
4379                   pdr_out += external_pdr_size;
4380                   ++iproc;
4381                 }
4382             }
4383           fil_ptr->fdr.cpd = iproc - fil_ptr->fdr.ipdFirst;
4384         }
4385     }
4386
4387   return offset + iproc * external_pdr_size;
4388 }
4389
4390 /* Swap out the aux information.  */
4391
4392 static unsigned long
4393 ecoff_build_aux (backend, buf, bufend, offset)
4394      const struct ecoff_debug_swap *backend;
4395      char **buf;
4396      char **bufend;
4397      unsigned long offset;
4398 {
4399   int bigendian;
4400   union aux_ext *aux_out;
4401   long iaux;
4402   vlinks_t *file_link;
4403
4404   bigendian = bfd_big_endian (stdoutput);
4405
4406   aux_out = (union aux_ext *) (*buf + offset);
4407
4408   iaux = 0;
4409
4410   /* The aux entries are stored by file.  */
4411   for (file_link = file_desc.first;
4412        file_link != (vlinks_t *) NULL;
4413        file_link = file_link->next)
4414     {
4415       int fil_cnt;
4416       efdr_t *fil_ptr;
4417       efdr_t *fil_end;
4418
4419       if (file_link->next == (vlinks_t *) NULL)
4420         fil_cnt = file_desc.objects_last_page;
4421       else
4422         fil_cnt = file_desc.objects_per_page;
4423       fil_ptr = file_link->datum->file;
4424       fil_end = fil_ptr + fil_cnt;
4425       for (; fil_ptr < fil_end; fil_ptr++)
4426         {
4427           vlinks_t *aux_link;
4428
4429           fil_ptr->fdr.fBigendian = bigendian;
4430           fil_ptr->fdr.iauxBase = iaux;
4431           for (aux_link = fil_ptr->aux_syms.first;
4432                aux_link != (vlinks_t *) NULL;
4433                aux_link = aux_link->next)
4434             {
4435               int aux_cnt;
4436               aux_t *aux_ptr;
4437               aux_t *aux_end;
4438
4439               if (aux_link->next == (vlinks_t *) NULL)
4440                 aux_cnt = fil_ptr->aux_syms.objects_last_page;
4441               else
4442                 aux_cnt = fil_ptr->aux_syms.objects_per_page;
4443               aux_ptr = aux_link->datum->aux;
4444               aux_end = aux_ptr + aux_cnt;
4445               for (; aux_ptr < aux_end; aux_ptr++)
4446                 {
4447                   if (*bufend - (char *) aux_out < sizeof (union aux_ext))
4448                     aux_out = ((union aux_ext *)
4449                                ecoff_add_bytes (buf, bufend,
4450                                                 (char *) aux_out,
4451                                                 sizeof (union aux_ext)));
4452                   switch (aux_ptr->type)
4453                     {
4454                     case aux_tir:
4455                       (*backend->swap_tir_out) (bigendian,
4456                                                 &aux_ptr->data.ti,
4457                                                 &aux_out->a_ti);
4458                       break;
4459                     case aux_rndx:
4460                       (*backend->swap_rndx_out) (bigendian,
4461                                                  &aux_ptr->data.rndx,
4462                                                  &aux_out->a_rndx);
4463                       break;
4464                     case aux_dnLow:
4465                       AUX_PUT_DNLOW (bigendian, aux_ptr->data.dnLow,
4466                                      aux_out);
4467                       break;
4468                     case aux_dnHigh:
4469                       AUX_PUT_DNHIGH (bigendian, aux_ptr->data.dnHigh,
4470                                       aux_out);
4471                       break;
4472                     case aux_isym:
4473                       AUX_PUT_ISYM (bigendian, aux_ptr->data.isym,
4474                                     aux_out);
4475                       break;
4476                     case aux_iss:
4477                       AUX_PUT_ISS (bigendian, aux_ptr->data.iss,
4478                                    aux_out);
4479                       break;
4480                     case aux_width:
4481                       AUX_PUT_WIDTH (bigendian, aux_ptr->data.width,
4482                                      aux_out);
4483                       break;
4484                     case aux_count:
4485                       AUX_PUT_COUNT (bigendian, aux_ptr->data.count,
4486                                      aux_out);
4487                       break;
4488                     }
4489
4490                   ++aux_out;
4491                   ++iaux;
4492                 }
4493             }
4494           fil_ptr->fdr.caux = iaux - fil_ptr->fdr.iauxBase;
4495         }
4496     }
4497
4498   return ecoff_padding_adjust (backend, buf, bufend,
4499                                offset + iaux * sizeof (union aux_ext),
4500                                (char **) NULL);
4501 }
4502
4503 /* Copy out the strings from a varray_t.  This returns the number of
4504    bytes copied, rather than the new offset.  */
4505
4506 static unsigned long
4507 ecoff_build_strings (buf, bufend, offset, vp)
4508      char **buf;
4509      char **bufend;
4510      unsigned long offset;
4511      varray_t *vp;
4512 {
4513   unsigned long istr;
4514   char *str_out;
4515   vlinks_t *str_link;
4516
4517   str_out = *buf + offset;
4518
4519   istr = 0;
4520
4521   for (str_link = vp->first;
4522        str_link != (vlinks_t *) NULL;
4523        str_link = str_link->next)
4524     {
4525       unsigned long str_cnt;
4526
4527       if (str_link->next == (vlinks_t *) NULL)
4528         str_cnt = vp->objects_last_page;
4529       else
4530         str_cnt = vp->objects_per_page;
4531
4532       if (*bufend - str_out < str_cnt)
4533         str_out = ecoff_add_bytes (buf, bufend, str_out, str_cnt);
4534
4535       memcpy (str_out, str_link->datum->byte, str_cnt);
4536       str_out += str_cnt;
4537       istr += str_cnt;
4538     }
4539
4540   return istr;
4541 }
4542
4543 /* Dump out the local strings.  */
4544
4545 static unsigned long
4546 ecoff_build_ss (backend, buf, bufend, offset)
4547      const struct ecoff_debug_swap *backend;
4548      char **buf;
4549      char **bufend;
4550      unsigned long offset;
4551 {
4552   long iss;
4553   vlinks_t *file_link;
4554
4555   iss = 0;
4556
4557   for (file_link = file_desc.first;
4558        file_link != (vlinks_t *) NULL;
4559        file_link = file_link->next)
4560     {
4561       int fil_cnt;
4562       efdr_t *fil_ptr;
4563       efdr_t *fil_end;
4564
4565       if (file_link->next == (vlinks_t *) NULL)
4566         fil_cnt = file_desc.objects_last_page;
4567       else
4568         fil_cnt = file_desc.objects_per_page;
4569       fil_ptr = file_link->datum->file;
4570       fil_end = fil_ptr + fil_cnt;
4571       for (; fil_ptr < fil_end; fil_ptr++)
4572         {
4573           long ss_cnt;
4574
4575           fil_ptr->fdr.issBase = iss;
4576           ss_cnt = ecoff_build_strings (buf, bufend, offset + iss,
4577                                         &fil_ptr->strings);
4578           fil_ptr->fdr.cbSs = ss_cnt;
4579           iss += ss_cnt;
4580         }
4581     }
4582
4583   return ecoff_padding_adjust (backend, buf, bufend, offset + iss,
4584                                (char **) NULL);
4585 }
4586
4587 /* Swap out the file descriptors.  */
4588
4589 static unsigned long
4590 ecoff_build_fdr (backend, buf, bufend, offset)
4591      const struct ecoff_debug_swap *backend;
4592      char **buf;
4593      char **bufend;
4594      unsigned long offset;
4595 {
4596   const bfd_size_type external_fdr_size = backend->external_fdr_size;
4597   void (* const swap_fdr_out) PARAMS ((bfd *, const FDR *, PTR))
4598     = backend->swap_fdr_out;
4599   long ifile;
4600   char *fdr_out;
4601   vlinks_t *file_link;
4602
4603   ifile = 0;
4604
4605   fdr_out = *buf + offset;
4606
4607   for (file_link = file_desc.first;
4608        file_link != (vlinks_t *) NULL;
4609        file_link = file_link->next)
4610     {
4611       int fil_cnt;
4612       efdr_t *fil_ptr;
4613       efdr_t *fil_end;
4614
4615       if (file_link->next == (vlinks_t *) NULL)
4616         fil_cnt = file_desc.objects_last_page;
4617       else
4618         fil_cnt = file_desc.objects_per_page;
4619       fil_ptr = file_link->datum->file;
4620       fil_end = fil_ptr + fil_cnt;
4621       for (; fil_ptr < fil_end; fil_ptr++)
4622         {
4623           if (*bufend - fdr_out < external_fdr_size)
4624             fdr_out = ecoff_add_bytes (buf, bufend, fdr_out,
4625                                        external_fdr_size);
4626           (*swap_fdr_out) (stdoutput, &fil_ptr->fdr, fdr_out);
4627           fdr_out += external_fdr_size;
4628           ++ifile;
4629         }
4630     }
4631
4632   return offset + ifile * external_fdr_size;
4633 }
4634
4635 /* Set up the external symbols.  These are supposed to be handled by
4636    the backend.  This routine just gets the right information and
4637    calls a backend function to deal with it.  */
4638
4639 static void
4640 ecoff_setup_ext ()
4641 {
4642   register symbolS *sym;
4643
4644   for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
4645     {
4646       if (symbol_get_obj (sym)->ecoff_symbol == NULL)
4647         continue;
4648
4649       /* If this is a local symbol, then force the fields to zero.  */
4650       if (! S_IS_EXTERNAL (sym)
4651           && ! S_IS_WEAK (sym)
4652           && S_IS_DEFINED (sym))
4653         {
4654           struct localsym *lsym;
4655
4656           lsym = symbol_get_obj (sym)->ecoff_symbol;
4657           lsym->ecoff_sym.asym.value = 0;
4658           lsym->ecoff_sym.asym.st = (int) st_Nil;
4659           lsym->ecoff_sym.asym.sc = (int) sc_Nil;
4660           lsym->ecoff_sym.asym.index = indexNil;
4661         }
4662
4663       obj_ecoff_set_ext (sym, &symbol_get_obj (sym)->ecoff_symbol->ecoff_sym);
4664     }
4665 }
4666
4667 /* Build the ECOFF debugging information.  */
4668
4669 unsigned long
4670 ecoff_build_debug (hdr, bufp, backend)
4671      HDRR *hdr;
4672      char **bufp;
4673      const struct ecoff_debug_swap *backend;
4674 {
4675   const bfd_size_type external_pdr_size = backend->external_pdr_size;
4676   tag_t *ptag;
4677   tag_t *ptag_next;
4678   efdr_t *fil_ptr;
4679   int end_warning;
4680   efdr_t *hold_file_ptr;
4681   proc_t *hold_proc_ptr;
4682   symbolS *sym;
4683   char *buf;
4684   char *bufend;
4685   unsigned long offset;
4686
4687   /* Make sure we have a file.  */
4688   if (first_file == (efdr_t *) NULL)
4689     add_file ((const char *) NULL, 0, 1);
4690
4691   /* Handle any top level tags.  */
4692   for (ptag = top_tag_head->first_tag;
4693        ptag != (tag_t *) NULL;
4694        ptag = ptag_next)
4695     {
4696       if (ptag->forward_ref != (forward_t *) NULL)
4697         add_unknown_tag (ptag);
4698
4699       ptag_next = ptag->same_block;
4700       ptag->hash_ptr->tag_ptr = ptag->same_name;
4701       free_tag (ptag);
4702     }
4703
4704   free_thead (top_tag_head);
4705
4706   /* Look through the symbols.  Add debugging information for each
4707      symbol that has not already received it.  */
4708   hold_file_ptr = cur_file_ptr;
4709   hold_proc_ptr = cur_proc_ptr;
4710   cur_proc_ptr = (proc_t *) NULL;
4711   for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
4712     {
4713       if (symbol_get_obj (sym)->ecoff_symbol != NULL
4714           || symbol_get_obj (sym)->ecoff_file == (efdr_t *) NULL
4715           || (symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) != 0)
4716         continue;
4717
4718       cur_file_ptr = symbol_get_obj (sym)->ecoff_file;
4719       add_ecoff_symbol ((const char *) NULL, st_Nil, sc_Nil, sym,
4720                         (bfd_vma) 0, S_GET_VALUE (sym), indexNil);
4721     }
4722   cur_proc_ptr = hold_proc_ptr;
4723   cur_file_ptr = hold_file_ptr;
4724
4725   /* Output an ending symbol for all the files.  We have to do this
4726      here for the last file, so we may as well do it for all of the
4727      files.  */
4728   end_warning = 0;
4729   for (fil_ptr = first_file;
4730        fil_ptr != (efdr_t *) NULL;
4731        fil_ptr = fil_ptr->next_file)
4732     {
4733       cur_file_ptr = fil_ptr;
4734       while (cur_file_ptr->cur_scope != (scope_t *) NULL
4735              && cur_file_ptr->cur_scope->prev != (scope_t *) NULL)
4736         {
4737           cur_file_ptr->cur_scope = cur_file_ptr->cur_scope->prev;
4738           if (! end_warning && ! cur_file_ptr->fake)
4739             {
4740               as_warn (_("Missing .end or .bend at end of file"));
4741               end_warning = 1;
4742             }
4743         }
4744       if (cur_file_ptr->cur_scope != (scope_t *) NULL)
4745         (void) add_ecoff_symbol ((const char *) NULL,
4746                                  st_End, sc_Text,
4747                                  (symbolS *) NULL,
4748                                  (bfd_vma) 0,
4749                                  (symint_t) 0,
4750                                  (symint_t) 0);
4751     }
4752
4753   /* Build the symbolic information.  */
4754   offset = 0;
4755   buf = xmalloc (PAGE_SIZE);
4756   bufend = buf + PAGE_SIZE;
4757
4758   /* Build the line number information.  */
4759   hdr->cbLineOffset = offset;
4760   offset = ecoff_build_lineno (backend, &buf, &bufend, offset,
4761                                &hdr->ilineMax);
4762   hdr->cbLine = offset - hdr->cbLineOffset;
4763
4764   /* We don't use dense numbers at all.  */
4765   hdr->idnMax = 0;
4766   hdr->cbDnOffset = 0;
4767
4768   /* We can't build the PDR table until we have built the symbols,
4769      because a PDR contains a symbol index.  However, we set aside
4770      space at this point.  */
4771   hdr->ipdMax = proc_cnt;
4772   hdr->cbPdOffset = offset;
4773   if (bufend - (buf + offset) < proc_cnt * external_pdr_size)
4774     (void) ecoff_add_bytes (&buf, &bufend, buf + offset,
4775                             proc_cnt * external_pdr_size);
4776   offset += proc_cnt * external_pdr_size;
4777
4778   /* Build the local symbols.  */
4779   hdr->cbSymOffset = offset;
4780   offset = ecoff_build_symbols (backend, &buf, &bufend, offset);
4781   hdr->isymMax = (offset - hdr->cbSymOffset) / backend->external_sym_size;
4782
4783   /* Building the symbols initializes the symbol index in the PDR's.
4784      Now we can swap out the PDR's.  */
4785   (void) ecoff_build_procs (backend, &buf, &bufend, hdr->cbPdOffset);
4786
4787   /* We don't use optimization symbols.  */
4788   hdr->ioptMax = 0;
4789   hdr->cbOptOffset = 0;
4790
4791   /* Swap out the auxiliary type information.  */
4792   hdr->cbAuxOffset = offset;
4793   offset = ecoff_build_aux (backend, &buf, &bufend, offset);
4794   hdr->iauxMax = (offset - hdr->cbAuxOffset) / sizeof (union aux_ext);
4795
4796   /* Copy out the local strings.  */
4797   hdr->cbSsOffset = offset;
4798   offset = ecoff_build_ss (backend, &buf, &bufend, offset);
4799   hdr->issMax = offset - hdr->cbSsOffset;
4800
4801   /* We don't use relative file descriptors.  */
4802   hdr->crfd = 0;
4803   hdr->cbRfdOffset = 0;
4804
4805   /* Swap out the file descriptors.  */
4806   hdr->cbFdOffset = offset;
4807   offset = ecoff_build_fdr (backend, &buf, &bufend, offset);
4808   hdr->ifdMax = (offset - hdr->cbFdOffset) / backend->external_fdr_size;
4809
4810   /* Set up the external symbols, which are handled by the BFD back
4811      end.  */
4812   hdr->issExtMax = 0;
4813   hdr->cbSsExtOffset = 0;
4814   hdr->iextMax = 0;
4815   hdr->cbExtOffset = 0;
4816   ecoff_setup_ext ();
4817
4818   know ((offset & (backend->debug_align - 1)) == 0);
4819
4820   /* FIXME: This value should be determined from the .verstamp directive,
4821      with reasonable defaults in config files.  */
4822 #ifdef TC_ALPHA
4823   hdr->vstamp = 0x030b;
4824 #else
4825   hdr->vstamp = 0x020b;
4826 #endif
4827
4828   *bufp = buf;
4829   return offset;
4830 }
4831 \f
4832 /* Allocate a cluster of pages.  */
4833
4834 #ifndef MALLOC_CHECK
4835
4836 static page_type *
4837 allocate_cluster (npages)
4838      unsigned long npages;
4839 {
4840   register page_type *value = (page_type *) xmalloc (npages * PAGE_USIZE);
4841
4842 #ifdef ECOFF_DEBUG
4843   if (debug > 3)
4844     fprintf (stderr, "\talloc\tnpages = %d, value = 0x%.8x\n", npages, value);
4845 #endif
4846
4847   memset (value, 0, npages * PAGE_USIZE);
4848
4849   return value;
4850 }
4851
4852 static page_type *cluster_ptr = NULL;
4853 static unsigned long pages_left = 0;
4854
4855 #endif /* MALLOC_CHECK */
4856
4857 /* Allocate one page (which is initialized to 0).  */
4858
4859 static page_type *
4860 allocate_page ()
4861 {
4862 #ifndef MALLOC_CHECK
4863
4864   if (pages_left == 0)
4865     {
4866       pages_left = MAX_CLUSTER_PAGES;
4867       cluster_ptr = allocate_cluster (pages_left);
4868     }
4869
4870   pages_left--;
4871   return cluster_ptr++;
4872
4873 #else /* MALLOC_CHECK */
4874
4875   page_type *ptr;
4876
4877   ptr = xmalloc (PAGE_USIZE);
4878   memset (ptr, 0, PAGE_USIZE);
4879   return ptr;
4880
4881 #endif /* MALLOC_CHECK */
4882 }
4883 \f
4884 /* Allocate scoping information.  */
4885
4886 static scope_t *
4887 allocate_scope ()
4888 {
4889   register scope_t *ptr;
4890   static scope_t initial_scope;
4891
4892 #ifndef MALLOC_CHECK
4893
4894   ptr = alloc_counts[(int) alloc_type_scope].free_list.f_scope;
4895   if (ptr != (scope_t *) NULL)
4896     alloc_counts[(int) alloc_type_scope].free_list.f_scope = ptr->free;
4897   else
4898     {
4899       register int unallocated  = alloc_counts[(int) alloc_type_scope].unallocated;
4900       register page_type *cur_page      = alloc_counts[(int) alloc_type_scope].cur_page;
4901
4902       if (unallocated == 0)
4903         {
4904           unallocated = PAGE_SIZE / sizeof (scope_t);
4905           alloc_counts[(int) alloc_type_scope].cur_page = cur_page = allocate_page ();
4906           alloc_counts[(int) alloc_type_scope].total_pages++;
4907         }
4908
4909       ptr = &cur_page->scope[--unallocated];
4910       alloc_counts[(int) alloc_type_scope].unallocated = unallocated;
4911     }
4912
4913 #else
4914
4915   ptr = (scope_t *) xmalloc (sizeof (scope_t));
4916
4917 #endif
4918
4919   alloc_counts[(int) alloc_type_scope].total_alloc++;
4920   *ptr = initial_scope;
4921   return ptr;
4922 }
4923
4924 /* Free scoping information.  */
4925
4926 static void
4927 free_scope (ptr)
4928      scope_t *ptr;
4929 {
4930   alloc_counts[(int) alloc_type_scope].total_free++;
4931
4932 #ifndef MALLOC_CHECK
4933   ptr->free = alloc_counts[(int) alloc_type_scope].free_list.f_scope;
4934   alloc_counts[(int) alloc_type_scope].free_list.f_scope = ptr;
4935 #else
4936   free ((PTR) ptr);
4937 #endif
4938 }
4939 \f
4940 /* Allocate links for pages in a virtual array.  */
4941
4942 static vlinks_t *
4943 allocate_vlinks ()
4944 {
4945   register vlinks_t *ptr;
4946   static vlinks_t initial_vlinks;
4947
4948 #ifndef MALLOC_CHECK
4949
4950   register int unallocated = alloc_counts[(int) alloc_type_vlinks].unallocated;
4951   register page_type *cur_page = alloc_counts[(int) alloc_type_vlinks].cur_page;
4952
4953   if (unallocated == 0)
4954     {
4955       unallocated = PAGE_SIZE / sizeof (vlinks_t);
4956       alloc_counts[(int) alloc_type_vlinks].cur_page = cur_page = allocate_page ();
4957       alloc_counts[(int) alloc_type_vlinks].total_pages++;
4958     }
4959
4960   ptr = &cur_page->vlinks[--unallocated];
4961   alloc_counts[(int) alloc_type_vlinks].unallocated = unallocated;
4962
4963 #else
4964
4965   ptr = (vlinks_t *) xmalloc (sizeof (vlinks_t));
4966
4967 #endif
4968
4969   alloc_counts[(int) alloc_type_vlinks].total_alloc++;
4970   *ptr = initial_vlinks;
4971   return ptr;
4972 }
4973 \f
4974 /* Allocate string hash buckets.  */
4975
4976 static shash_t *
4977 allocate_shash ()
4978 {
4979   register shash_t *ptr;
4980   static shash_t initial_shash;
4981
4982 #ifndef MALLOC_CHECK
4983
4984   register int unallocated = alloc_counts[(int) alloc_type_shash].unallocated;
4985   register page_type *cur_page = alloc_counts[(int) alloc_type_shash].cur_page;
4986
4987   if (unallocated == 0)
4988     {
4989       unallocated = PAGE_SIZE / sizeof (shash_t);
4990       alloc_counts[(int) alloc_type_shash].cur_page = cur_page = allocate_page ();
4991       alloc_counts[(int) alloc_type_shash].total_pages++;
4992     }
4993
4994   ptr = &cur_page->shash[--unallocated];
4995   alloc_counts[(int) alloc_type_shash].unallocated = unallocated;
4996
4997 #else
4998
4999   ptr = (shash_t *) xmalloc (sizeof (shash_t));
5000
5001 #endif
5002
5003   alloc_counts[(int) alloc_type_shash].total_alloc++;
5004   *ptr = initial_shash;
5005   return ptr;
5006 }
5007 \f
5008 /* Allocate type hash buckets.  */
5009
5010 static thash_t *
5011 allocate_thash ()
5012 {
5013   register thash_t *ptr;
5014   static thash_t initial_thash;
5015
5016 #ifndef MALLOC_CHECK
5017
5018   register int unallocated = alloc_counts[(int) alloc_type_thash].unallocated;
5019   register page_type *cur_page = alloc_counts[(int) alloc_type_thash].cur_page;
5020
5021   if (unallocated == 0)
5022     {
5023       unallocated = PAGE_SIZE / sizeof (thash_t);
5024       alloc_counts[(int) alloc_type_thash].cur_page = cur_page = allocate_page ();
5025       alloc_counts[(int) alloc_type_thash].total_pages++;
5026     }
5027
5028   ptr = &cur_page->thash[--unallocated];
5029   alloc_counts[(int) alloc_type_thash].unallocated = unallocated;
5030
5031 #else
5032
5033   ptr = (thash_t *) xmalloc (sizeof (thash_t));
5034
5035 #endif
5036
5037   alloc_counts[(int) alloc_type_thash].total_alloc++;
5038   *ptr = initial_thash;
5039   return ptr;
5040 }
5041 \f
5042 /* Allocate structure, union, or enum tag information.  */
5043
5044 static tag_t *
5045 allocate_tag ()
5046 {
5047   register tag_t *ptr;
5048   static tag_t initial_tag;
5049
5050 #ifndef MALLOC_CHECK
5051
5052   ptr = alloc_counts[(int) alloc_type_tag].free_list.f_tag;
5053   if (ptr != (tag_t *) NULL)
5054     alloc_counts[(int) alloc_type_tag].free_list.f_tag = ptr->free;
5055   else
5056     {
5057       register int unallocated = alloc_counts[(int) alloc_type_tag].unallocated;
5058       register page_type *cur_page = alloc_counts[(int) alloc_type_tag].cur_page;
5059
5060       if (unallocated == 0)
5061         {
5062           unallocated = PAGE_SIZE / sizeof (tag_t);
5063           alloc_counts[(int) alloc_type_tag].cur_page = cur_page = allocate_page ();
5064           alloc_counts[(int) alloc_type_tag].total_pages++;
5065         }
5066
5067       ptr = &cur_page->tag[--unallocated];
5068       alloc_counts[(int) alloc_type_tag].unallocated = unallocated;
5069     }
5070
5071 #else
5072
5073   ptr = (tag_t *) xmalloc (sizeof (tag_t));
5074
5075 #endif
5076
5077   alloc_counts[(int) alloc_type_tag].total_alloc++;
5078   *ptr = initial_tag;
5079   return ptr;
5080 }
5081
5082 /* Free scoping information.  */
5083
5084 static void
5085 free_tag (ptr)
5086      tag_t *ptr;
5087 {
5088   alloc_counts[(int) alloc_type_tag].total_free++;
5089
5090 #ifndef MALLOC_CHECK
5091   ptr->free = alloc_counts[(int) alloc_type_tag].free_list.f_tag;
5092   alloc_counts[(int) alloc_type_tag].free_list.f_tag = ptr;
5093 #else
5094   free ((PTR_T) ptr);
5095 #endif
5096 }
5097 \f
5098 /* Allocate forward reference to a yet unknown tag.  */
5099
5100 static forward_t *
5101 allocate_forward ()
5102 {
5103   register forward_t *ptr;
5104   static forward_t initial_forward;
5105
5106 #ifndef MALLOC_CHECK
5107
5108   register int unallocated = alloc_counts[(int) alloc_type_forward].unallocated;
5109   register page_type *cur_page = alloc_counts[(int) alloc_type_forward].cur_page;
5110
5111   if (unallocated == 0)
5112     {
5113       unallocated = PAGE_SIZE / sizeof (forward_t);
5114       alloc_counts[(int) alloc_type_forward].cur_page = cur_page = allocate_page ();
5115       alloc_counts[(int) alloc_type_forward].total_pages++;
5116     }
5117
5118   ptr = &cur_page->forward[--unallocated];
5119   alloc_counts[(int) alloc_type_forward].unallocated = unallocated;
5120
5121 #else
5122
5123   ptr = (forward_t *) xmalloc (sizeof (forward_t));
5124
5125 #endif
5126
5127   alloc_counts[(int) alloc_type_forward].total_alloc++;
5128   *ptr = initial_forward;
5129   return ptr;
5130 }
5131 \f
5132 /* Allocate head of type hash list.  */
5133
5134 static thead_t *
5135 allocate_thead ()
5136 {
5137   register thead_t *ptr;
5138   static thead_t initial_thead;
5139
5140 #ifndef MALLOC_CHECK
5141
5142   ptr = alloc_counts[(int) alloc_type_thead].free_list.f_thead;
5143   if (ptr != (thead_t *) NULL)
5144     alloc_counts[(int) alloc_type_thead].free_list.f_thead = ptr->free;
5145   else
5146     {
5147       register int unallocated = alloc_counts[(int) alloc_type_thead].unallocated;
5148       register page_type *cur_page = alloc_counts[(int) alloc_type_thead].cur_page;
5149
5150       if (unallocated == 0)
5151         {
5152           unallocated = PAGE_SIZE / sizeof (thead_t);
5153           alloc_counts[(int) alloc_type_thead].cur_page = cur_page = allocate_page ();
5154           alloc_counts[(int) alloc_type_thead].total_pages++;
5155         }
5156
5157       ptr = &cur_page->thead[--unallocated];
5158       alloc_counts[(int) alloc_type_thead].unallocated = unallocated;
5159     }
5160
5161 #else
5162
5163   ptr = (thead_t *) xmalloc (sizeof (thead_t));
5164
5165 #endif
5166
5167   alloc_counts[(int) alloc_type_thead].total_alloc++;
5168   *ptr = initial_thead;
5169   return ptr;
5170 }
5171
5172 /* Free scoping information.  */
5173
5174 static void
5175 free_thead (ptr)
5176      thead_t *ptr;
5177 {
5178   alloc_counts[(int) alloc_type_thead].total_free++;
5179
5180 #ifndef MALLOC_CHECK
5181   ptr->free = (thead_t *) alloc_counts[(int) alloc_type_thead].free_list.f_thead;
5182   alloc_counts[(int) alloc_type_thead].free_list.f_thead = ptr;
5183 #else
5184   free ((PTR_T) ptr);
5185 #endif
5186 }
5187 \f
5188 static lineno_list_t *
5189 allocate_lineno_list ()
5190 {
5191   register lineno_list_t *ptr;
5192   static lineno_list_t initial_lineno_list;
5193
5194 #ifndef MALLOC_CHECK
5195
5196   register int unallocated = alloc_counts[(int) alloc_type_lineno].unallocated;
5197   register page_type *cur_page = alloc_counts[(int) alloc_type_lineno].cur_page;
5198
5199   if (unallocated == 0)
5200     {
5201       unallocated = PAGE_SIZE / sizeof (lineno_list_t);
5202       alloc_counts[(int) alloc_type_lineno].cur_page = cur_page = allocate_page ();
5203       alloc_counts[(int) alloc_type_lineno].total_pages++;
5204     }
5205
5206   ptr = &cur_page->lineno[--unallocated];
5207   alloc_counts[(int) alloc_type_lineno].unallocated = unallocated;
5208
5209 #else
5210
5211   ptr = (lineno_list_t *) xmalloc (sizeof (lineno_list_t));
5212
5213 #endif
5214
5215   alloc_counts[(int) alloc_type_lineno].total_alloc++;
5216   *ptr = initial_lineno_list;
5217   return ptr;
5218 }
5219
5220 void
5221 ecoff_set_gp_prolog_size (sz)
5222      int sz;
5223 {
5224   if (cur_proc_ptr == 0)
5225     return;
5226
5227   cur_proc_ptr->pdr.gp_prologue = sz;
5228   if (cur_proc_ptr->pdr.gp_prologue != sz)
5229     {
5230       as_warn (_("GP prologue size exceeds field size, using 0 instead"));
5231       cur_proc_ptr->pdr.gp_prologue = 0;
5232     }
5233
5234   cur_proc_ptr->pdr.gp_used = 1;
5235 }
5236
5237 int
5238 ecoff_no_current_file ()
5239 {
5240   return cur_file_ptr == (efdr_t *) NULL;
5241 }
5242
5243 void
5244 ecoff_generate_asm_lineno ()
5245 {
5246   unsigned int lineno;
5247   char *filename;
5248   lineno_list_t *list;
5249
5250   as_where (&filename, &lineno);
5251
5252   if (current_stabs_filename == (char *) NULL
5253       || strcmp (current_stabs_filename, filename))
5254     add_file (filename, 0, 1);
5255
5256   list = allocate_lineno_list ();
5257
5258   list->next = (lineno_list_t *) NULL;
5259   list->file = cur_file_ptr;
5260   list->proc = cur_proc_ptr;
5261   list->frag = frag_now;
5262   list->paddr = frag_now_fix ();
5263   list->lineno = lineno;
5264
5265   /* We don't want to merge files which have line numbers.  */
5266   cur_file_ptr->fdr.fMerge = 0;
5267
5268   /* A .loc directive will sometimes appear before a .ent directive,
5269      which means that cur_proc_ptr will be NULL here.  Arrange to
5270      patch this up.  */
5271   if (cur_proc_ptr == (proc_t *) NULL)
5272     {
5273       lineno_list_t **pl;
5274
5275       pl = &noproc_lineno;
5276       while (*pl != (lineno_list_t *) NULL)
5277         pl = &(*pl)->next;
5278       *pl = list;
5279     }
5280   else
5281     {
5282       last_lineno = list;
5283       *last_lineno_ptr = list;
5284       last_lineno_ptr = &list->next;
5285     }
5286 }
5287
5288 #else
5289
5290 void
5291 ecoff_generate_asm_lineno ()
5292 {
5293 }
5294
5295 #endif /* ECOFF_DEBUGGING */