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