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