gas/ecoff.c

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