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