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