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