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
1405 /* Pseudo symbol to use when putting stabs into the symbol table.  */
1406 #ifndef STABS_SYMBOL
1407 #define STABS_SYMBOL "@stabs"
1408 #endif
1409
1410 static char stabs_symbol[] = STABS_SYMBOL;
1411 \f
1412 /* Prototypes for functions defined in this file.  */
1413
1414 static void add_varray_page PARAMS ((varray_t *vp));
1415 static symint_t add_string PARAMS ((varray_t *vp,
1416                                     struct hash_control *hash_tbl,
1417                                     const char *str,
1418                                     shash_t **ret_hash));
1419 static localsym_t *add_ecoff_symbol PARAMS ((const char *str, st_t type,
1420                                              sc_t storage, symbolS *sym,
1421                                              symint_t value,
1422                                              symint_t indx));
1423 static symint_t add_aux_sym_symint PARAMS ((symint_t aux_word));
1424 static symint_t add_aux_sym_rndx PARAMS ((int file_index,
1425                                           symint_t sym_index));
1426 static symint_t add_aux_sym_tir PARAMS ((type_info_t *t,
1427                                          hash_state_t state,
1428                                          thash_t **hash_tbl));
1429 static tag_t *get_tag PARAMS ((const char *tag, localsym_t *sym,
1430                                bt_t basic_type));
1431 static void add_unknown_tag PARAMS ((tag_t *ptag));
1432 static void add_procedure PARAMS ((char *func));
1433 static void add_file PARAMS ((const char *file_name, int indx));
1434 #ifdef ECOFF_DEBUG
1435 static char *sc_to_string PARAMS ((sc_t storage_class));
1436 static char *st_to_string PARAMS ((st_t symbol_type));
1437 #endif
1438 static void mark_stabs PARAMS ((int));
1439 static char *ecoff_add_bytes PARAMS ((char **buf, char **bufend,
1440                                       char *bufptr, unsigned long need));
1441 static unsigned long ecoff_padding_adjust
1442   PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1443            unsigned long offset, char **bufptrptr));
1444 static unsigned long ecoff_build_lineno
1445   PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1446            unsigned long offset, long *linecntptr));
1447 static unsigned long ecoff_build_symbols
1448   PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1449            unsigned long offset));
1450 static unsigned long ecoff_build_procs
1451   PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1452            unsigned long offset));
1453 static unsigned long ecoff_build_aux
1454   PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1455            unsigned long offset));
1456 static unsigned long ecoff_build_strings PARAMS ((char **buf, char **bufend,
1457                                                   unsigned long offset,
1458                                                   varray_t *vp));
1459 static unsigned long ecoff_build_ss
1460   PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1461            unsigned long offset));
1462 static unsigned long ecoff_build_fdr
1463   PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1464            unsigned long offset));
1465 static unsigned long ecoff_build_ext
1466   PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1467            unsigned long offset, varray_t *ext_strings,
1468            struct hash_control *ext_str_hash));
1469 static page_t *allocate_cluster PARAMS ((unsigned long npages));
1470 static page_t *allocate_page PARAMS ((void));
1471 static scope_t *allocate_scope PARAMS ((void));
1472 static void free_scope PARAMS ((scope_t *ptr));
1473 static vlinks_t *allocate_vlinks PARAMS ((void));
1474 static shash_t *allocate_shash PARAMS ((void));
1475 static thash_t *allocate_thash PARAMS ((void));
1476 static tag_t *allocate_tag PARAMS ((void));
1477 static void free_tag PARAMS ((tag_t *ptr));
1478 static forward_t *allocate_forward PARAMS ((void));
1479 static thead_t *allocate_thead PARAMS ((void));
1480 static void free_thead PARAMS ((thead_t *ptr));
1481 static lineno_list_t *allocate_lineno_list PARAMS ((void));
1482 \f
1483 /* This function should be called when the assembler starts up.  */
1484
1485 void
1486 ecoff_read_begin_hook ()
1487 {
1488   tag_hash = hash_new ();
1489   top_tag_head = allocate_thead ();
1490   top_tag_head->first_tag = (tag_t *) NULL;
1491   top_tag_head->free = (thead_t *) NULL;
1492   top_tag_head->prev = cur_tag_head;
1493   cur_tag_head = top_tag_head;
1494 }
1495
1496 /* This function should be called when a symbol is created.  */
1497
1498 void
1499 ecoff_symbol_new_hook (symbolP)
1500      symbolS *symbolP;
1501 {
1502   if (cur_file_ptr == (efdr_t *) NULL)
1503     add_file ((const char *) NULL, 0);
1504   symbolP->ecoff_file = cur_file_ptr;
1505   symbolP->ecoff_symbol = NULL;
1506   symbolP->ecoff_undefined = 0;
1507 }
1508 \f
1509 /* Add a page to a varray object.  */
1510
1511 static void
1512 add_varray_page (vp)
1513      varray_t *vp;                              /* varray to add page to */
1514 {
1515   vlinks_t *new_links = allocate_vlinks ();
1516
1517 #ifdef MALLOC_CHECK
1518   if (vp->object_size > 1)
1519     new_links->datum = (page_t *) xcalloc (1, vp->object_size);
1520   else
1521 #endif
1522     new_links->datum = allocate_page ();
1523
1524   alloc_counts[(int)alloc_type_varray].total_alloc++;
1525   alloc_counts[(int)alloc_type_varray].total_pages++;
1526
1527   new_links->start_index = vp->num_allocated;
1528   vp->objects_last_page = 0;
1529
1530   if (vp->first == (vlinks_t *) NULL)           /* first allocation? */
1531     vp->first = vp->last = new_links;
1532   else
1533     {                                           /* 2nd or greater allocation */
1534       new_links->prev = vp->last;
1535       vp->last->next = new_links;
1536       vp->last = new_links;
1537     }
1538 }
1539 \f
1540 /* Add a string (and null pad) to one of the string tables.  */
1541
1542 static symint_t
1543 add_string (vp, hash_tbl, str, ret_hash)
1544      varray_t *vp;                      /* string obstack */
1545      struct hash_control *hash_tbl;     /* ptr to hash table */
1546      const char *str;                   /* string */
1547      shash_t **ret_hash;                /* return hash pointer */
1548 {
1549   register unsigned long len = strlen (str);
1550   register shash_t *hash_ptr;
1551
1552   if (len >= PAGE_USIZE)
1553     as_fatal ("String too big (%lu bytes)", len);
1554
1555   hash_ptr = (shash_t *) hash_find (hash_tbl, str);
1556   if (hash_ptr == (shash_t *) NULL)
1557     {
1558       register const char *err;
1559
1560       if (vp->objects_last_page + len >= PAGE_USIZE)
1561         {
1562           vp->num_allocated =
1563             ((vp->num_allocated + PAGE_USIZE - 1) / PAGE_USIZE) * PAGE_USIZE;
1564           add_varray_page (vp);
1565         }
1566
1567       hash_ptr = allocate_shash ();
1568       hash_ptr->indx = vp->num_allocated;
1569
1570       hash_ptr->string = &vp->last->datum->byte[vp->objects_last_page];
1571
1572       vp->objects_last_page += len + 1;
1573       vp->num_allocated += len + 1;
1574
1575       strcpy (hash_ptr->string, str);
1576
1577       err = hash_insert (hash_tbl, str, (char *) hash_ptr);
1578       if (err)
1579         as_fatal ("Inserting \"%s\" into string hash table: %s",
1580                   str, err);
1581     }
1582
1583   if (ret_hash != (shash_t **) NULL)
1584     *ret_hash = hash_ptr;
1585
1586   return hash_ptr->indx;
1587 }
1588 \f
1589 /* Add debugging information for a symbol.  */
1590
1591 static localsym_t *
1592 add_ecoff_symbol (str, type, storage, sym_value, value, indx)
1593      const char *str;                   /* symbol name */
1594      st_t type;                         /* symbol type */
1595      sc_t storage;                      /* storage class */
1596      symbolS *sym_value;                /* associated symbol.  */
1597      symint_t value;                    /* value of symbol */
1598      symint_t indx;                     /* index to local/aux. syms */
1599 {
1600   localsym_t *psym;
1601   register scope_t *pscope;
1602   register thead_t *ptag_head;
1603   register tag_t *ptag;
1604   register tag_t *ptag_next;
1605   register varray_t *vp;
1606   register int scope_delta = 0;
1607   shash_t *hash_ptr = (shash_t *) NULL;
1608
1609   if (cur_file_ptr == (efdr_t *) NULL)
1610     as_fatal ("no current file pointer");
1611
1612   vp = &cur_file_ptr->symbols;
1613
1614  if (vp->objects_last_page == vp->objects_per_page)
1615     add_varray_page (vp);
1616
1617   psym = &vp->last->datum->sym[ vp->objects_last_page++ ];
1618
1619   if (str == (const char *) NULL && sym_value != (symbolS *) NULL)
1620     psym->name = S_GET_NAME (sym_value);
1621   else
1622     psym->name = str;
1623   psym->as_sym = sym_value;
1624   if (sym_value != (symbolS *) NULL)
1625     sym_value->ecoff_symbol = psym;
1626   psym->file_ptr = cur_file_ptr;
1627   psym->proc_ptr = cur_proc_ptr;
1628   psym->begin_ptr = (localsym_t *) NULL;
1629   psym->index_ptr = (aux_t *) NULL;
1630   psym->forward_ref = (forward_t *) NULL;
1631   psym->sym_index = -1;
1632   memset (&psym->ecoff_sym, 0, sizeof (EXTR));
1633   psym->ecoff_sym.asym.value = value;
1634   psym->ecoff_sym.asym.st = (unsigned) type;
1635   psym->ecoff_sym.asym.sc = (unsigned) storage;
1636   psym->ecoff_sym.asym.index = indx;
1637
1638   /* If there is an associated symbol, we wait until the end of the
1639      assembly before deciding where to put the name (it may be just an
1640      external symbol).  Otherwise, this is just a debugging symbol and
1641      the name should go with the current file.  */
1642   if (sym_value == (symbolS *) NULL)
1643     psym->ecoff_sym.asym.iss = ((str == (const char *) NULL)
1644                                 ? 0
1645                                 : add_string (&cur_file_ptr->strings,
1646                                               cur_file_ptr->str_hash,
1647                                               str,
1648                                               &hash_ptr));
1649
1650   ++vp->num_allocated;
1651
1652   if (ECOFF_IS_STAB (&psym->ecoff_sym.asym))
1653     return psym;
1654
1655   /* Save the symbol within the hash table if this is a static
1656      item, and it has a name.  */
1657   if (hash_ptr != (shash_t *) NULL
1658       && (type == st_Global || type == st_Static || type == st_Label
1659           || type == st_Proc || type == st_StaticProc))
1660     hash_ptr->sym_ptr = psym;
1661
1662   /* push or pop a scope if appropriate.  */
1663   switch (type)
1664     {
1665     default:
1666       break;
1667
1668     case st_File:                       /* beginning of file */
1669     case st_Proc:                       /* procedure */
1670     case st_StaticProc:                 /* static procedure */
1671     case st_Block:                      /* begin scope */
1672       pscope = allocate_scope ();
1673       pscope->prev = cur_file_ptr->cur_scope;
1674       pscope->lsym = psym;
1675       pscope->type = type;
1676       cur_file_ptr->cur_scope = pscope;
1677
1678       if (type != st_File)
1679         scope_delta = 1;
1680
1681       /* For every block type except file, struct, union, or
1682          enumeration blocks, push a level on the tag stack.  We omit
1683          file types, so that tags can span file boundaries.  */
1684       if (type != st_File && storage != sc_Info)
1685         {
1686           ptag_head = allocate_thead ();
1687           ptag_head->first_tag = 0;
1688           ptag_head->prev = cur_tag_head;
1689           cur_tag_head = ptag_head;
1690         }
1691       break;
1692
1693     case st_End:
1694       pscope = cur_file_ptr->cur_scope;
1695       if (pscope == (scope_t *) NULL)
1696         as_fatal ("too many st_End's");
1697       else
1698         {
1699           st_t begin_type = (st_t) pscope->lsym->ecoff_sym.asym.st;
1700
1701           psym->begin_ptr = pscope->lsym;
1702
1703           if (begin_type != st_File)
1704             scope_delta = -1;
1705
1706           /* Except for file, structure, union, or enumeration end
1707              blocks remove all tags created within this scope.  */
1708           if (begin_type != st_File && storage != sc_Info)
1709             {
1710               ptag_head = cur_tag_head;
1711               cur_tag_head = ptag_head->prev;
1712
1713               for (ptag = ptag_head->first_tag;
1714                    ptag != (tag_t *) NULL;
1715                    ptag = ptag_next)
1716                 {
1717                   if (ptag->forward_ref != (forward_t *) NULL)
1718                     add_unknown_tag (ptag);
1719
1720                   ptag_next = ptag->same_block;
1721                   ptag->hash_ptr->tag_ptr = ptag->same_name;
1722                   free_tag (ptag);
1723                 }
1724
1725               free_thead (ptag_head);
1726             }
1727
1728           cur_file_ptr->cur_scope = pscope->prev;
1729
1730           /* block begin gets next sym #.  This is set when we know
1731              the symbol index value.  */
1732
1733           /* Functions push two or more aux words as follows:
1734              1st word: index+1 of the end symbol (filled in later).
1735              2nd word: type of the function (plus any aux words needed).
1736              Also, tie the external pointer back to the function begin symbol.  */
1737           if (begin_type != st_File && begin_type != st_Block)
1738             {
1739               symint_t ty;
1740               varray_t *svp = &cur_file_ptr->aux_syms;
1741
1742               pscope->lsym->ecoff_sym.asym.index = add_aux_sym_symint (0);
1743               pscope->lsym->index_ptr =
1744                 &svp->last->datum->aux[svp->objects_last_page - 1];
1745               ty = add_aux_sym_tir (&last_func_type_info,
1746                                     hash_no,
1747                                     &cur_file_ptr->thash_head[0]);
1748
1749 /* This seems to be unnecessary.  I'm not even sure what it is
1750  * intended to do.  It's from mips-tfile.
1751  *            if (last_func_sym_value != (symbolS *) NULL)
1752  *              {
1753  *                last_func_sym_value->ifd = cur_file_ptr->file_index;
1754  *                last_func_sym_value->index = ty;
1755  *              }
1756  */
1757             }
1758
1759           free_scope (pscope);
1760         }
1761     }
1762
1763   cur_file_ptr->nested_scopes += scope_delta;
1764
1765 #ifdef ECOFF_DEBUG
1766   if (debug && type != st_File
1767       && (debug > 2 || type == st_Block || type == st_End
1768           || type == st_Proc || type == st_StaticProc))
1769     {
1770       char *sc_str = sc_to_string (storage);
1771       char *st_str = st_to_string (type);
1772       int depth = cur_file_ptr->nested_scopes + (scope_delta < 0);
1773
1774       fprintf (stderr,
1775                "\tlsym\tv= %10ld, depth= %2d, sc= %-12s",
1776                value, depth, sc_str);
1777
1778       if (str_start && str_end_p1 - str_start > 0)
1779         fprintf (stderr, " st= %-11s name= %.*s\n", st_str, str_end_p1 - str_start, str_start);
1780       else
1781         {
1782           unsigned long len = strlen (st_str);
1783           fprintf (stderr, " st= %.*s\n", len-1, st_str);
1784         }
1785     }
1786 #endif
1787
1788   return psym;
1789 }
1790 \f
1791 /* Add an auxiliary symbol (passing a symint).  This is actually used
1792    for integral aux types, not just symints.  */
1793
1794 static symint_t
1795 add_aux_sym_symint (aux_word)
1796      symint_t aux_word;         /* auxiliary information word */
1797 {
1798   register varray_t *vp;
1799   register aux_t *aux_ptr;
1800
1801   if (cur_file_ptr == (efdr_t *) NULL)
1802     as_fatal ("no current file pointer");
1803
1804   vp = &cur_file_ptr->aux_syms;
1805
1806   if (vp->objects_last_page == vp->objects_per_page)
1807     add_varray_page (vp);
1808
1809   aux_ptr = &vp->last->datum->aux[vp->objects_last_page++];
1810   aux_ptr->type = aux_isym;
1811   aux_ptr->data.isym = aux_word;
1812
1813   return vp->num_allocated++;
1814 }
1815
1816
1817 /* Add an auxiliary symbol (passing a file/symbol index combo).  */
1818
1819 static symint_t
1820 add_aux_sym_rndx (file_index, sym_index)
1821      int file_index;
1822      symint_t sym_index;
1823 {
1824   register varray_t *vp;
1825   register aux_t *aux_ptr;
1826
1827   if (cur_file_ptr == (efdr_t *) NULL)
1828     as_fatal ("no current file pointer");
1829
1830   vp = &cur_file_ptr->aux_syms;
1831
1832   if (vp->objects_last_page == vp->objects_per_page)
1833     add_varray_page (vp);
1834
1835   aux_ptr = &vp->last->datum->aux[vp->objects_last_page++];
1836   aux_ptr->type = aux_rndx;
1837   aux_ptr->data.rndx.rfd   = file_index;
1838   aux_ptr->data.rndx.index = sym_index;
1839
1840   return vp->num_allocated++;
1841 }
1842 \f
1843 /* Add an auxiliary symbol (passing the basic type and possibly
1844    type qualifiers).  */
1845
1846 static symint_t
1847 add_aux_sym_tir (t, state, hash_tbl)
1848      type_info_t *t;            /* current type information */
1849      hash_state_t state;        /* whether to hash type or not */
1850      thash_t **hash_tbl;        /* pointer to hash table to use */
1851 {
1852   register varray_t *vp;
1853   register aux_t *aux_ptr;
1854   static AUXU init_aux;
1855   symint_t ret;
1856   int i;
1857   AUXU aux;
1858
1859   if (cur_file_ptr == (efdr_t *) NULL)
1860     as_fatal ("no current file pointer");
1861
1862   vp = &cur_file_ptr->aux_syms;
1863
1864   aux = init_aux;
1865   aux.ti.bt = (int) t->basic_type;
1866   aux.ti.continued = 0;
1867   aux.ti.fBitfield = t->bitfield;
1868
1869   aux.ti.tq0 = (int) t->type_qualifiers[0];
1870   aux.ti.tq1 = (int) t->type_qualifiers[1];
1871   aux.ti.tq2 = (int) t->type_qualifiers[2];
1872   aux.ti.tq3 = (int) t->type_qualifiers[3];
1873   aux.ti.tq4 = (int) t->type_qualifiers[4];
1874   aux.ti.tq5 = (int) t->type_qualifiers[5];
1875
1876
1877   /* For anything that adds additional information, we must not hash,
1878      so check here, and reset our state. */
1879
1880   if (state != hash_no
1881       && (t->type_qualifiers[0] == tq_Array
1882           || t->type_qualifiers[1] == tq_Array
1883           || t->type_qualifiers[2] == tq_Array
1884           || t->type_qualifiers[3] == tq_Array
1885           || t->type_qualifiers[4] == tq_Array
1886           || t->type_qualifiers[5] == tq_Array
1887           || t->basic_type == bt_Struct
1888           || t->basic_type == bt_Union
1889           || t->basic_type == bt_Enum
1890           || t->bitfield
1891           || t->num_dims > 0))
1892     state = hash_no;
1893
1894   /* See if we can hash this type, and save some space, but some types
1895      can't be hashed (because they contain arrays or continuations),
1896      and others can be put into the hash list, but cannot use existing
1897      types because other aux entries precede this one.  */
1898
1899   if (state != hash_no)
1900     {
1901       register thash_t *hash_ptr;
1902       register symint_t hi;
1903
1904       hi = aux.isym & ((1 << HASHBITS) - 1);
1905       hi %= THASH_SIZE;
1906
1907       for (hash_ptr = hash_tbl[hi];
1908            hash_ptr != (thash_t *)0;
1909            hash_ptr = hash_ptr->next)
1910         {
1911           if (aux.isym == hash_ptr->type.isym)
1912             break;
1913         }
1914
1915       if (hash_ptr != (thash_t *) NULL && state == hash_yes)
1916         return hash_ptr->indx;
1917
1918       if (hash_ptr == (thash_t *) NULL)
1919         {
1920           hash_ptr = allocate_thash ();
1921           hash_ptr->next = hash_tbl[hi];
1922           hash_ptr->type = aux;
1923           hash_ptr->indx = vp->num_allocated;
1924           hash_tbl[hi] = hash_ptr;
1925         }
1926     }
1927
1928   /* Everything is set up, add the aux symbol. */
1929   if (vp->objects_last_page == vp->objects_per_page)
1930     add_varray_page (vp);
1931
1932   aux_ptr = &vp->last->datum->aux[ vp->objects_last_page++ ];
1933   aux_ptr->type = aux_tir;
1934   aux_ptr->data = aux;
1935
1936   ret = vp->num_allocated++;
1937
1938   /* Add bitfield length if it exists.
1939
1940      NOTE:  Mips documentation claims bitfield goes at the end of the
1941      AUX record, but the DECstation compiler emits it here.
1942      (This would only make a difference for enum bitfields.)
1943
1944      Also note:  We use the last size given since gcc may emit 2
1945      for an enum bitfield.  */
1946
1947   if (t->bitfield)
1948     (void) add_aux_sym_symint ((symint_t)t->sizes[t->num_sizes-1]);
1949
1950
1951   /* Add tag information if needed.  Structure, union, and enum
1952      references add 2 aux symbols: a [file index, symbol index]
1953      pointer to the structure type, and the current file index.  */
1954
1955   if (t->basic_type == bt_Struct
1956       || t->basic_type == bt_Union
1957       || t->basic_type == bt_Enum)
1958     {
1959       register symint_t file_index = t->tag_ptr->ifd;
1960       register localsym_t *sym  = t->tag_ptr->sym;
1961       register forward_t *forward_ref = allocate_forward ();
1962
1963       if (sym != (localsym_t *) NULL)
1964         {
1965           forward_ref->next = sym->forward_ref;
1966           sym->forward_ref = forward_ref;
1967         }
1968       else
1969         {
1970           forward_ref->next = t->tag_ptr->forward_ref;
1971           t->tag_ptr->forward_ref = forward_ref;
1972         }
1973
1974       (void) add_aux_sym_rndx (ST_RFDESCAPE, indexNil);
1975       forward_ref->index_ptr
1976         = &vp->last->datum->aux[ vp->objects_last_page - 1];
1977
1978       (void) add_aux_sym_symint (file_index);
1979       forward_ref->ifd_ptr
1980         = &vp->last->datum->aux[ vp->objects_last_page - 1];
1981     }
1982
1983   /* Add information about array bounds if they exist.  */
1984   for (i = 0; i < t->num_dims; i++)
1985     {
1986       (void) add_aux_sym_rndx (ST_RFDESCAPE,
1987                                cur_file_ptr->int_type);
1988
1989       (void) add_aux_sym_symint (cur_file_ptr->file_index);     /* file index*/
1990       (void) add_aux_sym_symint ((symint_t) 0);                 /* low bound */
1991       (void) add_aux_sym_symint (t->dimensions[i] - 1);         /* high bound*/
1992       (void) add_aux_sym_symint ((t->dimensions[i] == 0)        /* stride */
1993                                  ? 0
1994                                  : (t->sizes[i] * 8) / t->dimensions[i]);
1995     };
1996
1997   /* NOTE:  Mips documentation claims that the bitfield width goes here.
1998      But it needs to be emitted earlier. */
1999
2000   return ret;
2001 }
2002 \f
2003 /* Add a tag to the tag table (unless it already exists).  */
2004
2005 static tag_t *
2006 get_tag (tag, sym, basic_type)
2007      const char *tag;                   /* tag name */
2008      localsym_t *sym;                   /* tag start block */
2009      bt_t basic_type;                   /* bt_Struct, bt_Union, or bt_Enum */
2010 {
2011   shash_t *hash_ptr;
2012   const char *err;
2013   tag_t *tag_ptr;
2014
2015   if (cur_file_ptr == (efdr_t *) NULL)
2016     as_fatal ("no current file pointer");
2017
2018   hash_ptr = (shash_t *) hash_find (tag_hash, tag);
2019
2020   if (hash_ptr != (shash_t *) NULL
2021       && hash_ptr->tag_ptr != (tag_t *) NULL)
2022   {
2023     tag_ptr = hash_ptr->tag_ptr;
2024     if (sym != (localsym_t *) NULL)
2025       {
2026         tag_ptr->basic_type = basic_type;
2027         tag_ptr->ifd        = cur_file_ptr->file_index;
2028         tag_ptr->sym        = sym;
2029       }
2030     return tag_ptr;
2031   }
2032
2033   if (hash_ptr == (shash_t *) NULL)
2034     {
2035       char *perm;
2036
2037       perm = xmalloc ((unsigned long) (strlen (tag) + 1));
2038       strcpy (perm, tag);
2039       hash_ptr = allocate_shash ();
2040       err = hash_insert (tag_hash, perm, (char *) hash_ptr);
2041       if (err)
2042         as_fatal ("Inserting \"%s\" into tag hash table: %s",
2043                   tag, err);
2044       hash_ptr->string = perm;
2045     }
2046
2047   tag_ptr = allocate_tag ();
2048   tag_ptr->forward_ref  = (forward_t *) NULL;
2049   tag_ptr->hash_ptr     = hash_ptr;
2050   tag_ptr->same_name    = hash_ptr->tag_ptr;
2051   tag_ptr->basic_type   = basic_type;
2052   tag_ptr->sym          = sym;
2053   tag_ptr->ifd          = ((sym == (localsym_t *) NULL)
2054                            ? (symint_t) -1
2055                            : cur_file_ptr->file_index);
2056   tag_ptr->same_block   = cur_tag_head->first_tag;
2057
2058   cur_tag_head->first_tag = tag_ptr;
2059   hash_ptr->tag_ptr       = tag_ptr;
2060
2061   return tag_ptr;
2062 }
2063 \f
2064 /* Add an unknown {struct, union, enum} tag.  */
2065
2066 static void
2067 add_unknown_tag (ptag)
2068      tag_t      *ptag;          /* pointer to tag information */
2069 {
2070   shash_t *hash_ptr     = ptag->hash_ptr;
2071   char *name            = hash_ptr->string;
2072   localsym_t *sym;
2073   forward_t **pf;
2074
2075 #ifdef ECOFF_DEBUG
2076   if (debug > 1)
2077     {
2078       char *agg_type    = "{unknown aggregate type}";
2079       switch (ptag->basic_type)
2080         {
2081         case bt_Struct: agg_type = "struct";    break;
2082         case bt_Union:  agg_type = "union";     break;
2083         case bt_Enum:   agg_type = "enum";      break;
2084         default:                                break;
2085         }
2086
2087       fprintf (stderr, "unknown %s %.*s found\n", agg_type,
2088                hash_ptr->len, name_start);
2089     }
2090 #endif
2091
2092   sym = add_ecoff_symbol (name,
2093                           st_Block,
2094                           sc_Info,
2095                           (symbolS *) NULL,
2096                           (symint_t) 0,
2097                           (symint_t) 0);
2098
2099   (void) add_ecoff_symbol (name,
2100                            st_End,
2101                            sc_Info,
2102                            (symbolS *) NULL,
2103                            (symint_t) 0,
2104                            (symint_t) 0);
2105
2106   for (pf = &sym->forward_ref; *pf != (forward_t *) NULL; pf = &(*pf)->next)
2107     ;
2108   *pf = ptag->forward_ref;
2109 }
2110 \f
2111 /* Add a procedure to the current file's list of procedures, and record
2112    this is the current procedure.  */
2113
2114 static void
2115 add_procedure (func)
2116      char *func;                        /* func name */
2117 {
2118   register varray_t *vp;
2119   register proc_t *new_proc_ptr;
2120
2121 #ifdef ECOFF_DEBUG
2122   if (debug)
2123     fputc ('\n', stderr);
2124 #endif
2125
2126   if (cur_file_ptr == (efdr_t *) NULL)
2127     as_fatal ("no current file pointer");
2128
2129   vp = &cur_file_ptr->procs;
2130
2131   if (vp->objects_last_page == vp->objects_per_page)
2132     add_varray_page (vp);
2133
2134   cur_proc_ptr = new_proc_ptr = &vp->last->datum->proc[vp->objects_last_page++];
2135
2136   vp->num_allocated++;
2137
2138   new_proc_ptr->pdr.isym = -1;
2139   new_proc_ptr->pdr.iline = -1;
2140   new_proc_ptr->pdr.lnLow = -1;
2141   new_proc_ptr->pdr.lnHigh = -1;
2142
2143   /* Push the start of the function.  */
2144   new_proc_ptr->sym = add_ecoff_symbol ((const char *) NULL, st_Proc, sc_Text,
2145                                         symbol_find_or_make (func),
2146                                         (symint_t) 0, (symint_t) 0);
2147
2148   ++proc_cnt;
2149
2150   /* Fill in the linenos preceding the .ent, if any.  */
2151   if (noproc_lineno != (lineno_list_t *) NULL)
2152     {
2153       lineno_list_t *l;
2154
2155       for (l = noproc_lineno; l != (lineno_list_t *) NULL; l = l->next)
2156         l->proc = new_proc_ptr;
2157       *last_lineno_ptr = noproc_lineno;
2158       while (*last_lineno_ptr != NULL)
2159         last_lineno_ptr = &(*last_lineno_ptr)->next;
2160       noproc_lineno = (lineno_list_t *) NULL;
2161     }
2162 }
2163 \f
2164 /* Add a new filename, and set up all of the file relative
2165    virtual arrays (strings, symbols, aux syms, etc.).  Record
2166    where the current file structure lives.  */
2167
2168 static void
2169 add_file (file_name, indx)
2170      const char *file_name;             /* file name */
2171      int indx;
2172 {
2173   register int first_ch;
2174   register efdr_t *fil_ptr;
2175
2176 #ifdef ECOFF_DEBUG
2177   if (debug)
2178     fprintf (stderr, "\tfile\t%.*s\n", len, file_start);
2179 #endif
2180
2181   /* If the file name is NULL, then no .file symbol appeared, and we
2182      want to use the actual file name.  */
2183   if (file_name == (const char *) NULL)
2184     {
2185       char *file;
2186
2187       if (first_file != (efdr_t *) NULL)
2188         as_fatal ("fake .file after real one");
2189       as_where (&file, (unsigned int *) NULL);
2190       file_name = (const char *) file;
2191     }
2192
2193 #ifndef NO_LISTING
2194   if (listing)
2195     listing_source_file (file_name);
2196 #endif
2197
2198   /* If we're creating stabs, then we don't actually make a new FDR.
2199      Instead, we just create a stabs symbol.  */
2200   if (stabs_seen)
2201     {
2202       (void) add_ecoff_symbol (file_name, st_Nil, sc_Nil,
2203                                symbol_new ("L0\001", now_seg,
2204                                            (valueT) frag_now_fix (),
2205                                            frag_now),
2206                                0, ECOFF_MARK_STAB (N_SOL));
2207       return;
2208     }
2209
2210   first_ch = *file_name;
2211
2212   /* See if the file has already been created.  */
2213   for (fil_ptr = first_file;
2214        fil_ptr != (efdr_t *) NULL;
2215        fil_ptr = fil_ptr->next_file)
2216     {
2217       if (first_ch == fil_ptr->name[0]
2218           && strcmp (file_name, fil_ptr->name) == 0)
2219         {
2220           cur_file_ptr = fil_ptr;
2221           break;
2222         }
2223     }
2224
2225   /* If this is a new file, create it. */
2226   if (fil_ptr == (efdr_t *) NULL)
2227     {
2228       if (file_desc.objects_last_page == file_desc.objects_per_page)
2229         add_varray_page (&file_desc);
2230
2231       fil_ptr = cur_file_ptr =
2232         &file_desc.last->datum->file[file_desc.objects_last_page++];
2233       *fil_ptr = init_file;
2234
2235       fil_ptr->file_index = indx;
2236       ++file_desc.num_allocated;
2237
2238       /* Allocate the string hash table.  */
2239       fil_ptr->str_hash = hash_new ();
2240
2241       /* Make sure 0 byte in string table is null  */
2242       add_string (&fil_ptr->strings,
2243                   fil_ptr->str_hash,
2244                   "",
2245                   (shash_t **)0);
2246
2247       if (strlen (file_name) > PAGE_USIZE - 2)
2248         as_fatal ("Filename goes over one page boundary.");
2249
2250       /* Push the start of the filename. We assume that the filename
2251          will be stored at string offset 1.  */
2252       (void) add_ecoff_symbol (file_name, st_File, sc_Text,
2253                                (symbolS *) NULL,
2254                                (symint_t) 0, (symint_t) 0);
2255       fil_ptr->fdr.rss = 1;
2256       fil_ptr->name = &fil_ptr->strings.last->datum->byte[1];
2257
2258       /* Update the linked list of file descriptors.  */
2259       *last_file_ptr = fil_ptr;
2260       last_file_ptr = &fil_ptr->next_file;
2261
2262       /* Add void & int types to the file (void should be first to catch
2263          errant 0's within the index fields).  */
2264       fil_ptr->void_type = add_aux_sym_tir (&void_type_info,
2265                                             hash_yes,
2266                                             &cur_file_ptr->thash_head[0]);
2267
2268       fil_ptr->int_type = add_aux_sym_tir (&int_type_info,
2269                                            hash_yes,
2270                                            &cur_file_ptr->thash_head[0]);
2271     }
2272 }
2273 \f
2274 #ifdef ECOFF_DEBUG
2275
2276 /* Convert storage class to string.  */
2277
2278 static char *
2279 sc_to_string(storage_class)
2280      sc_t storage_class;
2281 {
2282   switch(storage_class)
2283     {
2284     case sc_Nil:         return "Nil,";
2285     case sc_Text:        return "Text,";
2286     case sc_Data:        return "Data,";
2287     case sc_Bss:         return "Bss,";
2288     case sc_Register:    return "Register,";
2289     case sc_Abs:         return "Abs,";
2290     case sc_Undefined:   return "Undefined,";
2291     case sc_CdbLocal:    return "CdbLocal,";
2292     case sc_Bits:        return "Bits,";
2293     case sc_CdbSystem:   return "CdbSystem,";
2294     case sc_RegImage:    return "RegImage,";
2295     case sc_Info:        return "Info,";
2296     case sc_UserStruct:  return "UserStruct,";
2297     case sc_SData:       return "SData,";
2298     case sc_SBss:        return "SBss,";
2299     case sc_RData:       return "RData,";
2300     case sc_Var:         return "Var,";
2301     case sc_Common:      return "Common,";
2302     case sc_SCommon:     return "SCommon,";
2303     case sc_VarRegister: return "VarRegister,";
2304     case sc_Variant:     return "Variant,";
2305     case sc_SUndefined:  return "SUndefined,";
2306     case sc_Init:        return "Init,";
2307     case sc_Max:         return "Max,";
2308     }
2309
2310   return "???,";
2311 }
2312
2313 #endif /* DEBUG */
2314 \f
2315 #ifdef ECOFF_DEBUG
2316
2317 /* Convert symbol type to string.  */
2318
2319 static char *
2320 st_to_string(symbol_type)
2321      st_t symbol_type;
2322 {
2323   switch(symbol_type)
2324     {
2325     case st_Nil:        return "Nil,";
2326     case st_Global:     return "Global,";
2327     case st_Static:     return "Static,";
2328     case st_Param:      return "Param,";
2329     case st_Local:      return "Local,";
2330     case st_Label:      return "Label,";
2331     case st_Proc:       return "Proc,";
2332     case st_Block:      return "Block,";
2333     case st_End:        return "End,";
2334     case st_Member:     return "Member,";
2335     case st_Typedef:    return "Typedef,";
2336     case st_File:       return "File,";
2337     case st_RegReloc:   return "RegReloc,";
2338     case st_Forward:    return "Forward,";
2339     case st_StaticProc: return "StaticProc,";
2340     case st_Constant:   return "Constant,";
2341     case st_Str:        return "String,";
2342     case st_Number:     return "Number,";
2343     case st_Expr:       return "Expr,";
2344     case st_Type:       return "Type,";
2345     case st_Max:        return "Max,";
2346     }
2347
2348   return "???,";
2349 }
2350
2351 #endif /* DEBUG */
2352 \f
2353 /* Parse .begin directives which have a label as the first argument
2354    which gives the location of the start of the block.  */
2355
2356 void
2357 ecoff_directive_begin (ignore)
2358      int ignore;
2359 {
2360   char *name;
2361   char name_end;
2362
2363   if (cur_file_ptr == (efdr_t *) NULL)
2364     {
2365       as_warn (".begin directive without a preceding .file directive");
2366       demand_empty_rest_of_line ();
2367       return;
2368     }
2369
2370   if (cur_proc_ptr == (proc_t *) NULL)
2371     {
2372       as_warn (".begin directive without a preceding .ent directive");
2373       demand_empty_rest_of_line ();
2374       return;
2375     }
2376
2377   name = input_line_pointer;
2378   name_end = get_symbol_end ();
2379
2380   (void) add_ecoff_symbol ((const char *) NULL, st_Block, sc_Text,
2381                            symbol_find_or_make (name),
2382                            (symint_t) 0, (symint_t) 0);
2383
2384   *input_line_pointer = name_end;
2385
2386   /* The line number follows, but we don't use it.  */
2387   (void) get_absolute_expression ();
2388   demand_empty_rest_of_line ();
2389 }
2390 \f
2391 /* Parse .bend directives which have a label as the first argument
2392    which gives the location of the end of the block.  */
2393
2394 void
2395 ecoff_directive_bend (ignore)
2396      int ignore;
2397 {
2398   char *name;
2399   char name_end;
2400   symbolS *endsym;
2401
2402   if (cur_file_ptr == (efdr_t *) NULL)
2403     {
2404       as_warn (".bend directive without a preceding .file directive");
2405       demand_empty_rest_of_line ();
2406       return;
2407     }
2408
2409   if (cur_proc_ptr == (proc_t *) NULL)
2410     {
2411       as_warn (".bend directive without a preceding .ent directive");
2412       demand_empty_rest_of_line ();
2413       return;
2414     }
2415
2416   name = input_line_pointer;
2417   name_end = get_symbol_end ();
2418
2419   /* The value is the distance between the .bend directive and the
2420      corresponding symbol.  We fill in the offset when we write out
2421      the symbol.  */
2422   endsym = symbol_find (name);
2423   if (endsym == (symbolS *) NULL)
2424     as_warn (".bend directive names unknown symbol");
2425   else
2426     (void) add_ecoff_symbol ((const char *) NULL, st_End, sc_Text, endsym,
2427                              (symint_t) 0, (symint_t) 0);
2428
2429   *input_line_pointer = name_end;
2430
2431   /* The line number follows, but we don't use it.  */
2432   (void) get_absolute_expression ();
2433   demand_empty_rest_of_line ();
2434 }
2435 \f
2436 /* COFF debugging information is provided as a series of directives
2437    (.def, .scl, etc.).  We build up information as we read the
2438    directives in the following static variables, and file it away when
2439    we reach the .endef directive.  */
2440 static char *coff_sym_name;
2441 static type_info_t coff_type;
2442 static sc_t coff_storage_class;
2443 static st_t coff_symbol_typ;
2444 static int coff_is_function;
2445 static char *coff_tag;
2446 static valueT coff_value;
2447 symbolS *coff_sym_value;
2448 static int coff_inside_enumeration;
2449
2450 /* Handle a .def directive: start defining a symbol.  */
2451
2452 void
2453 ecoff_directive_def (ignore)
2454      int ignore;
2455 {
2456   char *name;
2457   char name_end;
2458
2459   SKIP_WHITESPACE ();
2460
2461   name = input_line_pointer;
2462   name_end = get_symbol_end ();
2463
2464   if (coff_sym_name != (char *) NULL)
2465     as_warn (".def pseudo-op used inside of .def/.endef; ignored");
2466   else if (*name == '\0')
2467     as_warn ("Empty symbol name in .def; ignored");
2468   else
2469     {
2470       if (coff_sym_name != (char *) NULL)
2471         free (coff_sym_name);
2472       if (coff_tag != (char *) NULL)
2473         free (coff_tag);
2474       coff_sym_name = (char *) xmalloc ((unsigned long) (strlen (name) + 1));
2475       strcpy (coff_sym_name, name);
2476       coff_type = type_info_init;
2477       coff_storage_class = sc_Nil;
2478       coff_symbol_typ = st_Nil;
2479       coff_is_function = 0;
2480       coff_tag = (char *) NULL;
2481       coff_value = 0;
2482       coff_sym_value = (symbolS *) NULL;
2483     }
2484
2485   *input_line_pointer = name_end;
2486
2487   demand_empty_rest_of_line ();
2488 }
2489
2490 /* Handle a .dim directive, used to give dimensions for an array.  The
2491    arguments are comma separated numbers.  mips-tfile assumes that
2492    there will not be more than 6 dimensions, and gdb won't read any
2493    more than that anyhow, so I will also make that assumption.  */
2494
2495 void
2496 ecoff_directive_dim (ignore)
2497      int ignore;
2498 {
2499   int dimens[N_TQ];
2500   int i;
2501
2502   if (coff_sym_name == (char *) NULL)
2503     {
2504       as_warn (".dim pseudo-op used outside of .def/.endef; ignored");
2505       demand_empty_rest_of_line ();
2506       return;
2507     }
2508
2509   for (i = 0; i < N_TQ; i++)
2510     {
2511       SKIP_WHITESPACE ();
2512       dimens[i] = get_absolute_expression ();
2513       if (*input_line_pointer == ',')
2514         ++input_line_pointer;
2515       else
2516         {
2517           if (*input_line_pointer != '\n'
2518               && *input_line_pointer != ';')
2519             as_warn ("Badly formed .dim directive");
2520           break;
2521         }
2522     }
2523
2524   if (i == N_TQ)
2525     --i;
2526
2527   /* The dimensions are stored away in reverse order.  */
2528   for (; i >= 0; i--)
2529     {
2530       if (coff_type.num_dims >= N_TQ)
2531         {
2532           as_warn ("Too many .dim entries");
2533           break;
2534         }
2535       coff_type.dimensions[coff_type.num_dims] = dimens[i];
2536       ++coff_type.num_dims;
2537     }
2538
2539   demand_empty_rest_of_line ();
2540 }
2541
2542 /* Handle a .scl directive, which sets the COFF storage class of the
2543    symbol.  */
2544
2545 void
2546 ecoff_directive_scl (ignore)
2547      int ignore;
2548 {
2549   long val;
2550
2551   if (coff_sym_name == (char *) NULL)
2552     {
2553       as_warn (".scl pseudo-op used outside of .def/.endef; ignored");
2554       demand_empty_rest_of_line ();
2555       return;
2556     }
2557
2558   val = get_absolute_expression ();
2559
2560   coff_symbol_typ = map_coff_sym_type[val];
2561   coff_storage_class = map_coff_storage[val];
2562
2563   demand_empty_rest_of_line ();
2564 }
2565
2566 /* Handle a .size directive.  For some reason mips-tfile.c thinks that
2567    .size can have multiple arguments.  We humor it, although gcc will
2568    never generate more than one argument.  */
2569
2570 void
2571 ecoff_directive_size (ignore)
2572      int ignore;
2573 {
2574   int sizes[N_TQ];
2575   int i;
2576
2577   if (coff_sym_name == (char *) NULL)
2578     {
2579       as_warn (".size pseudo-op used outside of .def/.endef; ignored");
2580       demand_empty_rest_of_line ();
2581       return;
2582     }
2583
2584   for (i = 0; i < N_TQ; i++)
2585     {
2586       SKIP_WHITESPACE ();
2587       sizes[i] = get_absolute_expression ();
2588       if (*input_line_pointer == ',')
2589         ++input_line_pointer;
2590       else
2591         {
2592           if (*input_line_pointer != '\n'
2593               && *input_line_pointer != ';')
2594             as_warn ("Badly formed .size directive");
2595           break;
2596         }
2597     }
2598
2599   if (i == N_TQ)
2600     --i;
2601
2602   /* The sizes are stored away in reverse order.  */
2603   for (; i >= 0; i--)
2604     {
2605       if (coff_type.num_sizes >= N_TQ)
2606         {
2607           as_warn ("Too many .size entries");
2608           break;
2609         }
2610       coff_type.sizes[coff_type.num_sizes] = sizes[i];
2611       ++coff_type.num_sizes;
2612     }
2613
2614   demand_empty_rest_of_line ();
2615 }
2616
2617 /* Handle the .type directive, which gives the COFF type of the
2618    symbol.  */
2619
2620 void
2621 ecoff_directive_type (ignore)
2622      int ignore;
2623 {
2624   long val;
2625   tq_t *tq_ptr;
2626   tq_t *tq_shft;
2627
2628   if (coff_sym_name == (char *) NULL)
2629     {
2630       as_warn (".type pseudo-op used outside of .def/.endef; ignored");
2631       demand_empty_rest_of_line ();
2632       return;
2633     }
2634
2635   val = get_absolute_expression ();
2636
2637   coff_type.orig_type = BTYPE (val);
2638   coff_type.basic_type = map_coff_types[coff_type.orig_type];
2639
2640   tq_ptr = &coff_type.type_qualifiers[N_TQ];
2641   while (val &~ N_BTMASK)
2642     {
2643       if (tq_ptr == &coff_type.type_qualifiers[0])
2644         {
2645           as_warn ("Too derived values in .type argument");
2646           break;
2647         }
2648       if (ISPTR (val))
2649         *--tq_ptr = tq_Ptr;
2650       else if (ISFCN (val))
2651         *--tq_ptr = tq_Proc;
2652       else if (ISARY (val))
2653         *--tq_ptr = tq_Array;
2654       else
2655         as_fatal ("Unrecognized .type argument");
2656
2657       val = DECREF (val);
2658     }
2659
2660   tq_shft = &coff_type.type_qualifiers[0];
2661   while (tq_ptr != &coff_type.type_qualifiers[N_TQ])
2662     *tq_shft++ = *tq_ptr++;
2663
2664   if (tq_shft != &coff_type.type_qualifiers[0] && tq_shft[-1] == tq_Proc)
2665     {
2666       /* If this is a function, ignore it, so that we don't get two
2667          entries (one from the .ent, and one for the .def that
2668          precedes it).  Save the type information so that the end
2669          block can properly add it after the begin block index.  For
2670          MIPS knows what reason, we must strip off the function type
2671          at this point.  */
2672       coff_is_function = 1;
2673       tq_shft[-1] = tq_Nil;
2674     }
2675
2676   while (tq_shft != &coff_type.type_qualifiers[N_TQ])
2677     *tq_shft++ = tq_Nil;
2678
2679   demand_empty_rest_of_line ();
2680 }
2681
2682 /* Handle the .tag directive, which gives the name of a structure,
2683    union or enum.  */
2684
2685 void
2686 ecoff_directive_tag (ignore)
2687      int ignore;
2688 {
2689   char *name;
2690   char name_end;
2691
2692   if (coff_sym_name == (char *) NULL)
2693     {
2694       as_warn (".tag pseudo-op used outside of .def/.endef; ignored");
2695       demand_empty_rest_of_line ();
2696       return;
2697     }
2698
2699   name = input_line_pointer;
2700   name_end = get_symbol_end ();
2701
2702   coff_tag = (char *) xmalloc ((unsigned long) (strlen (name) + 1));
2703   strcpy (coff_tag, name);
2704
2705   *input_line_pointer = name_end;
2706
2707   demand_empty_rest_of_line ();
2708 }
2709
2710 /* Handle the .val directive, which gives the value of the symbol.  It
2711    may be the name of a static or global symbol.  */
2712
2713 void
2714 ecoff_directive_val (ignore)
2715      int ignore;
2716 {
2717   if (coff_sym_name == (char *) NULL)
2718     {
2719       as_warn (".val pseudo-op used outside of .def/.endef; ignored");
2720       demand_empty_rest_of_line ();
2721       return;
2722     }
2723
2724   if (! is_name_beginner ((unsigned char) *input_line_pointer))
2725     coff_value = get_absolute_expression ();
2726   else
2727     {
2728       char *name;
2729       char name_end;
2730
2731       name = input_line_pointer;
2732       name_end = get_symbol_end ();
2733
2734       if (strcmp (name, ".") == 0)
2735         as_warn ("`.val .' not supported");
2736       else
2737         coff_sym_value = symbol_find_or_make (name);
2738
2739       *input_line_pointer = name_end;
2740
2741       /* FIXME: gcc can generate address expressions here in unusual
2742          cases (search for "obscure" in sdbout.c), although this is
2743          very unlikely for a MIPS chip.  */
2744     }
2745
2746   demand_empty_rest_of_line ();
2747 }
2748
2749 /* Handle the .endef directive, which terminates processing of COFF
2750    debugging information for a symbol.  */
2751
2752 void
2753 ecoff_directive_endef (ignore)
2754      int ignore;
2755 {
2756   char *name;
2757   symint_t indx;
2758   localsym_t *sym;
2759
2760   demand_empty_rest_of_line ();
2761
2762   if (coff_sym_name == (char *) NULL)
2763     {
2764       as_warn (".endef pseudo-op used before .def; ignored");
2765       return;
2766     }
2767
2768   name = coff_sym_name;
2769   coff_sym_name = (char *) NULL;
2770
2771   /* If the symbol is a static or external, we have already gotten the
2772      appropriate type and class, so make sure we don't override those
2773      values.  This is needed because there are some type and classes
2774      that are not in COFF, such as short data, etc.  */
2775   if (coff_sym_value != (symbolS *) NULL)
2776     {
2777       coff_symbol_typ = st_Nil;
2778       coff_storage_class = sc_Nil;
2779     }
2780
2781   coff_type.extra_sizes = coff_tag != (char *) NULL;
2782   if (coff_type.num_dims > 0)
2783     {
2784       int diff = coff_type.num_dims - coff_type.num_sizes;
2785       int i = coff_type.num_dims - 1;
2786       int j;
2787
2788       if (coff_type.num_sizes != 1 || diff < 0)
2789         {
2790           as_warn ("Bad COFF debugging info");
2791           return;
2792         }
2793
2794       /* If this is an array, make sure the same number of dimensions
2795          and sizes were passed, creating extra sizes for multiply
2796          dimensioned arrays if not passed.  */
2797       coff_type.extra_sizes = 0;
2798       if (diff)
2799         {
2800           j = (sizeof (coff_type.sizes) / sizeof (coff_type.sizes[0])) - 1;
2801           while (j >= 0)
2802             {
2803               coff_type.sizes[j] = (((j - diff) >= 0)
2804                                     ? coff_type.sizes[j - diff]
2805                                     : 0);
2806               j--;
2807             }
2808
2809           coff_type.num_sizes = i + 1;
2810           for (i--; i >= 0; i--)
2811             coff_type.sizes[i] = (coff_type.sizes[i + 1]
2812                                   / coff_type.dimensions[i + 1]);
2813         }
2814     }
2815   else if (coff_symbol_typ == st_Member
2816            && coff_type.num_sizes - coff_type.extra_sizes == 1)
2817     {
2818       /* Is this a bitfield?  This is indicated by a structure memeber
2819          having a size field that isn't an array.  */
2820       coff_type.bitfield = 1;
2821     }
2822
2823   /* Except for enumeration members & begin/ending of scopes, put the
2824      type word in the aux. symbol table.  */
2825   if (coff_symbol_typ == st_Block || coff_symbol_typ == st_End)
2826     indx = 0;
2827   else if (coff_inside_enumeration)
2828     indx = cur_file_ptr->void_type;
2829   else
2830     {
2831       if (coff_type.basic_type == bt_Struct
2832           || coff_type.basic_type == bt_Union
2833           || coff_type.basic_type == bt_Enum)
2834         {
2835           if (coff_tag == (char *) NULL)
2836             {
2837               as_warn ("No tag specified for %s", name);
2838               return;
2839             }
2840
2841           coff_type.tag_ptr = get_tag (coff_tag, (localsym_t *) NULL,
2842                                        coff_type.basic_type);
2843         }
2844
2845       if (coff_is_function)
2846         {
2847           last_func_type_info = coff_type;
2848           last_func_sym_value = coff_sym_value;
2849           return;
2850         }
2851
2852       indx = add_aux_sym_tir (&coff_type,
2853                               hash_yes,
2854                               &cur_file_ptr->thash_head[0]);
2855     }
2856
2857   /* Do any last minute adjustments that are necessary.  */
2858   switch (coff_symbol_typ)
2859     {
2860     default:
2861       break;
2862
2863       /* For the beginning of structs, unions, and enumerations, the
2864          size info needs to be passed in the value field.  */
2865     case st_Block:
2866       if (coff_type.num_sizes - coff_type.num_dims - coff_type.extra_sizes
2867           != 1)
2868         {
2869           as_warn ("Bad COFF debugging information");
2870           return;
2871         }
2872       else
2873         coff_value = coff_type.sizes[0];
2874
2875       coff_inside_enumeration = (coff_type.orig_type == T_ENUM);
2876       break;
2877
2878       /* For the end of structs, unions, and enumerations, omit the
2879          name which is always ".eos".  This needs to be done last, so
2880          that any error reporting above gives the correct name.  */
2881     case st_End:
2882       free (name);
2883       name = (char *) NULL;
2884       coff_value = 0;
2885       coff_inside_enumeration = 0;
2886       break;
2887
2888       /* Members of structures and unions that aren't bitfields, need
2889          to adjust the value from a byte offset to a bit offset.
2890          Members of enumerations do not have the value adjusted, and
2891          can be distinguished by indx == indexNil.  For enumerations,
2892          update the maximum enumeration value.  */
2893     case st_Member:
2894       if (! coff_type.bitfield && ! coff_inside_enumeration)
2895         coff_value *= 8;
2896
2897       break;
2898     }
2899
2900   /* Add the symbol.  */
2901   sym = add_ecoff_symbol (name,
2902                           coff_symbol_typ,
2903                           coff_storage_class,
2904                           coff_sym_value,
2905                           (symint_t) coff_value,
2906                           indx);
2907
2908   /* deal with struct, union, and enum tags.  */
2909   if (coff_symbol_typ == st_Block)
2910     {
2911       /* Create or update the tag information.  */
2912       tag_t *tag_ptr = get_tag (name,
2913                                 sym,
2914                                 coff_type.basic_type);
2915       forward_t **pf;
2916
2917       /* Remember any forward references.  */
2918       for (pf = &sym->forward_ref;
2919            *pf != (forward_t *) NULL;
2920            pf = &(*pf)->next)
2921         ;
2922       *pf = tag_ptr->forward_ref;
2923       tag_ptr->forward_ref = (forward_t *) NULL;
2924     }
2925 }
2926 \f
2927 /* Parse .end directives.  */
2928
2929 void
2930 ecoff_directive_end (ignore)
2931      int ignore;
2932 {
2933   char *name;
2934   char name_end;
2935   register int ch;
2936   symbolS *ent;
2937
2938   if (cur_file_ptr == (efdr_t *) NULL)
2939     {
2940       as_warn (".end directive without a preceding .file directive");
2941       demand_empty_rest_of_line ();
2942       return;
2943     }
2944
2945   if (cur_proc_ptr == (proc_t *) NULL)
2946     {
2947       as_warn (".end directive without a preceding .ent directive");
2948       demand_empty_rest_of_line ();
2949       return;
2950     }
2951
2952   name = input_line_pointer;
2953   name_end = get_symbol_end ();
2954
2955   ch = *name;
2956   if (! is_name_beginner (ch))
2957     {
2958       as_warn (".end directive has no name");
2959       *input_line_pointer = name_end;
2960       demand_empty_rest_of_line ();
2961       return;
2962     }
2963
2964   /* The value is the distance between the .end directive and the
2965      corresponding symbol.  We create a fake symbol to hold the
2966      current location, and put in the offset when we write out the
2967      symbol.  */
2968   ent = symbol_find (name);
2969   if (ent == (symbolS *) NULL)
2970     as_warn (".end directive names unknown symbol");
2971   else
2972     (void) add_ecoff_symbol ((const char *) NULL, st_End, sc_Text,
2973                              symbol_new ("L0\001", now_seg,
2974                                          (valueT) frag_now_fix (),
2975                                          frag_now),
2976                              (symint_t) 0, (symint_t) 0);
2977
2978   cur_proc_ptr = (proc_t *) NULL;
2979
2980   *input_line_pointer = name_end;
2981   demand_empty_rest_of_line ();
2982 }
2983 \f
2984 /* Parse .ent directives.  */
2985
2986 void
2987 ecoff_directive_ent (ignore)
2988      int ignore;
2989 {
2990   char *name;
2991   char name_end;
2992   register int ch;
2993
2994   if (cur_file_ptr == (efdr_t *) NULL)
2995     add_file ((const char *) NULL, 0);
2996
2997   if (cur_proc_ptr != (proc_t *) NULL)
2998     {
2999       as_warn ("second .ent directive found before .end directive");
3000       demand_empty_rest_of_line ();
3001       return;
3002     }
3003
3004   name = input_line_pointer;
3005   name_end = get_symbol_end ();
3006
3007   ch = *name;
3008   if (! is_name_beginner (ch))
3009     {
3010       as_warn (".ent directive has no name");
3011       *input_line_pointer = name_end;
3012       demand_empty_rest_of_line ();
3013       return;
3014     }
3015
3016   add_procedure (name);
3017
3018   *input_line_pointer = name_end;
3019
3020   /* The .ent directive is sometimes followed by a number.  I'm not
3021      really sure what the number means.  I don't see any way to store
3022      the information in the PDR.  The Irix 4 assembler seems to ignore
3023      the information.  */
3024   SKIP_WHITESPACE ();
3025   if (*input_line_pointer == ',')
3026     {
3027       ++input_line_pointer;
3028       SKIP_WHITESPACE ();
3029     }
3030   if (isdigit (*input_line_pointer) || *input_line_pointer == '-')
3031     (void) get_absolute_expression ();
3032
3033   demand_empty_rest_of_line ();
3034 }
3035 \f
3036 /* Parse .file directives.  */
3037
3038 void
3039 ecoff_directive_file (ignore)
3040      int ignore;
3041 {
3042   int indx;
3043   char *name;
3044   int len;
3045
3046   if (cur_proc_ptr != (proc_t *) NULL)
3047     {
3048       as_warn ("No way to handle .file within .ent/.end section");
3049       demand_empty_rest_of_line ();
3050       return;
3051     }
3052
3053   indx = (int) get_absolute_expression ();
3054
3055   /* FIXME: we don't have to save the name here.  */
3056   name = demand_copy_C_string (&len);
3057
3058   add_file (name, indx - 1);
3059
3060   demand_empty_rest_of_line ();
3061 }
3062 \f
3063 /* Parse .fmask directives.  */
3064
3065 void
3066 ecoff_directive_fmask (ignore)
3067      int ignore;
3068 {
3069   long val;
3070
3071   if (cur_proc_ptr == (proc_t *) NULL)
3072     {
3073       as_warn (".fmask outside of .ent");
3074       demand_empty_rest_of_line ();
3075       return;
3076     }
3077
3078   if (get_absolute_expression_and_terminator (&val) != ',')
3079     {
3080       as_warn ("Bad .fmask directive");
3081       --input_line_pointer;
3082       demand_empty_rest_of_line ();
3083       return;
3084     }
3085
3086   cur_proc_ptr->pdr.fregmask = val;
3087   cur_proc_ptr->pdr.fregoffset = get_absolute_expression ();
3088
3089   demand_empty_rest_of_line ();
3090 }
3091 \f
3092 /* Parse .frame directives.  */
3093
3094 void
3095 ecoff_directive_frame (ignore)
3096      int ignore;
3097 {
3098   long val;
3099
3100   if (cur_proc_ptr == (proc_t *) NULL)
3101     {
3102       as_warn (".frame outside of .ent");
3103       demand_empty_rest_of_line ();
3104       return;
3105     }
3106
3107   cur_proc_ptr->pdr.framereg = tc_get_register (1);
3108
3109   SKIP_WHITESPACE ();
3110   if (*input_line_pointer++ != ','
3111       || get_absolute_expression_and_terminator (&val) != ',')
3112     {
3113       as_warn ("Bad .frame directive");
3114       --input_line_pointer;
3115       demand_empty_rest_of_line ();
3116       return;
3117     }
3118
3119   cur_proc_ptr->pdr.frameoffset = val;
3120
3121   cur_proc_ptr->pdr.pcreg = tc_get_register (0);
3122
3123   demand_empty_rest_of_line ();
3124 }
3125 \f
3126 /* Parse .mask directives.  */
3127
3128 void
3129 ecoff_directive_mask (ignore)
3130      int ignore;
3131 {
3132   long val;
3133
3134   if (cur_proc_ptr == (proc_t *) NULL)
3135     {
3136       as_warn (".mask outside of .ent");
3137       demand_empty_rest_of_line ();
3138       return;
3139     }
3140
3141   if (get_absolute_expression_and_terminator (&val) != ',')
3142     {
3143       as_warn ("Bad .mask directive");
3144       --input_line_pointer;
3145       demand_empty_rest_of_line ();
3146       return;
3147     }
3148
3149   cur_proc_ptr->pdr.regmask = val;
3150   cur_proc_ptr->pdr.regoffset = get_absolute_expression ();
3151
3152   demand_empty_rest_of_line ();
3153 }
3154 \f
3155 /* Parse .loc directives.  */
3156
3157 void
3158 ecoff_directive_loc (ignore)
3159      int ignore;
3160 {
3161   lineno_list_t *list;
3162   symint_t lineno;
3163
3164   if (cur_file_ptr == (efdr_t *) NULL)
3165     {
3166       as_warn (".loc before .file");
3167       demand_empty_rest_of_line ();
3168       return;
3169     }
3170
3171   if (now_seg != text_section)
3172     {
3173       as_warn (".loc outside of .text");
3174       demand_empty_rest_of_line ();
3175       return;
3176     }
3177
3178   /* Skip the file number.  */
3179   SKIP_WHITESPACE ();
3180   get_absolute_expression ();
3181   SKIP_WHITESPACE ();
3182
3183   lineno = get_absolute_expression ();
3184
3185 #ifndef NO_LISTING
3186   if (listing)
3187     listing_source_line (lineno);
3188 #endif
3189
3190   /* If we're building stabs, then output a special label rather than
3191      ECOFF line number info.  */
3192   if (stabs_seen)
3193     {
3194       (void) add_ecoff_symbol ((char *) NULL, st_Label, sc_Text,
3195                                symbol_new ("L0\001", now_seg,
3196                                            (valueT) frag_now_fix (),
3197                                            frag_now),
3198                                0, lineno);
3199       return;
3200     }
3201
3202   list = allocate_lineno_list ();
3203
3204   list->next = (lineno_list_t *) NULL;
3205   list->file = cur_file_ptr;
3206   list->proc = cur_proc_ptr;
3207   list->frag = frag_now;
3208   list->paddr = frag_now_fix ();
3209   list->lineno = lineno;
3210
3211   /* A .loc directive will sometimes appear before a .ent directive,
3212      which means that cur_proc_ptr will be NULL here.  Arrange to
3213      patch this up.  */
3214   if (cur_proc_ptr == (proc_t *) NULL)
3215     {
3216       lineno_list_t **pl;
3217
3218       pl = &noproc_lineno;
3219       while (*pl != (lineno_list_t *) NULL)
3220         pl = &(*pl)->next;
3221       *pl = list;
3222     }
3223   else
3224     {
3225       *last_lineno_ptr = list;
3226       last_lineno_ptr = &list->next;
3227     }
3228 }
3229 \f
3230 /* Make sure the @stabs symbol is emitted.  */
3231
3232 static void
3233 mark_stabs (ignore)
3234      int ignore;
3235 {
3236   if (! stabs_seen)
3237     {
3238       /* Add a dummy @stabs dymbol. */
3239       stabs_seen = 1;
3240       (void) add_ecoff_symbol (stabs_symbol, stNil, scInfo,
3241                                (symbolS *) NULL,
3242                                (symint_t) -1, ECOFF_MARK_STAB (0));
3243     }
3244 }
3245 \f
3246 /* Handle .stabs directives.  The actual parsing routine is done by a
3247    generic routine.  This routine is called via OBJ_PROCESS_STAB.
3248    When this is called, input_line_pointer will be pointing at the
3249    value field of the stab.
3250
3251    .stabs directives have five fields:
3252         "string"        a string, encoding the type information.
3253         code            a numeric code, defined in <stab.h>
3254         0               a zero
3255         desc            a zero or line number
3256         value           a numeric value or an address.
3257
3258     If the value is relocatable, we transform this into:
3259         iss             points as an index into string space
3260         value           value from lookup of the name
3261         st              st from lookup of the name
3262         sc              sc from lookup of the name
3263         index           code|CODE_MASK
3264
3265     If the value is not relocatable, we transform this into:
3266         iss             points as an index into string space
3267         value           value
3268         st              st_Nil
3269         sc              sc_Nil
3270         index           code|CODE_MASK
3271
3272     .stabn directives have four fields (string is null):
3273         code            a numeric code, defined in <stab.h>
3274         0               a zero
3275         desc            a zero or a line number
3276         value           a numeric value or an address.  */
3277
3278 void
3279 ecoff_stab (what, string, type, other, desc)
3280      int what;
3281      const char *string;
3282      int type;
3283      int other;
3284      int desc;
3285 {
3286   efdr_t *save_file_ptr = cur_file_ptr;
3287   symbolS *sym;
3288   symint_t value;
3289   st_t st;
3290   sc_t sc;
3291   symint_t indx;
3292
3293   /* We don't handle .stabd.  */
3294   if (what != 's' && what != 'n')
3295     {
3296       as_bad (".stab%c is not supported", what);
3297       return;
3298     }
3299
3300   /* A .stabn uses a null name, not an empty string.  */
3301   if (what == 'n')
3302     string = NULL;
3303
3304   /* We ignore the other field.  */
3305   if (other != 0)
3306     as_warn (".stab%c: ignoring non-zero other field", what);
3307
3308   /* Make sure we have a current file.  */
3309   if (cur_file_ptr == (efdr_t *) NULL)
3310     {
3311       add_file ((const char *) NULL, 0);
3312       save_file_ptr = cur_file_ptr;
3313     }
3314
3315   /* For stabs in ECOFF, the first symbol must be @stabs.  This is a
3316      signal to gdb.  */
3317   if (stabs_seen == 0)
3318     mark_stabs (0);
3319
3320   /* Line number stabs are handled differently, since they have two
3321      values, the line number and the address of the label.  We use the
3322      index field (aka desc) to hold the line number, and the value
3323      field to hold the address.  The symbol type is st_Label, which
3324      should be different from the other stabs, so that gdb can
3325      recognize it.  */
3326   if (type == N_SLINE)
3327     {
3328       SYMR dummy_symr;
3329       char *name;
3330       char name_end;
3331
3332 #ifndef NO_LISTING
3333       if (listing)
3334         listing_source_line ((unsigned int) desc);
3335 #endif
3336
3337       dummy_symr.index = desc;
3338       if (dummy_symr.index != desc)
3339         {
3340           as_warn ("Line number (%d) for .stab%c directive cannot fit in index field (20 bits)",
3341                    desc, what);
3342           return;
3343         }
3344
3345       name = input_line_pointer;
3346       name_end = get_symbol_end ();
3347
3348       sym = symbol_find_or_make (name);
3349       *input_line_pointer = name_end;
3350
3351       value = 0;
3352       st = st_Label;
3353       sc = sc_Text;
3354       indx = desc;
3355     }
3356   else
3357     {
3358 #ifndef NO_LISTING
3359       if (listing && (type == N_SO || type == N_SOL))
3360         listing_source_file (string);
3361 #endif
3362
3363       if (isdigit (*input_line_pointer)
3364           || *input_line_pointer == '-'
3365           || *input_line_pointer == '+')
3366         {
3367           st = st_Nil;
3368           sc = sc_Nil;
3369           sym = (symbolS *) NULL;
3370           value = get_absolute_expression ();
3371         }
3372       else if (! is_name_beginner ((unsigned char) *input_line_pointer))
3373         {
3374           as_warn ("Illegal .stab%c directive, bad character", what);
3375           return;
3376         }
3377       else
3378         {
3379           char *name;
3380           char name_end;
3381
3382           name = input_line_pointer;
3383           name_end = get_symbol_end ();
3384
3385           sym = symbol_find_or_make (name);
3386
3387           sc = sc_Nil;
3388           st = st_Nil;
3389           value = 0;
3390
3391           *input_line_pointer = name_end;
3392           if (name_end == '+' || name_end == '-')
3393             {
3394               ++input_line_pointer;
3395               value = get_absolute_expression ();
3396               if (name_end == '-')
3397                 value = - value;
3398             }
3399         }
3400
3401       indx = ECOFF_MARK_STAB (type);
3402     }
3403
3404   (void) add_ecoff_symbol (string, st, sc, sym, value, indx);
3405
3406   /* Restore normal file type.  */
3407   cur_file_ptr = save_file_ptr;
3408 }
3409 \f
3410 /* Add bytes to the symbolic information buffer.  */
3411
3412 static char *
3413 ecoff_add_bytes (buf, bufend, bufptr, need)
3414      char **buf;
3415      char **bufend;
3416      char *bufptr;
3417      unsigned long need;
3418 {
3419   unsigned long at;
3420   unsigned long want;
3421
3422   at = bufptr - *buf;
3423   need -= *bufend - bufptr;
3424   if (need < PAGE_SIZE)
3425     need = PAGE_SIZE;
3426   want = (*bufend - *buf) + need;
3427   *buf = xrealloc (*buf, want);
3428   *bufend = *buf + want;
3429   return *buf + at;
3430 }
3431
3432 /* Adjust the symbolic information buffer to the alignment required
3433    for the ECOFF target debugging information.  */
3434
3435 static unsigned long
3436 ecoff_padding_adjust (backend, buf, bufend, offset, bufptrptr)
3437      const struct ecoff_debug_swap *backend;
3438      char **buf;
3439      char **bufend;
3440      unsigned long offset;
3441      char **bufptrptr;
3442 {
3443   bfd_size_type align;
3444
3445   align = backend->debug_align;
3446   if ((offset & (align - 1)) != 0)
3447     {
3448       unsigned long add;
3449
3450       add = align - (offset & (align - 1));
3451       if (*bufend - (*buf + offset) < add)
3452         (void) ecoff_add_bytes (buf, bufend, *buf + offset, add);
3453       memset (*buf + offset, 0, add);
3454       offset += add;
3455       if (bufptrptr != (char **) NULL)
3456         *bufptrptr = *buf + offset;
3457     }
3458
3459   return offset;
3460 }
3461
3462 /* Build the line number information.  */
3463
3464 static unsigned long
3465 ecoff_build_lineno (backend, buf, bufend, offset, linecntptr)
3466      const struct ecoff_debug_swap *backend;
3467      char **buf;
3468      char **bufend;
3469      unsigned long offset;
3470      long *linecntptr;
3471 {
3472   char *bufptr;
3473   register lineno_list_t *l;
3474   lineno_list_t *last;
3475   efdr_t *file;
3476   proc_t *proc;
3477   unsigned long c;
3478   long iline;
3479   long totcount;
3480
3481   if (linecntptr != (long *) NULL)
3482     *linecntptr = 0;
3483
3484   bufptr = *buf + offset;
3485
3486   file = (efdr_t *) NULL;
3487   proc = (proc_t *) NULL;
3488   last = (lineno_list_t *) NULL;
3489   c = offset;
3490   iline = 0;
3491   totcount = 0;
3492   for (l = first_lineno; l != (lineno_list_t *) NULL; l = l->next)
3493     {
3494       long count;
3495       long delta;
3496
3497       /* Get the offset to the memory address of the next line number
3498          (in words).  Do this first, so that we can skip ahead to the
3499          next useful line number entry.  */
3500       if (l->next == (lineno_list_t *) NULL)
3501         count = 0;
3502       else
3503         {
3504           count = ((l->next->frag->fr_address + l->next->paddr
3505                     - (l->frag->fr_address + l->paddr))
3506                    >> 2);
3507           if (count <= 0)
3508             {
3509               /* Don't change last, so we still get the right delta.  */
3510               continue;
3511             }
3512         }
3513
3514       if (l->file != file || l->proc != proc)
3515         {
3516           if (l->proc != proc && proc != (proc_t *) NULL)
3517             proc->pdr.lnHigh = last->lineno;
3518           if (l->file != file && file != (efdr_t *) NULL)
3519             {
3520               file->fdr.cbLine = c - file->fdr.cbLineOffset;
3521               /* The cline field is ill-documented.  This is a guess
3522                  at the right value.  */
3523               file->fdr.cline = totcount + count;
3524               if (linecntptr != (long *) NULL)
3525                 *linecntptr += totcount + count;
3526               totcount = 0;
3527             }
3528
3529           if (l->file != file)
3530             {
3531               file = l->file;
3532               file->fdr.ilineBase = iline;
3533               file->fdr.cbLineOffset = c;
3534             }
3535           if (l->proc != proc)
3536             {
3537               proc = l->proc;
3538               if (proc != (proc_t *) NULL)
3539                 {
3540                   proc->pdr.lnLow = l->lineno;
3541                   proc->pdr.cbLineOffset = c - file->fdr.cbLineOffset;
3542                   /* The iline field is ill-documented.  This is a
3543                      guess at the right value.  */
3544                   proc->pdr.iline = totcount;
3545                 }
3546             }
3547
3548           last = (lineno_list_t *) NULL;
3549         }
3550
3551       totcount += count;
3552
3553       /* Get the offset to this line number.  */
3554       if (last == (lineno_list_t *) NULL)
3555         delta = 0;
3556       else
3557         delta = l->lineno - last->lineno;
3558
3559       /* Put in the offset to this line number.  */
3560       while (delta != 0)
3561         {
3562           int setcount;
3563
3564           /* 1 is added to each count read.  */
3565           --count;
3566           /* We can only adjust the word count by up to 15 words at a
3567              time.  */
3568           if (count <= 0x0f)
3569             {
3570               setcount = count;
3571               count = 0;
3572             }
3573           else
3574             {
3575               setcount = 0x0f;
3576               count -= 0x0f;
3577             }
3578           if (delta >= -7 && delta <= 7)
3579             {
3580               if (bufptr >= *bufend)
3581                 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1);
3582               *bufptr++ = setcount + (delta << 4);
3583               delta = 0;
3584               ++c;
3585             }
3586           else
3587             {
3588               int set;
3589
3590               if (*bufend - bufptr < 3)
3591                 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 3);
3592               *bufptr++ = setcount + (8 << 4);
3593               if (delta < -0x8000)
3594                 {
3595                   set = -0x8000;
3596                   delta += 0x8000;
3597                 }
3598               else if (delta > 0x7fff)
3599                 {
3600                   set = 0x7fff;
3601                   delta -= 0x7fff;
3602                 }
3603               else
3604                 {
3605                   set = delta;
3606                   delta = 0;
3607                 }
3608               *bufptr++ = set >> 8;
3609               *bufptr++ = set & 0xffff;
3610               c += 3;
3611             }
3612         }
3613
3614       /* Finish adjusting the count.  */
3615       while (count > 0)
3616         {
3617           if (bufptr >= *bufend)
3618             bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1);
3619           /* 1 is added to each count read.  */
3620           --count;
3621           if (count > 0x0f)
3622             {
3623               *bufptr++ = 0x0f;
3624               count -= 0x0f;
3625             }
3626           else
3627             {
3628               *bufptr++ = count;
3629               count = 0;
3630             }
3631           ++c;
3632         }
3633
3634       ++iline;
3635       last = l;
3636     }
3637
3638   if (proc != (proc_t *) NULL)
3639     proc->pdr.lnHigh = last->lineno;
3640   if (file != (efdr_t *) NULL)
3641     {
3642       file->fdr.cbLine = c - file->fdr.cbLineOffset;
3643       file->fdr.cline = totcount;
3644     }
3645
3646   if (linecntptr != (long *) NULL)
3647     *linecntptr += totcount;
3648
3649   c = ecoff_padding_adjust (backend, buf, bufend, c, &bufptr);
3650
3651   return c;
3652 }
3653
3654 /* Build and swap out the symbols.  */
3655
3656 static unsigned long
3657 ecoff_build_symbols (backend, buf, bufend, offset)
3658      const struct ecoff_debug_swap *backend;
3659      char **buf;
3660      char **bufend;
3661      unsigned long offset;
3662 {
3663   const bfd_size_type external_sym_size = backend->external_sym_size;
3664   void (* const swap_sym_out) PARAMS ((bfd *, const SYMR *, PTR))
3665     = backend->swap_sym_out;
3666   char *sym_out;
3667   long isym;
3668   vlinks_t *file_link;
3669
3670   sym_out = *buf + offset;
3671
3672   isym = 0;
3673
3674   /* The symbols are stored by file.  */
3675   for (file_link = file_desc.first;
3676        file_link != (vlinks_t *) NULL;
3677        file_link = file_link->next)
3678     {
3679       int ifilesym;
3680       int fil_cnt;
3681       efdr_t *fil_ptr;
3682       efdr_t *fil_end;
3683
3684       if (file_link->next == (vlinks_t *) NULL)
3685         fil_cnt = file_desc.objects_last_page;
3686       else
3687         fil_cnt = file_desc.objects_per_page;
3688       fil_ptr = file_link->datum->file;
3689       fil_end = fil_ptr + fil_cnt;
3690       for (; fil_ptr < fil_end; fil_ptr++)
3691         {
3692           vlinks_t *sym_link;
3693
3694           fil_ptr->fdr.isymBase = isym;
3695           ifilesym = isym;
3696           for (sym_link = fil_ptr->symbols.first;
3697                sym_link != (vlinks_t *) NULL;
3698                sym_link = sym_link->next)
3699             {
3700               int sym_cnt;
3701               localsym_t *sym_ptr;
3702               localsym_t *sym_end;
3703
3704               if (sym_link->next == (vlinks_t *) NULL)
3705                 sym_cnt = fil_ptr->symbols.objects_last_page;
3706               else
3707                 sym_cnt = fil_ptr->symbols.objects_per_page;
3708               sym_ptr = sym_link->datum->sym;
3709               sym_end = sym_ptr + sym_cnt;
3710               for (; sym_ptr < sym_end; sym_ptr++)
3711                 {
3712                   int local;
3713                   symbolS *as_sym;
3714                   forward_t *f;
3715
3716                   know (sym_ptr->file_ptr == fil_ptr);
3717
3718                   /* If there is no associated gas symbol, then this
3719                      is a pure debugging symbol.  We have already
3720                      added the name (if any) to fil_ptr->strings.
3721                      Otherwise we must decide whether this is an
3722                      external or a local symbol (actually, it may be
3723                      both if the local provides additional debugging
3724                      information for the external).  */
3725                   local = 1;
3726                   as_sym = sym_ptr->as_sym;
3727                   if (as_sym != (symbolS *) NULL)
3728                     {
3729                       symint_t indx;
3730
3731                       /* The value of a block start symbol is the
3732                          offset from the start of the procedure.  For
3733                          other symbols we just use the gas value (but
3734                          we must offset it by the vma of the section,
3735                          just as BFD does, because BFD will not see
3736                          this value).  */
3737                       if (sym_ptr->ecoff_sym.asym.st == (int) st_Block
3738                           && sym_ptr->ecoff_sym.asym.sc == (int) sc_Text)
3739                         {
3740                           symbolS *begin_sym;
3741
3742                           know (sym_ptr->proc_ptr != (proc_t *) NULL);
3743                           begin_sym = sym_ptr->proc_ptr->sym->as_sym;
3744                           if (S_GET_SEGMENT (as_sym)
3745                               != S_GET_SEGMENT (begin_sym))
3746                             as_warn (".begin/.bend in different segments");
3747                           sym_ptr->ecoff_sym.asym.value =
3748                             S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym);
3749                         }
3750                       else
3751                         sym_ptr->ecoff_sym.asym.value =
3752                           (S_GET_VALUE (as_sym)
3753                            + bfd_get_section_vma (stdoutput,
3754                                                   S_GET_SEGMENT (as_sym)));
3755
3756                       /* Set st_Proc to st_StaticProc for local
3757                          functions.  */
3758                       if (sym_ptr->ecoff_sym.asym.st == st_Proc
3759                           && S_IS_DEFINED (as_sym)
3760                           && ! S_IS_EXTERNAL (as_sym))
3761                         sym_ptr->ecoff_sym.asym.st = st_StaticProc;
3762
3763                       /* Get the type and storage class based on where
3764                          the symbol actually wound up.  Traditionally,
3765                          N_LBRAC and N_RBRAC are *not* relocated. */
3766                       indx = sym_ptr->ecoff_sym.asym.index;
3767                       if (sym_ptr->ecoff_sym.asym.st == st_Nil
3768                           && sym_ptr->ecoff_sym.asym.sc == sc_Nil
3769                           && (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym)
3770                               || ((ECOFF_UNMARK_STAB (indx) != N_LBRAC)
3771                                   && (ECOFF_UNMARK_STAB (indx) != N_RBRAC))))
3772                         {
3773                           segT seg;
3774                           const char *segname;
3775                           st_t st;
3776                           sc_t sc;
3777
3778                           seg = S_GET_SEGMENT (as_sym);
3779                           segname = segment_name (seg);
3780
3781                           if (S_IS_EXTERNAL (as_sym)
3782                               || ! S_IS_DEFINED (as_sym))
3783                             st = st_Global;
3784                           else if (seg == text_section)
3785                             st = st_Label;
3786                           else
3787                             st = st_Static;
3788
3789                           if (! S_IS_DEFINED (as_sym)
3790                               || as_sym->ecoff_undefined)
3791                             {
3792                               if (S_GET_VALUE (as_sym) > 0
3793                                   && (S_GET_VALUE (as_sym)
3794                                       <= bfd_get_gp_size (stdoutput)))
3795                                 sc = sc_SUndefined;
3796                               else
3797                                 sc = sc_Undefined;
3798                             }
3799                           else if (S_IS_COMMON (as_sym))
3800                             {
3801                               if (S_GET_VALUE (as_sym) > 0
3802                                   && (S_GET_VALUE (as_sym)
3803                                       <= bfd_get_gp_size (stdoutput)))
3804                                 sc = sc_SCommon;
3805                               else
3806                                 sc = sc_Common;
3807                             }
3808                           else if (seg == text_section)
3809                             sc = sc_Text;
3810                           else if (seg == data_section)
3811                             sc = sc_Data;
3812                           else if (strcmp (segname, ".rdata") == 0
3813                                    || strcmp (segname, ".rodata") == 0)
3814                             sc = sc_RData;
3815                           else if (strcmp (segname, ".sdata") == 0)
3816                             sc = sc_SData;
3817                           else if (seg == bss_section)
3818                             sc = sc_Bss;
3819                           else if (strcmp (segname, ".sbss") == 0)
3820                             sc = sc_SBss;
3821                           else if (seg == &bfd_abs_section)
3822                             sc = sc_Abs;
3823                           else
3824                             abort ();
3825
3826                           sym_ptr->ecoff_sym.asym.st = (int) st;
3827                           sym_ptr->ecoff_sym.asym.sc = (int) sc;
3828                         }
3829
3830                       /* This is just an external symbol if it is
3831                          outside a procedure and it has a type.
3832                          FIXME: g++ will generate symbols which have
3833                          different names in the debugging information
3834                          than the actual symbol.  Should we handle
3835                          them here?  */
3836                       if ((S_IS_EXTERNAL (as_sym)
3837                            || ! S_IS_DEFINED (as_sym))
3838                           && sym_ptr->proc_ptr == (proc_t *) NULL
3839                           && sym_ptr->ecoff_sym.asym.st != (int) st_Nil
3840                           && ! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym))
3841                         local = 0;
3842
3843                       /* If an st_end symbol has an associated gas
3844                          symbol, then it is a local label created for
3845                          a .bend or .end directive.  Stabs line
3846                          numbers will have \001 in the names.  */
3847                       if (local
3848                           && sym_ptr->ecoff_sym.asym.st != st_End
3849                           && strchr (sym_ptr->name, '\001') == 0)
3850                         sym_ptr->ecoff_sym.asym.iss =
3851                           add_string (&fil_ptr->strings,
3852                                       fil_ptr->str_hash,
3853                                       sym_ptr->name,
3854                                       (shash_t **) NULL);
3855                     }
3856
3857                   /* We now know the index of this symbol; fill in
3858                      locations that have been waiting for that
3859                      information.  */
3860                   if (sym_ptr->begin_ptr != (localsym_t *) NULL)
3861                     {
3862                       localsym_t *begin_ptr;
3863                       st_t begin_type;
3864
3865                       know (local);
3866                       begin_ptr = sym_ptr->begin_ptr;
3867                       know (begin_ptr->sym_index != -1);
3868                       sym_ptr->ecoff_sym.asym.index = begin_ptr->sym_index;
3869                       if (sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
3870                         sym_ptr->ecoff_sym.asym.iss =
3871                           begin_ptr->ecoff_sym.asym.iss;
3872
3873                       begin_type = begin_ptr->ecoff_sym.asym.st;
3874                       if (begin_type == st_File
3875                           || begin_type == st_Block)
3876                         {
3877                           begin_ptr->ecoff_sym.asym.index =
3878                             isym - ifilesym + 1;
3879                           (*swap_sym_out) (stdoutput,
3880                                            &begin_ptr->ecoff_sym.asym,
3881                                            (*buf
3882                                             + offset
3883                                             + (begin_ptr->sym_index
3884                                                * external_sym_size)));
3885                         }
3886                       else
3887                         {
3888                           know (begin_ptr->index_ptr != (aux_t *) NULL);
3889                           begin_ptr->index_ptr->data.isym =
3890                             isym - ifilesym + 1;
3891                         }
3892
3893                       /* The value of the symbol marking the end of a
3894                          procedure is the size of the procedure.  The
3895                          value of the symbol marking the end of a
3896                          block is the offset from the start of the
3897                          procedure to the block.  */
3898                       if (begin_type == st_Proc
3899                           || begin_type == st_StaticProc)
3900                         {
3901                           know (as_sym != (symbolS *) NULL);
3902                           know (begin_ptr->as_sym != (symbolS *) NULL);
3903                           if (S_GET_SEGMENT (as_sym)
3904                               != S_GET_SEGMENT (begin_ptr->as_sym))
3905                             as_warn (".begin/.bend in different segments");
3906                           sym_ptr->ecoff_sym.asym.value =
3907                             (S_GET_VALUE (as_sym)
3908                              - S_GET_VALUE (begin_ptr->as_sym));
3909                         }
3910                       else if (begin_type == st_Block
3911                                && sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
3912                         {
3913                           symbolS *begin_sym;
3914
3915                           know (as_sym != (symbolS *) NULL);
3916                           know (sym_ptr->proc_ptr != (proc_t *) NULL);
3917                           begin_sym = sym_ptr->proc_ptr->sym->as_sym;
3918                           if (S_GET_SEGMENT (as_sym)
3919                               != S_GET_SEGMENT (begin_sym))
3920                             as_warn (".begin/.bend in different segments");
3921                           sym_ptr->ecoff_sym.asym.value =
3922                             S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym);
3923                         }
3924                     }
3925
3926                   for (f = sym_ptr->forward_ref;
3927                        f != (forward_t *) NULL;
3928                        f = f->next)
3929                     {
3930                       know (local);
3931                       f->ifd_ptr->data.isym = fil_ptr->file_index;
3932                       f->index_ptr->data.rndx.index = isym - ifilesym;
3933                     }
3934
3935                   if (local)
3936                     {
3937                       if (*bufend - sym_out < external_sym_size)
3938                         sym_out = ecoff_add_bytes (buf, bufend,
3939                                                    sym_out,
3940                                                    external_sym_size);
3941                       (*swap_sym_out) (stdoutput, &sym_ptr->ecoff_sym.asym,
3942                                        sym_out);
3943                       sym_out += external_sym_size;
3944
3945                       sym_ptr->sym_index = isym;
3946
3947                       if (sym_ptr->proc_ptr != (proc_t *) NULL
3948                           && sym_ptr->proc_ptr->sym == sym_ptr)
3949                         sym_ptr->proc_ptr->pdr.isym = isym - ifilesym;
3950
3951                       ++isym;
3952                     }
3953
3954                   /* Record the local symbol index and file number in
3955                      case this is an external symbol.  Note that this
3956                      destroys the asym.index field.  */
3957                   if (as_sym != (symbolS *) NULL)
3958                     {
3959                       if (sym_ptr->ecoff_sym.asym.st == st_Proc
3960                           || sym_ptr->ecoff_sym.asym.st == st_StaticProc)
3961                         {
3962                           know (local);
3963                           sym_ptr->ecoff_sym.asym.index = isym - ifilesym - 1;
3964                         }
3965                       sym_ptr->ecoff_sym.ifd = fil_ptr->file_index;
3966                     }
3967                 }
3968             }
3969           fil_ptr->fdr.csym = isym - fil_ptr->fdr.isymBase;
3970         }
3971     }
3972
3973   return offset + isym * external_sym_size;
3974 }
3975
3976 /* Swap out the procedure information.  */
3977
3978 static unsigned long
3979 ecoff_build_procs (backend, buf, bufend, offset)
3980      const struct ecoff_debug_swap *backend;
3981      char **buf;
3982      char **bufend;
3983      unsigned long offset;
3984 {
3985   const bfd_size_type external_pdr_size = backend->external_pdr_size;
3986   void (* const swap_pdr_out) PARAMS ((bfd *, const PDR *, PTR))
3987     = backend->swap_pdr_out;
3988   char *pdr_out;
3989   int first_fil;
3990   long iproc;
3991   vlinks_t *file_link;
3992
3993   pdr_out = *buf + offset;
3994
3995   first_fil = 1;
3996   iproc = 0;
3997
3998   /* The procedures are stored by file.  */
3999   for (file_link = file_desc.first;
4000        file_link != (vlinks_t *) NULL;
4001        file_link = file_link->next)
4002     {
4003       int fil_cnt;
4004       efdr_t *fil_ptr;
4005       efdr_t *fil_end;
4006
4007       if (file_link->next == (vlinks_t *) NULL)
4008         fil_cnt = file_desc.objects_last_page;
4009       else
4010         fil_cnt = file_desc.objects_per_page;
4011       fil_ptr = file_link->datum->file;
4012       fil_end = fil_ptr + fil_cnt;
4013       for (; fil_ptr < fil_end; fil_ptr++)
4014         {
4015           vlinks_t *proc_link;
4016           int first;
4017
4018           fil_ptr->fdr.ipdFirst = iproc;
4019           first = 1;
4020           for (proc_link = fil_ptr->procs.first;
4021                proc_link != (vlinks_t *) NULL;
4022                proc_link = proc_link->next)
4023             {
4024               int prc_cnt;
4025               proc_t *proc_ptr;
4026               proc_t *proc_end;
4027
4028               if (proc_link->next == (vlinks_t *) NULL)
4029                 prc_cnt = fil_ptr->procs.objects_last_page;
4030               else
4031                 prc_cnt = fil_ptr->procs.objects_per_page;
4032               proc_ptr = proc_link->datum->proc;
4033               proc_end = proc_ptr + prc_cnt;
4034               for (; proc_ptr < proc_end; proc_ptr++)
4035                 {
4036                   symbolS *adr_sym;
4037                   unsigned long adr;
4038
4039                   adr_sym = proc_ptr->sym->as_sym;
4040                   adr = (S_GET_VALUE (adr_sym)
4041                          + bfd_get_section_vma (stdoutput,
4042                                                 S_GET_SEGMENT (adr_sym)));
4043                   if (first)
4044                     {
4045                       if (first_fil)
4046                         first_fil = 0;
4047                       else
4048                         fil_ptr->fdr.adr = adr;
4049                       first = 0;
4050                     }
4051                   proc_ptr->pdr.adr = adr - fil_ptr->fdr.adr;
4052                   if (*bufend - pdr_out < external_pdr_size)
4053                     pdr_out = ecoff_add_bytes (buf, bufend,
4054                                                pdr_out,
4055                                                external_pdr_size);
4056                   (*swap_pdr_out) (stdoutput, &proc_ptr->pdr, pdr_out);
4057                   pdr_out += external_pdr_size;
4058                   ++iproc;
4059                 }
4060             }
4061           fil_ptr->fdr.cpd = iproc - fil_ptr->fdr.ipdFirst;
4062         }
4063     }
4064
4065   return offset + iproc * external_pdr_size;
4066 }
4067
4068 /* Swap out the aux information.  */
4069
4070 static unsigned long
4071 ecoff_build_aux (backend, buf, bufend, offset)
4072      const struct ecoff_debug_swap *backend;
4073      char **buf;
4074      char **bufend;
4075      unsigned long offset;
4076 {
4077   int bigendian;
4078   union aux_ext *aux_out;
4079   long iaux;
4080   vlinks_t *file_link;
4081
4082   bigendian = stdoutput->xvec->header_byteorder_big_p;
4083
4084   aux_out = (union aux_ext *) (*buf + offset);
4085
4086   iaux = 0;
4087
4088   /* The aux entries are stored by file.  */
4089   for (file_link = file_desc.first;
4090        file_link != (vlinks_t *) NULL;
4091        file_link = file_link->next)
4092     {
4093       int fil_cnt;
4094       efdr_t *fil_ptr;
4095       efdr_t *fil_end;
4096
4097       if (file_link->next == (vlinks_t *) NULL)
4098         fil_cnt = file_desc.objects_last_page;
4099       else
4100         fil_cnt = file_desc.objects_per_page;
4101       fil_ptr = file_link->datum->file;
4102       fil_end = fil_ptr + fil_cnt;
4103       for (; fil_ptr < fil_end; fil_ptr++)
4104         {
4105           vlinks_t *aux_link;
4106
4107           fil_ptr->fdr.fBigendian = bigendian;
4108           fil_ptr->fdr.iauxBase = iaux;
4109           for (aux_link = fil_ptr->aux_syms.first;
4110                aux_link != (vlinks_t *) NULL;
4111                aux_link = aux_link->next)
4112             {
4113               int aux_cnt;
4114               aux_t *aux_ptr;
4115               aux_t *aux_end;
4116
4117               if (aux_link->next == (vlinks_t *) NULL)
4118                 aux_cnt = fil_ptr->aux_syms.objects_last_page;
4119               else
4120                 aux_cnt = fil_ptr->aux_syms.objects_per_page;
4121               aux_ptr = aux_link->datum->aux;
4122               aux_end = aux_ptr + aux_cnt;
4123               for (; aux_ptr < aux_end; aux_ptr++)
4124                 {
4125                   if (*bufend - (char *) aux_out < sizeof (union aux_ext))
4126                     aux_out = ((union aux_ext *)
4127                                ecoff_add_bytes (buf, bufend,
4128                                                 (char *) aux_out,
4129                                                 sizeof (union aux_ext)));
4130                   switch (aux_ptr->type)
4131                     {
4132                     case aux_tir:
4133                       ecoff_swap_tir_out (bigendian, &aux_ptr->data.ti,
4134                                           &aux_out->a_ti);
4135                       break;
4136                     case aux_rndx:
4137                       ecoff_swap_rndx_out (bigendian, &aux_ptr->data.rndx,
4138                                            &aux_out->a_rndx);
4139                       break;
4140                     case aux_dnLow:
4141                       AUX_PUT_DNLOW (bigendian, aux_ptr->data.dnLow,
4142                                      aux_out);
4143                       break;
4144                     case aux_dnHigh:
4145                       AUX_PUT_DNHIGH (bigendian, aux_ptr->data.dnHigh,
4146                                       aux_out);
4147                       break;
4148                     case aux_isym:
4149                       AUX_PUT_ISYM (bigendian, aux_ptr->data.isym,
4150                                     aux_out);
4151                       break;
4152                     case aux_iss:
4153                       AUX_PUT_ISS (bigendian, aux_ptr->data.iss,
4154                                    aux_out);
4155                       break;
4156                     case aux_width:
4157                       AUX_PUT_WIDTH (bigendian, aux_ptr->data.width,
4158                                      aux_out);
4159                       break;
4160                     case aux_count:
4161                       AUX_PUT_COUNT (bigendian, aux_ptr->data.count,
4162                                      aux_out);
4163                       break;
4164                     }
4165
4166                   ++aux_out;
4167                   ++iaux;
4168                 }
4169             }
4170           fil_ptr->fdr.caux = iaux - fil_ptr->fdr.iauxBase;
4171         }
4172     }
4173
4174   return ecoff_padding_adjust (backend, buf, bufend,
4175                                offset + iaux * sizeof (union aux_ext),
4176                                (char **) NULL);
4177 }
4178
4179 /* Copy out the strings from a varray_t.  This returns the number of
4180    bytes copied, rather than the new offset.  */
4181
4182 static unsigned long
4183 ecoff_build_strings (buf, bufend, offset, vp)
4184      char **buf;
4185      char **bufend;
4186      unsigned long offset;
4187      varray_t *vp;
4188 {
4189   unsigned long istr;
4190   char *str_out;
4191   vlinks_t *str_link;
4192
4193   str_out = *buf + offset;
4194
4195   istr = 0;
4196
4197   for (str_link = vp->first;
4198        str_link != (vlinks_t *) NULL;
4199        str_link = str_link->next)
4200     {
4201       unsigned long str_cnt;
4202
4203       if (str_link->next == (vlinks_t *) NULL)
4204         str_cnt = vp->objects_last_page;
4205       else
4206         str_cnt = vp->objects_per_page;
4207
4208       if (*bufend - str_out < str_cnt)
4209         str_out = ecoff_add_bytes (buf, bufend, str_out, str_cnt);
4210
4211       memcpy (str_out, str_link->datum->byte, str_cnt);
4212       str_out += str_cnt;
4213       istr += str_cnt;
4214     }
4215
4216   return istr;
4217 }
4218
4219 /* Dump out the local strings.  */
4220
4221 static unsigned long
4222 ecoff_build_ss (backend, buf, bufend, offset)
4223      const struct ecoff_debug_swap *backend;
4224      char **buf;
4225      char **bufend;
4226      unsigned long offset;
4227 {
4228   long iss;
4229   vlinks_t *file_link;
4230
4231   iss = 0;
4232
4233   for (file_link = file_desc.first;
4234        file_link != (vlinks_t *) NULL;
4235        file_link = file_link->next)
4236     {
4237       int fil_cnt;
4238       efdr_t *fil_ptr;
4239       efdr_t *fil_end;
4240
4241       if (file_link->next == (vlinks_t *) NULL)
4242         fil_cnt = file_desc.objects_last_page;
4243       else
4244         fil_cnt = file_desc.objects_per_page;
4245       fil_ptr = file_link->datum->file;
4246       fil_end = fil_ptr + fil_cnt;
4247       for (; fil_ptr < fil_end; fil_ptr++)
4248         {
4249           long ss_cnt;
4250
4251           fil_ptr->fdr.issBase = iss;
4252           ss_cnt = ecoff_build_strings (buf, bufend, offset + iss,
4253                                         &fil_ptr->strings);
4254           fil_ptr->fdr.cbSs = ss_cnt;
4255           iss += ss_cnt;
4256         }
4257     }
4258
4259   return ecoff_padding_adjust (backend, buf, bufend, offset + iss,
4260                                (char **) NULL);
4261 }
4262
4263 /* Swap out the file descriptors.  */
4264
4265 static unsigned long
4266 ecoff_build_fdr (backend, buf, bufend, offset)
4267      const struct ecoff_debug_swap *backend;
4268      char **buf;
4269      char **bufend;
4270      unsigned long offset;
4271 {
4272   const bfd_size_type external_fdr_size = backend->external_fdr_size;
4273   void (* const swap_fdr_out) PARAMS ((bfd *, const FDR *, PTR))
4274     = backend->swap_fdr_out;
4275   long ifile;
4276   char *fdr_out;
4277   vlinks_t *file_link;
4278
4279   ifile = 0;
4280
4281   fdr_out = *buf + offset;
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           if (*bufend - fdr_out < external_fdr_size)
4300             fdr_out = ecoff_add_bytes (buf, bufend, fdr_out,
4301                                        external_fdr_size);
4302           (*swap_fdr_out) (stdoutput, &fil_ptr->fdr, fdr_out);
4303           fdr_out += external_fdr_size;
4304           ++ifile;
4305         }
4306     }
4307
4308   return offset + ifile * external_fdr_size;
4309 }
4310
4311 /* Swap out the external symbols.  These are the symbols that the
4312    machine independent code has put in the symtab for the BFD.  */
4313
4314 static unsigned long
4315 ecoff_build_ext (backend, buf, bufend, offset, ext_strings, ext_str_hash)
4316      const struct ecoff_debug_swap *backend;
4317      char **buf;
4318      char **bufend;
4319      unsigned long offset;
4320      varray_t *ext_strings;
4321      struct hash_control *ext_str_hash;
4322 {
4323   const bfd_size_type external_ext_size = backend->external_ext_size;
4324   void (* const swap_ext_out) PARAMS ((bfd *, const EXTR *, PTR))
4325     = backend->swap_ext_out;
4326   register symbolS *sym;
4327   char *ext_out;
4328   long iext;
4329
4330   ext_out = *buf + offset;
4331   iext = 0;
4332   for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
4333     {
4334       if (sym->ecoff_symbol == NULL)
4335         continue;
4336
4337       /* If this is a local symbol, then force the fields to zero.  */
4338       if (! S_IS_EXTERNAL (sym)
4339           && S_IS_DEFINED (sym))
4340         {
4341           sym->ecoff_symbol->ecoff_sym.asym.value = 0;
4342           sym->ecoff_symbol->ecoff_sym.asym.st = (int) st_Nil;
4343           sym->ecoff_symbol->ecoff_sym.asym.sc = (int) sc_Nil;
4344           sym->ecoff_symbol->ecoff_sym.asym.index = indexNil;
4345         }
4346
4347       sym->ecoff_symbol->ecoff_sym.asym.iss =
4348         add_string (ext_strings, ext_str_hash, S_GET_NAME (sym),
4349                     (shash_t **) NULL);
4350       if (*bufend - ext_out < external_ext_size)
4351         ext_out = ecoff_add_bytes (buf, bufend, ext_out, external_ext_size);
4352       (*swap_ext_out) (stdoutput, &sym->ecoff_symbol->ecoff_sym, ext_out);
4353 #ifdef obj_set_sym_index
4354       obj_set_sym_index (as_sym->bsym, iext);
4355 #endif
4356       ext_out += external_ext_size;
4357       ++iext;
4358     }
4359
4360   return offset + iext * external_ext_size;
4361 }
4362
4363 /* Build the ECOFF dbeugging information.  */
4364
4365 unsigned long
4366 ecoff_build_debug (hdr, bufp, backend)
4367      HDRR *hdr;
4368      char **bufp;
4369      const struct ecoff_debug_swap *backend;
4370 {
4371   const bfd_size_type external_pdr_size = backend->external_pdr_size;
4372   tag_t *ptag;
4373   tag_t *ptag_next;
4374   efdr_t *fil_ptr;
4375   int end_warning;
4376   efdr_t *hold_file_ptr;
4377   proc_t * hold_proc_ptr;
4378   symbolS *sym;
4379   char *buf;
4380   char *bufend;
4381   unsigned long offset;
4382   char *extbuf;
4383   char *extbufend;
4384   unsigned long extoffset;
4385   varray_t ext_strings;
4386   static varray_t init_ext_strings = INIT_VARRAY (char);
4387   struct hash_control *ext_str_hash;
4388
4389   /* Make sure we have a file.  */
4390   if (first_file == (efdr_t *) NULL)
4391     add_file ((const char *) NULL, 0);
4392
4393   /* Handle any top level tags.  */
4394   for (ptag = top_tag_head->first_tag;
4395        ptag != (tag_t *) NULL;
4396        ptag = ptag_next)
4397     {
4398       if (ptag->forward_ref != (forward_t *) NULL)
4399         add_unknown_tag (ptag);
4400
4401       ptag_next = ptag->same_block;
4402       ptag->hash_ptr->tag_ptr = ptag->same_name;
4403       free_tag (ptag);
4404     }
4405
4406   free_thead (top_tag_head);
4407
4408   /* Look through the symbols.  Add debugging information for each
4409      symbol that has not already received it.  */
4410   hold_file_ptr = cur_file_ptr;
4411   hold_proc_ptr = cur_proc_ptr;
4412   cur_proc_ptr = (proc_t *) NULL;
4413   for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
4414     {
4415       if (sym->ecoff_symbol != NULL
4416           || sym->ecoff_file == (efdr_t *) NULL
4417           || (sym->bsym->flags & BSF_SECTION_SYM) != 0)
4418         continue;
4419
4420       cur_file_ptr = sym->ecoff_file;
4421       add_ecoff_symbol ((const char *) NULL, st_Nil, sc_Nil, sym,
4422                         S_GET_VALUE (sym), indexNil);
4423     }
4424   cur_proc_ptr = hold_proc_ptr;
4425   cur_file_ptr = hold_file_ptr;
4426
4427   /* Output an ending symbol for all the files.  We have to do this
4428      here for the last file, so we may as well do it for all of the
4429      files.  */
4430   end_warning = 0;
4431   for (fil_ptr = first_file;
4432        fil_ptr != (efdr_t *) NULL;
4433        fil_ptr = fil_ptr->next_file)
4434     {
4435       cur_file_ptr = fil_ptr;
4436       while (cur_file_ptr->cur_scope->prev != (scope_t *) NULL)
4437         {
4438           cur_file_ptr->cur_scope = cur_file_ptr->cur_scope->prev;
4439           if (! end_warning)
4440             {
4441               as_warn ("Missing .end or .bend at end of file");
4442               end_warning = 1;
4443             }
4444         }
4445       (void) add_ecoff_symbol ((const char *) NULL,
4446                                st_End, sc_Text,
4447                                (symbolS *) NULL,
4448                                (symint_t) 0,
4449                                (symint_t) 0);
4450     }
4451
4452   /* Build the symbolic information.  */
4453   offset = 0;
4454   buf = xmalloc (PAGE_SIZE);
4455   bufend = buf + PAGE_SIZE;
4456
4457   /* Build the line number information.  */
4458   hdr->cbLineOffset = offset;
4459   offset = ecoff_build_lineno (backend, &buf, &bufend, offset,
4460                                &hdr->ilineMax);
4461   hdr->cbLine = offset - hdr->cbLineOffset;
4462
4463   /* We don't use dense numbers at all.  */
4464   hdr->idnMax = 0;
4465   hdr->cbDnOffset = 0;
4466
4467   /* We can't build the PDR table until we have built the symbols,
4468      because a PDR contains a symbol index.  However, we set aside
4469      space at this point.  */
4470   hdr->ipdMax = proc_cnt;
4471   hdr->cbPdOffset = offset;
4472   if (bufend - (buf + offset) < proc_cnt * external_pdr_size)
4473     (void) ecoff_add_bytes (&buf, &bufend, buf + offset,
4474                             proc_cnt * external_pdr_size);
4475   offset += proc_cnt * external_pdr_size;
4476
4477   /* Build the local symbols.  */
4478   hdr->cbSymOffset = offset;
4479   offset = ecoff_build_symbols (backend, &buf, &bufend, offset);
4480   hdr->isymMax = (offset - hdr->cbSymOffset) / backend->external_sym_size;
4481
4482   /* Building the symbols initializes the symbol index in the PDR's.
4483      Now we can swap out the PDR's.  */
4484   (void) ecoff_build_procs (backend, &buf, &bufend, hdr->cbPdOffset);
4485
4486   /* We don't use optimization symbols.  */
4487   hdr->ioptMax = 0;
4488   hdr->cbOptOffset = 0;
4489
4490   /* Swap out the auxiliary type information.  */
4491   hdr->cbAuxOffset = offset;
4492   offset = ecoff_build_aux (backend, &buf, &bufend, offset);
4493   hdr->iauxMax = (offset - hdr->cbAuxOffset) / sizeof (union aux_ext);
4494
4495   /* Copy out the local strings.  */
4496   hdr->cbSsOffset = offset;
4497   offset = ecoff_build_ss (backend, &buf, &bufend, offset);
4498   hdr->issMax = offset - hdr->cbSsOffset;
4499
4500   /* Build the external symbols and external strings.  We build these
4501      now because we want to copy out the external strings now.  We
4502      copy out the external symbol information down below.  */
4503   extbuf = xmalloc (PAGE_SIZE);
4504   extbufend = extbuf + PAGE_SIZE;
4505   ext_strings = init_ext_strings;
4506   ext_str_hash = hash_new ();
4507   extoffset = ecoff_build_ext (backend, &extbuf, &extbufend,
4508                                (unsigned long) 0, &ext_strings,
4509                                ext_str_hash);
4510
4511   /* Copy out the external strings.  */
4512   hdr->cbSsExtOffset = offset;
4513   offset += ecoff_build_strings (&buf, &bufend, offset, &ext_strings);
4514   offset = ecoff_padding_adjust (backend, &buf, &bufend, offset,
4515                                  (char **) NULL);
4516   hdr->issExtMax = offset - hdr->cbSsExtOffset;
4517
4518   /* We don't use relative file descriptors.  */
4519   hdr->crfd = 0;
4520   hdr->cbRfdOffset = 0;
4521
4522   /* Swap out the file descriptors.  */
4523   hdr->cbFdOffset = offset;
4524   offset = ecoff_build_fdr (backend, &buf, &bufend, offset);
4525   hdr->ifdMax = (offset - hdr->cbFdOffset) / backend->external_fdr_size;
4526
4527   /* Copy out the external symbols.  */
4528   hdr->cbExtOffset = offset;
4529   if (bufend - (buf + offset) < extoffset)
4530     (void) ecoff_add_bytes (&buf, &bufend, buf + offset, extoffset);
4531   memcpy (buf + offset, extbuf, extoffset);
4532   offset += extoffset;
4533   hdr->iextMax = (offset - hdr->cbExtOffset) / backend->external_ext_size;
4534
4535   know ((offset & (backend->debug_align - 1)) == 0);
4536
4537   hdr->magic = backend->sym_magic;
4538   /* FIXME: what should hdr->vstamp be?  */
4539   hdr->vstamp = 0x020b;
4540
4541   *bufp = buf;
4542   return offset;
4543 }
4544 \f
4545 /* Allocate a cluster of pages.  */
4546
4547 #ifndef MALLOC_CHECK
4548
4549 static page_t *
4550 allocate_cluster (npages)
4551      unsigned long npages;
4552 {
4553   register page_t *value = (page_t *) xmalloc (npages * PAGE_USIZE);
4554
4555 #ifdef ECOFF_DEBUG
4556   if (debug > 3)
4557     fprintf (stderr, "\talloc\tnpages = %d, value = 0x%.8x\n", npages, value);
4558 #endif
4559
4560   memset (value, 0, npages * PAGE_USIZE);
4561
4562   return value;
4563 }
4564
4565
4566 static page_t *cluster_ptr = NULL;
4567 static unsigned long pages_left = 0;
4568
4569 #endif /* MALLOC_CHECK */
4570
4571 /* Allocate one page (which is initialized to 0).  */
4572
4573 static page_t *
4574 allocate_page ()
4575 {
4576 #ifndef MALLOC_CHECK
4577
4578   if (pages_left == 0)
4579     {
4580       pages_left = MAX_CLUSTER_PAGES;
4581       cluster_ptr = allocate_cluster (pages_left);
4582     }
4583
4584   pages_left--;
4585   return cluster_ptr++;
4586
4587 #else   /* MALLOC_CHECK */
4588
4589   page_t *ptr;
4590
4591   ptr = xmalloc (PAGE_USIZE);
4592   memset (ptr, 0, PAGE_USIZE);
4593   return ptr;
4594
4595 #endif  /* MALLOC_CHECK */
4596 }
4597 \f
4598 /* Allocate scoping information.  */
4599
4600 static scope_t *
4601 allocate_scope ()
4602 {
4603   register scope_t *ptr;
4604   static scope_t initial_scope;
4605
4606 #ifndef MALLOC_CHECK
4607
4608   ptr = alloc_counts[(int)alloc_type_scope].free_list.f_scope;
4609   if (ptr != (scope_t *) NULL)
4610     alloc_counts[ (int)alloc_type_scope ].free_list.f_scope = ptr->free;
4611   else
4612     {
4613       register int unallocated  = alloc_counts[(int)alloc_type_scope].unallocated;
4614       register page_t *cur_page = alloc_counts[(int)alloc_type_scope].cur_page;
4615
4616       if (unallocated == 0)
4617         {
4618           unallocated = PAGE_SIZE / sizeof (scope_t);
4619           alloc_counts[(int)alloc_type_scope].cur_page = cur_page = allocate_page ();
4620           alloc_counts[(int)alloc_type_scope].total_pages++;
4621         }
4622
4623       ptr = &cur_page->scope[--unallocated];
4624       alloc_counts[(int)alloc_type_scope].unallocated = unallocated;
4625     }
4626
4627 #else
4628
4629   ptr = (scope_t *) xmalloc (sizeof (scope_t));
4630
4631 #endif
4632
4633   alloc_counts[(int)alloc_type_scope].total_alloc++;
4634   *ptr = initial_scope;
4635   return ptr;
4636 }
4637
4638 /* Free scoping information.  */
4639
4640 static void
4641 free_scope (ptr)
4642      scope_t *ptr;
4643 {
4644   alloc_counts[(int)alloc_type_scope].total_free++;
4645
4646 #ifndef MALLOC_CHECK
4647   ptr->free = alloc_counts[(int)alloc_type_scope].free_list.f_scope;
4648   alloc_counts[(int)alloc_type_scope].free_list.f_scope = ptr;
4649 #else
4650   free ((PTR) ptr);
4651 #endif
4652 }
4653 \f
4654 /* Allocate links for pages in a virtual array.  */
4655
4656 static vlinks_t *
4657 allocate_vlinks ()
4658 {
4659   register vlinks_t *ptr;
4660   static vlinks_t initial_vlinks;
4661
4662 #ifndef MALLOC_CHECK
4663
4664   register int unallocated = alloc_counts[(int)alloc_type_vlinks].unallocated;
4665   register page_t *cur_page = alloc_counts[(int)alloc_type_vlinks].cur_page;
4666
4667   if (unallocated == 0)
4668     {
4669       unallocated = PAGE_SIZE / sizeof (vlinks_t);
4670       alloc_counts[(int)alloc_type_vlinks].cur_page = cur_page = allocate_page ();
4671       alloc_counts[(int)alloc_type_vlinks].total_pages++;
4672     }
4673
4674   ptr = &cur_page->vlinks[--unallocated];
4675   alloc_counts[(int)alloc_type_vlinks].unallocated = unallocated;
4676
4677 #else
4678
4679   ptr = (vlinks_t *) xmalloc (sizeof (vlinks_t));
4680
4681 #endif
4682
4683   alloc_counts[(int)alloc_type_vlinks].total_alloc++;
4684   *ptr = initial_vlinks;
4685   return ptr;
4686 }
4687 \f
4688 /* Allocate string hash buckets.  */
4689
4690 static shash_t *
4691 allocate_shash ()
4692 {
4693   register shash_t *ptr;
4694   static shash_t initial_shash;
4695
4696 #ifndef MALLOC_CHECK
4697
4698   register int unallocated = alloc_counts[(int)alloc_type_shash].unallocated;
4699   register page_t *cur_page = alloc_counts[(int)alloc_type_shash].cur_page;
4700
4701   if (unallocated == 0)
4702     {
4703       unallocated = PAGE_SIZE / sizeof (shash_t);
4704       alloc_counts[(int)alloc_type_shash].cur_page = cur_page = allocate_page ();
4705       alloc_counts[(int)alloc_type_shash].total_pages++;
4706     }
4707
4708   ptr = &cur_page->shash[--unallocated];
4709   alloc_counts[(int)alloc_type_shash].unallocated = unallocated;
4710
4711 #else
4712
4713   ptr = (shash_t *) xmalloc (sizeof (shash_t));
4714
4715 #endif
4716
4717   alloc_counts[(int)alloc_type_shash].total_alloc++;
4718   *ptr = initial_shash;
4719   return ptr;
4720 }
4721 \f
4722 /* Allocate type hash buckets.  */
4723
4724 static thash_t *
4725 allocate_thash ()
4726 {
4727   register thash_t *ptr;
4728   static thash_t initial_thash;
4729
4730 #ifndef MALLOC_CHECK
4731
4732   register int unallocated = alloc_counts[(int)alloc_type_thash].unallocated;
4733   register page_t *cur_page = alloc_counts[(int)alloc_type_thash].cur_page;
4734
4735   if (unallocated == 0)
4736     {
4737       unallocated = PAGE_SIZE / sizeof (thash_t);
4738       alloc_counts[(int)alloc_type_thash].cur_page = cur_page = allocate_page ();
4739       alloc_counts[(int)alloc_type_thash].total_pages++;
4740     }
4741
4742   ptr = &cur_page->thash[--unallocated];
4743   alloc_counts[(int)alloc_type_thash].unallocated = unallocated;
4744
4745 #else
4746
4747   ptr = (thash_t *) xmalloc (sizeof (thash_t));
4748
4749 #endif
4750
4751   alloc_counts[(int)alloc_type_thash].total_alloc++;
4752   *ptr = initial_thash;
4753   return ptr;
4754 }
4755 \f
4756 /* Allocate structure, union, or enum tag information.  */
4757
4758 static tag_t *
4759 allocate_tag ()
4760 {
4761   register tag_t *ptr;
4762   static tag_t initial_tag;
4763
4764 #ifndef MALLOC_CHECK
4765
4766   ptr = alloc_counts[(int)alloc_type_tag].free_list.f_tag;
4767   if (ptr != (tag_t *) NULL)
4768     alloc_counts[(int)alloc_type_tag].free_list.f_tag = ptr->free;
4769   else
4770     {
4771       register int unallocated = alloc_counts[(int)alloc_type_tag].unallocated;
4772       register page_t *cur_page = alloc_counts[(int)alloc_type_tag].cur_page;
4773
4774       if (unallocated == 0)
4775         {
4776           unallocated = PAGE_SIZE / sizeof (tag_t);
4777           alloc_counts[(int)alloc_type_tag].cur_page = cur_page = allocate_page ();
4778           alloc_counts[(int)alloc_type_tag].total_pages++;
4779         }
4780
4781       ptr = &cur_page->tag[--unallocated];
4782       alloc_counts[(int)alloc_type_tag].unallocated = unallocated;
4783     }
4784
4785 #else
4786
4787   ptr = (tag_t *) xmalloc (sizeof (tag_t));
4788
4789 #endif
4790
4791   alloc_counts[(int)alloc_type_tag].total_alloc++;
4792   *ptr = initial_tag;
4793   return ptr;
4794 }
4795
4796 /* Free scoping information.  */
4797
4798 static void
4799 free_tag (ptr)
4800      tag_t *ptr;
4801 {
4802   alloc_counts[(int)alloc_type_tag].total_free++;
4803
4804 #ifndef MALLOC_CHECK
4805   ptr->free = alloc_counts[(int)alloc_type_tag].free_list.f_tag;
4806   alloc_counts[(int)alloc_type_tag].free_list.f_tag = ptr;
4807 #else
4808   free ((PTR_T) ptr);
4809 #endif
4810 }
4811 \f
4812 /* Allocate forward reference to a yet unknown tag.  */
4813
4814 static forward_t *
4815 allocate_forward ()
4816 {
4817   register forward_t *ptr;
4818   static forward_t initial_forward;
4819
4820 #ifndef MALLOC_CHECK
4821
4822   register int unallocated = alloc_counts[(int)alloc_type_forward].unallocated;
4823   register page_t *cur_page = alloc_counts[(int)alloc_type_forward].cur_page;
4824
4825   if (unallocated == 0)
4826     {
4827       unallocated = PAGE_SIZE / sizeof (forward_t);
4828       alloc_counts[(int)alloc_type_forward].cur_page = cur_page = allocate_page ();
4829       alloc_counts[(int)alloc_type_forward].total_pages++;
4830     }
4831
4832   ptr = &cur_page->forward[--unallocated];
4833   alloc_counts[(int)alloc_type_forward].unallocated = unallocated;
4834
4835 #else
4836
4837   ptr = (forward_t *) xmalloc (sizeof (forward_t));
4838
4839 #endif
4840
4841   alloc_counts[(int)alloc_type_forward].total_alloc++;
4842   *ptr = initial_forward;
4843   return ptr;
4844 }
4845 \f
4846 /* Allocate head of type hash list.  */
4847
4848 static thead_t *
4849 allocate_thead ()
4850 {
4851   register thead_t *ptr;
4852   static thead_t initial_thead;
4853
4854 #ifndef MALLOC_CHECK
4855
4856   ptr = alloc_counts[(int)alloc_type_thead].free_list.f_thead;
4857   if (ptr != (thead_t *) NULL)
4858     alloc_counts[ (int)alloc_type_thead ].free_list.f_thead = ptr->free;
4859   else
4860     {
4861       register int unallocated = alloc_counts[(int)alloc_type_thead].unallocated;
4862       register page_t *cur_page = alloc_counts[(int)alloc_type_thead].cur_page;
4863
4864       if (unallocated == 0)
4865         {
4866           unallocated = PAGE_SIZE / sizeof (thead_t);
4867           alloc_counts[(int)alloc_type_thead].cur_page = cur_page = allocate_page ();
4868           alloc_counts[(int)alloc_type_thead].total_pages++;
4869         }
4870
4871       ptr = &cur_page->thead[--unallocated];
4872       alloc_counts[(int)alloc_type_thead].unallocated = unallocated;
4873     }
4874
4875 #else
4876
4877   ptr = (thead_t *) xmalloc (sizeof (thead_t));
4878
4879 #endif
4880
4881   alloc_counts[(int)alloc_type_thead].total_alloc++;
4882   *ptr = initial_thead;
4883   return ptr;
4884 }
4885
4886 /* Free scoping information.  */
4887
4888 static void
4889 free_thead (ptr)
4890      thead_t *ptr;
4891 {
4892   alloc_counts[(int)alloc_type_thead].total_free++;
4893
4894 #ifndef MALLOC_CHECK
4895   ptr->free = (thead_t *) alloc_counts[(int)alloc_type_thead].free_list.f_thead;
4896   alloc_counts[(int)alloc_type_thead].free_list.f_thead = ptr;
4897 #else
4898   free ((PTR_T) ptr);
4899 #endif
4900 }
4901 \f
4902 static lineno_list_t *
4903 allocate_lineno_list ()
4904 {
4905   register lineno_list_t *ptr;
4906   static lineno_list_t initial_lineno_list;
4907
4908 #ifndef MALLOC_CHECK
4909
4910   register int unallocated = alloc_counts[(int)alloc_type_lineno].unallocated;
4911   register page_t *cur_page = alloc_counts[(int)alloc_type_lineno].cur_page;
4912
4913   if (unallocated == 0)
4914     {
4915       unallocated = PAGE_SIZE / sizeof (lineno_list_t);
4916       alloc_counts[(int)alloc_type_lineno].cur_page = cur_page = allocate_page ();
4917       alloc_counts[(int)alloc_type_lineno].total_pages++;
4918     }
4919
4920   ptr = &cur_page->lineno[--unallocated];
4921   alloc_counts[(int)alloc_type_lineno].unallocated = unallocated;
4922
4923 #else
4924
4925   ptr = (lineno_list_t *) xmalloc (sizeof (lineno_list_t));
4926
4927 #endif
4928
4929   alloc_counts[(int)alloc_type_lineno].total_alloc++;
4930   *ptr = initial_lineno_list;
4931   return ptr;
4932 }
4933
4934 #endif /* ECOFF_DEBUGGING */