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                             {
3957                               /* This must be a user named section.
3958                                  This is not possible in ECOFF, but it
3959                                  is in ELF.  */
3960                               sc = sc_Data;
3961                             }
3962
3963                           sym_ptr->ecoff_sym.asym.st = (int) st;
3964                           sym_ptr->ecoff_sym.asym.sc = (int) sc;
3965                         }
3966
3967                       /* This is just an external symbol if it is
3968                          outside a procedure and it has a type.
3969                          FIXME: g++ will generate symbols which have
3970                          different names in the debugging information
3971                          than the actual symbol.  Should we handle
3972                          them here?  */
3973                       if ((S_IS_EXTERNAL (as_sym)
3974                            || ! S_IS_DEFINED (as_sym))
3975                           && sym_ptr->proc_ptr == (proc_t *) NULL
3976                           && sym_ptr->ecoff_sym.asym.st != (int) st_Nil
3977                           && ! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym))
3978                         local = 0;
3979
3980                       /* If an st_end symbol has an associated gas
3981                          symbol, then it is a local label created for
3982                          a .bend or .end directive.  Stabs line
3983                          numbers will have \001 in the names.  */
3984                       if (local
3985                           && sym_ptr->ecoff_sym.asym.st != st_End
3986                           && strchr (sym_ptr->name, '\001') == 0)
3987                         sym_ptr->ecoff_sym.asym.iss =
3988                           add_string (&fil_ptr->strings,
3989                                       fil_ptr->str_hash,
3990                                       sym_ptr->name,
3991                                       (shash_t **) NULL);
3992                     }
3993
3994                   /* We now know the index of this symbol; fill in
3995                      locations that have been waiting for that
3996                      information.  */
3997                   if (sym_ptr->begin_ptr != (localsym_t *) NULL)
3998                     {
3999                       localsym_t *begin_ptr;
4000                       st_t begin_type;
4001
4002                       know (local);
4003                       begin_ptr = sym_ptr->begin_ptr;
4004                       know (begin_ptr->sym_index != -1);
4005                       sym_ptr->ecoff_sym.asym.index = begin_ptr->sym_index;
4006                       if (sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
4007                         sym_ptr->ecoff_sym.asym.iss =
4008                           begin_ptr->ecoff_sym.asym.iss;
4009
4010                       begin_type = begin_ptr->ecoff_sym.asym.st;
4011                       if (begin_type == st_File
4012                           || begin_type == st_Block)
4013                         {
4014                           begin_ptr->ecoff_sym.asym.index =
4015                             isym - ifilesym + 1;
4016                           (*swap_sym_out) (stdoutput,
4017                                            &begin_ptr->ecoff_sym.asym,
4018                                            (*buf
4019                                             + offset
4020                                             + (begin_ptr->sym_index
4021                                                * external_sym_size)));
4022                         }
4023                       else
4024                         {
4025                           know (begin_ptr->index_ptr != (aux_t *) NULL);
4026                           begin_ptr->index_ptr->data.isym =
4027                             isym - ifilesym + 1;
4028                         }
4029
4030                       /* The value of the symbol marking the end of a
4031                          procedure is the size of the procedure.  The
4032                          value of the symbol marking the end of a
4033                          block is the offset from the start of the
4034                          procedure to the block.  */
4035                       if (begin_type == st_Proc
4036                           || begin_type == st_StaticProc)
4037                         {
4038                           know (as_sym != (symbolS *) NULL);
4039                           know (begin_ptr->as_sym != (symbolS *) NULL);
4040                           if (S_GET_SEGMENT (as_sym)
4041                               != S_GET_SEGMENT (begin_ptr->as_sym))
4042                             as_warn (".begin/.bend in different segments");
4043                           sym_ptr->ecoff_sym.asym.value =
4044                             (S_GET_VALUE (as_sym)
4045                              - S_GET_VALUE (begin_ptr->as_sym));
4046                         }
4047                       else if (begin_type == st_Block
4048                                && sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
4049                         {
4050                           symbolS *begin_sym;
4051
4052                           know (as_sym != (symbolS *) NULL);
4053                           know (sym_ptr->proc_ptr != (proc_t *) NULL);
4054                           begin_sym = sym_ptr->proc_ptr->sym->as_sym;
4055                           if (S_GET_SEGMENT (as_sym)
4056                               != S_GET_SEGMENT (begin_sym))
4057                             as_warn (".begin/.bend in different segments");
4058                           sym_ptr->ecoff_sym.asym.value =
4059                             S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym);
4060                         }
4061                     }
4062
4063                   for (f = sym_ptr->forward_ref;
4064                        f != (forward_t *) NULL;
4065                        f = f->next)
4066                     {
4067                       know (local);
4068                       f->ifd_ptr->data.isym = fil_ptr->file_index;
4069                       f->index_ptr->data.rndx.index = isym - ifilesym;
4070                     }
4071
4072                   if (local)
4073                     {
4074                       if (*bufend - sym_out < external_sym_size)
4075                         sym_out = ecoff_add_bytes (buf, bufend,
4076                                                    sym_out,
4077                                                    external_sym_size);
4078                       (*swap_sym_out) (stdoutput, &sym_ptr->ecoff_sym.asym,
4079                                        sym_out);
4080                       sym_out += external_sym_size;
4081
4082                       sym_ptr->sym_index = isym;
4083
4084                       if (sym_ptr->proc_ptr != (proc_t *) NULL
4085                           && sym_ptr->proc_ptr->sym == sym_ptr)
4086                         sym_ptr->proc_ptr->pdr.isym = isym - ifilesym;
4087
4088                       ++isym;
4089                     }
4090
4091                   /* Record the local symbol index and file number in
4092                      case this is an external symbol.  Note that this
4093                      destroys the asym.index field.  */
4094                   if (as_sym != (symbolS *) NULL
4095                       && as_sym->ecoff_symbol == sym_ptr)
4096                     {
4097                       if ((sym_ptr->ecoff_sym.asym.st == st_Proc
4098                            || sym_ptr->ecoff_sym.asym.st == st_StaticProc)
4099                           && local)
4100                         sym_ptr->ecoff_sym.asym.index = isym - ifilesym - 1;
4101                       sym_ptr->ecoff_sym.ifd = fil_ptr->file_index;
4102                     }
4103                 }
4104             }
4105           fil_ptr->fdr.csym = isym - fil_ptr->fdr.isymBase;
4106         }
4107     }
4108
4109   return offset + isym * external_sym_size;
4110 }
4111
4112 /* Swap out the procedure information.  */
4113
4114 static unsigned long
4115 ecoff_build_procs (backend, buf, bufend, offset)
4116      const struct ecoff_debug_swap *backend;
4117      char **buf;
4118      char **bufend;
4119      unsigned long offset;
4120 {
4121   const bfd_size_type external_pdr_size = backend->external_pdr_size;
4122   void (* const swap_pdr_out) PARAMS ((bfd *, const PDR *, PTR))
4123     = backend->swap_pdr_out;
4124   char *pdr_out;
4125   long iproc;
4126   vlinks_t *file_link;
4127
4128   pdr_out = *buf + offset;
4129
4130   iproc = 0;
4131
4132   /* The procedures are stored by file.  */
4133   for (file_link = file_desc.first;
4134        file_link != (vlinks_t *) NULL;
4135        file_link = file_link->next)
4136     {
4137       int fil_cnt;
4138       efdr_t *fil_ptr;
4139       efdr_t *fil_end;
4140
4141       if (file_link->next == (vlinks_t *) NULL)
4142         fil_cnt = file_desc.objects_last_page;
4143       else
4144         fil_cnt = file_desc.objects_per_page;
4145       fil_ptr = file_link->datum->file;
4146       fil_end = fil_ptr + fil_cnt;
4147       for (; fil_ptr < fil_end; fil_ptr++)
4148         {
4149           vlinks_t *proc_link;
4150           int first;
4151
4152           fil_ptr->fdr.ipdFirst = iproc;
4153           first = 1;
4154           for (proc_link = fil_ptr->procs.first;
4155                proc_link != (vlinks_t *) NULL;
4156                proc_link = proc_link->next)
4157             {
4158               int prc_cnt;
4159               proc_t *proc_ptr;
4160               proc_t *proc_end;
4161
4162               if (proc_link->next == (vlinks_t *) NULL)
4163                 prc_cnt = fil_ptr->procs.objects_last_page;
4164               else
4165                 prc_cnt = fil_ptr->procs.objects_per_page;
4166               proc_ptr = proc_link->datum->proc;
4167               proc_end = proc_ptr + prc_cnt;
4168               for (; proc_ptr < proc_end; proc_ptr++)
4169                 {
4170                   symbolS *adr_sym;
4171                   unsigned long adr;
4172
4173                   adr_sym = proc_ptr->sym->as_sym;
4174                   adr = (S_GET_VALUE (adr_sym)
4175                          + bfd_get_section_vma (stdoutput,
4176                                                 S_GET_SEGMENT (adr_sym)));
4177                   if (first)
4178                     {
4179                       /* This code used to force the adr of the very
4180                          first fdr to be 0.  However, the native tools
4181                          don't do that, and I can't remember why it
4182                          used to work that way, so I took it out.  */
4183                       fil_ptr->fdr.adr = adr;
4184                       first = 0;
4185                     }
4186                   proc_ptr->pdr.adr = adr - fil_ptr->fdr.adr;
4187                   if (*bufend - pdr_out < external_pdr_size)
4188                     pdr_out = ecoff_add_bytes (buf, bufend,
4189                                                pdr_out,
4190                                                external_pdr_size);
4191                   (*swap_pdr_out) (stdoutput, &proc_ptr->pdr, pdr_out);
4192                   pdr_out += external_pdr_size;
4193                   ++iproc;
4194                 }
4195             }
4196           fil_ptr->fdr.cpd = iproc - fil_ptr->fdr.ipdFirst;
4197         }
4198     }
4199
4200   return offset + iproc * external_pdr_size;
4201 }
4202
4203 /* Swap out the aux information.  */
4204
4205 static unsigned long
4206 ecoff_build_aux (backend, buf, bufend, offset)
4207      const struct ecoff_debug_swap *backend;
4208      char **buf;
4209      char **bufend;
4210      unsigned long offset;
4211 {
4212   int bigendian;
4213   union aux_ext *aux_out;
4214   long iaux;
4215   vlinks_t *file_link;
4216
4217   bigendian = stdoutput->xvec->header_byteorder_big_p;
4218
4219   aux_out = (union aux_ext *) (*buf + offset);
4220
4221   iaux = 0;
4222
4223   /* The aux entries are stored by file.  */
4224   for (file_link = file_desc.first;
4225        file_link != (vlinks_t *) NULL;
4226        file_link = file_link->next)
4227     {
4228       int fil_cnt;
4229       efdr_t *fil_ptr;
4230       efdr_t *fil_end;
4231
4232       if (file_link->next == (vlinks_t *) NULL)
4233         fil_cnt = file_desc.objects_last_page;
4234       else
4235         fil_cnt = file_desc.objects_per_page;
4236       fil_ptr = file_link->datum->file;
4237       fil_end = fil_ptr + fil_cnt;
4238       for (; fil_ptr < fil_end; fil_ptr++)
4239         {
4240           vlinks_t *aux_link;
4241
4242           fil_ptr->fdr.fBigendian = bigendian;
4243           fil_ptr->fdr.iauxBase = iaux;
4244           for (aux_link = fil_ptr->aux_syms.first;
4245                aux_link != (vlinks_t *) NULL;
4246                aux_link = aux_link->next)
4247             {
4248               int aux_cnt;
4249               aux_t *aux_ptr;
4250               aux_t *aux_end;
4251
4252               if (aux_link->next == (vlinks_t *) NULL)
4253                 aux_cnt = fil_ptr->aux_syms.objects_last_page;
4254               else
4255                 aux_cnt = fil_ptr->aux_syms.objects_per_page;
4256               aux_ptr = aux_link->datum->aux;
4257               aux_end = aux_ptr + aux_cnt;
4258               for (; aux_ptr < aux_end; aux_ptr++)
4259                 {
4260                   if (*bufend - (char *) aux_out < sizeof (union aux_ext))
4261                     aux_out = ((union aux_ext *)
4262                                ecoff_add_bytes (buf, bufend,
4263                                                 (char *) aux_out,
4264                                                 sizeof (union aux_ext)));
4265                   switch (aux_ptr->type)
4266                     {
4267                     case aux_tir:
4268                       (*backend->swap_tir_out) (bigendian,
4269                                                 &aux_ptr->data.ti,
4270                                                 &aux_out->a_ti);
4271                       break;
4272                     case aux_rndx:
4273                       (*backend->swap_rndx_out) (bigendian,
4274                                                  &aux_ptr->data.rndx,
4275                                                  &aux_out->a_rndx);
4276                       break;
4277                     case aux_dnLow:
4278                       AUX_PUT_DNLOW (bigendian, aux_ptr->data.dnLow,
4279                                      aux_out);
4280                       break;
4281                     case aux_dnHigh:
4282                       AUX_PUT_DNHIGH (bigendian, aux_ptr->data.dnHigh,
4283                                       aux_out);
4284                       break;
4285                     case aux_isym:
4286                       AUX_PUT_ISYM (bigendian, aux_ptr->data.isym,
4287                                     aux_out);
4288                       break;
4289                     case aux_iss:
4290                       AUX_PUT_ISS (bigendian, aux_ptr->data.iss,
4291                                    aux_out);
4292                       break;
4293                     case aux_width:
4294                       AUX_PUT_WIDTH (bigendian, aux_ptr->data.width,
4295                                      aux_out);
4296                       break;
4297                     case aux_count:
4298                       AUX_PUT_COUNT (bigendian, aux_ptr->data.count,
4299                                      aux_out);
4300                       break;
4301                     }
4302
4303                   ++aux_out;
4304                   ++iaux;
4305                 }
4306             }
4307           fil_ptr->fdr.caux = iaux - fil_ptr->fdr.iauxBase;
4308         }
4309     }
4310
4311   return ecoff_padding_adjust (backend, buf, bufend,
4312                                offset + iaux * sizeof (union aux_ext),
4313                                (char **) NULL);
4314 }
4315
4316 /* Copy out the strings from a varray_t.  This returns the number of
4317    bytes copied, rather than the new offset.  */
4318
4319 static unsigned long
4320 ecoff_build_strings (buf, bufend, offset, vp)
4321      char **buf;
4322      char **bufend;
4323      unsigned long offset;
4324      varray_t *vp;
4325 {
4326   unsigned long istr;
4327   char *str_out;
4328   vlinks_t *str_link;
4329
4330   str_out = *buf + offset;
4331
4332   istr = 0;
4333
4334   for (str_link = vp->first;
4335        str_link != (vlinks_t *) NULL;
4336        str_link = str_link->next)
4337     {
4338       unsigned long str_cnt;
4339
4340       if (str_link->next == (vlinks_t *) NULL)
4341         str_cnt = vp->objects_last_page;
4342       else
4343         str_cnt = vp->objects_per_page;
4344
4345       if (*bufend - str_out < str_cnt)
4346         str_out = ecoff_add_bytes (buf, bufend, str_out, str_cnt);
4347
4348       memcpy (str_out, str_link->datum->byte, str_cnt);
4349       str_out += str_cnt;
4350       istr += str_cnt;
4351     }
4352
4353   return istr;
4354 }
4355
4356 /* Dump out the local strings.  */
4357
4358 static unsigned long
4359 ecoff_build_ss (backend, buf, bufend, offset)
4360      const struct ecoff_debug_swap *backend;
4361      char **buf;
4362      char **bufend;
4363      unsigned long offset;
4364 {
4365   long iss;
4366   vlinks_t *file_link;
4367
4368   iss = 0;
4369
4370   for (file_link = file_desc.first;
4371        file_link != (vlinks_t *) NULL;
4372        file_link = file_link->next)
4373     {
4374       int fil_cnt;
4375       efdr_t *fil_ptr;
4376       efdr_t *fil_end;
4377
4378       if (file_link->next == (vlinks_t *) NULL)
4379         fil_cnt = file_desc.objects_last_page;
4380       else
4381         fil_cnt = file_desc.objects_per_page;
4382       fil_ptr = file_link->datum->file;
4383       fil_end = fil_ptr + fil_cnt;
4384       for (; fil_ptr < fil_end; fil_ptr++)
4385         {
4386           long ss_cnt;
4387
4388           fil_ptr->fdr.issBase = iss;
4389           ss_cnt = ecoff_build_strings (buf, bufend, offset + iss,
4390                                         &fil_ptr->strings);
4391           fil_ptr->fdr.cbSs = ss_cnt;
4392           iss += ss_cnt;
4393         }
4394     }
4395
4396   return ecoff_padding_adjust (backend, buf, bufend, offset + iss,
4397                                (char **) NULL);
4398 }
4399
4400 /* Swap out the file descriptors.  */
4401
4402 static unsigned long
4403 ecoff_build_fdr (backend, buf, bufend, offset)
4404      const struct ecoff_debug_swap *backend;
4405      char **buf;
4406      char **bufend;
4407      unsigned long offset;
4408 {
4409   const bfd_size_type external_fdr_size = backend->external_fdr_size;
4410   void (* const swap_fdr_out) PARAMS ((bfd *, const FDR *, PTR))
4411     = backend->swap_fdr_out;
4412   long ifile;
4413   char *fdr_out;
4414   vlinks_t *file_link;
4415
4416   ifile = 0;
4417
4418   fdr_out = *buf + offset;
4419
4420   for (file_link = file_desc.first;
4421        file_link != (vlinks_t *) NULL;
4422        file_link = file_link->next)
4423     {
4424       int fil_cnt;
4425       efdr_t *fil_ptr;
4426       efdr_t *fil_end;
4427
4428       if (file_link->next == (vlinks_t *) NULL)
4429         fil_cnt = file_desc.objects_last_page;
4430       else
4431         fil_cnt = file_desc.objects_per_page;
4432       fil_ptr = file_link->datum->file;
4433       fil_end = fil_ptr + fil_cnt;
4434       for (; fil_ptr < fil_end; fil_ptr++)
4435         {
4436           if (*bufend - fdr_out < external_fdr_size)
4437             fdr_out = ecoff_add_bytes (buf, bufend, fdr_out,
4438                                        external_fdr_size);
4439           (*swap_fdr_out) (stdoutput, &fil_ptr->fdr, fdr_out);
4440           fdr_out += external_fdr_size;
4441           ++ifile;
4442         }
4443     }
4444
4445   return offset + ifile * external_fdr_size;
4446 }
4447
4448 /* Set up the external symbols.  These are supposed to be handled by
4449    the backend.  This routine just gets the right information and
4450    calls a backend function to deal with it.  */
4451
4452 static void
4453 ecoff_setup_ext ()
4454 {
4455   register symbolS *sym;
4456
4457   for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
4458     {
4459       if (sym->ecoff_symbol == NULL)
4460         continue;
4461
4462       /* If this is a local symbol, then force the fields to zero.  */
4463       if (! S_IS_EXTERNAL (sym)
4464           && S_IS_DEFINED (sym))
4465         {
4466           sym->ecoff_symbol->ecoff_sym.asym.value = 0;
4467           sym->ecoff_symbol->ecoff_sym.asym.st = (int) st_Nil;
4468           sym->ecoff_symbol->ecoff_sym.asym.sc = (int) sc_Nil;
4469           sym->ecoff_symbol->ecoff_sym.asym.index = indexNil;
4470         }
4471
4472       obj_ecoff_set_ext (sym, &sym->ecoff_symbol->ecoff_sym);
4473     }
4474 }
4475
4476 /* Build the ECOFF dbeugging information.  */
4477
4478 unsigned long
4479 ecoff_build_debug (hdr, bufp, backend)
4480      HDRR *hdr;
4481      char **bufp;
4482      const struct ecoff_debug_swap *backend;
4483 {
4484   const bfd_size_type external_pdr_size = backend->external_pdr_size;
4485   tag_t *ptag;
4486   tag_t *ptag_next;
4487   efdr_t *fil_ptr;
4488   int end_warning;
4489   efdr_t *hold_file_ptr;
4490   proc_t * hold_proc_ptr;
4491   symbolS *sym;
4492   char *buf;
4493   char *bufend;
4494   unsigned long offset;
4495
4496   /* Make sure we have a file.  */
4497   if (first_file == (efdr_t *) NULL)
4498     add_file ((const char *) NULL, 0);
4499
4500   /* Handle any top level tags.  */
4501   for (ptag = top_tag_head->first_tag;
4502        ptag != (tag_t *) NULL;
4503        ptag = ptag_next)
4504     {
4505       if (ptag->forward_ref != (forward_t *) NULL)
4506         add_unknown_tag (ptag);
4507
4508       ptag_next = ptag->same_block;
4509       ptag->hash_ptr->tag_ptr = ptag->same_name;
4510       free_tag (ptag);
4511     }
4512
4513   free_thead (top_tag_head);
4514
4515   /* Look through the symbols.  Add debugging information for each
4516      symbol that has not already received it.  */
4517   hold_file_ptr = cur_file_ptr;
4518   hold_proc_ptr = cur_proc_ptr;
4519   cur_proc_ptr = (proc_t *) NULL;
4520   for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
4521     {
4522       if (sym->ecoff_symbol != NULL
4523           || sym->ecoff_file == (efdr_t *) NULL
4524           || (sym->bsym->flags & BSF_SECTION_SYM) != 0)
4525         continue;
4526
4527       cur_file_ptr = sym->ecoff_file;
4528       add_ecoff_symbol ((const char *) NULL, st_Nil, sc_Nil, sym,
4529                         S_GET_VALUE (sym), indexNil);
4530     }
4531   cur_proc_ptr = hold_proc_ptr;
4532   cur_file_ptr = hold_file_ptr;
4533
4534   /* Output an ending symbol for all the files.  We have to do this
4535      here for the last file, so we may as well do it for all of the
4536      files.  */
4537   end_warning = 0;
4538   for (fil_ptr = first_file;
4539        fil_ptr != (efdr_t *) NULL;
4540        fil_ptr = fil_ptr->next_file)
4541     {
4542       cur_file_ptr = fil_ptr;
4543       while (cur_file_ptr->cur_scope->prev != (scope_t *) NULL)
4544         {
4545           cur_file_ptr->cur_scope = cur_file_ptr->cur_scope->prev;
4546           if (! end_warning)
4547             {
4548               as_warn ("Missing .end or .bend at end of file");
4549               end_warning = 1;
4550             }
4551         }
4552       (void) add_ecoff_symbol ((const char *) NULL,
4553                                st_End, sc_Text,
4554                                (symbolS *) NULL,
4555                                (symint_t) 0,
4556                                (symint_t) 0);
4557     }
4558
4559   /* Build the symbolic information.  */
4560   offset = 0;
4561   buf = xmalloc (PAGE_SIZE);
4562   bufend = buf + PAGE_SIZE;
4563
4564   /* Build the line number information.  */
4565   hdr->cbLineOffset = offset;
4566   offset = ecoff_build_lineno (backend, &buf, &bufend, offset,
4567                                &hdr->ilineMax);
4568   hdr->cbLine = offset - hdr->cbLineOffset;
4569
4570   /* We don't use dense numbers at all.  */
4571   hdr->idnMax = 0;
4572   hdr->cbDnOffset = 0;
4573
4574   /* We can't build the PDR table until we have built the symbols,
4575      because a PDR contains a symbol index.  However, we set aside
4576      space at this point.  */
4577   hdr->ipdMax = proc_cnt;
4578   hdr->cbPdOffset = offset;
4579   if (bufend - (buf + offset) < proc_cnt * external_pdr_size)
4580     (void) ecoff_add_bytes (&buf, &bufend, buf + offset,
4581                             proc_cnt * external_pdr_size);
4582   offset += proc_cnt * external_pdr_size;
4583
4584   /* Build the local symbols.  */
4585   hdr->cbSymOffset = offset;
4586   offset = ecoff_build_symbols (backend, &buf, &bufend, offset);
4587   hdr->isymMax = (offset - hdr->cbSymOffset) / backend->external_sym_size;
4588
4589   /* Building the symbols initializes the symbol index in the PDR's.
4590      Now we can swap out the PDR's.  */
4591   (void) ecoff_build_procs (backend, &buf, &bufend, hdr->cbPdOffset);
4592
4593   /* We don't use optimization symbols.  */
4594   hdr->ioptMax = 0;
4595   hdr->cbOptOffset = 0;
4596
4597   /* Swap out the auxiliary type information.  */
4598   hdr->cbAuxOffset = offset;
4599   offset = ecoff_build_aux (backend, &buf, &bufend, offset);
4600   hdr->iauxMax = (offset - hdr->cbAuxOffset) / sizeof (union aux_ext);
4601
4602   /* Copy out the local strings.  */
4603   hdr->cbSsOffset = offset;
4604   offset = ecoff_build_ss (backend, &buf, &bufend, offset);
4605   hdr->issMax = offset - hdr->cbSsOffset;
4606
4607   /* We don't use relative file descriptors.  */
4608   hdr->crfd = 0;
4609   hdr->cbRfdOffset = 0;
4610
4611   /* Swap out the file descriptors.  */
4612   hdr->cbFdOffset = offset;
4613   offset = ecoff_build_fdr (backend, &buf, &bufend, offset);
4614   hdr->ifdMax = (offset - hdr->cbFdOffset) / backend->external_fdr_size;
4615
4616   /* Set up the external symbols, which are handled by the BFD back
4617      end.  */
4618   hdr->issExtMax = 0;
4619   hdr->cbSsExtOffset = 0;
4620   hdr->iextMax = 0;
4621   hdr->cbExtOffset = 0;
4622   ecoff_setup_ext ();
4623
4624   know ((offset & (backend->debug_align - 1)) == 0);
4625
4626   /* FIXME: This value should be determined from the .verstamp directive,
4627      with reasonable defaults in config files.  */
4628 #ifdef TC_ALPHA
4629   hdr->vstamp = 0x030b;
4630 #else
4631   hdr->vstamp = 0x020b;
4632 #endif
4633
4634   *bufp = buf;
4635   return offset;
4636 }
4637 \f
4638 /* Allocate a cluster of pages.  */
4639
4640 #ifndef MALLOC_CHECK
4641
4642 static page_t *
4643 allocate_cluster (npages)
4644      unsigned long npages;
4645 {
4646   register page_t *value = (page_t *) xmalloc (npages * PAGE_USIZE);
4647
4648 #ifdef ECOFF_DEBUG
4649   if (debug > 3)
4650     fprintf (stderr, "\talloc\tnpages = %d, value = 0x%.8x\n", npages, value);
4651 #endif
4652
4653   memset (value, 0, npages * PAGE_USIZE);
4654
4655   return value;
4656 }
4657
4658
4659 static page_t *cluster_ptr = NULL;
4660 static unsigned long pages_left = 0;
4661
4662 #endif /* MALLOC_CHECK */
4663
4664 /* Allocate one page (which is initialized to 0).  */
4665
4666 static page_t *
4667 allocate_page ()
4668 {
4669 #ifndef MALLOC_CHECK
4670
4671   if (pages_left == 0)
4672     {
4673       pages_left = MAX_CLUSTER_PAGES;
4674       cluster_ptr = allocate_cluster (pages_left);
4675     }
4676
4677   pages_left--;
4678   return cluster_ptr++;
4679
4680 #else   /* MALLOC_CHECK */
4681
4682   page_t *ptr;
4683
4684   ptr = xmalloc (PAGE_USIZE);
4685   memset (ptr, 0, PAGE_USIZE);
4686   return ptr;
4687
4688 #endif  /* MALLOC_CHECK */
4689 }
4690 \f
4691 /* Allocate scoping information.  */
4692
4693 static scope_t *
4694 allocate_scope ()
4695 {
4696   register scope_t *ptr;
4697   static scope_t initial_scope;
4698
4699 #ifndef MALLOC_CHECK
4700
4701   ptr = alloc_counts[(int)alloc_type_scope].free_list.f_scope;
4702   if (ptr != (scope_t *) NULL)
4703     alloc_counts[ (int)alloc_type_scope ].free_list.f_scope = ptr->free;
4704   else
4705     {
4706       register int unallocated  = alloc_counts[(int)alloc_type_scope].unallocated;
4707       register page_t *cur_page = alloc_counts[(int)alloc_type_scope].cur_page;
4708
4709       if (unallocated == 0)
4710         {
4711           unallocated = PAGE_SIZE / sizeof (scope_t);
4712           alloc_counts[(int)alloc_type_scope].cur_page = cur_page = allocate_page ();
4713           alloc_counts[(int)alloc_type_scope].total_pages++;
4714         }
4715
4716       ptr = &cur_page->scope[--unallocated];
4717       alloc_counts[(int)alloc_type_scope].unallocated = unallocated;
4718     }
4719
4720 #else
4721
4722   ptr = (scope_t *) xmalloc (sizeof (scope_t));
4723
4724 #endif
4725
4726   alloc_counts[(int)alloc_type_scope].total_alloc++;
4727   *ptr = initial_scope;
4728   return ptr;
4729 }
4730
4731 /* Free scoping information.  */
4732
4733 static void
4734 free_scope (ptr)
4735      scope_t *ptr;
4736 {
4737   alloc_counts[(int)alloc_type_scope].total_free++;
4738
4739 #ifndef MALLOC_CHECK
4740   ptr->free = alloc_counts[(int)alloc_type_scope].free_list.f_scope;
4741   alloc_counts[(int)alloc_type_scope].free_list.f_scope = ptr;
4742 #else
4743   free ((PTR) ptr);
4744 #endif
4745 }
4746 \f
4747 /* Allocate links for pages in a virtual array.  */
4748
4749 static vlinks_t *
4750 allocate_vlinks ()
4751 {
4752   register vlinks_t *ptr;
4753   static vlinks_t initial_vlinks;
4754
4755 #ifndef MALLOC_CHECK
4756
4757   register int unallocated = alloc_counts[(int)alloc_type_vlinks].unallocated;
4758   register page_t *cur_page = alloc_counts[(int)alloc_type_vlinks].cur_page;
4759
4760   if (unallocated == 0)
4761     {
4762       unallocated = PAGE_SIZE / sizeof (vlinks_t);
4763       alloc_counts[(int)alloc_type_vlinks].cur_page = cur_page = allocate_page ();
4764       alloc_counts[(int)alloc_type_vlinks].total_pages++;
4765     }
4766
4767   ptr = &cur_page->vlinks[--unallocated];
4768   alloc_counts[(int)alloc_type_vlinks].unallocated = unallocated;
4769
4770 #else
4771
4772   ptr = (vlinks_t *) xmalloc (sizeof (vlinks_t));
4773
4774 #endif
4775
4776   alloc_counts[(int)alloc_type_vlinks].total_alloc++;
4777   *ptr = initial_vlinks;
4778   return ptr;
4779 }
4780 \f
4781 /* Allocate string hash buckets.  */
4782
4783 static shash_t *
4784 allocate_shash ()
4785 {
4786   register shash_t *ptr;
4787   static shash_t initial_shash;
4788
4789 #ifndef MALLOC_CHECK
4790
4791   register int unallocated = alloc_counts[(int)alloc_type_shash].unallocated;
4792   register page_t *cur_page = alloc_counts[(int)alloc_type_shash].cur_page;
4793
4794   if (unallocated == 0)
4795     {
4796       unallocated = PAGE_SIZE / sizeof (shash_t);
4797       alloc_counts[(int)alloc_type_shash].cur_page = cur_page = allocate_page ();
4798       alloc_counts[(int)alloc_type_shash].total_pages++;
4799     }
4800
4801   ptr = &cur_page->shash[--unallocated];
4802   alloc_counts[(int)alloc_type_shash].unallocated = unallocated;
4803
4804 #else
4805
4806   ptr = (shash_t *) xmalloc (sizeof (shash_t));
4807
4808 #endif
4809
4810   alloc_counts[(int)alloc_type_shash].total_alloc++;
4811   *ptr = initial_shash;
4812   return ptr;
4813 }
4814 \f
4815 /* Allocate type hash buckets.  */
4816
4817 static thash_t *
4818 allocate_thash ()
4819 {
4820   register thash_t *ptr;
4821   static thash_t initial_thash;
4822
4823 #ifndef MALLOC_CHECK
4824
4825   register int unallocated = alloc_counts[(int)alloc_type_thash].unallocated;
4826   register page_t *cur_page = alloc_counts[(int)alloc_type_thash].cur_page;
4827
4828   if (unallocated == 0)
4829     {
4830       unallocated = PAGE_SIZE / sizeof (thash_t);
4831       alloc_counts[(int)alloc_type_thash].cur_page = cur_page = allocate_page ();
4832       alloc_counts[(int)alloc_type_thash].total_pages++;
4833     }
4834
4835   ptr = &cur_page->thash[--unallocated];
4836   alloc_counts[(int)alloc_type_thash].unallocated = unallocated;
4837
4838 #else
4839
4840   ptr = (thash_t *) xmalloc (sizeof (thash_t));
4841
4842 #endif
4843
4844   alloc_counts[(int)alloc_type_thash].total_alloc++;
4845   *ptr = initial_thash;
4846   return ptr;
4847 }
4848 \f
4849 /* Allocate structure, union, or enum tag information.  */
4850
4851 static tag_t *
4852 allocate_tag ()
4853 {
4854   register tag_t *ptr;
4855   static tag_t initial_tag;
4856
4857 #ifndef MALLOC_CHECK
4858
4859   ptr = alloc_counts[(int)alloc_type_tag].free_list.f_tag;
4860   if (ptr != (tag_t *) NULL)
4861     alloc_counts[(int)alloc_type_tag].free_list.f_tag = ptr->free;
4862   else
4863     {
4864       register int unallocated = alloc_counts[(int)alloc_type_tag].unallocated;
4865       register page_t *cur_page = alloc_counts[(int)alloc_type_tag].cur_page;
4866
4867       if (unallocated == 0)
4868         {
4869           unallocated = PAGE_SIZE / sizeof (tag_t);
4870           alloc_counts[(int)alloc_type_tag].cur_page = cur_page = allocate_page ();
4871           alloc_counts[(int)alloc_type_tag].total_pages++;
4872         }
4873
4874       ptr = &cur_page->tag[--unallocated];
4875       alloc_counts[(int)alloc_type_tag].unallocated = unallocated;
4876     }
4877
4878 #else
4879
4880   ptr = (tag_t *) xmalloc (sizeof (tag_t));
4881
4882 #endif
4883
4884   alloc_counts[(int)alloc_type_tag].total_alloc++;
4885   *ptr = initial_tag;
4886   return ptr;
4887 }
4888
4889 /* Free scoping information.  */
4890
4891 static void
4892 free_tag (ptr)
4893      tag_t *ptr;
4894 {
4895   alloc_counts[(int)alloc_type_tag].total_free++;
4896
4897 #ifndef MALLOC_CHECK
4898   ptr->free = alloc_counts[(int)alloc_type_tag].free_list.f_tag;
4899   alloc_counts[(int)alloc_type_tag].free_list.f_tag = ptr;
4900 #else
4901   free ((PTR_T) ptr);
4902 #endif
4903 }
4904 \f
4905 /* Allocate forward reference to a yet unknown tag.  */
4906
4907 static forward_t *
4908 allocate_forward ()
4909 {
4910   register forward_t *ptr;
4911   static forward_t initial_forward;
4912
4913 #ifndef MALLOC_CHECK
4914
4915   register int unallocated = alloc_counts[(int)alloc_type_forward].unallocated;
4916   register page_t *cur_page = alloc_counts[(int)alloc_type_forward].cur_page;
4917
4918   if (unallocated == 0)
4919     {
4920       unallocated = PAGE_SIZE / sizeof (forward_t);
4921       alloc_counts[(int)alloc_type_forward].cur_page = cur_page = allocate_page ();
4922       alloc_counts[(int)alloc_type_forward].total_pages++;
4923     }
4924
4925   ptr = &cur_page->forward[--unallocated];
4926   alloc_counts[(int)alloc_type_forward].unallocated = unallocated;
4927
4928 #else
4929
4930   ptr = (forward_t *) xmalloc (sizeof (forward_t));
4931
4932 #endif
4933
4934   alloc_counts[(int)alloc_type_forward].total_alloc++;
4935   *ptr = initial_forward;
4936   return ptr;
4937 }
4938 \f
4939 /* Allocate head of type hash list.  */
4940
4941 static thead_t *
4942 allocate_thead ()
4943 {
4944   register thead_t *ptr;
4945   static thead_t initial_thead;
4946
4947 #ifndef MALLOC_CHECK
4948
4949   ptr = alloc_counts[(int)alloc_type_thead].free_list.f_thead;
4950   if (ptr != (thead_t *) NULL)
4951     alloc_counts[ (int)alloc_type_thead ].free_list.f_thead = ptr->free;
4952   else
4953     {
4954       register int unallocated = alloc_counts[(int)alloc_type_thead].unallocated;
4955       register page_t *cur_page = alloc_counts[(int)alloc_type_thead].cur_page;
4956
4957       if (unallocated == 0)
4958         {
4959           unallocated = PAGE_SIZE / sizeof (thead_t);
4960           alloc_counts[(int)alloc_type_thead].cur_page = cur_page = allocate_page ();
4961           alloc_counts[(int)alloc_type_thead].total_pages++;
4962         }
4963
4964       ptr = &cur_page->thead[--unallocated];
4965       alloc_counts[(int)alloc_type_thead].unallocated = unallocated;
4966     }
4967
4968 #else
4969
4970   ptr = (thead_t *) xmalloc (sizeof (thead_t));
4971
4972 #endif
4973
4974   alloc_counts[(int)alloc_type_thead].total_alloc++;
4975   *ptr = initial_thead;
4976   return ptr;
4977 }
4978
4979 /* Free scoping information.  */
4980
4981 static void
4982 free_thead (ptr)
4983      thead_t *ptr;
4984 {
4985   alloc_counts[(int)alloc_type_thead].total_free++;
4986
4987 #ifndef MALLOC_CHECK
4988   ptr->free = (thead_t *) alloc_counts[(int)alloc_type_thead].free_list.f_thead;
4989   alloc_counts[(int)alloc_type_thead].free_list.f_thead = ptr;
4990 #else
4991   free ((PTR_T) ptr);
4992 #endif
4993 }
4994 \f
4995 static lineno_list_t *
4996 allocate_lineno_list ()
4997 {
4998   register lineno_list_t *ptr;
4999   static lineno_list_t initial_lineno_list;
5000
5001 #ifndef MALLOC_CHECK
5002
5003   register int unallocated = alloc_counts[(int)alloc_type_lineno].unallocated;
5004   register page_t *cur_page = alloc_counts[(int)alloc_type_lineno].cur_page;
5005
5006   if (unallocated == 0)
5007     {
5008       unallocated = PAGE_SIZE / sizeof (lineno_list_t);
5009       alloc_counts[(int)alloc_type_lineno].cur_page = cur_page = allocate_page ();
5010       alloc_counts[(int)alloc_type_lineno].total_pages++;
5011     }
5012
5013   ptr = &cur_page->lineno[--unallocated];
5014   alloc_counts[(int)alloc_type_lineno].unallocated = unallocated;
5015
5016 #else
5017
5018   ptr = (lineno_list_t *) xmalloc (sizeof (lineno_list_t));
5019
5020 #endif
5021
5022   alloc_counts[(int)alloc_type_lineno].total_alloc++;
5023   *ptr = initial_lineno_list;
5024   return ptr;
5025 }
5026
5027 void
5028 ecoff_set_gp_prolog_size (sz)
5029      int sz;
5030 {
5031   if (cur_proc_ptr == 0)
5032     abort ();
5033
5034   cur_proc_ptr->pdr.gp_prologue = sz;
5035   if (cur_proc_ptr->pdr.gp_prologue != sz)
5036     {
5037       as_warn ("GP prologue size exceeds field size, using 0 instead");
5038       cur_proc_ptr->pdr.gp_prologue = 0;
5039     }
5040
5041   cur_proc_ptr->pdr.gp_used = 1;
5042 }
5043
5044 static void
5045 generate_ecoff_stab (what, string, type, other, desc)
5046      int what;
5047      const char *string;
5048      int type;
5049      int other;
5050      int desc;
5051 {
5052   efdr_t *save_file_ptr = cur_file_ptr;
5053   symbolS *sym;
5054   symint_t value;
5055   st_t st;
5056   sc_t sc;
5057   symint_t indx;
5058   localsym_t *hold = NULL;
5059
5060   /* We don't handle .stabd.  */
5061   if (what != 's' && what != 'n')
5062     {
5063       as_bad (".stab%c is not supported", what);
5064       return;
5065     }
5066
5067   /* We ignore the other field.  */
5068   if (other != 0)
5069     as_warn (".stab%c: ignoring non-zero other field", what);
5070
5071   /* Make sure we have a current file.  */
5072   if (cur_file_ptr == (efdr_t *) NULL)
5073     {
5074       add_file ((const char *) NULL, 0);
5075       save_file_ptr = cur_file_ptr;
5076     }
5077
5078   /* For stabs in ECOFF, the first symbol must be @stabs.  This is a
5079      signal to gdb.  */
5080   if (stabs_seen == 0)
5081     mark_stabs (0);
5082
5083   /* Line number stabs are handled differently, since they have two
5084      values, the line number and the address of the label.  We use the
5085      index field (aka desc) to hold the line number, and the value
5086      field to hold the address.  The symbol type is st_Label, which
5087      should be different from the other stabs, so that gdb can
5088      recognize it.  */
5089   if (type == N_SLINE)
5090     {
5091       SYMR dummy_symr;
5092
5093 #ifndef NO_LISTING
5094       if (listing)
5095         listing_source_line ((unsigned int) desc);
5096 #endif
5097
5098       dummy_symr.index = desc;
5099       if (dummy_symr.index != desc)
5100         {
5101           as_warn ("Line number (%d) for .stab%c directive cannot fit in index field (20 bits)",
5102                    desc, what);
5103           return;
5104         }
5105
5106       sym = symbol_find_or_make ((char *)string);
5107       value = 0;
5108       st = st_Label;
5109       sc = sc_Text;
5110       indx = desc;
5111     }
5112   else
5113     {
5114 #ifndef NO_LISTING
5115       if (listing && (type == N_SO || type == N_SOL))
5116         listing_source_file (string);
5117 #endif
5118
5119       sym = symbol_find_or_make ((char *)string);
5120       sc = sc_Nil;
5121       st = st_Nil;
5122       value = 0;
5123       indx = ECOFF_MARK_STAB (type);
5124     }
5125
5126   /* Don't store the stabs symbol we are creating as the type of the
5127      ECOFF symbol.  We want to compute the type of the ECOFF symbol
5128      independently.  */
5129   if (sym != (symbolS *) NULL)
5130     hold = sym->ecoff_symbol;
5131
5132   (void) add_ecoff_symbol (string, st, sc, sym, value, indx);
5133
5134   if (sym != (symbolS *) NULL)
5135     sym->ecoff_symbol = hold;
5136
5137   /* Restore normal file type.  */
5138   cur_file_ptr = save_file_ptr;
5139 }
5140
5141 int
5142 ecoff_no_current_file ()
5143 {
5144   return cur_file_ptr == (efdr_t *) NULL;
5145 }
5146
5147 void
5148 ecoff_generate_asm_lineno (filename, lineno)
5149     char *filename;
5150     int lineno;
5151 {
5152   lineno_list_t *list;
5153
5154   /* this potential can cause problem, when we start to see stab half the
5155      way thru the file */
5156 /*
5157   if (stabs_seen)
5158     ecoff_generate_asm_line_stab(filename, lineno);
5159 */
5160
5161   if (current_stabs_filename == (char *)NULL || strcmp (current_stabs_filename, filename))
5162     {
5163       add_file (filename, 0);
5164       generate_asm_lineno = 1;
5165     }
5166
5167   list = allocate_lineno_list ();
5168
5169   list->next = (lineno_list_t *) NULL;
5170   list->file = cur_file_ptr;
5171   list->proc = cur_proc_ptr;
5172   list->frag = frag_now;
5173   list->paddr = frag_now_fix ();
5174   list->lineno = lineno;
5175
5176   /* A .loc directive will sometimes appear before a .ent directive,
5177      which means that cur_proc_ptr will be NULL here.  Arrange to
5178      patch this up.  */
5179   if (cur_proc_ptr == (proc_t *) NULL)
5180     {
5181       lineno_list_t **pl;
5182
5183       pl = &noproc_lineno;
5184       while (*pl != (lineno_list_t *) NULL)
5185         pl = &(*pl)->next;
5186       *pl = list;
5187     }
5188   else
5189     {
5190       *last_lineno_ptr = list;
5191       last_lineno_ptr = &list->next;
5192     }
5193 }
5194
5195 static int line_label_cnt = 0;
5196 void
5197 ecoff_generate_asm_line_stab (filename, lineno)
5198     char *filename;
5199     int lineno;
5200 {
5201   char *ll;
5202
5203   if (strcmp (current_stabs_filename, filename))
5204     {
5205       add_file (filename, 0);
5206       generate_asm_lineno = 1;
5207     }
5208
5209   line_label_cnt++;
5210   /* generate local label $LMnn */
5211   ll = xmalloc(10);
5212   sprintf(ll, "$LM%d", line_label_cnt);
5213   colon (ll);
5214
5215   /* generate stab for the line */
5216   generate_ecoff_stab ('n', ll, N_SLINE, 0, lineno);
5217
5218 }
5219
5220 #endif /* ECOFF_DEBUGGING */