gas/ecoff.c

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