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