projects / deliverable / binutils-gdb.git / blob
? search:


682bc9efb195b41eec0035e31f25a8c78eee2533
[deliverable/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 /* Record whether we have seen any debugging information. */
1394 int ecoff_debugging_seen = 0;
1395
1396 /* Various statics. */
1397 static efdr_t *cur_file_ptr = (efdr_t *) 0; /* current file desc. header */
1398 static proc_t *cur_proc_ptr = (proc_t *) 0; /* current procedure header */
1399 static proc_t *first_proc_ptr = (proc_t *) 0; /* first procedure header */
1400 static thead_t *top_tag_head = (thead_t *) 0; /* top level tag head */
1401 static thead_t *cur_tag_head = (thead_t *) 0; /* current tag head */
1402 #ifdef ECOFF_DEBUG
1403 static int debug = 0; /* trace functions */
1404 #endif
1405 static int stabs_seen = 0; /* != 0 if stabs have been seen */
1406
1407 static int current_file_idx;
1408 static const char *current_stabs_filename;
1409
1410 /* Pseudo symbol to use when putting stabs into the symbol table. */
1411 #ifndef STABS_SYMBOL
1412 #define STABS_SYMBOL "@stabs"
1413 #endif
1414
1415 static char stabs_symbol[] = STABS_SYMBOL;
1416 \f
1417 /* Prototypes for functions defined in this file. */
1418
1419 static void add_varray_page PARAMS ((varray_t *vp));
1420 static symint_t add_string PARAMS ((varray_t *vp,
1421 struct hash_control *hash_tbl,
1422 const char *str,
1423 shash_t **ret_hash));
1424 static localsym_t *add_ecoff_symbol PARAMS ((const char *str, st_t type,
1425 sc_t storage, symbolS *sym,
1426 symint_t value,
1427 symint_t indx));
1428 static symint_t add_aux_sym_symint PARAMS ((symint_t aux_word));
1429 static symint_t add_aux_sym_rndx PARAMS ((int file_index,
1430 symint_t sym_index));
1431 static symint_t add_aux_sym_tir PARAMS ((type_info_t *t,
1432 hash_state_t state,
1433 thash_t **hash_tbl));
1434 static tag_t *get_tag PARAMS ((const char *tag, localsym_t *sym,
1435 bt_t basic_type));
1436 static void add_unknown_tag PARAMS ((tag_t *ptag));
1437 static void add_procedure PARAMS ((char *func));
1438 static void add_file PARAMS ((const char *file_name, int indx));
1439 #ifdef ECOFF_DEBUG
1440 static char *sc_to_string PARAMS ((sc_t storage_class));
1441 static char *st_to_string PARAMS ((st_t symbol_type));
1442 #endif
1443 static void mark_stabs PARAMS ((int));
1444 static char *ecoff_add_bytes PARAMS ((char **buf, char **bufend,
1445 char *bufptr, unsigned long need));
1446 static unsigned long ecoff_padding_adjust
1447 PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1448 unsigned long offset, char **bufptrptr));
1449 static unsigned long ecoff_build_lineno
1450 PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1451 unsigned long offset, long *linecntptr));
1452 static unsigned long ecoff_build_symbols
1453 PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1454 unsigned long offset));
1455 static unsigned long ecoff_build_procs
1456 PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1457 unsigned long offset));
1458 static unsigned long ecoff_build_aux
1459 PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1460 unsigned long offset));
1461 static unsigned long ecoff_build_strings PARAMS ((char **buf, char **bufend,
1462 unsigned long offset,
1463 varray_t *vp));
1464 static unsigned long ecoff_build_ss
1465 PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1466 unsigned long offset));
1467 static unsigned long ecoff_build_fdr
1468 PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1469 unsigned long offset));
1470 static void ecoff_setup_ext PARAMS ((void));
1471 static page_t *allocate_cluster PARAMS ((unsigned long npages));
1472 static page_t *allocate_page PARAMS ((void));
1473 static scope_t *allocate_scope PARAMS ((void));
1474 static void free_scope PARAMS ((scope_t *ptr));
1475 static vlinks_t *allocate_vlinks PARAMS ((void));
1476 static shash_t *allocate_shash PARAMS ((void));
1477 static thash_t *allocate_thash PARAMS ((void));
1478 static tag_t *allocate_tag PARAMS ((void));
1479 static void free_tag PARAMS ((tag_t *ptr));
1480 static forward_t *allocate_forward PARAMS ((void));
1481 static thead_t *allocate_thead PARAMS ((void));
1482 static void free_thead PARAMS ((thead_t *ptr));
1483 static lineno_list_t *allocate_lineno_list PARAMS ((void));
1484 static void generate_ecoff_stab PARAMS ((int, const char *, int, int, int));
1485 \f
1486 /* This function should be called when the assembler starts up. */
1487
1488 void
1489 ecoff_read_begin_hook ()
1490 {
1491 tag_hash = hash_new ();
1492 top_tag_head = allocate_thead ();
1493 top_tag_head->first_tag = (tag_t *) NULL;
1494 top_tag_head->free = (thead_t *) NULL;
1495 top_tag_head->prev = cur_tag_head;
1496 cur_tag_head = top_tag_head;
1497 }
1498
1499 /* This function should be called when a symbol is created. */
1500
1501 void
1502 ecoff_symbol_new_hook (symbolP)
1503 symbolS *symbolP;
1504 {
1505 /* Make sure that we have a file pointer, but only if we have seen a
1506 file. If we haven't seen a file, then this is a probably special
1507 symbol created by md_begin which may required special handling at
1508 some point. Creating a dummy file with a dummy name is certainly
1509 wrong. */
1510 if (cur_file_ptr == (efdr_t *) NULL
1511 && seen_at_least_1_file ())
1512 add_file ((const char *) NULL, 0);
1513 symbolP->ecoff_file = cur_file_ptr;
1514 symbolP->ecoff_symbol = NULL;
1515 symbolP->ecoff_extern_size = 0;
1516 }
1517 \f
1518 /* Add a page to a varray object. */
1519
1520 static void
1521 add_varray_page (vp)
1522 varray_t *vp; /* varray to add page to */
1523 {
1524 vlinks_t *new_links = allocate_vlinks ();
1525
1526 #ifdef MALLOC_CHECK
1527 if (vp->object_size > 1)
1528 new_links->datum = (page_t *) xcalloc (1, vp->object_size);
1529 else
1530 #endif
1531 new_links->datum = allocate_page ();
1532
1533 alloc_counts[(int)alloc_type_varray].total_alloc++;
1534 alloc_counts[(int)alloc_type_varray].total_pages++;
1535
1536 new_links->start_index = vp->num_allocated;
1537 vp->objects_last_page = 0;
1538
1539 if (vp->first == (vlinks_t *) NULL) /* first allocation? */
1540 vp->first = vp->last = new_links;
1541 else
1542 { /* 2nd or greater allocation */
1543 new_links->prev = vp->last;
1544 vp->last->next = new_links;
1545 vp->last = new_links;
1546 }
1547 }
1548 \f
1549 /* Add a string (and null pad) to one of the string tables. */
1550
1551 static symint_t
1552 add_string (vp, hash_tbl, str, ret_hash)
1553 varray_t *vp; /* string obstack */
1554 struct hash_control *hash_tbl; /* ptr to hash table */
1555 const char *str; /* string */
1556 shash_t **ret_hash; /* return hash pointer */
1557 {
1558 register unsigned long len = strlen (str);
1559 register shash_t *hash_ptr;
1560
1561 if (len >= PAGE_USIZE)
1562 as_fatal ("String too big (%lu bytes)", len);
1563
1564 hash_ptr = (shash_t *) hash_find (hash_tbl, str);
1565 if (hash_ptr == (shash_t *) NULL)
1566 {
1567 register const char *err;
1568
1569 if (vp->objects_last_page + len >= PAGE_USIZE)
1570 {
1571 vp->num_allocated =
1572 ((vp->num_allocated + PAGE_USIZE - 1) / PAGE_USIZE) * PAGE_USIZE;
1573 add_varray_page (vp);
1574 }
1575
1576 hash_ptr = allocate_shash ();
1577 hash_ptr->indx = vp->num_allocated;
1578
1579 hash_ptr->string = &vp->last->datum->byte[vp->objects_last_page];
1580
1581 vp->objects_last_page += len + 1;
1582 vp->num_allocated += len + 1;
1583
1584 strcpy (hash_ptr->string, str);
1585
1586 err = hash_insert (hash_tbl, str, (char *) hash_ptr);
1587 if (err)
1588 as_fatal ("Inserting \"%s\" into string hash table: %s",
1589 str, err);
1590 }
1591
1592 if (ret_hash != (shash_t **) NULL)
1593 *ret_hash = hash_ptr;
1594
1595 return hash_ptr->indx;
1596 }
1597 \f
1598 /* Add debugging information for a symbol. */
1599
1600 static localsym_t *
1601 add_ecoff_symbol (str, type, storage, sym_value, value, indx)
1602 const char *str; /* symbol name */
1603 st_t type; /* symbol type */
1604 sc_t storage; /* storage class */
1605 symbolS *sym_value; /* associated symbol. */
1606 symint_t value; /* value of symbol */
1607 symint_t indx; /* index to local/aux. syms */
1608 {
1609 localsym_t *psym;
1610 register scope_t *pscope;
1611 register thead_t *ptag_head;
1612 register tag_t *ptag;
1613 register tag_t *ptag_next;
1614 register varray_t *vp;
1615 register int scope_delta = 0;
1616 shash_t *hash_ptr = (shash_t *) NULL;
1617
1618 if (cur_file_ptr == (efdr_t *) NULL)
1619 as_fatal ("no current file pointer");
1620
1621 vp = &cur_file_ptr->symbols;
1622
1623 if (vp->objects_last_page == vp->objects_per_page)
1624 add_varray_page (vp);
1625
1626 psym = &vp->last->datum->sym[ vp->objects_last_page++ ];
1627
1628 if (str == (const char *) NULL && sym_value != (symbolS *) NULL)
1629 psym->name = S_GET_NAME (sym_value);
1630 else
1631 psym->name = str;
1632 psym->as_sym = sym_value;
1633 if (sym_value != (symbolS *) NULL)
1634 sym_value->ecoff_symbol = psym;
1635 psym->file_ptr = cur_file_ptr;
1636 psym->proc_ptr = cur_proc_ptr;
1637 psym->begin_ptr = (localsym_t *) NULL;
1638 psym->index_ptr = (aux_t *) NULL;
1639 psym->forward_ref = (forward_t *) NULL;
1640 psym->sym_index = -1;
1641 memset (&psym->ecoff_sym, 0, sizeof (EXTR));
1642 psym->ecoff_sym.asym.value = value;
1643 psym->ecoff_sym.asym.st = (unsigned) type;
1644 psym->ecoff_sym.asym.sc = (unsigned) storage;
1645 psym->ecoff_sym.asym.index = indx;
1646
1647 /* If there is an associated symbol, we wait until the end of the
1648 assembly before deciding where to put the name (it may be just an
1649 external symbol). Otherwise, this is just a debugging symbol and
1650 the name should go with the current file. */
1651 if (sym_value == (symbolS *) NULL)
1652 psym->ecoff_sym.asym.iss = ((str == (const char *) NULL)
1653 ? 0
1654 : add_string (&cur_file_ptr->strings,
1655 cur_file_ptr->str_hash,
1656 str,
1657 &hash_ptr));
1658
1659 ++vp->num_allocated;
1660
1661 if (ECOFF_IS_STAB (&psym->ecoff_sym.asym))
1662 return psym;
1663
1664 /* Save the symbol within the hash table if this is a static
1665 item, and it has a name. */
1666 if (hash_ptr != (shash_t *) NULL
1667 && (type == st_Global || type == st_Static || type == st_Label
1668 || type == st_Proc || type == st_StaticProc))
1669 hash_ptr->sym_ptr = psym;
1670
1671 /* push or pop a scope if appropriate. */
1672 switch (type)
1673 {
1674 default:
1675 break;
1676
1677 case st_File: /* beginning of file */
1678 case st_Proc: /* procedure */
1679 case st_StaticProc: /* static procedure */
1680 case st_Block: /* begin scope */
1681 pscope = allocate_scope ();
1682 pscope->prev = cur_file_ptr->cur_scope;
1683 pscope->lsym = psym;
1684 pscope->type = type;
1685 cur_file_ptr->cur_scope = pscope;
1686
1687 if (type != st_File)
1688 scope_delta = 1;
1689
1690 /* For every block type except file, struct, union, or
1691 enumeration blocks, push a level on the tag stack. We omit
1692 file types, so that tags can span file boundaries. */
1693 if (type != st_File && storage != sc_Info)
1694 {
1695 ptag_head = allocate_thead ();
1696 ptag_head->first_tag = 0;
1697 ptag_head->prev = cur_tag_head;
1698 cur_tag_head = ptag_head;
1699 }
1700 break;
1701
1702 case st_End:
1703 pscope = cur_file_ptr->cur_scope;
1704 if (pscope == (scope_t *) NULL)
1705 as_fatal ("too many st_End's");
1706 else
1707 {
1708 st_t begin_type = (st_t) pscope->lsym->ecoff_sym.asym.st;
1709
1710 psym->begin_ptr = pscope->lsym;
1711
1712 if (begin_type != st_File)
1713 scope_delta = -1;
1714
1715 /* Except for file, structure, union, or enumeration end
1716 blocks remove all tags created within this scope. */
1717 if (begin_type != st_File && storage != sc_Info)
1718 {
1719 ptag_head = cur_tag_head;
1720 cur_tag_head = ptag_head->prev;
1721
1722 for (ptag = ptag_head->first_tag;
1723 ptag != (tag_t *) NULL;
1724 ptag = ptag_next)
1725 {
1726 if (ptag->forward_ref != (forward_t *) NULL)
1727 add_unknown_tag (ptag);
1728
1729 ptag_next = ptag->same_block;
1730 ptag->hash_ptr->tag_ptr = ptag->same_name;
1731 free_tag (ptag);
1732 }
1733
1734 free_thead (ptag_head);
1735 }
1736
1737 cur_file_ptr->cur_scope = pscope->prev;
1738
1739 /* block begin gets next sym #. This is set when we know
1740 the symbol index value. */
1741
1742 /* Functions push two or more aux words as follows:
1743 1st word: index+1 of the end symbol (filled in later).
1744 2nd word: type of the function (plus any aux words needed).
1745 Also, tie the external pointer back to the function begin symbol. */
1746 if (begin_type != st_File && begin_type != st_Block)
1747 {
1748 symint_t ty;
1749 varray_t *svp = &cur_file_ptr->aux_syms;
1750
1751 pscope->lsym->ecoff_sym.asym.index = add_aux_sym_symint (0);
1752 pscope->lsym->index_ptr =
1753 &svp->last->datum->aux[svp->objects_last_page - 1];
1754 ty = add_aux_sym_tir (&last_func_type_info,
1755 hash_no,
1756 &cur_file_ptr->thash_head[0]);
1757
1758 /* This seems to be unnecessary. I'm not even sure what it is
1759 * intended to do. It's from mips-tfile.
1760 * if (last_func_sym_value != (symbolS *) NULL)
1761 * {
1762 * last_func_sym_value->ifd = cur_file_ptr->file_index;
1763 * last_func_sym_value->index = ty;
1764 * }
1765 */
1766 }
1767
1768 free_scope (pscope);
1769 }
1770 }
1771
1772 cur_file_ptr->nested_scopes += scope_delta;
1773
1774 #ifdef ECOFF_DEBUG
1775 if (debug && type != st_File
1776 && (debug > 2 || type == st_Block || type == st_End
1777 || type == st_Proc || type == st_StaticProc))
1778 {
1779 char *sc_str = sc_to_string (storage);
1780 char *st_str = st_to_string (type);
1781 int depth = cur_file_ptr->nested_scopes + (scope_delta < 0);
1782
1783 fprintf (stderr,
1784 "\tlsym\tv= %10ld, depth= %2d, sc= %-12s",
1785 value, depth, sc_str);
1786
1787 if (str_start && str_end_p1 - str_start > 0)
1788 fprintf (stderr, " st= %-11s name= %.*s\n", st_str, str_end_p1 - str_start, str_start);
1789 else
1790 {
1791 unsigned long len = strlen (st_str);
1792 fprintf (stderr, " st= %.*s\n", len-1, st_str);
1793 }
1794 }
1795 #endif
1796
1797 return psym;
1798 }
1799 \f
1800 /* Add an auxiliary symbol (passing a symint). This is actually used
1801 for integral aux types, not just symints. */
1802
1803 static symint_t
1804 add_aux_sym_symint (aux_word)
1805 symint_t aux_word; /* auxiliary information word */
1806 {
1807 register varray_t *vp;
1808 register aux_t *aux_ptr;
1809
1810 if (cur_file_ptr == (efdr_t *) NULL)
1811 as_fatal ("no current file pointer");
1812
1813 vp = &cur_file_ptr->aux_syms;
1814
1815 if (vp->objects_last_page == vp->objects_per_page)
1816 add_varray_page (vp);
1817
1818 aux_ptr = &vp->last->datum->aux[vp->objects_last_page++];
1819 aux_ptr->type = aux_isym;
1820 aux_ptr->data.isym = aux_word;
1821
1822 return vp->num_allocated++;
1823 }
1824
1825
1826 /* Add an auxiliary symbol (passing a file/symbol index combo). */
1827
1828 static symint_t
1829 add_aux_sym_rndx (file_index, sym_index)
1830 int file_index;
1831 symint_t sym_index;
1832 {
1833 register varray_t *vp;
1834 register aux_t *aux_ptr;
1835
1836 if (cur_file_ptr == (efdr_t *) NULL)
1837 as_fatal ("no current file pointer");
1838
1839 vp = &cur_file_ptr->aux_syms;
1840
1841 if (vp->objects_last_page == vp->objects_per_page)
1842 add_varray_page (vp);
1843
1844 aux_ptr = &vp->last->datum->aux[vp->objects_last_page++];
1845 aux_ptr->type = aux_rndx;
1846 aux_ptr->data.rndx.rfd = file_index;
1847 aux_ptr->data.rndx.index = sym_index;
1848
1849 return vp->num_allocated++;
1850 }
1851 \f
1852 /* Add an auxiliary symbol (passing the basic type and possibly
1853 type qualifiers). */
1854
1855 static symint_t
1856 add_aux_sym_tir (t, state, hash_tbl)
1857 type_info_t *t; /* current type information */
1858 hash_state_t state; /* whether to hash type or not */
1859 thash_t **hash_tbl; /* pointer to hash table to use */
1860 {
1861 register varray_t *vp;
1862 register aux_t *aux_ptr;
1863 static AUXU init_aux;
1864 symint_t ret;
1865 int i;
1866 AUXU aux;
1867
1868 if (cur_file_ptr == (efdr_t *) NULL)
1869 as_fatal ("no current file pointer");
1870
1871 vp = &cur_file_ptr->aux_syms;
1872
1873 aux = init_aux;
1874 aux.ti.bt = (int) t->basic_type;
1875 aux.ti.continued = 0;
1876 aux.ti.fBitfield = t->bitfield;
1877
1878 aux.ti.tq0 = (int) t->type_qualifiers[0];
1879 aux.ti.tq1 = (int) t->type_qualifiers[1];
1880 aux.ti.tq2 = (int) t->type_qualifiers[2];
1881 aux.ti.tq3 = (int) t->type_qualifiers[3];
1882 aux.ti.tq4 = (int) t->type_qualifiers[4];
1883 aux.ti.tq5 = (int) t->type_qualifiers[5];
1884
1885
1886 /* For anything that adds additional information, we must not hash,
1887 so check here, and reset our state. */
1888
1889 if (state != hash_no
1890 && (t->type_qualifiers[0] == tq_Array
1891 || t->type_qualifiers[1] == tq_Array
1892 || t->type_qualifiers[2] == tq_Array
1893 || t->type_qualifiers[3] == tq_Array
1894 || t->type_qualifiers[4] == tq_Array
1895 || t->type_qualifiers[5] == tq_Array
1896 || t->basic_type == bt_Struct
1897 || t->basic_type == bt_Union
1898 || t->basic_type == bt_Enum
1899 || t->bitfield
1900 || t->num_dims > 0))
1901 state = hash_no;
1902
1903 /* See if we can hash this type, and save some space, but some types
1904 can't be hashed (because they contain arrays or continuations),
1905 and others can be put into the hash list, but cannot use existing
1906 types because other aux entries precede this one. */
1907
1908 if (state != hash_no)
1909 {
1910 register thash_t *hash_ptr;
1911 register symint_t hi;
1912
1913 hi = aux.isym & ((1 << HASHBITS) - 1);
1914 hi %= THASH_SIZE;
1915
1916 for (hash_ptr = hash_tbl[hi];
1917 hash_ptr != (thash_t *)0;
1918 hash_ptr = hash_ptr->next)
1919 {
1920 if (aux.isym == hash_ptr->type.isym)
1921 break;
1922 }
1923
1924 if (hash_ptr != (thash_t *) NULL && state == hash_yes)
1925 return hash_ptr->indx;
1926
1927 if (hash_ptr == (thash_t *) NULL)
1928 {
1929 hash_ptr = allocate_thash ();
1930 hash_ptr->next = hash_tbl[hi];
1931 hash_ptr->type = aux;
1932 hash_ptr->indx = vp->num_allocated;
1933 hash_tbl[hi] = hash_ptr;
1934 }
1935 }
1936
1937 /* Everything is set up, add the aux symbol. */
1938 if (vp->objects_last_page == vp->objects_per_page)
1939 add_varray_page (vp);
1940
1941 aux_ptr = &vp->last->datum->aux[ vp->objects_last_page++ ];
1942 aux_ptr->type = aux_tir;
1943 aux_ptr->data = aux;
1944
1945 ret = vp->num_allocated++;
1946
1947 /* Add bitfield length if it exists.
1948
1949 NOTE: Mips documentation claims bitfield goes at the end of the
1950 AUX record, but the DECstation compiler emits it here.
1951 (This would only make a difference for enum bitfields.)
1952
1953 Also note: We use the last size given since gcc may emit 2
1954 for an enum bitfield. */
1955
1956 if (t->bitfield)
1957 (void) add_aux_sym_symint ((symint_t)t->sizes[t->num_sizes-1]);
1958
1959
1960 /* Add tag information if needed. Structure, union, and enum
1961 references add 2 aux symbols: a [file index, symbol index]
1962 pointer to the structure type, and the current file index. */
1963
1964 if (t->basic_type == bt_Struct
1965 || t->basic_type == bt_Union
1966 || t->basic_type == bt_Enum)
1967 {
1968 register symint_t file_index = t->tag_ptr->ifd;
1969 register localsym_t *sym = t->tag_ptr->sym;
1970 register forward_t *forward_ref = allocate_forward ();
1971
1972 if (sym != (localsym_t *) NULL)
1973 {
1974 forward_ref->next = sym->forward_ref;
1975 sym->forward_ref = forward_ref;
1976 }
1977 else
1978 {
1979 forward_ref->next = t->tag_ptr->forward_ref;
1980 t->tag_ptr->forward_ref = forward_ref;
1981 }
1982
1983 (void) add_aux_sym_rndx (ST_RFDESCAPE, indexNil);
1984 forward_ref->index_ptr
1985 = &vp->last->datum->aux[ vp->objects_last_page - 1];
1986
1987 (void) add_aux_sym_symint (file_index);
1988 forward_ref->ifd_ptr
1989 = &vp->last->datum->aux[ vp->objects_last_page - 1];
1990 }
1991
1992 /* Add information about array bounds if they exist. */
1993 for (i = 0; i < t->num_dims; i++)
1994 {
1995 (void) add_aux_sym_rndx (ST_RFDESCAPE,
1996 cur_file_ptr->int_type);
1997
1998 (void) add_aux_sym_symint (cur_file_ptr->file_index); /* file index*/
1999 (void) add_aux_sym_symint ((symint_t) 0); /* low bound */
2000 (void) add_aux_sym_symint (t->dimensions[i] - 1); /* high bound*/
2001 (void) add_aux_sym_symint ((t->dimensions[i] == 0) /* stride */
2002 ? 0
2003 : (t->sizes[i] * 8) / t->dimensions[i]);
2004 };
2005
2006 /* NOTE: Mips documentation claims that the bitfield width goes here.
2007 But it needs to be emitted earlier. */
2008
2009 return ret;
2010 }
2011 \f
2012 /* Add a tag to the tag table (unless it already exists). */
2013
2014 static tag_t *
2015 get_tag (tag, sym, basic_type)
2016 const char *tag; /* tag name */
2017 localsym_t *sym; /* tag start block */
2018 bt_t basic_type; /* bt_Struct, bt_Union, or bt_Enum */
2019 {
2020 shash_t *hash_ptr;
2021 const char *err;
2022 tag_t *tag_ptr;
2023
2024 if (cur_file_ptr == (efdr_t *) NULL)
2025 as_fatal ("no current file pointer");
2026
2027 hash_ptr = (shash_t *) hash_find (tag_hash, tag);
2028
2029 if (hash_ptr != (shash_t *) NULL
2030 && hash_ptr->tag_ptr != (tag_t *) NULL)
2031 {
2032 tag_ptr = hash_ptr->tag_ptr;
2033 if (sym != (localsym_t *) NULL)
2034 {
2035 tag_ptr->basic_type = basic_type;
2036 tag_ptr->ifd = cur_file_ptr->file_index;
2037 tag_ptr->sym = sym;
2038 }
2039 return tag_ptr;
2040 }
2041
2042 if (hash_ptr == (shash_t *) NULL)
2043 {
2044 char *perm;
2045
2046 perm = xmalloc ((unsigned long) (strlen (tag) + 1));
2047 strcpy (perm, tag);
2048 hash_ptr = allocate_shash ();
2049 err = hash_insert (tag_hash, perm, (char *) hash_ptr);
2050 if (err)
2051 as_fatal ("Inserting \"%s\" into tag hash table: %s",
2052 tag, err);
2053 hash_ptr->string = perm;
2054 }
2055
2056 tag_ptr = allocate_tag ();
2057 tag_ptr->forward_ref = (forward_t *) NULL;
2058 tag_ptr->hash_ptr = hash_ptr;
2059 tag_ptr->same_name = hash_ptr->tag_ptr;
2060 tag_ptr->basic_type = basic_type;
2061 tag_ptr->sym = sym;
2062 tag_ptr->ifd = ((sym == (localsym_t *) NULL)
2063 ? (symint_t) -1
2064 : cur_file_ptr->file_index);
2065 tag_ptr->same_block = cur_tag_head->first_tag;
2066
2067 cur_tag_head->first_tag = tag_ptr;
2068 hash_ptr->tag_ptr = tag_ptr;
2069
2070 return tag_ptr;
2071 }
2072 \f
2073 /* Add an unknown {struct, union, enum} tag. */
2074
2075 static void
2076 add_unknown_tag (ptag)
2077 tag_t *ptag; /* pointer to tag information */
2078 {
2079 shash_t *hash_ptr = ptag->hash_ptr;
2080 char *name = hash_ptr->string;
2081 localsym_t *sym;
2082 forward_t **pf;
2083
2084 #ifdef ECOFF_DEBUG
2085 if (debug > 1)
2086 {
2087 char *agg_type = "{unknown aggregate type}";
2088 switch (ptag->basic_type)
2089 {
2090 case bt_Struct: agg_type = "struct"; break;
2091 case bt_Union: agg_type = "union"; break;
2092 case bt_Enum: agg_type = "enum"; break;
2093 default: break;
2094 }
2095
2096 fprintf (stderr, "unknown %s %.*s found\n", agg_type,
2097 hash_ptr->len, name_start);
2098 }
2099 #endif
2100
2101 sym = add_ecoff_symbol (name,
2102 st_Block,
2103 sc_Info,
2104 (symbolS *) NULL,
2105 (symint_t) 0,
2106 (symint_t) 0);
2107
2108 (void) add_ecoff_symbol (name,
2109 st_End,
2110 sc_Info,
2111 (symbolS *) NULL,
2112 (symint_t) 0,
2113 (symint_t) 0);
2114
2115 for (pf = &sym->forward_ref; *pf != (forward_t *) NULL; pf = &(*pf)->next)
2116 ;
2117 *pf = ptag->forward_ref;
2118 }
2119 \f
2120 /* Add a procedure to the current file's list of procedures, and record
2121 this is the current procedure. */
2122
2123 static void
2124 add_procedure (func)
2125 char *func; /* func name */
2126 {
2127 register varray_t *vp;
2128 register proc_t *new_proc_ptr;
2129
2130 #ifdef ECOFF_DEBUG
2131 if (debug)
2132 fputc ('\n', stderr);
2133 #endif
2134
2135 if (cur_file_ptr == (efdr_t *) NULL)
2136 as_fatal ("no current file pointer");
2137
2138 vp = &cur_file_ptr->procs;
2139
2140 if (vp->objects_last_page == vp->objects_per_page)
2141 add_varray_page (vp);
2142
2143 cur_proc_ptr = new_proc_ptr = &vp->last->datum->proc[vp->objects_last_page++];
2144
2145 if (first_proc_ptr == (proc_t *) NULL)
2146 first_proc_ptr = new_proc_ptr;
2147
2148 vp->num_allocated++;
2149
2150 new_proc_ptr->pdr.isym = -1;
2151 new_proc_ptr->pdr.iline = -1;
2152 new_proc_ptr->pdr.lnLow = -1;
2153 new_proc_ptr->pdr.lnHigh = -1;
2154
2155 /* Push the start of the function. */
2156 new_proc_ptr->sym = add_ecoff_symbol ((const char *) NULL, st_Proc, sc_Text,
2157 symbol_find_or_make (func),
2158 (symint_t) 0, (symint_t) 0);
2159
2160 ++proc_cnt;
2161
2162 /* Fill in the linenos preceding the .ent, if any. */
2163 if (noproc_lineno != (lineno_list_t *) NULL)
2164 {
2165 lineno_list_t *l;
2166
2167 for (l = noproc_lineno; l != (lineno_list_t *) NULL; l = l->next)
2168 l->proc = new_proc_ptr;
2169 *last_lineno_ptr = noproc_lineno;
2170 while (*last_lineno_ptr != NULL)
2171 last_lineno_ptr = &(*last_lineno_ptr)->next;
2172 noproc_lineno = (lineno_list_t *) NULL;
2173 }
2174 }
2175 \f
2176 /* Add a new filename, and set up all of the file relative
2177 virtual arrays (strings, symbols, aux syms, etc.). Record
2178 where the current file structure lives. */
2179
2180 static void
2181 add_file (file_name, indx)
2182 const char *file_name; /* file name */
2183 int indx;
2184 {
2185 register int first_ch;
2186 register efdr_t *fil_ptr;
2187
2188 #ifdef ECOFF_DEBUG
2189 if (debug)
2190 fprintf (stderr, "\tfile\t%.*s\n", len, file_start);
2191 #endif
2192
2193 /* If the file name is NULL, then no .file symbol appeared, and we
2194 want to use the actual file name. */
2195 if (file_name == (const char *) NULL)
2196 {
2197 char *file;
2198
2199 if (first_file != (efdr_t *) NULL)
2200 as_fatal ("fake .file after real one");
2201 as_where (&file, (unsigned int *) NULL);
2202 file_name = (const char *) file;
2203
2204 if (! symbol_table_frozen)
2205 generate_asm_lineno = 1;
2206 }
2207 else
2208 generate_asm_lineno = 0;
2209
2210 #ifndef NO_LISTING
2211 if (listing)
2212 listing_source_file (file_name);
2213 #endif
2214
2215 current_stabs_filename = file_name;
2216
2217 /* If we're creating stabs, then we don't actually make a new FDR.
2218 Instead, we just create a stabs symbol. */
2219 if (stabs_seen)
2220 {
2221 (void) add_ecoff_symbol (file_name, st_Nil, sc_Nil,
2222 symbol_new ("L0\001", now_seg,
2223 (valueT) frag_now_fix (),
2224 frag_now),
2225 0, ECOFF_MARK_STAB (N_SOL));
2226 return;
2227 }
2228
2229 first_ch = *file_name;
2230
2231 /* See if the file has already been created. */
2232 for (fil_ptr = first_file;
2233 fil_ptr != (efdr_t *) NULL;
2234 fil_ptr = fil_ptr->next_file)
2235 {
2236 if (first_ch == fil_ptr->name[0]
2237 && strcmp (file_name, fil_ptr->name) == 0)
2238 {
2239 cur_file_ptr = fil_ptr;
2240 break;
2241 }
2242 }
2243
2244 /* If this is a new file, create it. */
2245 if (fil_ptr == (efdr_t *) NULL)
2246 {
2247 if (file_desc.objects_last_page == file_desc.objects_per_page)
2248 add_varray_page (&file_desc);
2249
2250 fil_ptr = cur_file_ptr =
2251 &file_desc.last->datum->file[file_desc.objects_last_page++];
2252 *fil_ptr = init_file;
2253
2254 fil_ptr->file_index = current_file_idx++;
2255 ++file_desc.num_allocated;
2256
2257 /* Allocate the string hash table. */
2258 fil_ptr->str_hash = hash_new ();
2259
2260 /* Make sure 0 byte in string table is null */
2261 add_string (&fil_ptr->strings,
2262 fil_ptr->str_hash,
2263 "",
2264 (shash_t **)0);
2265
2266 if (strlen (file_name) > PAGE_USIZE - 2)
2267 as_fatal ("Filename goes over one page boundary.");
2268
2269 /* Push the start of the filename. We assume that the filename
2270 will be stored at string offset 1. */
2271 (void) add_ecoff_symbol (file_name, st_File, sc_Text,
2272 (symbolS *) NULL,
2273 (symint_t) 0, (symint_t) 0);
2274 fil_ptr->fdr.rss = 1;
2275 fil_ptr->name = &fil_ptr->strings.last->datum->byte[1];
2276
2277 /* Update the linked list of file descriptors. */
2278 *last_file_ptr = fil_ptr;
2279 last_file_ptr = &fil_ptr->next_file;
2280
2281 /* Add void & int types to the file (void should be first to catch
2282 errant 0's within the index fields). */
2283 fil_ptr->void_type = add_aux_sym_tir (&void_type_info,
2284 hash_yes,
2285 &cur_file_ptr->thash_head[0]);
2286
2287 fil_ptr->int_type = add_aux_sym_tir (&int_type_info,
2288 hash_yes,
2289 &cur_file_ptr->thash_head[0]);
2290 /* gas used to have a bug that if the file does not have any
2291 symbol, it either will abort or will not build the file,
2292 the following is to get around that problem. ---kung*/
2293 #if 0
2294 if (generate_asm_lineno)
2295 {
2296 mark_stabs (0);
2297 (void) add_ecoff_symbol (file_name, st_Nil, sc_Nil,
2298 symbol_new ("L0\001", now_seg,
2299 (valueT) frag_now_fix (),
2300 frag_now),
2301 0, ECOFF_MARK_STAB (N_SO));
2302 (void) add_ecoff_symbol ("void:t1=1", st_Nil, sc_Nil,
2303 (symbolS *) NULL, 0,
2304 ECOFF_MARK_STAB (N_LSYM));
2305 }
2306 #endif
2307 }
2308 }
2309 \f
2310 #ifdef ECOFF_DEBUG
2311
2312 /* Convert storage class to string. */
2313
2314 static char *
2315 sc_to_string(storage_class)
2316 sc_t storage_class;
2317 {
2318 switch(storage_class)
2319 {
2320 case sc_Nil: return "Nil,";
2321 case sc_Text: return "Text,";
2322 case sc_Data: return "Data,";
2323 case sc_Bss: return "Bss,";
2324 case sc_Register: return "Register,";
2325 case sc_Abs: return "Abs,";
2326 case sc_Undefined: return "Undefined,";
2327 case sc_CdbLocal: return "CdbLocal,";
2328 case sc_Bits: return "Bits,";
2329 case sc_CdbSystem: return "CdbSystem,";
2330 case sc_RegImage: return "RegImage,";
2331 case sc_Info: return "Info,";
2332 case sc_UserStruct: return "UserStruct,";
2333 case sc_SData: return "SData,";
2334 case sc_SBss: return "SBss,";
2335 case sc_RData: return "RData,";
2336 case sc_Var: return "Var,";
2337 case sc_Common: return "Common,";
2338 case sc_SCommon: return "SCommon,";
2339 case sc_VarRegister: return "VarRegister,";
2340 case sc_Variant: return "Variant,";
2341 case sc_SUndefined: return "SUndefined,";
2342 case sc_Init: return "Init,";
2343 case sc_Max: return "Max,";
2344 }
2345
2346 return "???,";
2347 }
2348
2349 #endif /* DEBUG */
2350 \f
2351 #ifdef ECOFF_DEBUG
2352
2353 /* Convert symbol type to string. */
2354
2355 static char *
2356 st_to_string(symbol_type)
2357 st_t symbol_type;
2358 {
2359 switch(symbol_type)
2360 {
2361 case st_Nil: return "Nil,";
2362 case st_Global: return "Global,";
2363 case st_Static: return "Static,";
2364 case st_Param: return "Param,";
2365 case st_Local: return "Local,";
2366 case st_Label: return "Label,";
2367 case st_Proc: return "Proc,";
2368 case st_Block: return "Block,";
2369 case st_End: return "End,";
2370 case st_Member: return "Member,";
2371 case st_Typedef: return "Typedef,";
2372 case st_File: return "File,";
2373 case st_RegReloc: return "RegReloc,";
2374 case st_Forward: return "Forward,";
2375 case st_StaticProc: return "StaticProc,";
2376 case st_Constant: return "Constant,";
2377 case st_Str: return "String,";
2378 case st_Number: return "Number,";
2379 case st_Expr: return "Expr,";
2380 case st_Type: return "Type,";
2381 case st_Max: return "Max,";
2382 }
2383
2384 return "???,";
2385 }
2386
2387 #endif /* DEBUG */
2388 \f
2389 /* Parse .begin directives which have a label as the first argument
2390 which gives the location of the start of the block. */
2391
2392 void
2393 ecoff_directive_begin (ignore)
2394 int ignore;
2395 {
2396 char *name;
2397 char name_end;
2398
2399 if (cur_file_ptr == (efdr_t *) NULL)
2400 {
2401 as_warn (".begin directive without a preceding .file directive");
2402 demand_empty_rest_of_line ();
2403 return;
2404 }
2405
2406 if (cur_proc_ptr == (proc_t *) NULL)
2407 {
2408 as_warn (".begin directive without a preceding .ent directive");
2409 demand_empty_rest_of_line ();
2410 return;
2411 }
2412
2413 name = input_line_pointer;
2414 name_end = get_symbol_end ();
2415
2416 (void) add_ecoff_symbol ((const char *) NULL, st_Block, sc_Text,
2417 symbol_find_or_make (name),
2418 (symint_t) 0, (symint_t) 0);
2419
2420 *input_line_pointer = name_end;
2421
2422 /* The line number follows, but we don't use it. */
2423 (void) get_absolute_expression ();
2424 demand_empty_rest_of_line ();
2425 }
2426 \f
2427 /* Parse .bend directives which have a label as the first argument
2428 which gives the location of the end of the block. */
2429
2430 void
2431 ecoff_directive_bend (ignore)
2432 int ignore;
2433 {
2434 char *name;
2435 char name_end;
2436 symbolS *endsym;
2437
2438 if (cur_file_ptr == (efdr_t *) NULL)
2439 {
2440 as_warn (".bend directive without a preceding .file directive");
2441 demand_empty_rest_of_line ();
2442 return;
2443 }
2444
2445 if (cur_proc_ptr == (proc_t *) NULL)
2446 {
2447 as_warn (".bend directive without a preceding .ent directive");
2448 demand_empty_rest_of_line ();
2449 return;
2450 }
2451
2452 name = input_line_pointer;
2453 name_end = get_symbol_end ();
2454
2455 /* The value is the distance between the .bend directive and the
2456 corresponding symbol. We fill in the offset when we write out
2457 the symbol. */
2458 endsym = symbol_find (name);
2459 if (endsym == (symbolS *) NULL)
2460 as_warn (".bend directive names unknown symbol");
2461 else
2462 (void) add_ecoff_symbol ((const char *) NULL, st_End, sc_Text, endsym,
2463 (symint_t) 0, (symint_t) 0);
2464
2465 *input_line_pointer = name_end;
2466
2467 /* The line number follows, but we don't use it. */
2468 (void) get_absolute_expression ();
2469 demand_empty_rest_of_line ();
2470 }
2471 \f
2472 /* COFF debugging information is provided as a series of directives
2473 (.def, .scl, etc.). We build up information as we read the
2474 directives in the following static variables, and file it away when
2475 we reach the .endef directive. */
2476 static char *coff_sym_name;
2477 static type_info_t coff_type;
2478 static sc_t coff_storage_class;
2479 static st_t coff_symbol_typ;
2480 static int coff_is_function;
2481 static char *coff_tag;
2482 static valueT coff_value;
2483 symbolS *coff_sym_value;
2484 static int coff_inside_enumeration;
2485
2486 /* Handle a .def directive: start defining a symbol. */
2487
2488 void
2489 ecoff_directive_def (ignore)
2490 int ignore;
2491 {
2492 char *name;
2493 char name_end;
2494
2495 ecoff_debugging_seen = 1;
2496
2497 SKIP_WHITESPACE ();
2498
2499 name = input_line_pointer;
2500 name_end = get_symbol_end ();
2501
2502 if (coff_sym_name != (char *) NULL)
2503 as_warn (".def pseudo-op used inside of .def/.endef; ignored");
2504 else if (*name == '\0')
2505 as_warn ("Empty symbol name in .def; ignored");
2506 else
2507 {
2508 if (coff_sym_name != (char *) NULL)
2509 free (coff_sym_name);
2510 if (coff_tag != (char *) NULL)
2511 free (coff_tag);
2512 coff_sym_name = (char *) xmalloc ((unsigned long) (strlen (name) + 1));
2513 strcpy (coff_sym_name, name);
2514 coff_type = type_info_init;
2515 coff_storage_class = sc_Nil;
2516 coff_symbol_typ = st_Nil;
2517 coff_is_function = 0;
2518 coff_tag = (char *) NULL;
2519 coff_value = 0;
2520 coff_sym_value = (symbolS *) NULL;
2521 }
2522
2523 *input_line_pointer = name_end;
2524
2525 demand_empty_rest_of_line ();
2526 }
2527
2528 /* Handle a .dim directive, used to give dimensions for an array. The
2529 arguments are comma separated numbers. mips-tfile assumes that
2530 there will not be more than 6 dimensions, and gdb won't read any
2531 more than that anyhow, so I will also make that assumption. */
2532
2533 void
2534 ecoff_directive_dim (ignore)
2535 int ignore;
2536 {
2537 int dimens[N_TQ];
2538 int i;
2539
2540 if (coff_sym_name == (char *) NULL)
2541 {
2542 as_warn (".dim pseudo-op used outside of .def/.endef; ignored");
2543 demand_empty_rest_of_line ();
2544 return;
2545 }
2546
2547 for (i = 0; i < N_TQ; i++)
2548 {
2549 SKIP_WHITESPACE ();
2550 dimens[i] = get_absolute_expression ();
2551 if (*input_line_pointer == ',')
2552 ++input_line_pointer;
2553 else
2554 {
2555 if (*input_line_pointer != '\n'
2556 && *input_line_pointer != ';')
2557 as_warn ("Badly formed .dim directive");
2558 break;
2559 }
2560 }
2561
2562 if (i == N_TQ)
2563 --i;
2564
2565 /* The dimensions are stored away in reverse order. */
2566 for (; i >= 0; i--)
2567 {
2568 if (coff_type.num_dims >= N_TQ)
2569 {
2570 as_warn ("Too many .dim entries");
2571 break;
2572 }
2573 coff_type.dimensions[coff_type.num_dims] = dimens[i];
2574 ++coff_type.num_dims;
2575 }
2576
2577 demand_empty_rest_of_line ();
2578 }
2579
2580 /* Handle a .scl directive, which sets the COFF storage class of the
2581 symbol. */
2582
2583 void
2584 ecoff_directive_scl (ignore)
2585 int ignore;
2586 {
2587 long val;
2588
2589 if (coff_sym_name == (char *) NULL)
2590 {
2591 as_warn (".scl pseudo-op used outside of .def/.endef; ignored");
2592 demand_empty_rest_of_line ();
2593 return;
2594 }
2595
2596 val = get_absolute_expression ();
2597
2598 coff_symbol_typ = map_coff_sym_type[val];
2599 coff_storage_class = map_coff_storage[val];
2600
2601 demand_empty_rest_of_line ();
2602 }
2603
2604 /* Handle a .size directive. For some reason mips-tfile.c thinks that
2605 .size can have multiple arguments. We humor it, although gcc will
2606 never generate more than one argument. */
2607
2608 void
2609 ecoff_directive_size (ignore)
2610 int ignore;
2611 {
2612 int sizes[N_TQ];
2613 int i;
2614
2615 if (coff_sym_name == (char *) NULL)
2616 {
2617 as_warn (".size pseudo-op used outside of .def/.endef; ignored");
2618 demand_empty_rest_of_line ();
2619 return;
2620 }
2621
2622 for (i = 0; i < N_TQ; i++)
2623 {
2624 SKIP_WHITESPACE ();
2625 sizes[i] = get_absolute_expression ();
2626 if (*input_line_pointer == ',')
2627 ++input_line_pointer;
2628 else
2629 {
2630 if (*input_line_pointer != '\n'
2631 && *input_line_pointer != ';')
2632 as_warn ("Badly formed .size directive");
2633 break;
2634 }
2635 }
2636
2637 if (i == N_TQ)
2638 --i;
2639
2640 /* The sizes are stored away in reverse order. */
2641 for (; i >= 0; i--)
2642 {
2643 if (coff_type.num_sizes >= N_TQ)
2644 {
2645 as_warn ("Too many .size entries");
2646 break;
2647 }
2648 coff_type.sizes[coff_type.num_sizes] = sizes[i];
2649 ++coff_type.num_sizes;
2650 }
2651
2652 demand_empty_rest_of_line ();
2653 }
2654
2655 /* Handle the .type directive, which gives the COFF type of the
2656 symbol. */
2657
2658 void
2659 ecoff_directive_type (ignore)
2660 int ignore;
2661 {
2662 long val;
2663 tq_t *tq_ptr;
2664 tq_t *tq_shft;
2665
2666 if (coff_sym_name == (char *) NULL)
2667 {
2668 as_warn (".type pseudo-op used outside of .def/.endef; ignored");
2669 demand_empty_rest_of_line ();
2670 return;
2671 }
2672
2673 val = get_absolute_expression ();
2674
2675 coff_type.orig_type = BTYPE (val);
2676 coff_type.basic_type = map_coff_types[coff_type.orig_type];
2677
2678 tq_ptr = &coff_type.type_qualifiers[N_TQ];
2679 while (val &~ N_BTMASK)
2680 {
2681 if (tq_ptr == &coff_type.type_qualifiers[0])
2682 {
2683 /* FIXME: We could handle this by setting the continued bit.
2684 There would still be a limit: the .type argument can not
2685 be infinite. */
2686 as_warn ("The type of %s is too complex; it will be simplified",
2687 coff_sym_name);
2688 break;
2689 }
2690 if (ISPTR (val))
2691 *--tq_ptr = tq_Ptr;
2692 else if (ISFCN (val))
2693 *--tq_ptr = tq_Proc;
2694 else if (ISARY (val))
2695 *--tq_ptr = tq_Array;
2696 else
2697 as_fatal ("Unrecognized .type argument");
2698
2699 val = DECREF (val);
2700 }
2701
2702 tq_shft = &coff_type.type_qualifiers[0];
2703 while (tq_ptr != &coff_type.type_qualifiers[N_TQ])
2704 *tq_shft++ = *tq_ptr++;
2705
2706 if (tq_shft != &coff_type.type_qualifiers[0] && tq_shft[-1] == tq_Proc)
2707 {
2708 /* If this is a function, ignore it, so that we don't get two
2709 entries (one from the .ent, and one for the .def that
2710 precedes it). Save the type information so that the end
2711 block can properly add it after the begin block index. For
2712 MIPS knows what reason, we must strip off the function type
2713 at this point. */
2714 coff_is_function = 1;
2715 tq_shft[-1] = tq_Nil;
2716 }
2717
2718 while (tq_shft != &coff_type.type_qualifiers[N_TQ])
2719 *tq_shft++ = tq_Nil;
2720
2721 demand_empty_rest_of_line ();
2722 }
2723
2724 /* Handle the .tag directive, which gives the name of a structure,
2725 union or enum. */
2726
2727 void
2728 ecoff_directive_tag (ignore)
2729 int ignore;
2730 {
2731 char *name;
2732 char name_end;
2733
2734 if (coff_sym_name == (char *) NULL)
2735 {
2736 as_warn (".tag pseudo-op used outside of .def/.endef; ignored");
2737 demand_empty_rest_of_line ();
2738 return;
2739 }
2740
2741 name = input_line_pointer;
2742 name_end = get_symbol_end ();
2743
2744 coff_tag = (char *) xmalloc ((unsigned long) (strlen (name) + 1));
2745 strcpy (coff_tag, name);
2746
2747 *input_line_pointer = name_end;
2748
2749 demand_empty_rest_of_line ();
2750 }
2751
2752 /* Handle the .val directive, which gives the value of the symbol. It
2753 may be the name of a static or global symbol. */
2754
2755 void
2756 ecoff_directive_val (ignore)
2757 int ignore;
2758 {
2759 if (coff_sym_name == (char *) NULL)
2760 {
2761 as_warn (".val pseudo-op used outside of .def/.endef; ignored");
2762 demand_empty_rest_of_line ();
2763 return;
2764 }
2765
2766 if (! is_name_beginner ((unsigned char) *input_line_pointer))
2767 coff_value = get_absolute_expression ();
2768 else
2769 {
2770 char *name;
2771 char name_end;
2772
2773 name = input_line_pointer;
2774 name_end = get_symbol_end ();
2775
2776 if (strcmp (name, ".") == 0)
2777 as_warn ("`.val .' not supported");
2778 else
2779 coff_sym_value = symbol_find_or_make (name);
2780
2781 *input_line_pointer = name_end;
2782
2783 /* FIXME: gcc can generate address expressions here in unusual
2784 cases (search for "obscure" in sdbout.c), although this is
2785 very unlikely for a MIPS chip. */
2786 }
2787
2788 demand_empty_rest_of_line ();
2789 }
2790
2791 /* Handle the .endef directive, which terminates processing of COFF
2792 debugging information for a symbol. */
2793
2794 void
2795 ecoff_directive_endef (ignore)
2796 int ignore;
2797 {
2798 char *name;
2799 symint_t indx;
2800 localsym_t *sym;
2801
2802 demand_empty_rest_of_line ();
2803
2804 if (coff_sym_name == (char *) NULL)
2805 {
2806 as_warn (".endef pseudo-op used before .def; ignored");
2807 return;
2808 }
2809
2810 name = coff_sym_name;
2811 coff_sym_name = (char *) NULL;
2812
2813 /* If the symbol is a static or external, we have already gotten the
2814 appropriate type and class, so make sure we don't override those
2815 values. This is needed because there are some type and classes
2816 that are not in COFF, such as short data, etc. */
2817 if (coff_sym_value != (symbolS *) NULL)
2818 {
2819 coff_symbol_typ = st_Nil;
2820 coff_storage_class = sc_Nil;
2821 }
2822
2823 coff_type.extra_sizes = coff_tag != (char *) NULL;
2824 if (coff_type.num_dims > 0)
2825 {
2826 int diff = coff_type.num_dims - coff_type.num_sizes;
2827 int i = coff_type.num_dims - 1;
2828 int j;
2829
2830 if (coff_type.num_sizes != 1 || diff < 0)
2831 {
2832 as_warn ("Bad COFF debugging info");
2833 return;
2834 }
2835
2836 /* If this is an array, make sure the same number of dimensions
2837 and sizes were passed, creating extra sizes for multiply
2838 dimensioned arrays if not passed. */
2839 coff_type.extra_sizes = 0;
2840 if (diff)
2841 {
2842 j = (sizeof (coff_type.sizes) / sizeof (coff_type.sizes[0])) - 1;
2843 while (j >= 0)
2844 {
2845 coff_type.sizes[j] = (((j - diff) >= 0)
2846 ? coff_type.sizes[j - diff]
2847 : 0);
2848 j--;
2849 }
2850
2851 coff_type.num_sizes = i + 1;
2852 for (i--; i >= 0; i--)
2853 coff_type.sizes[i] = (coff_type.sizes[i + 1]
2854 / coff_type.dimensions[i + 1]);
2855 }
2856 }
2857 else if (coff_symbol_typ == st_Member
2858 && coff_type.num_sizes - coff_type.extra_sizes == 1)
2859 {
2860 /* Is this a bitfield? This is indicated by a structure memeber
2861 having a size field that isn't an array. */
2862 coff_type.bitfield = 1;
2863 }
2864
2865 /* Except for enumeration members & begin/ending of scopes, put the
2866 type word in the aux. symbol table. */
2867 if (coff_symbol_typ == st_Block || coff_symbol_typ == st_End)
2868 indx = 0;
2869 else if (coff_inside_enumeration)
2870 indx = cur_file_ptr->void_type;
2871 else
2872 {
2873 if (coff_type.basic_type == bt_Struct
2874 || coff_type.basic_type == bt_Union
2875 || coff_type.basic_type == bt_Enum)
2876 {
2877 if (coff_tag == (char *) NULL)
2878 {
2879 as_warn ("No tag specified for %s", name);
2880 return;
2881 }
2882
2883 coff_type.tag_ptr = get_tag (coff_tag, (localsym_t *) NULL,
2884 coff_type.basic_type);
2885 }
2886
2887 if (coff_is_function)
2888 {
2889 last_func_type_info = coff_type;
2890 last_func_sym_value = coff_sym_value;
2891 return;
2892 }
2893
2894 indx = add_aux_sym_tir (&coff_type,
2895 hash_yes,
2896 &cur_file_ptr->thash_head[0]);
2897 }
2898
2899 /* Do any last minute adjustments that are necessary. */
2900 switch (coff_symbol_typ)
2901 {
2902 default:
2903 break;
2904
2905 /* For the beginning of structs, unions, and enumerations, the
2906 size info needs to be passed in the value field. */
2907 case st_Block:
2908 if (coff_type.num_sizes - coff_type.num_dims - coff_type.extra_sizes
2909 != 1)
2910 {
2911 as_warn ("Bad COFF debugging information");
2912 return;
2913 }
2914 else
2915 coff_value = coff_type.sizes[0];
2916
2917 coff_inside_enumeration = (coff_type.orig_type == T_ENUM);
2918 break;
2919
2920 /* For the end of structs, unions, and enumerations, omit the
2921 name which is always ".eos". This needs to be done last, so
2922 that any error reporting above gives the correct name. */
2923 case st_End:
2924 free (name);
2925 name = (char *) NULL;
2926 coff_value = 0;
2927 coff_inside_enumeration = 0;
2928 break;
2929
2930 /* Members of structures and unions that aren't bitfields, need
2931 to adjust the value from a byte offset to a bit offset.
2932 Members of enumerations do not have the value adjusted, and
2933 can be distinguished by indx == indexNil. For enumerations,
2934 update the maximum enumeration value. */
2935 case st_Member:
2936 if (! coff_type.bitfield && ! coff_inside_enumeration)
2937 coff_value *= 8;
2938
2939 break;
2940 }
2941
2942 /* Add the symbol. */
2943 sym = add_ecoff_symbol (name,
2944 coff_symbol_typ,
2945 coff_storage_class,
2946 coff_sym_value,
2947 (symint_t) coff_value,
2948 indx);
2949
2950 /* deal with struct, union, and enum tags. */
2951 if (coff_symbol_typ == st_Block)
2952 {
2953 /* Create or update the tag information. */
2954 tag_t *tag_ptr = get_tag (name,
2955 sym,
2956 coff_type.basic_type);
2957 forward_t **pf;
2958
2959 /* Remember any forward references. */
2960 for (pf = &sym->forward_ref;
2961 *pf != (forward_t *) NULL;
2962 pf = &(*pf)->next)
2963 ;
2964 *pf = tag_ptr->forward_ref;
2965 tag_ptr->forward_ref = (forward_t *) NULL;
2966 }
2967 }
2968 \f
2969 /* Parse .end directives. */
2970
2971 void
2972 ecoff_directive_end (ignore)
2973 int ignore;
2974 {
2975 char *name;
2976 char name_end;
2977 register int ch;
2978 symbolS *ent;
2979
2980 if (cur_file_ptr == (efdr_t *) NULL)
2981 {
2982 as_warn (".end directive without a preceding .file directive");
2983 demand_empty_rest_of_line ();
2984 return;
2985 }
2986
2987 if (cur_proc_ptr == (proc_t *) NULL)
2988 {
2989 as_warn (".end directive without a preceding .ent directive");
2990 demand_empty_rest_of_line ();
2991 return;
2992 }
2993
2994 name = input_line_pointer;
2995 name_end = get_symbol_end ();
2996
2997 ch = *name;
2998 if (! is_name_beginner (ch))
2999 {
3000 as_warn (".end directive has no name");
3001 *input_line_pointer = name_end;
3002 demand_empty_rest_of_line ();
3003 return;
3004 }
3005
3006 /* The value is the distance between the .end directive and the
3007 corresponding symbol. We create a fake symbol to hold the
3008 current location, and put in the offset when we write out the
3009 symbol. */
3010 ent = symbol_find (name);
3011 if (ent == (symbolS *) NULL)
3012 as_warn (".end directive names unknown symbol");
3013 else
3014 {
3015 (void) add_ecoff_symbol ((const char *) NULL, st_End, sc_Text,
3016 symbol_new ("L0\001", now_seg,
3017 (valueT) frag_now_fix (),
3018 frag_now),
3019 (symint_t) 0, (symint_t) 0);
3020
3021 if (stabs_seen && generate_asm_lineno)
3022 {
3023 char *n;
3024
3025 n = xmalloc (strlen (name) + 4);
3026 strcpy (n, name);
3027 strcat (n, ":F1");
3028 (void) add_ecoff_symbol ((const char *) n, stGlobal, scText,
3029 ent, 0, ECOFF_MARK_STAB (N_FUN));
3030 }
3031 }
3032
3033 cur_proc_ptr = (proc_t *) NULL;
3034
3035 *input_line_pointer = name_end;
3036 demand_empty_rest_of_line ();
3037 }
3038 \f
3039 /* Parse .ent directives. */
3040
3041 void
3042 ecoff_directive_ent (ignore)
3043 int ignore;
3044 {
3045 char *name;
3046 char name_end;
3047 register int ch;
3048
3049 if (cur_file_ptr == (efdr_t *) NULL)
3050 add_file ((const char *) NULL, 0);
3051
3052 if (cur_proc_ptr != (proc_t *) NULL)
3053 {
3054 as_warn ("second .ent directive found before .end directive");
3055 demand_empty_rest_of_line ();
3056 return;
3057 }
3058
3059 name = input_line_pointer;
3060 name_end = get_symbol_end ();
3061
3062 ch = *name;
3063 if (! is_name_beginner (ch))
3064 {
3065 as_warn (".ent directive has no name");
3066 *input_line_pointer = name_end;
3067 demand_empty_rest_of_line ();
3068 return;
3069 }
3070
3071 add_procedure (name);
3072
3073 *input_line_pointer = name_end;
3074
3075 /* The .ent directive is sometimes followed by a number. I'm not
3076 really sure what the number means. I don't see any way to store
3077 the information in the PDR. The Irix 4 assembler seems to ignore
3078 the information. */
3079 SKIP_WHITESPACE ();
3080 if (*input_line_pointer == ',')
3081 {
3082 ++input_line_pointer;
3083 SKIP_WHITESPACE ();
3084 }
3085 if (isdigit (*input_line_pointer) || *input_line_pointer == '-')
3086 (void) get_absolute_expression ();
3087
3088 demand_empty_rest_of_line ();
3089 }
3090 \f
3091 /* Parse .file directives. */
3092
3093 void
3094 ecoff_directive_file (ignore)
3095 int ignore;
3096 {
3097 int indx;
3098 char *name;
3099 int len;
3100
3101 if (cur_proc_ptr != (proc_t *) NULL)
3102 {
3103 as_warn ("No way to handle .file within .ent/.end section");
3104 demand_empty_rest_of_line ();
3105 return;
3106 }
3107
3108 indx = (int) get_absolute_expression ();
3109
3110 /* FIXME: we don't have to save the name here. */
3111 name = demand_copy_C_string (&len);
3112
3113 add_file (name, indx - 1);
3114
3115 demand_empty_rest_of_line ();
3116 }
3117 \f
3118 /* Parse .fmask directives. */
3119
3120 void
3121 ecoff_directive_fmask (ignore)
3122 int ignore;
3123 {
3124 long val;
3125
3126 if (cur_proc_ptr == (proc_t *) NULL)
3127 {
3128 as_warn (".fmask outside of .ent");
3129 demand_empty_rest_of_line ();
3130 return;
3131 }
3132
3133 if (get_absolute_expression_and_terminator (&val) != ',')
3134 {
3135 as_warn ("Bad .fmask directive");
3136 --input_line_pointer;
3137 demand_empty_rest_of_line ();
3138 return;
3139 }
3140
3141 cur_proc_ptr->pdr.fregmask = val;
3142 cur_proc_ptr->pdr.fregoffset = get_absolute_expression ();
3143
3144 demand_empty_rest_of_line ();
3145 }
3146 \f
3147 /* Parse .frame directives. */
3148
3149 void
3150 ecoff_directive_frame (ignore)
3151 int ignore;
3152 {
3153 long val;
3154
3155 if (cur_proc_ptr == (proc_t *) NULL)
3156 {
3157 as_warn (".frame outside of .ent");
3158 demand_empty_rest_of_line ();
3159 return;
3160 }
3161
3162 cur_proc_ptr->pdr.framereg = tc_get_register (1);
3163
3164 SKIP_WHITESPACE ();
3165 if (*input_line_pointer++ != ','
3166 || get_absolute_expression_and_terminator (&val) != ',')
3167 {
3168 as_warn ("Bad .frame directive");
3169 --input_line_pointer;
3170 demand_empty_rest_of_line ();
3171 return;
3172 }
3173
3174 cur_proc_ptr->pdr.frameoffset = val;
3175
3176 cur_proc_ptr->pdr.pcreg = tc_get_register (0);
3177
3178 #if 0 /* Alpha-OSF1 adds "the offset of saved $a0 from $sp", according
3179 to Sandro. I don't yet know where this value should be stored, if
3180 anywhere. */
3181 demand_empty_rest_of_line ();
3182 #else
3183 s_ignore (42);
3184 #endif
3185 }
3186 \f
3187 /* Parse .mask directives. */
3188
3189 void
3190 ecoff_directive_mask (ignore)
3191 int ignore;
3192 {
3193 long val;
3194
3195 if (cur_proc_ptr == (proc_t *) NULL)
3196 {
3197 as_warn (".mask outside of .ent");
3198 demand_empty_rest_of_line ();
3199 return;
3200 }
3201
3202 if (get_absolute_expression_and_terminator (&val) != ',')
3203 {
3204 as_warn ("Bad .mask directive");
3205 --input_line_pointer;
3206 demand_empty_rest_of_line ();
3207 return;
3208 }
3209
3210 cur_proc_ptr->pdr.regmask = val;
3211 cur_proc_ptr->pdr.regoffset = get_absolute_expression ();
3212
3213 demand_empty_rest_of_line ();
3214 }
3215 \f
3216 /* Parse .loc directives. */
3217
3218 void
3219 ecoff_directive_loc (ignore)
3220 int ignore;
3221 {
3222 lineno_list_t *list;
3223 symint_t lineno;
3224
3225 if (cur_file_ptr == (efdr_t *) NULL)
3226 {
3227 as_warn (".loc before .file");
3228 demand_empty_rest_of_line ();
3229 return;
3230 }
3231
3232 if (now_seg != text_section)
3233 {
3234 as_warn (".loc outside of .text");
3235 demand_empty_rest_of_line ();
3236 return;
3237 }
3238
3239 /* Skip the file number. */
3240 SKIP_WHITESPACE ();
3241 get_absolute_expression ();
3242 SKIP_WHITESPACE ();
3243
3244 lineno = get_absolute_expression ();
3245
3246 #ifndef NO_LISTING
3247 if (listing)
3248 listing_source_line (lineno);
3249 #endif
3250
3251 /* If we're building stabs, then output a special label rather than
3252 ECOFF line number info. */
3253 if (stabs_seen)
3254 {
3255 (void) add_ecoff_symbol ((char *) NULL, st_Label, sc_Text,
3256 symbol_new ("L0\001", now_seg,
3257 (valueT) frag_now_fix (),
3258 frag_now),
3259 0, lineno);
3260 return;
3261 }
3262
3263 list = allocate_lineno_list ();
3264
3265 list->next = (lineno_list_t *) NULL;
3266 list->file = cur_file_ptr;
3267 list->proc = cur_proc_ptr;
3268 list->frag = frag_now;
3269 list->paddr = frag_now_fix ();
3270 list->lineno = lineno;
3271
3272 /* A .loc directive will sometimes appear before a .ent directive,
3273 which means that cur_proc_ptr will be NULL here. Arrange to
3274 patch this up. */
3275 if (cur_proc_ptr == (proc_t *) NULL)
3276 {
3277 lineno_list_t **pl;
3278
3279 pl = &noproc_lineno;
3280 while (*pl != (lineno_list_t *) NULL)
3281 pl = &(*pl)->next;
3282 *pl = list;
3283 }
3284 else
3285 {
3286 *last_lineno_ptr = list;
3287 last_lineno_ptr = &list->next;
3288 }
3289 }
3290 \f
3291 /* Make sure the @stabs symbol is emitted. */
3292
3293 static void
3294 mark_stabs (ignore)
3295 int ignore;
3296 {
3297 if (! stabs_seen)
3298 {
3299 /* Add a dummy @stabs dymbol. */
3300 stabs_seen = 1;
3301 (void) add_ecoff_symbol (stabs_symbol, stNil, scInfo,
3302 (symbolS *) NULL,
3303 (symint_t) -1, ECOFF_MARK_STAB (0));
3304 }
3305 }
3306 \f
3307 /* Handle .stabs directives. The actual parsing routine is done by a
3308 generic routine. This routine is called via OBJ_PROCESS_STAB.
3309 When this is called, input_line_pointer will be pointing at the
3310 value field of the stab.
3311
3312 .stabs directives have five fields:
3313 "string" a string, encoding the type information.
3314 code a numeric code, defined in <stab.h>
3315 0 a zero
3316 desc a zero or line number
3317 value a numeric value or an address.
3318
3319 If the value is relocatable, we transform this into:
3320 iss points as an index into string space
3321 value value from lookup of the name
3322 st st from lookup of the name
3323 sc sc from lookup of the name
3324 index code|CODE_MASK
3325
3326 If the value is not relocatable, we transform this into:
3327 iss points as an index into string space
3328 value value
3329 st st_Nil
3330 sc sc_Nil
3331 index code|CODE_MASK
3332
3333 .stabn directives have four fields (string is null):
3334 code a numeric code, defined in <stab.h>
3335 0 a zero
3336 desc a zero or a line number
3337 value a numeric value or an address. */
3338
3339 void
3340 ecoff_stab (sec, what, string, type, other, desc)
3341 segT sec;
3342 int what;
3343 const char *string;
3344 int type;
3345 int other;
3346 int desc;
3347 {
3348 efdr_t *save_file_ptr = cur_file_ptr;
3349 symbolS *sym;
3350 symint_t value;
3351 st_t st;
3352 sc_t sc;
3353 symint_t indx;
3354 localsym_t *hold = NULL;
3355
3356 ecoff_debugging_seen = 1;
3357
3358 /* We don't handle .stabd. */
3359 if (what != 's' && what != 'n')
3360 {
3361 as_bad (".stab%c is not supported", what);
3362 return;
3363 }
3364
3365 /* A .stabn uses a null name, not an empty string. */
3366 if (what == 'n')
3367 string = NULL;
3368
3369 /* We ignore the other field. */
3370 if (other != 0)
3371 as_warn (".stab%c: ignoring non-zero other field", what);
3372
3373 /* Make sure we have a current file. */
3374 if (cur_file_ptr == (efdr_t *) NULL)
3375 {
3376 add_file ((const char *) NULL, 0);
3377 save_file_ptr = cur_file_ptr;
3378 }
3379
3380 /* For stabs in ECOFF, the first symbol must be @stabs. This is a
3381 signal to gdb. */
3382 if (stabs_seen == 0)
3383 mark_stabs (0);
3384
3385 /* Line number stabs are handled differently, since they have two
3386 values, the line number and the address of the label. We use the
3387 index field (aka desc) to hold the line number, and the value
3388 field to hold the address. The symbol type is st_Label, which
3389 should be different from the other stabs, so that gdb can
3390 recognize it. */
3391 if (type == N_SLINE)
3392 {
3393 SYMR dummy_symr;
3394 char *name;
3395 char name_end;
3396
3397 #ifndef NO_LISTING
3398 if (listing)
3399 listing_source_line ((unsigned int) desc);
3400 #endif
3401
3402 dummy_symr.index = desc;
3403 if (dummy_symr.index != desc)
3404 {
3405 as_warn ("Line number (%d) for .stab%c directive cannot fit in index field (20 bits)",
3406 desc, what);
3407 return;
3408 }
3409
3410 name = input_line_pointer;
3411 name_end = get_symbol_end ();
3412
3413 sym = symbol_find_or_make (name);
3414 *input_line_pointer = name_end;
3415
3416 value = 0;
3417 st = st_Label;
3418 sc = sc_Text;
3419 indx = desc;
3420 }
3421 else
3422 {
3423 #ifndef NO_LISTING
3424 if (listing && (type == N_SO || type == N_SOL))
3425 listing_source_file (string);
3426 #endif
3427
3428 if (isdigit (*input_line_pointer)
3429 || *input_line_pointer == '-'
3430 || *input_line_pointer == '+')
3431 {
3432 st = st_Nil;
3433 sc = sc_Nil;
3434 sym = (symbolS *) NULL;
3435 value = get_absolute_expression ();
3436 }
3437 else if (! is_name_beginner ((unsigned char) *input_line_pointer))
3438 {
3439 as_warn ("Illegal .stab%c directive, bad character", what);
3440 return;
3441 }
3442 else
3443 {
3444 char *name;
3445 char name_end;
3446
3447 name = input_line_pointer;
3448 name_end = get_symbol_end ();
3449
3450 sym = symbol_find_or_make (name);
3451
3452 sc = sc_Nil;
3453 st = st_Nil;
3454 value = 0;
3455
3456 *input_line_pointer = name_end;
3457 if (name_end == '+' || name_end == '-')
3458 {
3459 ++input_line_pointer;
3460 value = get_absolute_expression ();
3461 if (name_end == '-')
3462 value = - value;
3463 }
3464 }
3465
3466 indx = ECOFF_MARK_STAB (type);
3467 }
3468
3469 /* Don't store the stabs symbol we are creating as the type of the
3470 ECOFF symbol. We want to compute the type of the ECOFF symbol
3471 independently. */
3472 if (sym != (symbolS *) NULL)
3473 hold = sym->ecoff_symbol;
3474
3475 (void) add_ecoff_symbol (string, st, sc, sym, value, indx);
3476
3477 if (sym != (symbolS *) NULL)
3478 sym->ecoff_symbol = hold;
3479
3480 /* Restore normal file type. */
3481 cur_file_ptr = save_file_ptr;
3482 }
3483 \f
3484 /* Frob an ECOFF symbol. Small common symbols go into a special
3485 .scommon section rather than bfd_com_section. */
3486
3487 void
3488 ecoff_frob_symbol (sym)
3489 symbolS *sym;
3490 {
3491 if (S_IS_COMMON (sym)
3492 && S_GET_VALUE (sym) > 0
3493 && S_GET_VALUE (sym) <= bfd_get_gp_size (stdoutput))
3494 {
3495 static asection scom_section;
3496 static asymbol scom_symbol;
3497
3498 /* We must construct a fake section similar to bfd_com_section
3499 but with the name .scommon. */
3500 if (scom_section.name == NULL)
3501 {
3502 scom_section = bfd_com_section;
3503 scom_section.name = ".scommon";
3504 scom_section.output_section = &scom_section;
3505 scom_section.symbol = &scom_symbol;
3506 scom_section.symbol_ptr_ptr = &scom_section.symbol;
3507 scom_symbol = *bfd_com_section.symbol;
3508 scom_symbol.name = ".scommon";
3509 scom_symbol.section = &scom_section;
3510 }
3511 S_SET_SEGMENT (sym, &scom_section);
3512 }
3513 }
3514 \f
3515 /* Add bytes to the symbolic information buffer. */
3516
3517 static char *
3518 ecoff_add_bytes (buf, bufend, bufptr, need)
3519 char **buf;
3520 char **bufend;
3521 char *bufptr;
3522 unsigned long need;
3523 {
3524 unsigned long at;
3525 unsigned long want;
3526
3527 at = bufptr - *buf;
3528 need -= *bufend - bufptr;
3529 if (need < PAGE_SIZE)
3530 need = PAGE_SIZE;
3531 want = (*bufend - *buf) + need;
3532 *buf = xrealloc (*buf, want);
3533 *bufend = *buf + want;
3534 return *buf + at;
3535 }
3536
3537 /* Adjust the symbolic information buffer to the alignment required
3538 for the ECOFF target debugging information. */
3539
3540 static unsigned long
3541 ecoff_padding_adjust (backend, buf, bufend, offset, bufptrptr)
3542 const struct ecoff_debug_swap *backend;
3543 char **buf;
3544 char **bufend;
3545 unsigned long offset;
3546 char **bufptrptr;
3547 {
3548 bfd_size_type align;
3549
3550 align = backend->debug_align;
3551 if ((offset & (align - 1)) != 0)
3552 {
3553 unsigned long add;
3554
3555 add = align - (offset & (align - 1));
3556 if (*bufend - (*buf + offset) < add)
3557 (void) ecoff_add_bytes (buf, bufend, *buf + offset, add);
3558 memset (*buf + offset, 0, add);
3559 offset += add;
3560 if (bufptrptr != (char **) NULL)
3561 *bufptrptr = *buf + offset;
3562 }
3563
3564 return offset;
3565 }
3566
3567 /* Build the line number information. */
3568
3569 static unsigned long
3570 ecoff_build_lineno (backend, buf, bufend, offset, linecntptr)
3571 const struct ecoff_debug_swap *backend;
3572 char **buf;
3573 char **bufend;
3574 unsigned long offset;
3575 long *linecntptr;
3576 {
3577 char *bufptr;
3578 register lineno_list_t *l;
3579 lineno_list_t *last;
3580 efdr_t *file;
3581 proc_t *proc;
3582 unsigned long c;
3583 long iline;
3584 long totcount;
3585 lineno_list_t first;
3586
3587 if (linecntptr != (long *) NULL)
3588 *linecntptr = 0;
3589
3590 bufptr = *buf + offset;
3591
3592 file = (efdr_t *) NULL;
3593 proc = (proc_t *) NULL;
3594 last = (lineno_list_t *) NULL;
3595 c = offset;
3596 iline = 0;
3597 totcount = 0;
3598
3599 /* For some reason the address of the first procedure is ignored
3600 when reading line numbers. This doesn't matter if the address of
3601 the first procedure is 0, but when gcc is generating MIPS
3602 embedded PIC code, it will put strings in the .text section
3603 before the first procedure. We cope by inserting a dummy line if
3604 the address of the first procedure is not 0. Hopefully this
3605 won't screw things up too badly. */
3606 if (first_proc_ptr != (proc_t *) NULL
3607 && first_lineno != (lineno_list_t *) NULL
3608 && ((S_GET_VALUE (first_proc_ptr->sym->as_sym)
3609 + bfd_get_section_vma (stdoutput,
3610 S_GET_SEGMENT (first_proc_ptr->sym->as_sym)))
3611 != 0))
3612 {
3613 first.file = first_lineno->file;
3614 first.proc = first_lineno->proc;
3615 first.frag = &zero_address_frag;
3616 first.paddr = 0;
3617 first.lineno = 0;
3618
3619 first.next = first_lineno;
3620 first_lineno = &first;
3621 }
3622
3623 for (l = first_lineno; l != (lineno_list_t *) NULL; l = l->next)
3624 {
3625 long count;
3626 long delta;
3627
3628 /* Get the offset to the memory address of the next line number
3629 (in words). Do this first, so that we can skip ahead to the
3630 next useful line number entry. */
3631 if (l->next == (lineno_list_t *) NULL)
3632 {
3633 /* We want a count of zero, but it will be decremented
3634 before it is used. */
3635 count = 1;
3636 }
3637 else
3638 {
3639 count = ((l->next->frag->fr_address + l->next->paddr
3640 - (l->frag->fr_address + l->paddr))
3641 >> 2);
3642 if (count <= 0)
3643 {
3644 /* Don't change last, so we still get the right delta. */
3645 continue;
3646 }
3647 }
3648
3649 if (l->file != file || l->proc != proc)
3650 {
3651 if (l->proc != proc && proc != (proc_t *) NULL)
3652 proc->pdr.lnHigh = last->lineno;
3653 if (l->file != file && file != (efdr_t *) NULL)
3654 {
3655 file->fdr.cbLine = c - file->fdr.cbLineOffset;
3656 /* The cline field is ill-documented. This is a guess
3657 at the right value. */
3658 file->fdr.cline = totcount + count;
3659 if (linecntptr != (long *) NULL)
3660 *linecntptr += totcount + count;
3661 totcount = 0;
3662 }
3663
3664 if (l->file != file)
3665 {
3666 file = l->file;
3667 file->fdr.ilineBase = iline;
3668 file->fdr.cbLineOffset = c;
3669 }
3670 if (l->proc != proc)
3671 {
3672 proc = l->proc;
3673 if (proc != (proc_t *) NULL)
3674 {
3675 proc->pdr.lnLow = l->lineno;
3676 proc->pdr.cbLineOffset = c - file->fdr.cbLineOffset;
3677 /* The iline field is ill-documented. This is a
3678 guess at the right value. */
3679 proc->pdr.iline = totcount;
3680 }
3681 }
3682
3683 last = (lineno_list_t *) NULL;
3684 }
3685
3686 totcount += count;
3687
3688 /* Get the offset to this line number. */
3689 if (last == (lineno_list_t *) NULL)
3690 delta = 0;
3691 else
3692 delta = l->lineno - last->lineno;
3693
3694 /* Put in the offset to this line number. */
3695 while (delta != 0)
3696 {
3697 int setcount;
3698
3699 /* 1 is added to each count read. */
3700 --count;
3701 /* We can only adjust the word count by up to 15 words at a
3702 time. */
3703 if (count <= 0x0f)
3704 {
3705 setcount = count;
3706 count = 0;
3707 }
3708 else
3709 {
3710 setcount = 0x0f;
3711 count -= 0x0f;
3712 }
3713 if (delta >= -7 && delta <= 7)
3714 {
3715 if (bufptr >= *bufend)
3716 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1);
3717 *bufptr++ = setcount + (delta << 4);
3718 delta = 0;
3719 ++c;
3720 }
3721 else
3722 {
3723 int set;
3724
3725 if (*bufend - bufptr < 3)
3726 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 3);
3727 *bufptr++ = setcount + (8 << 4);
3728 if (delta < -0x8000)
3729 {
3730 set = -0x8000;
3731 delta += 0x8000;
3732 }
3733 else if (delta > 0x7fff)
3734 {
3735 set = 0x7fff;
3736 delta -= 0x7fff;
3737 }
3738 else
3739 {
3740 set = delta;
3741 delta = 0;
3742 }
3743 *bufptr++ = set >> 8;
3744 *bufptr++ = set & 0xffff;
3745 c += 3;
3746 }
3747 }
3748
3749 /* Finish adjusting the count. */
3750 while (count > 0)
3751 {
3752 if (bufptr >= *bufend)
3753 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1);
3754 /* 1 is added to each count read. */
3755 --count;
3756 if (count > 0x0f)
3757 {
3758 *bufptr++ = 0x0f;
3759 count -= 0x0f;
3760 }
3761 else
3762 {
3763 *bufptr++ = count;
3764 count = 0;
3765 }
3766 ++c;
3767 }
3768
3769 ++iline;
3770 last = l;
3771 }
3772
3773 if (proc != (proc_t *) NULL)
3774 proc->pdr.lnHigh = last->lineno;
3775 if (file != (efdr_t *) NULL)
3776 {
3777 file->fdr.cbLine = c - file->fdr.cbLineOffset;
3778 file->fdr.cline = totcount;
3779 }
3780
3781 if (linecntptr != (long *) NULL)
3782 *linecntptr += totcount;
3783
3784 c = ecoff_padding_adjust (backend, buf, bufend, c, &bufptr);
3785
3786 return c;
3787 }
3788
3789 /* Build and swap out the symbols. */
3790
3791 static unsigned long
3792 ecoff_build_symbols (backend, buf, bufend, offset)
3793 const struct ecoff_debug_swap *backend;
3794 char **buf;
3795 char **bufend;
3796 unsigned long offset;
3797 {
3798 const bfd_size_type external_sym_size = backend->external_sym_size;
3799 void (* const swap_sym_out) PARAMS ((bfd *, const SYMR *, PTR))
3800 = backend->swap_sym_out;
3801 char *sym_out;
3802 long isym;
3803 vlinks_t *file_link;
3804
3805 sym_out = *buf + offset;
3806
3807 isym = 0;
3808
3809 /* The symbols are stored by file. */
3810 for (file_link = file_desc.first;
3811 file_link != (vlinks_t *) NULL;
3812 file_link = file_link->next)
3813 {
3814 int ifilesym;
3815 int fil_cnt;
3816 efdr_t *fil_ptr;
3817 efdr_t *fil_end;
3818
3819 if (file_link->next == (vlinks_t *) NULL)
3820 fil_cnt = file_desc.objects_last_page;
3821 else
3822 fil_cnt = file_desc.objects_per_page;
3823 fil_ptr = file_link->datum->file;
3824 fil_end = fil_ptr + fil_cnt;
3825 for (; fil_ptr < fil_end; fil_ptr++)
3826 {
3827 vlinks_t *sym_link;
3828
3829 fil_ptr->fdr.isymBase = isym;
3830 ifilesym = isym;
3831 for (sym_link = fil_ptr->symbols.first;
3832 sym_link != (vlinks_t *) NULL;
3833 sym_link = sym_link->next)
3834 {
3835 int sym_cnt;
3836 localsym_t *sym_ptr;
3837 localsym_t *sym_end;
3838
3839 if (sym_link->next == (vlinks_t *) NULL)
3840 sym_cnt = fil_ptr->symbols.objects_last_page;
3841 else
3842 sym_cnt = fil_ptr->symbols.objects_per_page;
3843 sym_ptr = sym_link->datum->sym;
3844 sym_end = sym_ptr + sym_cnt;
3845 for (; sym_ptr < sym_end; sym_ptr++)
3846 {
3847 int local;
3848 symbolS *as_sym;
3849 forward_t *f;
3850
3851 know (sym_ptr->file_ptr == fil_ptr);
3852
3853 /* If there is no associated gas symbol, then this
3854 is a pure debugging symbol. We have already
3855 added the name (if any) to fil_ptr->strings.
3856 Otherwise we must decide whether this is an
3857 external or a local symbol (actually, it may be
3858 both if the local provides additional debugging
3859 information for the external). */
3860 local = 1;
3861 as_sym = sym_ptr->as_sym;
3862 if (as_sym != (symbolS *) NULL)
3863 {
3864 symint_t indx;
3865
3866 /* The value of a block start symbol is the
3867 offset from the start of the procedure. For
3868 other symbols we just use the gas value (but
3869 we must offset it by the vma of the section,
3870 just as BFD does, because BFD will not see
3871 this value). */
3872 if (sym_ptr->ecoff_sym.asym.st == (int) st_Block
3873 && sym_ptr->ecoff_sym.asym.sc == (int) sc_Text)
3874 {
3875 symbolS *begin_sym;
3876
3877 know (sym_ptr->proc_ptr != (proc_t *) NULL);
3878 begin_sym = sym_ptr->proc_ptr->sym->as_sym;
3879 if (S_GET_SEGMENT (as_sym)
3880 != S_GET_SEGMENT (begin_sym))
3881 as_warn (".begin/.bend in different segments");
3882 sym_ptr->ecoff_sym.asym.value =
3883 S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym);
3884 }
3885 else
3886 sym_ptr->ecoff_sym.asym.value =
3887 (S_GET_VALUE (as_sym)
3888 + bfd_get_section_vma (stdoutput,
3889 S_GET_SEGMENT (as_sym)));
3890
3891 /* Set st_Proc to st_StaticProc for local
3892 functions. */
3893 if (sym_ptr->ecoff_sym.asym.st == st_Proc
3894 && S_IS_DEFINED (as_sym)
3895 && ! S_IS_EXTERNAL (as_sym))
3896 sym_ptr->ecoff_sym.asym.st = st_StaticProc;
3897
3898 /* Get the type and storage class based on where
3899 the symbol actually wound up. Traditionally,
3900 N_LBRAC and N_RBRAC are *not* relocated. */
3901 indx = sym_ptr->ecoff_sym.asym.index;
3902 if (sym_ptr->ecoff_sym.asym.st == st_Nil
3903 && sym_ptr->ecoff_sym.asym.sc == sc_Nil
3904 && (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym)
3905 || ((ECOFF_UNMARK_STAB (indx) != N_LBRAC)
3906 && (ECOFF_UNMARK_STAB (indx) != N_RBRAC))))
3907 {
3908 segT seg;
3909 const char *segname;
3910 st_t st;
3911 sc_t sc;
3912
3913 seg = S_GET_SEGMENT (as_sym);
3914 segname = segment_name (seg);
3915
3916 if (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym)
3917 && (S_IS_EXTERNAL (as_sym)
3918 || ! S_IS_DEFINED (as_sym)))
3919 {
3920 if ((as_sym->bsym->flags & BSF_FUNCTION) != 0)
3921 st = st_Proc;
3922 else
3923 st = st_Global;
3924 }
3925 else if (seg == text_section)
3926 st = st_Label;
3927 else
3928 st = st_Static;
3929
3930 if (! S_IS_DEFINED (as_sym))
3931 {
3932 if (as_sym->ecoff_extern_size == 0
3933 || (as_sym->ecoff_extern_size
3934 > bfd_get_gp_size (stdoutput)))
3935 sc = sc_Undefined;
3936 else
3937 {
3938 sc = sc_SUndefined;
3939 sym_ptr->ecoff_sym.asym.value =
3940 as_sym->ecoff_extern_size;
3941 }
3942 }
3943 else if (S_IS_COMMON (as_sym))
3944 {
3945 if (S_GET_VALUE (as_sym) > 0
3946 && (S_GET_VALUE (as_sym)
3947 <= bfd_get_gp_size (stdoutput)))
3948 sc = sc_SCommon;
3949 else
3950 sc = sc_Common;
3951 }
3952 else if (seg == text_section)
3953 sc = sc_Text;
3954 else if (seg == data_section)
3955 sc = sc_Data;
3956 else if (strcmp (segname, ".rdata") == 0
3957 || strcmp (segname, ".rodata") == 0)
3958 sc = sc_RData;
3959 else if (strcmp (segname, ".sdata") == 0)
3960 sc = sc_SData;
3961 else if (seg == bss_section)
3962 sc = sc_Bss;
3963 else if (strcmp (segname, ".sbss") == 0)
3964 sc = sc_SBss;
3965 else if (seg == &bfd_abs_section)
3966 sc = sc_Abs;
3967 else
3968 {
3969 /* This must be a user named section.
3970 This is not possible in ECOFF, but it
3971 is in ELF. */
3972 sc = sc_Data;
3973 }
3974
3975 sym_ptr->ecoff_sym.asym.st = (int) st;
3976 sym_ptr->ecoff_sym.asym.sc = (int) sc;
3977 }
3978
3979 /* This is just an external symbol if it is
3980 outside a procedure and it has a type.
3981 FIXME: g++ will generate symbols which have
3982 different names in the debugging information
3983 than the actual symbol. Should we handle
3984 them here? */
3985 if ((S_IS_EXTERNAL (as_sym)
3986 || ! S_IS_DEFINED (as_sym))
3987 && sym_ptr->proc_ptr == (proc_t *) NULL
3988 && sym_ptr->ecoff_sym.asym.st != (int) st_Nil
3989 && ! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym))
3990 local = 0;
3991
3992 /* If an st_end symbol has an associated gas
3993 symbol, then it is a local label created for
3994 a .bend or .end directive. Stabs line
3995 numbers will have \001 in the names. */
3996 if (local
3997 && sym_ptr->ecoff_sym.asym.st != st_End
3998 && strchr (sym_ptr->name, '\001') == 0)
3999 sym_ptr->ecoff_sym.asym.iss =
4000 add_string (&fil_ptr->strings,
4001 fil_ptr->str_hash,
4002 sym_ptr->name,
4003 (shash_t **) NULL);
4004 }
4005
4006 /* We now know the index of this symbol; fill in
4007 locations that have been waiting for that
4008 information. */
4009 if (sym_ptr->begin_ptr != (localsym_t *) NULL)
4010 {
4011 localsym_t *begin_ptr;
4012 st_t begin_type;
4013
4014 know (local);
4015 begin_ptr = sym_ptr->begin_ptr;
4016 know (begin_ptr->sym_index != -1);
4017 sym_ptr->ecoff_sym.asym.index = begin_ptr->sym_index;
4018 if (sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
4019 sym_ptr->ecoff_sym.asym.iss =
4020 begin_ptr->ecoff_sym.asym.iss;
4021
4022 begin_type = begin_ptr->ecoff_sym.asym.st;
4023 if (begin_type == st_File
4024 || begin_type == st_Block)
4025 {
4026 begin_ptr->ecoff_sym.asym.index =
4027 isym - ifilesym + 1;
4028 (*swap_sym_out) (stdoutput,
4029 &begin_ptr->ecoff_sym.asym,
4030 (*buf
4031 + offset
4032 + (begin_ptr->sym_index
4033 * external_sym_size)));
4034 }
4035 else
4036 {
4037 know (begin_ptr->index_ptr != (aux_t *) NULL);
4038 begin_ptr->index_ptr->data.isym =
4039 isym - ifilesym + 1;
4040 }
4041
4042 /* The value of the symbol marking the end of a
4043 procedure is the size of the procedure. The
4044 value of the symbol marking the end of a
4045 block is the offset from the start of the
4046 procedure to the block. */
4047 if (begin_type == st_Proc
4048 || begin_type == st_StaticProc)
4049 {
4050 know (as_sym != (symbolS *) NULL);
4051 know (begin_ptr->as_sym != (symbolS *) NULL);
4052 if (S_GET_SEGMENT (as_sym)
4053 != S_GET_SEGMENT (begin_ptr->as_sym))
4054 as_warn (".begin/.bend in different segments");
4055 sym_ptr->ecoff_sym.asym.value =
4056 (S_GET_VALUE (as_sym)
4057 - S_GET_VALUE (begin_ptr->as_sym));
4058 }
4059 else if (begin_type == st_Block
4060 && sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
4061 {
4062 symbolS *begin_sym;
4063
4064 know (as_sym != (symbolS *) NULL);
4065 know (sym_ptr->proc_ptr != (proc_t *) NULL);
4066 begin_sym = sym_ptr->proc_ptr->sym->as_sym;
4067 if (S_GET_SEGMENT (as_sym)
4068 != S_GET_SEGMENT (begin_sym))
4069 as_warn (".begin/.bend in different segments");
4070 sym_ptr->ecoff_sym.asym.value =
4071 S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym);
4072 }
4073 }
4074
4075 for (f = sym_ptr->forward_ref;
4076 f != (forward_t *) NULL;
4077 f = f->next)
4078 {
4079 know (local);
4080 f->ifd_ptr->data.isym = fil_ptr->file_index;
4081 f->index_ptr->data.rndx.index = isym - ifilesym;
4082 }
4083
4084 if (local)
4085 {
4086 if (*bufend - sym_out < external_sym_size)
4087 sym_out = ecoff_add_bytes (buf, bufend,
4088 sym_out,
4089 external_sym_size);
4090 (*swap_sym_out) (stdoutput, &sym_ptr->ecoff_sym.asym,
4091 sym_out);
4092 sym_out += external_sym_size;
4093
4094 sym_ptr->sym_index = isym;
4095
4096 if (sym_ptr->proc_ptr != (proc_t *) NULL
4097 && sym_ptr->proc_ptr->sym == sym_ptr)
4098 sym_ptr->proc_ptr->pdr.isym = isym - ifilesym;
4099
4100 ++isym;
4101 }
4102
4103 /* Record the local symbol index and file number in
4104 case this is an external symbol. Note that this
4105 destroys the asym.index field. */
4106 if (as_sym != (symbolS *) NULL
4107 && as_sym->ecoff_symbol == sym_ptr)
4108 {
4109 if ((sym_ptr->ecoff_sym.asym.st == st_Proc
4110 || sym_ptr->ecoff_sym.asym.st == st_StaticProc)
4111 && local)
4112 sym_ptr->ecoff_sym.asym.index = isym - ifilesym - 1;
4113 sym_ptr->ecoff_sym.ifd = fil_ptr->file_index;
4114 }
4115 }
4116 }
4117 fil_ptr->fdr.csym = isym - fil_ptr->fdr.isymBase;
4118 }
4119 }
4120
4121 return offset + isym * external_sym_size;
4122 }
4123
4124 /* Swap out the procedure information. */
4125
4126 static unsigned long
4127 ecoff_build_procs (backend, buf, bufend, offset)
4128 const struct ecoff_debug_swap *backend;
4129 char **buf;
4130 char **bufend;
4131 unsigned long offset;
4132 {
4133 const bfd_size_type external_pdr_size = backend->external_pdr_size;
4134 void (* const swap_pdr_out) PARAMS ((bfd *, const PDR *, PTR))
4135 = backend->swap_pdr_out;
4136 char *pdr_out;
4137 long iproc;
4138 vlinks_t *file_link;
4139
4140 pdr_out = *buf + offset;
4141
4142 iproc = 0;
4143
4144 /* The procedures are stored by file. */
4145 for (file_link = file_desc.first;
4146 file_link != (vlinks_t *) NULL;
4147 file_link = file_link->next)
4148 {
4149 int fil_cnt;
4150 efdr_t *fil_ptr;
4151 efdr_t *fil_end;
4152
4153 if (file_link->next == (vlinks_t *) NULL)
4154 fil_cnt = file_desc.objects_last_page;
4155 else
4156 fil_cnt = file_desc.objects_per_page;
4157 fil_ptr = file_link->datum->file;
4158 fil_end = fil_ptr + fil_cnt;
4159 for (; fil_ptr < fil_end; fil_ptr++)
4160 {
4161 vlinks_t *proc_link;
4162 int first;
4163
4164 fil_ptr->fdr.ipdFirst = iproc;
4165 first = 1;
4166 for (proc_link = fil_ptr->procs.first;
4167 proc_link != (vlinks_t *) NULL;
4168 proc_link = proc_link->next)
4169 {
4170 int prc_cnt;
4171 proc_t *proc_ptr;
4172 proc_t *proc_end;
4173
4174 if (proc_link->next == (vlinks_t *) NULL)
4175 prc_cnt = fil_ptr->procs.objects_last_page;
4176 else
4177 prc_cnt = fil_ptr->procs.objects_per_page;
4178 proc_ptr = proc_link->datum->proc;
4179 proc_end = proc_ptr + prc_cnt;
4180 for (; proc_ptr < proc_end; proc_ptr++)
4181 {
4182 symbolS *adr_sym;
4183 unsigned long adr;
4184
4185 adr_sym = proc_ptr->sym->as_sym;
4186 adr = (S_GET_VALUE (adr_sym)
4187 + bfd_get_section_vma (stdoutput,
4188 S_GET_SEGMENT (adr_sym)));
4189 if (first)
4190 {
4191 /* This code used to force the adr of the very
4192 first fdr to be 0. However, the native tools
4193 don't do that, and I can't remember why it
4194 used to work that way, so I took it out. */
4195 fil_ptr->fdr.adr = adr;
4196 first = 0;
4197 }
4198 proc_ptr->pdr.adr = adr - fil_ptr->fdr.adr;
4199 if (*bufend - pdr_out < external_pdr_size)
4200 pdr_out = ecoff_add_bytes (buf, bufend,
4201 pdr_out,
4202 external_pdr_size);
4203 (*swap_pdr_out) (stdoutput, &proc_ptr->pdr, pdr_out);
4204 pdr_out += external_pdr_size;
4205 ++iproc;
4206 }
4207 }
4208 fil_ptr->fdr.cpd = iproc - fil_ptr->fdr.ipdFirst;
4209 }
4210 }
4211
4212 return offset + iproc * external_pdr_size;
4213 }
4214
4215 /* Swap out the aux information. */
4216
4217 static unsigned long
4218 ecoff_build_aux (backend, buf, bufend, offset)
4219 const struct ecoff_debug_swap *backend;
4220 char **buf;
4221 char **bufend;
4222 unsigned long offset;
4223 {
4224 int bigendian;
4225 union aux_ext *aux_out;
4226 long iaux;
4227 vlinks_t *file_link;
4228
4229 bigendian = stdoutput->xvec->header_byteorder_big_p;
4230
4231 aux_out = (union aux_ext *) (*buf + offset);
4232
4233 iaux = 0;
4234
4235 /* The aux entries are stored by file. */
4236 for (file_link = file_desc.first;
4237 file_link != (vlinks_t *) NULL;
4238 file_link = file_link->next)
4239 {
4240 int fil_cnt;
4241 efdr_t *fil_ptr;
4242 efdr_t *fil_end;
4243
4244 if (file_link->next == (vlinks_t *) NULL)
4245 fil_cnt = file_desc.objects_last_page;
4246 else
4247 fil_cnt = file_desc.objects_per_page;
4248 fil_ptr = file_link->datum->file;
4249 fil_end = fil_ptr + fil_cnt;
4250 for (; fil_ptr < fil_end; fil_ptr++)
4251 {
4252 vlinks_t *aux_link;
4253
4254 fil_ptr->fdr.fBigendian = bigendian;
4255 fil_ptr->fdr.iauxBase = iaux;
4256 for (aux_link = fil_ptr->aux_syms.first;
4257 aux_link != (vlinks_t *) NULL;
4258 aux_link = aux_link->next)
4259 {
4260 int aux_cnt;
4261 aux_t *aux_ptr;
4262 aux_t *aux_end;
4263
4264 if (aux_link->next == (vlinks_t *) NULL)
4265 aux_cnt = fil_ptr->aux_syms.objects_last_page;
4266 else
4267 aux_cnt = fil_ptr->aux_syms.objects_per_page;
4268 aux_ptr = aux_link->datum->aux;
4269 aux_end = aux_ptr + aux_cnt;
4270 for (; aux_ptr < aux_end; aux_ptr++)
4271 {
4272 if (*bufend - (char *) aux_out < sizeof (union aux_ext))
4273 aux_out = ((union aux_ext *)
4274 ecoff_add_bytes (buf, bufend,
4275 (char *) aux_out,
4276 sizeof (union aux_ext)));
4277 switch (aux_ptr->type)
4278 {
4279 case aux_tir:
4280 (*backend->swap_tir_out) (bigendian,
4281 &aux_ptr->data.ti,
4282 &aux_out->a_ti);
4283 break;
4284 case aux_rndx:
4285 (*backend->swap_rndx_out) (bigendian,
4286 &aux_ptr->data.rndx,
4287 &aux_out->a_rndx);
4288 break;
4289 case aux_dnLow:
4290 AUX_PUT_DNLOW (bigendian, aux_ptr->data.dnLow,
4291 aux_out);
4292 break;
4293 case aux_dnHigh:
4294 AUX_PUT_DNHIGH (bigendian, aux_ptr->data.dnHigh,
4295 aux_out);
4296 break;
4297 case aux_isym:
4298 AUX_PUT_ISYM (bigendian, aux_ptr->data.isym,
4299 aux_out);
4300 break;
4301 case aux_iss:
4302 AUX_PUT_ISS (bigendian, aux_ptr->data.iss,
4303 aux_out);
4304 break;
4305 case aux_width:
4306 AUX_PUT_WIDTH (bigendian, aux_ptr->data.width,
4307 aux_out);
4308 break;
4309 case aux_count:
4310 AUX_PUT_COUNT (bigendian, aux_ptr->data.count,
4311 aux_out);
4312 break;
4313 }
4314
4315 ++aux_out;
4316 ++iaux;
4317 }
4318 }
4319 fil_ptr->fdr.caux = iaux - fil_ptr->fdr.iauxBase;
4320 }
4321 }
4322
4323 return ecoff_padding_adjust (backend, buf, bufend,
4324 offset + iaux * sizeof (union aux_ext),
4325 (char **) NULL);
4326 }
4327
4328 /* Copy out the strings from a varray_t. This returns the number of
4329 bytes copied, rather than the new offset. */
4330
4331 static unsigned long
4332 ecoff_build_strings (buf, bufend, offset, vp)
4333 char **buf;
4334 char **bufend;
4335 unsigned long offset;
4336 varray_t *vp;
4337 {
4338 unsigned long istr;
4339 char *str_out;
4340 vlinks_t *str_link;
4341
4342 str_out = *buf + offset;
4343
4344 istr = 0;
4345
4346 for (str_link = vp->first;
4347 str_link != (vlinks_t *) NULL;
4348 str_link = str_link->next)
4349 {
4350 unsigned long str_cnt;
4351
4352 if (str_link->next == (vlinks_t *) NULL)
4353 str_cnt = vp->objects_last_page;
4354 else
4355 str_cnt = vp->objects_per_page;
4356
4357 if (*bufend - str_out < str_cnt)
4358 str_out = ecoff_add_bytes (buf, bufend, str_out, str_cnt);
4359
4360 memcpy (str_out, str_link->datum->byte, str_cnt);
4361 str_out += str_cnt;
4362 istr += str_cnt;
4363 }
4364
4365 return istr;
4366 }
4367
4368 /* Dump out the local strings. */
4369
4370 static unsigned long
4371 ecoff_build_ss (backend, buf, bufend, offset)
4372 const struct ecoff_debug_swap *backend;
4373 char **buf;
4374 char **bufend;
4375 unsigned long offset;
4376 {
4377 long iss;
4378 vlinks_t *file_link;
4379
4380 iss = 0;
4381
4382 for (file_link = file_desc.first;
4383 file_link != (vlinks_t *) NULL;
4384 file_link = file_link->next)
4385 {
4386 int fil_cnt;
4387 efdr_t *fil_ptr;
4388 efdr_t *fil_end;
4389
4390 if (file_link->next == (vlinks_t *) NULL)
4391 fil_cnt = file_desc.objects_last_page;
4392 else
4393 fil_cnt = file_desc.objects_per_page;
4394 fil_ptr = file_link->datum->file;
4395 fil_end = fil_ptr + fil_cnt;
4396 for (; fil_ptr < fil_end; fil_ptr++)
4397 {
4398 long ss_cnt;
4399
4400 fil_ptr->fdr.issBase = iss;
4401 ss_cnt = ecoff_build_strings (buf, bufend, offset + iss,
4402 &fil_ptr->strings);
4403 fil_ptr->fdr.cbSs = ss_cnt;
4404 iss += ss_cnt;
4405 }
4406 }
4407
4408 return ecoff_padding_adjust (backend, buf, bufend, offset + iss,
4409 (char **) NULL);
4410 }
4411
4412 /* Swap out the file descriptors. */
4413
4414 static unsigned long
4415 ecoff_build_fdr (backend, buf, bufend, offset)
4416 const struct ecoff_debug_swap *backend;
4417 char **buf;
4418 char **bufend;
4419 unsigned long offset;
4420 {
4421 const bfd_size_type external_fdr_size = backend->external_fdr_size;
4422 void (* const swap_fdr_out) PARAMS ((bfd *, const FDR *, PTR))
4423 = backend->swap_fdr_out;
4424 long ifile;
4425 char *fdr_out;
4426 vlinks_t *file_link;
4427
4428 ifile = 0;
4429
4430 fdr_out = *buf + offset;
4431
4432 for (file_link = file_desc.first;
4433 file_link != (vlinks_t *) NULL;
4434 file_link = file_link->next)
4435 {
4436 int fil_cnt;
4437 efdr_t *fil_ptr;
4438 efdr_t *fil_end;
4439
4440 if (file_link->next == (vlinks_t *) NULL)
4441 fil_cnt = file_desc.objects_last_page;
4442 else
4443 fil_cnt = file_desc.objects_per_page;
4444 fil_ptr = file_link->datum->file;
4445 fil_end = fil_ptr + fil_cnt;
4446 for (; fil_ptr < fil_end; fil_ptr++)
4447 {
4448 if (*bufend - fdr_out < external_fdr_size)
4449 fdr_out = ecoff_add_bytes (buf, bufend, fdr_out,
4450 external_fdr_size);
4451 (*swap_fdr_out) (stdoutput, &fil_ptr->fdr, fdr_out);
4452 fdr_out += external_fdr_size;
4453 ++ifile;
4454 }
4455 }
4456
4457 return offset + ifile * external_fdr_size;
4458 }
4459
4460 /* Set up the external symbols. These are supposed to be handled by
4461 the backend. This routine just gets the right information and
4462 calls a backend function to deal with it. */
4463
4464 static void
4465 ecoff_setup_ext ()
4466 {
4467 register symbolS *sym;
4468
4469 for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
4470 {
4471 if (sym->ecoff_symbol == NULL)
4472 continue;
4473
4474 /* If this is a local symbol, then force the fields to zero. */
4475 if (! S_IS_EXTERNAL (sym)
4476 && S_IS_DEFINED (sym))
4477 {
4478 sym->ecoff_symbol->ecoff_sym.asym.value = 0;
4479 sym->ecoff_symbol->ecoff_sym.asym.st = (int) st_Nil;
4480 sym->ecoff_symbol->ecoff_sym.asym.sc = (int) sc_Nil;
4481 sym->ecoff_symbol->ecoff_sym.asym.index = indexNil;
4482 }
4483
4484 obj_ecoff_set_ext (sym, &sym->ecoff_symbol->ecoff_sym);
4485 }
4486 }
4487
4488 /* Build the ECOFF dbeugging information. */
4489
4490 unsigned long
4491 ecoff_build_debug (hdr, bufp, backend)
4492 HDRR *hdr;
4493 char **bufp;
4494 const struct ecoff_debug_swap *backend;
4495 {
4496 const bfd_size_type external_pdr_size = backend->external_pdr_size;
4497 tag_t *ptag;
4498 tag_t *ptag_next;
4499 efdr_t *fil_ptr;
4500 int end_warning;
4501 efdr_t *hold_file_ptr;
4502 proc_t * hold_proc_ptr;
4503 symbolS *sym;
4504 char *buf;
4505 char *bufend;
4506 unsigned long offset;
4507
4508 /* Make sure we have a file. */
4509 if (first_file == (efdr_t *) NULL)
4510 add_file ((const char *) NULL, 0);
4511
4512 /* Handle any top level tags. */
4513 for (ptag = top_tag_head->first_tag;
4514 ptag != (tag_t *) NULL;
4515 ptag = ptag_next)
4516 {
4517 if (ptag->forward_ref != (forward_t *) NULL)
4518 add_unknown_tag (ptag);
4519
4520 ptag_next = ptag->same_block;
4521 ptag->hash_ptr->tag_ptr = ptag->same_name;
4522 free_tag (ptag);
4523 }
4524
4525 free_thead (top_tag_head);
4526
4527 /* Look through the symbols. Add debugging information for each
4528 symbol that has not already received it. */
4529 hold_file_ptr = cur_file_ptr;
4530 hold_proc_ptr = cur_proc_ptr;
4531 cur_proc_ptr = (proc_t *) NULL;
4532 for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
4533 {
4534 if (sym->ecoff_symbol != NULL
4535 || sym->ecoff_file == (efdr_t *) NULL
4536 || (sym->bsym->flags & BSF_SECTION_SYM) != 0)
4537 continue;
4538
4539 cur_file_ptr = sym->ecoff_file;
4540 add_ecoff_symbol ((const char *) NULL, st_Nil, sc_Nil, sym,
4541 S_GET_VALUE (sym), indexNil);
4542 }
4543 cur_proc_ptr = hold_proc_ptr;
4544 cur_file_ptr = hold_file_ptr;
4545
4546 /* Output an ending symbol for all the files. We have to do this
4547 here for the last file, so we may as well do it for all of the
4548 files. */
4549 end_warning = 0;
4550 for (fil_ptr = first_file;
4551 fil_ptr != (efdr_t *) NULL;
4552 fil_ptr = fil_ptr->next_file)
4553 {
4554 cur_file_ptr = fil_ptr;
4555 while (cur_file_ptr->cur_scope != (scope_t *) NULL
4556 && cur_file_ptr->cur_scope->prev != (scope_t *) NULL)
4557 {
4558 cur_file_ptr->cur_scope = cur_file_ptr->cur_scope->prev;
4559 if (! end_warning)
4560 {
4561 as_warn ("Missing .end or .bend at end of file");
4562 end_warning = 1;
4563 }
4564 }
4565 if (cur_file_ptr->cur_scope != (scope_t *) NULL)
4566 (void) add_ecoff_symbol ((const char *) NULL,
4567 st_End, sc_Text,
4568 (symbolS *) NULL,
4569 (symint_t) 0,
4570 (symint_t) 0);
4571 }
4572
4573 /* Build the symbolic information. */
4574 offset = 0;
4575 buf = xmalloc (PAGE_SIZE);
4576 bufend = buf + PAGE_SIZE;
4577
4578 /* Build the line number information. */
4579 hdr->cbLineOffset = offset;
4580 offset = ecoff_build_lineno (backend, &buf, &bufend, offset,
4581 &hdr->ilineMax);
4582 hdr->cbLine = offset - hdr->cbLineOffset;
4583
4584 /* We don't use dense numbers at all. */
4585 hdr->idnMax = 0;
4586 hdr->cbDnOffset = 0;
4587
4588 /* We can't build the PDR table until we have built the symbols,
4589 because a PDR contains a symbol index. However, we set aside
4590 space at this point. */
4591 hdr->ipdMax = proc_cnt;
4592 hdr->cbPdOffset = offset;
4593 if (bufend - (buf + offset) < proc_cnt * external_pdr_size)
4594 (void) ecoff_add_bytes (&buf, &bufend, buf + offset,
4595 proc_cnt * external_pdr_size);
4596 offset += proc_cnt * external_pdr_size;
4597
4598 /* Build the local symbols. */
4599 hdr->cbSymOffset = offset;
4600 offset = ecoff_build_symbols (backend, &buf, &bufend, offset);
4601 hdr->isymMax = (offset - hdr->cbSymOffset) / backend->external_sym_size;
4602
4603 /* Building the symbols initializes the symbol index in the PDR's.
4604 Now we can swap out the PDR's. */
4605 (void) ecoff_build_procs (backend, &buf, &bufend, hdr->cbPdOffset);
4606
4607 /* We don't use optimization symbols. */
4608 hdr->ioptMax = 0;
4609 hdr->cbOptOffset = 0;
4610
4611 /* Swap out the auxiliary type information. */
4612 hdr->cbAuxOffset = offset;
4613 offset = ecoff_build_aux (backend, &buf, &bufend, offset);
4614 hdr->iauxMax = (offset - hdr->cbAuxOffset) / sizeof (union aux_ext);
4615
4616 /* Copy out the local strings. */
4617 hdr->cbSsOffset = offset;
4618 offset = ecoff_build_ss (backend, &buf, &bufend, offset);
4619 hdr->issMax = offset - hdr->cbSsOffset;
4620
4621 /* We don't use relative file descriptors. */
4622 hdr->crfd = 0;
4623 hdr->cbRfdOffset = 0;
4624
4625 /* Swap out the file descriptors. */
4626 hdr->cbFdOffset = offset;
4627 offset = ecoff_build_fdr (backend, &buf, &bufend, offset);
4628 hdr->ifdMax = (offset - hdr->cbFdOffset) / backend->external_fdr_size;
4629
4630 /* Set up the external symbols, which are handled by the BFD back
4631 end. */
4632 hdr->issExtMax = 0;
4633 hdr->cbSsExtOffset = 0;
4634 hdr->iextMax = 0;
4635 hdr->cbExtOffset = 0;
4636 ecoff_setup_ext ();
4637
4638 know ((offset & (backend->debug_align - 1)) == 0);
4639
4640 /* FIXME: This value should be determined from the .verstamp directive,
4641 with reasonable defaults in config files. */
4642 #ifdef TC_ALPHA
4643 hdr->vstamp = 0x030b;
4644 #else
4645 hdr->vstamp = 0x020b;
4646 #endif
4647
4648 *bufp = buf;
4649 return offset;
4650 }
4651 \f
4652 /* Allocate a cluster of pages. */
4653
4654 #ifndef MALLOC_CHECK
4655
4656 static page_t *
4657 allocate_cluster (npages)
4658 unsigned long npages;
4659 {
4660 register page_t *value = (page_t *) xmalloc (npages * PAGE_USIZE);
4661
4662 #ifdef ECOFF_DEBUG
4663 if (debug > 3)
4664 fprintf (stderr, "\talloc\tnpages = %d, value = 0x%.8x\n", npages, value);
4665 #endif
4666
4667 memset (value, 0, npages * PAGE_USIZE);
4668
4669 return value;
4670 }
4671
4672
4673 static page_t *cluster_ptr = NULL;
4674 static unsigned long pages_left = 0;
4675
4676 #endif /* MALLOC_CHECK */
4677
4678 /* Allocate one page (which is initialized to 0). */
4679
4680 static page_t *
4681 allocate_page ()
4682 {
4683 #ifndef MALLOC_CHECK
4684
4685 if (pages_left == 0)
4686 {
4687 pages_left = MAX_CLUSTER_PAGES;
4688 cluster_ptr = allocate_cluster (pages_left);
4689 }
4690
4691 pages_left--;
4692 return cluster_ptr++;
4693
4694 #else /* MALLOC_CHECK */
4695
4696 page_t *ptr;
4697
4698 ptr = xmalloc (PAGE_USIZE);
4699 memset (ptr, 0, PAGE_USIZE);
4700 return ptr;
4701
4702 #endif /* MALLOC_CHECK */
4703 }
4704 \f
4705 /* Allocate scoping information. */
4706
4707 static scope_t *
4708 allocate_scope ()
4709 {
4710 register scope_t *ptr;
4711 static scope_t initial_scope;
4712
4713 #ifndef MALLOC_CHECK
4714
4715 ptr = alloc_counts[(int)alloc_type_scope].free_list.f_scope;
4716 if (ptr != (scope_t *) NULL)
4717 alloc_counts[ (int)alloc_type_scope ].free_list.f_scope = ptr->free;
4718 else
4719 {
4720 register int unallocated = alloc_counts[(int)alloc_type_scope].unallocated;
4721 register page_t *cur_page = alloc_counts[(int)alloc_type_scope].cur_page;
4722
4723 if (unallocated == 0)
4724 {
4725 unallocated = PAGE_SIZE / sizeof (scope_t);
4726 alloc_counts[(int)alloc_type_scope].cur_page = cur_page = allocate_page ();
4727 alloc_counts[(int)alloc_type_scope].total_pages++;
4728 }
4729
4730 ptr = &cur_page->scope[--unallocated];
4731 alloc_counts[(int)alloc_type_scope].unallocated = unallocated;
4732 }
4733
4734 #else
4735
4736 ptr = (scope_t *) xmalloc (sizeof (scope_t));
4737
4738 #endif
4739
4740 alloc_counts[(int)alloc_type_scope].total_alloc++;
4741 *ptr = initial_scope;
4742 return ptr;
4743 }
4744
4745 /* Free scoping information. */
4746
4747 static void
4748 free_scope (ptr)
4749 scope_t *ptr;
4750 {
4751 alloc_counts[(int)alloc_type_scope].total_free++;
4752
4753 #ifndef MALLOC_CHECK
4754 ptr->free = alloc_counts[(int)alloc_type_scope].free_list.f_scope;
4755 alloc_counts[(int)alloc_type_scope].free_list.f_scope = ptr;
4756 #else
4757 free ((PTR) ptr);
4758 #endif
4759 }
4760 \f
4761 /* Allocate links for pages in a virtual array. */
4762
4763 static vlinks_t *
4764 allocate_vlinks ()
4765 {
4766 register vlinks_t *ptr;
4767 static vlinks_t initial_vlinks;
4768
4769 #ifndef MALLOC_CHECK
4770
4771 register int unallocated = alloc_counts[(int)alloc_type_vlinks].unallocated;
4772 register page_t *cur_page = alloc_counts[(int)alloc_type_vlinks].cur_page;
4773
4774 if (unallocated == 0)
4775 {
4776 unallocated = PAGE_SIZE / sizeof (vlinks_t);
4777 alloc_counts[(int)alloc_type_vlinks].cur_page = cur_page = allocate_page ();
4778 alloc_counts[(int)alloc_type_vlinks].total_pages++;
4779 }
4780
4781 ptr = &cur_page->vlinks[--unallocated];
4782 alloc_counts[(int)alloc_type_vlinks].unallocated = unallocated;
4783
4784 #else
4785
4786 ptr = (vlinks_t *) xmalloc (sizeof (vlinks_t));
4787
4788 #endif
4789
4790 alloc_counts[(int)alloc_type_vlinks].total_alloc++;
4791 *ptr = initial_vlinks;
4792 return ptr;
4793 }
4794 \f
4795 /* Allocate string hash buckets. */
4796
4797 static shash_t *
4798 allocate_shash ()
4799 {
4800 register shash_t *ptr;
4801 static shash_t initial_shash;
4802
4803 #ifndef MALLOC_CHECK
4804
4805 register int unallocated = alloc_counts[(int)alloc_type_shash].unallocated;
4806 register page_t *cur_page = alloc_counts[(int)alloc_type_shash].cur_page;
4807
4808 if (unallocated == 0)
4809 {
4810 unallocated = PAGE_SIZE / sizeof (shash_t);
4811 alloc_counts[(int)alloc_type_shash].cur_page = cur_page = allocate_page ();
4812 alloc_counts[(int)alloc_type_shash].total_pages++;
4813 }
4814
4815 ptr = &cur_page->shash[--unallocated];
4816 alloc_counts[(int)alloc_type_shash].unallocated = unallocated;
4817
4818 #else
4819
4820 ptr = (shash_t *) xmalloc (sizeof (shash_t));
4821
4822 #endif
4823
4824 alloc_counts[(int)alloc_type_shash].total_alloc++;
4825 *ptr = initial_shash;
4826 return ptr;
4827 }
4828 \f
4829 /* Allocate type hash buckets. */
4830
4831 static thash_t *
4832 allocate_thash ()
4833 {
4834 register thash_t *ptr;
4835 static thash_t initial_thash;
4836
4837 #ifndef MALLOC_CHECK
4838
4839 register int unallocated = alloc_counts[(int)alloc_type_thash].unallocated;
4840 register page_t *cur_page = alloc_counts[(int)alloc_type_thash].cur_page;
4841
4842 if (unallocated == 0)
4843 {
4844 unallocated = PAGE_SIZE / sizeof (thash_t);
4845 alloc_counts[(int)alloc_type_thash].cur_page = cur_page = allocate_page ();
4846 alloc_counts[(int)alloc_type_thash].total_pages++;
4847 }
4848
4849 ptr = &cur_page->thash[--unallocated];
4850 alloc_counts[(int)alloc_type_thash].unallocated = unallocated;
4851
4852 #else
4853
4854 ptr = (thash_t *) xmalloc (sizeof (thash_t));
4855
4856 #endif
4857
4858 alloc_counts[(int)alloc_type_thash].total_alloc++;
4859 *ptr = initial_thash;
4860 return ptr;
4861 }
4862 \f
4863 /* Allocate structure, union, or enum tag information. */
4864
4865 static tag_t *
4866 allocate_tag ()
4867 {
4868 register tag_t *ptr;
4869 static tag_t initial_tag;
4870
4871 #ifndef MALLOC_CHECK
4872
4873 ptr = alloc_counts[(int)alloc_type_tag].free_list.f_tag;
4874 if (ptr != (tag_t *) NULL)
4875 alloc_counts[(int)alloc_type_tag].free_list.f_tag = ptr->free;
4876 else
4877 {
4878 register int unallocated = alloc_counts[(int)alloc_type_tag].unallocated;
4879 register page_t *cur_page = alloc_counts[(int)alloc_type_tag].cur_page;
4880
4881 if (unallocated == 0)
4882 {
4883 unallocated = PAGE_SIZE / sizeof (tag_t);
4884 alloc_counts[(int)alloc_type_tag].cur_page = cur_page = allocate_page ();
4885 alloc_counts[(int)alloc_type_tag].total_pages++;
4886 }
4887
4888 ptr = &cur_page->tag[--unallocated];
4889 alloc_counts[(int)alloc_type_tag].unallocated = unallocated;
4890 }
4891
4892 #else
4893
4894 ptr = (tag_t *) xmalloc (sizeof (tag_t));
4895
4896 #endif
4897
4898 alloc_counts[(int)alloc_type_tag].total_alloc++;
4899 *ptr = initial_tag;
4900 return ptr;
4901 }
4902
4903 /* Free scoping information. */
4904
4905 static void
4906 free_tag (ptr)
4907 tag_t *ptr;
4908 {
4909 alloc_counts[(int)alloc_type_tag].total_free++;
4910
4911 #ifndef MALLOC_CHECK
4912 ptr->free = alloc_counts[(int)alloc_type_tag].free_list.f_tag;
4913 alloc_counts[(int)alloc_type_tag].free_list.f_tag = ptr;
4914 #else
4915 free ((PTR_T) ptr);
4916 #endif
4917 }
4918 \f
4919 /* Allocate forward reference to a yet unknown tag. */
4920
4921 static forward_t *
4922 allocate_forward ()
4923 {
4924 register forward_t *ptr;
4925 static forward_t initial_forward;
4926
4927 #ifndef MALLOC_CHECK
4928
4929 register int unallocated = alloc_counts[(int)alloc_type_forward].unallocated;
4930 register page_t *cur_page = alloc_counts[(int)alloc_type_forward].cur_page;
4931
4932 if (unallocated == 0)
4933 {
4934 unallocated = PAGE_SIZE / sizeof (forward_t);
4935 alloc_counts[(int)alloc_type_forward].cur_page = cur_page = allocate_page ();
4936 alloc_counts[(int)alloc_type_forward].total_pages++;
4937 }
4938
4939 ptr = &cur_page->forward[--unallocated];
4940 alloc_counts[(int)alloc_type_forward].unallocated = unallocated;
4941
4942 #else
4943
4944 ptr = (forward_t *) xmalloc (sizeof (forward_t));
4945
4946 #endif
4947
4948 alloc_counts[(int)alloc_type_forward].total_alloc++;
4949 *ptr = initial_forward;
4950 return ptr;
4951 }
4952 \f
4953 /* Allocate head of type hash list. */
4954
4955 static thead_t *
4956 allocate_thead ()
4957 {
4958 register thead_t *ptr;
4959 static thead_t initial_thead;
4960
4961 #ifndef MALLOC_CHECK
4962
4963 ptr = alloc_counts[(int)alloc_type_thead].free_list.f_thead;
4964 if (ptr != (thead_t *) NULL)
4965 alloc_counts[ (int)alloc_type_thead ].free_list.f_thead = ptr->free;
4966 else
4967 {
4968 register int unallocated = alloc_counts[(int)alloc_type_thead].unallocated;
4969 register page_t *cur_page = alloc_counts[(int)alloc_type_thead].cur_page;
4970
4971 if (unallocated == 0)
4972 {
4973 unallocated = PAGE_SIZE / sizeof (thead_t);
4974 alloc_counts[(int)alloc_type_thead].cur_page = cur_page = allocate_page ();
4975 alloc_counts[(int)alloc_type_thead].total_pages++;
4976 }
4977
4978 ptr = &cur_page->thead[--unallocated];
4979 alloc_counts[(int)alloc_type_thead].unallocated = unallocated;
4980 }
4981
4982 #else
4983
4984 ptr = (thead_t *) xmalloc (sizeof (thead_t));
4985
4986 #endif
4987
4988 alloc_counts[(int)alloc_type_thead].total_alloc++;
4989 *ptr = initial_thead;
4990 return ptr;
4991 }
4992
4993 /* Free scoping information. */
4994
4995 static void
4996 free_thead (ptr)
4997 thead_t *ptr;
4998 {
4999 alloc_counts[(int)alloc_type_thead].total_free++;
5000
5001 #ifndef MALLOC_CHECK
5002 ptr->free = (thead_t *) alloc_counts[(int)alloc_type_thead].free_list.f_thead;
5003 alloc_counts[(int)alloc_type_thead].free_list.f_thead = ptr;
5004 #else
5005 free ((PTR_T) ptr);
5006 #endif
5007 }
5008 \f
5009 static lineno_list_t *
5010 allocate_lineno_list ()
5011 {
5012 register lineno_list_t *ptr;
5013 static lineno_list_t initial_lineno_list;
5014
5015 #ifndef MALLOC_CHECK
5016
5017 register int unallocated = alloc_counts[(int)alloc_type_lineno].unallocated;
5018 register page_t *cur_page = alloc_counts[(int)alloc_type_lineno].cur_page;
5019
5020 if (unallocated == 0)
5021 {
5022 unallocated = PAGE_SIZE / sizeof (lineno_list_t);
5023 alloc_counts[(int)alloc_type_lineno].cur_page = cur_page = allocate_page ();
5024 alloc_counts[(int)alloc_type_lineno].total_pages++;
5025 }
5026
5027 ptr = &cur_page->lineno[--unallocated];
5028 alloc_counts[(int)alloc_type_lineno].unallocated = unallocated;
5029
5030 #else
5031
5032 ptr = (lineno_list_t *) xmalloc (sizeof (lineno_list_t));
5033
5034 #endif
5035
5036 alloc_counts[(int)alloc_type_lineno].total_alloc++;
5037 *ptr = initial_lineno_list;
5038 return ptr;
5039 }
5040
5041 void
5042 ecoff_set_gp_prolog_size (sz)
5043 int sz;
5044 {
5045 if (cur_proc_ptr == 0)
5046 return;
5047
5048 cur_proc_ptr->pdr.gp_prologue = sz;
5049 if (cur_proc_ptr->pdr.gp_prologue != sz)
5050 {
5051 as_warn ("GP prologue size exceeds field size, using 0 instead");
5052 cur_proc_ptr->pdr.gp_prologue = 0;
5053 }
5054
5055 cur_proc_ptr->pdr.gp_used = 1;
5056 }
5057
5058 static void
5059 generate_ecoff_stab (what, string, type, other, desc)
5060 int what;
5061 const char *string;
5062 int type;
5063 int other;
5064 int desc;
5065 {
5066 efdr_t *save_file_ptr = cur_file_ptr;
5067 symbolS *sym;
5068 symint_t value;
5069 st_t st;
5070 sc_t sc;
5071 symint_t indx;
5072 localsym_t *hold = NULL;
5073
5074 /* We don't handle .stabd. */
5075 if (what != 's' && what != 'n')
5076 {
5077 as_bad (".stab%c is not supported", what);
5078 return;
5079 }
5080
5081 /* We ignore the other field. */
5082 if (other != 0)
5083 as_warn (".stab%c: ignoring non-zero other field", what);
5084
5085 /* Make sure we have a current file. */
5086 if (cur_file_ptr == (efdr_t *) NULL)
5087 {
5088 add_file ((const char *) NULL, 0);
5089 save_file_ptr = cur_file_ptr;
5090 }
5091
5092 /* For stabs in ECOFF, the first symbol must be @stabs. This is a
5093 signal to gdb. */
5094 if (stabs_seen == 0)
5095 mark_stabs (0);
5096
5097 /* Line number stabs are handled differently, since they have two
5098 values, the line number and the address of the label. We use the
5099 index field (aka desc) to hold the line number, and the value
5100 field to hold the address. The symbol type is st_Label, which
5101 should be different from the other stabs, so that gdb can
5102 recognize it. */
5103 if (type == N_SLINE)
5104 {
5105 SYMR dummy_symr;
5106
5107 #ifndef NO_LISTING
5108 if (listing)
5109 listing_source_line ((unsigned int) desc);
5110 #endif
5111
5112 dummy_symr.index = desc;
5113 if (dummy_symr.index != desc)
5114 {
5115 as_warn ("Line number (%d) for .stab%c directive cannot fit in index field (20 bits)",
5116 desc, what);
5117 return;
5118 }
5119
5120 sym = symbol_find_or_make ((char *)string);
5121 value = 0;
5122 st = st_Label;
5123 sc = sc_Text;
5124 indx = desc;
5125 }
5126 else
5127 {
5128 #ifndef NO_LISTING
5129 if (listing && (type == N_SO || type == N_SOL))
5130 listing_source_file (string);
5131 #endif
5132
5133 sym = symbol_find_or_make ((char *)string);
5134 sc = sc_Nil;
5135 st = st_Nil;
5136 value = 0;
5137 indx = ECOFF_MARK_STAB (type);
5138 }
5139
5140 /* Don't store the stabs symbol we are creating as the type of the
5141 ECOFF symbol. We want to compute the type of the ECOFF symbol
5142 independently. */
5143 if (sym != (symbolS *) NULL)
5144 hold = sym->ecoff_symbol;
5145
5146 (void) add_ecoff_symbol (string, st, sc, sym, value, indx);
5147
5148 if (sym != (symbolS *) NULL)
5149 sym->ecoff_symbol = hold;
5150
5151 /* Restore normal file type. */
5152 cur_file_ptr = save_file_ptr;
5153 }
5154
5155 int
5156 ecoff_no_current_file ()
5157 {
5158 return cur_file_ptr == (efdr_t *) NULL;
5159 }
5160
5161 void
5162 ecoff_generate_asm_lineno (filename, lineno)
5163 const char *filename;
5164 int lineno;
5165 {
5166 lineno_list_t *list;
5167
5168 /* this potential can cause problem, when we start to see stab half the
5169 way thru the file */
5170 /*
5171 if (stabs_seen)
5172 ecoff_generate_asm_line_stab(filename, lineno);
5173 */
5174
5175 if (current_stabs_filename == (char *)NULL || strcmp (current_stabs_filename, filename))
5176 {
5177 add_file (filename, 0);
5178 generate_asm_lineno = 1;
5179 }
5180
5181 list = allocate_lineno_list ();
5182
5183 list->next = (lineno_list_t *) NULL;
5184 list->file = cur_file_ptr;
5185 list->proc = cur_proc_ptr;
5186 list->frag = frag_now;
5187 list->paddr = frag_now_fix ();
5188 list->lineno = lineno;
5189
5190 /* A .loc directive will sometimes appear before a .ent directive,
5191 which means that cur_proc_ptr will be NULL here. Arrange to
5192 patch this up. */
5193 if (cur_proc_ptr == (proc_t *) NULL)
5194 {
5195 lineno_list_t **pl;
5196
5197 pl = &noproc_lineno;
5198 while (*pl != (lineno_list_t *) NULL)
5199 pl = &(*pl)->next;
5200 *pl = list;
5201 }
5202 else
5203 {
5204 *last_lineno_ptr = list;
5205 last_lineno_ptr = &list->next;
5206 }
5207 }
5208
5209 static int line_label_cnt = 0;
5210 void
5211 ecoff_generate_asm_line_stab (filename, lineno)
5212 char *filename;
5213 int lineno;
5214 {
5215 char *ll;
5216
5217 if (strcmp (current_stabs_filename, filename))
5218 {
5219 add_file (filename, 0);
5220 generate_asm_lineno = 1;
5221 }
5222
5223 line_label_cnt++;
5224 /* generate local label $LMnn */
5225 ll = xmalloc(10);
5226 sprintf(ll, "$LM%d", line_label_cnt);
5227 colon (ll);
5228
5229 /* generate stab for the line */
5230 generate_ecoff_stab ('n', ll, N_SLINE, 0, lineno);
5231
5232 }
5233
5234 #endif /* ECOFF_DEBUGGING */
GDB Binutils - Deliverables
This page took 0.191462 seconds and 4 git commands to generate.