gas/ecoff.c

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