gas/ecoff.c

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