gas/ecoff.c

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