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