gas/ecoff.c

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