1 /* ECOFF debugging support.
2    Copyright (C) 1993-2016 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 
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 
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 
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 
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 
1473 /* This function should be called when the assembler starts up.  */
1474 
1475 void
ecoff_read_begin_hook(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
ecoff_symbol_new_hook(symbolS * symbolP)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
ecoff_symbol_clone_hook(symbolS * newsymP,symbolS * orgsymP)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 
1517 /* Add a page to a varray object.  */
1518 
1519 static void
add_varray_page(varray_t * vp)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 
1547 /* Add a string (and null pad) to one of the string tables.  */
1548 
1549 static symint_t
add_string(varray_t * vp,struct hash_control * hash_tbl,const char * str,shash_t ** ret_hash)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   unsigned long len = strlen (str);
1556   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       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 
1595 /* Add debugging information for a symbol.  */
1596 
1597 static localsym_t *
add_ecoff_symbol(const char * str,st_t type,sc_t storage,symbolS * sym_value,bfd_vma addend,symint_t value,symint_t indx)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   scope_t *pscope;
1608   thead_t *ptag_head;
1609   tag_t *ptag;
1610   tag_t *ptag_next;
1611   varray_t *vp;
1612   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 
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
add_aux_sym_symint(symint_t aux_word)1803 add_aux_sym_symint (symint_t aux_word /* auxiliary information word */)
1804 {
1805   varray_t *vp;
1806   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
add_aux_sym_rndx(int file_index,symint_t sym_index)1826 add_aux_sym_rndx (int file_index, symint_t sym_index)
1827 {
1828   varray_t *vp;
1829   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 
1847 /* Add an auxiliary symbol (passing the basic type and possibly
1848    type qualifiers).  */
1849 
1850 static symint_t
add_aux_sym_tir(type_info_t * t,hash_state_t state,thash_t ** hash_tbl)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   varray_t *vp;
1856   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       thash_t *hash_ptr;
1904       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       symint_t file_index = t->tag_ptr->ifd;
1961       localsym_t *sym = t->tag_ptr->sym;
1962       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 
2004 /* Add a tag to the tag table (unless it already exists).  */
2005 
2006 static tag_t *
get_tag(const char * tag,localsym_t * sym,bt_t basic_type)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 
2063 /* Add an unknown {struct, union, enum} tag.  */
2064 
2065 static void
add_unknown_tag(tag_t * ptag)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 
2111 /* Add a procedure to the current file's list of procedures, and record
2112    this is the current procedure.  */
2113 
2114 static void
add_procedure(char * func)2115 add_procedure (char *func /* func name */)
2116 {
2117   varray_t *vp;
2118   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 *
ecoff_get_cur_proc_sym(void)2175 ecoff_get_cur_proc_sym (void)
2176 {
2177   return (cur_proc_ptr ? cur_proc_ptr->sym->as_sym : NULL);
2178 }
2179 
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
add_file(const char * file_name,int indx ATTRIBUTE_UNUSED,int fake)2185 add_file (const char *file_name, int indx ATTRIBUTE_UNUSED, int fake)
2186 {
2187   int first_ch;
2188   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       if (first_file != (efdr_t *) NULL)
2200 	as_fatal (_("fake .file after real one"));
2201       file_name = as_where ((unsigned int *) NULL);
2202 
2203       /* Automatically generate ECOFF debugging information, since I
2204          think that's what other ECOFF assemblers do.  We don't do
2205          this if we see a .file directive with a string, since that
2206          implies that some sort of debugging information is being
2207          provided.  */
2208       if (! symbol_table_frozen && debug_type == DEBUG_UNSPECIFIED)
2209 	debug_type = DEBUG_ECOFF;
2210     }
2211   else if (debug_type == DEBUG_UNSPECIFIED)
2212     debug_type = DEBUG_NONE;
2213 
2214 #ifndef NO_LISTING
2215   if (listing)
2216     listing_source_file (file_name);
2217 #endif
2218 
2219   current_stabs_filename = file_name;
2220 
2221   /* If we're creating stabs, then we don't actually make a new FDR.
2222      Instead, we just create a stabs symbol.  */
2223   if (stabs_seen)
2224     {
2225       (void) add_ecoff_symbol (file_name, st_Nil, sc_Nil,
2226 			       symbol_new ("L0\001", now_seg,
2227 					   (valueT) frag_now_fix (),
2228 					   frag_now),
2229 			       (bfd_vma) 0, 0, ECOFF_MARK_STAB (N_SOL));
2230       return;
2231     }
2232 
2233   first_ch = *file_name;
2234 
2235   /* FIXME: We can't safely merge files which have line number
2236      information (fMerge will be zero in this case).  Otherwise, we
2237      get incorrect line number debugging info.  See for instance
2238      ecoff_build_lineno, which will end up setting all file->fdr.*
2239      fields multiple times, resulting in incorrect debug info.  In
2240      order to make this work right, all line number and symbol info
2241      for the same source file has to be adjacent in the object file,
2242      so that a single file descriptor can be used to point to them.
2243      This would require maintaining file specific lists of line
2244      numbers and symbols for each file, so that they can be merged
2245      together (or output together) when two .file pseudo-ops are
2246      merged into one file descriptor.  */
2247 
2248   /* See if the file has already been created.  */
2249   for (fil_ptr = first_file;
2250        fil_ptr != (efdr_t *) NULL;
2251        fil_ptr = fil_ptr->next_file)
2252     {
2253       if (first_ch == fil_ptr->name[0]
2254 	  && filename_cmp (file_name, fil_ptr->name) == 0
2255 	  && fil_ptr->fdr.fMerge)
2256 	{
2257 	  cur_file_ptr = fil_ptr;
2258 	  if (! fake)
2259 	    cur_file_ptr->fake = 0;
2260 	  break;
2261 	}
2262     }
2263 
2264   /* If this is a new file, create it.  */
2265   if (fil_ptr == (efdr_t *) NULL)
2266     {
2267       if (file_desc.objects_last_page == file_desc.objects_per_page)
2268 	add_varray_page (&file_desc);
2269 
2270       fil_ptr = cur_file_ptr =
2271 	&file_desc.last->datum->file[file_desc.objects_last_page++];
2272       *fil_ptr = init_file;
2273 
2274       fil_ptr->file_index = current_file_idx++;
2275       ++file_desc.num_allocated;
2276 
2277       fil_ptr->fake = fake;
2278 
2279       /* Allocate the string hash table.  */
2280       fil_ptr->str_hash = hash_new ();
2281 
2282       /* Make sure 0 byte in string table is null  */
2283       add_string (&fil_ptr->strings,
2284 		  fil_ptr->str_hash,
2285 		  "",
2286 		  (shash_t **)0);
2287 
2288       if (strlen (file_name) > PAGE_USIZE - 2)
2289 	as_fatal (_("filename goes over one page boundary"));
2290 
2291       /* Push the start of the filename. We assume that the filename
2292          will be stored at string offset 1.  */
2293       (void) add_ecoff_symbol (file_name, st_File, sc_Text,
2294 			       (symbolS *) NULL, (bfd_vma) 0,
2295 			       (symint_t) 0, (symint_t) 0);
2296       fil_ptr->fdr.rss = 1;
2297       fil_ptr->name = &fil_ptr->strings.last->datum->byte[1];
2298 
2299       /* Update the linked list of file descriptors.  */
2300       *last_file_ptr = fil_ptr;
2301       last_file_ptr = &fil_ptr->next_file;
2302 
2303       /* Add void & int types to the file (void should be first to catch
2304          errant 0's within the index fields).  */
2305       fil_ptr->void_type = add_aux_sym_tir (&void_type_info,
2306 					    hash_yes,
2307 					    &cur_file_ptr->thash_head[0]);
2308 
2309       fil_ptr->int_type = add_aux_sym_tir (&int_type_info,
2310 					   hash_yes,
2311 					   &cur_file_ptr->thash_head[0]);
2312     }
2313 }
2314 
2315 /* This function is called when the assembler notices a preprocessor
2316    directive switching to a new file.  This will not happen in
2317    compiler output, only in hand coded assembler.  */
2318 
2319 void
ecoff_new_file(const char * name,int appfile ATTRIBUTE_UNUSED)2320 ecoff_new_file (const char *name, int appfile ATTRIBUTE_UNUSED)
2321 {
2322   if (cur_file_ptr != NULL && filename_cmp (cur_file_ptr->name, name) == 0)
2323     return;
2324   add_file (name, 0, 0);
2325 
2326   /* This is a hand coded assembler file, so automatically turn on
2327      debugging information.  */
2328   if (debug_type == DEBUG_UNSPECIFIED)
2329     debug_type = DEBUG_ECOFF;
2330 }
2331 
2332 #ifdef ECOFF_DEBUG
2333 
2334 /* Convert storage class to string.  */
2335 
2336 static char *
sc_to_string(storage_class)2337 sc_to_string (storage_class)
2338      sc_t storage_class;
2339 {
2340   switch (storage_class)
2341     {
2342     case sc_Nil:	 return "Nil,";
2343     case sc_Text:	 return "Text,";
2344     case sc_Data:	 return "Data,";
2345     case sc_Bss:	 return "Bss,";
2346     case sc_Register:	 return "Register,";
2347     case sc_Abs:	 return "Abs,";
2348     case sc_Undefined:	 return "Undefined,";
2349     case sc_CdbLocal:	 return "CdbLocal,";
2350     case sc_Bits:	 return "Bits,";
2351     case sc_CdbSystem:	 return "CdbSystem,";
2352     case sc_RegImage:	 return "RegImage,";
2353     case sc_Info:	 return "Info,";
2354     case sc_UserStruct:	 return "UserStruct,";
2355     case sc_SData:	 return "SData,";
2356     case sc_SBss:	 return "SBss,";
2357     case sc_RData:	 return "RData,";
2358     case sc_Var:	 return "Var,";
2359     case sc_Common:	 return "Common,";
2360     case sc_SCommon:	 return "SCommon,";
2361     case sc_VarRegister: return "VarRegister,";
2362     case sc_Variant:	 return "Variant,";
2363     case sc_SUndefined:	 return "SUndefined,";
2364     case sc_Init:	 return "Init,";
2365     case sc_Max:	 return "Max,";
2366     }
2367 
2368   return "???,";
2369 }
2370 
2371 #endif /* DEBUG */
2372 
2373 #ifdef ECOFF_DEBUG
2374 
2375 /* Convert symbol type to string.  */
2376 
2377 static char *
st_to_string(symbol_type)2378 st_to_string (symbol_type)
2379      st_t symbol_type;
2380 {
2381   switch (symbol_type)
2382     {
2383     case st_Nil:	return "Nil,";
2384     case st_Global:	return "Global,";
2385     case st_Static:	return "Static,";
2386     case st_Param:	return "Param,";
2387     case st_Local:	return "Local,";
2388     case st_Label:	return "Label,";
2389     case st_Proc:	return "Proc,";
2390     case st_Block:	return "Block,";
2391     case st_End:	return "End,";
2392     case st_Member:	return "Member,";
2393     case st_Typedef:	return "Typedef,";
2394     case st_File:	return "File,";
2395     case st_RegReloc:	return "RegReloc,";
2396     case st_Forward:	return "Forward,";
2397     case st_StaticProc:	return "StaticProc,";
2398     case st_Constant:	return "Constant,";
2399     case st_Str:	return "String,";
2400     case st_Number:	return "Number,";
2401     case st_Expr:	return "Expr,";
2402     case st_Type:	return "Type,";
2403     case st_Max:	return "Max,";
2404     }
2405 
2406   return "???,";
2407 }
2408 
2409 #endif /* DEBUG */
2410 
2411 /* Parse .begin directives which have a label as the first argument
2412    which gives the location of the start of the block.  */
2413 
2414 void
ecoff_directive_begin(int ignore ATTRIBUTE_UNUSED)2415 ecoff_directive_begin (int ignore ATTRIBUTE_UNUSED)
2416 {
2417   char *name;
2418   char name_end;
2419 
2420   if (cur_file_ptr == (efdr_t *) NULL)
2421     {
2422       as_warn (_(".begin directive without a preceding .file directive"));
2423       demand_empty_rest_of_line ();
2424       return;
2425     }
2426 
2427   if (cur_proc_ptr == (proc_t *) NULL)
2428     {
2429       as_warn (_(".begin directive without a preceding .ent directive"));
2430       demand_empty_rest_of_line ();
2431       return;
2432     }
2433 
2434   name_end = get_symbol_name (&name);
2435 
2436   (void) add_ecoff_symbol ((const char *) NULL, st_Block, sc_Text,
2437 			   symbol_find_or_make (name),
2438 			   (bfd_vma) 0, (symint_t) 0, (symint_t) 0);
2439 
2440   (void) restore_line_pointer (name_end);
2441 
2442   /* The line number follows, but we don't use it.  */
2443   (void) get_absolute_expression ();
2444   demand_empty_rest_of_line ();
2445 }
2446 
2447 /* Parse .bend directives which have a label as the first argument
2448    which gives the location of the end of the block.  */
2449 
2450 void
ecoff_directive_bend(int ignore ATTRIBUTE_UNUSED)2451 ecoff_directive_bend (int ignore ATTRIBUTE_UNUSED)
2452 {
2453   char *name;
2454   char name_end;
2455   symbolS *endsym;
2456 
2457   if (cur_file_ptr == (efdr_t *) NULL)
2458     {
2459       as_warn (_(".bend directive without a preceding .file directive"));
2460       demand_empty_rest_of_line ();
2461       return;
2462     }
2463 
2464   if (cur_proc_ptr == (proc_t *) NULL)
2465     {
2466       as_warn (_(".bend directive without a preceding .ent directive"));
2467       demand_empty_rest_of_line ();
2468       return;
2469     }
2470 
2471   name_end = get_symbol_name (&name);
2472 
2473   /* The value is the distance between the .bend directive and the
2474      corresponding symbol.  We fill in the offset when we write out
2475      the symbol.  */
2476   endsym = symbol_find (name);
2477   if (endsym == (symbolS *) NULL)
2478     as_warn (_(".bend directive names unknown symbol"));
2479   else
2480     (void) add_ecoff_symbol ((const char *) NULL, st_End, sc_Text, endsym,
2481 			     (bfd_vma) 0, (symint_t) 0, (symint_t) 0);
2482 
2483   restore_line_pointer (name_end);
2484 
2485   /* The line number follows, but we don't use it.  */
2486   (void) get_absolute_expression ();
2487   demand_empty_rest_of_line ();
2488 }
2489 
2490 /* COFF debugging information is provided as a series of directives
2491    (.def, .scl, etc.).  We build up information as we read the
2492    directives in the following static variables, and file it away when
2493    we reach the .endef directive.  */
2494 static char *coff_sym_name;
2495 static type_info_t coff_type;
2496 static sc_t coff_storage_class;
2497 static st_t coff_symbol_typ;
2498 static int coff_is_function;
2499 static char *coff_tag;
2500 static valueT coff_value;
2501 static symbolS *coff_sym_value;
2502 static bfd_vma coff_sym_addend;
2503 static int coff_inside_enumeration;
2504 
2505 /* Handle a .def directive: start defining a symbol.  */
2506 
2507 void
ecoff_directive_def(int ignore ATTRIBUTE_UNUSED)2508 ecoff_directive_def (int ignore ATTRIBUTE_UNUSED)
2509 {
2510   char *name;
2511   char name_end;
2512 
2513   ecoff_debugging_seen = 1;
2514 
2515   SKIP_WHITESPACE ();
2516 
2517   name_end = get_symbol_name (&name);
2518 
2519   if (coff_sym_name != (char *) NULL)
2520     as_warn (_(".def pseudo-op used inside of .def/.endef; ignored"));
2521   else if (*name == '\0')
2522     as_warn (_("empty symbol name in .def; ignored"));
2523   else
2524     {
2525       if (coff_sym_name != (char *) NULL)
2526 	free (coff_sym_name);
2527       if (coff_tag != (char *) NULL)
2528 	free (coff_tag);
2529 
2530       coff_sym_name = xstrdup (name);
2531       coff_type = type_info_init;
2532       coff_storage_class = sc_Nil;
2533       coff_symbol_typ = st_Nil;
2534       coff_is_function = 0;
2535       coff_tag = (char *) NULL;
2536       coff_value = 0;
2537       coff_sym_value = (symbolS *) NULL;
2538       coff_sym_addend = 0;
2539     }
2540 
2541   restore_line_pointer (name_end);
2542 
2543   demand_empty_rest_of_line ();
2544 }
2545 
2546 /* Handle a .dim directive, used to give dimensions for an array.  The
2547    arguments are comma separated numbers.  mips-tfile assumes that
2548    there will not be more than 6 dimensions, and gdb won't read any
2549    more than that anyhow, so I will also make that assumption.  */
2550 
2551 void
ecoff_directive_dim(int ignore ATTRIBUTE_UNUSED)2552 ecoff_directive_dim (int ignore ATTRIBUTE_UNUSED)
2553 {
2554   int dimens[N_TQ];
2555   int i;
2556 
2557   if (coff_sym_name == (char *) NULL)
2558     {
2559       as_warn (_(".dim pseudo-op used outside of .def/.endef; ignored"));
2560       demand_empty_rest_of_line ();
2561       return;
2562     }
2563 
2564   for (i = 0; i < N_TQ; i++)
2565     {
2566       SKIP_WHITESPACE ();
2567       dimens[i] = get_absolute_expression ();
2568       if (*input_line_pointer == ',')
2569 	++input_line_pointer;
2570       else
2571 	{
2572 	  if (*input_line_pointer != '\n'
2573 	      && *input_line_pointer != ';')
2574 	    as_warn (_("badly formed .dim directive"));
2575 	  break;
2576 	}
2577     }
2578 
2579   if (i == N_TQ)
2580     --i;
2581 
2582   /* The dimensions are stored away in reverse order.  */
2583   for (; i >= 0; i--)
2584     {
2585       if (coff_type.num_dims >= N_TQ)
2586 	{
2587 	  as_warn (_("too many .dim entries"));
2588 	  break;
2589 	}
2590       coff_type.dimensions[coff_type.num_dims] = dimens[i];
2591       ++coff_type.num_dims;
2592     }
2593 
2594   demand_empty_rest_of_line ();
2595 }
2596 
2597 /* Handle a .scl directive, which sets the COFF storage class of the
2598    symbol.  */
2599 
2600 void
ecoff_directive_scl(int ignore ATTRIBUTE_UNUSED)2601 ecoff_directive_scl (int ignore ATTRIBUTE_UNUSED)
2602 {
2603   long val;
2604 
2605   if (coff_sym_name == (char *) NULL)
2606     {
2607       as_warn (_(".scl pseudo-op used outside of .def/.endef; ignored"));
2608       demand_empty_rest_of_line ();
2609       return;
2610     }
2611 
2612   val = get_absolute_expression ();
2613 
2614   coff_symbol_typ = map_coff_sym_type[val];
2615   coff_storage_class = map_coff_storage[val];
2616 
2617   demand_empty_rest_of_line ();
2618 }
2619 
2620 /* Handle a .size directive.  For some reason mips-tfile.c thinks that
2621    .size can have multiple arguments.  We humor it, although gcc will
2622    never generate more than one argument.  */
2623 
2624 void
ecoff_directive_size(int ignore ATTRIBUTE_UNUSED)2625 ecoff_directive_size (int ignore ATTRIBUTE_UNUSED)
2626 {
2627   int sizes[N_TQ];
2628   int i;
2629 
2630   if (coff_sym_name == (char *) NULL)
2631     {
2632       as_warn (_(".size pseudo-op used outside of .def/.endef; ignored"));
2633       demand_empty_rest_of_line ();
2634       return;
2635     }
2636 
2637   for (i = 0; i < N_TQ; i++)
2638     {
2639       SKIP_WHITESPACE ();
2640       sizes[i] = get_absolute_expression ();
2641       if (*input_line_pointer == ',')
2642 	++input_line_pointer;
2643       else
2644 	{
2645 	  if (*input_line_pointer != '\n'
2646 	      && *input_line_pointer != ';')
2647 	    as_warn (_("badly formed .size directive"));
2648 	  break;
2649 	}
2650     }
2651 
2652   if (i == N_TQ)
2653     --i;
2654 
2655   /* The sizes are stored away in reverse order.  */
2656   for (; i >= 0; i--)
2657     {
2658       if (coff_type.num_sizes >= N_TQ)
2659 	{
2660 	  as_warn (_("too many .size entries"));
2661 	  break;
2662 	}
2663       coff_type.sizes[coff_type.num_sizes] = sizes[i];
2664       ++coff_type.num_sizes;
2665     }
2666 
2667   demand_empty_rest_of_line ();
2668 }
2669 
2670 /* Handle the .type directive, which gives the COFF type of the
2671    symbol.  */
2672 
2673 void
ecoff_directive_type(int ignore ATTRIBUTE_UNUSED)2674 ecoff_directive_type (int ignore ATTRIBUTE_UNUSED)
2675 {
2676   long val;
2677   tq_t *tq_ptr;
2678   tq_t *tq_shft;
2679 
2680   if (coff_sym_name == (char *) NULL)
2681     {
2682       as_warn (_(".type pseudo-op used outside of .def/.endef; ignored"));
2683       demand_empty_rest_of_line ();
2684       return;
2685     }
2686 
2687   val = get_absolute_expression ();
2688 
2689   coff_type.orig_type = BTYPE (val);
2690   coff_type.basic_type = map_coff_types[coff_type.orig_type];
2691 
2692   tq_ptr = &coff_type.type_qualifiers[N_TQ];
2693   while (val & ~N_BTMASK)
2694     {
2695       if (tq_ptr == &coff_type.type_qualifiers[0])
2696 	{
2697 	  /* FIXME: We could handle this by setting the continued bit.
2698 	     There would still be a limit: the .type argument can not
2699 	     be infinite.  */
2700 	  as_warn (_("the type of %s is too complex; it will be simplified"),
2701 		   coff_sym_name);
2702 	  break;
2703 	}
2704       if (ISPTR (val))
2705 	*--tq_ptr = tq_Ptr;
2706       else if (ISFCN (val))
2707 	*--tq_ptr = tq_Proc;
2708       else if (ISARY (val))
2709 	*--tq_ptr = tq_Array;
2710       else
2711 	as_fatal (_("Unrecognized .type argument"));
2712 
2713       val = DECREF (val);
2714     }
2715 
2716   tq_shft = &coff_type.type_qualifiers[0];
2717   while (tq_ptr != &coff_type.type_qualifiers[N_TQ])
2718     *tq_shft++ = *tq_ptr++;
2719 
2720   if (tq_shft != &coff_type.type_qualifiers[0] && tq_shft[-1] == tq_Proc)
2721     {
2722       /* If this is a function, ignore it, so that we don't get two
2723          entries (one from the .ent, and one for the .def that
2724          precedes it).  Save the type information so that the end
2725          block can properly add it after the begin block index.  For
2726          MIPS knows what reason, we must strip off the function type
2727          at this point.  */
2728       coff_is_function = 1;
2729       tq_shft[-1] = tq_Nil;
2730     }
2731 
2732   while (tq_shft != &coff_type.type_qualifiers[N_TQ])
2733     *tq_shft++ = tq_Nil;
2734 
2735   demand_empty_rest_of_line ();
2736 }
2737 
2738 /* Handle the .tag directive, which gives the name of a structure,
2739    union or enum.  */
2740 
2741 void
ecoff_directive_tag(int ignore ATTRIBUTE_UNUSED)2742 ecoff_directive_tag (int ignore ATTRIBUTE_UNUSED)
2743 {
2744   char *name;
2745   char name_end;
2746 
2747   if (coff_sym_name == (char *) NULL)
2748     {
2749       as_warn (_(".tag pseudo-op used outside of .def/.endef; ignored"));
2750       demand_empty_rest_of_line ();
2751       return;
2752     }
2753 
2754   name_end = get_symbol_name (&name);
2755 
2756   coff_tag = xstrdup (name);
2757 
2758   (void) restore_line_pointer (name_end);
2759 
2760   demand_empty_rest_of_line ();
2761 }
2762 
2763 /* Handle the .val directive, which gives the value of the symbol.  It
2764    may be the name of a static or global symbol.  */
2765 
2766 void
ecoff_directive_val(int ignore ATTRIBUTE_UNUSED)2767 ecoff_directive_val (int ignore ATTRIBUTE_UNUSED)
2768 {
2769   expressionS exp;
2770 
2771   if (coff_sym_name == (char *) NULL)
2772     {
2773       as_warn (_(".val pseudo-op used outside of .def/.endef; ignored"));
2774       demand_empty_rest_of_line ();
2775       return;
2776     }
2777 
2778   expression (&exp);
2779   if (exp.X_op != O_constant && exp.X_op != O_symbol)
2780     {
2781       as_bad (_(".val expression is too complex"));
2782       demand_empty_rest_of_line ();
2783       return;
2784     }
2785 
2786   if (exp.X_op == O_constant)
2787     coff_value = exp.X_add_number;
2788   else
2789     {
2790       coff_sym_value = exp.X_add_symbol;
2791       coff_sym_addend = exp.X_add_number;
2792     }
2793 
2794   demand_empty_rest_of_line ();
2795 }
2796 
2797 /* Handle the .endef directive, which terminates processing of COFF
2798    debugging information for a symbol.  */
2799 
2800 void
ecoff_directive_endef(int ignore ATTRIBUTE_UNUSED)2801 ecoff_directive_endef (int ignore ATTRIBUTE_UNUSED)
2802 {
2803   char *name;
2804   symint_t indx;
2805   localsym_t *sym;
2806 
2807   demand_empty_rest_of_line ();
2808 
2809   if (coff_sym_name == (char *) NULL)
2810     {
2811       as_warn (_(".endef pseudo-op used before .def; ignored"));
2812       return;
2813     }
2814 
2815   name = coff_sym_name;
2816   coff_sym_name = (char *) NULL;
2817 
2818   /* If the symbol is a static or external, we have already gotten the
2819      appropriate type and class, so make sure we don't override those
2820      values.  This is needed because there are some type and classes
2821      that are not in COFF, such as short data, etc.  */
2822   if (coff_sym_value != (symbolS *) NULL)
2823     {
2824       coff_symbol_typ = st_Nil;
2825       coff_storage_class = sc_Nil;
2826     }
2827 
2828   coff_type.extra_sizes = coff_tag != (char *) NULL;
2829   if (coff_type.num_dims > 0)
2830     {
2831       int diff = coff_type.num_dims - coff_type.num_sizes;
2832       int i = coff_type.num_dims - 1;
2833       int j;
2834 
2835       if (coff_type.num_sizes != 1 || diff < 0)
2836 	{
2837 	  as_warn (_("bad COFF debugging information"));
2838 	  return;
2839 	}
2840 
2841       /* If this is an array, make sure the same number of dimensions
2842          and sizes were passed, creating extra sizes for multiply
2843          dimensioned arrays if not passed.  */
2844       coff_type.extra_sizes = 0;
2845       if (diff)
2846 	{
2847 	  j = (sizeof (coff_type.sizes) / sizeof (coff_type.sizes[0])) - 1;
2848 	  while (j >= 0)
2849 	    {
2850 	      coff_type.sizes[j] = (((j - diff) >= 0)
2851 				    ? coff_type.sizes[j - diff]
2852 				    : 0);
2853 	      j--;
2854 	    }
2855 
2856 	  coff_type.num_sizes = i + 1;
2857 	  for (i--; i >= 0; i--)
2858 	    coff_type.sizes[i] = (coff_type.dimensions[i + 1] == 0
2859 				  ? 0
2860 				  : (coff_type.sizes[i + 1]
2861 				     / coff_type.dimensions[i + 1]));
2862 	}
2863     }
2864   else if (coff_symbol_typ == st_Member
2865 	   && coff_type.num_sizes - coff_type.extra_sizes == 1)
2866     {
2867       /* Is this a bitfield?  This is indicated by a structure member
2868          having a size field that isn't an array.  */
2869       coff_type.bitfield = 1;
2870     }
2871 
2872   /* Except for enumeration members & begin/ending of scopes, put the
2873      type word in the aux. symbol table.  */
2874   if (coff_symbol_typ == st_Block || coff_symbol_typ == st_End)
2875     indx = 0;
2876   else if (coff_inside_enumeration)
2877     indx = cur_file_ptr->void_type;
2878   else
2879     {
2880       if (coff_type.basic_type == bt_Struct
2881 	  || coff_type.basic_type == bt_Union
2882 	  || coff_type.basic_type == bt_Enum)
2883 	{
2884 	  if (coff_tag == (char *) NULL)
2885 	    {
2886 	      as_warn (_("no tag specified for %s"), name);
2887 	      return;
2888 	    }
2889 
2890 	  coff_type.tag_ptr = get_tag (coff_tag, (localsym_t *) NULL,
2891 				       coff_type.basic_type);
2892 	}
2893 
2894       if (coff_is_function)
2895 	{
2896 	  last_func_type_info = coff_type;
2897 	  last_func_sym_value = coff_sym_value;
2898 	  return;
2899 	}
2900 
2901       indx = add_aux_sym_tir (&coff_type,
2902 			      hash_yes,
2903 			      &cur_file_ptr->thash_head[0]);
2904     }
2905 
2906   /* Do any last minute adjustments that are necessary.  */
2907   switch (coff_symbol_typ)
2908     {
2909     default:
2910       break;
2911 
2912       /* For the beginning of structs, unions, and enumerations, the
2913          size info needs to be passed in the value field.  */
2914     case st_Block:
2915       if (coff_type.num_sizes - coff_type.num_dims - coff_type.extra_sizes
2916 	  != 1)
2917 	{
2918 	  as_warn (_("bad COFF debugging information"));
2919 	  return;
2920 	}
2921       else
2922 	coff_value = coff_type.sizes[0];
2923 
2924       coff_inside_enumeration = (coff_type.orig_type == T_ENUM);
2925       break;
2926 
2927       /* For the end of structs, unions, and enumerations, omit the
2928          name which is always ".eos".  This needs to be done last, so
2929          that any error reporting above gives the correct name.  */
2930     case st_End:
2931       free (name);
2932       name = (char *) NULL;
2933       coff_value = 0;
2934       coff_inside_enumeration = 0;
2935       break;
2936 
2937       /* Members of structures and unions that aren't bitfields, need
2938          to adjust the value from a byte offset to a bit offset.
2939          Members of enumerations do not have the value adjusted, and
2940          can be distinguished by indx == indexNil.  For enumerations,
2941          update the maximum enumeration value.  */
2942     case st_Member:
2943       if (! coff_type.bitfield && ! coff_inside_enumeration)
2944 	coff_value *= 8;
2945 
2946       break;
2947     }
2948 
2949   /* Add the symbol.  */
2950   sym = add_ecoff_symbol (name,
2951 			  coff_symbol_typ,
2952 			  coff_storage_class,
2953 			  coff_sym_value,
2954 			  coff_sym_addend,
2955 			  (symint_t) coff_value,
2956 			  indx);
2957 
2958   /* deal with struct, union, and enum tags.  */
2959   if (coff_symbol_typ == st_Block)
2960     {
2961       /* Create or update the tag information.  */
2962       tag_t *tag_ptr = get_tag (name,
2963 				sym,
2964 				coff_type.basic_type);
2965       forward_t **pf;
2966 
2967       /* Remember any forward references.  */
2968       for (pf = &sym->forward_ref;
2969 	   *pf != (forward_t *) NULL;
2970 	   pf = &(*pf)->next)
2971 	;
2972       *pf = tag_ptr->forward_ref;
2973       tag_ptr->forward_ref = (forward_t *) NULL;
2974     }
2975 }
2976 
2977 /* Parse .end directives.  */
2978 
2979 void
ecoff_directive_end(int ignore ATTRIBUTE_UNUSED)2980 ecoff_directive_end (int ignore ATTRIBUTE_UNUSED)
2981 {
2982   char *name;
2983   char name_end;
2984   symbolS *ent;
2985 
2986   if (cur_file_ptr == (efdr_t *) NULL)
2987     {
2988       as_warn (_(".end directive without a preceding .file directive"));
2989       demand_empty_rest_of_line ();
2990       return;
2991     }
2992 
2993   if (cur_proc_ptr == (proc_t *) NULL)
2994     {
2995       as_warn (_(".end directive without a preceding .ent directive"));
2996       demand_empty_rest_of_line ();
2997       return;
2998     }
2999 
3000   name_end = get_symbol_name (&name);
3001 
3002   if (name == input_line_pointer)
3003     {
3004       as_warn (_(".end directive has no name"));
3005       (void) restore_line_pointer (name_end);
3006       demand_empty_rest_of_line ();
3007       return;
3008     }
3009 
3010   /* The value is the distance between the .end directive and the
3011      corresponding symbol.  We create a fake symbol to hold the
3012      current location, and put in the offset when we write out the
3013      symbol.  */
3014   ent = symbol_find (name);
3015   if (ent == (symbolS *) NULL)
3016     as_warn (_(".end directive names unknown symbol"));
3017   else
3018     (void) add_ecoff_symbol ((const char *) NULL, st_End, sc_Text,
3019 			     symbol_new ("L0\001", now_seg,
3020 					 (valueT) frag_now_fix (),
3021 					 frag_now),
3022 			     (bfd_vma) 0, (symint_t) 0, (symint_t) 0);
3023 
3024   cur_proc_ptr = (proc_t *) NULL;
3025 
3026   (void) restore_line_pointer (name_end);
3027   demand_empty_rest_of_line ();
3028 }
3029 
3030 /* Parse .ent directives.  */
3031 
3032 void
ecoff_directive_ent(int ignore ATTRIBUTE_UNUSED)3033 ecoff_directive_ent (int ignore ATTRIBUTE_UNUSED)
3034 {
3035   char *name;
3036   char name_end;
3037 
3038   if (cur_file_ptr == (efdr_t *) NULL)
3039     add_file ((const char *) NULL, 0, 1);
3040 
3041   if (cur_proc_ptr != (proc_t *) NULL)
3042     {
3043       as_warn (_("second .ent directive found before .end directive"));
3044       demand_empty_rest_of_line ();
3045       return;
3046     }
3047 
3048   name_end = get_symbol_name (&name);
3049 
3050   if (name == input_line_pointer)
3051     {
3052       as_warn (_(".ent directive has no name"));
3053       (void) restore_line_pointer (name_end);
3054       demand_empty_rest_of_line ();
3055       return;
3056     }
3057 
3058   add_procedure (name);
3059 
3060   (void) restore_line_pointer (name_end);
3061 
3062   /* The .ent directive is sometimes followed by a number.  I'm not
3063      really sure what the number means.  I don't see any way to store
3064      the information in the PDR.  The Irix 4 assembler seems to ignore
3065      the information.  */
3066   SKIP_WHITESPACE ();
3067   if (*input_line_pointer == ',')
3068     {
3069       ++input_line_pointer;
3070       SKIP_WHITESPACE ();
3071     }
3072   if (ISDIGIT (*input_line_pointer)
3073       || *input_line_pointer == '-')
3074     (void) get_absolute_expression ();
3075 
3076   demand_empty_rest_of_line ();
3077 }
3078 
3079 /* Parse .extern directives.  */
3080 
3081 void
ecoff_directive_extern(int ignore ATTRIBUTE_UNUSED)3082 ecoff_directive_extern (int ignore ATTRIBUTE_UNUSED)
3083 {
3084   char *name;
3085   int c;
3086   symbolS *symbolp;
3087   valueT size;
3088 
3089   c = get_symbol_name (&name);
3090   symbolp = symbol_find_or_make (name);
3091   (void) restore_line_pointer (c);
3092 
3093   S_SET_EXTERNAL (symbolp);
3094 
3095   if (*input_line_pointer == ',')
3096     ++input_line_pointer;
3097   size = get_absolute_expression ();
3098 
3099   symbol_get_obj (symbolp)->ecoff_extern_size = size;
3100 }
3101 
3102 /* Parse .file directives.  */
3103 
3104 void
ecoff_directive_file(int ignore ATTRIBUTE_UNUSED)3105 ecoff_directive_file (int ignore ATTRIBUTE_UNUSED)
3106 {
3107   int indx;
3108   char *name;
3109   int len;
3110 
3111   if (cur_proc_ptr != (proc_t *) NULL)
3112     {
3113       as_warn (_("no way to handle .file within .ent/.end section"));
3114       demand_empty_rest_of_line ();
3115       return;
3116     }
3117 
3118   indx = (int) get_absolute_expression ();
3119 
3120   /* FIXME: we don't have to save the name here.  */
3121   name = demand_copy_C_string (&len);
3122 
3123   add_file (name, indx - 1, 0);
3124 
3125   demand_empty_rest_of_line ();
3126 }
3127 
3128 /* Parse .fmask directives.  */
3129 
3130 void
ecoff_directive_fmask(int ignore ATTRIBUTE_UNUSED)3131 ecoff_directive_fmask (int ignore ATTRIBUTE_UNUSED)
3132 {
3133   long val;
3134 
3135   if (cur_proc_ptr == (proc_t *) NULL)
3136     {
3137       as_warn (_(".fmask outside of .ent"));
3138       demand_empty_rest_of_line ();
3139       return;
3140     }
3141 
3142   if (get_absolute_expression_and_terminator (&val) != ',')
3143     {
3144       as_warn (_("bad .fmask directive"));
3145       --input_line_pointer;
3146       demand_empty_rest_of_line ();
3147       return;
3148     }
3149 
3150   cur_proc_ptr->pdr.fregmask = val;
3151   cur_proc_ptr->pdr.fregoffset = get_absolute_expression ();
3152 
3153   demand_empty_rest_of_line ();
3154 }
3155 
3156 /* Parse .frame directives.  */
3157 
3158 void
ecoff_directive_frame(int ignore ATTRIBUTE_UNUSED)3159 ecoff_directive_frame (int ignore ATTRIBUTE_UNUSED)
3160 {
3161   long val;
3162 
3163   if (cur_proc_ptr == (proc_t *) NULL)
3164     {
3165       as_warn (_(".frame outside of .ent"));
3166       demand_empty_rest_of_line ();
3167       return;
3168     }
3169 
3170   cur_proc_ptr->pdr.framereg = tc_get_register (1);
3171 
3172   SKIP_WHITESPACE ();
3173   if (*input_line_pointer++ != ','
3174       || get_absolute_expression_and_terminator (&val) != ',')
3175     {
3176       as_warn (_("bad .frame directive"));
3177       --input_line_pointer;
3178       demand_empty_rest_of_line ();
3179       return;
3180     }
3181 
3182   cur_proc_ptr->pdr.frameoffset = val;
3183 
3184   cur_proc_ptr->pdr.pcreg = tc_get_register (0);
3185 
3186   /* Alpha-OSF1 adds "the offset of saved $a0 from $sp", according to
3187      Sandro.  I don't yet know where this value should be stored, if
3188      anywhere.  Don't call demand_empty_rest_of_line ().  */
3189   s_ignore (42);
3190 }
3191 
3192 /* Parse .mask directives.  */
3193 
3194 void
ecoff_directive_mask(int ignore ATTRIBUTE_UNUSED)3195 ecoff_directive_mask (int ignore ATTRIBUTE_UNUSED)
3196 {
3197   long val;
3198 
3199   if (cur_proc_ptr == (proc_t *) NULL)
3200     {
3201       as_warn (_(".mask outside of .ent"));
3202       demand_empty_rest_of_line ();
3203       return;
3204     }
3205 
3206   if (get_absolute_expression_and_terminator (&val) != ',')
3207     {
3208       as_warn (_("bad .mask directive"));
3209       --input_line_pointer;
3210       demand_empty_rest_of_line ();
3211       return;
3212     }
3213 
3214   cur_proc_ptr->pdr.regmask = val;
3215   cur_proc_ptr->pdr.regoffset = get_absolute_expression ();
3216 
3217   demand_empty_rest_of_line ();
3218 }
3219 
3220 /* Parse .loc directives.  */
3221 
3222 void
ecoff_directive_loc(int ignore ATTRIBUTE_UNUSED)3223 ecoff_directive_loc (int ignore ATTRIBUTE_UNUSED)
3224 {
3225   lineno_list_t *list;
3226   symint_t lineno;
3227 
3228   if (cur_file_ptr == (efdr_t *) NULL)
3229     {
3230       as_warn (_(".loc before .file"));
3231       demand_empty_rest_of_line ();
3232       return;
3233     }
3234 
3235   if (now_seg != text_section)
3236     {
3237       as_warn (_(".loc outside of .text"));
3238       demand_empty_rest_of_line ();
3239       return;
3240     }
3241 
3242   /* Skip the file number.  */
3243   SKIP_WHITESPACE ();
3244   get_absolute_expression ();
3245   SKIP_WHITESPACE ();
3246 
3247   lineno = get_absolute_expression ();
3248 
3249 #ifndef NO_LISTING
3250   if (listing)
3251     listing_source_line (lineno);
3252 #endif
3253 
3254   /* If we're building stabs, then output a special label rather than
3255      ECOFF line number info.  */
3256   if (stabs_seen)
3257     {
3258       (void) add_ecoff_symbol ((char *) NULL, st_Label, sc_Text,
3259 			       symbol_new ("L0\001", now_seg,
3260 					   (valueT) frag_now_fix (),
3261 					   frag_now),
3262 			       (bfd_vma) 0, 0, lineno);
3263       return;
3264     }
3265 
3266   list = allocate_lineno_list ();
3267 
3268   list->next = (lineno_list_t *) NULL;
3269   list->file = cur_file_ptr;
3270   list->proc = cur_proc_ptr;
3271   list->frag = frag_now;
3272   list->paddr = frag_now_fix ();
3273   list->lineno = lineno;
3274 
3275   /* We don't want to merge files which have line numbers.  */
3276   cur_file_ptr->fdr.fMerge = 0;
3277 
3278   /* A .loc directive will sometimes appear before a .ent directive,
3279      which means that cur_proc_ptr will be NULL here.  Arrange to
3280      patch this up.  */
3281   if (cur_proc_ptr == (proc_t *) NULL)
3282     {
3283       lineno_list_t **pl;
3284 
3285       pl = &noproc_lineno;
3286       while (*pl != (lineno_list_t *) NULL)
3287 	pl = &(*pl)->next;
3288       *pl = list;
3289     }
3290   else
3291     {
3292       last_lineno = list;
3293       *last_lineno_ptr = list;
3294       last_lineno_ptr = &list->next;
3295     }
3296 }
3297 
3298 /* The MIPS assembler sometimes inserts nop instructions in the
3299    instruction stream.  When this happens, we must patch up the .loc
3300    information so that it points to the instruction after the nop.  */
3301 
3302 void
ecoff_fix_loc(fragS * old_frag,unsigned long old_frag_offset)3303 ecoff_fix_loc (fragS *old_frag, unsigned long old_frag_offset)
3304 {
3305   if (last_lineno != NULL
3306       && last_lineno->frag == old_frag
3307       && last_lineno->paddr == old_frag_offset)
3308     {
3309       last_lineno->frag = frag_now;
3310       last_lineno->paddr = frag_now_fix ();
3311     }
3312 }
3313 
3314 /* Make sure the @stabs symbol is emitted.  */
3315 
3316 static void
mark_stabs(int ignore ATTRIBUTE_UNUSED)3317 mark_stabs (int ignore ATTRIBUTE_UNUSED)
3318 {
3319   if (! stabs_seen)
3320     {
3321       /* Add a dummy @stabs dymbol.  */
3322       stabs_seen = 1;
3323       (void) add_ecoff_symbol (stabs_symbol, st_Nil, sc_Info,
3324 			       (symbolS *) NULL,
3325 			       (bfd_vma) 0, (symint_t) -1,
3326 			       ECOFF_MARK_STAB (0));
3327     }
3328 }
3329 
3330 /* Parse .weakext directives.  */
3331 #ifndef TC_MIPS
3332 /* For TC_MIPS use the version in tc-mips.c.  */
3333 void
ecoff_directive_weakext(int ignore ATTRIBUTE_UNUSED)3334 ecoff_directive_weakext (int ignore ATTRIBUTE_UNUSED)
3335 {
3336   char *name;
3337   int c;
3338   symbolS *symbolP;
3339   expressionS exp;
3340 
3341   c = get_symbol_name (&name);
3342   symbolP = symbol_find_or_make (name);
3343   (void) restore_line_pointer (c);
3344 
3345   SKIP_WHITESPACE ();
3346 
3347   if (*input_line_pointer == ',')
3348     {
3349       if (S_IS_DEFINED (symbolP))
3350 	{
3351 	  as_bad (_("symbol `%s' is already defined"),
3352 		  S_GET_NAME (symbolP));
3353 	  ignore_rest_of_line ();
3354 	  return;
3355 	}
3356 
3357       ++input_line_pointer;
3358       SKIP_WHITESPACE ();
3359       if (! is_end_of_line[(unsigned char) *input_line_pointer])
3360 	{
3361 	  expression (&exp);
3362 	  if (exp.X_op != O_symbol)
3363 	    {
3364 	      as_bad (_("bad .weakext directive"));
3365 	      ignore_rest_of_line ();
3366 	      return;
3367 	    }
3368 	  symbol_set_value_expression (symbolP, &exp);
3369 	}
3370     }
3371 
3372   S_SET_WEAK (symbolP);
3373 
3374   demand_empty_rest_of_line ();
3375 }
3376 #endif /* not TC_MIPS */
3377 
3378 /* Handle .stabs directives.  The actual parsing routine is done by a
3379    generic routine.  This routine is called via OBJ_PROCESS_STAB.
3380    When this is called, input_line_pointer will be pointing at the
3381    value field of the stab.
3382 
3383    .stabs directives have five fields:
3384 	"string"	a string, encoding the type information.
3385 	code		a numeric code, defined in <stab.h>
3386 	0		a zero
3387 	desc		a zero or line number
3388 	value		a numeric value or an address.
3389 
3390     If the value is relocatable, we transform this into:
3391 	iss		points as an index into string space
3392 	value		value from lookup of the name
3393 	st		st from lookup of the name
3394 	sc		sc from lookup of the name
3395 	index		code|CODE_MASK
3396 
3397     If the value is not relocatable, we transform this into:
3398 	iss		points as an index into string space
3399 	value		value
3400 	st		st_Nil
3401 	sc		sc_Nil
3402 	index		code|CODE_MASK
3403 
3404     .stabn directives have four fields (string is null):
3405 	code		a numeric code, defined in <stab.h>
3406 	0		a zero
3407 	desc		a zero or a line number
3408 	value		a numeric value or an address.  */
3409 
3410 void
ecoff_stab(segT sec ATTRIBUTE_UNUSED,int what,const char * string,int type,int other,int desc)3411 ecoff_stab (segT sec ATTRIBUTE_UNUSED,
3412 	    int what,
3413 	    const char *string,
3414 	    int type,
3415 	    int other,
3416 	    int desc)
3417 {
3418   efdr_t *save_file_ptr = cur_file_ptr;
3419   symbolS *sym;
3420   symint_t value;
3421   bfd_vma addend;
3422   st_t st;
3423   sc_t sc;
3424   symint_t indx;
3425   localsym_t *hold = NULL;
3426 
3427   ecoff_debugging_seen = 1;
3428 
3429   /* We don't handle .stabd.  */
3430   if (what != 's' && what != 'n')
3431     {
3432       as_bad (_(".stab%c is not supported"), what);
3433       return;
3434     }
3435 
3436   /* A .stabn uses a null name, not an empty string.  */
3437   if (what == 'n')
3438     string = NULL;
3439 
3440   /* We ignore the other field.  */
3441   if (other != 0)
3442     as_warn (_(".stab%c: ignoring non-zero other field"), what);
3443 
3444   /* Make sure we have a current file.  */
3445   if (cur_file_ptr == (efdr_t *) NULL)
3446     {
3447       add_file ((const char *) NULL, 0, 1);
3448       save_file_ptr = cur_file_ptr;
3449     }
3450 
3451   /* For stabs in ECOFF, the first symbol must be @stabs.  This is a
3452      signal to gdb.  */
3453   if (stabs_seen == 0)
3454     mark_stabs (0);
3455 
3456   /* Line number stabs are handled differently, since they have two
3457      values, the line number and the address of the label.  We use the
3458      index field (aka desc) to hold the line number, and the value
3459      field to hold the address.  The symbol type is st_Label, which
3460      should be different from the other stabs, so that gdb can
3461      recognize it.  */
3462   if (type == N_SLINE)
3463     {
3464       SYMR dummy_symr;
3465       char *name;
3466       char name_end;
3467 
3468 #ifndef NO_LISTING
3469       if (listing)
3470 	listing_source_line ((unsigned int) desc);
3471 #endif
3472 
3473       dummy_symr.index = desc;
3474       if (dummy_symr.index != desc)
3475 	{
3476 	  as_warn (_("line number (%d) for .stab%c directive cannot fit in index field (20 bits)"),
3477 		   desc, what);
3478 	  return;
3479 	}
3480 
3481       name_end = get_symbol_name (&name);
3482       sym = symbol_find_or_make (name);
3483       (void) restore_line_pointer (name_end);
3484 
3485       value = 0;
3486       addend = 0;
3487       st = st_Label;
3488       sc = sc_Text;
3489       indx = desc;
3490     }
3491   else
3492     {
3493 #ifndef NO_LISTING
3494       if (listing && (type == N_SO || type == N_SOL))
3495 	listing_source_file (string);
3496 #endif
3497 
3498       if (ISDIGIT (*input_line_pointer)
3499 	  || *input_line_pointer == '-'
3500 	  || *input_line_pointer == '+')
3501 	{
3502 	  st = st_Nil;
3503 	  sc = sc_Nil;
3504 	  sym = (symbolS *) NULL;
3505 	  value = get_absolute_expression ();
3506 	  addend = 0;
3507 	}
3508       else if (! is_name_beginner ((unsigned char) *input_line_pointer))
3509 	{
3510 	  as_warn (_("illegal .stab%c directive, bad character"), what);
3511 	  return;
3512 	}
3513       else
3514 	{
3515 	  expressionS exp;
3516 
3517 	  sc = sc_Nil;
3518 	  st = st_Nil;
3519 
3520 	  expression (&exp);
3521 	  if (exp.X_op == O_constant)
3522 	    {
3523 	      sym = NULL;
3524 	      value = exp.X_add_number;
3525 	      addend = 0;
3526 	    }
3527 	  else if (exp.X_op == O_symbol)
3528 	    {
3529 	      sym = exp.X_add_symbol;
3530 	      value = 0;
3531 	      addend = exp.X_add_number;
3532 	    }
3533 	  else
3534 	    {
3535 	      sym = make_expr_symbol (&exp);
3536 	      value = 0;
3537 	      addend = 0;
3538 	    }
3539 	}
3540 
3541       indx = ECOFF_MARK_STAB (type);
3542     }
3543 
3544   /* Don't store the stabs symbol we are creating as the type of the
3545      ECOFF symbol.  We want to compute the type of the ECOFF symbol
3546      independently.  */
3547   if (sym != (symbolS *) NULL)
3548     hold = symbol_get_obj (sym)->ecoff_symbol;
3549 
3550   (void) add_ecoff_symbol (string, st, sc, sym, addend, value, indx);
3551 
3552   if (sym != (symbolS *) NULL)
3553     symbol_get_obj (sym)->ecoff_symbol = hold;
3554 
3555   /* Restore normal file type.  */
3556   cur_file_ptr = save_file_ptr;
3557 }
3558 
3559 /* Frob an ECOFF symbol.  Small common symbols go into a special
3560    .scommon section rather than bfd_com_section.  */
3561 
3562 void
ecoff_frob_symbol(symbolS * sym)3563 ecoff_frob_symbol (symbolS *sym)
3564 {
3565   if (S_IS_COMMON (sym)
3566       && S_GET_VALUE (sym) > 0
3567       && S_GET_VALUE (sym) <= bfd_get_gp_size (stdoutput))
3568     {
3569       static asection scom_section;
3570       static asymbol scom_symbol;
3571 
3572       /* We must construct a fake section similar to bfd_com_section
3573          but with the name .scommon.  */
3574       if (scom_section.name == NULL)
3575 	{
3576 	  scom_section = *bfd_com_section_ptr;
3577 	  scom_section.name = ".scommon";
3578 	  scom_section.output_section = &scom_section;
3579 	  scom_section.symbol = &scom_symbol;
3580 	  scom_section.symbol_ptr_ptr = &scom_section.symbol;
3581 	  scom_symbol = *bfd_com_section_ptr->symbol;
3582 	  scom_symbol.name = ".scommon";
3583 	  scom_symbol.section = &scom_section;
3584 	}
3585       S_SET_SEGMENT (sym, &scom_section);
3586     }
3587 
3588   /* Double check weak symbols.  */
3589   if (S_IS_WEAK (sym))
3590     {
3591       if (S_IS_COMMON (sym))
3592 	as_bad (_("symbol `%s' can not be both weak and common"),
3593 		S_GET_NAME (sym));
3594     }
3595 }
3596 
3597 /* Add bytes to the symbolic information buffer.  */
3598 
3599 static char *
ecoff_add_bytes(char ** buf,char ** bufend,char * bufptr,unsigned long need)3600 ecoff_add_bytes (char **buf,
3601 		 char **bufend,
3602 		 char *bufptr,
3603 		 unsigned long need)
3604 {
3605   unsigned long at;
3606   unsigned long want;
3607 
3608   at = bufptr - *buf;
3609   need -= *bufend - bufptr;
3610   if (need < PAGE_SIZE)
3611     need = PAGE_SIZE;
3612   want = (*bufend - *buf) + need;
3613   *buf = XRESIZEVEC (char, *buf, want);
3614   *bufend = *buf + want;
3615   return *buf + at;
3616 }
3617 
3618 /* Adjust the symbolic information buffer to the alignment required
3619    for the ECOFF target debugging information.  */
3620 
3621 static unsigned long
ecoff_padding_adjust(const struct ecoff_debug_swap * backend,char ** buf,char ** bufend,unsigned long offset,char ** bufptrptr)3622 ecoff_padding_adjust (const struct ecoff_debug_swap *backend,
3623 		      char **buf,
3624 		      char **bufend,
3625 		      unsigned long offset,
3626 		      char **bufptrptr)
3627 {
3628   bfd_size_type align;
3629 
3630   align = backend->debug_align;
3631   if ((offset & (align - 1)) != 0)
3632     {
3633       unsigned long add;
3634 
3635       add = align - (offset & (align - 1));
3636       if ((unsigned long) (*bufend - (*buf + offset)) < add)
3637 	(void) ecoff_add_bytes (buf, bufend, *buf + offset, add);
3638       memset (*buf + offset, 0, add);
3639       offset += add;
3640       if (bufptrptr != (char **) NULL)
3641 	*bufptrptr = *buf + offset;
3642     }
3643 
3644   return offset;
3645 }
3646 
3647 /* Build the line number information.  */
3648 
3649 static unsigned long
ecoff_build_lineno(const struct ecoff_debug_swap * backend,char ** buf,char ** bufend,unsigned long offset,long * linecntptr)3650 ecoff_build_lineno (const struct ecoff_debug_swap *backend,
3651 		    char **buf,
3652 		    char **bufend,
3653 		    unsigned long offset,
3654 		    long *linecntptr)
3655 {
3656   char *bufptr;
3657   lineno_list_t *l;
3658   lineno_list_t *last;
3659   efdr_t *file;
3660   proc_t *proc;
3661   unsigned long c;
3662   long iline;
3663   long totcount;
3664   lineno_list_t first;
3665   lineno_list_t *local_first_lineno = first_lineno;
3666 
3667   if (linecntptr != (long *) NULL)
3668     *linecntptr = 0;
3669 
3670   bufptr = *buf + offset;
3671 
3672   file = (efdr_t *) NULL;
3673   proc = (proc_t *) NULL;
3674   last = (lineno_list_t *) NULL;
3675   c = offset;
3676   iline = 0;
3677   totcount = 0;
3678 
3679   /* FIXME?  Now that MIPS embedded-PIC is gone, it may be safe to
3680      remove this code.  */
3681   /* For some reason the address of the first procedure is ignored
3682      when reading line numbers.  This doesn't matter if the address of
3683      the first procedure is 0, but when gcc is generating MIPS
3684      embedded PIC code, it will put strings in the .text section
3685      before the first procedure.  We cope by inserting a dummy line if
3686      the address of the first procedure is not 0.  Hopefully this
3687      won't screw things up too badly.
3688 
3689      Don't do this for ECOFF assembly source line numbers.  They work
3690      without this extra attention.  */
3691   if (debug_type != DEBUG_ECOFF
3692       && first_proc_ptr != (proc_t *) NULL
3693       && local_first_lineno != (lineno_list_t *) NULL
3694       && ((S_GET_VALUE (first_proc_ptr->sym->as_sym)
3695 	   + bfd_get_section_vma (stdoutput,
3696 				  S_GET_SEGMENT (first_proc_ptr->sym->as_sym)))
3697 	  != 0))
3698     {
3699       first.file = local_first_lineno->file;
3700       first.proc = local_first_lineno->proc;
3701       first.frag = &zero_address_frag;
3702       first.paddr = 0;
3703       first.lineno = 0;
3704 
3705       first.next = local_first_lineno;
3706       local_first_lineno = &first;
3707     }
3708 
3709   for (l = local_first_lineno; l != (lineno_list_t *) NULL; l = l->next)
3710     {
3711       long count;
3712       long delta;
3713 
3714       /* Get the offset to the memory address of the next line number
3715          (in words).  Do this first, so that we can skip ahead to the
3716          next useful line number entry.  */
3717       if (l->next == (lineno_list_t *) NULL)
3718 	{
3719 	  /* We want a count of zero, but it will be decremented
3720 	     before it is used.  */
3721 	  count = 1;
3722 	}
3723       else if (l->next->frag->fr_address + l->next->paddr
3724 	       > l->frag->fr_address + l->paddr)
3725 	{
3726 	  count = ((l->next->frag->fr_address + l->next->paddr
3727 		    - (l->frag->fr_address + l->paddr))
3728 		   >> 2);
3729 	}
3730       else
3731 	{
3732 	  /* Don't change last, so we still get the right delta.  */
3733 	  continue;
3734 	}
3735 
3736       if (l->file != file || l->proc != proc)
3737 	{
3738 	  if (l->proc != proc && proc != (proc_t *) NULL)
3739 	    proc->pdr.lnHigh = last->lineno;
3740 	  if (l->file != file && file != (efdr_t *) NULL)
3741 	    {
3742 	      file->fdr.cbLine = c - file->fdr.cbLineOffset;
3743 	      file->fdr.cline = totcount + count;
3744 	      if (linecntptr != (long *) NULL)
3745 		*linecntptr += totcount + count;
3746 	      totcount = 0;
3747 	    }
3748 
3749 	  if (l->file != file)
3750 	    {
3751 	      efdr_t *last_file = file;
3752 
3753 	      file = l->file;
3754 	      if (last_file != (efdr_t *) NULL)
3755 		file->fdr.ilineBase
3756 		  = last_file->fdr.ilineBase + last_file->fdr.cline;
3757 	      else
3758 		file->fdr.ilineBase = 0;
3759 	      file->fdr.cbLineOffset = c;
3760 	    }
3761 	  if (l->proc != proc)
3762 	    {
3763 	      proc = l->proc;
3764 	      if (proc != (proc_t *) NULL)
3765 		{
3766 		  proc->pdr.lnLow = l->lineno;
3767 		  proc->pdr.cbLineOffset = c - file->fdr.cbLineOffset;
3768 		  proc->pdr.iline = totcount;
3769 		}
3770 	    }
3771 
3772 	  last = (lineno_list_t *) NULL;
3773 	}
3774 
3775       totcount += count;
3776 
3777       /* Get the offset to this line number.  */
3778       if (last == (lineno_list_t *) NULL)
3779 	delta = 0;
3780       else
3781 	delta = l->lineno - last->lineno;
3782 
3783       /* Put in the offset to this line number.  */
3784       while (delta != 0)
3785 	{
3786 	  int setcount;
3787 
3788 	  /* 1 is added to each count read.  */
3789 	  --count;
3790 	  /* We can only adjust the word count by up to 15 words at a
3791 	     time.  */
3792 	  if (count <= 0x0f)
3793 	    {
3794 	      setcount = count;
3795 	      count = 0;
3796 	    }
3797 	  else
3798 	    {
3799 	      setcount = 0x0f;
3800 	      count -= 0x0f;
3801 	    }
3802 	  if (delta >= -7 && delta <= 7)
3803 	    {
3804 	      if (bufptr >= *bufend)
3805 		bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1);
3806 	      *bufptr++ = setcount + (delta << 4);
3807 	      delta = 0;
3808 	      ++c;
3809 	    }
3810 	  else
3811 	    {
3812 	      int set;
3813 
3814 	      if (*bufend - bufptr < 3)
3815 		bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 3);
3816 	      *bufptr++ = setcount + (8 << 4);
3817 	      if (delta < -0x8000)
3818 		{
3819 		  set = -0x8000;
3820 		  delta += 0x8000;
3821 		}
3822 	      else if (delta > 0x7fff)
3823 		{
3824 		  set = 0x7fff;
3825 		  delta -= 0x7fff;
3826 		}
3827 	      else
3828 		{
3829 		  set = delta;
3830 		  delta = 0;
3831 		}
3832 	      *bufptr++ = set >> 8;
3833 	      *bufptr++ = set & 0xffff;
3834 	      c += 3;
3835 	    }
3836 	}
3837 
3838       /* Finish adjusting the count.  */
3839       while (count > 0)
3840 	{
3841 	  if (bufptr >= *bufend)
3842 	    bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1);
3843 	  /* 1 is added to each count read.  */
3844 	  --count;
3845 	  if (count > 0x0f)
3846 	    {
3847 	      *bufptr++ = 0x0f;
3848 	      count -= 0x0f;
3849 	    }
3850 	  else
3851 	    {
3852 	      *bufptr++ = count;
3853 	      count = 0;
3854 	    }
3855 	  ++c;
3856 	}
3857 
3858       ++iline;
3859       last = l;
3860     }
3861 
3862   if (proc != (proc_t *) NULL)
3863     proc->pdr.lnHigh = last->lineno;
3864   if (file != (efdr_t *) NULL)
3865     {
3866       file->fdr.cbLine = c - file->fdr.cbLineOffset;
3867       file->fdr.cline = totcount;
3868     }
3869 
3870   if (linecntptr != (long *) NULL)
3871     *linecntptr += totcount;
3872 
3873   c = ecoff_padding_adjust (backend, buf, bufend, c, &bufptr);
3874 
3875   return c;
3876 }
3877 
3878 /* Build and swap out the symbols.  */
3879 
3880 static unsigned long
ecoff_build_symbols(const struct ecoff_debug_swap * backend,char ** buf,char ** bufend,unsigned long offset)3881 ecoff_build_symbols (const struct ecoff_debug_swap *backend,
3882 		     char **buf,
3883 		     char **bufend,
3884 		     unsigned long offset)
3885 {
3886   const bfd_size_type external_sym_size = backend->external_sym_size;
3887   void (* const swap_sym_out) (bfd *, const SYMR *, void *)
3888     = backend->swap_sym_out;
3889   char *sym_out;
3890   long isym;
3891   vlinks_t *file_link;
3892 
3893   sym_out = *buf + offset;
3894 
3895   isym = 0;
3896 
3897   /* The symbols are stored by file.  */
3898   for (file_link = file_desc.first;
3899        file_link != (vlinks_t *) NULL;
3900        file_link = file_link->next)
3901     {
3902       int ifilesym;
3903       int fil_cnt;
3904       efdr_t *fil_ptr;
3905       efdr_t *fil_end;
3906 
3907       if (file_link->next == (vlinks_t *) NULL)
3908 	fil_cnt = file_desc.objects_last_page;
3909       else
3910 	fil_cnt = file_desc.objects_per_page;
3911       fil_ptr = file_link->datum->file;
3912       fil_end = fil_ptr + fil_cnt;
3913       for (; fil_ptr < fil_end; fil_ptr++)
3914 	{
3915 	  vlinks_t *sym_link;
3916 
3917 	  fil_ptr->fdr.isymBase = isym;
3918 	  ifilesym = isym;
3919 	  for (sym_link = fil_ptr->symbols.first;
3920 	       sym_link != (vlinks_t *) NULL;
3921 	       sym_link = sym_link->next)
3922 	    {
3923 	      int sym_cnt;
3924 	      localsym_t *sym_ptr;
3925 	      localsym_t *sym_end;
3926 
3927 	      if (sym_link->next == (vlinks_t *) NULL)
3928 		sym_cnt = fil_ptr->symbols.objects_last_page;
3929 	      else
3930 		sym_cnt = fil_ptr->symbols.objects_per_page;
3931 	      sym_ptr = sym_link->datum->sym;
3932 	      sym_end = sym_ptr + sym_cnt;
3933 	      for (; sym_ptr < sym_end; sym_ptr++)
3934 		{
3935 		  int local;
3936 		  symbolS *as_sym;
3937 		  forward_t *f;
3938 
3939 		  know (sym_ptr->file_ptr == fil_ptr);
3940 
3941 		  /* If there is no associated gas symbol, then this
3942 		     is a pure debugging symbol.  We have already
3943 		     added the name (if any) to fil_ptr->strings.
3944 		     Otherwise we must decide whether this is an
3945 		     external or a local symbol (actually, it may be
3946 		     both if the local provides additional debugging
3947 		     information for the external).  */
3948 		  local = 1;
3949 		  as_sym = sym_ptr->as_sym;
3950 		  if (as_sym != (symbolS *) NULL)
3951 		    {
3952 		      symint_t indx;
3953 
3954 		      /* The value of a block start symbol is the
3955 		         offset from the start of the procedure.  For
3956 		         other symbols we just use the gas value (but
3957 		         we must offset it by the vma of the section,
3958 		         just as BFD does, because BFD will not see
3959 		         this value).  */
3960 		      if (sym_ptr->ecoff_sym.asym.st == (int) st_Block
3961 			  && sym_ptr->ecoff_sym.asym.sc == (int) sc_Text)
3962 			{
3963 			  symbolS *begin_sym;
3964 
3965 			  know (sym_ptr->proc_ptr != (proc_t *) NULL);
3966 			  begin_sym = sym_ptr->proc_ptr->sym->as_sym;
3967 			  if (S_GET_SEGMENT (as_sym)
3968 			      != S_GET_SEGMENT (begin_sym))
3969 			    as_warn (_(".begin/.bend in different segments"));
3970 			  sym_ptr->ecoff_sym.asym.value =
3971 			    S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym);
3972 			}
3973 		      else
3974 			sym_ptr->ecoff_sym.asym.value =
3975 			  (S_GET_VALUE (as_sym)
3976 			   + bfd_get_section_vma (stdoutput,
3977 						  S_GET_SEGMENT (as_sym))
3978 			   + sym_ptr->addend);
3979 
3980 		      sym_ptr->ecoff_sym.weakext = S_IS_WEAK (as_sym);
3981 
3982 		      /* Set st_Proc to st_StaticProc for local
3983 			 functions.  */
3984 		      if (sym_ptr->ecoff_sym.asym.st == st_Proc
3985 			  && S_IS_DEFINED (as_sym)
3986 			  && ! S_IS_EXTERNAL (as_sym)
3987 			  && ! S_IS_WEAK (as_sym))
3988 			sym_ptr->ecoff_sym.asym.st = st_StaticProc;
3989 
3990 		      /* Get the type and storage class based on where
3991 		         the symbol actually wound up.  Traditionally,
3992 		         N_LBRAC and N_RBRAC are *not* relocated.  */
3993 		      indx = sym_ptr->ecoff_sym.asym.index;
3994 		      if (sym_ptr->ecoff_sym.asym.st == st_Nil
3995 			  && sym_ptr->ecoff_sym.asym.sc == sc_Nil
3996 			  && (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym)
3997 			      || ((ECOFF_UNMARK_STAB (indx) != N_LBRAC)
3998 				  && (ECOFF_UNMARK_STAB (indx) != N_RBRAC))))
3999 			{
4000 			  segT seg;
4001 			  const char *segname;
4002 			  st_t st;
4003 			  sc_t sc;
4004 
4005 			  seg = S_GET_SEGMENT (as_sym);
4006 			  segname = segment_name (seg);
4007 
4008 			  if (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym)
4009 			      && (S_IS_EXTERNAL (as_sym)
4010 				  || S_IS_WEAK (as_sym)
4011 				  || ! S_IS_DEFINED (as_sym)))
4012 			    {
4013 			      if ((symbol_get_bfdsym (as_sym)->flags
4014 				   & BSF_FUNCTION) != 0)
4015 				st = st_Proc;
4016 			      else
4017 				st = st_Global;
4018 			    }
4019 			  else if (seg == text_section)
4020 			    st = st_Label;
4021 			  else
4022 			    st = st_Static;
4023 
4024 			  if (! S_IS_DEFINED (as_sym))
4025 			    {
4026 			      valueT s;
4027 
4028 			      s = symbol_get_obj (as_sym)->ecoff_extern_size;
4029 			      if (s == 0
4030 				  || s > bfd_get_gp_size (stdoutput))
4031 				sc = sc_Undefined;
4032 			      else
4033 				{
4034 				  sc = sc_SUndefined;
4035 				  sym_ptr->ecoff_sym.asym.value = s;
4036 				}
4037 #ifdef S_SET_SIZE
4038 			      S_SET_SIZE (as_sym, s);
4039 #endif
4040 			    }
4041 			  else if (S_IS_COMMON (as_sym))
4042 			    {
4043 			      if (S_GET_VALUE (as_sym) > 0
4044 				  && (S_GET_VALUE (as_sym)
4045 				      <= bfd_get_gp_size (stdoutput)))
4046 				sc = sc_SCommon;
4047 			      else
4048 				sc = sc_Common;
4049 			    }
4050 			  else if (seg == text_section)
4051 			    sc = sc_Text;
4052 			  else if (seg == data_section)
4053 			    sc = sc_Data;
4054 			  else if (strcmp (segname, ".rdata") == 0
4055 				   || strcmp (segname, ".rodata") == 0)
4056 			    sc = sc_RData;
4057 			  else if (strcmp (segname, ".sdata") == 0)
4058 			    sc = sc_SData;
4059 			  else if (seg == bss_section)
4060 			    sc = sc_Bss;
4061 			  else if (strcmp (segname, ".sbss") == 0)
4062 			    sc = sc_SBss;
4063 			  else if (seg == bfd_abs_section_ptr)
4064 			    sc = sc_Abs;
4065 			  else
4066 			    {
4067 			      /* This must be a user named section.
4068 			         This is not possible in ECOFF, but it
4069 			         is in ELF.  */
4070 			      sc = sc_Data;
4071 			    }
4072 
4073 			  sym_ptr->ecoff_sym.asym.st = (int) st;
4074 			  sym_ptr->ecoff_sym.asym.sc = (int) sc;
4075 			}
4076 
4077 		      /* This is just an external symbol if it is
4078 		         outside a procedure and it has a type.
4079 		         FIXME: g++ will generate symbols which have
4080 		         different names in the debugging information
4081 		         than the actual symbol.  Should we handle
4082 		         them here?  */
4083 		      if ((S_IS_EXTERNAL (as_sym)
4084 			   || S_IS_WEAK (as_sym)
4085 			   || ! S_IS_DEFINED (as_sym))
4086 			  && sym_ptr->proc_ptr == (proc_t *) NULL
4087 			  && sym_ptr->ecoff_sym.asym.st != (int) st_Nil
4088 			  && ! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym))
4089 			local = 0;
4090 
4091 		      /* This is just an external symbol if it is a
4092 		         common symbol.  */
4093 		      if (S_IS_COMMON (as_sym))
4094 			local = 0;
4095 
4096 		      /* If an st_end symbol has an associated gas
4097 		         symbol, then it is a local label created for
4098 		         a .bend or .end directive.  Stabs line
4099 		         numbers will have \001 in the names.  */
4100 		      if (local
4101 			  && sym_ptr->ecoff_sym.asym.st != st_End
4102 			  && strchr (sym_ptr->name, '\001') == 0)
4103 			sym_ptr->ecoff_sym.asym.iss =
4104 			  add_string (&fil_ptr->strings,
4105 				      fil_ptr->str_hash,
4106 				      sym_ptr->name,
4107 				      (shash_t **) NULL);
4108 		    }
4109 
4110 		  /* We now know the index of this symbol; fill in
4111 		     locations that have been waiting for that
4112 		     information.  */
4113 		  if (sym_ptr->begin_ptr != (localsym_t *) NULL)
4114 		    {
4115 		      localsym_t *begin_ptr;
4116 		      st_t begin_type;
4117 
4118 		      know (local);
4119 		      begin_ptr = sym_ptr->begin_ptr;
4120 		      know (begin_ptr->sym_index != -1);
4121 		      sym_ptr->ecoff_sym.asym.index = begin_ptr->sym_index;
4122 		      if (sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
4123 			sym_ptr->ecoff_sym.asym.iss =
4124 			  begin_ptr->ecoff_sym.asym.iss;
4125 
4126 		      begin_type = (st_t) begin_ptr->ecoff_sym.asym.st;
4127 		      if (begin_type == st_File
4128 			  || begin_type == st_Block)
4129 			{
4130 			  begin_ptr->ecoff_sym.asym.index =
4131 			    isym - ifilesym + 1;
4132 			  (*swap_sym_out) (stdoutput,
4133 					   &begin_ptr->ecoff_sym.asym,
4134 					   (*buf
4135 					    + offset
4136 					    + (begin_ptr->sym_index
4137 					       * external_sym_size)));
4138 			}
4139 		      else
4140 			{
4141 			  know (begin_ptr->index_ptr != (aux_t *) NULL);
4142 			  begin_ptr->index_ptr->data.isym =
4143 			    isym - ifilesym + 1;
4144 			}
4145 
4146 		      /* The value of the symbol marking the end of a
4147 		         procedure is the size of the procedure.  The
4148 		         value of the symbol marking the end of a
4149 		         block is the offset from the start of the
4150 		         procedure to the block.  */
4151 		      if (begin_type == st_Proc
4152 			  || begin_type == st_StaticProc)
4153 			{
4154 			  know (as_sym != (symbolS *) NULL);
4155 			  know (begin_ptr->as_sym != (symbolS *) NULL);
4156 			  if (S_GET_SEGMENT (as_sym)
4157 			      != S_GET_SEGMENT (begin_ptr->as_sym))
4158 			    as_warn (_(".begin/.bend in different segments"));
4159 			  sym_ptr->ecoff_sym.asym.value =
4160 			    (S_GET_VALUE (as_sym)
4161 			     - S_GET_VALUE (begin_ptr->as_sym));
4162 
4163 			  /* If the size is odd, this is probably a
4164 			     mips16 function; force it to be even.  */
4165 			  if ((sym_ptr->ecoff_sym.asym.value & 1) != 0)
4166 			    ++sym_ptr->ecoff_sym.asym.value;
4167 
4168 #ifdef S_SET_SIZE
4169 			  S_SET_SIZE (begin_ptr->as_sym,
4170 				      sym_ptr->ecoff_sym.asym.value);
4171 #endif
4172 			}
4173 		      else if (begin_type == st_Block
4174 			       && sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
4175 			{
4176 			  symbolS *begin_sym;
4177 
4178 			  know (as_sym != (symbolS *) NULL);
4179 			  know (sym_ptr->proc_ptr != (proc_t *) NULL);
4180 			  begin_sym = sym_ptr->proc_ptr->sym->as_sym;
4181 			  if (S_GET_SEGMENT (as_sym)
4182 			      != S_GET_SEGMENT (begin_sym))
4183 			    as_warn (_(".begin/.bend in different segments"));
4184 			  sym_ptr->ecoff_sym.asym.value =
4185 			    S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym);
4186 			}
4187 		    }
4188 
4189 		  for (f = sym_ptr->forward_ref;
4190 		       f != (forward_t *) NULL;
4191 		       f = f->next)
4192 		    {
4193 		      know (local);
4194 		      f->ifd_ptr->data.isym = fil_ptr->file_index;
4195 		      f->index_ptr->data.rndx.index = isym - ifilesym;
4196 		    }
4197 
4198 		  if (local)
4199 		    {
4200 		      if ((bfd_size_type)(*bufend - sym_out) < external_sym_size)
4201 			sym_out = ecoff_add_bytes (buf, bufend,
4202 						   sym_out,
4203 						   external_sym_size);
4204 		      (*swap_sym_out) (stdoutput, &sym_ptr->ecoff_sym.asym,
4205 				       sym_out);
4206 		      sym_out += external_sym_size;
4207 
4208 		      sym_ptr->sym_index = isym;
4209 
4210 		      if (sym_ptr->proc_ptr != (proc_t *) NULL
4211 			  && sym_ptr->proc_ptr->sym == sym_ptr)
4212 			sym_ptr->proc_ptr->pdr.isym = isym - ifilesym;
4213 
4214 		      ++isym;
4215 		    }
4216 
4217 		  /* Record the local symbol index and file number in
4218 		     case this is an external symbol.  Note that this
4219 		     destroys the asym.index field.  */
4220 		  if (as_sym != (symbolS *) NULL
4221 		      && symbol_get_obj (as_sym)->ecoff_symbol == sym_ptr)
4222 		    {
4223 		      if ((sym_ptr->ecoff_sym.asym.st == st_Proc
4224 			   || sym_ptr->ecoff_sym.asym.st == st_StaticProc)
4225 			  && local)
4226 			sym_ptr->ecoff_sym.asym.index = isym - ifilesym - 1;
4227 		      sym_ptr->ecoff_sym.ifd = fil_ptr->file_index;
4228 
4229 		      /* Don't try to merge an FDR which has an
4230 		         external symbol attached to it.  */
4231 		      if (S_IS_EXTERNAL (as_sym) || S_IS_WEAK (as_sym))
4232 			fil_ptr->fdr.fMerge = 0;
4233 		    }
4234 		}
4235 	    }
4236 	  fil_ptr->fdr.csym = isym - fil_ptr->fdr.isymBase;
4237 	}
4238     }
4239 
4240   return offset + isym * external_sym_size;
4241 }
4242 
4243 /* Swap out the procedure information.  */
4244 
4245 static unsigned long
ecoff_build_procs(const struct ecoff_debug_swap * backend,char ** buf,char ** bufend,unsigned long offset)4246 ecoff_build_procs (const struct ecoff_debug_swap *backend,
4247 		   char **buf,
4248 		   char **bufend,
4249 		   unsigned long offset)
4250 {
4251   const bfd_size_type external_pdr_size = backend->external_pdr_size;
4252   void (* const swap_pdr_out) (bfd *, const PDR *, void *)
4253     = backend->swap_pdr_out;
4254   char *pdr_out;
4255   long iproc;
4256   vlinks_t *file_link;
4257 
4258   pdr_out = *buf + offset;
4259 
4260   iproc = 0;
4261 
4262   /* The procedures are stored by file.  */
4263   for (file_link = file_desc.first;
4264        file_link != (vlinks_t *) NULL;
4265        file_link = file_link->next)
4266     {
4267       int fil_cnt;
4268       efdr_t *fil_ptr;
4269       efdr_t *fil_end;
4270 
4271       if (file_link->next == (vlinks_t *) NULL)
4272 	fil_cnt = file_desc.objects_last_page;
4273       else
4274 	fil_cnt = file_desc.objects_per_page;
4275       fil_ptr = file_link->datum->file;
4276       fil_end = fil_ptr + fil_cnt;
4277       for (; fil_ptr < fil_end; fil_ptr++)
4278 	{
4279 	  vlinks_t *proc_link;
4280 	  int first;
4281 
4282 	  fil_ptr->fdr.ipdFirst = iproc;
4283 	  first = 1;
4284 	  for (proc_link = fil_ptr->procs.first;
4285 	       proc_link != (vlinks_t *) NULL;
4286 	       proc_link = proc_link->next)
4287 	    {
4288 	      int prc_cnt;
4289 	      proc_t *proc_ptr;
4290 	      proc_t *proc_end;
4291 
4292 	      if (proc_link->next == (vlinks_t *) NULL)
4293 		prc_cnt = fil_ptr->procs.objects_last_page;
4294 	      else
4295 		prc_cnt = fil_ptr->procs.objects_per_page;
4296 	      proc_ptr = proc_link->datum->proc;
4297 	      proc_end = proc_ptr + prc_cnt;
4298 	      for (; proc_ptr < proc_end; proc_ptr++)
4299 		{
4300 		  symbolS *adr_sym;
4301 		  unsigned long adr;
4302 
4303 		  adr_sym = proc_ptr->sym->as_sym;
4304 		  adr = (S_GET_VALUE (adr_sym)
4305 			 + bfd_get_section_vma (stdoutput,
4306 						S_GET_SEGMENT (adr_sym)));
4307 		  if (first)
4308 		    {
4309 		      /* This code used to force the adr of the very
4310 		         first fdr to be 0.  However, the native tools
4311 		         don't do that, and I can't remember why it
4312 		         used to work that way, so I took it out.  */
4313 		      fil_ptr->fdr.adr = adr;
4314 		      first = 0;
4315 		    }
4316 		  proc_ptr->pdr.adr = adr - fil_ptr->fdr.adr;
4317 		  if ((bfd_size_type)(*bufend - pdr_out) < external_pdr_size)
4318 		    pdr_out = ecoff_add_bytes (buf, bufend,
4319 					       pdr_out,
4320 					       external_pdr_size);
4321 		  (*swap_pdr_out) (stdoutput, &proc_ptr->pdr, pdr_out);
4322 		  pdr_out += external_pdr_size;
4323 		  ++iproc;
4324 		}
4325 	    }
4326 	  fil_ptr->fdr.cpd = iproc - fil_ptr->fdr.ipdFirst;
4327 	}
4328     }
4329 
4330   return offset + iproc * external_pdr_size;
4331 }
4332 
4333 /* Swap out the aux information.  */
4334 
4335 static unsigned long
ecoff_build_aux(const struct ecoff_debug_swap * backend,char ** buf,char ** bufend,unsigned long offset)4336 ecoff_build_aux (const struct ecoff_debug_swap *backend,
4337 		 char **buf,
4338 		 char **bufend,
4339 		 unsigned long offset)
4340 {
4341   int bigendian;
4342   union aux_ext *aux_out;
4343   long iaux;
4344   vlinks_t *file_link;
4345 
4346   bigendian = bfd_big_endian (stdoutput);
4347 
4348   aux_out = (union aux_ext *) (*buf + offset);
4349 
4350   iaux = 0;
4351 
4352   /* The aux entries are stored by file.  */
4353   for (file_link = file_desc.first;
4354        file_link != (vlinks_t *) NULL;
4355        file_link = file_link->next)
4356     {
4357       int fil_cnt;
4358       efdr_t *fil_ptr;
4359       efdr_t *fil_end;
4360 
4361       if (file_link->next == (vlinks_t *) NULL)
4362 	fil_cnt = file_desc.objects_last_page;
4363       else
4364 	fil_cnt = file_desc.objects_per_page;
4365       fil_ptr = file_link->datum->file;
4366       fil_end = fil_ptr + fil_cnt;
4367       for (; fil_ptr < fil_end; fil_ptr++)
4368 	{
4369 	  vlinks_t *aux_link;
4370 
4371 	  fil_ptr->fdr.fBigendian = bigendian;
4372 	  fil_ptr->fdr.iauxBase = iaux;
4373 	  for (aux_link = fil_ptr->aux_syms.first;
4374 	       aux_link != (vlinks_t *) NULL;
4375 	       aux_link = aux_link->next)
4376 	    {
4377 	      int aux_cnt;
4378 	      aux_t *aux_ptr;
4379 	      aux_t *aux_end;
4380 
4381 	      if (aux_link->next == (vlinks_t *) NULL)
4382 		aux_cnt = fil_ptr->aux_syms.objects_last_page;
4383 	      else
4384 		aux_cnt = fil_ptr->aux_syms.objects_per_page;
4385 	      aux_ptr = aux_link->datum->aux;
4386 	      aux_end = aux_ptr + aux_cnt;
4387 	      for (; aux_ptr < aux_end; aux_ptr++)
4388 		{
4389 		  if ((unsigned long) (*bufend - (char *) aux_out)
4390 		      < sizeof (union aux_ext))
4391 		    aux_out = ((union aux_ext *)
4392 			       ecoff_add_bytes (buf, bufend,
4393 						(char *) aux_out,
4394 						sizeof (union aux_ext)));
4395 		  switch (aux_ptr->type)
4396 		    {
4397 		    case aux_tir:
4398 		      (*backend->swap_tir_out) (bigendian,
4399 						&aux_ptr->data.ti,
4400 						&aux_out->a_ti);
4401 		      break;
4402 		    case aux_rndx:
4403 		      (*backend->swap_rndx_out) (bigendian,
4404 						 &aux_ptr->data.rndx,
4405 						 &aux_out->a_rndx);
4406 		      break;
4407 		    case aux_dnLow:
4408 		      AUX_PUT_DNLOW (bigendian, aux_ptr->data.dnLow,
4409 				     aux_out);
4410 		      break;
4411 		    case aux_dnHigh:
4412 		      AUX_PUT_DNHIGH (bigendian, aux_ptr->data.dnHigh,
4413 				      aux_out);
4414 		      break;
4415 		    case aux_isym:
4416 		      AUX_PUT_ISYM (bigendian, aux_ptr->data.isym,
4417 				    aux_out);
4418 		      break;
4419 		    case aux_iss:
4420 		      AUX_PUT_ISS (bigendian, aux_ptr->data.iss,
4421 				   aux_out);
4422 		      break;
4423 		    case aux_width:
4424 		      AUX_PUT_WIDTH (bigendian, aux_ptr->data.width,
4425 				     aux_out);
4426 		      break;
4427 		    case aux_count:
4428 		      AUX_PUT_COUNT (bigendian, aux_ptr->data.count,
4429 				     aux_out);
4430 		      break;
4431 		    }
4432 
4433 		  ++aux_out;
4434 		  ++iaux;
4435 		}
4436 	    }
4437 	  fil_ptr->fdr.caux = iaux - fil_ptr->fdr.iauxBase;
4438 	}
4439     }
4440 
4441   return ecoff_padding_adjust (backend, buf, bufend,
4442 			       offset + iaux * sizeof (union aux_ext),
4443 			       (char **) NULL);
4444 }
4445 
4446 /* Copy out the strings from a varray_t.  This returns the number of
4447    bytes copied, rather than the new offset.  */
4448 
4449 static unsigned long
ecoff_build_strings(char ** buf,char ** bufend,unsigned long offset,varray_t * vp)4450 ecoff_build_strings (char **buf,
4451 		     char **bufend,
4452 		     unsigned long offset,
4453 		     varray_t *vp)
4454 {
4455   unsigned long istr;
4456   char *str_out;
4457   vlinks_t *str_link;
4458 
4459   str_out = *buf + offset;
4460 
4461   istr = 0;
4462 
4463   for (str_link = vp->first;
4464        str_link != (vlinks_t *) NULL;
4465        str_link = str_link->next)
4466     {
4467       unsigned long str_cnt;
4468 
4469       if (str_link->next == (vlinks_t *) NULL)
4470 	str_cnt = vp->objects_last_page;
4471       else
4472 	str_cnt = vp->objects_per_page;
4473 
4474       if ((unsigned long)(*bufend - str_out) < str_cnt)
4475 	str_out = ecoff_add_bytes (buf, bufend, str_out, str_cnt);
4476 
4477       memcpy (str_out, str_link->datum->byte, str_cnt);
4478       str_out += str_cnt;
4479       istr += str_cnt;
4480     }
4481 
4482   return istr;
4483 }
4484 
4485 /* Dump out the local strings.  */
4486 
4487 static unsigned long
ecoff_build_ss(const struct ecoff_debug_swap * backend,char ** buf,char ** bufend,unsigned long offset)4488 ecoff_build_ss (const struct ecoff_debug_swap *backend,
4489 		char **buf,
4490 		char **bufend,
4491 		unsigned long offset)
4492 {
4493   long iss;
4494   vlinks_t *file_link;
4495 
4496   iss = 0;
4497 
4498   for (file_link = file_desc.first;
4499        file_link != (vlinks_t *) NULL;
4500        file_link = file_link->next)
4501     {
4502       int fil_cnt;
4503       efdr_t *fil_ptr;
4504       efdr_t *fil_end;
4505 
4506       if (file_link->next == (vlinks_t *) NULL)
4507 	fil_cnt = file_desc.objects_last_page;
4508       else
4509 	fil_cnt = file_desc.objects_per_page;
4510       fil_ptr = file_link->datum->file;
4511       fil_end = fil_ptr + fil_cnt;
4512       for (; fil_ptr < fil_end; fil_ptr++)
4513 	{
4514 	  long ss_cnt;
4515 
4516 	  fil_ptr->fdr.issBase = iss;
4517 	  ss_cnt = ecoff_build_strings (buf, bufend, offset + iss,
4518 					&fil_ptr->strings);
4519 	  fil_ptr->fdr.cbSs = ss_cnt;
4520 	  iss += ss_cnt;
4521 	}
4522     }
4523 
4524   return ecoff_padding_adjust (backend, buf, bufend, offset + iss,
4525 			       (char **) NULL);
4526 }
4527 
4528 /* Swap out the file descriptors.  */
4529 
4530 static unsigned long
ecoff_build_fdr(const struct ecoff_debug_swap * backend,char ** buf,char ** bufend,unsigned long offset)4531 ecoff_build_fdr (const struct ecoff_debug_swap *backend,
4532 		 char **buf,
4533 		 char **bufend,
4534 		 unsigned long offset)
4535 {
4536   const bfd_size_type external_fdr_size = backend->external_fdr_size;
4537   void (* const swap_fdr_out) (bfd *, const FDR *, void *)
4538     = backend->swap_fdr_out;
4539   long ifile;
4540   char *fdr_out;
4541   vlinks_t *file_link;
4542 
4543   ifile = 0;
4544 
4545   fdr_out = *buf + offset;
4546 
4547   for (file_link = file_desc.first;
4548        file_link != (vlinks_t *) NULL;
4549        file_link = file_link->next)
4550     {
4551       int fil_cnt;
4552       efdr_t *fil_ptr;
4553       efdr_t *fil_end;
4554 
4555       if (file_link->next == (vlinks_t *) NULL)
4556 	fil_cnt = file_desc.objects_last_page;
4557       else
4558 	fil_cnt = file_desc.objects_per_page;
4559       fil_ptr = file_link->datum->file;
4560       fil_end = fil_ptr + fil_cnt;
4561       for (; fil_ptr < fil_end; fil_ptr++)
4562 	{
4563 	  if ((bfd_size_type)(*bufend - fdr_out) < external_fdr_size)
4564 	    fdr_out = ecoff_add_bytes (buf, bufend, fdr_out,
4565 				       external_fdr_size);
4566 	  (*swap_fdr_out) (stdoutput, &fil_ptr->fdr, fdr_out);
4567 	  fdr_out += external_fdr_size;
4568 	  ++ifile;
4569 	}
4570     }
4571 
4572   return offset + ifile * external_fdr_size;
4573 }
4574 
4575 /* Set up the external symbols.  These are supposed to be handled by
4576    the backend.  This routine just gets the right information and
4577    calls a backend function to deal with it.  */
4578 
4579 static void
ecoff_setup_ext(void)4580 ecoff_setup_ext (void)
4581 {
4582   symbolS *sym;
4583 
4584   for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
4585     {
4586       if (symbol_get_obj (sym)->ecoff_symbol == NULL)
4587 	continue;
4588 
4589       /* If this is a local symbol, then force the fields to zero.  */
4590       if (! S_IS_EXTERNAL (sym)
4591 	  && ! S_IS_WEAK (sym)
4592 	  && S_IS_DEFINED (sym))
4593 	{
4594 	  struct localsym *lsym;
4595 
4596 	  lsym = symbol_get_obj (sym)->ecoff_symbol;
4597 	  lsym->ecoff_sym.asym.value = 0;
4598 	  lsym->ecoff_sym.asym.st = (int) st_Nil;
4599 	  lsym->ecoff_sym.asym.sc = (int) sc_Nil;
4600 	  lsym->ecoff_sym.asym.index = indexNil;
4601 	}
4602 
4603       obj_ecoff_set_ext (sym, &symbol_get_obj (sym)->ecoff_symbol->ecoff_sym);
4604     }
4605 }
4606 
4607 /* Build the ECOFF debugging information.  */
4608 
4609 unsigned long
ecoff_build_debug(HDRR * hdr,char ** bufp,const struct ecoff_debug_swap * backend)4610 ecoff_build_debug (HDRR *hdr,
4611 		   char **bufp,
4612 		   const struct ecoff_debug_swap *backend)
4613 {
4614   const bfd_size_type external_pdr_size = backend->external_pdr_size;
4615   tag_t *ptag;
4616   tag_t *ptag_next;
4617   efdr_t *fil_ptr;
4618   int end_warning;
4619   efdr_t *hold_file_ptr;
4620   proc_t *hold_proc_ptr;
4621   symbolS *sym;
4622   char *buf;
4623   char *bufend;
4624   unsigned long offset;
4625 
4626   /* Make sure we have a file.  */
4627   if (first_file == (efdr_t *) NULL)
4628     add_file ((const char *) NULL, 0, 1);
4629 
4630   /* Handle any top level tags.  */
4631   for (ptag = top_tag_head->first_tag;
4632        ptag != (tag_t *) NULL;
4633        ptag = ptag_next)
4634     {
4635       if (ptag->forward_ref != (forward_t *) NULL)
4636 	add_unknown_tag (ptag);
4637 
4638       ptag_next = ptag->same_block;
4639       ptag->hash_ptr->tag_ptr = ptag->same_name;
4640       free_tag (ptag);
4641     }
4642 
4643   free_thead (top_tag_head);
4644 
4645   /* Look through the symbols.  Add debugging information for each
4646      symbol that has not already received it.  */
4647   hold_file_ptr = cur_file_ptr;
4648   hold_proc_ptr = cur_proc_ptr;
4649   cur_proc_ptr = (proc_t *) NULL;
4650   for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
4651     {
4652       if (symbol_get_obj (sym)->ecoff_symbol != NULL
4653 	  || symbol_get_obj (sym)->ecoff_file == (efdr_t *) NULL
4654 	  || (symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) != 0)
4655 	continue;
4656 
4657       cur_file_ptr = symbol_get_obj (sym)->ecoff_file;
4658       add_ecoff_symbol ((const char *) NULL, st_Nil, sc_Nil, sym,
4659 			(bfd_vma) 0, S_GET_VALUE (sym), indexNil);
4660     }
4661   cur_proc_ptr = hold_proc_ptr;
4662   cur_file_ptr = hold_file_ptr;
4663 
4664   /* Output an ending symbol for all the files.  We have to do this
4665      here for the last file, so we may as well do it for all of the
4666      files.  */
4667   end_warning = 0;
4668   for (fil_ptr = first_file;
4669        fil_ptr != (efdr_t *) NULL;
4670        fil_ptr = fil_ptr->next_file)
4671     {
4672       cur_file_ptr = fil_ptr;
4673       while (cur_file_ptr->cur_scope != (scope_t *) NULL
4674 	     && cur_file_ptr->cur_scope->prev != (scope_t *) NULL)
4675 	{
4676 	  cur_file_ptr->cur_scope = cur_file_ptr->cur_scope->prev;
4677 	  if (! end_warning && ! cur_file_ptr->fake)
4678 	    {
4679 	      as_warn (_("missing .end or .bend at end of file"));
4680 	      end_warning = 1;
4681 	    }
4682 	}
4683       if (cur_file_ptr->cur_scope != (scope_t *) NULL)
4684 	(void) add_ecoff_symbol ((const char *) NULL,
4685 				 st_End, sc_Text,
4686 				 (symbolS *) NULL,
4687 				 (bfd_vma) 0,
4688 				 (symint_t) 0,
4689 				 (symint_t) 0);
4690     }
4691 
4692   /* Build the symbolic information.  */
4693   offset = 0;
4694   buf = XNEWVEC (char, PAGE_SIZE);
4695   bufend = buf + PAGE_SIZE;
4696 
4697   /* Build the line number information.  */
4698   hdr->cbLineOffset = offset;
4699   offset = ecoff_build_lineno (backend, &buf, &bufend, offset,
4700 			       &hdr->ilineMax);
4701   hdr->cbLine = offset - hdr->cbLineOffset;
4702 
4703   /* We don't use dense numbers at all.  */
4704   hdr->idnMax = 0;
4705   hdr->cbDnOffset = 0;
4706 
4707   /* We can't build the PDR table until we have built the symbols,
4708      because a PDR contains a symbol index.  However, we set aside
4709      space at this point.  */
4710   hdr->ipdMax = proc_cnt;
4711   hdr->cbPdOffset = offset;
4712   if ((bfd_size_type)(bufend - (buf + offset)) < proc_cnt * external_pdr_size)
4713     (void) ecoff_add_bytes (&buf, &bufend, buf + offset,
4714 			    proc_cnt * external_pdr_size);
4715   offset += proc_cnt * external_pdr_size;
4716 
4717   /* Build the local symbols.  */
4718   hdr->cbSymOffset = offset;
4719   offset = ecoff_build_symbols (backend, &buf, &bufend, offset);
4720   hdr->isymMax = (offset - hdr->cbSymOffset) / backend->external_sym_size;
4721 
4722   /* Building the symbols initializes the symbol index in the PDR's.
4723      Now we can swap out the PDR's.  */
4724   (void) ecoff_build_procs (backend, &buf, &bufend, hdr->cbPdOffset);
4725 
4726   /* We don't use optimization symbols.  */
4727   hdr->ioptMax = 0;
4728   hdr->cbOptOffset = 0;
4729 
4730   /* Swap out the auxiliary type information.  */
4731   hdr->cbAuxOffset = offset;
4732   offset = ecoff_build_aux (backend, &buf, &bufend, offset);
4733   hdr->iauxMax = (offset - hdr->cbAuxOffset) / sizeof (union aux_ext);
4734 
4735   /* Copy out the local strings.  */
4736   hdr->cbSsOffset = offset;
4737   offset = ecoff_build_ss (backend, &buf, &bufend, offset);
4738   hdr->issMax = offset - hdr->cbSsOffset;
4739 
4740   /* We don't use relative file descriptors.  */
4741   hdr->crfd = 0;
4742   hdr->cbRfdOffset = 0;
4743 
4744   /* Swap out the file descriptors.  */
4745   hdr->cbFdOffset = offset;
4746   offset = ecoff_build_fdr (backend, &buf, &bufend, offset);
4747   hdr->ifdMax = (offset - hdr->cbFdOffset) / backend->external_fdr_size;
4748 
4749   /* Set up the external symbols, which are handled by the BFD back
4750      end.  */
4751   hdr->issExtMax = 0;
4752   hdr->cbSsExtOffset = 0;
4753   hdr->iextMax = 0;
4754   hdr->cbExtOffset = 0;
4755   ecoff_setup_ext ();
4756 
4757   know ((offset & (backend->debug_align - 1)) == 0);
4758 
4759   /* FIXME: This value should be determined from the .verstamp directive,
4760      with reasonable defaults in config files.  */
4761 #ifdef TC_ALPHA
4762   hdr->vstamp = 0x030b;
4763 #else
4764   hdr->vstamp = 0x020b;
4765 #endif
4766 
4767   *bufp = buf;
4768   return offset;
4769 }
4770 
4771 /* Allocate a cluster of pages.  */
4772 
4773 #ifndef MALLOC_CHECK
4774 
4775 static page_type *
allocate_cluster(unsigned long npages)4776 allocate_cluster (unsigned long npages)
4777 {
4778   page_type *value = (page_type *) xmalloc (npages * PAGE_USIZE);
4779 
4780 #ifdef ECOFF_DEBUG
4781   if (debug > 3)
4782     fprintf (stderr, "\talloc\tnpages = %d, value = 0x%.8x\n", npages, value);
4783 #endif
4784 
4785   memset (value, 0, npages * PAGE_USIZE);
4786 
4787   return value;
4788 }
4789 
4790 static page_type *cluster_ptr = NULL;
4791 static unsigned long pages_left = 0;
4792 
4793 #endif /* MALLOC_CHECK */
4794 
4795 /* Allocate one page (which is initialized to 0).  */
4796 
4797 static page_type *
allocate_page(void)4798 allocate_page (void)
4799 {
4800 #ifndef MALLOC_CHECK
4801 
4802   if (pages_left == 0)
4803     {
4804       pages_left = MAX_CLUSTER_PAGES;
4805       cluster_ptr = allocate_cluster (pages_left);
4806     }
4807 
4808   pages_left--;
4809   return cluster_ptr++;
4810 
4811 #else /* MALLOC_CHECK */
4812 
4813   page_type *ptr;
4814 
4815   ptr = xmalloc (PAGE_USIZE);
4816   memset (ptr, 0, PAGE_USIZE);
4817   return ptr;
4818 
4819 #endif /* MALLOC_CHECK */
4820 }
4821 
4822 /* Allocate scoping information.  */
4823 
4824 static scope_t *
allocate_scope(void)4825 allocate_scope (void)
4826 {
4827   scope_t *ptr;
4828   static scope_t initial_scope;
4829 
4830 #ifndef MALLOC_CHECK
4831 
4832   ptr = alloc_counts[(int) alloc_type_scope].free_list.f_scope;
4833   if (ptr != (scope_t *) NULL)
4834     alloc_counts[(int) alloc_type_scope].free_list.f_scope = ptr->free;
4835   else
4836     {
4837       int unallocated	= alloc_counts[(int) alloc_type_scope].unallocated;
4838       page_type *cur_page	= alloc_counts[(int) alloc_type_scope].cur_page;
4839 
4840       if (unallocated == 0)
4841 	{
4842 	  unallocated = PAGE_SIZE / sizeof (scope_t);
4843 	  alloc_counts[(int) alloc_type_scope].cur_page = cur_page = allocate_page ();
4844 	  alloc_counts[(int) alloc_type_scope].total_pages++;
4845 	}
4846 
4847       ptr = &cur_page->scope[--unallocated];
4848       alloc_counts[(int) alloc_type_scope].unallocated = unallocated;
4849     }
4850 
4851 #else
4852 
4853   ptr = XNEW (scope_t);
4854 
4855 #endif
4856 
4857   alloc_counts[(int) alloc_type_scope].total_alloc++;
4858   *ptr = initial_scope;
4859   return ptr;
4860 }
4861 
4862 /* Free scoping information.  */
4863 
4864 static void
free_scope(scope_t * ptr)4865 free_scope (scope_t *ptr)
4866 {
4867   alloc_counts[(int) alloc_type_scope].total_free++;
4868 
4869 #ifndef MALLOC_CHECK
4870   ptr->free = alloc_counts[(int) alloc_type_scope].free_list.f_scope;
4871   alloc_counts[(int) alloc_type_scope].free_list.f_scope = ptr;
4872 #else
4873   free ((void *) ptr);
4874 #endif
4875 }
4876 
4877 /* Allocate links for pages in a virtual array.  */
4878 
4879 static vlinks_t *
allocate_vlinks(void)4880 allocate_vlinks (void)
4881 {
4882   vlinks_t *ptr;
4883   static vlinks_t initial_vlinks;
4884 
4885 #ifndef MALLOC_CHECK
4886 
4887   int unallocated = alloc_counts[(int) alloc_type_vlinks].unallocated;
4888   page_type *cur_page = alloc_counts[(int) alloc_type_vlinks].cur_page;
4889 
4890   if (unallocated == 0)
4891     {
4892       unallocated = PAGE_SIZE / sizeof (vlinks_t);
4893       alloc_counts[(int) alloc_type_vlinks].cur_page = cur_page = allocate_page ();
4894       alloc_counts[(int) alloc_type_vlinks].total_pages++;
4895     }
4896 
4897   ptr = &cur_page->vlinks[--unallocated];
4898   alloc_counts[(int) alloc_type_vlinks].unallocated = unallocated;
4899 
4900 #else
4901 
4902   ptr = XNEW (vlinks_t);
4903 
4904 #endif
4905 
4906   alloc_counts[(int) alloc_type_vlinks].total_alloc++;
4907   *ptr = initial_vlinks;
4908   return ptr;
4909 }
4910 
4911 /* Allocate string hash buckets.  */
4912 
4913 static shash_t *
allocate_shash(void)4914 allocate_shash (void)
4915 {
4916   shash_t *ptr;
4917   static shash_t initial_shash;
4918 
4919 #ifndef MALLOC_CHECK
4920 
4921   int unallocated = alloc_counts[(int) alloc_type_shash].unallocated;
4922   page_type *cur_page = alloc_counts[(int) alloc_type_shash].cur_page;
4923 
4924   if (unallocated == 0)
4925     {
4926       unallocated = PAGE_SIZE / sizeof (shash_t);
4927       alloc_counts[(int) alloc_type_shash].cur_page = cur_page = allocate_page ();
4928       alloc_counts[(int) alloc_type_shash].total_pages++;
4929     }
4930 
4931   ptr = &cur_page->shash[--unallocated];
4932   alloc_counts[(int) alloc_type_shash].unallocated = unallocated;
4933 
4934 #else
4935 
4936   ptr = XNEW (shash_t);
4937 
4938 #endif
4939 
4940   alloc_counts[(int) alloc_type_shash].total_alloc++;
4941   *ptr = initial_shash;
4942   return ptr;
4943 }
4944 
4945 /* Allocate type hash buckets.  */
4946 
4947 static thash_t *
allocate_thash(void)4948 allocate_thash (void)
4949 {
4950   thash_t *ptr;
4951   static thash_t initial_thash;
4952 
4953 #ifndef MALLOC_CHECK
4954 
4955   int unallocated = alloc_counts[(int) alloc_type_thash].unallocated;
4956   page_type *cur_page = alloc_counts[(int) alloc_type_thash].cur_page;
4957 
4958   if (unallocated == 0)
4959     {
4960       unallocated = PAGE_SIZE / sizeof (thash_t);
4961       alloc_counts[(int) alloc_type_thash].cur_page = cur_page = allocate_page ();
4962       alloc_counts[(int) alloc_type_thash].total_pages++;
4963     }
4964 
4965   ptr = &cur_page->thash[--unallocated];
4966   alloc_counts[(int) alloc_type_thash].unallocated = unallocated;
4967 
4968 #else
4969 
4970   ptr = XNEW (thash_t);
4971 
4972 #endif
4973 
4974   alloc_counts[(int) alloc_type_thash].total_alloc++;
4975   *ptr = initial_thash;
4976   return ptr;
4977 }
4978 
4979 /* Allocate structure, union, or enum tag information.  */
4980 
4981 static tag_t *
allocate_tag(void)4982 allocate_tag (void)
4983 {
4984   tag_t *ptr;
4985   static tag_t initial_tag;
4986 
4987 #ifndef MALLOC_CHECK
4988 
4989   ptr = alloc_counts[(int) alloc_type_tag].free_list.f_tag;
4990   if (ptr != (tag_t *) NULL)
4991     alloc_counts[(int) alloc_type_tag].free_list.f_tag = ptr->free;
4992   else
4993     {
4994       int unallocated = alloc_counts[(int) alloc_type_tag].unallocated;
4995       page_type *cur_page = alloc_counts[(int) alloc_type_tag].cur_page;
4996 
4997       if (unallocated == 0)
4998 	{
4999 	  unallocated = PAGE_SIZE / sizeof (tag_t);
5000 	  alloc_counts[(int) alloc_type_tag].cur_page = cur_page = allocate_page ();
5001 	  alloc_counts[(int) alloc_type_tag].total_pages++;
5002 	}
5003 
5004       ptr = &cur_page->tag[--unallocated];
5005       alloc_counts[(int) alloc_type_tag].unallocated = unallocated;
5006     }
5007 
5008 #else
5009 
5010   ptr = XNEW (tag_t);
5011 
5012 #endif
5013 
5014   alloc_counts[(int) alloc_type_tag].total_alloc++;
5015   *ptr = initial_tag;
5016   return ptr;
5017 }
5018 
5019 /* Free scoping information.  */
5020 
5021 static void
free_tag(tag_t * ptr)5022 free_tag (tag_t *ptr)
5023 {
5024   alloc_counts[(int) alloc_type_tag].total_free++;
5025 
5026 #ifndef MALLOC_CHECK
5027   ptr->free = alloc_counts[(int) alloc_type_tag].free_list.f_tag;
5028   alloc_counts[(int) alloc_type_tag].free_list.f_tag = ptr;
5029 #else
5030   free ((PTR_T) ptr);
5031 #endif
5032 }
5033 
5034 /* Allocate forward reference to a yet unknown tag.  */
5035 
5036 static forward_t *
allocate_forward(void)5037 allocate_forward (void)
5038 {
5039   forward_t *ptr;
5040   static forward_t initial_forward;
5041 
5042 #ifndef MALLOC_CHECK
5043 
5044   int unallocated = alloc_counts[(int) alloc_type_forward].unallocated;
5045   page_type *cur_page = alloc_counts[(int) alloc_type_forward].cur_page;
5046 
5047   if (unallocated == 0)
5048     {
5049       unallocated = PAGE_SIZE / sizeof (forward_t);
5050       alloc_counts[(int) alloc_type_forward].cur_page = cur_page = allocate_page ();
5051       alloc_counts[(int) alloc_type_forward].total_pages++;
5052     }
5053 
5054   ptr = &cur_page->forward[--unallocated];
5055   alloc_counts[(int) alloc_type_forward].unallocated = unallocated;
5056 
5057 #else
5058 
5059   ptr = XNEW (forward_t);
5060 
5061 #endif
5062 
5063   alloc_counts[(int) alloc_type_forward].total_alloc++;
5064   *ptr = initial_forward;
5065   return ptr;
5066 }
5067 
5068 /* Allocate head of type hash list.  */
5069 
5070 static thead_t *
allocate_thead(void)5071 allocate_thead (void)
5072 {
5073   thead_t *ptr;
5074   static thead_t initial_thead;
5075 
5076 #ifndef MALLOC_CHECK
5077 
5078   ptr = alloc_counts[(int) alloc_type_thead].free_list.f_thead;
5079   if (ptr != (thead_t *) NULL)
5080     alloc_counts[(int) alloc_type_thead].free_list.f_thead = ptr->free;
5081   else
5082     {
5083       int unallocated = alloc_counts[(int) alloc_type_thead].unallocated;
5084       page_type *cur_page = alloc_counts[(int) alloc_type_thead].cur_page;
5085 
5086       if (unallocated == 0)
5087 	{
5088 	  unallocated = PAGE_SIZE / sizeof (thead_t);
5089 	  alloc_counts[(int) alloc_type_thead].cur_page = cur_page = allocate_page ();
5090 	  alloc_counts[(int) alloc_type_thead].total_pages++;
5091 	}
5092 
5093       ptr = &cur_page->thead[--unallocated];
5094       alloc_counts[(int) alloc_type_thead].unallocated = unallocated;
5095     }
5096 
5097 #else
5098 
5099   ptr = XNEW (thead_t);
5100 
5101 #endif
5102 
5103   alloc_counts[(int) alloc_type_thead].total_alloc++;
5104   *ptr = initial_thead;
5105   return ptr;
5106 }
5107 
5108 /* Free scoping information.  */
5109 
5110 static void
free_thead(thead_t * ptr)5111 free_thead (thead_t *ptr)
5112 {
5113   alloc_counts[(int) alloc_type_thead].total_free++;
5114 
5115 #ifndef MALLOC_CHECK
5116   ptr->free = (thead_t *) alloc_counts[(int) alloc_type_thead].free_list.f_thead;
5117   alloc_counts[(int) alloc_type_thead].free_list.f_thead = ptr;
5118 #else
5119   free ((PTR_T) ptr);
5120 #endif
5121 }
5122 
5123 static lineno_list_t *
allocate_lineno_list(void)5124 allocate_lineno_list (void)
5125 {
5126   lineno_list_t *ptr;
5127   static lineno_list_t initial_lineno_list;
5128 
5129 #ifndef MALLOC_CHECK
5130 
5131   int unallocated = alloc_counts[(int) alloc_type_lineno].unallocated;
5132   page_type *cur_page = alloc_counts[(int) alloc_type_lineno].cur_page;
5133 
5134   if (unallocated == 0)
5135     {
5136       unallocated = PAGE_SIZE / sizeof (lineno_list_t);
5137       alloc_counts[(int) alloc_type_lineno].cur_page = cur_page = allocate_page ();
5138       alloc_counts[(int) alloc_type_lineno].total_pages++;
5139     }
5140 
5141   ptr = &cur_page->lineno[--unallocated];
5142   alloc_counts[(int) alloc_type_lineno].unallocated = unallocated;
5143 
5144 #else
5145 
5146   ptr = XNEW (lineno_list_t);
5147 
5148 #endif
5149 
5150   alloc_counts[(int) alloc_type_lineno].total_alloc++;
5151   *ptr = initial_lineno_list;
5152   return ptr;
5153 }
5154 
5155 void
ecoff_set_gp_prolog_size(int sz)5156 ecoff_set_gp_prolog_size (int sz)
5157 {
5158   if (cur_proc_ptr == 0)
5159     return;
5160 
5161   cur_proc_ptr->pdr.gp_prologue = sz;
5162   if (cur_proc_ptr->pdr.gp_prologue != sz)
5163     {
5164       as_warn (_("GP prologue size exceeds field size, using 0 instead"));
5165       cur_proc_ptr->pdr.gp_prologue = 0;
5166     }
5167 
5168   cur_proc_ptr->pdr.gp_used = 1;
5169 }
5170 
5171 int
ecoff_no_current_file(void)5172 ecoff_no_current_file (void)
5173 {
5174   return cur_file_ptr == (efdr_t *) NULL;
5175 }
5176 
5177 void
ecoff_generate_asm_lineno(void)5178 ecoff_generate_asm_lineno (void)
5179 {
5180   unsigned int lineno;
5181   const char *filename;
5182   lineno_list_t *list;
5183 
5184   filename = as_where (&lineno);
5185 
5186   if (current_stabs_filename == (char *) NULL
5187       || filename_cmp (current_stabs_filename, filename))
5188     add_file (filename, 0, 1);
5189 
5190   list = allocate_lineno_list ();
5191 
5192   list->next = (lineno_list_t *) NULL;
5193   list->file = cur_file_ptr;
5194   list->proc = cur_proc_ptr;
5195   list->frag = frag_now;
5196   list->paddr = frag_now_fix ();
5197   list->lineno = lineno;
5198 
5199   /* We don't want to merge files which have line numbers.  */
5200   cur_file_ptr->fdr.fMerge = 0;
5201 
5202   /* A .loc directive will sometimes appear before a .ent directive,
5203      which means that cur_proc_ptr will be NULL here.  Arrange to
5204      patch this up.  */
5205   if (cur_proc_ptr == (proc_t *) NULL)
5206     {
5207       lineno_list_t **pl;
5208 
5209       pl = &noproc_lineno;
5210       while (*pl != (lineno_list_t *) NULL)
5211 	pl = &(*pl)->next;
5212       *pl = list;
5213     }
5214   else
5215     {
5216       last_lineno = list;
5217       *last_lineno_ptr = list;
5218       last_lineno_ptr = &list->next;
5219     }
5220 }
5221 
5222 #else
5223 
5224 void
ecoff_generate_asm_lineno(void)5225 ecoff_generate_asm_lineno (void)
5226 {
5227 }
5228 
5229 #endif /* ECOFF_DEBUGGING */
5230