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