Import binutils-2.20
[dragonfly.git] / contrib / binutils-2.20 / gas / ecoff.c
1 /* ECOFF debugging support.
2    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3    2003, 2004, 2005, 2006, 2007, 2008, 2009
4    Free Software Foundation, Inc.
5    Contributed by Cygnus Support.
6    This file was put together by Ian Lance Taylor <ian@cygnus.com>.  A
7    good deal of it comes directly from mips-tfile.c, by Michael
8    Meissner <meissner@osf.org>.
9
10    This file is part of GAS.
11
12    GAS is free software; you can redistribute it and/or modify
13    it under the terms of the GNU General Public License as published by
14    the Free Software Foundation; either version 3, or (at your option)
15    any later version.
16
17    GAS is distributed in the hope that it will be useful,
18    but WITHOUT ANY WARRANTY; without even the implied warranty of
19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20    GNU General Public License for more details.
21
22    You should have received a copy of the GNU General Public License
23    along with GAS; see the file COPYING.  If not, write to the Free
24    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
25    02110-1301, USA.  */
26
27 #include "as.h"
28
29 /* This file is compiled conditionally for those targets which use
30    ECOFF debugging information (e.g., MIPS ECOFF, MIPS ELF, Alpha
31    ECOFF).  */
32
33 #include "ecoff.h"
34
35 #ifdef ECOFF_DEBUGGING
36
37 #include "coff/internal.h"
38 #include "coff/symconst.h"
39 #include "aout/stab_gnu.h"
40
41 #include "safe-ctype.h"
42
43 /* Why isn't this in coff/sym.h?  */
44 #define ST_RFDESCAPE 0xfff
45
46 /* This file constructs the information used by the ECOFF debugging
47    format.  It just builds a large block of data.
48
49    We support both ECOFF style debugging and stabs debugging (the
50    stabs symbols are encapsulated in ECOFF symbols).  This should let
51    us handle anything the compiler might throw at us.  */
52
53 /* Here is a brief description of the MIPS ECOFF symbol table, by
54    Michael Meissner.  The MIPS symbol table has the following pieces:
55
56         Symbolic Header
57             |
58             +-- Auxiliary Symbols
59             |
60             +-- Dense number table
61             |
62             +-- Optimizer Symbols
63             |
64             +-- External Strings
65             |
66             +-- External Symbols
67             |
68             +-- Relative file descriptors
69             |
70             +-- File table
71                     |
72                     +-- Procedure table
73                     |
74                     +-- Line number table
75                     |
76                     +-- Local Strings
77                     |
78                     +-- Local Symbols
79
80    The symbolic header points to each of the other tables, and also
81    contains the number of entries.  It also contains a magic number
82    and MIPS compiler version number, such as 2.0.
83
84    The auxiliary table is a series of 32 bit integers, that are
85    referenced as needed from the local symbol table.  Unlike standard
86    COFF, the aux.  information does not follow the symbol that uses
87    it, but rather is a separate table.  In theory, this would allow
88    the MIPS compilers to collapse duplicate aux. entries, but I've not
89    noticed this happening with the 1.31 compiler suite.  The different
90    types of aux. entries are:
91
92     1)  dnLow: Low bound on array dimension.
93
94     2)  dnHigh: High bound on array dimension.
95
96     3)  isym: Index to the local symbol which is the start of the
97         function for the end of function first aux. entry.
98
99     4)  width: Width of structures and bitfields.
100
101     5)  count: Count of ranges for variant part.
102
103     6)  rndx: A relative index into the symbol table.  The relative
104         index field has two parts: rfd which is a pointer into the
105         relative file index table or ST_RFDESCAPE which says the next
106         aux. entry is the file number, and index: which is the pointer
107         into the local symbol within a given file table.  This is for
108         things like references to types defined in another file.
109
110     7)  Type information: This is like the COFF type bits, except it
111         is 32 bits instead of 16; they still have room to add new
112         basic types; and they can handle more than 6 levels of array,
113         pointer, function, etc.  Each type information field contains
114         the following structure members:
115
116             a)  fBitfield: a bit that says this is a bitfield, and the
117                 size in bits follows as the next aux. entry.
118
119             b)  continued: a bit that says the next aux. entry is a
120                 continuation of the current type information (in case
121                 there are more than 6 levels of array/ptr/function).
122
123             c)  bt: an integer containing the base type before adding
124                 array, pointer, function, etc. qualifiers.  The
125                 current base types that I have documentation for are:
126
127                         btNil           -- undefined
128                         btAdr           -- address - integer same size as ptr
129                         btChar          -- character
130                         btUChar         -- unsigned character
131                         btShort         -- short
132                         btUShort        -- unsigned short
133                         btInt           -- int
134                         btUInt          -- unsigned int
135                         btLong          -- long
136                         btULong         -- unsigned long
137                         btFloat         -- float (real)
138                         btDouble        -- Double (real)
139                         btStruct        -- Structure (Record)
140                         btUnion         -- Union (variant)
141                         btEnum          -- Enumerated
142                         btTypedef       -- defined via a typedef isymRef
143                         btRange         -- subrange of int
144                         btSet           -- pascal sets
145                         btComplex       -- fortran complex
146                         btDComplex      -- fortran double complex
147                         btIndirect      -- forward or unnamed typedef
148                         btFixedDec      -- Fixed Decimal
149                         btFloatDec      -- Float Decimal
150                         btString        -- Varying Length Character String
151                         btBit           -- Aligned Bit String
152                         btPicture       -- Picture
153                         btVoid          -- Void (MIPS cc revision >= 2.00)
154
155             d)  tq0 - tq5: type qualifier fields as needed.  The
156                 current type qualifier fields I have documentation for
157                 are:
158
159                         tqNil           -- no more qualifiers
160                         tqPtr           -- pointer
161                         tqProc          -- procedure
162                         tqArray         -- array
163                         tqFar           -- 8086 far pointers
164                         tqVol           -- volatile
165
166    The dense number table is used in the front ends, and disappears by
167    the time the .o is created.
168
169    With the 1.31 compiler suite, the optimization symbols don't seem
170    to be used as far as I can tell.
171
172    The linker is the first entity that creates the relative file
173    descriptor table, and I believe it is used so that the individual
174    file table pointers don't have to be rewritten when the objects are
175    merged together into the program file.
176
177    Unlike COFF, the basic symbol & string tables are split into
178    external and local symbols/strings.  The relocation information
179    only goes off of the external symbol table, and the debug
180    information only goes off of the internal symbol table.  The
181    external symbols can have links to an appropriate file index and
182    symbol within the file to give it the appropriate type information.
183    Because of this, the external symbols are actually larger than the
184    internal symbols (to contain the link information), and contain the
185    local symbol structure as a member, though this member is not the
186    first member of the external symbol structure (!).  I suspect this
187    split is to make strip easier to deal with.
188
189    Each file table has offsets for where the line numbers, local
190    strings, local symbols, and procedure table starts from within the
191    global tables, and the indexs are reset to 0 for each of those
192    tables for the file.
193
194    The procedure table contains the binary equivalents of the .ent
195    (start of the function address), .frame (what register is the
196    virtual frame pointer, constant offset from the register to obtain
197    the VFP, and what register holds the return address), .mask/.fmask
198    (bitmask of saved registers, and where the first register is stored
199    relative to the VFP) assembler directives.  It also contains the
200    low and high bounds of the line numbers if debugging is turned on.
201
202    The line number table is a compressed form of the normal COFF line
203    table.  Each line number entry is either 1 or 3 bytes long, and
204    contains a signed delta from the previous line, and an unsigned
205    count of the number of instructions this statement takes.
206
207    The local symbol table contains the following fields:
208
209     1)  iss: index to the local string table giving the name of the
210         symbol.
211
212     2)  value: value of the symbol (address, register number, etc.).
213
214     3)  st: symbol type.  The current symbol types are:
215
216             stNil         -- Nuthin' special
217             stGlobal      -- external symbol
218             stStatic      -- static
219             stParam       -- procedure argument
220             stLocal       -- local variable
221             stLabel       -- label
222             stProc        -- External Procedure
223             stBlock       -- beginning of block
224             stEnd         -- end (of anything)
225             stMember      -- member (of anything)
226             stTypedef     -- type definition
227             stFile        -- file name
228             stRegReloc    -- register relocation
229             stForward     -- forwarding address
230             stStaticProc  -- Static procedure
231             stConstant    -- const
232
233     4)  sc: storage class.  The current storage classes are:
234
235             scText        -- text symbol
236             scData        -- initialized data symbol
237             scBss         -- un-initialized data symbol
238             scRegister    -- value of symbol is register number
239             scAbs         -- value of symbol is absolute
240             scUndefined   -- who knows?
241             scCdbLocal    -- variable's value is IN se->va.??
242             scBits        -- this is a bit field
243             scCdbSystem   -- value is IN debugger's address space
244             scRegImage    -- register value saved on stack
245             scInfo        -- symbol contains debugger information
246             scUserStruct  -- addr in struct user for current process
247             scSData       -- load time only small data
248             scSBss        -- load time only small common
249             scRData       -- load time only read only data
250             scVar         -- Var parameter (fortranpascal)
251             scCommon      -- common variable
252             scSCommon     -- small common
253             scVarRegister -- Var parameter in a register
254             scVariant     -- Variant record
255             scSUndefined  -- small undefined(external) data
256             scInit        -- .init section symbol
257
258     5)  index: pointer to a local symbol or aux. entry.
259
260    For the following program:
261
262         #include <stdio.h>
263
264         main(){
265                 printf("Hello World!\n");
266                 return 0;
267         }
268
269    Mips-tdump produces the following information:
270
271    Global file header:
272        magic number             0x162
273        # sections               2
274        timestamp                645311799, Wed Jun 13 17:16:39 1990
275        symbolic header offset   284
276        symbolic header size     96
277        optional header          56
278        flags                    0x0
279
280    Symbolic header, magic number = 0x7009, vstamp = 1.31:
281
282        Info                      Offset      Number       Bytes
283        ====                      ======      ======      =====
284
285        Line numbers                 380           4           4 [13]
286        Dense numbers                  0           0           0
287        Procedures Tables            384           1          52
288        Local Symbols                436          16         192
289        Optimization Symbols           0           0           0
290        Auxiliary Symbols            628          39         156
291        Local Strings                784          80          80
292        External Strings             864         144         144
293        File Tables                 1008           2         144
294        Relative Files                 0           0           0
295        External Symbols            1152          20         320
296
297    File #0, "hello2.c"
298
299        Name index  = 1          Readin      = No
300        Merge       = No         Endian      = LITTLE
301        Debug level = G2         Language    = C
302        Adr         = 0x00000000
303
304        Info                       Start      Number        Size      Offset
305        ====                       =====      ======        ====      ======
306        Local strings                  0          15          15         784
307        Local symbols                  0           6          72         436
308        Line numbers                   0          13          13         380
309        Optimization symbols           0           0           0           0
310        Procedures                     0           1          52         384
311        Auxiliary symbols              0          14          56         628
312        Relative Files                 0           0           0           0
313
314     There are 6 local symbols, starting at 436
315
316         Symbol# 0: "hello2.c"
317             End+1 symbol  = 6
318             String index  = 1
319             Storage class = Text        Index  = 6
320             Symbol type   = File        Value  = 0
321
322         Symbol# 1: "main"
323             End+1 symbol  = 5
324             Type          = int
325             String index  = 10
326             Storage class = Text        Index  = 12
327             Symbol type   = Proc        Value  = 0
328
329         Symbol# 2: ""
330             End+1 symbol  = 4
331             String index  = 0
332             Storage class = Text        Index  = 4
333             Symbol type   = Block       Value  = 8
334
335         Symbol# 3: ""
336             First symbol  = 2
337             String index  = 0
338             Storage class = Text        Index  = 2
339             Symbol type   = End         Value  = 28
340
341         Symbol# 4: "main"
342             First symbol  = 1
343             String index  = 10
344             Storage class = Text        Index  = 1
345             Symbol type   = End         Value  = 52
346
347         Symbol# 5: "hello2.c"
348             First symbol  = 0
349             String index  = 1
350             Storage class = Text        Index  = 0
351             Symbol type   = End         Value  = 0
352
353     There are 14 auxiliary table entries, starting at 628.
354
355         * #0               0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
356         * #1              24, [  24/      0], [ 6 0:0 0:0:0:0:0:0]
357         * #2               8, [   8/      0], [ 2 0:0 0:0:0:0:0:0]
358         * #3              16, [  16/      0], [ 4 0:0 0:0:0:0:0:0]
359         * #4              24, [  24/      0], [ 6 0:0 0:0:0:0:0:0]
360         * #5              32, [  32/      0], [ 8 0:0 0:0:0:0:0:0]
361         * #6              40, [  40/      0], [10 0:0 0:0:0:0:0:0]
362         * #7              44, [  44/      0], [11 0:0 0:0:0:0:0:0]
363         * #8              12, [  12/      0], [ 3 0:0 0:0:0:0:0:0]
364         * #9              20, [  20/      0], [ 5 0:0 0:0:0:0:0:0]
365         * #10             28, [  28/      0], [ 7 0:0 0:0:0:0:0:0]
366         * #11             36, [  36/      0], [ 9 0:0 0:0:0:0:0:0]
367           #12              5, [   5/      0], [ 1 1:0 0:0:0:0:0:0]
368           #13             24, [  24/      0], [ 6 0:0 0:0:0:0:0:0]
369
370     There are 1 procedure descriptor entries, starting at 0.
371
372         Procedure descriptor 0:
373             Name index   = 10          Name          = "main"
374             .mask 0x80000000,-4        .fmask 0x00000000,0
375             .frame $29,24,$31
376             Opt. start   = -1          Symbols start = 1
377             First line # = 3           Last line #   = 6
378             Line Offset  = 0           Address       = 0x00000000
379
380         There are 4 bytes holding line numbers, starting at 380.
381             Line           3,   delta     0,   count  2
382             Line           4,   delta     1,   count  3
383             Line           5,   delta     1,   count  2
384             Line           6,   delta     1,   count  6
385
386    File #1, "/usr/include/stdio.h"
387
388     Name index  = 1          Readin      = No
389     Merge       = Yes        Endian      = LITTLE
390     Debug level = G2         Language    = C
391     Adr         = 0x00000000
392
393     Info                       Start      Number        Size      Offset
394     ====                       =====      ======        ====      ======
395     Local strings                 15          65          65         799
396     Local symbols                  6          10         120         508
397     Line numbers                   0           0           0         380
398     Optimization symbols           0           0           0           0
399     Procedures                     1           0           0         436
400     Auxiliary symbols             14          25         100         684
401     Relative Files                 0           0           0           0
402
403     There are 10 local symbols, starting at 442
404
405         Symbol# 0: "/usr/include/stdio.h"
406             End+1 symbol  = 10
407             String index  = 1
408             Storage class = Text        Index  = 10
409             Symbol type   = File        Value  = 0
410
411         Symbol# 1: "_iobuf"
412             End+1 symbol  = 9
413             String index  = 22
414             Storage class = Info        Index  = 9
415             Symbol type   = Block       Value  = 20
416
417         Symbol# 2: "_cnt"
418             Type          = int
419             String index  = 29
420             Storage class = Info        Index  = 4
421             Symbol type   = Member      Value  = 0
422
423         Symbol# 3: "_ptr"
424             Type          = ptr to char
425             String index  = 34
426             Storage class = Info        Index  = 15
427             Symbol type   = Member      Value  = 32
428
429         Symbol# 4: "_base"
430             Type          = ptr to char
431             String index  = 39
432             Storage class = Info        Index  = 16
433             Symbol type   = Member      Value  = 64
434
435         Symbol# 5: "_bufsiz"
436             Type          = int
437             String index  = 45
438             Storage class = Info        Index  = 4
439             Symbol type   = Member      Value  = 96
440
441         Symbol# 6: "_flag"
442             Type          = short
443             String index  = 53
444             Storage class = Info        Index  = 3
445             Symbol type   = Member      Value  = 128
446
447         Symbol# 7: "_file"
448             Type          = char
449             String index  = 59
450             Storage class = Info        Index  = 2
451             Symbol type   = Member      Value  = 144
452
453         Symbol# 8: ""
454             First symbol  = 1
455             String index  = 0
456             Storage class = Info        Index  = 1
457             Symbol type   = End         Value  = 0
458
459         Symbol# 9: "/usr/include/stdio.h"
460             First symbol  = 0
461             String index  = 1
462             Storage class = Text        Index  = 0
463             Symbol type   = End         Value  = 0
464
465     There are 25 auxiliary table entries, starting at 642.
466
467         * #14             -1, [4095/1048575], [63 1:1 f:f:f:f:f:f]
468           #15          65544, [   8/     16], [ 2 0:0 1:0:0:0:0:0]
469           #16          65544, [   8/     16], [ 2 0:0 1:0:0:0:0:0]
470         * #17         196656, [  48/     48], [12 0:0 3:0:0:0:0:0]
471         * #18           8191, [4095/      1], [63 1:1 0:0:0:0:f:1]
472         * #19              1, [   1/      0], [ 0 1:0 0:0:0:0:0:0]
473         * #20          20479, [4095/      4], [63 1:1 0:0:0:0:f:4]
474         * #21              1, [   1/      0], [ 0 1:0 0:0:0:0:0:0]
475         * #22              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
476         * #23              2, [   2/      0], [ 0 0:1 0:0:0:0:0:0]
477         * #24            160, [ 160/      0], [40 0:0 0:0:0:0:0:0]
478         * #25              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
479         * #26              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
480         * #27              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
481         * #28              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
482         * #29              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
483         * #30              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
484         * #31              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
485         * #32              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
486         * #33              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
487         * #34              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
488         * #35              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
489         * #36              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
490         * #37              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
491         * #38              0, [   0/      0], [ 0 0:0 0:0:0:0:0:0]
492
493     There are 0 procedure descriptor entries, starting at 1.
494
495    There are 20 external symbols, starting at 1152
496
497         Symbol# 0: "_iob"
498             Type          = array [3 {160}] of struct _iobuf { ifd = 1, index = 1 }
499             String index  = 0           Ifd    = 1
500             Storage class = Nil         Index  = 17
501             Symbol type   = Global      Value  = 60
502
503         Symbol# 1: "fopen"
504             String index  = 5           Ifd    = 1
505             Storage class = Nil         Index  = 1048575
506             Symbol type   = Proc        Value  = 0
507
508         Symbol# 2: "fdopen"
509             String index  = 11          Ifd    = 1
510             Storage class = Nil         Index  = 1048575
511             Symbol type   = Proc        Value  = 0
512
513         Symbol# 3: "freopen"
514             String index  = 18          Ifd    = 1
515             Storage class = Nil         Index  = 1048575
516             Symbol type   = Proc        Value  = 0
517
518         Symbol# 4: "popen"
519             String index  = 26          Ifd    = 1
520             Storage class = Nil         Index  = 1048575
521             Symbol type   = Proc        Value  = 0
522
523         Symbol# 5: "tmpfile"
524             String index  = 32          Ifd    = 1
525             Storage class = Nil         Index  = 1048575
526             Symbol type   = Proc        Value  = 0
527
528         Symbol# 6: "ftell"
529             String index  = 40          Ifd    = 1
530             Storage class = Nil         Index  = 1048575
531             Symbol type   = Proc        Value  = 0
532
533         Symbol# 7: "rewind"
534             String index  = 46          Ifd    = 1
535             Storage class = Nil         Index  = 1048575
536             Symbol type   = Proc        Value  = 0
537
538         Symbol# 8: "setbuf"
539             String index  = 53          Ifd    = 1
540             Storage class = Nil         Index  = 1048575
541             Symbol type   = Proc        Value  = 0
542
543         Symbol# 9: "setbuffer"
544             String index  = 60          Ifd    = 1
545             Storage class = Nil         Index  = 1048575
546             Symbol type   = Proc        Value  = 0
547
548         Symbol# 10: "setlinebuf"
549             String index  = 70          Ifd    = 1
550             Storage class = Nil         Index  = 1048575
551             Symbol type   = Proc        Value  = 0
552
553         Symbol# 11: "fgets"
554             String index  = 81          Ifd    = 1
555             Storage class = Nil         Index  = 1048575
556             Symbol type   = Proc        Value  = 0
557
558         Symbol# 12: "gets"
559             String index  = 87          Ifd    = 1
560             Storage class = Nil         Index  = 1048575
561             Symbol type   = Proc        Value  = 0
562
563         Symbol# 13: "ctermid"
564             String index  = 92          Ifd    = 1
565             Storage class = Nil         Index  = 1048575
566             Symbol type   = Proc        Value  = 0
567
568         Symbol# 14: "cuserid"
569             String index  = 100         Ifd    = 1
570             Storage class = Nil         Index  = 1048575
571             Symbol type   = Proc        Value  = 0
572
573         Symbol# 15: "tempnam"
574             String index  = 108         Ifd    = 1
575             Storage class = Nil         Index  = 1048575
576             Symbol type   = Proc        Value  = 0
577
578         Symbol# 16: "tmpnam"
579             String index  = 116         Ifd    = 1
580             Storage class = Nil         Index  = 1048575
581             Symbol type   = Proc        Value  = 0
582
583         Symbol# 17: "sprintf"
584             String index  = 123         Ifd    = 1
585             Storage class = Nil         Index  = 1048575
586             Symbol type   = Proc        Value  = 0
587
588         Symbol# 18: "main"
589             Type          = int
590             String index  = 131         Ifd    = 0
591             Storage class = Text        Index  = 1
592             Symbol type   = Proc        Value  = 0
593
594         Symbol# 19: "printf"
595             String index  = 136         Ifd    = 0
596             Storage class = Undefined   Index  = 1048575
597             Symbol type   = Proc        Value  = 0
598
599    The following auxiliary table entries were unused:
600
601     #0               0  0x00000000  void
602     #2               8  0x00000008  char
603     #3              16  0x00000010  short
604     #4              24  0x00000018  int
605     #5              32  0x00000020  long
606     #6              40  0x00000028  float
607     #7              44  0x0000002c  double
608     #8              12  0x0000000c  unsigned char
609     #9              20  0x00000014  unsigned short
610     #10             28  0x0000001c  unsigned int
611     #11             36  0x00000024  unsigned long
612     #14              0  0x00000000  void
613     #15             24  0x00000018  int
614     #19             32  0x00000020  long
615     #20             40  0x00000028  float
616     #21             44  0x0000002c  double
617     #22             12  0x0000000c  unsigned char
618     #23             20  0x00000014  unsigned short
619     #24             28  0x0000001c  unsigned int
620     #25             36  0x00000024  unsigned long
621     #26             48  0x00000030  struct no name { ifd = -1, index = 1048575 }
622 */
623 \f
624 /* Redefinition of of storage classes as an enumeration for better
625    debugging.  */
626
627 typedef enum sc {
628   sc_Nil         = scNil,         /* no storage class */
629   sc_Text        = scText,        /* text symbol */
630   sc_Data        = scData,        /* initialized data symbol */
631   sc_Bss         = scBss,         /* un-initialized data symbol */
632   sc_Register    = scRegister,    /* value of symbol is register number */
633   sc_Abs         = scAbs,         /* value of symbol is absolute */
634   sc_Undefined   = scUndefined,   /* who knows? */
635   sc_CdbLocal    = scCdbLocal,    /* variable's value is IN se->va.?? */
636   sc_Bits        = scBits,        /* this is a bit field */
637   sc_CdbSystem   = scCdbSystem,   /* value is IN CDB's address space */
638   sc_RegImage    = scRegImage,    /* register value saved on stack */
639   sc_Info        = scInfo,        /* symbol contains debugger information */
640   sc_UserStruct  = scUserStruct,  /* addr in struct user for current process */
641   sc_SData       = scSData,       /* load time only small data */
642   sc_SBss        = scSBss,        /* load time only small common */
643   sc_RData       = scRData,       /* load time only read only data */
644   sc_Var         = scVar,         /* Var parameter (fortran,pascal) */
645   sc_Common      = scCommon,      /* common variable */
646   sc_SCommon     = scSCommon,     /* small common */
647   sc_VarRegister = scVarRegister, /* Var parameter in a register */
648   sc_Variant     = scVariant,     /* Variant record */
649   sc_SUndefined  = scSUndefined,  /* small undefined(external) data */
650   sc_Init        = scInit,        /* .init section symbol */
651   sc_Max         = scMax          /* Max storage class+1 */
652 } sc_t;
653
654 /* Redefinition of symbol type.  */
655
656 typedef enum st {
657   st_Nil        = stNil,        /* Nuthin' special */
658   st_Global     = stGlobal,     /* external symbol */
659   st_Static     = stStatic,     /* static */
660   st_Param      = stParam,      /* procedure argument */
661   st_Local      = stLocal,      /* local variable */
662   st_Label      = stLabel,      /* label */
663   st_Proc       = stProc,       /*     "      "  Procedure */
664   st_Block      = stBlock,      /* beginning of block */
665   st_End        = stEnd,        /* end (of anything) */
666   st_Member     = stMember,     /* member (of anything  - struct/union/enum */
667   st_Typedef    = stTypedef,    /* type definition */
668   st_File       = stFile,       /* file name */
669   st_RegReloc   = stRegReloc,   /* register relocation */
670   st_Forward    = stForward,    /* forwarding address */
671   st_StaticProc = stStaticProc, /* load time only static procs */
672   st_Constant   = stConstant,   /* const */
673   st_Str        = stStr,        /* string */
674   st_Number     = stNumber,     /* pure number (ie. 4 NOR 2+2) */
675   st_Expr       = stExpr,       /* 2+2 vs. 4 */
676   st_Type       = stType,       /* post-coercion SER */
677   st_Max        = stMax         /* max type+1 */
678 } st_t;
679
680 /* Redefinition of type qualifiers.  */
681
682 typedef enum tq {
683   tq_Nil        = tqNil,        /* bt is what you see */
684   tq_Ptr        = tqPtr,        /* pointer */
685   tq_Proc       = tqProc,       /* procedure */
686   tq_Array      = tqArray,      /* duh */
687   tq_Far        = tqFar,        /* longer addressing - 8086/8 land */
688   tq_Vol        = tqVol,        /* volatile */
689   tq_Max        = tqMax         /* Max type qualifier+1 */
690 } tq_t;
691
692 /* Redefinition of basic types.  */
693
694 typedef enum bt {
695   bt_Nil        = btNil,        /* undefined */
696   bt_Adr        = btAdr,        /* address - integer same size as pointer */
697   bt_Char       = btChar,       /* character */
698   bt_UChar      = btUChar,      /* unsigned character */
699   bt_Short      = btShort,      /* short */
700   bt_UShort     = btUShort,     /* unsigned short */
701   bt_Int        = btInt,        /* int */
702   bt_UInt       = btUInt,       /* unsigned int */
703   bt_Long       = btLong,       /* long */
704   bt_ULong      = btULong,      /* unsigned long */
705   bt_Float      = btFloat,      /* float (real) */
706   bt_Double     = btDouble,     /* Double (real) */
707   bt_Struct     = btStruct,     /* Structure (Record) */
708   bt_Union      = btUnion,      /* Union (variant) */
709   bt_Enum       = btEnum,       /* Enumerated */
710   bt_Typedef    = btTypedef,    /* defined via a typedef, isymRef points */
711   bt_Range      = btRange,      /* subrange of int */
712   bt_Set        = btSet,        /* pascal sets */
713   bt_Complex    = btComplex,    /* fortran complex */
714   bt_DComplex   = btDComplex,   /* fortran double complex */
715   bt_Indirect   = btIndirect,   /* forward or unnamed typedef */
716   bt_FixedDec   = btFixedDec,   /* Fixed Decimal */
717   bt_FloatDec   = btFloatDec,   /* Float Decimal */
718   bt_String     = btString,     /* Varying Length Character String */
719   bt_Bit        = btBit,        /* Aligned Bit String */
720   bt_Picture    = btPicture,    /* Picture */
721   bt_Void       = btVoid,       /* Void */
722   bt_Max        = btMax         /* Max basic type+1 */
723 } bt_t;
724
725 #define N_TQ itqMax
726
727 /* States for whether to hash type or not.  */
728 typedef enum hash_state {
729   hash_no       = 0,            /* Don't hash type */
730   hash_yes      = 1,            /* OK to hash type, or use previous hash */
731   hash_record   = 2             /* OK to record hash, but don't use prev.  */
732 } hash_state_t;
733
734 /* Types of different sized allocation requests.  */
735 enum alloc_type {
736   alloc_type_none,              /* dummy value */
737   alloc_type_scope,             /* nested scopes linked list */
738   alloc_type_vlinks,            /* glue linking pages in varray */
739   alloc_type_shash,             /* string hash element */
740   alloc_type_thash,             /* type hash element */
741   alloc_type_tag,               /* struct/union/tag element */
742   alloc_type_forward,           /* element to hold unknown tag */
743   alloc_type_thead,             /* head of type hash list */
744   alloc_type_varray,            /* general varray allocation */
745   alloc_type_lineno,            /* line number list */
746   alloc_type_last               /* last+1 element for array bounds */
747 };
748
749 /* Types of auxiliary type information.  */
750 enum aux_type {
751   aux_tir,                      /* TIR type information */
752   aux_rndx,                     /* relative index into symbol table */
753   aux_dnLow,                    /* low dimension */
754   aux_dnHigh,                   /* high dimension */
755   aux_isym,                     /* symbol table index (end of proc) */
756   aux_iss,                      /* index into string space (not used) */
757   aux_width,                    /* width for non-default sized struc fields */
758   aux_count                     /* count of ranges for variant arm */
759 };
760 \f
761 /* Structures to provide n-number of virtual arrays, each of which can
762    grow linearly, and which are written in the object file as
763    sequential pages.  On systems with a BSD malloc, the
764    MAX_CLUSTER_PAGES should be 1 less than a power of two, since
765    malloc adds it's overhead, and rounds up to the next power of 2.
766    Pages are linked together via a linked list.
767
768    If PAGE_SIZE is > 4096, the string length in the shash_t structure
769    can't be represented (assuming there are strings > 4096 bytes).  */
770
771 /* FIXME: Yes, there can be such strings while emitting C++ class debug
772    info.  Templates are the offender here, the test case in question
773    having a mangled class name of
774
775      t7rb_tree4Z4xkeyZt4pair2ZC4xkeyZt7xsocket1Z4UserZt9select1st2Zt4pair\
776      2ZC4xkeyZt7xsocket1Z4UserZ4xkeyZt4less1Z4xkey
777
778    Repeat that a couple dozen times while listing the class members and
779    you've got strings over 4k.  Hack around this for now by increasing
780    the page size.  A proper solution would abandon this structure scheme
781    certainly for very large strings, and possibly entirely.  */
782
783 #ifndef PAGE_SIZE
784 #define PAGE_SIZE (8*1024)      /* size of varray pages */
785 #endif
786
787 #define PAGE_USIZE ((unsigned long) PAGE_SIZE)
788
789 #ifndef MAX_CLUSTER_PAGES       /* # pages to get from system */
790 #define MAX_CLUSTER_PAGES 63
791 #endif
792
793 /* Linked list connecting separate page allocations.  */
794 typedef struct vlinks {
795   struct vlinks *prev;          /* previous set of pages */
796   struct vlinks *next;          /* next set of pages */
797   union  page   *datum;         /* start of page */
798   unsigned long  start_index;   /* starting index # of page */
799 } vlinks_t;
800
801 /* Virtual array header.  */
802 typedef struct varray {
803   vlinks_t      *first;                 /* first page link */
804   vlinks_t      *last;                  /* last page link */
805   unsigned long  num_allocated;         /* # objects allocated */
806   unsigned short object_size;           /* size in bytes of each object */
807   unsigned short objects_per_page;      /* # objects that can fit on a page */
808   unsigned short objects_last_page;     /* # objects allocated on last page */
809 } varray_t;
810
811 #ifndef MALLOC_CHECK
812 #define OBJECTS_PER_PAGE(type) (PAGE_SIZE / sizeof (type))
813 #else
814 #define OBJECTS_PER_PAGE(type) ((sizeof (type) > 1) ? 1 : PAGE_SIZE)
815 #endif
816
817 #define INIT_VARRAY(type) {     /* macro to initialize a varray */      \
818   (vlinks_t *)0,                /* first */                             \
819   (vlinks_t *)0,                /* last */                              \
820   0,                            /* num_allocated */                     \
821   sizeof (type),                /* object_size */                       \
822   OBJECTS_PER_PAGE (type),      /* objects_per_page */                  \
823   OBJECTS_PER_PAGE (type),      /* objects_last_page */                 \
824 }
825
826 /* Master type for indexes within the symbol table.  */
827 typedef unsigned long symint_t;
828
829 /* Linked list support for nested scopes (file, block, structure, etc.).  */
830 typedef struct scope {
831   struct scope  *prev;          /* previous scope level */
832   struct scope  *free;          /* free list pointer */
833   struct localsym *lsym;        /* pointer to local symbol node */
834   st_t           type;          /* type of the node */
835 } scope_t;
836
837 /* For a local symbol we store a gas symbol as well as the debugging
838    information we generate.  The gas symbol will be NULL if this is
839    only a debugging symbol.  */
840 typedef struct localsym {
841   const char *name;             /* symbol name */
842   symbolS *as_sym;              /* symbol as seen by gas */
843   bfd_vma addend;               /* addend to as_sym value */
844   struct efdr *file_ptr;        /* file pointer */
845   struct ecoff_proc *proc_ptr;  /* proc pointer */
846   struct localsym *begin_ptr;   /* symbol at start of block */
847   struct ecoff_aux *index_ptr;  /* index value to be filled in */
848   struct forward *forward_ref;  /* forward references to this symbol */
849   long sym_index;               /* final symbol index */
850   EXTR ecoff_sym;               /* ECOFF debugging symbol */
851 } localsym_t;
852
853 /* For aux information we keep the type and the data.  */
854 typedef struct ecoff_aux {
855   enum aux_type type;           /* aux type */
856   AUXU data;                    /* aux data */
857 } aux_t;
858
859 /* For a procedure we store the gas symbol as well as the PDR
860    debugging information.  */
861 typedef struct ecoff_proc {
862   localsym_t *sym;              /* associated symbol */
863   PDR pdr;                      /* ECOFF debugging info */
864 } proc_t;
865
866 /* Number of proc_t structures allocated.  */
867 static unsigned long proc_cnt;
868
869 /* Forward reference list for tags referenced, but not yet defined.  */
870 typedef struct forward {
871   struct forward *next;         /* next forward reference */
872   struct forward *free;         /* free list pointer */
873   aux_t          *ifd_ptr;      /* pointer to store file index */
874   aux_t          *index_ptr;    /* pointer to store symbol index */
875 } forward_t;
876
877 /* Linked list support for tags.  The first tag in the list is always
878    the current tag for that block.  */
879 typedef struct tag {
880   struct tag     *free;         /* free list pointer */
881   struct shash   *hash_ptr;     /* pointer to the hash table head */
882   struct tag     *same_name;    /* tag with same name in outer scope */
883   struct tag     *same_block;   /* next tag defined in the same block.  */
884   struct forward *forward_ref;  /* list of forward references */
885   bt_t            basic_type;   /* bt_Struct, bt_Union, or bt_Enum */
886   symint_t        ifd;          /* file # tag defined in */
887   localsym_t     *sym;          /* file's local symbols */
888 } tag_t;
889
890 /* Head of a block's linked list of tags.  */
891 typedef struct thead {
892   struct thead  *prev;          /* previous block */
893   struct thead  *free;          /* free list pointer */
894   struct tag    *first_tag;     /* first tag in block defined */
895 } thead_t;
896
897 /* Union containing pointers to each the small structures which are freed up.  */
898 typedef union small_free {
899   scope_t       *f_scope;       /* scope structure */
900   thead_t       *f_thead;       /* tag head structure */
901   tag_t         *f_tag;         /* tag element structure */
902   forward_t     *f_forward;     /* forward tag reference */
903 } small_free_t;
904
905 /* String hash table entry.  */
906
907 typedef struct shash {
908   char          *string;        /* string we are hashing */
909   symint_t       indx;          /* index within string table */
910   EXTR          *esym_ptr;      /* global symbol pointer */
911   localsym_t    *sym_ptr;       /* local symbol pointer */
912   localsym_t    *end_ptr;       /* symbol pointer to end block */
913   tag_t         *tag_ptr;       /* tag pointer */
914   proc_t        *proc_ptr;      /* procedure descriptor pointer */
915 } shash_t;
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 /* Extended file descriptor that contains all of the support necessary
935    to add things to each file separately.  */
936 typedef struct efdr {
937   FDR            fdr;           /* File header to be written out */
938   FDR           *orig_fdr;      /* original file header */
939   char          *name;          /* filename */
940   int            fake;          /* whether this is faked .file */
941   symint_t       void_type;     /* aux. pointer to 'void' type */
942   symint_t       int_type;      /* aux. pointer to 'int' type */
943   scope_t       *cur_scope;     /* current nested scopes */
944   symint_t       file_index;    /* current file number */
945   int            nested_scopes; /* # nested scopes */
946   varray_t       strings;       /* local strings */
947   varray_t       symbols;       /* local symbols */
948   varray_t       procs;         /* procedures */
949   varray_t       aux_syms;      /* auxiliary symbols */
950   struct efdr   *next_file;     /* next file descriptor */
951                                 /* string/type hash tables */
952   struct hash_control *str_hash;        /* string hash table */
953   thash_t       *thash_head[THASH_SIZE];
954 } efdr_t;
955
956 /* Pre-initialized extended file structure.  */
957 static const efdr_t init_file = {
958   {                     /* FDR structure */
959     0,                  /* adr:         memory address of beginning of file */
960     0,                  /* rss:         file name (of source, if known) */
961     0,                  /* issBase:     file's string space */
962     0,                  /* cbSs:        number of bytes in the ss */
963     0,                  /* isymBase:    beginning of symbols */
964     0,                  /* csym:        count file's of symbols */
965     0,                  /* ilineBase:   file's line symbols */
966     0,                  /* cline:       count of file's line symbols */
967     0,                  /* ioptBase:    file's optimization entries */
968     0,                  /* copt:        count of file's optimization entries */
969     0,                  /* ipdFirst:    start of procedures for this file */
970     0,                  /* cpd:         count of procedures for this file */
971     0,                  /* iauxBase:    file's auxiliary entries */
972     0,                  /* caux:        count of file's auxiliary entries */
973     0,                  /* rfdBase:     index into the file indirect table */
974     0,                  /* crfd:        count file indirect entries */
975     langC,              /* lang:        language for this file */
976     1,                  /* fMerge:      whether this file can be merged */
977     0,                  /* fReadin:     true if read in (not just created) */
978     TARGET_BYTES_BIG_ENDIAN,  /* fBigendian:    if 1, compiled on big endian machine */
979     GLEVEL_2,           /* glevel:      level this file was compiled with */
980     0,                  /* reserved:    reserved for future use */
981     0,                  /* cbLineOffset: byte offset from header for this file ln's */
982     0,                  /* cbLine:      size of lines for this file */
983   },
984
985   (FDR *)0,             /* orig_fdr:    original file header pointer */
986   (char *)0,            /* name:        pointer to filename */
987   0,                    /* fake:        whether this is a faked .file */
988   0,                    /* void_type:   ptr to aux node for void type */
989   0,                    /* int_type:    ptr to aux node for int type */
990   (scope_t *)0,         /* cur_scope:   current scope being processed */
991   0,                    /* file_index:  current file # */
992   0,                    /* nested_scopes: # nested scopes */
993   INIT_VARRAY (char),   /* strings:     local string varray */
994   INIT_VARRAY (localsym_t),     /* symbols:     local symbols varray */
995   INIT_VARRAY (proc_t), /* procs:       procedure varray */
996   INIT_VARRAY (aux_t),  /* aux_syms:    auxiliary symbols varray */
997
998   (struct efdr *)0,     /* next_file:   next file structure */
999
1000   (struct hash_control *)0,     /* str_hash:    string hash table */
1001   { 0 },                /* thash_head:  type hash table */
1002 };
1003
1004 static efdr_t *first_file;                      /* first file descriptor */
1005 static efdr_t **last_file_ptr = &first_file;    /* file descriptor tail */
1006
1007 /* Line number information is kept in a list until the assembly is
1008    finished.  */
1009 typedef struct lineno_list {
1010   struct lineno_list *next;     /* next element in list */
1011   efdr_t *file;                 /* file this line is in */
1012   proc_t *proc;                 /* procedure this line is in */
1013   fragS *frag;                  /* fragment this line number is in */
1014   unsigned long paddr;          /* offset within fragment */
1015   long lineno;                  /* actual line number */
1016 } lineno_list_t;
1017
1018 static lineno_list_t *first_lineno;
1019 static lineno_list_t *last_lineno;
1020 static lineno_list_t **last_lineno_ptr = &first_lineno;
1021
1022 /* Sometimes there will be some .loc statements before a .ent.  We
1023    keep them in this list so that we can fill in the procedure pointer
1024    after we see the .ent.  */
1025 static lineno_list_t *noproc_lineno;
1026
1027 /* Union of various things that are held in pages.  */
1028 typedef union page {
1029   char          byte    [ PAGE_SIZE ];
1030   unsigned char ubyte   [ PAGE_SIZE ];
1031   efdr_t        file    [ PAGE_SIZE / sizeof (efdr_t)        ];
1032   FDR           ofile   [ PAGE_SIZE / sizeof (FDR)           ];
1033   proc_t        proc    [ PAGE_SIZE / sizeof (proc_t)        ];
1034   localsym_t    sym     [ PAGE_SIZE / sizeof (localsym_t)    ];
1035   aux_t         aux     [ PAGE_SIZE / sizeof (aux_t)         ];
1036   DNR           dense   [ PAGE_SIZE / sizeof (DNR)           ];
1037   scope_t       scope   [ PAGE_SIZE / sizeof (scope_t)       ];
1038   vlinks_t      vlinks  [ PAGE_SIZE / sizeof (vlinks_t)      ];
1039   shash_t       shash   [ PAGE_SIZE / sizeof (shash_t)       ];
1040   thash_t       thash   [ PAGE_SIZE / sizeof (thash_t)       ];
1041   tag_t         tag     [ PAGE_SIZE / sizeof (tag_t)         ];
1042   forward_t     forward [ PAGE_SIZE / sizeof (forward_t)     ];
1043   thead_t       thead   [ PAGE_SIZE / sizeof (thead_t)       ];
1044   lineno_list_t lineno  [ PAGE_SIZE / sizeof (lineno_list_t) ];
1045 } page_type;
1046
1047 /* Structure holding allocation information for small sized structures.  */
1048 typedef struct alloc_info {
1049   char          *alloc_name;    /* name of this allocation type (must be first) */
1050   page_type     *cur_page;      /* current page being allocated from */
1051   small_free_t   free_list;     /* current free list if any */
1052   int            unallocated;   /* number of elements unallocated on page */
1053   int            total_alloc;   /* total number of allocations */
1054   int            total_free;    /* total number of frees */
1055   int            total_pages;   /* total number of pages allocated */
1056 } alloc_info_t;
1057
1058 /* Type information collected together.  */
1059 typedef struct type_info {
1060   bt_t        basic_type;               /* basic type */
1061   int         orig_type;                /* original COFF-based type */
1062   int         num_tq;                   /* # type qualifiers */
1063   int         num_dims;                 /* # dimensions */
1064   int         num_sizes;                /* # sizes */
1065   int         extra_sizes;              /* # extra sizes not tied with dims */
1066   tag_t *     tag_ptr;                  /* tag pointer */
1067   int         bitfield;                 /* symbol is a bitfield */
1068   tq_t        type_qualifiers[N_TQ];    /* type qualifiers (ptr, func, array)*/
1069   symint_t    dimensions     [N_TQ];    /* dimensions for each array */
1070   symint_t    sizes          [N_TQ+2];  /* sizes of each array slice + size of
1071                                            struct/union/enum + bitfield size */
1072 } type_info_t;
1073
1074 /* Pre-initialized type_info struct.  */
1075 static const type_info_t type_info_init = {
1076   bt_Nil,                               /* basic type */
1077   T_NULL,                               /* original COFF-based type */
1078   0,                                    /* # type qualifiers */
1079   0,                                    /* # dimensions */
1080   0,                                    /* # sizes */
1081   0,                                    /* sizes not tied with dims */
1082   NULL,                                 /* ptr to tag */
1083   0,                                    /* bitfield */
1084   {                                     /* type qualifiers */
1085     tq_Nil,
1086     tq_Nil,
1087     tq_Nil,
1088     tq_Nil,
1089     tq_Nil,
1090     tq_Nil,
1091   },
1092   {                                     /* dimensions */
1093     0,
1094     0,
1095     0,
1096     0,
1097     0,
1098     0
1099   },
1100   {                                     /* sizes */
1101     0,
1102     0,
1103     0,
1104     0,
1105     0,
1106     0,
1107     0,
1108     0,
1109   },
1110 };
1111
1112 /* Global hash table for the tags table and global table for file
1113    descriptors.  */
1114
1115 static varray_t file_desc = INIT_VARRAY (efdr_t);
1116
1117 static struct hash_control *tag_hash;
1118
1119 /* Static types for int and void.  Also, remember the last function's
1120    type (which is set up when we encounter the declaration for the
1121    function, and used when the end block for the function is emitted.  */
1122
1123 static type_info_t int_type_info;
1124 static type_info_t void_type_info;
1125 static type_info_t last_func_type_info;
1126 static symbolS *last_func_sym_value;
1127
1128 /* Convert COFF basic type to ECOFF basic type.  The T_NULL type
1129    really should use bt_Void, but this causes the current ecoff GDB to
1130    issue unsupported type messages, and the Ultrix 4.00 dbx (aka MIPS
1131    2.0) doesn't understand it, even though the compiler generates it.
1132    Maybe this will be fixed in 2.10 or 2.20 of the MIPS compiler
1133    suite, but for now go with what works.
1134
1135    It would make sense for the .type and .scl directives to use the
1136    ECOFF numbers directly, rather than using the COFF numbers and
1137    mapping them.  Unfortunately, this is historically what mips-tfile
1138    expects, and changing gcc now would be a considerable pain (the
1139    native compiler generates debugging information internally, rather
1140    than via the assembler, so it will never use .type or .scl).  */
1141
1142 static const bt_t map_coff_types[] = {
1143   bt_Nil,                       /* T_NULL */
1144   bt_Nil,                       /* T_ARG */
1145   bt_Char,                      /* T_CHAR */
1146   bt_Short,                     /* T_SHORT */
1147   bt_Int,                       /* T_INT */
1148   bt_Long,                      /* T_LONG */
1149   bt_Float,                     /* T_FLOAT */
1150   bt_Double,                    /* T_DOUBLE */
1151   bt_Struct,                    /* T_STRUCT */
1152   bt_Union,                     /* T_UNION */
1153   bt_Enum,                      /* T_ENUM */
1154   bt_Enum,                      /* T_MOE */
1155   bt_UChar,                     /* T_UCHAR */
1156   bt_UShort,                    /* T_USHORT */
1157   bt_UInt,                      /* T_UINT */
1158   bt_ULong                      /* T_ULONG */
1159 };
1160
1161 /* Convert COFF storage class to ECOFF storage class.  */
1162 static const sc_t map_coff_storage[] = {
1163   sc_Nil,                       /*   0: C_NULL */
1164   sc_Abs,                       /*   1: C_AUTO    auto var */
1165   sc_Undefined,                 /*   2: C_EXT     external */
1166   sc_Data,                      /*   3: C_STAT    static */
1167   sc_Register,                  /*   4: C_REG     register */
1168   sc_Undefined,                 /*   5: C_EXTDEF  ??? */
1169   sc_Text,                      /*   6: C_LABEL   label */
1170   sc_Text,                      /*   7: C_ULABEL  user label */
1171   sc_Info,                      /*   8: C_MOS     member of struct */
1172   sc_Abs,                       /*   9: C_ARG     argument */
1173   sc_Info,                      /*  10: C_STRTAG  struct tag */
1174   sc_Info,                      /*  11: C_MOU     member of union */
1175   sc_Info,                      /*  12: C_UNTAG   union tag */
1176   sc_Info,                      /*  13: C_TPDEF   typedef */
1177   sc_Data,                      /*  14: C_USTATIC ??? */
1178   sc_Info,                      /*  15: C_ENTAG   enum tag */
1179   sc_Info,                      /*  16: C_MOE     member of enum */
1180   sc_Register,                  /*  17: C_REGPARM register parameter */
1181   sc_Bits,                      /*  18; C_FIELD   bitfield */
1182   sc_Nil,                       /*  19 */
1183   sc_Nil,                       /*  20 */
1184   sc_Nil,                       /*  21 */
1185   sc_Nil,                       /*  22 */
1186   sc_Nil,                       /*  23 */
1187   sc_Nil,                       /*  24 */
1188   sc_Nil,                       /*  25 */
1189   sc_Nil,                       /*  26 */
1190   sc_Nil,                       /*  27 */
1191   sc_Nil,                       /*  28 */
1192   sc_Nil,                       /*  29 */
1193   sc_Nil,                       /*  30 */
1194   sc_Nil,                       /*  31 */
1195   sc_Nil,                       /*  32 */
1196   sc_Nil,                       /*  33 */
1197   sc_Nil,                       /*  34 */
1198   sc_Nil,                       /*  35 */
1199   sc_Nil,                       /*  36 */
1200   sc_Nil,                       /*  37 */
1201   sc_Nil,                       /*  38 */
1202   sc_Nil,                       /*  39 */
1203   sc_Nil,                       /*  40 */
1204   sc_Nil,                       /*  41 */
1205   sc_Nil,                       /*  42 */
1206   sc_Nil,                       /*  43 */
1207   sc_Nil,                       /*  44 */
1208   sc_Nil,                       /*  45 */
1209   sc_Nil,                       /*  46 */
1210   sc_Nil,                       /*  47 */
1211   sc_Nil,                       /*  48 */
1212   sc_Nil,                       /*  49 */
1213   sc_Nil,                       /*  50 */
1214   sc_Nil,                       /*  51 */
1215   sc_Nil,                       /*  52 */
1216   sc_Nil,                       /*  53 */
1217   sc_Nil,                       /*  54 */
1218   sc_Nil,                       /*  55 */
1219   sc_Nil,                       /*  56 */
1220   sc_Nil,                       /*  57 */
1221   sc_Nil,                       /*  58 */
1222   sc_Nil,                       /*  59 */
1223   sc_Nil,                       /*  60 */
1224   sc_Nil,                       /*  61 */
1225   sc_Nil,                       /*  62 */
1226   sc_Nil,                       /*  63 */
1227   sc_Nil,                       /*  64 */
1228   sc_Nil,                       /*  65 */
1229   sc_Nil,                       /*  66 */
1230   sc_Nil,                       /*  67 */
1231   sc_Nil,                       /*  68 */
1232   sc_Nil,                       /*  69 */
1233   sc_Nil,                       /*  70 */
1234   sc_Nil,                       /*  71 */
1235   sc_Nil,                       /*  72 */
1236   sc_Nil,                       /*  73 */
1237   sc_Nil,                       /*  74 */
1238   sc_Nil,                       /*  75 */
1239   sc_Nil,                       /*  76 */
1240   sc_Nil,                       /*  77 */
1241   sc_Nil,                       /*  78 */
1242   sc_Nil,                       /*  79 */
1243   sc_Nil,                       /*  80 */
1244   sc_Nil,                       /*  81 */
1245   sc_Nil,                       /*  82 */
1246   sc_Nil,                       /*  83 */
1247   sc_Nil,                       /*  84 */
1248   sc_Nil,                       /*  85 */
1249   sc_Nil,                       /*  86 */
1250   sc_Nil,                       /*  87 */
1251   sc_Nil,                       /*  88 */
1252   sc_Nil,                       /*  89 */
1253   sc_Nil,                       /*  90 */
1254   sc_Nil,                       /*  91 */
1255   sc_Nil,                       /*  92 */
1256   sc_Nil,                       /*  93 */
1257   sc_Nil,                       /*  94 */
1258   sc_Nil,                       /*  95 */
1259   sc_Nil,                       /*  96 */
1260   sc_Nil,                       /*  97 */
1261   sc_Nil,                       /*  98 */
1262   sc_Nil,                       /*  99 */
1263   sc_Text,                      /* 100: C_BLOCK  block start/end */
1264   sc_Text,                      /* 101: C_FCN    function start/end */
1265   sc_Info,                      /* 102: C_EOS    end of struct/union/enum */
1266   sc_Nil,                       /* 103: C_FILE   file start */
1267   sc_Nil,                       /* 104: C_LINE   line number */
1268   sc_Nil,                       /* 105: C_ALIAS  combined type info */
1269   sc_Nil,                       /* 106: C_HIDDEN ??? */
1270 };
1271
1272 /* Convert COFF storage class to ECOFF symbol type.  */
1273 static const st_t map_coff_sym_type[] = {
1274   st_Nil,                       /*   0: C_NULL */
1275   st_Local,                     /*   1: C_AUTO    auto var */
1276   st_Global,                    /*   2: C_EXT     external */
1277   st_Static,                    /*   3: C_STAT    static */
1278   st_Local,                     /*   4: C_REG     register */
1279   st_Global,                    /*   5: C_EXTDEF  ??? */
1280   st_Label,                     /*   6: C_LABEL   label */
1281   st_Label,                     /*   7: C_ULABEL  user label */
1282   st_Member,                    /*   8: C_MOS     member of struct */
1283   st_Param,                     /*   9: C_ARG     argument */
1284   st_Block,                     /*  10: C_STRTAG  struct tag */
1285   st_Member,                    /*  11: C_MOU     member of union */
1286   st_Block,                     /*  12: C_UNTAG   union tag */
1287   st_Typedef,                   /*  13: C_TPDEF   typedef */
1288   st_Static,                    /*  14: C_USTATIC ??? */
1289   st_Block,                     /*  15: C_ENTAG   enum tag */
1290   st_Member,                    /*  16: C_MOE     member of enum */
1291   st_Param,                     /*  17: C_REGPARM register parameter */
1292   st_Member,                    /*  18; C_FIELD   bitfield */
1293   st_Nil,                       /*  19 */
1294   st_Nil,                       /*  20 */
1295   st_Nil,                       /*  21 */
1296   st_Nil,                       /*  22 */
1297   st_Nil,                       /*  23 */
1298   st_Nil,                       /*  24 */
1299   st_Nil,                       /*  25 */
1300   st_Nil,                       /*  26 */
1301   st_Nil,                       /*  27 */
1302   st_Nil,                       /*  28 */
1303   st_Nil,                       /*  29 */
1304   st_Nil,                       /*  30 */
1305   st_Nil,                       /*  31 */
1306   st_Nil,                       /*  32 */
1307   st_Nil,                       /*  33 */
1308   st_Nil,                       /*  34 */
1309   st_Nil,                       /*  35 */
1310   st_Nil,                       /*  36 */
1311   st_Nil,                       /*  37 */
1312   st_Nil,                       /*  38 */
1313   st_Nil,                       /*  39 */
1314   st_Nil,                       /*  40 */
1315   st_Nil,                       /*  41 */
1316   st_Nil,                       /*  42 */
1317   st_Nil,                       /*  43 */
1318   st_Nil,                       /*  44 */
1319   st_Nil,                       /*  45 */
1320   st_Nil,                       /*  46 */
1321   st_Nil,                       /*  47 */
1322   st_Nil,                       /*  48 */
1323   st_Nil,                       /*  49 */
1324   st_Nil,                       /*  50 */
1325   st_Nil,                       /*  51 */
1326   st_Nil,                       /*  52 */
1327   st_Nil,                       /*  53 */
1328   st_Nil,                       /*  54 */
1329   st_Nil,                       /*  55 */
1330   st_Nil,                       /*  56 */
1331   st_Nil,                       /*  57 */
1332   st_Nil,                       /*  58 */
1333   st_Nil,                       /*  59 */
1334   st_Nil,                       /*  60 */
1335   st_Nil,                       /*  61 */
1336   st_Nil,                       /*  62 */
1337   st_Nil,                       /*  63 */
1338   st_Nil,                       /*  64 */
1339   st_Nil,                       /*  65 */
1340   st_Nil,                       /*  66 */
1341   st_Nil,                       /*  67 */
1342   st_Nil,                       /*  68 */
1343   st_Nil,                       /*  69 */
1344   st_Nil,                       /*  70 */
1345   st_Nil,                       /*  71 */
1346   st_Nil,                       /*  72 */
1347   st_Nil,                       /*  73 */
1348   st_Nil,                       /*  74 */
1349   st_Nil,                       /*  75 */
1350   st_Nil,                       /*  76 */
1351   st_Nil,                       /*  77 */
1352   st_Nil,                       /*  78 */
1353   st_Nil,                       /*  79 */
1354   st_Nil,                       /*  80 */
1355   st_Nil,                       /*  81 */
1356   st_Nil,                       /*  82 */
1357   st_Nil,                       /*  83 */
1358   st_Nil,                       /*  84 */
1359   st_Nil,                       /*  85 */
1360   st_Nil,                       /*  86 */
1361   st_Nil,                       /*  87 */
1362   st_Nil,                       /*  88 */
1363   st_Nil,                       /*  89 */
1364   st_Nil,                       /*  90 */
1365   st_Nil,                       /*  91 */
1366   st_Nil,                       /*  92 */
1367   st_Nil,                       /*  93 */
1368   st_Nil,                       /*  94 */
1369   st_Nil,                       /*  95 */
1370   st_Nil,                       /*  96 */
1371   st_Nil,                       /*  97 */
1372   st_Nil,                       /*  98 */
1373   st_Nil,                       /*  99 */
1374   st_Block,                     /* 100: C_BLOCK  block start/end */
1375   st_Proc,                      /* 101: C_FCN    function start/end */
1376   st_End,                       /* 102: C_EOS    end of struct/union/enum */
1377   st_File,                      /* 103: C_FILE   file start */
1378   st_Nil,                       /* 104: C_LINE   line number */
1379   st_Nil,                       /* 105: C_ALIAS  combined type info */
1380   st_Nil,                       /* 106: C_HIDDEN ??? */
1381 };
1382
1383 /* Keep track of different sized allocation requests.  */
1384 static alloc_info_t alloc_counts[(int) alloc_type_last];
1385 \f
1386 /* Record whether we have seen any debugging information.  */
1387 int ecoff_debugging_seen = 0;
1388
1389 /* Various statics.  */
1390 static efdr_t  *cur_file_ptr    = (efdr_t *) 0; /* current file desc. header */
1391 static proc_t  *cur_proc_ptr    = (proc_t *) 0; /* current procedure header */
1392 static proc_t  *first_proc_ptr  = (proc_t *) 0; /* first procedure header */
1393 static thead_t *top_tag_head    = (thead_t *) 0; /* top level tag head */
1394 static thead_t *cur_tag_head    = (thead_t *) 0; /* current tag head */
1395 #ifdef ECOFF_DEBUG
1396 static int      debug           = 0;            /* trace functions */
1397 #endif
1398 static int      stabs_seen      = 0;            /* != 0 if stabs have been seen */
1399
1400 static int current_file_idx;
1401 static const char *current_stabs_filename;
1402
1403 /* Pseudo symbol to use when putting stabs into the symbol table.  */
1404 #ifndef STABS_SYMBOL
1405 #define STABS_SYMBOL "@stabs"
1406 #endif
1407
1408 static char stabs_symbol[] = STABS_SYMBOL;
1409 \f
1410 /* Prototypes for functions defined in this file.  */
1411
1412 static void add_varray_page (varray_t *vp);
1413 static symint_t add_string (varray_t *vp,
1414                             struct hash_control *hash_tbl,
1415                             const char *str,
1416                             shash_t **ret_hash);
1417 static localsym_t *add_ecoff_symbol (const char *str, st_t type,
1418                                      sc_t storage, symbolS *sym,
1419                                      bfd_vma addend, symint_t value,
1420                                      symint_t indx);
1421 static symint_t add_aux_sym_symint (symint_t aux_word);
1422 static symint_t add_aux_sym_rndx (int file_index, symint_t sym_index);
1423 static symint_t add_aux_sym_tir (type_info_t *t,
1424                                  hash_state_t state,
1425                                  thash_t **hash_tbl);
1426 static tag_t *get_tag (const char *tag, localsym_t *sym, bt_t basic_type);
1427 static void add_unknown_tag (tag_t *ptag);
1428 static void add_procedure (char *func);
1429 static void add_file (const char *file_name, int indx, int fake);
1430 #ifdef ECOFF_DEBUG
1431 static char *sc_to_string (sc_t storage_class);
1432 static char *st_to_string (st_t symbol_type);
1433 #endif
1434 static void mark_stabs (int);
1435 static char *ecoff_add_bytes (char **buf, char **bufend,
1436                               char *bufptr, unsigned long need);
1437 static unsigned long ecoff_padding_adjust
1438   (const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1439    unsigned long offset, char **bufptrptr);
1440 static unsigned long ecoff_build_lineno
1441   (const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1442    unsigned long offset, long *linecntptr);
1443 static unsigned long ecoff_build_symbols
1444   (const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1445    unsigned long offset);
1446 static unsigned long ecoff_build_procs
1447   (const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1448    unsigned long offset);
1449 static unsigned long ecoff_build_aux
1450   (const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1451    unsigned long offset);
1452 static unsigned long ecoff_build_strings (char **buf, char **bufend,
1453                                           unsigned long offset,
1454                                           varray_t *vp);
1455 static unsigned long ecoff_build_ss
1456   (const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1457    unsigned long offset);
1458 static unsigned long ecoff_build_fdr
1459   (const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1460    unsigned long offset);
1461 static void ecoff_setup_ext (void);
1462 static page_type *allocate_cluster (unsigned long npages);
1463 static page_type *allocate_page (void);
1464 static scope_t *allocate_scope (void);
1465 static void free_scope (scope_t *ptr);
1466 static vlinks_t *allocate_vlinks (void);
1467 static shash_t *allocate_shash (void);
1468 static thash_t *allocate_thash (void);
1469 static tag_t *allocate_tag (void);
1470 static void free_tag (tag_t *ptr);
1471 static forward_t *allocate_forward (void);
1472 static thead_t *allocate_thead (void);
1473 static void free_thead (thead_t *ptr);
1474 static lineno_list_t *allocate_lineno_list (void);
1475 \f
1476 /* This function should be called when the assembler starts up.  */
1477
1478 void
1479 ecoff_read_begin_hook (void)
1480 {
1481   tag_hash = hash_new ();
1482   top_tag_head = allocate_thead ();
1483   top_tag_head->first_tag = (tag_t *) NULL;
1484   top_tag_head->free = (thead_t *) NULL;
1485   top_tag_head->prev = cur_tag_head;
1486   cur_tag_head = top_tag_head;
1487 }
1488
1489 /* This function should be called when a symbol is created.  */
1490
1491 void
1492 ecoff_symbol_new_hook (symbolS *symbolP)
1493 {
1494   OBJ_SYMFIELD_TYPE *obj;
1495
1496   /* Make sure that we have a file pointer, but only if we have seen a
1497      file.  If we haven't seen a file, then this is a probably special
1498      symbol created by md_begin which may required special handling at
1499      some point.  Creating a dummy file with a dummy name is certainly
1500      wrong.  */
1501   if (cur_file_ptr == (efdr_t *) NULL
1502       && seen_at_least_1_file ())
1503     add_file ((const char *) NULL, 0, 1);
1504   obj = symbol_get_obj (symbolP);
1505   obj->ecoff_file = cur_file_ptr;
1506   obj->ecoff_symbol = NULL;
1507   obj->ecoff_extern_size = 0;
1508 }
1509 \f
1510 /* Add a page to a varray object.  */
1511
1512 static void
1513 add_varray_page (varray_t *vp /* varray to add page to */)
1514 {
1515   vlinks_t *new_links = allocate_vlinks ();
1516
1517 #ifdef MALLOC_CHECK
1518   if (vp->object_size > 1)
1519     new_links->datum = (page_type *) xcalloc (1, vp->object_size);
1520   else
1521 #endif
1522     new_links->datum = allocate_page ();
1523
1524   alloc_counts[(int) alloc_type_varray].total_alloc++;
1525   alloc_counts[(int) alloc_type_varray].total_pages++;
1526
1527   new_links->start_index = vp->num_allocated;
1528   vp->objects_last_page = 0;
1529
1530   if (vp->first == (vlinks_t *) NULL)           /* first allocation? */
1531     vp->first = vp->last = new_links;
1532   else
1533     {                                           /* 2nd or greater allocation */
1534       new_links->prev = vp->last;
1535       vp->last->next = new_links;
1536       vp->last = new_links;
1537     }
1538 }
1539 \f
1540 /* Add a string (and null pad) to one of the string tables.  */
1541
1542 static symint_t
1543 add_string (varray_t *vp,                       /* string obstack */
1544             struct hash_control *hash_tbl,      /* ptr to hash table */
1545             const char *str,                    /* string */
1546             shash_t **ret_hash                  /* return hash pointer */)
1547 {
1548   register unsigned long len = strlen (str);
1549   register shash_t *hash_ptr;
1550
1551   if (len >= PAGE_USIZE)
1552     as_fatal (_("string too big (%lu bytes)"), len);
1553
1554   hash_ptr = (shash_t *) hash_find (hash_tbl, str);
1555   if (hash_ptr == (shash_t *) NULL)
1556     {
1557       register const char *err;
1558
1559       if (vp->objects_last_page + len >= PAGE_USIZE)
1560         {
1561           vp->num_allocated =
1562             ((vp->num_allocated + PAGE_USIZE - 1) / PAGE_USIZE) * PAGE_USIZE;
1563           add_varray_page (vp);
1564         }
1565
1566       hash_ptr = allocate_shash ();
1567       hash_ptr->indx = vp->num_allocated;
1568
1569       hash_ptr->string = &vp->last->datum->byte[vp->objects_last_page];
1570
1571       vp->objects_last_page += len + 1;
1572       vp->num_allocated += len + 1;
1573
1574       strcpy (hash_ptr->string, str);
1575
1576       err = hash_insert (hash_tbl, str, (char *) hash_ptr);
1577       if (err)
1578         as_fatal (_("inserting \"%s\" into string hash table: %s"),
1579                   str, err);
1580     }
1581
1582   if (ret_hash != (shash_t **) NULL)
1583     *ret_hash = hash_ptr;
1584
1585   return hash_ptr->indx;
1586 }
1587 \f
1588 /* Add debugging information for a symbol.  */
1589
1590 static localsym_t *
1591 add_ecoff_symbol (const char *str,      /* symbol name */
1592                   st_t type,            /* symbol type */
1593                   sc_t storage,         /* storage class */
1594                   symbolS *sym_value,   /* associated symbol.  */
1595                   bfd_vma addend,       /* addend to sym_value.  */
1596                   symint_t value,       /* value of symbol */
1597                   symint_t indx         /* index to local/aux. syms */)
1598 {
1599   localsym_t *psym;
1600   register scope_t *pscope;
1601   register thead_t *ptag_head;
1602   register tag_t *ptag;
1603   register tag_t *ptag_next;
1604   register varray_t *vp;
1605   register int scope_delta = 0;
1606   shash_t *hash_ptr = (shash_t *) NULL;
1607
1608   if (cur_file_ptr == (efdr_t *) NULL)
1609     as_fatal (_("no current file pointer"));
1610
1611   vp = &cur_file_ptr->symbols;
1612
1613   if (vp->objects_last_page == vp->objects_per_page)
1614     add_varray_page (vp);
1615
1616   psym = &vp->last->datum->sym[vp->objects_last_page++];
1617
1618   if (str == (const char *) NULL && sym_value != (symbolS *) NULL)
1619     psym->name = S_GET_NAME (sym_value);
1620   else
1621     psym->name = str;
1622   psym->as_sym = sym_value;
1623   if (sym_value != (symbolS *) NULL)
1624     symbol_get_obj (sym_value)->ecoff_symbol = psym;
1625   psym->addend = addend;
1626   psym->file_ptr = cur_file_ptr;
1627   psym->proc_ptr = cur_proc_ptr;
1628   psym->begin_ptr = (localsym_t *) NULL;
1629   psym->index_ptr = (aux_t *) NULL;
1630   psym->forward_ref = (forward_t *) NULL;
1631   psym->sym_index = -1;
1632   memset (&psym->ecoff_sym, 0, sizeof (EXTR));
1633   psym->ecoff_sym.asym.value = value;
1634   psym->ecoff_sym.asym.st = (unsigned) type;
1635   psym->ecoff_sym.asym.sc = (unsigned) storage;
1636   psym->ecoff_sym.asym.index = indx;
1637
1638   /* If there is an associated symbol, we wait until the end of the
1639      assembly before deciding where to put the name (it may be just an
1640      external symbol).  Otherwise, this is just a debugging symbol and
1641      the name should go with the current file.  */
1642   if (sym_value == (symbolS *) NULL)
1643     psym->ecoff_sym.asym.iss = ((str == (const char *) NULL)
1644                                 ? 0
1645                                 : add_string (&cur_file_ptr->strings,
1646                                               cur_file_ptr->str_hash,
1647                                               str,
1648                                               &hash_ptr));
1649
1650   ++vp->num_allocated;
1651
1652   if (ECOFF_IS_STAB (&psym->ecoff_sym.asym))
1653     return psym;
1654
1655   /* Save the symbol within the hash table if this is a static
1656      item, and it has a name.  */
1657   if (hash_ptr != (shash_t *) NULL
1658       && (type == st_Global || type == st_Static || type == st_Label
1659           || type == st_Proc || type == st_StaticProc))
1660     hash_ptr->sym_ptr = psym;
1661
1662   /* push or pop a scope if appropriate.  */
1663   switch (type)
1664     {
1665     default:
1666       break;
1667
1668     case st_File:                       /* beginning of file */
1669     case st_Proc:                       /* procedure */
1670     case st_StaticProc:                 /* static procedure */
1671     case st_Block:                      /* begin scope */
1672       pscope = allocate_scope ();
1673       pscope->prev = cur_file_ptr->cur_scope;
1674       pscope->lsym = psym;
1675       pscope->type = type;
1676       cur_file_ptr->cur_scope = pscope;
1677
1678       if (type != st_File)
1679         scope_delta = 1;
1680
1681       /* For every block type except file, struct, union, or
1682          enumeration blocks, push a level on the tag stack.  We omit
1683          file types, so that tags can span file boundaries.  */
1684       if (type != st_File && storage != sc_Info)
1685         {
1686           ptag_head = allocate_thead ();
1687           ptag_head->first_tag = 0;
1688           ptag_head->prev = cur_tag_head;
1689           cur_tag_head = ptag_head;
1690         }
1691       break;
1692
1693     case st_End:
1694       pscope = cur_file_ptr->cur_scope;
1695       if (pscope == (scope_t *) NULL)
1696         as_fatal (_("too many st_End's"));
1697       else
1698         {
1699           st_t begin_type = (st_t) pscope->lsym->ecoff_sym.asym.st;
1700
1701           psym->begin_ptr = pscope->lsym;
1702
1703           if (begin_type != st_File)
1704             scope_delta = -1;
1705
1706           /* Except for file, structure, union, or enumeration end
1707              blocks remove all tags created within this scope.  */
1708           if (begin_type != st_File && storage != sc_Info)
1709             {
1710               ptag_head = cur_tag_head;
1711               cur_tag_head = ptag_head->prev;
1712
1713               for (ptag = ptag_head->first_tag;
1714                    ptag != (tag_t *) NULL;
1715                    ptag = ptag_next)
1716                 {
1717                   if (ptag->forward_ref != (forward_t *) NULL)
1718                     add_unknown_tag (ptag);
1719
1720                   ptag_next = ptag->same_block;
1721                   ptag->hash_ptr->tag_ptr = ptag->same_name;
1722                   free_tag (ptag);
1723                 }
1724
1725               free_thead (ptag_head);
1726             }
1727
1728           cur_file_ptr->cur_scope = pscope->prev;
1729
1730           /* block begin gets next sym #.  This is set when we know
1731              the symbol index value.  */
1732
1733           /* Functions push two or more aux words as follows:
1734              1st word: index+1 of the end symbol (filled in later).
1735              2nd word: type of the function (plus any aux words needed).
1736              Also, tie the external pointer back to the function begin symbol.  */
1737           if (begin_type != st_File && begin_type != st_Block)
1738             {
1739               symint_t ty;
1740               varray_t *svp = &cur_file_ptr->aux_syms;
1741
1742               pscope->lsym->ecoff_sym.asym.index = add_aux_sym_symint (0);
1743               pscope->lsym->index_ptr =
1744                 &svp->last->datum->aux[svp->objects_last_page - 1];
1745               ty = add_aux_sym_tir (&last_func_type_info,
1746                                     hash_no,
1747                                     &cur_file_ptr->thash_head[0]);
1748
1749 /* This seems to be unnecessary.  I'm not even sure what it is
1750  * intended to do.  It's from mips-tfile.
1751  *            if (last_func_sym_value != (symbolS *) NULL)
1752  *              {
1753  *                last_func_sym_value->ifd = cur_file_ptr->file_index;
1754  *                last_func_sym_value->index = ty;
1755  *              }
1756  */
1757             }
1758
1759           free_scope (pscope);
1760         }
1761     }
1762
1763   cur_file_ptr->nested_scopes += scope_delta;
1764
1765 #ifdef ECOFF_DEBUG
1766   if (debug && type != st_File
1767       && (debug > 2 || type == st_Block || type == st_End
1768           || type == st_Proc || type == st_StaticProc))
1769     {
1770       char *sc_str = sc_to_string (storage);
1771       char *st_str = st_to_string (type);
1772       int depth = cur_file_ptr->nested_scopes + (scope_delta < 0);
1773
1774       fprintf (stderr,
1775                "\tlsym\tv= %10ld, depth= %2d, sc= %-12s",
1776                value, depth, sc_str);
1777
1778       if (str_start && str_end_p1 - str_start > 0)
1779         fprintf (stderr, " st= %-11s name= %.*s\n",
1780                  st_str, str_end_p1 - str_start, str_start);
1781       else
1782         {
1783           unsigned long len = strlen (st_str);
1784           fprintf (stderr, " st= %.*s\n", len - 1, st_str);
1785         }
1786     }
1787 #endif
1788
1789   return psym;
1790 }
1791 \f
1792 /* Add an auxiliary symbol (passing a symint).  This is actually used
1793    for integral aux types, not just symints.  */
1794
1795 static symint_t
1796 add_aux_sym_symint (symint_t aux_word /* auxiliary information word */)
1797 {
1798   register varray_t *vp;
1799   register aux_t *aux_ptr;
1800
1801   if (cur_file_ptr == (efdr_t *) NULL)
1802     as_fatal (_("no current file pointer"));
1803
1804   vp = &cur_file_ptr->aux_syms;
1805
1806   if (vp->objects_last_page == vp->objects_per_page)
1807     add_varray_page (vp);
1808
1809   aux_ptr = &vp->last->datum->aux[vp->objects_last_page++];
1810   aux_ptr->type = aux_isym;
1811   aux_ptr->data.isym = aux_word;
1812
1813   return vp->num_allocated++;
1814 }
1815
1816 /* Add an auxiliary symbol (passing a file/symbol index combo).  */
1817
1818 static symint_t
1819 add_aux_sym_rndx (int file_index, symint_t sym_index)
1820 {
1821   register varray_t *vp;
1822   register aux_t *aux_ptr;
1823
1824   if (cur_file_ptr == (efdr_t *) NULL)
1825     as_fatal (_("no current file pointer"));
1826
1827   vp = &cur_file_ptr->aux_syms;
1828
1829   if (vp->objects_last_page == vp->objects_per_page)
1830     add_varray_page (vp);
1831
1832   aux_ptr = &vp->last->datum->aux[vp->objects_last_page++];
1833   aux_ptr->type = aux_rndx;
1834   aux_ptr->data.rndx.rfd   = file_index;
1835   aux_ptr->data.rndx.index = sym_index;
1836
1837   return vp->num_allocated++;
1838 }
1839 \f
1840 /* Add an auxiliary symbol (passing the basic type and possibly
1841    type qualifiers).  */
1842
1843 static symint_t
1844 add_aux_sym_tir (type_info_t *t,        /* current type information */
1845                  hash_state_t state,    /* whether to hash type or not */
1846                  thash_t **hash_tbl     /* pointer to hash table to use */)
1847 {
1848   register varray_t *vp;
1849   register aux_t *aux_ptr;
1850   static AUXU init_aux;
1851   symint_t ret;
1852   int i;
1853   AUXU aux;
1854
1855   if (cur_file_ptr == (efdr_t *) NULL)
1856     as_fatal (_("no current file pointer"));
1857
1858   vp = &cur_file_ptr->aux_syms;
1859
1860   aux = init_aux;
1861   aux.ti.bt = (int) t->basic_type;
1862   aux.ti.continued = 0;
1863   aux.ti.fBitfield = t->bitfield;
1864
1865   aux.ti.tq0 = (int) t->type_qualifiers[0];
1866   aux.ti.tq1 = (int) t->type_qualifiers[1];
1867   aux.ti.tq2 = (int) t->type_qualifiers[2];
1868   aux.ti.tq3 = (int) t->type_qualifiers[3];
1869   aux.ti.tq4 = (int) t->type_qualifiers[4];
1870   aux.ti.tq5 = (int) t->type_qualifiers[5];
1871
1872   /* For anything that adds additional information, we must not hash,
1873      so check here, and reset our state.  */
1874
1875   if (state != hash_no
1876       && (t->type_qualifiers[0] == tq_Array
1877           || t->type_qualifiers[1] == tq_Array
1878           || t->type_qualifiers[2] == tq_Array
1879           || t->type_qualifiers[3] == tq_Array
1880           || t->type_qualifiers[4] == tq_Array
1881           || t->type_qualifiers[5] == tq_Array
1882           || t->basic_type == bt_Struct
1883           || t->basic_type == bt_Union
1884           || t->basic_type == bt_Enum
1885           || t->bitfield
1886           || t->num_dims > 0))
1887     state = hash_no;
1888
1889   /* See if we can hash this type, and save some space, but some types
1890      can't be hashed (because they contain arrays or continuations),
1891      and others can be put into the hash list, but cannot use existing
1892      types because other aux entries precede this one.  */
1893
1894   if (state != hash_no)
1895     {
1896       register thash_t *hash_ptr;
1897       register symint_t hi;
1898
1899       hi = aux.isym & ((1 << HASHBITS) - 1);
1900       hi %= THASH_SIZE;
1901
1902       for (hash_ptr = hash_tbl[hi];
1903            hash_ptr != (thash_t *)0;
1904            hash_ptr = hash_ptr->next)
1905         {
1906           if (aux.isym == hash_ptr->type.isym)
1907             break;
1908         }
1909
1910       if (hash_ptr != (thash_t *) NULL && state == hash_yes)
1911         return hash_ptr->indx;
1912
1913       if (hash_ptr == (thash_t *) NULL)
1914         {
1915           hash_ptr = allocate_thash ();
1916           hash_ptr->next = hash_tbl[hi];
1917           hash_ptr->type = aux;
1918           hash_ptr->indx = vp->num_allocated;
1919           hash_tbl[hi] = hash_ptr;
1920         }
1921     }
1922
1923   /* Everything is set up, add the aux symbol.  */
1924   if (vp->objects_last_page == vp->objects_per_page)
1925     add_varray_page (vp);
1926
1927   aux_ptr = &vp->last->datum->aux[vp->objects_last_page++];
1928   aux_ptr->type = aux_tir;
1929   aux_ptr->data = aux;
1930
1931   ret = vp->num_allocated++;
1932
1933   /* Add bitfield length if it exists.
1934
1935      NOTE:  Mips documentation claims bitfield goes at the end of the
1936      AUX record, but the DECstation compiler emits it here.
1937      (This would only make a difference for enum bitfields.)
1938
1939      Also note:  We use the last size given since gcc may emit 2
1940      for an enum bitfield.  */
1941
1942   if (t->bitfield)
1943     (void) add_aux_sym_symint ((symint_t) t->sizes[t->num_sizes - 1]);
1944
1945   /* Add tag information if needed.  Structure, union, and enum
1946      references add 2 aux symbols: a [file index, symbol index]
1947      pointer to the structure type, and the current file index.  */
1948
1949   if (t->basic_type == bt_Struct
1950       || t->basic_type == bt_Union
1951       || t->basic_type == bt_Enum)
1952     {
1953       register symint_t file_index = t->tag_ptr->ifd;
1954       register localsym_t *sym = t->tag_ptr->sym;
1955       register forward_t *forward_ref = allocate_forward ();
1956
1957       if (sym != (localsym_t *) NULL)
1958         {
1959           forward_ref->next = sym->forward_ref;
1960           sym->forward_ref = forward_ref;
1961         }
1962       else
1963         {
1964           forward_ref->next = t->tag_ptr->forward_ref;
1965           t->tag_ptr->forward_ref = forward_ref;
1966         }
1967
1968       (void) add_aux_sym_rndx (ST_RFDESCAPE, indexNil);
1969       forward_ref->index_ptr
1970         = &vp->last->datum->aux[vp->objects_last_page - 1];
1971
1972       (void) add_aux_sym_symint (file_index);
1973       forward_ref->ifd_ptr
1974         = &vp->last->datum->aux[vp->objects_last_page - 1];
1975     }
1976
1977   /* Add information about array bounds if they exist.  */
1978   for (i = 0; i < t->num_dims; i++)
1979     {
1980       (void) add_aux_sym_rndx (ST_RFDESCAPE,
1981                                cur_file_ptr->int_type);
1982
1983       (void) add_aux_sym_symint (cur_file_ptr->file_index);     /* file index*/
1984       (void) add_aux_sym_symint ((symint_t) 0);                 /* low bound */
1985       (void) add_aux_sym_symint (t->dimensions[i] - 1);         /* high bound*/
1986       (void) add_aux_sym_symint ((t->dimensions[i] == 0)        /* stride */
1987                                  ? 0
1988                                  : (t->sizes[i] * 8) / t->dimensions[i]);
1989     };
1990
1991   /* NOTE:  Mips documentation claims that the bitfield width goes here.
1992      But it needs to be emitted earlier.  */
1993
1994   return ret;
1995 }
1996 \f
1997 /* Add a tag to the tag table (unless it already exists).  */
1998
1999 static tag_t *
2000 get_tag (const char *tag,       /* tag name */
2001          localsym_t *sym,       /* tag start block */
2002          bt_t basic_type        /* bt_Struct, bt_Union, or bt_Enum */)
2003 {
2004   shash_t *hash_ptr;
2005   const char *err;
2006   tag_t *tag_ptr;
2007
2008   if (cur_file_ptr == (efdr_t *) NULL)
2009     as_fatal (_("no current file pointer"));
2010
2011   hash_ptr = (shash_t *) hash_find (tag_hash, tag);
2012
2013   if (hash_ptr != (shash_t *) NULL
2014       && hash_ptr->tag_ptr != (tag_t *) NULL)
2015     {
2016       tag_ptr = hash_ptr->tag_ptr;
2017       if (sym != (localsym_t *) NULL)
2018         {
2019           tag_ptr->basic_type = basic_type;
2020           tag_ptr->ifd        = cur_file_ptr->file_index;
2021           tag_ptr->sym        = sym;
2022         }
2023       return tag_ptr;
2024     }
2025
2026   if (hash_ptr == (shash_t *) NULL)
2027     {
2028       char *perm;
2029
2030       perm = xstrdup (tag);
2031       hash_ptr = allocate_shash ();
2032       err = hash_insert (tag_hash, perm, (char *) hash_ptr);
2033       if (err)
2034         as_fatal (_("inserting \"%s\" into tag hash table: %s"),
2035                   tag, err);
2036       hash_ptr->string = perm;
2037     }
2038
2039   tag_ptr = allocate_tag ();
2040   tag_ptr->forward_ref  = (forward_t *) NULL;
2041   tag_ptr->hash_ptr     = hash_ptr;
2042   tag_ptr->same_name    = hash_ptr->tag_ptr;
2043   tag_ptr->basic_type   = basic_type;
2044   tag_ptr->sym          = sym;
2045   tag_ptr->ifd          = ((sym == (localsym_t *) NULL)
2046                            ? (symint_t) -1
2047                            : cur_file_ptr->file_index);
2048   tag_ptr->same_block   = cur_tag_head->first_tag;
2049
2050   cur_tag_head->first_tag = tag_ptr;
2051   hash_ptr->tag_ptr       = tag_ptr;
2052
2053   return tag_ptr;
2054 }
2055 \f
2056 /* Add an unknown {struct, union, enum} tag.  */
2057
2058 static void
2059 add_unknown_tag (tag_t *ptag /* pointer to tag information */)
2060 {
2061   shash_t *hash_ptr     = ptag->hash_ptr;
2062   char *name            = hash_ptr->string;
2063   localsym_t *sym;
2064   forward_t **pf;
2065
2066 #ifdef ECOFF_DEBUG
2067   if (debug > 1)
2068     {
2069       char *agg_type = "{unknown aggregate type}";
2070       switch (ptag->basic_type)
2071         {
2072         case bt_Struct: agg_type = "struct";    break;
2073         case bt_Union:  agg_type = "union";     break;
2074         case bt_Enum:   agg_type = "enum";      break;
2075         default:                                break;
2076         }
2077
2078       fprintf (stderr, "unknown %s %.*s found\n", agg_type,
2079                hash_ptr->len, name_start);
2080     }
2081 #endif
2082
2083   sym = add_ecoff_symbol (name,
2084                           st_Block,
2085                           sc_Info,
2086                           (symbolS *) NULL,
2087                           (bfd_vma) 0,
2088                           (symint_t) 0,
2089                           (symint_t) 0);
2090
2091   (void) add_ecoff_symbol (name,
2092                            st_End,
2093                            sc_Info,
2094                            (symbolS *) NULL,
2095                            (bfd_vma) 0,
2096                            (symint_t) 0,
2097                            (symint_t) 0);
2098
2099   for (pf = &sym->forward_ref; *pf != (forward_t *) NULL; pf = &(*pf)->next)
2100     ;
2101   *pf = ptag->forward_ref;
2102 }
2103 \f
2104 /* Add a procedure to the current file's list of procedures, and record
2105    this is the current procedure.  */
2106
2107 static void
2108 add_procedure (char *func /* func name */)
2109 {
2110   register varray_t *vp;
2111   register proc_t *new_proc_ptr;
2112   symbolS *sym;
2113
2114 #ifdef ECOFF_DEBUG
2115   if (debug)
2116     fputc ('\n', stderr);
2117 #endif
2118
2119   if (cur_file_ptr == (efdr_t *) NULL)
2120     as_fatal (_("no current file pointer"));
2121
2122   vp = &cur_file_ptr->procs;
2123
2124   if (vp->objects_last_page == vp->objects_per_page)
2125     add_varray_page (vp);
2126
2127   cur_proc_ptr = new_proc_ptr = &vp->last->datum->proc[vp->objects_last_page++];
2128
2129   if (first_proc_ptr == (proc_t *) NULL)
2130     first_proc_ptr = new_proc_ptr;
2131
2132   vp->num_allocated++;
2133
2134   new_proc_ptr->pdr.isym = -1;
2135   new_proc_ptr->pdr.iline = -1;
2136   new_proc_ptr->pdr.lnLow = -1;
2137   new_proc_ptr->pdr.lnHigh = -1;
2138
2139   /* Set the BSF_FUNCTION flag for the symbol.  */
2140   sym = symbol_find_or_make (func);
2141   symbol_get_bfdsym (sym)->flags |= BSF_FUNCTION;
2142
2143   /* Push the start of the function.  */
2144   new_proc_ptr->sym = add_ecoff_symbol ((const char *) NULL, st_Proc, sc_Text,
2145                                         sym, (bfd_vma) 0, (symint_t) 0,
2146                                         (symint_t) 0);
2147
2148   ++proc_cnt;
2149
2150   /* Fill in the linenos preceding the .ent, if any.  */
2151   if (noproc_lineno != (lineno_list_t *) NULL)
2152     {
2153       lineno_list_t *l;
2154
2155       for (l = noproc_lineno; l != (lineno_list_t *) NULL; l = l->next)
2156         l->proc = new_proc_ptr;
2157       *last_lineno_ptr = noproc_lineno;
2158       while (*last_lineno_ptr != NULL)
2159         {
2160           last_lineno = *last_lineno_ptr;
2161           last_lineno_ptr = &last_lineno->next;
2162         }
2163       noproc_lineno = (lineno_list_t *) NULL;
2164     }
2165 }
2166
2167 symbolS *
2168 ecoff_get_cur_proc_sym (void)
2169 {
2170   return (cur_proc_ptr ? cur_proc_ptr->sym->as_sym : NULL);
2171 }
2172 \f
2173 /* Add a new filename, and set up all of the file relative
2174    virtual arrays (strings, symbols, aux syms, etc.).  Record
2175    where the current file structure lives.  */
2176
2177 static void
2178 add_file (const char *file_name, int indx ATTRIBUTE_UNUSED, int fake)
2179 {
2180   register int first_ch;
2181   register efdr_t *fil_ptr;
2182
2183 #ifdef ECOFF_DEBUG
2184   if (debug)
2185     fprintf (stderr, "\tfile\t%.*s\n", len, file_start);
2186 #endif
2187
2188   /* If the file name is NULL, then no .file symbol appeared, and we
2189      want to use the actual file name.  */
2190   if (file_name == (const char *) NULL)
2191     {
2192       char *file;
2193
2194       if (first_file != (efdr_t *) NULL)
2195         as_fatal (_("fake .file after real one"));
2196       as_where (&file, (unsigned int *) NULL);
2197       file_name = (const char *) file;
2198
2199       /* Automatically generate ECOFF debugging information, since I
2200          think that's what other ECOFF assemblers do.  We don't do
2201          this if we see a .file directive with a string, since that
2202          implies that some sort of debugging information is being
2203          provided.  */
2204       if (! symbol_table_frozen && debug_type == DEBUG_UNSPECIFIED)
2205         debug_type = DEBUG_ECOFF;
2206     }
2207   else if (debug_type == DEBUG_UNSPECIFIED)
2208     debug_type = DEBUG_NONE;
2209
2210 #ifndef NO_LISTING
2211   if (listing)
2212     listing_source_file (file_name);
2213 #endif
2214
2215   current_stabs_filename = file_name;
2216
2217   /* If we're creating stabs, then we don't actually make a new FDR.
2218      Instead, we just create a stabs symbol.  */
2219   if (stabs_seen)
2220     {
2221       (void) add_ecoff_symbol (file_name, st_Nil, sc_Nil,
2222                                symbol_new ("L0\001", now_seg,
2223                                            (valueT) frag_now_fix (),
2224                                            frag_now),
2225                                (bfd_vma) 0, 0, ECOFF_MARK_STAB (N_SOL));
2226       return;
2227     }
2228
2229   first_ch = *file_name;
2230
2231   /* FIXME: We can't safely merge files which have line number
2232      information (fMerge will be zero in this case).  Otherwise, we
2233      get incorrect line number debugging info.  See for instance
2234      ecoff_build_lineno, which will end up setting all file->fdr.*
2235      fields multiple times, resulting in incorrect debug info.  In
2236      order to make this work right, all line number and symbol info
2237      for the same source file has to be adjacent in the object file,
2238      so that a single file descriptor can be used to point to them.
2239      This would require maintaining file specific lists of line
2240      numbers and symbols for each file, so that they can be merged
2241      together (or output together) when two .file pseudo-ops are
2242      merged into one file descriptor.  */
2243
2244   /* See if the file has already been created.  */
2245   for (fil_ptr = first_file;
2246        fil_ptr != (efdr_t *) NULL;
2247        fil_ptr = fil_ptr->next_file)
2248     {
2249       if (first_ch == fil_ptr->name[0]
2250           && strcmp (file_name, fil_ptr->name) == 0
2251           && fil_ptr->fdr.fMerge)
2252         {
2253           cur_file_ptr = fil_ptr;
2254           if (! fake)
2255             cur_file_ptr->fake = 0;
2256           break;
2257         }
2258     }
2259
2260   /* If this is a new file, create it.  */
2261   if (fil_ptr == (efdr_t *) NULL)
2262     {
2263       if (file_desc.objects_last_page == file_desc.objects_per_page)
2264         add_varray_page (&file_desc);
2265
2266       fil_ptr = cur_file_ptr =
2267         &file_desc.last->datum->file[file_desc.objects_last_page++];
2268       *fil_ptr = init_file;
2269
2270       fil_ptr->file_index = current_file_idx++;
2271       ++file_desc.num_allocated;
2272
2273       fil_ptr->fake = fake;
2274
2275       /* Allocate the string hash table.  */
2276       fil_ptr->str_hash = hash_new ();
2277
2278       /* Make sure 0 byte in string table is null  */
2279       add_string (&fil_ptr->strings,
2280                   fil_ptr->str_hash,
2281                   "",
2282                   (shash_t **)0);
2283
2284       if (strlen (file_name) > PAGE_USIZE - 2)
2285         as_fatal (_("filename goes over one page boundary"));
2286
2287       /* Push the start of the filename. We assume that the filename
2288          will be stored at string offset 1.  */
2289       (void) add_ecoff_symbol (file_name, st_File, sc_Text,
2290                                (symbolS *) NULL, (bfd_vma) 0,
2291                                (symint_t) 0, (symint_t) 0);
2292       fil_ptr->fdr.rss = 1;
2293       fil_ptr->name = &fil_ptr->strings.last->datum->byte[1];
2294
2295       /* Update the linked list of file descriptors.  */
2296       *last_file_ptr = fil_ptr;
2297       last_file_ptr = &fil_ptr->next_file;
2298
2299       /* Add void & int types to the file (void should be first to catch
2300          errant 0's within the index fields).  */
2301       fil_ptr->void_type = add_aux_sym_tir (&void_type_info,
2302                                             hash_yes,
2303                                             &cur_file_ptr->thash_head[0]);
2304
2305       fil_ptr->int_type = add_aux_sym_tir (&int_type_info,
2306                                            hash_yes,
2307                                            &cur_file_ptr->thash_head[0]);
2308     }
2309 }
2310
2311 /* This function is called when the assembler notices a preprocessor
2312    directive switching to a new file.  This will not happen in
2313    compiler output, only in hand coded assembler.  */
2314
2315 void
2316 ecoff_new_file (const char *name, int appfile ATTRIBUTE_UNUSED)
2317 {
2318   if (cur_file_ptr != NULL && strcmp (cur_file_ptr->name, name) == 0)
2319     return;
2320   add_file (name, 0, 0);
2321
2322   /* This is a hand coded assembler file, so automatically turn on
2323      debugging information.  */
2324   if (debug_type == DEBUG_UNSPECIFIED)
2325     debug_type = DEBUG_ECOFF;
2326 }
2327 \f
2328 #ifdef ECOFF_DEBUG
2329
2330 /* Convert storage class to string.  */
2331
2332 static char *
2333 sc_to_string (storage_class)
2334      sc_t storage_class;
2335 {
2336   switch (storage_class)
2337     {
2338     case sc_Nil:         return "Nil,";
2339     case sc_Text:        return "Text,";
2340     case sc_Data:        return "Data,";
2341     case sc_Bss:         return "Bss,";
2342     case sc_Register:    return "Register,";
2343     case sc_Abs:         return "Abs,";
2344     case sc_Undefined:   return "Undefined,";
2345     case sc_CdbLocal:    return "CdbLocal,";
2346     case sc_Bits:        return "Bits,";
2347     case sc_CdbSystem:   return "CdbSystem,";
2348     case sc_RegImage:    return "RegImage,";
2349     case sc_Info:        return "Info,";
2350     case sc_UserStruct:  return "UserStruct,";
2351     case sc_SData:       return "SData,";
2352     case sc_SBss:        return "SBss,";
2353     case sc_RData:       return "RData,";
2354     case sc_Var:         return "Var,";
2355     case sc_Common:      return "Common,";
2356     case sc_SCommon:     return "SCommon,";
2357     case sc_VarRegister: return "VarRegister,";
2358     case sc_Variant:     return "Variant,";
2359     case sc_SUndefined:  return "SUndefined,";
2360     case sc_Init:        return "Init,";
2361     case sc_Max:         return "Max,";
2362     }
2363
2364   return "???,";
2365 }
2366
2367 #endif /* DEBUG */
2368 \f
2369 #ifdef ECOFF_DEBUG
2370
2371 /* Convert symbol type to string.  */
2372
2373 static char *
2374 st_to_string (symbol_type)
2375      st_t symbol_type;
2376 {
2377   switch (symbol_type)
2378     {
2379     case st_Nil:        return "Nil,";
2380     case st_Global:     return "Global,";
2381     case st_Static:     return "Static,";
2382     case st_Param:      return "Param,";
2383     case st_Local:      return "Local,";
2384     case st_Label:      return "Label,";
2385     case st_Proc:       return "Proc,";
2386     case st_Block:      return "Block,";
2387     case st_End:        return "End,";
2388     case st_Member:     return "Member,";
2389     case st_Typedef:    return "Typedef,";
2390     case st_File:       return "File,";
2391     case st_RegReloc:   return "RegReloc,";
2392     case st_Forward:    return "Forward,";
2393     case st_StaticProc: return "StaticProc,";
2394     case st_Constant:   return "Constant,";
2395     case st_Str:        return "String,";
2396     case st_Number:     return "Number,";
2397     case st_Expr:       return "Expr,";
2398     case st_Type:       return "Type,";
2399     case st_Max:        return "Max,";
2400     }
2401
2402   return "???,";
2403 }
2404
2405 #endif /* DEBUG */
2406 \f
2407 /* Parse .begin directives which have a label as the first argument
2408    which gives the location of the start of the block.  */
2409
2410 void
2411 ecoff_directive_begin (int ignore ATTRIBUTE_UNUSED)
2412 {
2413   char *name;
2414   char name_end;
2415
2416   if (cur_file_ptr == (efdr_t *) NULL)
2417     {
2418       as_warn (_(".begin directive without a preceding .file directive"));
2419       demand_empty_rest_of_line ();
2420       return;
2421     }
2422
2423   if (cur_proc_ptr == (proc_t *) NULL)
2424     {
2425       as_warn (_(".begin directive without a preceding .ent directive"));
2426       demand_empty_rest_of_line ();
2427       return;
2428     }
2429
2430   name = input_line_pointer;
2431   name_end = get_symbol_end ();
2432
2433   (void) add_ecoff_symbol ((const char *) NULL, st_Block, sc_Text,
2434                            symbol_find_or_make (name),
2435                            (bfd_vma) 0, (symint_t) 0, (symint_t) 0);
2436
2437   *input_line_pointer = name_end;
2438
2439   /* The line number follows, but we don't use it.  */
2440   (void) get_absolute_expression ();
2441   demand_empty_rest_of_line ();
2442 }
2443 \f
2444 /* Parse .bend directives which have a label as the first argument
2445    which gives the location of the end of the block.  */
2446
2447 void
2448 ecoff_directive_bend (int ignore ATTRIBUTE_UNUSED)
2449 {
2450   char *name;
2451   char name_end;
2452   symbolS *endsym;
2453
2454   if (cur_file_ptr == (efdr_t *) NULL)
2455     {
2456       as_warn (_(".bend directive without a preceding .file directive"));
2457       demand_empty_rest_of_line ();
2458       return;
2459     }
2460
2461   if (cur_proc_ptr == (proc_t *) NULL)
2462     {
2463       as_warn (_(".bend directive without a preceding .ent directive"));
2464       demand_empty_rest_of_line ();
2465       return;
2466     }
2467
2468   name = input_line_pointer;
2469   name_end = get_symbol_end ();
2470
2471   /* The value is the distance between the .bend directive and the
2472      corresponding symbol.  We fill in the offset when we write out
2473      the symbol.  */
2474   endsym = symbol_find (name);
2475   if (endsym == (symbolS *) NULL)
2476     as_warn (_(".bend directive names unknown symbol"));
2477   else
2478     (void) add_ecoff_symbol ((const char *) NULL, st_End, sc_Text, endsym,
2479                              (bfd_vma) 0, (symint_t) 0, (symint_t) 0);
2480
2481   *input_line_pointer = name_end;
2482
2483   /* The line number follows, but we don't use it.  */
2484   (void) get_absolute_expression ();
2485   demand_empty_rest_of_line ();
2486 }
2487 \f
2488 /* COFF debugging information is provided as a series of directives
2489    (.def, .scl, etc.).  We build up information as we read the
2490    directives in the following static variables, and file it away when
2491    we reach the .endef directive.  */
2492 static char *coff_sym_name;
2493 static type_info_t coff_type;
2494 static sc_t coff_storage_class;
2495 static st_t coff_symbol_typ;
2496 static int coff_is_function;
2497 static char *coff_tag;
2498 static valueT coff_value;
2499 static symbolS *coff_sym_value;
2500 static bfd_vma coff_sym_addend;
2501 static int coff_inside_enumeration;
2502
2503 /* Handle a .def directive: start defining a symbol.  */
2504
2505 void
2506 ecoff_directive_def (int ignore ATTRIBUTE_UNUSED)
2507 {
2508   char *name;
2509   char name_end;
2510
2511   ecoff_debugging_seen = 1;
2512
2513   SKIP_WHITESPACE ();
2514
2515   name = input_line_pointer;
2516   name_end = get_symbol_end ();
2517
2518   if (coff_sym_name != (char *) NULL)
2519     as_warn (_(".def pseudo-op used inside of .def/.endef; ignored"));
2520   else if (*name == '\0')
2521     as_warn (_("empty symbol name in .def; ignored"));
2522   else
2523     {
2524       if (coff_sym_name != (char *) NULL)
2525         free (coff_sym_name);
2526       if (coff_tag != (char *) NULL)
2527         free (coff_tag);
2528       
2529       coff_sym_name = xstrdup (name);
2530       coff_type = type_info_init;
2531       coff_storage_class = sc_Nil;
2532       coff_symbol_typ = st_Nil;
2533       coff_is_function = 0;
2534       coff_tag = (char *) NULL;
2535       coff_value = 0;
2536       coff_sym_value = (symbolS *) NULL;
2537       coff_sym_addend = 0;
2538     }
2539
2540   *input_line_pointer = name_end;
2541
2542   demand_empty_rest_of_line ();
2543 }
2544
2545 /* Handle a .dim directive, used to give dimensions for an array.  The
2546    arguments are comma separated numbers.  mips-tfile assumes that
2547    there will not be more than 6 dimensions, and gdb won't read any
2548    more than that anyhow, so I will also make that assumption.  */
2549
2550 void
2551 ecoff_directive_dim (int ignore ATTRIBUTE_UNUSED)
2552 {
2553   int dimens[N_TQ];
2554   int i;
2555
2556   if (coff_sym_name == (char *) NULL)
2557     {
2558       as_warn (_(".dim pseudo-op used outside of .def/.endef; ignored"));
2559       demand_empty_rest_of_line ();
2560       return;
2561     }
2562
2563   for (i = 0; i < N_TQ; i++)
2564     {
2565       SKIP_WHITESPACE ();
2566       dimens[i] = get_absolute_expression ();
2567       if (*input_line_pointer == ',')
2568         ++input_line_pointer;
2569       else
2570         {
2571           if (*input_line_pointer != '\n'
2572               && *input_line_pointer != ';')
2573             as_warn (_("badly formed .dim directive"));
2574           break;
2575         }
2576     }
2577
2578   if (i == N_TQ)
2579     --i;
2580
2581   /* The dimensions are stored away in reverse order.  */
2582   for (; i >= 0; i--)
2583     {
2584       if (coff_type.num_dims >= N_TQ)
2585         {
2586           as_warn (_("too many .dim entries"));
2587           break;
2588         }
2589       coff_type.dimensions[coff_type.num_dims] = dimens[i];
2590       ++coff_type.num_dims;
2591     }
2592
2593   demand_empty_rest_of_line ();
2594 }
2595
2596 /* Handle a .scl directive, which sets the COFF storage class of the
2597    symbol.  */
2598
2599 void
2600 ecoff_directive_scl (int ignore ATTRIBUTE_UNUSED)
2601 {
2602   long val;
2603
2604   if (coff_sym_name == (char *) NULL)
2605     {
2606       as_warn (_(".scl pseudo-op used outside of .def/.endef; ignored"));
2607       demand_empty_rest_of_line ();
2608       return;
2609     }
2610
2611   val = get_absolute_expression ();
2612
2613   coff_symbol_typ = map_coff_sym_type[val];
2614   coff_storage_class = map_coff_storage[val];
2615
2616   demand_empty_rest_of_line ();
2617 }
2618
2619 /* Handle a .size directive.  For some reason mips-tfile.c thinks that
2620    .size can have multiple arguments.  We humor it, although gcc will
2621    never generate more than one argument.  */
2622
2623 void
2624 ecoff_directive_size (int ignore ATTRIBUTE_UNUSED)
2625 {
2626   int sizes[N_TQ];
2627   int i;
2628
2629   if (coff_sym_name == (char *) NULL)
2630     {
2631       as_warn (_(".size pseudo-op used outside of .def/.endef; ignored"));
2632       demand_empty_rest_of_line ();
2633       return;
2634     }
2635
2636   for (i = 0; i < N_TQ; i++)
2637     {
2638       SKIP_WHITESPACE ();
2639       sizes[i] = get_absolute_expression ();
2640       if (*input_line_pointer == ',')
2641         ++input_line_pointer;
2642       else
2643         {
2644           if (*input_line_pointer != '\n'
2645               && *input_line_pointer != ';')
2646             as_warn (_("badly formed .size directive"));
2647           break;
2648         }
2649     }
2650
2651   if (i == N_TQ)
2652     --i;
2653
2654   /* The sizes are stored away in reverse order.  */
2655   for (; i >= 0; i--)
2656     {
2657       if (coff_type.num_sizes >= N_TQ)
2658         {
2659           as_warn (_("too many .size entries"));
2660           break;
2661         }
2662       coff_type.sizes[coff_type.num_sizes] = sizes[i];
2663       ++coff_type.num_sizes;
2664     }
2665
2666   demand_empty_rest_of_line ();
2667 }
2668
2669 /* Handle the .type directive, which gives the COFF type of the
2670    symbol.  */
2671
2672 void
2673 ecoff_directive_type (int ignore ATTRIBUTE_UNUSED)
2674 {
2675   long val;
2676   tq_t *tq_ptr;
2677   tq_t *tq_shft;
2678
2679   if (coff_sym_name == (char *) NULL)
2680     {
2681       as_warn (_(".type pseudo-op used outside of .def/.endef; ignored"));
2682       demand_empty_rest_of_line ();
2683       return;
2684     }
2685
2686   val = get_absolute_expression ();
2687
2688   coff_type.orig_type = BTYPE (val);
2689   coff_type.basic_type = map_coff_types[coff_type.orig_type];
2690
2691   tq_ptr = &coff_type.type_qualifiers[N_TQ];
2692   while (val & ~N_BTMASK)
2693     {
2694       if (tq_ptr == &coff_type.type_qualifiers[0])
2695         {
2696           /* FIXME: We could handle this by setting the continued bit.
2697              There would still be a limit: the .type argument can not
2698              be infinite.  */
2699           as_warn (_("the type of %s is too complex; it will be simplified"),
2700                    coff_sym_name);
2701           break;
2702         }
2703       if (ISPTR (val))
2704         *--tq_ptr = tq_Ptr;
2705       else if (ISFCN (val))
2706         *--tq_ptr = tq_Proc;
2707       else if (ISARY (val))
2708         *--tq_ptr = tq_Array;
2709       else
2710         as_fatal (_("Unrecognized .type argument"));
2711
2712       val = DECREF (val);
2713     }
2714
2715   tq_shft = &coff_type.type_qualifiers[0];
2716   while (tq_ptr != &coff_type.type_qualifiers[N_TQ])
2717     *tq_shft++ = *tq_ptr++;
2718
2719   if (tq_shft != &coff_type.type_qualifiers[0] && tq_shft[-1] == tq_Proc)
2720     {
2721       /* If this is a function, ignore it, so that we don't get two
2722          entries (one from the .ent, and one for the .def that
2723          precedes it).  Save the type information so that the end
2724          block can properly add it after the begin block index.  For
2725          MIPS knows what reason, we must strip off the function type
2726          at this point.  */
2727       coff_is_function = 1;
2728       tq_shft[-1] = tq_Nil;
2729     }
2730
2731   while (tq_shft != &coff_type.type_qualifiers[N_TQ])
2732     *tq_shft++ = tq_Nil;
2733
2734   demand_empty_rest_of_line ();
2735 }
2736
2737 /* Handle the .tag directive, which gives the name of a structure,
2738    union or enum.  */
2739
2740 void
2741 ecoff_directive_tag (int ignore ATTRIBUTE_UNUSED)
2742 {
2743   char *name;
2744   char name_end;
2745
2746   if (coff_sym_name == (char *) NULL)
2747     {
2748       as_warn (_(".tag pseudo-op used outside of .def/.endef; ignored"));
2749       demand_empty_rest_of_line ();
2750       return;
2751     }
2752
2753   name = input_line_pointer;
2754   name_end = get_symbol_end ();
2755
2756   coff_tag = xstrdup (name);
2757
2758   *input_line_pointer = name_end;
2759
2760   demand_empty_rest_of_line ();
2761 }
2762
2763 /* Handle the .val directive, which gives the value of the symbol.  It
2764    may be the name of a static or global symbol.  */
2765
2766 void
2767 ecoff_directive_val (int ignore ATTRIBUTE_UNUSED)
2768 {
2769   expressionS exp;
2770
2771   if (coff_sym_name == (char *) NULL)
2772     {
2773       as_warn (_(".val pseudo-op used outside of .def/.endef; ignored"));
2774       demand_empty_rest_of_line ();
2775       return;
2776     }
2777
2778   expression (&exp);
2779   if (exp.X_op != O_constant && exp.X_op != O_symbol)
2780     {
2781       as_bad (_(".val expression is too complex"));
2782       demand_empty_rest_of_line ();
2783       return;
2784     }
2785
2786   if (exp.X_op == O_constant)
2787     coff_value = exp.X_add_number;
2788   else
2789     {
2790       coff_sym_value = exp.X_add_symbol;
2791       coff_sym_addend = exp.X_add_number;
2792     }
2793
2794   demand_empty_rest_of_line ();
2795 }
2796
2797 /* Handle the .endef directive, which terminates processing of COFF
2798    debugging information for a symbol.  */
2799
2800 void
2801 ecoff_directive_endef (int ignore ATTRIBUTE_UNUSED)
2802 {
2803   char *name;
2804   symint_t indx;
2805   localsym_t *sym;
2806
2807   demand_empty_rest_of_line ();
2808
2809   if (coff_sym_name == (char *) NULL)
2810     {
2811       as_warn (_(".endef pseudo-op used before .def; ignored"));
2812       return;
2813     }
2814
2815   name = coff_sym_name;
2816   coff_sym_name = (char *) NULL;
2817
2818   /* If the symbol is a static or external, we have already gotten the
2819      appropriate type and class, so make sure we don't override those
2820      values.  This is needed because there are some type and classes
2821      that are not in COFF, such as short data, etc.  */
2822   if (coff_sym_value != (symbolS *) NULL)
2823     {
2824       coff_symbol_typ = st_Nil;
2825       coff_storage_class = sc_Nil;
2826     }
2827
2828   coff_type.extra_sizes = coff_tag != (char *) NULL;
2829   if (coff_type.num_dims > 0)
2830     {
2831       int diff = coff_type.num_dims - coff_type.num_sizes;
2832       int i = coff_type.num_dims - 1;
2833       int j;
2834
2835       if (coff_type.num_sizes != 1 || diff < 0)
2836         {
2837           as_warn (_("bad COFF debugging information"));
2838           return;
2839         }
2840
2841       /* If this is an array, make sure the same number of dimensions
2842          and sizes were passed, creating extra sizes for multiply
2843          dimensioned arrays if not passed.  */
2844       coff_type.extra_sizes = 0;
2845       if (diff)
2846         {
2847           j = (sizeof (coff_type.sizes) / sizeof (coff_type.sizes[0])) - 1;
2848           while (j >= 0)
2849             {
2850               coff_type.sizes[j] = (((j - diff) >= 0)
2851                                     ? coff_type.sizes[j - diff]
2852                                     : 0);
2853               j--;
2854             }
2855
2856           coff_type.num_sizes = i + 1;
2857           for (i--; i >= 0; i--)
2858             coff_type.sizes[i] = (coff_type.dimensions[i + 1] == 0
2859                                   ? 0
2860                                   : (coff_type.sizes[i + 1]
2861                                      / coff_type.dimensions[i + 1]));
2862         }
2863     }
2864   else if (coff_symbol_typ == st_Member
2865            && coff_type.num_sizes - coff_type.extra_sizes == 1)
2866     {
2867       /* Is this a bitfield?  This is indicated by a structure member
2868          having a size field that isn't an array.  */
2869       coff_type.bitfield = 1;
2870     }
2871
2872   /* Except for enumeration members & begin/ending of scopes, put the
2873      type word in the aux. symbol table.  */
2874   if (coff_symbol_typ == st_Block || coff_symbol_typ == st_End)
2875     indx = 0;
2876   else if (coff_inside_enumeration)
2877     indx = cur_file_ptr->void_type;
2878   else
2879     {
2880       if (coff_type.basic_type == bt_Struct
2881           || coff_type.basic_type == bt_Union
2882           || coff_type.basic_type == bt_Enum)
2883         {
2884           if (coff_tag == (char *) NULL)
2885             {
2886               as_warn (_("no tag specified for %s"), name);
2887               return;
2888             }
2889
2890           coff_type.tag_ptr = get_tag (coff_tag, (localsym_t *) NULL,
2891                                        coff_type.basic_type);
2892         }
2893
2894       if (coff_is_function)
2895         {
2896           last_func_type_info = coff_type;
2897           last_func_sym_value = coff_sym_value;
2898           return;
2899         }
2900
2901       indx = add_aux_sym_tir (&coff_type,
2902                               hash_yes,
2903                               &cur_file_ptr->thash_head[0]);
2904     }
2905
2906   /* Do any last minute adjustments that are necessary.  */
2907   switch (coff_symbol_typ)
2908     {
2909     default:
2910       break;
2911
2912       /* For the beginning of structs, unions, and enumerations, the
2913          size info needs to be passed in the value field.  */
2914     case st_Block:
2915       if (coff_type.num_sizes - coff_type.num_dims - coff_type.extra_sizes
2916           != 1)
2917         {
2918           as_warn (_("bad COFF debugging information"));
2919           return;
2920         }
2921       else
2922         coff_value = coff_type.sizes[0];
2923
2924       coff_inside_enumeration = (coff_type.orig_type == T_ENUM);
2925       break;
2926
2927       /* For the end of structs, unions, and enumerations, omit the
2928          name which is always ".eos".  This needs to be done last, so
2929          that any error reporting above gives the correct name.  */
2930     case st_End:
2931       free (name);
2932       name = (char *) NULL;
2933       coff_value = 0;
2934       coff_inside_enumeration = 0;
2935       break;
2936
2937       /* Members of structures and unions that aren't bitfields, need
2938          to adjust the value from a byte offset to a bit offset.
2939          Members of enumerations do not have the value adjusted, and
2940          can be distinguished by indx == indexNil.  For enumerations,
2941          update the maximum enumeration value.  */
2942     case st_Member:
2943       if (! coff_type.bitfield && ! coff_inside_enumeration)
2944         coff_value *= 8;
2945
2946       break;
2947     }
2948
2949   /* Add the symbol.  */
2950   sym = add_ecoff_symbol (name,
2951                           coff_symbol_typ,
2952                           coff_storage_class,
2953                           coff_sym_value,
2954                           coff_sym_addend,
2955                           (symint_t) coff_value,
2956                           indx);
2957
2958   /* deal with struct, union, and enum tags.  */
2959   if (coff_symbol_typ == st_Block)
2960     {
2961       /* Create or update the tag information.  */
2962       tag_t *tag_ptr = get_tag (name,
2963                                 sym,
2964                                 coff_type.basic_type);
2965       forward_t **pf;
2966
2967       /* Remember any forward references.  */
2968       for (pf = &sym->forward_ref;
2969            *pf != (forward_t *) NULL;
2970            pf = &(*pf)->next)
2971         ;
2972       *pf = tag_ptr->forward_ref;
2973       tag_ptr->forward_ref = (forward_t *) NULL;
2974     }
2975 }
2976 \f
2977 /* Parse .end directives.  */
2978
2979 void
2980 ecoff_directive_end (int ignore ATTRIBUTE_UNUSED)
2981 {
2982   char *name;
2983   char name_end;
2984   symbolS *ent;
2985
2986   if (cur_file_ptr == (efdr_t *) NULL)
2987     {
2988       as_warn (_(".end directive without a preceding .file directive"));
2989       demand_empty_rest_of_line ();
2990       return;
2991     }
2992
2993   if (cur_proc_ptr == (proc_t *) NULL)
2994     {
2995       as_warn (_(".end directive without a preceding .ent directive"));
2996       demand_empty_rest_of_line ();
2997       return;
2998     }
2999
3000   name = input_line_pointer;
3001   name_end = get_symbol_end ();
3002
3003   if (name == input_line_pointer)
3004     {
3005       as_warn (_(".end directive has no name"));
3006       *input_line_pointer = name_end;
3007       demand_empty_rest_of_line ();
3008       return;
3009     }
3010
3011   /* The value is the distance between the .end directive and the
3012      corresponding symbol.  We create a fake symbol to hold the
3013      current location, and put in the offset when we write out the
3014      symbol.  */
3015   ent = symbol_find (name);
3016   if (ent == (symbolS *) NULL)
3017     as_warn (_(".end directive names unknown symbol"));
3018   else
3019     (void) add_ecoff_symbol ((const char *) NULL, st_End, sc_Text,
3020                              symbol_new ("L0\001", now_seg,
3021                                          (valueT) frag_now_fix (),
3022                                          frag_now),
3023                              (bfd_vma) 0, (symint_t) 0, (symint_t) 0);
3024
3025   cur_proc_ptr = (proc_t *) NULL;
3026
3027   *input_line_pointer = name_end;
3028   demand_empty_rest_of_line ();
3029 }
3030 \f
3031 /* Parse .ent directives.  */
3032
3033 void
3034 ecoff_directive_ent (int ignore ATTRIBUTE_UNUSED)
3035 {
3036   char *name;
3037   char name_end;
3038
3039   if (cur_file_ptr == (efdr_t *) NULL)
3040     add_file ((const char *) NULL, 0, 1);
3041
3042   if (cur_proc_ptr != (proc_t *) NULL)
3043     {
3044       as_warn (_("second .ent directive found before .end directive"));
3045       demand_empty_rest_of_line ();
3046       return;
3047     }
3048
3049   name = input_line_pointer;
3050   name_end = get_symbol_end ();
3051
3052   if (name == input_line_pointer)
3053     {
3054       as_warn (_(".ent directive has no name"));
3055       *input_line_pointer = name_end;
3056       demand_empty_rest_of_line ();
3057       return;
3058     }
3059
3060   add_procedure (name);
3061
3062   *input_line_pointer = name_end;
3063
3064   /* The .ent directive is sometimes followed by a number.  I'm not
3065      really sure what the number means.  I don't see any way to store
3066      the information in the PDR.  The Irix 4 assembler seems to ignore
3067      the information.  */
3068   SKIP_WHITESPACE ();
3069   if (*input_line_pointer == ',')
3070     {
3071       ++input_line_pointer;
3072       SKIP_WHITESPACE ();
3073     }
3074   if (ISDIGIT (*input_line_pointer)
3075       || *input_line_pointer == '-')
3076     (void) get_absolute_expression ();
3077
3078   demand_empty_rest_of_line ();
3079 }
3080 \f
3081 /* Parse .extern directives.  */
3082
3083 void
3084 ecoff_directive_extern (int ignore ATTRIBUTE_UNUSED)
3085 {
3086   char *name;
3087   int c;
3088   symbolS *symbolp;
3089   valueT size;
3090
3091   name = input_line_pointer;
3092   c = get_symbol_end ();
3093   symbolp = symbol_find_or_make (name);
3094   *input_line_pointer = c;
3095
3096   S_SET_EXTERNAL (symbolp);
3097
3098   if (*input_line_pointer == ',')
3099     ++input_line_pointer;
3100   size = get_absolute_expression ();
3101
3102   symbol_get_obj (symbolp)->ecoff_extern_size = size;
3103 }
3104 \f
3105 /* Parse .file directives.  */
3106
3107 void
3108 ecoff_directive_file (int ignore ATTRIBUTE_UNUSED)
3109 {
3110   int indx;
3111   char *name;
3112   int len;
3113
3114   if (cur_proc_ptr != (proc_t *) NULL)
3115     {
3116       as_warn (_("no way to handle .file within .ent/.end section"));
3117       demand_empty_rest_of_line ();
3118       return;
3119     }
3120
3121   indx = (int) get_absolute_expression ();
3122
3123   /* FIXME: we don't have to save the name here.  */
3124   name = demand_copy_C_string (&len);
3125
3126   add_file (name, indx - 1, 0);
3127
3128   demand_empty_rest_of_line ();
3129 }
3130 \f
3131 /* Parse .fmask directives.  */
3132
3133 void
3134 ecoff_directive_fmask (int ignore ATTRIBUTE_UNUSED)
3135 {
3136   long val;
3137
3138   if (cur_proc_ptr == (proc_t *) NULL)
3139     {
3140       as_warn (_(".fmask outside of .ent"));
3141       demand_empty_rest_of_line ();
3142       return;
3143     }
3144
3145   if (get_absolute_expression_and_terminator (&val) != ',')
3146     {
3147       as_warn (_("bad .fmask directive"));
3148       --input_line_pointer;
3149       demand_empty_rest_of_line ();
3150       return;
3151     }
3152
3153   cur_proc_ptr->pdr.fregmask = val;
3154   cur_proc_ptr->pdr.fregoffset = get_absolute_expression ();
3155
3156   demand_empty_rest_of_line ();
3157 }
3158 \f
3159 /* Parse .frame directives.  */
3160
3161 void
3162 ecoff_directive_frame (int ignore ATTRIBUTE_UNUSED)
3163 {
3164   long val;
3165
3166   if (cur_proc_ptr == (proc_t *) NULL)
3167     {
3168       as_warn (_(".frame outside of .ent"));
3169       demand_empty_rest_of_line ();
3170       return;
3171     }
3172
3173   cur_proc_ptr->pdr.framereg = tc_get_register (1);
3174
3175   SKIP_WHITESPACE ();
3176   if (*input_line_pointer++ != ','
3177       || get_absolute_expression_and_terminator (&val) != ',')
3178     {
3179       as_warn (_("bad .frame directive"));
3180       --input_line_pointer;
3181       demand_empty_rest_of_line ();
3182       return;
3183     }
3184
3185   cur_proc_ptr->pdr.frameoffset = val;
3186
3187   cur_proc_ptr->pdr.pcreg = tc_get_register (0);
3188
3189   /* Alpha-OSF1 adds "the offset of saved $a0 from $sp", according to
3190      Sandro.  I don't yet know where this value should be stored, if
3191      anywhere.  Don't call demand_empty_rest_of_line ().  */
3192   s_ignore (42);
3193 }
3194 \f
3195 /* Parse .mask directives.  */
3196
3197 void
3198 ecoff_directive_mask (int ignore ATTRIBUTE_UNUSED)
3199 {
3200   long val;
3201
3202   if (cur_proc_ptr == (proc_t *) NULL)
3203     {
3204       as_warn (_(".mask outside of .ent"));
3205       demand_empty_rest_of_line ();
3206       return;
3207     }
3208
3209   if (get_absolute_expression_and_terminator (&val) != ',')
3210     {
3211       as_warn (_("bad .mask directive"));
3212       --input_line_pointer;
3213       demand_empty_rest_of_line ();
3214       return;
3215     }
3216
3217   cur_proc_ptr->pdr.regmask = val;
3218   cur_proc_ptr->pdr.regoffset = get_absolute_expression ();
3219
3220   demand_empty_rest_of_line ();
3221 }
3222 \f
3223 /* Parse .loc directives.  */
3224
3225 void
3226 ecoff_directive_loc (int ignore ATTRIBUTE_UNUSED)
3227 {
3228   lineno_list_t *list;
3229   symint_t lineno;
3230
3231   if (cur_file_ptr == (efdr_t *) NULL)
3232     {
3233       as_warn (_(".loc before .file"));
3234       demand_empty_rest_of_line ();
3235       return;
3236     }
3237
3238   if (now_seg != text_section)
3239     {
3240       as_warn (_(".loc outside of .text"));
3241       demand_empty_rest_of_line ();
3242       return;
3243     }
3244
3245   /* Skip the file number.  */
3246   SKIP_WHITESPACE ();
3247   get_absolute_expression ();
3248   SKIP_WHITESPACE ();
3249
3250   lineno = get_absolute_expression ();
3251
3252 #ifndef NO_LISTING
3253   if (listing)
3254     listing_source_line (lineno);
3255 #endif
3256
3257   /* If we're building stabs, then output a special label rather than
3258      ECOFF line number info.  */
3259   if (stabs_seen)
3260     {
3261       (void) add_ecoff_symbol ((char *) NULL, st_Label, sc_Text,
3262                                symbol_new ("L0\001", now_seg,
3263                                            (valueT) frag_now_fix (),
3264                                            frag_now),
3265                                (bfd_vma) 0, 0, lineno);
3266       return;
3267     }
3268
3269   list = allocate_lineno_list ();
3270
3271   list->next = (lineno_list_t *) NULL;
3272   list->file = cur_file_ptr;
3273   list->proc = cur_proc_ptr;
3274   list->frag = frag_now;
3275   list->paddr = frag_now_fix ();
3276   list->lineno = lineno;
3277
3278   /* We don't want to merge files which have line numbers.  */
3279   cur_file_ptr->fdr.fMerge = 0;
3280
3281   /* A .loc directive will sometimes appear before a .ent directive,
3282      which means that cur_proc_ptr will be NULL here.  Arrange to
3283      patch this up.  */
3284   if (cur_proc_ptr == (proc_t *) NULL)
3285     {
3286       lineno_list_t **pl;
3287
3288       pl = &noproc_lineno;
3289       while (*pl != (lineno_list_t *) NULL)
3290         pl = &(*pl)->next;
3291       *pl = list;
3292     }
3293   else
3294     {
3295       last_lineno = list;
3296       *last_lineno_ptr = list;
3297       last_lineno_ptr = &list->next;
3298     }
3299 }
3300
3301 /* The MIPS assembler sometimes inserts nop instructions in the
3302    instruction stream.  When this happens, we must patch up the .loc
3303    information so that it points to the instruction after the nop.  */
3304
3305 void
3306 ecoff_fix_loc (fragS *old_frag, unsigned long old_frag_offset)
3307 {
3308   if (last_lineno != NULL
3309       && last_lineno->frag == old_frag
3310       && last_lineno->paddr == old_frag_offset)
3311     {
3312       last_lineno->frag = frag_now;
3313       last_lineno->paddr = frag_now_fix ();
3314     }
3315 }
3316 \f
3317 /* Make sure the @stabs symbol is emitted.  */
3318
3319 static void
3320 mark_stabs (int ignore ATTRIBUTE_UNUSED)
3321 {
3322   if (! stabs_seen)
3323     {
3324       /* Add a dummy @stabs dymbol.  */
3325       stabs_seen = 1;
3326       (void) add_ecoff_symbol (stabs_symbol, stNil, scInfo,
3327                                (symbolS *) NULL,
3328                                (bfd_vma) 0, (symint_t) -1,
3329                                ECOFF_MARK_STAB (0));
3330     }
3331 }
3332 \f
3333 /* Parse .weakext directives.  */
3334 #ifndef TC_MIPS
3335 /* For TC_MIPS use the version in tc-mips.c.  */
3336 void
3337 ecoff_directive_weakext (int ignore ATTRIBUTE_UNUSED)
3338 {
3339   char *name;
3340   int c;
3341   symbolS *symbolP;
3342   expressionS exp;
3343
3344   name = input_line_pointer;
3345   c = get_symbol_end ();
3346   symbolP = symbol_find_or_make (name);
3347   *input_line_pointer = c;
3348
3349   SKIP_WHITESPACE ();
3350
3351   if (*input_line_pointer == ',')
3352     {
3353       if (S_IS_DEFINED (symbolP))
3354         {
3355           as_bad (_("symbol `%s' is already defined"),
3356                   S_GET_NAME (symbolP));
3357           ignore_rest_of_line ();
3358           return;
3359         }
3360
3361       ++input_line_pointer;
3362       SKIP_WHITESPACE ();
3363       if (! is_end_of_line[(unsigned char) *input_line_pointer])
3364         {
3365           expression (&exp);
3366           if (exp.X_op != O_symbol)
3367             {
3368               as_bad (_("bad .weakext directive"));
3369               ignore_rest_of_line ();
3370               return;
3371             }
3372           symbol_set_value_expression (symbolP, &exp);
3373         }
3374     }
3375
3376   S_SET_WEAK (symbolP);
3377
3378   demand_empty_rest_of_line ();
3379 }
3380 #endif /* not TC_MIPS */
3381 \f
3382 /* Handle .stabs directives.  The actual parsing routine is done by a
3383    generic routine.  This routine is called via OBJ_PROCESS_STAB.
3384    When this is called, input_line_pointer will be pointing at the
3385    value field of the stab.
3386
3387    .stabs directives have five fields:
3388         "string"        a string, encoding the type information.
3389         code            a numeric code, defined in <stab.h>
3390         0               a zero
3391         desc            a zero or line number
3392         value           a numeric value or an address.
3393
3394     If the value is relocatable, we transform this into:
3395         iss             points as an index into string space
3396         value           value from lookup of the name
3397         st              st from lookup of the name
3398         sc              sc from lookup of the name
3399         index           code|CODE_MASK
3400
3401     If the value is not relocatable, we transform this into:
3402         iss             points as an index into string space
3403         value           value
3404         st              st_Nil
3405         sc              sc_Nil
3406         index           code|CODE_MASK
3407
3408     .stabn directives have four fields (string is null):
3409         code            a numeric code, defined in <stab.h>
3410         0               a zero
3411         desc            a zero or a line number
3412         value           a numeric value or an address.  */
3413
3414 void
3415 ecoff_stab (segT sec ATTRIBUTE_UNUSED,
3416             int what,
3417             const char *string,
3418             int type,
3419             int other,
3420             int desc)
3421 {
3422   efdr_t *save_file_ptr = cur_file_ptr;
3423   symbolS *sym;
3424   symint_t value;
3425   bfd_vma addend;
3426   st_t st;
3427   sc_t sc;
3428   symint_t indx;
3429   localsym_t *hold = NULL;
3430
3431   ecoff_debugging_seen = 1;
3432
3433   /* We don't handle .stabd.  */
3434   if (what != 's' && what != 'n')
3435     {
3436       as_bad (_(".stab%c is not supported"), what);
3437       return;
3438     }
3439
3440   /* A .stabn uses a null name, not an empty string.  */
3441   if (what == 'n')
3442     string = NULL;
3443
3444   /* We ignore the other field.  */
3445   if (other != 0)
3446     as_warn (_(".stab%c: ignoring non-zero other field"), what);
3447
3448   /* Make sure we have a current file.  */
3449   if (cur_file_ptr == (efdr_t *) NULL)
3450     {
3451       add_file ((const char *) NULL, 0, 1);
3452       save_file_ptr = cur_file_ptr;
3453     }
3454
3455   /* For stabs in ECOFF, the first symbol must be @stabs.  This is a
3456      signal to gdb.  */
3457   if (stabs_seen == 0)
3458     mark_stabs (0);
3459
3460   /* Line number stabs are handled differently, since they have two
3461      values, the line number and the address of the label.  We use the
3462      index field (aka desc) to hold the line number, and the value
3463      field to hold the address.  The symbol type is st_Label, which
3464      should be different from the other stabs, so that gdb can
3465      recognize it.  */
3466   if (type == N_SLINE)
3467     {
3468       SYMR dummy_symr;
3469       char *name;
3470       char name_end;
3471
3472 #ifndef NO_LISTING
3473       if (listing)
3474         listing_source_line ((unsigned int) desc);
3475 #endif
3476
3477       dummy_symr.index = desc;
3478       if (dummy_symr.index != desc)
3479         {
3480           as_warn (_("line number (%d) for .stab%c directive cannot fit in index field (20 bits)"),
3481                    desc, what);
3482           return;
3483         }
3484
3485       name = input_line_pointer;
3486       name_end = get_symbol_end ();
3487
3488       sym = symbol_find_or_make (name);
3489       *input_line_pointer = name_end;
3490
3491       value = 0;
3492       addend = 0;
3493       st = st_Label;
3494       sc = sc_Text;
3495       indx = desc;
3496     }
3497   else
3498     {
3499 #ifndef NO_LISTING
3500       if (listing && (type == N_SO || type == N_SOL))
3501         listing_source_file (string);
3502 #endif
3503
3504       if (ISDIGIT (*input_line_pointer)
3505           || *input_line_pointer == '-'
3506           || *input_line_pointer == '+')
3507         {
3508           st = st_Nil;
3509           sc = sc_Nil;
3510           sym = (symbolS *) NULL;
3511           value = get_absolute_expression ();
3512           addend = 0;
3513         }
3514       else if (! is_name_beginner ((unsigned char) *input_line_pointer))
3515         {
3516           as_warn (_("illegal .stab%c directive, bad character"), what);
3517           return;
3518         }
3519       else
3520         {
3521           expressionS exp;
3522
3523           sc = sc_Nil;
3524           st = st_Nil;
3525
3526           expression (&exp);
3527           if (exp.X_op == O_constant)
3528             {
3529               sym = NULL;
3530               value = exp.X_add_number;
3531               addend = 0;
3532             }
3533           else if (exp.X_op == O_symbol)
3534             {
3535               sym = exp.X_add_symbol;
3536               value = 0;
3537               addend = exp.X_add_number;
3538             }
3539           else
3540             {
3541               sym = make_expr_symbol (&exp);
3542               value = 0;
3543               addend = 0;
3544             }
3545         }
3546
3547       indx = ECOFF_MARK_STAB (type);
3548     }
3549
3550   /* Don't store the stabs symbol we are creating as the type of the
3551      ECOFF symbol.  We want to compute the type of the ECOFF symbol
3552      independently.  */
3553   if (sym != (symbolS *) NULL)
3554     hold = symbol_get_obj (sym)->ecoff_symbol;
3555
3556   (void) add_ecoff_symbol (string, st, sc, sym, addend, value, indx);
3557
3558   if (sym != (symbolS *) NULL)
3559     symbol_get_obj (sym)->ecoff_symbol = hold;
3560
3561   /* Restore normal file type.  */
3562   cur_file_ptr = save_file_ptr;
3563 }
3564 \f
3565 /* Frob an ECOFF symbol.  Small common symbols go into a special
3566    .scommon section rather than bfd_com_section.  */
3567
3568 void
3569 ecoff_frob_symbol (symbolS *sym)
3570 {
3571   if (S_IS_COMMON (sym)
3572       && S_GET_VALUE (sym) > 0
3573       && S_GET_VALUE (sym) <= bfd_get_gp_size (stdoutput))
3574     {
3575       static asection scom_section;
3576       static asymbol scom_symbol;
3577
3578       /* We must construct a fake section similar to bfd_com_section
3579          but with the name .scommon.  */
3580       if (scom_section.name == NULL)
3581         {
3582           scom_section = bfd_com_section;
3583           scom_section.name = ".scommon";
3584           scom_section.output_section = &scom_section;
3585           scom_section.symbol = &scom_symbol;
3586           scom_section.symbol_ptr_ptr = &scom_section.symbol;
3587           scom_symbol = *bfd_com_section.symbol;
3588           scom_symbol.name = ".scommon";
3589           scom_symbol.section = &scom_section;
3590         }
3591       S_SET_SEGMENT (sym, &scom_section);
3592     }
3593
3594   /* Double check weak symbols.  */
3595   if (S_IS_WEAK (sym))
3596     {
3597       if (S_IS_COMMON (sym))
3598         as_bad (_("symbol `%s' can not be both weak and common"),
3599                 S_GET_NAME (sym));
3600     }
3601 }
3602 \f
3603 /* Add bytes to the symbolic information buffer.  */
3604
3605 static char *
3606 ecoff_add_bytes (char **buf,
3607                  char **bufend,
3608                  char *bufptr,
3609                  unsigned long need)
3610 {
3611   unsigned long at;
3612   unsigned long want;
3613
3614   at = bufptr - *buf;
3615   need -= *bufend - bufptr;
3616   if (need < PAGE_SIZE)
3617     need = PAGE_SIZE;
3618   want = (*bufend - *buf) + need;
3619   *buf = xrealloc (*buf, want);
3620   *bufend = *buf + want;
3621   return *buf + at;
3622 }
3623
3624 /* Adjust the symbolic information buffer to the alignment required
3625    for the ECOFF target debugging information.  */
3626
3627 static unsigned long
3628 ecoff_padding_adjust (const struct ecoff_debug_swap *backend,
3629                       char **buf,
3630                       char **bufend,
3631                       unsigned long offset,
3632                       char **bufptrptr)
3633 {
3634   bfd_size_type align;
3635
3636   align = backend->debug_align;
3637   if ((offset & (align - 1)) != 0)
3638     {
3639       unsigned long add;
3640
3641       add = align - (offset & (align - 1));
3642       if ((unsigned long) (*bufend - (*buf + offset)) < add)
3643         (void) ecoff_add_bytes (buf, bufend, *buf + offset, add);
3644       memset (*buf + offset, 0, add);
3645       offset += add;
3646       if (bufptrptr != (char **) NULL)
3647         *bufptrptr = *buf + offset;
3648     }
3649
3650   return offset;
3651 }
3652
3653 /* Build the line number information.  */
3654
3655 static unsigned long
3656 ecoff_build_lineno (const struct ecoff_debug_swap *backend,
3657                     char **buf,
3658                     char **bufend,
3659                     unsigned long offset,
3660                     long *linecntptr)
3661 {
3662   char *bufptr;
3663   register lineno_list_t *l;
3664   lineno_list_t *last;
3665   efdr_t *file;
3666   proc_t *proc;
3667   unsigned long c;
3668   long iline;
3669   long totcount;
3670   lineno_list_t first;
3671   lineno_list_t *local_first_lineno = first_lineno;
3672
3673   if (linecntptr != (long *) NULL)
3674     *linecntptr = 0;
3675
3676   bufptr = *buf + offset;
3677
3678   file = (efdr_t *) NULL;
3679   proc = (proc_t *) NULL;
3680   last = (lineno_list_t *) NULL;
3681   c = offset;
3682   iline = 0;
3683   totcount = 0;
3684
3685   /* FIXME?  Now that MIPS embedded-PIC is gone, it may be safe to
3686      remove this code.  */
3687   /* For some reason the address of the first procedure is ignored
3688      when reading line numbers.  This doesn't matter if the address of
3689      the first procedure is 0, but when gcc is generating MIPS
3690      embedded PIC code, it will put strings in the .text section
3691      before the first procedure.  We cope by inserting a dummy line if
3692      the address of the first procedure is not 0.  Hopefully this
3693      won't screw things up too badly.
3694
3695      Don't do this for ECOFF assembly source line numbers.  They work
3696      without this extra attention.  */
3697   if (debug_type != DEBUG_ECOFF
3698       && first_proc_ptr != (proc_t *) NULL
3699       && local_first_lineno != (lineno_list_t *) NULL
3700       && ((S_GET_VALUE (first_proc_ptr->sym->as_sym)
3701            + bfd_get_section_vma (stdoutput,
3702                                   S_GET_SEGMENT (first_proc_ptr->sym->as_sym)))
3703           != 0))
3704     {
3705       first.file = local_first_lineno->file;
3706       first.proc = local_first_lineno->proc;
3707       first.frag = &zero_address_frag;
3708       first.paddr = 0;
3709       first.lineno = 0;
3710
3711       first.next = local_first_lineno;
3712       local_first_lineno = &first;
3713     }
3714
3715   for (l = local_first_lineno; l != (lineno_list_t *) NULL; l = l->next)
3716     {
3717       long count;
3718       long delta;
3719
3720       /* Get the offset to the memory address of the next line number
3721          (in words).  Do this first, so that we can skip ahead to the
3722          next useful line number entry.  */
3723       if (l->next == (lineno_list_t *) NULL)
3724         {
3725           /* We want a count of zero, but it will be decremented
3726              before it is used.  */
3727           count = 1;
3728         }
3729       else if (l->next->frag->fr_address + l->next->paddr
3730                > l->frag->fr_address + l->paddr)
3731         {
3732           count = ((l->next->frag->fr_address + l->next->paddr
3733                     - (l->frag->fr_address + l->paddr))
3734                    >> 2);
3735         }
3736       else
3737         {
3738           /* Don't change last, so we still get the right delta.  */
3739           continue;
3740         }
3741
3742       if (l->file != file || l->proc != proc)
3743         {
3744           if (l->proc != proc && proc != (proc_t *) NULL)
3745             proc->pdr.lnHigh = last->lineno;
3746           if (l->file != file && file != (efdr_t *) NULL)
3747             {
3748               file->fdr.cbLine = c - file->fdr.cbLineOffset;
3749               file->fdr.cline = totcount + count;
3750               if (linecntptr != (long *) NULL)
3751                 *linecntptr += totcount + count;
3752               totcount = 0;
3753             }
3754
3755           if (l->file != file)
3756             {
3757               efdr_t *last_file = file;
3758
3759               file = l->file;
3760               if (last_file != (efdr_t *) NULL)
3761                 file->fdr.ilineBase
3762                   = last_file->fdr.ilineBase + last_file->fdr.cline;
3763               else
3764                 file->fdr.ilineBase = 0;
3765               file->fdr.cbLineOffset = c;
3766             }
3767           if (l->proc != proc)
3768             {
3769               proc = l->proc;
3770               if (proc != (proc_t *) NULL)
3771                 {
3772                   proc->pdr.lnLow = l->lineno;
3773                   proc->pdr.cbLineOffset = c - file->fdr.cbLineOffset;
3774                   proc->pdr.iline = totcount;
3775                 }
3776             }
3777
3778           last = (lineno_list_t *) NULL;
3779         }
3780
3781       totcount += count;
3782
3783       /* Get the offset to this line number.  */
3784       if (last == (lineno_list_t *) NULL)
3785         delta = 0;
3786       else
3787         delta = l->lineno - last->lineno;
3788
3789       /* Put in the offset to this line number.  */
3790       while (delta != 0)
3791         {
3792           int setcount;
3793
3794           /* 1 is added to each count read.  */
3795           --count;
3796           /* We can only adjust the word count by up to 15 words at a
3797              time.  */
3798           if (count <= 0x0f)
3799             {
3800               setcount = count;
3801               count = 0;
3802             }
3803           else
3804             {
3805               setcount = 0x0f;
3806               count -= 0x0f;
3807             }
3808           if (delta >= -7 && delta <= 7)
3809             {
3810               if (bufptr >= *bufend)
3811                 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1);
3812               *bufptr++ = setcount + (delta << 4);
3813               delta = 0;
3814               ++c;
3815             }
3816           else
3817             {
3818               int set;
3819
3820               if (*bufend - bufptr < 3)
3821                 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 3);
3822               *bufptr++ = setcount + (8 << 4);
3823               if (delta < -0x8000)
3824                 {
3825                   set = -0x8000;
3826                   delta += 0x8000;
3827                 }
3828               else if (delta > 0x7fff)
3829                 {
3830                   set = 0x7fff;
3831                   delta -= 0x7fff;
3832                 }
3833               else
3834                 {
3835                   set = delta;
3836                   delta = 0;
3837                 }
3838               *bufptr++ = set >> 8;
3839               *bufptr++ = set & 0xffff;
3840               c += 3;
3841             }
3842         }
3843
3844       /* Finish adjusting the count.  */
3845       while (count > 0)
3846         {
3847           if (bufptr >= *bufend)
3848             bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1);
3849           /* 1 is added to each count read.  */
3850           --count;
3851           if (count > 0x0f)
3852             {
3853               *bufptr++ = 0x0f;
3854               count -= 0x0f;
3855             }
3856           else
3857             {
3858               *bufptr++ = count;
3859               count = 0;
3860             }
3861           ++c;
3862         }
3863
3864       ++iline;
3865       last = l;
3866     }
3867
3868   if (proc != (proc_t *) NULL)
3869     proc->pdr.lnHigh = last->lineno;
3870   if (file != (efdr_t *) NULL)
3871     {
3872       file->fdr.cbLine = c - file->fdr.cbLineOffset;
3873       file->fdr.cline = totcount;
3874     }
3875
3876   if (linecntptr != (long *) NULL)
3877     *linecntptr += totcount;
3878
3879   c = ecoff_padding_adjust (backend, buf, bufend, c, &bufptr);
3880
3881   return c;
3882 }
3883
3884 /* Build and swap out the symbols.  */
3885
3886 static unsigned long
3887 ecoff_build_symbols (const struct ecoff_debug_swap *backend,
3888                      char **buf,
3889                      char **bufend,
3890                      unsigned long offset)
3891 {
3892   const bfd_size_type external_sym_size = backend->external_sym_size;
3893   void (* const swap_sym_out) (bfd *, const SYMR *, void *)
3894     = backend->swap_sym_out;
3895   char *sym_out;
3896   long isym;
3897   vlinks_t *file_link;
3898
3899   sym_out = *buf + offset;
3900
3901   isym = 0;
3902
3903   /* The symbols are stored by file.  */
3904   for (file_link = file_desc.first;
3905        file_link != (vlinks_t *) NULL;
3906        file_link = file_link->next)
3907     {
3908       int ifilesym;
3909       int fil_cnt;
3910       efdr_t *fil_ptr;
3911       efdr_t *fil_end;
3912
3913       if (file_link->next == (vlinks_t *) NULL)
3914         fil_cnt = file_desc.objects_last_page;
3915       else
3916         fil_cnt = file_desc.objects_per_page;
3917       fil_ptr = file_link->datum->file;
3918       fil_end = fil_ptr + fil_cnt;
3919       for (; fil_ptr < fil_end; fil_ptr++)
3920         {
3921           vlinks_t *sym_link;
3922
3923           fil_ptr->fdr.isymBase = isym;
3924           ifilesym = isym;
3925           for (sym_link = fil_ptr->symbols.first;
3926                sym_link != (vlinks_t *) NULL;
3927                sym_link = sym_link->next)
3928             {
3929               int sym_cnt;
3930               localsym_t *sym_ptr;
3931               localsym_t *sym_end;
3932
3933               if (sym_link->next == (vlinks_t *) NULL)
3934                 sym_cnt = fil_ptr->symbols.objects_last_page;
3935               else
3936                 sym_cnt = fil_ptr->symbols.objects_per_page;
3937               sym_ptr = sym_link->datum->sym;
3938               sym_end = sym_ptr + sym_cnt;
3939               for (; sym_ptr < sym_end; sym_ptr++)
3940                 {
3941                   int local;
3942                   symbolS *as_sym;
3943                   forward_t *f;
3944
3945                   know (sym_ptr->file_ptr == fil_ptr);
3946
3947                   /* If there is no associated gas symbol, then this
3948                      is a pure debugging symbol.  We have already
3949                      added the name (if any) to fil_ptr->strings.
3950                      Otherwise we must decide whether this is an
3951                      external or a local symbol (actually, it may be
3952                      both if the local provides additional debugging
3953                      information for the external).  */
3954                   local = 1;