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