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 #if 0
3189   /* Alpha-OSF1 adds "the offset of saved $a0 from $sp", according to
3190      Sandro.  I don't yet know where this value should be stored, if
3191      anywhere.  */
3192   demand_empty_rest_of_line ();
3193 #else
3194   s_ignore (42);
3195 #endif
3196 }
3197 \f
3198 /* Parse .mask directives.  */
3199
3200 void
3201 ecoff_directive_mask (int ignore ATTRIBUTE_UNUSED)
3202 {
3203   long val;
3204
3205   if (cur_proc_ptr == (proc_t *) NULL)
3206     {
3207       as_warn (_(".mask outside of .ent"));
3208       demand_empty_rest_of_line ();
3209       return;
3210     }
3211
3212   if (get_absolute_expression_and_terminator (&val) != ',')
3213     {
3214       as_warn (_("bad .mask directive"));
3215       --input_line_pointer;
3216       demand_empty_rest_of_line ();
3217       return;
3218     }
3219
3220   cur_proc_ptr->pdr.regmask = val;
3221   cur_proc_ptr->pdr.regoffset = get_absolute_expression ();
3222
3223   demand_empty_rest_of_line ();
3224 }
3225 \f
3226 /* Parse .loc directives.  */
3227
3228 void
3229 ecoff_directive_loc (int ignore ATTRIBUTE_UNUSED)
3230 {
3231   lineno_list_t *list;
3232   symint_t lineno;
3233
3234   if (cur_file_ptr == (efdr_t *) NULL)
3235     {
3236       as_warn (_(".loc before .file"));
3237       demand_empty_rest_of_line ();
3238       return;
3239     }
3240
3241   if (now_seg != text_section)
3242     {
3243       as_warn (_(".loc outside of .text"));
3244       demand_empty_rest_of_line ();
3245       return;
3246     }
3247
3248   /* Skip the file number.  */
3249   SKIP_WHITESPACE ();
3250   get_absolute_expression ();
3251   SKIP_WHITESPACE ();
3252
3253   lineno = get_absolute_expression ();
3254
3255 #ifndef NO_LISTING
3256   if (listing)
3257     listing_source_line (lineno);
3258 #endif
3259
3260   /* If we're building stabs, then output a special label rather than
3261      ECOFF line number info.  */
3262   if (stabs_seen)
3263     {
3264       (void) add_ecoff_symbol ((char *) NULL, st_Label, sc_Text,
3265                                symbol_new ("L0\001", now_seg,
3266                                            (valueT) frag_now_fix (),
3267                                            frag_now),
3268                                (bfd_vma) 0, 0, lineno);
3269       return;
3270     }
3271
3272   list = allocate_lineno_list ();
3273
3274   list->next = (lineno_list_t *) NULL;
3275   list->file = cur_file_ptr;
3276   list->proc = cur_proc_ptr;
3277   list->frag = frag_now;
3278   list->paddr = frag_now_fix ();
3279   list->lineno = lineno;
3280
3281   /* We don't want to merge files which have line numbers.  */
3282   cur_file_ptr->fdr.fMerge = 0;
3283
3284   /* A .loc directive will sometimes appear before a .ent directive,
3285      which means that cur_proc_ptr will be NULL here.  Arrange to
3286      patch this up.  */
3287   if (cur_proc_ptr == (proc_t *) NULL)
3288     {
3289       lineno_list_t **pl;
3290
3291       pl = &noproc_lineno;
3292       while (*pl != (lineno_list_t *) NULL)
3293         pl = &(*pl)->next;
3294       *pl = list;
3295     }
3296   else
3297     {
3298       last_lineno = list;
3299       *last_lineno_ptr = list;
3300       last_lineno_ptr = &list->next;
3301     }
3302 }
3303
3304 /* The MIPS assembler sometimes inserts nop instructions in the
3305    instruction stream.  When this happens, we must patch up the .loc
3306    information so that it points to the instruction after the nop.  */
3307
3308 void
3309 ecoff_fix_loc (fragS *old_frag, unsigned long old_frag_offset)
3310 {
3311   if (last_lineno != NULL
3312       && last_lineno->frag == old_frag
3313       && last_lineno->paddr == old_frag_offset)
3314     {
3315       last_lineno->frag = frag_now;
3316       last_lineno->paddr = frag_now_fix ();
3317     }
3318 }
3319 \f
3320 /* Make sure the @stabs symbol is emitted.  */
3321
3322 static void
3323 mark_stabs (int ignore ATTRIBUTE_UNUSED)
3324 {
3325   if (! stabs_seen)
3326     {
3327       /* Add a dummy @stabs dymbol.  */
3328       stabs_seen = 1;
3329       (void) add_ecoff_symbol (stabs_symbol, stNil, scInfo,
3330                                (symbolS *) NULL,
3331                                (bfd_vma) 0, (symint_t) -1,
3332                                ECOFF_MARK_STAB (0));
3333     }
3334 }
3335 \f
3336 /* Parse .weakext directives.  */
3337 #ifndef TC_MIPS
3338 /* For TC_MIPS use the version in tc-mips.c.  */
3339 void
3340 ecoff_directive_weakext (int ignore ATTRIBUTE_UNUSED)
3341 {
3342   char *name;
3343   int c;
3344   symbolS *symbolP;
3345   expressionS exp;
3346
3347   name = input_line_pointer;
3348   c = get_symbol_end ();
3349   symbolP = symbol_find_or_make (name);
3350   *input_line_pointer = c;
3351
3352   SKIP_WHITESPACE ();
3353
3354   if (*input_line_pointer == ',')
3355     {
3356       if (S_IS_DEFINED (symbolP))
3357         {
3358           as_bad (_("symbol `%s' is already defined"),
3359                   S_GET_NAME (symbolP));
3360           ignore_rest_of_line ();
3361           return;
3362         }
3363
3364       ++input_line_pointer;
3365       SKIP_WHITESPACE ();
3366       if (! is_end_of_line[(unsigned char) *input_line_pointer])
3367         {
3368           expression (&exp);
3369           if (exp.X_op != O_symbol)
3370             {
3371               as_bad (_("bad .weakext directive"));
3372               ignore_rest_of_line ();
3373               return;
3374             }
3375           symbol_set_value_expression (symbolP, &exp);
3376         }
3377     }
3378
3379   S_SET_WEAK (symbolP);
3380
3381   demand_empty_rest_of_line ();
3382 }
3383 #endif /* not TC_MIPS */
3384 \f
3385 /* Handle .stabs directives.  The actual parsing routine is done by a
3386    generic routine.  This routine is called via OBJ_PROCESS_STAB.
3387    When this is called, input_line_pointer will be pointing at the
3388    value field of the stab.
3389
3390    .stabs directives have five fields:
3391         "string"        a string, encoding the type information.
3392         code            a numeric code, defined in <stab.h>
3393         0               a zero
3394         desc            a zero or line number
3395         value           a numeric value or an address.
3396
3397     If the value is relocatable, we transform this into:
3398         iss             points as an index into string space
3399         value           value from lookup of the name
3400         st              st from lookup of the name
3401         sc              sc from lookup of the name
3402         index           code|CODE_MASK
3403
3404     If the value is not relocatable, we transform this into:
3405         iss             points as an index into string space
3406         value           value
3407         st              st_Nil
3408         sc              sc_Nil
3409         index           code|CODE_MASK
3410
3411     .stabn directives have four fields (string is null):
3412         code            a numeric code, defined in <stab.h>
3413         0               a zero
3414         desc            a zero or a line number
3415         value           a numeric value or an address.  */
3416
3417 void
3418 ecoff_stab (segT sec ATTRIBUTE_UNUSED,
3419             int what,
3420             const char *string,
3421             int type,
3422             int other,
3423             int desc)
3424 {
3425   efdr_t *save_file_ptr = cur_file_ptr;
3426   symbolS *sym;
3427   symint_t value;
3428   bfd_vma addend;
3429   st_t st;
3430   sc_t sc;
3431   symint_t indx;
3432   localsym_t *hold = NULL;
3433
3434   ecoff_debugging_seen = 1;
3435
3436   /* We don't handle .stabd.  */
3437   if (what != 's' && what != 'n')
3438     {
3439       as_bad (_(".stab%c is not supported"), what);
3440       return;
3441     }
3442
3443   /* A .stabn uses a null name, not an empty string.  */
3444   if (what == 'n')
3445     string = NULL;
3446
3447   /* We ignore the other field.  */
3448   if (other != 0)
3449     as_warn (_(".stab%c: ignoring non-zero other field"), what);
3450
3451   /* Make sure we have a current file.  */
3452   if (cur_file_ptr == (efdr_t *) NULL)
3453     {
3454       add_file ((const char *) NULL, 0, 1);
3455       save_file_ptr = cur_file_ptr;
3456     }
3457
3458   /* For stabs in ECOFF, the first symbol must be @stabs.  This is a
3459      signal to gdb.  */
3460   if (stabs_seen == 0)
3461     mark_stabs (0);
3462
3463   /* Line number stabs are handled differently, since they have two
3464      values, the line number and the address of the label.  We use the
3465      index field (aka desc) to hold the line number, and the value
3466      field to hold the address.  The symbol type is st_Label, which
3467      should be different from the other stabs, so that gdb can
3468      recognize it.  */
3469   if (type == N_SLINE)
3470     {
3471       SYMR dummy_symr;
3472       char *name;
3473       char name_end;
3474
3475 #ifndef NO_LISTING
3476       if (listing)
3477         listing_source_line ((unsigned int) desc);
3478 #endif
3479
3480       dummy_symr.index = desc;
3481       if (dummy_symr.index != desc)
3482         {
3483           as_warn (_("line number (%d) for .stab%c directive cannot fit in index field (20 bits)"),
3484                    desc, what);
3485           return;
3486         }
3487
3488       name = input_line_pointer;
3489       name_end = get_symbol_end ();
3490
3491       sym = symbol_find_or_make (name);
3492       *input_line_pointer = name_end;
3493
3494       value = 0;
3495       addend = 0;
3496       st = st_Label;
3497       sc = sc_Text;
3498       indx = desc;
3499     }
3500   else
3501     {
3502 #ifndef NO_LISTING
3503       if (listing && (type == N_SO || type == N_SOL))
3504         listing_source_file (string);
3505 #endif
3506
3507       if (ISDIGIT (*input_line_pointer)
3508           || *input_line_pointer == '-'
3509           || *input_line_pointer == '+')
3510         {
3511           st = st_Nil;
3512           sc = sc_Nil;
3513           sym = (symbolS *) NULL;
3514           value = get_absolute_expression ();
3515           addend = 0;
3516         }
3517       else if (! is_name_beginner ((unsigned char) *input_line_pointer))
3518         {
3519           as_warn (_("illegal .stab%c directive, bad character"), what);
3520           return;
3521         }
3522       else
3523         {
3524           expressionS exp;
3525
3526           sc = sc_Nil;
3527           st = st_Nil;
3528
3529           expression (&exp);
3530           if (exp.X_op == O_constant)
3531             {
3532               sym = NULL;
3533               value = exp.X_add_number;
3534               addend = 0;
3535             }
3536           else if (exp.X_op == O_symbol)
3537             {
3538               sym = exp.X_add_symbol;
3539               value = 0;
3540               addend = exp.X_add_number;
3541             }
3542           else
3543             {
3544               sym = make_expr_symbol (&exp);
3545               value = 0;
3546               addend = 0;
3547             }
3548         }
3549
3550       indx = ECOFF_MARK_STAB (type);
3551     }
3552
3553   /* Don't store the stabs symbol we are creating as the type of the
3554      ECOFF symbol.  We want to compute the type of the ECOFF symbol
3555      independently.  */
3556   if (sym != (symbolS *) NULL)
3557     hold = symbol_get_obj (sym)->ecoff_symbol;
3558
3559   (void) add_ecoff_symbol (string, st, sc, sym, addend, value, indx);
3560
3561   if (sym != (symbolS *) NULL)
3562     symbol_get_obj (sym)->ecoff_symbol = hold;
3563
3564   /* Restore normal file type.  */
3565   cur_file_ptr = save_file_ptr;
3566 }
3567 \f
3568 /* Frob an ECOFF symbol.  Small common symbols go into a special
3569    .scommon section rather than bfd_com_section.  */
3570
3571 void
3572 ecoff_frob_symbol (symbolS *sym)
3573 {
3574   if (S_IS_COMMON (sym)
3575       && S_GET_VALUE (sym) > 0
3576       && S_GET_VALUE (sym) <= bfd_get_gp_size (stdoutput))
3577     {
3578       static asection scom_section;
3579       static asymbol scom_symbol;
3580
3581       /* We must construct a fake section similar to bfd_com_section
3582          but with the name .scommon.  */
3583       if (scom_section.name == NULL)
3584         {
3585           scom_section = bfd_com_section;
3586           scom_section.name = ".scommon";
3587           scom_section.output_section = &scom_section;
3588           scom_section.symbol = &scom_symbol;
3589           scom_section.symbol_ptr_ptr = &scom_section.symbol;
3590           scom_symbol = *bfd_com_section.symbol;
3591           scom_symbol.name = ".scommon";
3592           scom_symbol.section = &scom_section;
3593         }
3594       S_SET_SEGMENT (sym, &scom_section);
3595     }
3596
3597   /* Double check weak symbols.  */
3598   if (S_IS_WEAK (sym))
3599     {
3600       if (S_IS_COMMON (sym))
3601         as_bad (_("symbol `%s' can not be both weak and common"),
3602                 S_GET_NAME (sym));
3603     }
3604 }
3605 \f
3606 /* Add bytes to the symbolic information buffer.  */
3607
3608 static char *
3609 ecoff_add_bytes (char **buf,
3610                  char **bufend,
3611                  char *bufptr,
3612                  unsigned long need)
3613 {
3614   unsigned long at;
3615   unsigned long want;
3616
3617   at = bufptr - *buf;
3618   need -= *bufend - bufptr;
3619   if (need < PAGE_SIZE)
3620     need = PAGE_SIZE;
3621   want = (*bufend - *buf) + need;
3622   *buf = xrealloc (*buf, want);
3623   *bufend = *buf + want;
3624   return *buf + at;
3625 }
3626
3627 /* Adjust the symbolic information buffer to the alignment required
3628    for the ECOFF target debugging information.  */
3629
3630 static unsigned long
3631 ecoff_padding_adjust (const struct ecoff_debug_swap *backend,
3632                       char **buf,
3633                       char **bufend,
3634                       unsigned long offset,
3635                       char **bufptrptr)
3636 {
3637   bfd_size_type align;
3638
3639   align = backend->debug_align;
3640   if ((offset & (align - 1)) != 0)
3641     {
3642       unsigned long add;
3643
3644       add = align - (offset & (align - 1));
3645       if ((unsigned long) (*bufend - (*buf + offset)) < add)
3646         (void) ecoff_add_bytes (buf, bufend, *buf + offset, add);
3647       memset (*buf + offset, 0, add);
3648       offset += add;
3649       if (bufptrptr != (char **) NULL)
3650         *bufptrptr = *buf + offset;
3651     }
3652
3653   return offset;
3654 }
3655
3656 /* Build the line number information.  */
3657
3658 static unsigned long
3659 ecoff_build_lineno (const struct ecoff_debug_swap *backend,
3660                     char **buf,
3661                     char **bufend,
3662                     unsigned long offset,
3663                     long *linecntptr)
3664 {
3665   char *bufptr;
3666   register lineno_list_t *l;
3667   lineno_list_t *last;
3668   efdr_t *file;
3669   proc_t *proc;
3670   unsigned long c;
3671   long iline;
3672   long totcount;
3673   lineno_list_t first;
3674   lineno_list_t *local_first_lineno = first_lineno;
3675
3676   if (linecntptr != (long *) NULL)
3677     *linecntptr = 0;
3678
3679   bufptr = *buf + offset;
3680
3681   file = (efdr_t *) NULL;
3682   proc = (proc_t *) NULL;
3683   last = (lineno_list_t *) NULL;
3684   c = offset;
3685   iline = 0;
3686   totcount = 0;
3687
3688   /* For some reason the address of the first procedure is ignored
3689      when reading line numbers.  This doesn't matter if the address of
3690      the first procedure is 0, but when gcc is generating MIPS
3691      embedded PIC code, it will put strings in the .text section
3692      before the first procedure.  We cope by inserting a dummy line if
3693      the address of the first procedure is not 0.  Hopefully this
3694      won't screw things up too badly.
3695
3696      Don't do this for ECOFF assembly source line numbers.  They work
3697      without this extra attention.  */
3698   if (debug_type != DEBUG_ECOFF
3699       && first_proc_ptr != (proc_t *) NULL
3700       && local_first_lineno != (lineno_list_t *) NULL
3701       && ((S_GET_VALUE (first_proc_ptr->sym->as_sym)
3702            + bfd_get_section_vma (stdoutput,
3703                                   S_GET_SEGMENT (first_proc_ptr->sym->as_sym)))
3704           != 0))
3705     {
3706       first.file = local_first_lineno->file;
3707       first.proc = local_first_lineno->proc;
3708       first.frag = &zero_address_frag;
3709       first.paddr = 0;
3710       first.lineno = 0;
3711
3712       first.next = local_first_lineno;
3713       local_first_lineno = &first;
3714     }
3715
3716   for (l = local_first_lineno; l != (lineno_list_t *) NULL; l = l->next)
3717     {
3718       long count;
3719       long delta;
3720
3721       /* Get the offset to the memory address of the next line number
3722          (in words).  Do this first, so that we can skip ahead to the
3723          next useful line number entry.  */
3724       if (l->next == (lineno_list_t *) NULL)
3725         {
3726           /* We want a count of zero, but it will be decremented
3727              before it is used.  */
3728           count = 1;
3729         }
3730       else if (l->next->frag->fr_address + l->next->paddr
3731                > l->frag->fr_address + l->paddr)
3732         {
3733           count = ((l->next->frag->fr_address + l->next->paddr
3734                     - (l->frag->fr_address + l->paddr))
3735                    >> 2);
3736         }
3737       else
3738         {
3739           /* Don't change last, so we still get the right delta.  */
3740           continue;
3741         }
3742
3743       if (l->file != file || l->proc != proc)
3744         {
3745           if (l->proc != proc && proc != (proc_t *) NULL)
3746             proc->pdr.lnHigh = last->lineno;
3747           if (l->file != file && file != (efdr_t *) NULL)
3748             {
3749               file->fdr.cbLine = c - file->fdr.cbLineOffset;
3750               file->fdr.cline = totcount + count;
3751               if (linecntptr != (long *) NULL)
3752                 *linecntptr += totcount + count;
3753               totcount = 0;
3754             }
3755
3756           if (l->file != file)
3757             {
3758               efdr_t *last_file = file;
3759
3760               file = l->file;
3761               if (last_file != (efdr_t *) NULL)
3762                 file->fdr.ilineBase
3763                   = last_file->fdr.ilineBase + last_file->fdr.cline;
3764               else
3765                 file->fdr.ilineBase = 0;
3766               file->fdr.cbLineOffset = c;
3767             }
3768           if (l->proc != proc)
3769             {
3770               proc = l->proc;
3771               if (proc != (proc_t *) NULL)
3772                 {
3773                   proc->pdr.lnLow = l->lineno;
3774                   proc->pdr.cbLineOffset = c - file->fdr.cbLineOffset;
3775                   proc->pdr.iline = totcount;
3776                 }
3777             }
3778
3779           last = (lineno_list_t *) NULL;
3780         }
3781
3782       totcount += count;
3783
3784       /* Get the offset to this line number.  */
3785       if (last == (lineno_list_t *) NULL)
3786         delta = 0;
3787       else
3788         delta = l->lineno - last->lineno;
3789
3790       /* Put in the offset to this line number.  */
3791       while (delta != 0)
3792         {
3793           int setcount;
3794
3795           /* 1 is added to each count read.  */
3796           --count;
3797           /* We can only adjust the word count by up to 15 words at a
3798              time.  */
3799           if (count <= 0x0f)
3800             {
3801               setcount = count;
3802               count = 0;
3803             }
3804           else
3805             {
3806               setcount = 0x0f;
3807               count -= 0x0f;
3808             }
3809           if (delta >= -7 && delta <= 7)
3810             {
3811               if (bufptr >= *bufend)
3812                 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1);
3813               *bufptr++ = setcount + (delta << 4);
3814               delta = 0;
3815               ++c;
3816             }
3817           else
3818             {
3819               int set;
3820
3821               if (*bufend - bufptr < 3)
3822                 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 3);
3823               *bufptr++ = setcount + (8 << 4);
3824               if (delta < -0x8000)
3825                 {
3826                   set = -0x8000;
3827                   delta += 0x8000;
3828                 }
3829               else if (delta > 0x7fff)
3830                 {
3831                   set = 0x7fff;
3832                   delta -= 0x7fff;
3833                 }
3834               else
3835                 {
3836                   set = delta;
3837                   delta = 0;
3838                 }
3839               *bufptr++ = set >> 8;
3840               *bufptr++ = set & 0xffff;
3841               c += 3;
3842             }
3843         }
3844
3845       /* Finish adjusting the count.  */
3846       while (count > 0)
3847         {
3848           if (bufptr >= *bufend)
3849             bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1);
3850           /* 1 is added to each count read.  */
3851           --count;
3852           if (count > 0x0f)
3853             {
3854               *bufptr++ = 0x0f;
3855               count -= 0x0f;
3856             }
3857           else
3858             {
3859               *bufptr++ = count;
3860               count = 0;
3861             }
3862           ++c;
3863         }
3864
3865       ++iline;
3866       last = l;
3867     }
3868
3869   if (proc != (proc_t *) NULL)
3870     proc->pdr.lnHigh = last->lineno;
3871   if (file != (efdr_t *) NULL)
3872     {
3873       file->fdr.cbLine = c - file->fdr.cbLineOffset;
3874       file->fdr.cline = totcount;
3875     }
3876
3877   if (linecntptr != (long *) NULL)
3878     *linecntptr += totcount;
3879
3880   c = ecoff_padding_adjust (backend, buf, bufend, c, &bufptr);
3881
3882   return c;
3883 }
3884
3885 /* Build and swap out the symbols.  */
3886
3887 static unsigned long
3888 ecoff_build_symbols (const struct ecoff_debug_swap *backend,
3889                      char **buf,
3890                      char **bufend,
3891                      unsigned long offset)
3892 {
3893   const bfd_size_type external_sym_size = backend->external_sym_size;
3894   void (* const swap_sym_out) (bfd *, const SYMR *, PTR)
3895     = backend->swap_sym_out;
3896   char *sym_out;
3897   long isym;
3898   vlinks_t *file_link;
3899
3900   sym_out = *buf + offset;
3901
3902   isym = 0;
3903
3904   /* The symbols are stored by file.  */
3905   for (file_link = file_desc.first;
3906        file_link != (vlinks_t *) NULL;
3907        file_link = file_link->next)
3908     {
3909       int ifilesym;
3910       int fil_cnt;
3911       efdr_t *fil_ptr;
3912       efdr_t *fil_end;
3913
3914       if (file_link->next == (vlinks_t *) NULL)
3915         fil_cnt = file_desc.objects_last_page;
3916       else
3917         fil_cnt = file_desc.objects_per_page;
3918       fil_ptr = file_link->datum->file;
3919       fil_end = fil_ptr + fil_cnt;
3920       for (; fil_ptr < fil_end; fil_ptr++)
3921         {
3922           vlinks_t *sym_link;
3923
3924           fil_ptr->fdr.isymBase = isym;
3925           ifilesym = isym;
3926           for (sym_link = fil_ptr->symbols.first;
3927                sym_link != (vlinks_t *) NULL;
3928                sym_link = sym_link->next)
3929             {
3930               int sym_cnt;
3931               localsym_t *sym_ptr;
3932               localsym_t *sym_end;
3933
3934               if (sym_link->next == (vlinks_t *) NULL)
3935                 sym_cnt = fil_ptr->symbols.objects_last_page;
3936               else
3937                 sym_cnt = fil_ptr->symbols.objects_per_page;
3938               sym_ptr = sym_link->datum->sym;
3939               sym_end = sym_ptr + sym_cnt;
3940               for (; sym_ptr < sym_end; sym_ptr++)
3941                 {
3942                   int local;
3943                   symbolS *as_sym;
3944                   forward_t *f;
3945
3946                   know (sym_ptr->file_ptr == fil_ptr);
3947
3948                   /* If there is no associated gas symbol, then this
3949                      is a pure debugging symbol.  We have already
3950                      added the name (if any) to fil_ptr->strings.
3951                      Otherwise we must decide whether this is an
3952                      external or a local symbol (actually, it may be
3953                      both if the local provides additional debugging
3954                      information for the external).  */
3955                   local = 1;
3956                   as_sym = sym_ptr->as_sym;
3957                   if (as_sym != (symbolS *) NULL)
3958                     {
3959                       symint_t indx;
3960
3961                       /* The value of a block start symbol is the
3962                          offset from the start of the procedure.  For
3963                          other symbols we just use the gas value (but
3964                          we must offset it by the vma of the section,
3965                          just as BFD does, because BFD will not see
3966                          this value).  */
3967                       if (sym_ptr->ecoff_sym.asym.st == (int) st_Block
3968                           && sym_ptr->ecoff_sym.asym.sc == (int) sc_Text)
3969                         {
3970                           symbolS *begin_sym;
3971
3972                           know (sym_ptr->proc_ptr != (proc_t *) NULL);
3973                           begin_sym = sym_ptr->proc_ptr->sym->as_sym;
3974                           if (S_GET_SEGMENT (as_sym)
3975                               != S_GET_SEGMENT (begin_sym))
3976                             as_warn (_(".begin/.bend in different segments"));
3977                           sym_ptr->ecoff_sym.asym.value =
3978                             S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym);
3979                         }
3980                       else
3981                         sym_ptr->ecoff_sym.asym.value =
3982                           (S_GET_VALUE (as_sym)
3983                            + bfd_get_section_vma (stdoutput,
3984                                                   S_GET_SEGMENT (as_sym))
3985                            + sym_ptr->addend);
3986
3987                       sym_ptr->ecoff_sym.weakext = S_IS_WEAK (as_sym);
3988
3989                       /* Set st_Proc to st_StaticProc for local
3990                          functions.  */
3991                       if (sym_ptr->ecoff_sym.asym.st == st_Proc
3992                           && S_IS_DEFINED (as_sym)
3993                           && ! S_IS_EXTERNAL (as_sym)
3994                           && ! S_IS_WEAK (as_sym))
3995                         sym_ptr->ecoff_sym.asym.st = st_StaticProc;
3996
3997                       /* Get the type and storage class based on where
3998                          the symbol actually wound up.  Traditionally,
3999                          N_LBRAC and N_RBRAC are *not* relocated.  */
4000                       indx = sym_ptr->ecoff_sym.asym.index;
4001                       if (sym_ptr->ecoff_sym.asym.st == st_Nil
4002                           && sym_ptr->ecoff_sym.asym.sc == sc_Nil
4003                           && (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym)
4004                               || ((ECOFF_UNMARK_STAB (indx) != N_LBRAC)
4005                                   && (ECOFF_UNMARK_STAB (indx) != N_RBRAC))))
4006                         {
4007                           segT seg;
4008                           const char *segname;
4009                           st_t st;
4010                           sc_t sc;
4011
4012                           seg = S_GET_SEGMENT (as_sym);
4013                           segname = segment_name (seg);
4014
4015                           if (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym)
4016                               && (S_IS_EXTERNAL (as_sym)
4017                                   || S_IS_WEAK (as_sym)
4018                                   || ! S_IS_DEFINED (as_sym)))
4019                             {
4020                               if ((symbol_get_bfdsym (as_sym)->flags
4021                                    & BSF_FUNCTION) != 0)
4022                                 st = st_Proc;
4023                               else
4024                                 st = st_Global;
4025                             }
4026                           else if (seg == text_section)
4027                             st = st_Label;
4028                           else
4029                             st = st_Static;
4030
4031                           if (! S_IS_DEFINED (as_sym))
4032                             {
4033                               valueT s;
4034
4035                               s = symbol_get_obj (as_sym)->ecoff_extern_size;
4036                               if (s == 0
4037                                   || s > bfd_get_gp_size (stdoutput))
4038                                 sc = sc_Undefined;
4039                               else
4040                                 {
4041                                   sc = sc_SUndefined;
4042                                   sym_ptr->ecoff_sym.asym.value = s;
4043                                 }
4044 #ifdef S_SET_SIZE
4045                               S_SET_SIZE (as_sym, s);
4046 #endif
4047                             }
4048                           else if (S_IS_COMMON (as_sym))
4049                             {
4050                               if (S_GET_VALUE (as_sym) > 0
4051                                   && (S_GET_VALUE (as_sym)
4052                                       <= bfd_get_gp_size (stdoutput)))
4053                                 sc = sc_SCommon;
4054                               else
4055                                 sc = sc_Common;
4056                             }
4057                           else if (seg == text_section)
4058                             sc = sc_Text;
4059                           else if (seg == data_section)
4060                             sc = sc_Data;
4061                           else if (strcmp (segname, ".rdata") == 0
4062                                    || strcmp (segname, ".rodata") == 0)
4063                             sc = sc_RData;
4064                           else if (strcmp (segname, ".sdata") == 0)
4065                             sc = sc_SData;
4066                           else if (seg == bss_section)
4067                             sc = sc_Bss;
4068                           else if (strcmp (segname, ".sbss") == 0)
4069                             sc = sc_SBss;
4070                           else if (seg == &bfd_abs_section)
4071                             sc = sc_Abs;
4072                           else
4073                             {
4074                               /* This must be a user named section.
4075                                  This is not possible in ECOFF, but it
4076                                  is in ELF.  */
4077                               sc = sc_Data;
4078                             }
4079
4080                           sym_ptr->ecoff_sym.asym.st = (int) st;
4081                           sym_ptr->ecoff_sym.asym.sc = (int) sc;
4082                         }
4083
4084                       /* This is just an external symbol if it is
4085                          outside a procedure and it has a type.
4086                          FIXME: g++ will generate symbols which have
4087                          different names in the debugging information
4088                          than the actual symbol.  Should we handle
4089                          them here?  */
4090                       if ((S_IS_EXTERNAL (as_sym)
4091                            || S_IS_WEAK (as_sym)
4092                            || ! S_IS_DEFINED (as_sym))
4093                           && sym_ptr->proc_ptr == (proc_t *) NULL
4094                           && sym_ptr->ecoff_sym.asym.st != (int) st_Nil
4095                           && ! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym))
4096                         local = 0;
4097
4098                       /* This is just an external symbol if it is a
4099                          common symbol.  */
4100                       if (S_IS_COMMON (as_sym))
4101                         local = 0;
4102
4103                       /* If an st_end symbol has an associated gas
4104                          symbol, then it is a local label created for
4105                          a .bend or .end directive.  Stabs line
4106                          numbers will have \001 in the names.  */
4107                       if (local
4108                           && sym_ptr->ecoff_sym.asym.st != st_End
4109                           && strchr (sym_ptr->name, '\001') == 0)
4110                         sym_ptr->ecoff_sym.asym.iss =
4111                           add_string (&fil_ptr->strings,
4112                                       fil_ptr->str_hash,
4113                                       sym_ptr->name,
4114                                       (shash_t **) NULL);
4115                     }
4116
4117                   /* We now know the index of this symbol; fill in
4118                      locations that have been waiting for that
4119                      information.  */
4120                   if (sym_ptr->begin_ptr != (localsym_t *) NULL)
4121                     {
4122                       localsym_t *begin_ptr;
4123                       st_t begin_type;
4124
4125                       know (local);
4126                       begin_ptr = sym_ptr->begin_ptr;
4127                       know (begin_ptr->sym_index != -1);
4128                       sym_ptr->ecoff_sym.asym.index = begin_ptr->sym_index;
4129                       if (sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
4130                         sym_ptr->ecoff_sym.asym.iss =
4131                           begin_ptr->ecoff_sym.asym.iss;
4132
4133                       begin_type = begin_ptr->ecoff_sym.asym.st;
4134                       if (begin_type == st_File
4135                           || begin_type == st_Block)
4136                         {
4137                           begin_ptr->ecoff_sym.asym.index =
4138                             isym - ifilesym + 1;
4139                           (*swap_sym_out) (stdoutput,
4140                                            &begin_ptr->ecoff_sym.asym,
4141                                            (*buf
4142                                             + offset
4143                                             + (begin_ptr->sym_index
4144                                                * external_sym_size)));
4145                         }
4146                       else
4147                         {
4148                           know (begin_ptr->index_ptr != (aux_t *) NULL);
4149                           begin_ptr->index_ptr->data.isym =
4150                             isym - ifilesym + 1;
4151                         }
4152
4153                       /* The value of the symbol marking the end of a
4154                          procedure is the size of the procedure.  The
4155                          value of the symbol marking the end of a
4156                          block is the offset from the start of the
4157                          procedure to the block.  */
4158                       if (begin_type == st_Proc
4159                           || begin_type == st_StaticProc)
4160                         {
4161                           know (as_sym != (symbolS *) NULL);
4162                           know (begin_ptr->as_sym != (symbolS *) NULL);
4163                           if (S_GET_SEGMENT (as_sym)
4164                               != S_GET_SEGMENT (begin_ptr->as_sym))
4165                             as_warn (_(".begin/.bend in different segments"));
4166                           sym_ptr->ecoff_sym.asym.value =
4167                             (S_GET_VALUE (as_sym)
4168                              - S_GET_VALUE (begin_ptr->as_sym));
4169
4170                           /* If the size is odd, this is probably a
4171                              mips16 function; force it to be even.  */
4172                           if ((sym_ptr->ecoff_sym.asym.value & 1) != 0)
4173                             ++sym_ptr->ecoff_sym.asym.value;
4174
4175 #ifdef S_SET_SIZE
4176                           S_SET_SIZE (begin_ptr->as_sym,
4177                                       sym_ptr->ecoff_sym.asym.value);
4178 #endif
4179                         }
4180                       else if (begin_type == st_Block
4181                                && sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
4182                         {
4183                           symbolS *begin_sym;
4184
4185                           know (as_sym != (symbolS *) NULL);
4186                           know (sym_ptr->proc_ptr != (proc_t *) NULL);
4187                           begin_sym = sym_ptr->proc_ptr->sym->as_sym;
4188                           if (S_GET_SEGMENT (as_sym)
4189                               != S_GET_SEGMENT (begin_sym))
4190                             as_warn (_(".begin/.bend in different segments"));
4191                           sym_ptr->ecoff_sym.asym.value =
4192                             S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym);
4193                         }
4194                     }
4195
4196                   for (f = sym_ptr->forward_ref;
4197                        f != (forward_t *) NULL;
4198                        f = f->next)
4199                     {
4200                       know (local);
4201                       f->ifd_ptr->data.isym = fil_ptr->file_index;
4202                       f->index_ptr->data.rndx.index = isym - ifilesym;
4203                     }
4204
4205                   if (local)
4206                     {
4207                       if ((bfd_size_type)(*bufend - sym_out) < external_sym_size)
4208                         sym_out = ecoff_add_bytes (buf, bufend,
4209                                                    sym_out,
4210                                                    external_sym_size);
4211                       (*swap_sym_out) (stdoutput, &sym_ptr->ecoff_sym.asym,
4212                                        sym_out);
4213                       sym_out += external_sym_size;
4214
4215                       sym_ptr->sym_index = isym;
4216
4217                       if (sym_ptr->proc_ptr != (proc_t *) NULL
4218                           && sym_ptr->proc_ptr->sym == sym_ptr)
4219                         sym_ptr->proc_ptr->pdr.isym = isym - ifilesym;
4220
4221                       ++isym;
4222                     }
4223
4224                   /* Record the local symbol index and file number in
4225                      case this is an external symbol.  Note that this
4226                      destroys the asym.index field.  */
4227                   if (as_sym != (symbolS *) NULL
4228                       && symbol_get_obj (as_sym)->ecoff_symbol == sym_ptr)
4229                     {
4230                       if ((sym_ptr->ecoff_sym.asym.st == st_Proc
4231                            || sym_ptr->ecoff_sym.asym.st == st_StaticProc)
4232                           && local)
4233                         sym_ptr->ecoff_sym.asym.index = isym - ifilesym - 1;
4234                       sym_ptr->ecoff_sym.ifd = fil_ptr->file_index;
4235
4236                       /* Don't try to merge an FDR which has an
4237                          external symbol attached to it.  */
4238                       if (S_IS_EXTERNAL (as_sym) || S_IS_WEAK (as_sym))
4239                         fil_ptr->fdr.fMerge = 0;
4240                     }
4241                 }
4242             }
4243           fil_ptr->fdr.csym = isym - fil_ptr->fdr.isymBase;
4244         }
4245     }
4246
4247   return offset + isym * external_sym_size;
4248 }
4249
4250 /* Swap out the procedure information.  */
4251
4252 static unsigned long
4253 ecoff_build_procs (const struct ecoff_debug_swap *backend,
4254                    char **buf,
4255                    char **bufend,
4256                    unsigned long offset)
4257 {
4258   const bfd_size_type external_pdr_size = backend->external_pdr_size;
4259   void (* const swap_pdr_out) (bfd *, const PDR *, PTR)
4260     = backend->swap_pdr_out;
4261   char *pdr_out;
4262   long iproc;
4263   vlinks_t *file_link;
4264
4265   pdr_out = *buf + offset;
4266
4267   iproc = 0;
4268
4269   /* The procedures are stored by file.  */
4270   for (file_link = file_desc.first;
4271        file_link != (vlinks_t *) NULL;
4272        file_link = file_link->next)
4273     {
4274       int fil_cnt;
4275       efdr_t *fil_ptr;
4276       efdr_t *fil_end;
4277
4278       if (file_link->next == (vlinks_t *) NULL)
4279         fil_cnt = file_desc.objects_last_page;
4280       else
4281         fil_cnt = file_desc.objects_per_page;
4282       fil_ptr = file_link->datum->file;
4283       fil_end = fil_ptr + fil_cnt;
4284       for (; fil_ptr < fil_end; fil_ptr++)
4285         {
4286           vlinks_t *proc_link;
4287           int first;
4288
4289           fil_ptr->fdr.ipdFirst = iproc;
4290           first = 1;
4291           for (proc_link = fil_ptr->procs.first;
4292                proc_link != (vlinks_t *) NULL;
4293                proc_link = proc_link->next)
4294             {
4295               int prc_cnt;
4296               proc_t *proc_ptr;
4297               proc_t *proc_end;
4298
4299               if (proc_link->next == (vlinks_t *) NULL)
4300                 prc_cnt = fil_ptr->procs.objects_last_page;
4301               else
4302                 prc_cnt = fil_ptr->procs.objects_per_page;
4303               proc_ptr = proc_link->datum->proc;
4304               proc_end = proc_ptr + prc_cnt;
4305               for (; proc_ptr < proc_end; proc_ptr++)
4306                 {
4307                   symbolS *adr_sym;
4308                   unsigned long adr;
4309
4310                   adr_sym = proc_ptr->sym->as_sym;
4311                   adr = (S_GET_VALUE (adr_sym)
4312                          + bfd_get_section_vma (stdoutput,
4313                                                 S_GET_SEGMENT (adr_sym)));
4314                   if (first)
4315                     {
4316                       /* This code used to force the adr of the very
4317                          first fdr to be 0.  However, the native tools
4318                          don't do that, and I can't remember why it
4319                          used to work that way, so I took it out.  */
4320                       fil_ptr->fdr.adr = adr;
4321                       first = 0;
4322                     }
4323                   proc_ptr->pdr.adr = adr - fil_ptr->fdr.adr;
4324                   if ((bfd_size_type)(*bufend - pdr_out) < external_pdr_size)
4325                     pdr_out = ecoff_add_bytes (buf, bufend,
4326                                                pdr_out,
4327                                                external_pdr_size);
4328                   (*swap_pdr_out) (stdoutput, &proc_ptr->pdr, pdr_out);
4329                   pdr_out += external_pdr_size;
4330                   ++iproc;
4331                 }
4332             }
4333           fil_ptr->fdr.cpd = iproc - fil_ptr->fdr.ipdFirst;
4334         }
4335     }
4336
4337   return offset + iproc * external_pdr_size;
4338 }
4339
4340 /* Swap out the aux information.  */
4341
4342 static unsigned long
4343 ecoff_build_aux (const struct ecoff_debug_swap *backend,
4344                  char **buf,
4345                  char **bufend,
4346                  unsigned long offset)
4347 {
4348   int bigendian;
4349   union aux_ext *aux_out;
4350   long iaux;
4351   vlinks_t *file_link;
4352
4353   bigendian = bfd_big_endian (stdoutput);
4354
4355   aux_out = (union aux_ext *) (*buf + offset);
4356
4357   iaux = 0;
4358
4359   /* The aux entries are stored by file.  */
4360   for (file_link = file_desc.first;
4361        file_link != (vlinks_t *) NULL;
4362        file_link = file_link->next)
4363     {
4364       int fil_cnt;
4365       efdr_t *fil_ptr;
4366       efdr_t *fil_end;
4367
4368       if (file_link->next == (vlinks_t *) NULL)
4369         fil_cnt = file_desc.objects_last_page;
4370       else
4371         fil_cnt = file_desc.objects_per_page;
4372       fil_ptr = file_link->datum->file;
4373       fil_end = fil_ptr + fil_cnt;
4374       for (; fil_ptr < fil_end; fil_ptr++)
4375         {
4376           vlinks_t *aux_link;
4377
4378           fil_ptr->fdr.fBigendian = bigendian;
4379           fil_ptr->fdr.iauxBase = iaux;
4380           for (aux_link = fil_ptr->aux_syms.first;
4381                aux_link != (vlinks_t *) NULL;
4382                aux_link = aux_link->next)
4383             {
4384               int aux_cnt;
4385               aux_t *aux_ptr;
4386               aux_t *aux_end;
4387
4388               if (aux_link->next == (vlinks_t *) NULL)
4389                 aux_cnt = fil_ptr->aux_syms.objects_last_page;
4390               else
4391                 aux_cnt = fil_ptr->aux_syms.objects_per_page;
4392               aux_ptr = aux_link->datum->aux;
4393               aux_end = aux_ptr + aux_cnt;
4394               for (; aux_ptr < aux_end; aux_ptr++)
4395                 {
4396                   if ((unsigned long) (*bufend - (char *) aux_out)
4397                       < sizeof (union aux_ext))
4398                     aux_out = ((union aux_ext *)
4399                                ecoff_add_bytes (buf, bufend,
4400                                                 (char *) aux_out,
4401                                                 sizeof (union aux_ext)));
4402                   switch (aux_ptr->type)
4403                     {
4404                     case aux_tir:
4405                       (*backend->swap_tir_out) (bigendian,
4406                                                 &aux_ptr->data.ti,
4407                                                 &aux_out->a_ti);
4408                       break;
4409                     case aux_rndx:
4410                       (*backend->swap_rndx_out) (bigendian,
4411                                                  &aux_ptr->data.rndx,
4412                                                  &aux_out->a_rndx);
4413                       break;
4414                     case aux_dnLow:
4415                       AUX_PUT_DNLOW (bigendian, aux_ptr->data.dnLow,
4416                                      aux_out);
4417                       break;
4418                     case aux_dnHigh:
4419                       AUX_PUT_DNHIGH (bigendian, aux_ptr->data.dnHigh,
4420                                       aux_out);
4421                       break;
4422                     case aux_isym:
4423                       AUX_PUT_ISYM (bigendian, aux_ptr->data.isym,
4424                                     aux_out);
4425                       break;
4426                     case aux_iss:
4427                       AUX_PUT_ISS (bigendian, aux_ptr->data.iss,
4428                                    aux_out);
4429                       break;
4430                     case aux_width:
4431                       AUX_PUT_WIDTH (bigendian, aux_ptr->data.width,
4432                                      aux_out);
4433                       break;
4434                     case aux_count:
4435                       AUX_PUT_COUNT (bigendian, aux_ptr->data.count,
4436                                      aux_out);
4437                       break;
4438                     }
4439
4440                   ++aux_out;
4441                   ++iaux;
4442                 }
4443             }
4444           fil_ptr->fdr.caux = iaux - fil_ptr->fdr.iauxBase;
4445         }
4446     }
4447
4448   return ecoff_padding_adjust (backend, buf, bufend,
4449                                offset + iaux * sizeof (union aux_ext),
4450                                (char **) NULL);
4451 }
4452
4453 /* Copy out the strings from a varray_t.  This returns the number of
4454    bytes copied, rather than the new offset.  */
4455
4456 static unsigned long
4457 ecoff_build_strings (char **buf,
4458                      char **bufend,
4459                      unsigned long offset,
4460                      varray_t *vp)
4461 {
4462   unsigned long istr;
4463   char *str_out;
4464   vlinks_t *str_link;
4465
4466   str_out = *buf + offset;
4467
4468   istr = 0;
4469
4470   for (str_link = vp->first;
4471        str_link != (vlinks_t *) NULL;
4472        str_link = str_link->next)
4473     {
4474       unsigned long str_cnt;
4475
4476       if (str_link->next == (vlinks_t *) NULL)
4477         str_cnt = vp->objects_last_page;
4478       else
4479         str_cnt = vp->objects_per_page;
4480
4481       if ((unsigned long)(*bufend - str_out) < str_cnt)
4482         str_out = ecoff_add_bytes (buf, bufend, str_out, str_cnt);
4483
4484       memcpy (str_out, str_link->datum->byte, str_cnt);
4485       str_out += str_cnt;
4486       istr += str_cnt;
4487     }
4488
4489   return istr;
4490 }
4491
4492 /* Dump out the local strings.  */
4493
4494 static unsigned long
4495 ecoff_build_ss (const struct ecoff_debug_swap *backend,
4496                 char **buf,
4497                 char **bufend,
4498                 unsigned long offset)
4499 {
4500   long iss;
4501   vlinks_t *file_link;
4502
4503   iss = 0;
4504
4505   for (file_link = file_desc.first;
4506        file_link != (vlinks_t *) NULL;
4507        file_link = file_link->next)
4508     {
4509       int fil_cnt;
4510       efdr_t *fil_ptr;
4511       efdr_t *fil_end;
4512
4513       if (file_link->next == (vlinks_t *) NULL)
4514         fil_cnt = file_desc.objects_last_page;
4515       else
4516         fil_cnt = file_desc.objects_per_page;
4517       fil_ptr = file_link->datum->file;
4518       fil_end = fil_ptr + fil_cnt;
4519       for (; fil_ptr < fil_end; fil_ptr++)
4520         {
4521           long ss_cnt;
4522
4523           fil_ptr->fdr.issBase = iss;
4524           ss_cnt = ecoff_build_strings (buf, bufend, offset + iss,
4525                                         &fil_ptr->strings);
4526           fil_ptr->fdr.cbSs = ss_cnt;
4527           iss += ss_cnt;
4528         }
4529     }
4530
4531   return ecoff_padding_adjust (backend, buf, bufend, offset + iss,
4532                                (char **) NULL);
4533 }
4534
4535 /* Swap out the file descriptors.  */
4536
4537 static unsigned long
4538 ecoff_build_fdr (const struct ecoff_debug_swap *backend,
4539                  char **buf,
4540                  char **bufend,
4541                  unsigned long offset)
4542 {
4543   const bfd_size_type external_fdr_size = backend->external_fdr_size;
4544   void (* const swap_fdr_out) (bfd *, const FDR *, PTR)
4545     = backend->swap_fdr_out;
4546   long ifile;
4547   char *fdr_out;
4548   vlinks_t *file_link;
4549
4550   ifile = 0;
4551
4552   fdr_out = *buf + offset;
4553
4554   for (file_link = file_desc.first;
4555        file_link != (vlinks_t *) NULL;
4556        file_link = file_link->next)
4557     {
4558       int fil_cnt;
4559       efdr_t *fil_ptr;
4560       efdr_t *fil_end;
4561
4562       if (file_link->next == (vlinks_t *) NULL)
4563         fil_cnt = file_desc.objects_last_page;
4564       else
4565         fil_cnt = file_desc.objects_per_page;
4566       fil_ptr = file_link->datum->file;
4567       fil_end = fil_ptr + fil_cnt;
4568       for (; fil_ptr < fil_end; fil_ptr++)
4569         {
4570           if ((bfd_size_type)(*bufend - fdr_out) < external_fdr_size)
4571             fdr_out = ecoff_add_bytes (buf, bufend, fdr_out,
4572                                        external_fdr_size);
4573           (*swap_fdr_out) (stdoutput, &fil_ptr->fdr, fdr_out);
4574           fdr_out += external_fdr_size;
4575           ++ifile;
4576         }
4577     }
4578
4579   return offset + ifile * external_fdr_size;
4580 }
4581
4582 /* Set up the external symbols.  These are supposed to be handled by
4583    the backend.  This routine just gets the right information and
4584    calls a backend function to deal with it.  */
4585
4586 static void
4587 ecoff_setup_ext (void)
4588 {
4589   register symbolS *sym;
4590
4591   for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
4592     {
4593       if (symbol_get_obj (sym)->ecoff_symbol == NULL)
4594         continue;
4595
4596       /* If this is a local symbol, then force the fields to zero.  */
4597       if (! S_IS_EXTERNAL (sym)
4598           && ! S_IS_WEAK (sym)
4599           && S_IS_DEFINED (sym))
4600         {
4601           struct localsym *lsym;
4602
4603           lsym = symbol_get_obj (sym)->ecoff_symbol;
4604           lsym->ecoff_sym.asym.value = 0;
4605           lsym->ecoff_sym.asym.st = (int) st_Nil;
4606           lsym->ecoff_sym.asym.sc = (int) sc_Nil;
4607           lsym->ecoff_sym.asym.index = indexNil;
4608         }
4609
4610       obj_ecoff_set_ext (sym, &symbol_get_obj (sym)->ecoff_symbol->ecoff_sym);
4611     }
4612 }
4613
4614 /* Build the ECOFF debugging information.  */
4615
4616 unsigned long
4617 ecoff_build_debug (HDRR *hdr,
4618                    char **bufp,
4619                    const struct ecoff_debug_swap *backend)
4620 {
4621   const bfd_size_type external_pdr_size = backend->external_pdr_size;
4622   tag_t *ptag;
4623   tag_t *ptag_next;
4624   efdr_t *fil_ptr;
4625   int end_warning;
4626   efdr_t *hold_file_ptr;
4627   proc_t *hold_proc_ptr;
4628   symbolS *sym;
4629   char *buf;
4630   char *bufend;
4631   unsigned long offset;
4632
4633   /* Make sure we have a file.  */
4634   if (first_file == (efdr_t *) NULL)
4635     add_file ((const char *) NULL, 0, 1);
4636
4637   /* Handle any top level tags.  */
4638   for (ptag = top_tag_head->first_tag;
4639        ptag != (tag_t *) NULL;
4640        ptag = ptag_next)
4641     {
4642       if (ptag->forward_ref != (forward_t *) NULL)
4643         add_unknown_tag (ptag);
4644
4645       ptag_next = ptag->same_block;
4646       ptag->hash_ptr->tag_ptr = ptag->same_name;
4647       free_tag (ptag);
4648     }
4649
4650   free_thead (top_tag_head);
4651
4652   /* Look through the symbols.  Add debugging information for each
4653      symbol that has not already received it.  */
4654   hold_file_ptr = cur_file_ptr;
4655   hold_proc_ptr = cur_proc_ptr;
4656   cur_proc_ptr = (proc_t *) NULL;
4657   for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
4658     {
4659       if (symbol_get_obj (sym)->ecoff_symbol != NULL
4660           || symbol_get_obj (sym)->ecoff_file == (efdr_t *) NULL
4661           || (symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) != 0)
4662         continue;
4663
4664       cur_file_ptr = symbol_get_obj (sym)->ecoff_file;
4665       add_ecoff_symbol ((const char *) NULL, st_Nil, sc_Nil, sym,
4666                         (bfd_vma) 0, S_GET_VALUE (sym), indexNil);
4667     }
4668   cur_proc_ptr = hold_proc_ptr;
4669   cur_file_ptr = hold_file_ptr;
4670
4671   /* Output an ending symbol for all the files.  We have to do this
4672      here for the last file, so we may as well do it for all of the
4673      files.  */
4674   end_warning = 0;
4675   for (fil_ptr = first_file;
4676        fil_ptr != (efdr_t *) NULL;
4677        fil_ptr = fil_ptr->next_file)
4678     {
4679       cur_file_ptr = fil_ptr;
4680       while (cur_file_ptr->cur_scope != (scope_t *) NULL
4681              && cur_file_ptr->cur_scope->prev != (scope_t *) NULL)
4682         {
4683           cur_file_ptr->cur_scope = cur_file_ptr->cur_scope->prev;
4684           if (! end_warning && ! cur_file_ptr->fake)
4685             {
4686               as_warn (_("missing .end or .bend at end of file"));
4687               end_warning = 1;
4688             }
4689         }
4690       if (cur_file_ptr->cur_scope != (scope_t *) NULL)
4691         (void) add_ecoff_symbol ((const char *) NULL,
4692                                  st_End, sc_Text,
4693                                  (symbolS *) NULL,
4694                                  (bfd_vma) 0,
4695                                  (symint_t) 0,
4696                                  (symint_t) 0);
4697     }
4698
4699   /* Build the symbolic information.  */
4700   offset = 0;
4701   buf = xmalloc (PAGE_SIZE);
4702   bufend = buf + PAGE_SIZE;
4703
4704   /* Build the line number information.  */
4705   hdr->cbLineOffset = offset;
4706   offset = ecoff_build_lineno (backend, &buf, &bufend, offset,
4707                                &hdr->ilineMax);
4708   hdr->cbLine = offset - hdr->cbLineOffset;
4709
4710   /* We don't use dense numbers at all.  */
4711   hdr->idnMax = 0;
4712   hdr->cbDnOffset = 0;
4713
4714   /* We can't build the PDR table until we have built the symbols,
4715      because a PDR contains a symbol index.  However, we set aside
4716      space at this point.  */
4717   hdr->ipdMax = proc_cnt;
4718   hdr->cbPdOffset = offset;
4719   if ((bfd_size_type)(bufend - (buf + offset)) < proc_cnt * external_pdr_size)
4720     (void) ecoff_add_bytes (&buf, &bufend, buf + offset,
4721                             proc_cnt * external_pdr_size);
4722   offset += proc_cnt * external_pdr_size;
4723
4724   /* Build the local symbols.  */
4725   hdr->cbSymOffset = offset;
4726   offset = ecoff_build_symbols (backend, &buf, &bufend, offset);
4727   hdr->isymMax = (offset - hdr->cbSymOffset) / backend->external_sym_size;
4728
4729   /* Building the symbols initializes the symbol index in the PDR's.
4730      Now we can swap out the PDR's.  */
4731   (void) ecoff_build_procs (backend, &buf, &bufend, hdr->cbPdOffset);
4732
4733   /* We don't use optimization symbols.  */
4734   hdr->ioptMax = 0;
4735   hdr->cbOptOffset = 0;
4736
4737   /* Swap out the auxiliary type information.  */
4738   hdr->cbAuxOffset = offset;
4739   offset = ecoff_build_aux (backend, &buf, &bufend, offset);
4740   hdr->iauxMax = (offset - hdr->cbAuxOffset) / sizeof (union aux_ext);
4741
4742   /* Copy out the local strings.  */
4743   hdr->cbSsOffset = offset;
4744   offset = ecoff_build_ss (backend, &buf, &bufend, offset);
4745   hdr->issMax = offset - hdr->cbSsOffset;
4746
4747   /* We don't use relative file descriptors.  */
4748   hdr->crfd = 0;
4749   hdr->cbRfdOffset = 0;
4750
4751   /* Swap out the file descriptors.  */
4752   hdr->cbFdOffset = offset;
4753   offset = ecoff_build_fdr (backend, &buf, &bufend, offset);
4754   hdr->ifdMax = (offset - hdr->cbFdOffset) / backend->external_fdr_size;
4755
4756   /* Set up the external symbols, which are handled by the BFD back
4757      end.  */
4758   hdr->issExtMax = 0;
4759   hdr->cbSsExtOffset = 0;
4760   hdr->iextMax = 0;
4761   hdr->cbExtOffset = 0;
4762   ecoff_setup_ext ();
4763
4764   know ((offset & (backend->debug_align - 1)) == 0);
4765
4766   /* FIXME: This value should be determined from the .verstamp directive,
4767      with reasonable defaults in config files.  */
4768 #ifdef TC_ALPHA
4769   hdr->vstamp = 0x030b;
4770 #else
4771   hdr->vstamp = 0x020b;
4772 #endif
4773
4774   *bufp = buf;
4775   return offset;
4776 }
4777 \f
4778 /* Allocate a cluster of pages.  */
4779
4780 #ifndef MALLOC_CHECK
4781
4782 static page_type *
4783 allocate_cluster (unsigned long npages)
4784 {
4785   register page_type *value = (page_type *) xmalloc (npages * PAGE_USIZE);
4786
4787 #ifdef ECOFF_DEBUG
4788   if (debug > 3)
4789     fprintf (stderr, "\talloc\tnpages = %d, value = 0x%.8x\n", npages, value);
4790 #endif
4791
4792   memset (value, 0, npages * PAGE_USIZE);
4793
4794   return value;
4795 }
4796
4797 static page_type *cluster_ptr = NULL;
4798 static unsigned long pages_left = 0;
4799
4800 #endif /* MALLOC_CHECK */
4801
4802 /* Allocate one page (which is initialized to 0).  */
4803
4804 static page_type *
4805 allocate_page (void)
4806 {
4807 #ifndef MALLOC_CHECK
4808
4809   if (pages_left == 0)
4810     {
4811       pages_left = MAX_CLUSTER_PAGES;
4812       cluster_ptr = allocate_cluster (pages_left);
4813     }
4814
4815   pages_left--;
4816   return cluster_ptr++;
4817
4818 #else /* MALLOC_CHECK */
4819
4820   page_type *ptr;
4821
4822   ptr = xmalloc (PAGE_USIZE);
4823   memset (ptr, 0, PAGE_USIZE);
4824   return ptr;
4825
4826 #endif /* MALLOC_CHECK */
4827 }
4828 \f
4829 /* Allocate scoping information.  */
4830
4831 static scope_t *
4832 allocate_scope (void)
4833 {
4834   register scope_t *ptr;
4835   static scope_t initial_scope;
4836
4837 #ifndef MALLOC_CHECK
4838
4839   ptr = alloc_counts[(int) alloc_type_scope].free_list.f_scope;
4840   if (ptr != (scope_t *) NULL)
4841     alloc_counts[(int) alloc_type_scope].free_list.f_scope = ptr->free;
4842   else
4843     {
4844       register int unallocated  = alloc_counts[(int) alloc_type_scope].unallocated;
4845       register page_type *cur_page      = alloc_counts[(int) alloc_type_scope].cur_page;
4846
4847       if (unallocated == 0)
4848         {
4849           unallocated = PAGE_SIZE / sizeof (scope_t);
4850           alloc_counts[(int) alloc_type_scope].cur_page = cur_page = allocate_page ();
4851           alloc_counts[(int) alloc_type_scope].total_pages++;
4852         }
4853
4854       ptr = &cur_page->scope[--unallocated];
4855       alloc_counts[(int) alloc_type_scope].unallocated = unallocated;
4856     }
4857
4858 #else
4859
4860   ptr = (scope_t *) xmalloc (sizeof (scope_t));
4861
4862 #endif
4863
4864   alloc_counts[(int) alloc_type_scope].total_alloc++;
4865   *ptr = initial_scope;
4866   return ptr;
4867 }
4868
4869 /* Free scoping information.  */
4870
4871 static void
4872 free_scope (scope_t *ptr)
4873 {
4874   alloc_counts[(int) alloc_type_scope].total_free++;
4875
4876 #ifndef MALLOC_CHECK
4877   ptr->free = alloc_counts[(int) alloc_type_scope].free_list.f_scope;
4878   alloc_counts[(int) alloc_type_scope].free_list.f_scope = ptr;
4879 #else
4880   free ((PTR) ptr);
4881 #endif
4882 }
4883 \f
4884 /* Allocate links for pages in a virtual array.  */
4885
4886 static vlinks_t *
4887 allocate_vlinks (void)
4888 {
4889   register vlinks_t *ptr;
4890   static vlinks_t initial_vlinks;
4891
4892 #ifndef MALLOC_CHECK
4893
4894   register int unallocated = alloc_counts[(int) alloc_type_vlinks].unallocated;
4895   register page_type *cur_page = alloc_counts[(int) alloc_type_vlinks].cur_page;
4896
4897   if (unallocated == 0)
4898     {
4899       unallocated = PAGE_SIZE / sizeof (vlinks_t);
4900       alloc_counts[(int) alloc_type_vlinks].cur_page = cur_page = allocate_page ();
4901       alloc_counts[(int) alloc_type_vlinks].total_pages++;
4902     }
4903
4904   ptr = &cur_page->vlinks[--unallocated];
4905   alloc_counts[(int) alloc_type_vlinks].unallocated = unallocated;
4906
4907 #else
4908
4909   ptr = (vlinks_t *) xmalloc (sizeof (vlinks_t));
4910
4911 #endif
4912
4913   alloc_counts[(int) alloc_type_vlinks].total_alloc++;
4914   *ptr = initial_vlinks;
4915   return ptr;
4916 }
4917 \f
4918 /* Allocate string hash buckets.  */
4919
4920 static shash_t *
4921 allocate_shash (void)
4922 {
4923   register shash_t *ptr;
4924   static shash_t initial_shash;
4925
4926 #ifndef MALLOC_CHECK
4927
4928   register int unallocated = alloc_counts[(int) alloc_type_shash].unallocated;
4929   register page_type *cur_page = alloc_counts[(int) alloc_type_shash].cur_page;
4930
4931   if (unallocated == 0)
4932     {
4933       unallocated = PAGE_SIZE / sizeof (shash_t);
4934       alloc_counts[(int) alloc_type_shash].cur_page = cur_page = allocate_page ();
4935       alloc_counts[(int) alloc_type_shash].total_pages++;
4936     }
4937
4938   ptr = &cur_page->shash[--unallocated];
4939   alloc_counts[(int) alloc_type_shash].unallocated = unallocated;
4940
4941 #else
4942
4943   ptr = (shash_t *) xmalloc (sizeof (shash_t));
4944
4945 #endif
4946
4947   alloc_counts[(int) alloc_type_shash].total_alloc++;
4948   *ptr = initial_shash;
4949   return ptr;
4950 }
4951 \f
4952 /* Allocate type hash buckets.  */
4953
4954 static thash_t *
4955 allocate_thash (void)
4956 {
4957   register thash_t *ptr;
4958   static thash_t initial_thash;
4959
4960 #ifndef MALLOC_CHECK
4961
4962   register int unallocated = alloc_counts[(int) alloc_type_thash].unallocated;
4963   register page_type *cur_page = alloc_counts[(int) alloc_type_thash].cur_page;
4964
4965   if (unallocated == 0)
4966     {
4967       unallocated = PAGE_SIZE / sizeof (thash_t);
4968       alloc_counts[(int) alloc_type_thash].cur_page = cur_page = allocate_page ();
4969       alloc_counts[(int) alloc_type_thash].total_pages++;
4970     }
4971
4972   ptr = &cur_page->thash[--unallocated];
4973   alloc_counts[(int) alloc_type_thash].unallocated = unallocated;
4974
4975 #else
4976
4977   ptr = (thash_t *) xmalloc (sizeof (thash_t));
4978
4979 #endif
4980
4981   alloc_counts[(int) alloc_type_thash].total_alloc++;
4982   *ptr = initial_thash;
4983   return ptr;
4984 }
4985 \f
4986 /* Allocate structure, union, or enum tag information.  */
4987
4988 static tag_t *
4989 allocate_tag (void)
4990 {
4991   register tag_t *ptr;
4992   static tag_t initial_tag;
4993
4994 #ifndef MALLOC_CHECK
4995
4996   ptr = alloc_counts[(int) alloc_type_tag].free_list.f_tag;
4997   if (ptr != (tag_t *) NULL)
4998     alloc_counts[(int) alloc_type_tag].free_list.f_tag = ptr->free;
4999   else
5000     {
5001       register int unallocated = alloc_counts[(int) alloc_type_tag].unallocated;
5002       register page_type *cur_page = alloc_counts[(int) alloc_type_tag].cur_page;
5003
5004       if (unallocated == 0)
5005         {
5006           unallocated = PAGE_SIZE / sizeof (tag_t);
5007           alloc_counts[(int) alloc_type_tag].cur_page = cur_page = allocate_page ();
5008           alloc_counts[(int) alloc_type_tag].total_pages++;
5009         }
5010
5011       ptr = &cur_page->tag[--unallocated];
5012       alloc_counts[(int) alloc_type_tag].unallocated = unallocated;
5013     }
5014
5015 #else
5016
5017   ptr = (tag_t *) xmalloc (sizeof (tag_t));
5018
5019 #endif
5020
5021   alloc_counts[(int) alloc_type_tag].total_alloc++;
5022   *ptr = initial_tag;
5023   return ptr;
5024 }
5025
5026 /* Free scoping information.  */
5027
5028 static void
5029 free_tag (tag_t *ptr)
5030 {
5031   alloc_counts[(int) alloc_type_tag].total_free++;
5032
5033 #ifndef MALLOC_CHECK
5034   ptr->free = alloc_counts[(int) alloc_type_tag].free_list.f_tag;
5035   alloc_counts[(int) alloc_type_tag].free_list.f_tag = ptr;
5036 #else
5037   free ((PTR_T) ptr);
5038 #endif
5039 }
5040 \f
5041 /* Allocate forward reference to a yet unknown tag.  */
5042
5043 static forward_t *
5044 allocate_forward (void)
5045 {
5046   register forward_t *ptr;
5047   static forward_t initial_forward;
5048
5049 #ifndef MALLOC_CHECK
5050
5051   register int unallocated = alloc_counts[(int) alloc_type_forward].unallocated;
5052   register page_type *cur_page = alloc_counts[(int) alloc_type_forward].cur_page;
5053
5054   if (unallocated == 0)
5055     {
5056       unallocated = PAGE_SIZE / sizeof (forward_t);
5057       alloc_counts[(int) alloc_type_forward].cur_page = cur_page = allocate_page ();
5058       alloc_counts[(int) alloc_type_forward].total_pages++;
5059     }
5060
5061   ptr = &cur_page->forward[--unallocated];
5062   alloc_counts[(int) alloc_type_forward].unallocated = unallocated;
5063
5064 #else
5065
5066   ptr = (forward_t *) xmalloc (sizeof (forward_t));
5067
5068 #endif
5069
5070   alloc_counts[(int) alloc_type_forward].total_alloc++;
5071   *ptr = initial_forward;
5072   return ptr;
5073 }
5074 \f
5075 /* Allocate head of type hash list.  */
5076
5077 static thead_t *
5078 allocate_thead (void)
5079 {
5080   register thead_t *ptr;
5081   static thead_t initial_thead;
5082
5083 #ifndef MALLOC_CHECK
5084
5085   ptr = alloc_counts[(int) alloc_type_thead].free_list.f_thead;
5086   if (ptr != (thead_t *) NULL)
5087     alloc_counts[(int) alloc_type_thead].free_list.f_thead = ptr->free;
5088   else
5089     {
5090       register int unallocated = alloc_counts[(int) alloc_type_thead].unallocated;
5091       register page_type *cur_page = alloc_counts[(int) alloc_type_thead].cur_page;
5092
5093       if (unallocated == 0)
5094         {
5095           unallocated = PAGE_SIZE / sizeof (thead_t);
5096           alloc_counts[(int) alloc_type_thead].cur_page = cur_page = allocate_page ();
5097           alloc_counts[(int) alloc_type_thead].total_pages++;
5098         }
5099
5100       ptr = &cur_page->thead[--unallocated];
5101       alloc_counts[(int) alloc_type_thead].unallocated = unallocated;
5102     }
5103
5104 #else
5105
5106   ptr = (thead_t *) xmalloc (sizeof (thead_t));
5107
5108 #endif
5109
5110   alloc_counts[(int) alloc_type_thead].total_alloc++;
5111   *ptr = initial_thead;
5112   return ptr;
5113 }
5114
5115 /* Free scoping information.  */
5116
5117 static void
5118 free_thead (thead_t *ptr)
5119 {
5120   alloc_counts[(int) alloc_type_thead].total_free++;
5121
5122 #ifndef MALLOC_CHECK
5123   ptr->free = (thead_t *) alloc_counts[(int) alloc_type_thead].free_list.f_thead;
5124   alloc_counts[(int) alloc_type_thead].free_list.f_thead = ptr;
5125 #else
5126   free ((PTR_T) ptr);
5127 #endif
5128 }
5129 \f
5130 static lineno_list_t *
5131 allocate_lineno_list (void)
5132 {
5133   register lineno_list_t *ptr;
5134   static lineno_list_t initial_lineno_list;
5135
5136 #ifndef MALLOC_CHECK
5137
5138   register int unallocated = alloc_counts[(int) alloc_type_lineno].unallocated;
5139   register page_type *cur_page = alloc_counts[(int) alloc_type_lineno].cur_page;
5140
5141   if (unallocated == 0)
5142     {
5143       unallocated = PAGE_SIZE / sizeof (lineno_list_t);
5144       alloc_counts[(int) alloc_type_lineno].cur_page = cur_page = allocate_page ();
5145       alloc_counts[(int) alloc_type_lineno].total_pages++;
5146     }
5147
5148   ptr = &cur_page->lineno[--unallocated];
5149   alloc_counts[(int) alloc_type_lineno].unallocated = unallocated;
5150
5151 #else
5152
5153   ptr = (lineno_list_t *) xmalloc (sizeof (lineno_list_t));
5154
5155 #endif
5156
5157   alloc_counts[(int) alloc_type_lineno].total_alloc++;
5158   *ptr = initial_lineno_list;
5159   return ptr;
5160 }
5161
5162 void
5163 ecoff_set_gp_prolog_size (int sz)
5164 {
5165   if (cur_proc_ptr == 0)
5166     return;
5167
5168   cur_proc_ptr->pdr.gp_prologue = sz;
5169   if (cur_proc_ptr->pdr.gp_prologue != sz)
5170     {
5171       as_warn (_("GP prologue size exceeds field size, using 0 instead"));
5172       cur_proc_ptr->pdr.gp_prologue = 0;
5173     }
5174
5175   cur_proc_ptr->pdr.gp_used = 1;
5176 }
5177
5178 int
5179 ecoff_no_current_file (void)
5180 {
5181   return cur_file_ptr == (efdr_t *) NULL;
5182 }
5183
5184 void
5185 ecoff_generate_asm_lineno (void)
5186 {
5187   unsigned int lineno;
5188   char *filename;
5189   lineno_list_t *list;
5190
5191   as_where (&filename, &lineno);
5192
5193   if (current_stabs_filename == (char *) NULL
5194       || strcmp (current_stabs_filename, filename))
5195     add_file (filename, 0, 1);
5196
5197   list = allocate_lineno_list ();
5198
5199   list->next = (lineno_list_t *) NULL;
5200   list->file = cur_file_ptr;
5201   list->proc = cur_proc_ptr;
5202   list->frag = frag_now;
5203   list->paddr = frag_now_fix ();
5204   list->lineno = lineno;
5205
5206   /* We don't want to merge files which have line numbers.  */
5207   cur_file_ptr->fdr.fMerge = 0;
5208
5209   /* A .loc directive will sometimes appear before a .ent directive,
5210      which means that cur_proc_ptr will be NULL here.  Arrange to
5211      patch this up.  */
5212   if (cur_proc_ptr == (proc_t *) NULL)
5213     {
5214       lineno_list_t **pl;
5215
5216       pl = &noproc_lineno;
5217       while (*pl != (lineno_list_t *) NULL)
5218         pl = &(*pl)->next;
5219       *pl = list;
5220     }
5221   else
5222     {
5223       last_lineno = list;
5224       *last_lineno_ptr = list;
5225       last_lineno_ptr = &list->next;
5226     }
5227 }
5228
5229 #else
5230
5231 void
5232 ecoff_generate_asm_lineno (void)
5233 {
5234 }
5235
5236 #endif /* ECOFF_DEBUGGING */