gas/ecoff.c

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