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