source: trunk/src/binutils/gas/ecoff.c@ 289

Last change on this file since 289 was 10, checked in by bird, 23 years ago

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