gas/ecoff.c

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