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