gas/ecoff.c

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