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