gas/ecoff.c

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