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