1 /* ECOFF debugging support.
2 Copyright (C) 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
3 Contributed by Cygnus Support.
4 This file was put together by Ian Lance Taylor <ian@cygnus.com>. A
5 good deal of it comes directly from mips-tfile.c, by Michael
6 Meissner <meissner@osf.org>.
8 This file is part of GAS.
10 GAS is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2, or (at your option)
15 GAS is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GAS; see the file COPYING. If not, write to the Free
22 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
27 /* This file is compiled conditionally for those targets which use
28 ECOFF debugging information (e.g., MIPS ECOFF, MIPS ELF, Alpha
31 #ifdef ECOFF_DEBUGGING
33 #include "coff/internal.h"
34 #include "coff/symconst.h"
36 #include "aout/stab_gnu.h"
40 /* Why isn't this in coff/sym.h? */
41 #define ST_RFDESCAPE 0xfff
43 /* This file constructs the information used by the ECOFF debugging
44 format. It just builds a large block of data.
46 We support both ECOFF style debugging and stabs debugging (the
47 stabs symbols are encapsulated in ECOFF symbols). This should let
48 us handle anything the compiler might throw at us. */
50 /* Here is a brief description of the MIPS ECOFF symbol table, by
51 Michael Meissner. The MIPS symbol table has the following pieces:
57 +-- Dense number table
65 +-- Relative file descriptors
77 The symbolic header points to each of the other tables, and also
78 contains the number of entries. It also contains a magic number
79 and MIPS compiler version number, such as 2.0.
81 The auxiliary table is a series of 32 bit integers, that are
82 referenced as needed from the local symbol table. Unlike standard
83 COFF, the aux. information does not follow the symbol that uses
84 it, but rather is a separate table. In theory, this would allow
85 the MIPS compilers to collapse duplicate aux. entries, but I've not
86 noticed this happening with the 1.31 compiler suite. The different
87 types of aux. entries are:
89 1) dnLow: Low bound on array dimension.
91 2) dnHigh: High bound on array dimension.
93 3) isym: Index to the local symbol which is the start of the
94 function for the end of function first aux. entry.
96 4) width: Width of structures and bitfields.
98 5) count: Count of ranges for variant part.
100 6) rndx: A relative index into the symbol table. The relative
101 index field has two parts: rfd which is a pointer into the
102 relative file index table or ST_RFDESCAPE which says the next
103 aux. entry is the file number, and index: which is the pointer
104 into the local symbol within a given file table. This is for
105 things like references to types defined in another file.
107 7) Type information: This is like the COFF type bits, except it
108 is 32 bits instead of 16; they still have room to add new
109 basic types; and they can handle more than 6 levels of array,
110 pointer, function, etc. Each type information field contains
111 the following structure members:
113 a) fBitfield: a bit that says this is a bitfield, and the
114 size in bits follows as the next aux. entry.
116 b) continued: a bit that says the next aux. entry is a
117 continuation of the current type information (in case
118 there are more than 6 levels of array/ptr/function).
120 c) bt: an integer containing the base type before adding
121 array, pointer, function, etc. qualifiers. The
122 current base types that I have documentation for are:
125 btAdr -- address - integer same size as ptr
127 btUChar -- unsigned character
129 btUShort -- unsigned short
131 btUInt -- unsigned int
133 btULong -- unsigned long
134 btFloat -- float (real)
135 btDouble -- Double (real)
136 btStruct -- Structure (Record)
137 btUnion -- Union (variant)
139 btTypedef -- defined via a typedef isymRef
140 btRange -- subrange of int
142 btComplex -- fortran complex
143 btDComplex -- fortran double complex
144 btIndirect -- forward or unnamed typedef
145 btFixedDec -- Fixed Decimal
146 btFloatDec -- Float Decimal
147 btString -- Varying Length Character String
148 btBit -- Aligned Bit String
150 btVoid -- Void (MIPS cc revision >= 2.00)
152 d) tq0 - tq5: type qualifier fields as needed. The
153 current type qualifier fields I have documentation for
156 tqNil -- no more qualifiers
160 tqFar -- 8086 far pointers
164 The dense number table is used in the front ends, and disappears by
165 the time the .o is created.
167 With the 1.31 compiler suite, the optimization symbols don't seem
168 to be used as far as I can tell.
170 The linker is the first entity that creates the relative file
171 descriptor table, and I believe it is used so that the individual
172 file table pointers don't have to be rewritten when the objects are
173 merged together into the program file.
175 Unlike COFF, the basic symbol & string tables are split into
176 external and local symbols/strings. The relocation information
177 only goes off of the external symbol table, and the debug
178 information only goes off of the internal symbol table. The
179 external symbols can have links to an appropriate file index and
180 symbol within the file to give it the appropriate type information.
181 Because of this, the external symbols are actually larger than the
182 internal symbols (to contain the link information), and contain the
183 local symbol structure as a member, though this member is not the
184 first member of the external symbol structure (!). I suspect this
185 split is to make strip easier to deal with.
187 Each file table has offsets for where the line numbers, local
188 strings, local symbols, and procedure table starts from within the
189 global tables, and the indexs are reset to 0 for each of those
192 The procedure table contains the binary equivalents of the .ent
193 (start of the function address), .frame (what register is the
194 virtual frame pointer, constant offset from the register to obtain
195 the VFP, and what register holds the return address), .mask/.fmask
196 (bitmask of saved registers, and where the first register is stored
197 relative to the VFP) assembler directives. It also contains the
198 low and high bounds of the line numbers if debugging is turned on.
200 The line number table is a compressed form of the normal COFF line
201 table. Each line number entry is either 1 or 3 bytes long, and
202 contains a signed delta from the previous line, and an unsigned
203 count of the number of instructions this statement takes.
205 The local symbol table contains the following fields:
207 1) iss: index to the local string table giving the name of the
210 2) value: value of the symbol (address, register number, etc.).
212 3) st: symbol type. The current symbol types are:
214 stNil -- Nuthin' special
215 stGlobal -- external symbol
217 stParam -- procedure argument
218 stLocal -- local variable
220 stProc -- External Procedure
221 stBlock -- beginning of block
222 stEnd -- end (of anything)
223 stMember -- member (of anything)
224 stTypedef -- type definition
226 stRegReloc -- register relocation
227 stForward -- forwarding address
228 stStaticProc -- Static procedure
231 4) sc: storage class. The current storage classes are:
233 scText -- text symbol
234 scData -- initialized data symbol
235 scBss -- un-initialized data symbol
236 scRegister -- value of symbol is register number
237 scAbs -- value of symbol is absolute
238 scUndefined -- who knows?
239 scCdbLocal -- variable's value is IN se->va.??
240 scBits -- this is a bit field
241 scCdbSystem -- value is IN debugger's address space
242 scRegImage -- register value saved on stack
243 scInfo -- symbol contains debugger information
244 scUserStruct -- addr in struct user for current process
245 scSData -- load time only small data
246 scSBss -- load time only small common
247 scRData -- load time only read only data
248 scVar -- Var parameter (fortranpascal)
249 scCommon -- common variable
250 scSCommon -- small common
251 scVarRegister -- Var parameter in a register
252 scVariant -- Variant record
253 scSUndefined -- small undefined(external) data
254 scInit -- .init section symbol
256 5) index: pointer to a local symbol or aux. entry.
260 For the following program:
265 printf("Hello World!\n");
269 Mips-tdump produces the following information:
274 timestamp 645311799, Wed Jun 13 17:16:39 1990
275 symbolic header offset 284
276 symbolic header size 96
280 Symbolic header, magic number = 0x7009, vstamp = 1.31:
282 Info Offset Number Bytes
283 ==== ====== ====== =====
285 Line numbers 380 4 4 [13]
287 Procedures Tables 384 1 52
288 Local Symbols 436 16 192
289 Optimization Symbols 0 0 0
290 Auxiliary Symbols 628 39 156
291 Local Strings 784 80 80
292 External Strings 864 144 144
293 File Tables 1008 2 144
295 External Symbols 1152 20 320
299 Name index = 1 Readin = No
300 Merge = No Endian = LITTLE
301 Debug level = G2 Language = C
304 Info Start Number Size Offset
305 ==== ===== ====== ==== ======
306 Local strings 0 15 15 784
307 Local symbols 0 6 72 436
308 Line numbers 0 13 13 380
309 Optimization symbols 0 0 0 0
310 Procedures 0 1 52 384
311 Auxiliary symbols 0 14 56 628
312 Relative Files 0 0 0 0
314 There are 6 local symbols, starting at 436
316 Symbol# 0: "hello2.c"
319 Storage class = Text Index = 6
320 Symbol type = File Value = 0
326 Storage class = Text Index = 12
327 Symbol type = Proc Value = 0
332 Storage class = Text Index = 4
333 Symbol type = Block Value = 8
338 Storage class = Text Index = 2
339 Symbol type = End Value = 28
344 Storage class = Text Index = 1
345 Symbol type = End Value = 52
347 Symbol# 5: "hello2.c"
350 Storage class = Text Index = 0
351 Symbol type = End Value = 0
353 There are 14 auxiliary table entries, starting at 628.
355 * #0 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
356 * #1 24, [ 24/ 0], [ 6 0:0 0:0:0:0:0:0]
357 * #2 8, [ 8/ 0], [ 2 0:0 0:0:0:0:0:0]
358 * #3 16, [ 16/ 0], [ 4 0:0 0:0:0:0:0:0]
359 * #4 24, [ 24/ 0], [ 6 0:0 0:0:0:0:0:0]
360 * #5 32, [ 32/ 0], [ 8 0:0 0:0:0:0:0:0]
361 * #6 40, [ 40/ 0], [10 0:0 0:0:0:0:0:0]
362 * #7 44, [ 44/ 0], [11 0:0 0:0:0:0:0:0]
363 * #8 12, [ 12/ 0], [ 3 0:0 0:0:0:0:0:0]
364 * #9 20, [ 20/ 0], [ 5 0:0 0:0:0:0:0:0]
365 * #10 28, [ 28/ 0], [ 7 0:0 0:0:0:0:0:0]
366 * #11 36, [ 36/ 0], [ 9 0:0 0:0:0:0:0:0]
367 #12 5, [ 5/ 0], [ 1 1:0 0:0:0:0:0:0]
368 #13 24, [ 24/ 0], [ 6 0:0 0:0:0:0:0:0]
370 There are 1 procedure descriptor entries, starting at 0.
372 Procedure descriptor 0:
373 Name index = 10 Name = "main"
374 .mask 0x80000000,-4 .fmask 0x00000000,0
376 Opt. start = -1 Symbols start = 1
377 First line # = 3 Last line # = 6
378 Line Offset = 0 Address = 0x00000000
380 There are 4 bytes holding line numbers, starting at 380.
381 Line 3, delta 0, count 2
382 Line 4, delta 1, count 3
383 Line 5, delta 1, count 2
384 Line 6, delta 1, count 6
386 File #1, "/usr/include/stdio.h"
388 Name index = 1 Readin = No
389 Merge = Yes Endian = LITTLE
390 Debug level = G2 Language = C
393 Info Start Number Size Offset
394 ==== ===== ====== ==== ======
395 Local strings 15 65 65 799
396 Local symbols 6 10 120 508
397 Line numbers 0 0 0 380
398 Optimization symbols 0 0 0 0
400 Auxiliary symbols 14 25 100 684
401 Relative Files 0 0 0 0
403 There are 10 local symbols, starting at 442
405 Symbol# 0: "/usr/include/stdio.h"
408 Storage class = Text Index = 10
409 Symbol type = File Value = 0
414 Storage class = Info Index = 9
415 Symbol type = Block Value = 20
420 Storage class = Info Index = 4
421 Symbol type = Member Value = 0
426 Storage class = Info Index = 15
427 Symbol type = Member Value = 32
432 Storage class = Info Index = 16
433 Symbol type = Member Value = 64
438 Storage class = Info Index = 4
439 Symbol type = Member Value = 96
444 Storage class = Info Index = 3
445 Symbol type = Member Value = 128
450 Storage class = Info Index = 2
451 Symbol type = Member Value = 144
456 Storage class = Info Index = 1
457 Symbol type = End Value = 0
459 Symbol# 9: "/usr/include/stdio.h"
462 Storage class = Text Index = 0
463 Symbol type = End Value = 0
465 There are 25 auxiliary table entries, starting at 642.
467 * #14 -1, [4095/1048575], [63 1:1 f:f:f:f:f:f]
468 #15 65544, [ 8/ 16], [ 2 0:0 1:0:0:0:0:0]
469 #16 65544, [ 8/ 16], [ 2 0:0 1:0:0:0:0:0]
470 * #17 196656, [ 48/ 48], [12 0:0 3:0:0:0:0:0]
471 * #18 8191, [4095/ 1], [63 1:1 0:0:0:0:f:1]
472 * #19 1, [ 1/ 0], [ 0 1:0 0:0:0:0:0:0]
473 * #20 20479, [4095/ 4], [63 1:1 0:0:0:0:f:4]
474 * #21 1, [ 1/ 0], [ 0 1:0 0:0:0:0:0:0]
475 * #22 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
476 * #23 2, [ 2/ 0], [ 0 0:1 0:0:0:0:0:0]
477 * #24 160, [ 160/ 0], [40 0:0 0:0:0:0:0:0]
478 * #25 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
479 * #26 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
480 * #27 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
481 * #28 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
482 * #29 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
483 * #30 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
484 * #31 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
485 * #32 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
486 * #33 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
487 * #34 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
488 * #35 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
489 * #36 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
490 * #37 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
491 * #38 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
493 There are 0 procedure descriptor entries, starting at 1.
495 There are 20 external symbols, starting at 1152
498 Type = array [3 {160}] of struct _iobuf { ifd = 1, index = 1 }
499 String index = 0 Ifd = 1
500 Storage class = Nil Index = 17
501 Symbol type = Global Value = 60
504 String index = 5 Ifd = 1
505 Storage class = Nil Index = 1048575
506 Symbol type = Proc Value = 0
509 String index = 11 Ifd = 1
510 Storage class = Nil Index = 1048575
511 Symbol type = Proc Value = 0
514 String index = 18 Ifd = 1
515 Storage class = Nil Index = 1048575
516 Symbol type = Proc Value = 0
519 String index = 26 Ifd = 1
520 Storage class = Nil Index = 1048575
521 Symbol type = Proc Value = 0
524 String index = 32 Ifd = 1
525 Storage class = Nil Index = 1048575
526 Symbol type = Proc Value = 0
529 String index = 40 Ifd = 1
530 Storage class = Nil Index = 1048575
531 Symbol type = Proc Value = 0
534 String index = 46 Ifd = 1
535 Storage class = Nil Index = 1048575
536 Symbol type = Proc Value = 0
539 String index = 53 Ifd = 1
540 Storage class = Nil Index = 1048575
541 Symbol type = Proc Value = 0
543 Symbol# 9: "setbuffer"
544 String index = 60 Ifd = 1
545 Storage class = Nil Index = 1048575
546 Symbol type = Proc Value = 0
548 Symbol# 10: "setlinebuf"
549 String index = 70 Ifd = 1
550 Storage class = Nil Index = 1048575
551 Symbol type = Proc Value = 0
554 String index = 81 Ifd = 1
555 Storage class = Nil Index = 1048575
556 Symbol type = Proc Value = 0
559 String index = 87 Ifd = 1
560 Storage class = Nil Index = 1048575
561 Symbol type = Proc Value = 0
563 Symbol# 13: "ctermid"
564 String index = 92 Ifd = 1
565 Storage class = Nil Index = 1048575
566 Symbol type = Proc Value = 0
568 Symbol# 14: "cuserid"
569 String index = 100 Ifd = 1
570 Storage class = Nil Index = 1048575
571 Symbol type = Proc Value = 0
573 Symbol# 15: "tempnam"
574 String index = 108 Ifd = 1
575 Storage class = Nil Index = 1048575
576 Symbol type = Proc Value = 0
579 String index = 116 Ifd = 1
580 Storage class = Nil Index = 1048575
581 Symbol type = Proc Value = 0
583 Symbol# 17: "sprintf"
584 String index = 123 Ifd = 1
585 Storage class = Nil Index = 1048575
586 Symbol type = Proc Value = 0
590 String index = 131 Ifd = 0
591 Storage class = Text Index = 1
592 Symbol type = Proc Value = 0
595 String index = 136 Ifd = 0
596 Storage class = Undefined Index = 1048575
597 Symbol type = Proc Value = 0
599 The following auxiliary table entries were unused:
603 #3 16 0x00000010 short
605 #5 32 0x00000020 long
606 #6 40 0x00000028 float
607 #7 44 0x0000002c double
608 #8 12 0x0000000c unsigned char
609 #9 20 0x00000014 unsigned short
610 #10 28 0x0000001c unsigned int
611 #11 36 0x00000024 unsigned long
612 #14 0 0x00000000 void
613 #15 24 0x00000018 int
614 #19 32 0x00000020 long
615 #20 40 0x00000028 float
616 #21 44 0x0000002c double
617 #22 12 0x0000000c unsigned char
618 #23 20 0x00000014 unsigned short
619 #24 28 0x0000001c unsigned int
620 #25 36 0x00000024 unsigned long
621 #26 48 0x00000030 struct no name { ifd = -1, index = 1048575 }
624 /* Redefinition of of storage classes as an enumeration for better
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 */
654 /* Redefinition of symbol type. */
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 */
680 /* Redefinition of type qualifiers. */
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 */
692 /* Redefinition of basic types. */
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 */
727 /* States for whether to hash type or not. */
728 typedef 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. */
734 /* Types of different sized allocation requests. */
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 */
749 /* Types of auxiliary type information. */
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 */
761 /* Structures to provide n-number of virtual arrays, each of which can
762 grow linearly, and which are written in the object file as
763 sequential pages. On systems with a BSD malloc, the
764 MAX_CLUSTER_PAGES should be 1 less than a power of two, since
765 malloc adds it's overhead, and rounds up to the next power of 2.
766 Pages are linked together via a linked list.
768 If PAGE_SIZE is > 4096, the string length in the shash_t structure
769 can't be represented (assuming there are strings > 4096 bytes). */
772 #define PAGE_SIZE 4096 /* size of varray pages */
775 #define PAGE_USIZE ((unsigned long) PAGE_SIZE)
778 #ifndef MAX_CLUSTER_PAGES /* # pages to get from system */
779 #define MAX_CLUSTER_PAGES 63
782 /* Linked list connecting separate page allocations. */
783 typedef struct vlinks
{
784 struct vlinks
*prev
; /* previous set of pages */
785 struct vlinks
*next
; /* next set of pages */
786 union page
*datum
; /* start of page */
787 unsigned long start_index
; /* starting index # of page */
791 /* Virtual array header. */
792 typedef struct varray
{
793 vlinks_t
*first
; /* first page link */
794 vlinks_t
*last
; /* last page link */
795 unsigned long num_allocated
; /* # objects allocated */
796 unsigned short object_size
; /* size in bytes of each object */
797 unsigned short objects_per_page
; /* # objects that can fit on a page */
798 unsigned short objects_last_page
; /* # objects allocated on last page */
802 #define OBJECTS_PER_PAGE(type) (PAGE_SIZE / sizeof (type))
804 #define OBJECTS_PER_PAGE(type) ((sizeof (type) > 1) ? 1 : PAGE_SIZE)
807 #define INIT_VARRAY(type) { /* macro to initialize a varray */ \
808 (vlinks_t *)0, /* first */ \
809 (vlinks_t *)0, /* last */ \
810 0, /* num_allocated */ \
811 sizeof (type), /* object_size */ \
812 OBJECTS_PER_PAGE (type), /* objects_per_page */ \
813 OBJECTS_PER_PAGE (type), /* objects_last_page */ \
817 /* Master type for indexes within the symbol table. */
818 typedef unsigned long symint_t
;
821 /* Linked list support for nested scopes (file, block, structure, etc.). */
822 typedef struct scope
{
823 struct scope
*prev
; /* previous scope level */
824 struct scope
*free
; /* free list pointer */
825 struct localsym
*lsym
; /* pointer to local symbol node */
826 st_t type
; /* type of the node */
830 /* For a local symbol we store a gas symbol as well as the debugging
831 information we generate. The gas symbol will be NULL if this is
832 only a debugging symbol. */
833 typedef struct localsym
{
834 const char *name
; /* symbol name */
835 symbolS
*as_sym
; /* symbol as seen by gas */
836 bfd_vma addend
; /* addend to as_sym value */
837 struct efdr
*file_ptr
; /* file pointer */
838 struct ecoff_proc
*proc_ptr
; /* proc pointer */
839 struct localsym
*begin_ptr
; /* symbol at start of block */
840 struct ecoff_aux
*index_ptr
; /* index value to be filled in */
841 struct forward
*forward_ref
; /* forward references to this symbol */
842 long sym_index
; /* final symbol index */
843 EXTR ecoff_sym
; /* ECOFF debugging symbol */
847 /* For aux information we keep the type and the data. */
848 typedef struct ecoff_aux
{
849 enum aux_type type
; /* aux type */
850 AUXU data
; /* aux data */
853 /* For a procedure we store the gas symbol as well as the PDR
854 debugging information. */
855 typedef struct ecoff_proc
{
856 localsym_t
*sym
; /* associated symbol */
857 PDR pdr
; /* ECOFF debugging info */
860 /* Number of proc_t structures allocated. */
861 static unsigned long proc_cnt
;
864 /* Forward reference list for tags referenced, but not yet defined. */
865 typedef struct forward
{
866 struct forward
*next
; /* next forward reference */
867 struct forward
*free
; /* free list pointer */
868 aux_t
*ifd_ptr
; /* pointer to store file index */
869 aux_t
*index_ptr
; /* pointer to store symbol index */
873 /* Linked list support for tags. The first tag in the list is always
874 the current tag for that block. */
876 struct tag
*free
; /* free list pointer */
877 struct shash
*hash_ptr
; /* pointer to the hash table head */
878 struct tag
*same_name
; /* tag with same name in outer scope */
879 struct tag
*same_block
; /* next tag defined in the same block. */
880 struct forward
*forward_ref
; /* list of forward references */
881 bt_t basic_type
; /* bt_Struct, bt_Union, or bt_Enum */
882 symint_t ifd
; /* file # tag defined in */
883 localsym_t
*sym
; /* file's local symbols */
887 /* Head of a block's linked list of tags. */
888 typedef struct thead
{
889 struct thead
*prev
; /* previous block */
890 struct thead
*free
; /* free list pointer */
891 struct tag
*first_tag
; /* first tag in block defined */
895 /* Union containing pointers to each the small structures which are freed up. */
896 typedef union small_free
{
897 scope_t
*f_scope
; /* scope structure */
898 thead_t
*f_thead
; /* tag head structure */
899 tag_t
*f_tag
; /* tag element structure */
900 forward_t
*f_forward
; /* forward tag reference */
904 /* String hash table entry. */
906 typedef struct shash
{
907 char *string
; /* string we are hashing */
908 symint_t indx
; /* index within string table */
909 EXTR
*esym_ptr
; /* global symbol pointer */
910 localsym_t
*sym_ptr
; /* local symbol pointer */
911 localsym_t
*end_ptr
; /* symbol pointer to end block */
912 tag_t
*tag_ptr
; /* tag pointer */
913 proc_t
*proc_ptr
; /* procedure descriptor pointer */
917 /* Type hash table support. The size of the hash table must fit
918 within a page with the other extended file descriptor information.
919 Because unique types which are hashed are fewer in number than
920 strings, we use a smaller hash value. */
925 #define THASH_SIZE 113
928 typedef struct thash
{
929 struct thash
*next
; /* next hash value */
930 AUXU type
; /* type we are hashing */
931 symint_t indx
; /* index within string table */
935 /* Extended file descriptor that contains all of the support necessary
936 to add things to each file separately. */
937 typedef 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
];
957 /* Pre-initialized extended file structure. */
958 static const efdr_t init_file
=
960 { /* FDR structure */
961 0, /* adr: memory address of beginning of file */
962 0, /* rss: file name (of source, if known) */
963 0, /* issBase: file's string space */
964 0, /* cbSs: number of bytes in the ss */
965 0, /* isymBase: beginning of symbols */
966 0, /* csym: count file's of symbols */
967 0, /* ilineBase: file's line symbols */
968 0, /* cline: count of file's line symbols */
969 0, /* ioptBase: file's optimization entries */
970 0, /* copt: count of file's optimization entries */
971 0, /* ipdFirst: start of procedures for this file */
972 0, /* cpd: count of procedures for this file */
973 0, /* iauxBase: file's auxiliary entries */
974 0, /* caux: count of file's auxiliary entries */
975 0, /* rfdBase: index into the file indirect table */
976 0, /* crfd: count file indirect entries */
977 langC
, /* lang: language for this file */
978 0, /* fMerge: whether this file can be merged */
979 0, /* fReadin: true if read in (not just created) */
980 #ifdef TARGET_BYTES_BIG_ENDIAN
981 1, /* fBigendian: if 1, compiled on big endian machine */
983 0, /* fBigendian: if 1, compiled on big endian machine */
985 GLEVEL_2
, /* glevel: level this file was compiled with */
986 0, /* reserved: reserved for future use */
987 0, /* cbLineOffset: byte offset from header for this file ln's */
988 0, /* cbLine: size of lines for this file */
991 (FDR
*)0, /* orig_fdr: original file header pointer */
992 (char *)0, /* name: pointer to filename */
993 0, /* fake: whether this is a faked .file */
994 0, /* void_type: ptr to aux node for void type */
995 0, /* int_type: ptr to aux node for int type */
996 (scope_t
*)0, /* cur_scope: current scope being processed */
997 0, /* file_index: current file # */
998 0, /* nested_scopes: # nested scopes */
999 INIT_VARRAY (char), /* strings: local string varray */
1000 INIT_VARRAY (localsym_t
), /* symbols: local symbols varray */
1001 INIT_VARRAY (proc_t
), /* procs: procedure varray */
1002 INIT_VARRAY (aux_t
), /* aux_syms: auxiliary symbols varray */
1004 (struct efdr
*)0, /* next_file: next file structure */
1006 (struct hash_control
*)0, /* str_hash: string hash table */
1007 { 0 }, /* thash_head: type hash table */
1011 static efdr_t
*first_file
; /* first file descriptor */
1012 static efdr_t
**last_file_ptr
= &first_file
; /* file descriptor tail */
1015 /* Line number information is kept in a list until the assembly is
1017 typedef struct lineno_list
{
1018 struct lineno_list
*next
; /* next element in list */
1019 efdr_t
*file
; /* file this line is in */
1020 proc_t
*proc
; /* procedure this line is in */
1021 fragS
*frag
; /* fragment this line number is in */
1022 unsigned long paddr
; /* offset within fragment */
1023 long lineno
; /* actual line number */
1026 static lineno_list_t
*first_lineno
;
1027 static lineno_list_t
**last_lineno_ptr
= &first_lineno
;
1029 /* Sometimes there will be some .loc statements before a .ent. We
1030 keep them in this list so that we can fill in the procedure pointer
1031 after we see the .ent. */
1032 static lineno_list_t
*noproc_lineno
;
1034 /* Union of various things that are held in pages. */
1035 typedef union page
{
1036 char byte
[ PAGE_SIZE
];
1037 unsigned char ubyte
[ PAGE_SIZE
];
1038 efdr_t file
[ PAGE_SIZE
/ sizeof (efdr_t
) ];
1039 FDR ofile
[ PAGE_SIZE
/ sizeof (FDR
) ];
1040 proc_t proc
[ PAGE_SIZE
/ sizeof (proc_t
) ];
1041 localsym_t sym
[ PAGE_SIZE
/ sizeof (localsym_t
) ];
1042 aux_t aux
[ PAGE_SIZE
/ sizeof (aux_t
) ];
1043 DNR dense
[ PAGE_SIZE
/ sizeof (DNR
) ];
1044 scope_t scope
[ PAGE_SIZE
/ sizeof (scope_t
) ];
1045 vlinks_t vlinks
[ PAGE_SIZE
/ sizeof (vlinks_t
) ];
1046 shash_t shash
[ PAGE_SIZE
/ sizeof (shash_t
) ];
1047 thash_t thash
[ PAGE_SIZE
/ sizeof (thash_t
) ];
1048 tag_t tag
[ PAGE_SIZE
/ sizeof (tag_t
) ];
1049 forward_t forward
[ PAGE_SIZE
/ sizeof (forward_t
) ];
1050 thead_t thead
[ PAGE_SIZE
/ sizeof (thead_t
) ];
1051 lineno_list_t lineno
[ PAGE_SIZE
/ sizeof (lineno_list_t
) ];
1055 /* Structure holding allocation information for small sized structures. */
1056 typedef struct alloc_info
{
1057 char *alloc_name
; /* name of this allocation type (must be first) */
1058 page_t
*cur_page
; /* current page being allocated from */
1059 small_free_t free_list
; /* current free list if any */
1060 int unallocated
; /* number of elements unallocated on page */
1061 int total_alloc
; /* total number of allocations */
1062 int total_free
; /* total number of frees */
1063 int total_pages
; /* total number of pages allocated */
1067 /* Type information collected together. */
1068 typedef struct type_info
{
1069 bt_t basic_type
; /* basic type */
1070 int orig_type
; /* original COFF-based type */
1071 int num_tq
; /* # type qualifiers */
1072 int num_dims
; /* # dimensions */
1073 int num_sizes
; /* # sizes */
1074 int extra_sizes
; /* # extra sizes not tied with dims */
1075 tag_t
* tag_ptr
; /* tag pointer */
1076 int bitfield
; /* symbol is a bitfield */
1077 tq_t type_qualifiers
[N_TQ
]; /* type qualifiers (ptr, func, array)*/
1078 symint_t dimensions
[N_TQ
]; /* dimensions for each array */
1079 symint_t sizes
[N_TQ
+2]; /* sizes of each array slice + size of
1080 struct/union/enum + bitfield size */
1083 /* Pre-initialized type_info struct. */
1084 static const type_info_t type_info_init
= {
1085 bt_Nil
, /* basic type */
1086 T_NULL
, /* original COFF-based type */
1087 0, /* # type qualifiers */
1088 0, /* # dimensions */
1090 0, /* sizes not tied with dims */
1091 NULL
, /* ptr to tag */
1093 { /* type qualifiers */
1121 /* Global hash table for the tags table and global table for file
1124 static varray_t file_desc
= INIT_VARRAY (efdr_t
);
1126 static struct hash_control
*tag_hash
;
1128 /* Static types for int and void. Also, remember the last function's
1129 type (which is set up when we encounter the declaration for the
1130 function, and used when the end block for the function is emitted. */
1132 static type_info_t int_type_info
;
1133 static type_info_t void_type_info
;
1134 static type_info_t last_func_type_info
;
1135 static symbolS
*last_func_sym_value
;
1138 /* Convert COFF basic type to ECOFF basic type. The T_NULL type
1139 really should use bt_Void, but this causes the current ecoff GDB to
1140 issue unsupported type messages, and the Ultrix 4.00 dbx (aka MIPS
1141 2.0) doesn't understand it, even though the compiler generates it.
1142 Maybe this will be fixed in 2.10 or 2.20 of the MIPS compiler
1143 suite, but for now go with what works.
1145 It would make sense for the .type and .scl directives to use the
1146 ECOFF numbers directly, rather than using the COFF numbers and
1147 mapping them. Unfortunately, this is historically what mips-tfile
1148 expects, and changing gcc now would be a considerable pain (the
1149 native compiler generates debugging information internally, rather
1150 than via the assembler, so it will never use .type or .scl). */
1152 static const bt_t map_coff_types
[] = {
1153 bt_Nil
, /* T_NULL */
1155 bt_Char
, /* T_CHAR */
1156 bt_Short
, /* T_SHORT */
1158 bt_Long
, /* T_LONG */
1159 bt_Float
, /* T_FLOAT */
1160 bt_Double
, /* T_DOUBLE */
1161 bt_Struct
, /* T_STRUCT */
1162 bt_Union
, /* T_UNION */
1163 bt_Enum
, /* T_ENUM */
1164 bt_Enum
, /* T_MOE */
1165 bt_UChar
, /* T_UCHAR */
1166 bt_UShort
, /* T_USHORT */
1167 bt_UInt
, /* T_UINT */
1168 bt_ULong
/* T_ULONG */
1171 /* Convert COFF storage class to ECOFF storage class. */
1172 static const sc_t map_coff_storage
[] = {
1173 sc_Nil
, /* 0: C_NULL */
1174 sc_Abs
, /* 1: C_AUTO auto var */
1175 sc_Undefined
, /* 2: C_EXT external */
1176 sc_Data
, /* 3: C_STAT static */
1177 sc_Register
, /* 4: C_REG register */
1178 sc_Undefined
, /* 5: C_EXTDEF ??? */
1179 sc_Text
, /* 6: C_LABEL label */
1180 sc_Text
, /* 7: C_ULABEL user label */
1181 sc_Info
, /* 8: C_MOS member of struct */
1182 sc_Abs
, /* 9: C_ARG argument */
1183 sc_Info
, /* 10: C_STRTAG struct tag */
1184 sc_Info
, /* 11: C_MOU member of union */
1185 sc_Info
, /* 12: C_UNTAG union tag */
1186 sc_Info
, /* 13: C_TPDEF typedef */
1187 sc_Data
, /* 14: C_USTATIC ??? */
1188 sc_Info
, /* 15: C_ENTAG enum tag */
1189 sc_Info
, /* 16: C_MOE member of enum */
1190 sc_Register
, /* 17: C_REGPARM register parameter */
1191 sc_Bits
, /* 18; C_FIELD bitfield */
1273 sc_Text
, /* 100: C_BLOCK block start/end */
1274 sc_Text
, /* 101: C_FCN function start/end */
1275 sc_Info
, /* 102: C_EOS end of struct/union/enum */
1276 sc_Nil
, /* 103: C_FILE file start */
1277 sc_Nil
, /* 104: C_LINE line number */
1278 sc_Nil
, /* 105: C_ALIAS combined type info */
1279 sc_Nil
, /* 106: C_HIDDEN ??? */
1282 /* Convert COFF storage class to ECOFF symbol type. */
1283 static const st_t map_coff_sym_type
[] = {
1284 st_Nil
, /* 0: C_NULL */
1285 st_Local
, /* 1: C_AUTO auto var */
1286 st_Global
, /* 2: C_EXT external */
1287 st_Static
, /* 3: C_STAT static */
1288 st_Local
, /* 4: C_REG register */
1289 st_Global
, /* 5: C_EXTDEF ??? */
1290 st_Label
, /* 6: C_LABEL label */
1291 st_Label
, /* 7: C_ULABEL user label */
1292 st_Member
, /* 8: C_MOS member of struct */
1293 st_Param
, /* 9: C_ARG argument */
1294 st_Block
, /* 10: C_STRTAG struct tag */
1295 st_Member
, /* 11: C_MOU member of union */
1296 st_Block
, /* 12: C_UNTAG union tag */
1297 st_Typedef
, /* 13: C_TPDEF typedef */
1298 st_Static
, /* 14: C_USTATIC ??? */
1299 st_Block
, /* 15: C_ENTAG enum tag */
1300 st_Member
, /* 16: C_MOE member of enum */
1301 st_Param
, /* 17: C_REGPARM register parameter */
1302 st_Member
, /* 18; C_FIELD bitfield */
1384 st_Block
, /* 100: C_BLOCK block start/end */
1385 st_Proc
, /* 101: C_FCN function start/end */
1386 st_End
, /* 102: C_EOS end of struct/union/enum */
1387 st_File
, /* 103: C_FILE file start */
1388 st_Nil
, /* 104: C_LINE line number */
1389 st_Nil
, /* 105: C_ALIAS combined type info */
1390 st_Nil
, /* 106: C_HIDDEN ??? */
1394 /* Keep track of different sized allocation requests. */
1395 static alloc_info_t alloc_counts
[ (int)alloc_type_last
];
1397 /* Record whether we have seen any debugging information. */
1398 int ecoff_debugging_seen
= 0;
1400 /* Various statics. */
1401 static efdr_t
*cur_file_ptr
= (efdr_t
*) 0; /* current file desc. header */
1402 static proc_t
*cur_proc_ptr
= (proc_t
*) 0; /* current procedure header */
1403 static proc_t
*first_proc_ptr
= (proc_t
*) 0; /* first procedure header */
1404 static thead_t
*top_tag_head
= (thead_t
*) 0; /* top level tag head */
1405 static thead_t
*cur_tag_head
= (thead_t
*) 0; /* current tag head */
1407 static int debug
= 0; /* trace functions */
1409 static int stabs_seen
= 0; /* != 0 if stabs have been seen */
1411 static int current_file_idx
;
1412 static const char *current_stabs_filename
;
1414 /* Pseudo symbol to use when putting stabs into the symbol table. */
1415 #ifndef STABS_SYMBOL
1416 #define STABS_SYMBOL "@stabs"
1419 static char stabs_symbol
[] = STABS_SYMBOL
;
1421 /* Prototypes for functions defined in this file. */
1423 static void add_varray_page
PARAMS ((varray_t
*vp
));
1424 static symint_t add_string
PARAMS ((varray_t
*vp
,
1425 struct hash_control
*hash_tbl
,
1427 shash_t
**ret_hash
));
1428 static localsym_t
*add_ecoff_symbol
PARAMS ((const char *str
, st_t type
,
1429 sc_t storage
, symbolS
*sym
,
1430 bfd_vma addend
, symint_t value
,
1432 static symint_t add_aux_sym_symint
PARAMS ((symint_t aux_word
));
1433 static symint_t add_aux_sym_rndx
PARAMS ((int file_index
,
1434 symint_t sym_index
));
1435 static symint_t add_aux_sym_tir
PARAMS ((type_info_t
*t
,
1437 thash_t
**hash_tbl
));
1438 static tag_t
*get_tag
PARAMS ((const char *tag
, localsym_t
*sym
,
1440 static void add_unknown_tag
PARAMS ((tag_t
*ptag
));
1441 static void add_procedure
PARAMS ((char *func
));
1442 static void add_file
PARAMS ((const char *file_name
, int indx
, int fake
));
1444 static char *sc_to_string
PARAMS ((sc_t storage_class
));
1445 static char *st_to_string
PARAMS ((st_t symbol_type
));
1447 static void mark_stabs
PARAMS ((int));
1448 static char *ecoff_add_bytes
PARAMS ((char **buf
, char **bufend
,
1449 char *bufptr
, unsigned long need
));
1450 static unsigned long ecoff_padding_adjust
1451 PARAMS ((const struct ecoff_debug_swap
*backend
, char **buf
, char **bufend
,
1452 unsigned long offset
, char **bufptrptr
));
1453 static unsigned long ecoff_build_lineno
1454 PARAMS ((const struct ecoff_debug_swap
*backend
, char **buf
, char **bufend
,
1455 unsigned long offset
, long *linecntptr
));
1456 static unsigned long ecoff_build_symbols
1457 PARAMS ((const struct ecoff_debug_swap
*backend
, char **buf
, char **bufend
,
1458 unsigned long offset
));
1459 static unsigned long ecoff_build_procs
1460 PARAMS ((const struct ecoff_debug_swap
*backend
, char **buf
, char **bufend
,
1461 unsigned long offset
));
1462 static unsigned long ecoff_build_aux
1463 PARAMS ((const struct ecoff_debug_swap
*backend
, char **buf
, char **bufend
,
1464 unsigned long offset
));
1465 static unsigned long ecoff_build_strings
PARAMS ((char **buf
, char **bufend
,
1466 unsigned long offset
,
1468 static unsigned long ecoff_build_ss
1469 PARAMS ((const struct ecoff_debug_swap
*backend
, char **buf
, char **bufend
,
1470 unsigned long offset
));
1471 static unsigned long ecoff_build_fdr
1472 PARAMS ((const struct ecoff_debug_swap
*backend
, char **buf
, char **bufend
,
1473 unsigned long offset
));
1474 static void ecoff_setup_ext
PARAMS ((void));
1475 static page_t
*allocate_cluster
PARAMS ((unsigned long npages
));
1476 static page_t
*allocate_page
PARAMS ((void));
1477 static scope_t
*allocate_scope
PARAMS ((void));
1478 static void free_scope
PARAMS ((scope_t
*ptr
));
1479 static vlinks_t
*allocate_vlinks
PARAMS ((void));
1480 static shash_t
*allocate_shash
PARAMS ((void));
1481 static thash_t
*allocate_thash
PARAMS ((void));
1482 static tag_t
*allocate_tag
PARAMS ((void));
1483 static void free_tag
PARAMS ((tag_t
*ptr
));
1484 static forward_t
*allocate_forward
PARAMS ((void));
1485 static thead_t
*allocate_thead
PARAMS ((void));
1486 static void free_thead
PARAMS ((thead_t
*ptr
));
1487 static lineno_list_t
*allocate_lineno_list
PARAMS ((void));
1488 static void generate_ecoff_stab
PARAMS ((int, const char *, int, int, int));
1490 /* This function should be called when the assembler starts up. */
1493 ecoff_read_begin_hook ()
1495 tag_hash
= hash_new ();
1496 top_tag_head
= allocate_thead ();
1497 top_tag_head
->first_tag
= (tag_t
*) NULL
;
1498 top_tag_head
->free
= (thead_t
*) NULL
;
1499 top_tag_head
->prev
= cur_tag_head
;
1500 cur_tag_head
= top_tag_head
;
1503 /* This function should be called when a symbol is created. */
1506 ecoff_symbol_new_hook (symbolP
)
1509 /* Make sure that we have a file pointer, but only if we have seen a
1510 file. If we haven't seen a file, then this is a probably special
1511 symbol created by md_begin which may required special handling at
1512 some point. Creating a dummy file with a dummy name is certainly
1514 if (cur_file_ptr
== (efdr_t
*) NULL
1515 && seen_at_least_1_file ())
1516 add_file ((const char *) NULL
, 0, 1);
1517 symbolP
->ecoff_file
= cur_file_ptr
;
1518 symbolP
->ecoff_symbol
= NULL
;
1519 symbolP
->ecoff_extern_size
= 0;
1522 /* Add a page to a varray object. */
1525 add_varray_page (vp
)
1526 varray_t
*vp
; /* varray to add page to */
1528 vlinks_t
*new_links
= allocate_vlinks ();
1531 if (vp
->object_size
> 1)
1532 new_links
->datum
= (page_t
*) xcalloc (1, vp
->object_size
);
1535 new_links
->datum
= allocate_page ();
1537 alloc_counts
[(int)alloc_type_varray
].total_alloc
++;
1538 alloc_counts
[(int)alloc_type_varray
].total_pages
++;
1540 new_links
->start_index
= vp
->num_allocated
;
1541 vp
->objects_last_page
= 0;
1543 if (vp
->first
== (vlinks_t
*) NULL
) /* first allocation? */
1544 vp
->first
= vp
->last
= new_links
;
1546 { /* 2nd or greater allocation */
1547 new_links
->prev
= vp
->last
;
1548 vp
->last
->next
= new_links
;
1549 vp
->last
= new_links
;
1553 /* Add a string (and null pad) to one of the string tables. */
1556 add_string (vp
, hash_tbl
, str
, ret_hash
)
1557 varray_t
*vp
; /* string obstack */
1558 struct hash_control
*hash_tbl
; /* ptr to hash table */
1559 const char *str
; /* string */
1560 shash_t
**ret_hash
; /* return hash pointer */
1562 register unsigned long len
= strlen (str
);
1563 register shash_t
*hash_ptr
;
1565 if (len
>= PAGE_USIZE
)
1566 as_fatal ("String too big (%lu bytes)", len
);
1568 hash_ptr
= (shash_t
*) hash_find (hash_tbl
, str
);
1569 if (hash_ptr
== (shash_t
*) NULL
)
1571 register const char *err
;
1573 if (vp
->objects_last_page
+ len
>= PAGE_USIZE
)
1576 ((vp
->num_allocated
+ PAGE_USIZE
- 1) / PAGE_USIZE
) * PAGE_USIZE
;
1577 add_varray_page (vp
);
1580 hash_ptr
= allocate_shash ();
1581 hash_ptr
->indx
= vp
->num_allocated
;
1583 hash_ptr
->string
= &vp
->last
->datum
->byte
[vp
->objects_last_page
];
1585 vp
->objects_last_page
+= len
+ 1;
1586 vp
->num_allocated
+= len
+ 1;
1588 strcpy (hash_ptr
->string
, str
);
1590 err
= hash_insert (hash_tbl
, str
, (char *) hash_ptr
);
1592 as_fatal ("Inserting \"%s\" into string hash table: %s",
1596 if (ret_hash
!= (shash_t
**) NULL
)
1597 *ret_hash
= hash_ptr
;
1599 return hash_ptr
->indx
;
1602 /* Add debugging information for a symbol. */
1605 add_ecoff_symbol (str
, type
, storage
, sym_value
, addend
, value
, indx
)
1606 const char *str
; /* symbol name */
1607 st_t type
; /* symbol type */
1608 sc_t storage
; /* storage class */
1609 symbolS
*sym_value
; /* associated symbol. */
1610 bfd_vma addend
; /* addend to sym_value. */
1611 symint_t value
; /* value of symbol */
1612 symint_t indx
; /* index to local/aux. syms */
1615 register scope_t
*pscope
;
1616 register thead_t
*ptag_head
;
1617 register tag_t
*ptag
;
1618 register tag_t
*ptag_next
;
1619 register varray_t
*vp
;
1620 register int scope_delta
= 0;
1621 shash_t
*hash_ptr
= (shash_t
*) NULL
;
1623 if (cur_file_ptr
== (efdr_t
*) NULL
)
1624 as_fatal ("no current file pointer");
1626 vp
= &cur_file_ptr
->symbols
;
1628 if (vp
->objects_last_page
== vp
->objects_per_page
)
1629 add_varray_page (vp
);
1631 psym
= &vp
->last
->datum
->sym
[ vp
->objects_last_page
++ ];
1633 if (str
== (const char *) NULL
&& sym_value
!= (symbolS
*) NULL
)
1634 psym
->name
= S_GET_NAME (sym_value
);
1637 psym
->as_sym
= sym_value
;
1638 if (sym_value
!= (symbolS
*) NULL
)
1639 sym_value
->ecoff_symbol
= psym
;
1640 psym
->addend
= addend
;
1641 psym
->file_ptr
= cur_file_ptr
;
1642 psym
->proc_ptr
= cur_proc_ptr
;
1643 psym
->begin_ptr
= (localsym_t
*) NULL
;
1644 psym
->index_ptr
= (aux_t
*) NULL
;
1645 psym
->forward_ref
= (forward_t
*) NULL
;
1646 psym
->sym_index
= -1;
1647 memset (&psym
->ecoff_sym
, 0, sizeof (EXTR
));
1648 psym
->ecoff_sym
.asym
.value
= value
;
1649 psym
->ecoff_sym
.asym
.st
= (unsigned) type
;
1650 psym
->ecoff_sym
.asym
.sc
= (unsigned) storage
;
1651 psym
->ecoff_sym
.asym
.index
= indx
;
1653 /* If there is an associated symbol, we wait until the end of the
1654 assembly before deciding where to put the name (it may be just an
1655 external symbol). Otherwise, this is just a debugging symbol and
1656 the name should go with the current file. */
1657 if (sym_value
== (symbolS
*) NULL
)
1658 psym
->ecoff_sym
.asym
.iss
= ((str
== (const char *) NULL
)
1660 : add_string (&cur_file_ptr
->strings
,
1661 cur_file_ptr
->str_hash
,
1665 ++vp
->num_allocated
;
1667 if (ECOFF_IS_STAB (&psym
->ecoff_sym
.asym
))
1670 /* Save the symbol within the hash table if this is a static
1671 item, and it has a name. */
1672 if (hash_ptr
!= (shash_t
*) NULL
1673 && (type
== st_Global
|| type
== st_Static
|| type
== st_Label
1674 || type
== st_Proc
|| type
== st_StaticProc
))
1675 hash_ptr
->sym_ptr
= psym
;
1677 /* push or pop a scope if appropriate. */
1683 case st_File
: /* beginning of file */
1684 case st_Proc
: /* procedure */
1685 case st_StaticProc
: /* static procedure */
1686 case st_Block
: /* begin scope */
1687 pscope
= allocate_scope ();
1688 pscope
->prev
= cur_file_ptr
->cur_scope
;
1689 pscope
->lsym
= psym
;
1690 pscope
->type
= type
;
1691 cur_file_ptr
->cur_scope
= pscope
;
1693 if (type
!= st_File
)
1696 /* For every block type except file, struct, union, or
1697 enumeration blocks, push a level on the tag stack. We omit
1698 file types, so that tags can span file boundaries. */
1699 if (type
!= st_File
&& storage
!= sc_Info
)
1701 ptag_head
= allocate_thead ();
1702 ptag_head
->first_tag
= 0;
1703 ptag_head
->prev
= cur_tag_head
;
1704 cur_tag_head
= ptag_head
;
1709 pscope
= cur_file_ptr
->cur_scope
;
1710 if (pscope
== (scope_t
*) NULL
)
1711 as_fatal ("too many st_End's");
1714 st_t begin_type
= (st_t
) pscope
->lsym
->ecoff_sym
.asym
.st
;
1716 psym
->begin_ptr
= pscope
->lsym
;
1718 if (begin_type
!= st_File
)
1721 /* Except for file, structure, union, or enumeration end
1722 blocks remove all tags created within this scope. */
1723 if (begin_type
!= st_File
&& storage
!= sc_Info
)
1725 ptag_head
= cur_tag_head
;
1726 cur_tag_head
= ptag_head
->prev
;
1728 for (ptag
= ptag_head
->first_tag
;
1729 ptag
!= (tag_t
*) NULL
;
1732 if (ptag
->forward_ref
!= (forward_t
*) NULL
)
1733 add_unknown_tag (ptag
);
1735 ptag_next
= ptag
->same_block
;
1736 ptag
->hash_ptr
->tag_ptr
= ptag
->same_name
;
1740 free_thead (ptag_head
);
1743 cur_file_ptr
->cur_scope
= pscope
->prev
;
1745 /* block begin gets next sym #. This is set when we know
1746 the symbol index value. */
1748 /* Functions push two or more aux words as follows:
1749 1st word: index+1 of the end symbol (filled in later).
1750 2nd word: type of the function (plus any aux words needed).
1751 Also, tie the external pointer back to the function begin symbol. */
1752 if (begin_type
!= st_File
&& begin_type
!= st_Block
)
1755 varray_t
*svp
= &cur_file_ptr
->aux_syms
;
1757 pscope
->lsym
->ecoff_sym
.asym
.index
= add_aux_sym_symint (0);
1758 pscope
->lsym
->index_ptr
=
1759 &svp
->last
->datum
->aux
[svp
->objects_last_page
- 1];
1760 ty
= add_aux_sym_tir (&last_func_type_info
,
1762 &cur_file_ptr
->thash_head
[0]);
1764 /* This seems to be unnecessary. I'm not even sure what it is
1765 * intended to do. It's from mips-tfile.
1766 * if (last_func_sym_value != (symbolS *) NULL)
1768 * last_func_sym_value->ifd = cur_file_ptr->file_index;
1769 * last_func_sym_value->index = ty;
1774 free_scope (pscope
);
1778 cur_file_ptr
->nested_scopes
+= scope_delta
;
1781 if (debug
&& type
!= st_File
1782 && (debug
> 2 || type
== st_Block
|| type
== st_End
1783 || type
== st_Proc
|| type
== st_StaticProc
))
1785 char *sc_str
= sc_to_string (storage
);
1786 char *st_str
= st_to_string (type
);
1787 int depth
= cur_file_ptr
->nested_scopes
+ (scope_delta
< 0);
1790 "\tlsym\tv= %10ld, depth= %2d, sc= %-12s",
1791 value
, depth
, sc_str
);
1793 if (str_start
&& str_end_p1
- str_start
> 0)
1794 fprintf (stderr
, " st= %-11s name= %.*s\n", st_str
, str_end_p1
- str_start
, str_start
);
1797 unsigned long len
= strlen (st_str
);
1798 fprintf (stderr
, " st= %.*s\n", len
-1, st_str
);
1806 /* Add an auxiliary symbol (passing a symint). This is actually used
1807 for integral aux types, not just symints. */
1810 add_aux_sym_symint (aux_word
)
1811 symint_t aux_word
; /* auxiliary information word */
1813 register varray_t
*vp
;
1814 register aux_t
*aux_ptr
;
1816 if (cur_file_ptr
== (efdr_t
*) NULL
)
1817 as_fatal ("no current file pointer");
1819 vp
= &cur_file_ptr
->aux_syms
;
1821 if (vp
->objects_last_page
== vp
->objects_per_page
)
1822 add_varray_page (vp
);
1824 aux_ptr
= &vp
->last
->datum
->aux
[vp
->objects_last_page
++];
1825 aux_ptr
->type
= aux_isym
;
1826 aux_ptr
->data
.isym
= aux_word
;
1828 return vp
->num_allocated
++;
1832 /* Add an auxiliary symbol (passing a file/symbol index combo). */
1835 add_aux_sym_rndx (file_index
, sym_index
)
1839 register varray_t
*vp
;
1840 register aux_t
*aux_ptr
;
1842 if (cur_file_ptr
== (efdr_t
*) NULL
)
1843 as_fatal ("no current file pointer");
1845 vp
= &cur_file_ptr
->aux_syms
;
1847 if (vp
->objects_last_page
== vp
->objects_per_page
)
1848 add_varray_page (vp
);
1850 aux_ptr
= &vp
->last
->datum
->aux
[vp
->objects_last_page
++];
1851 aux_ptr
->type
= aux_rndx
;
1852 aux_ptr
->data
.rndx
.rfd
= file_index
;
1853 aux_ptr
->data
.rndx
.index
= sym_index
;
1855 return vp
->num_allocated
++;
1858 /* Add an auxiliary symbol (passing the basic type and possibly
1859 type qualifiers). */
1862 add_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 */
1867 register varray_t
*vp
;
1868 register aux_t
*aux_ptr
;
1869 static AUXU init_aux
;
1874 if (cur_file_ptr
== (efdr_t
*) NULL
)
1875 as_fatal ("no current file pointer");
1877 vp
= &cur_file_ptr
->aux_syms
;
1880 aux
.ti
.bt
= (int) t
->basic_type
;
1881 aux
.ti
.continued
= 0;
1882 aux
.ti
.fBitfield
= t
->bitfield
;
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];
1892 /* For anything that adds additional information, we must not hash,
1893 so check here, and reset our state. */
1895 if (state
!= hash_no
1896 && (t
->type_qualifiers
[0] == tq_Array
1897 || t
->type_qualifiers
[1] == tq_Array
1898 || t
->type_qualifiers
[2] == tq_Array
1899 || t
->type_qualifiers
[3] == tq_Array
1900 || t
->type_qualifiers
[4] == tq_Array
1901 || t
->type_qualifiers
[5] == tq_Array
1902 || t
->basic_type
== bt_Struct
1903 || t
->basic_type
== bt_Union
1904 || t
->basic_type
== bt_Enum
1906 || t
->num_dims
> 0))
1909 /* See if we can hash this type, and save some space, but some types
1910 can't be hashed (because they contain arrays or continuations),
1911 and others can be put into the hash list, but cannot use existing
1912 types because other aux entries precede this one. */
1914 if (state
!= hash_no
)
1916 register thash_t
*hash_ptr
;
1917 register symint_t hi
;
1919 hi
= aux
.isym
& ((1 << HASHBITS
) - 1);
1922 for (hash_ptr
= hash_tbl
[hi
];
1923 hash_ptr
!= (thash_t
*)0;
1924 hash_ptr
= hash_ptr
->next
)
1926 if (aux
.isym
== hash_ptr
->type
.isym
)
1930 if (hash_ptr
!= (thash_t
*) NULL
&& state
== hash_yes
)
1931 return hash_ptr
->indx
;
1933 if (hash_ptr
== (thash_t
*) NULL
)
1935 hash_ptr
= allocate_thash ();
1936 hash_ptr
->next
= hash_tbl
[hi
];
1937 hash_ptr
->type
= aux
;
1938 hash_ptr
->indx
= vp
->num_allocated
;
1939 hash_tbl
[hi
] = hash_ptr
;
1943 /* Everything is set up, add the aux symbol. */
1944 if (vp
->objects_last_page
== vp
->objects_per_page
)
1945 add_varray_page (vp
);
1947 aux_ptr
= &vp
->last
->datum
->aux
[ vp
->objects_last_page
++ ];
1948 aux_ptr
->type
= aux_tir
;
1949 aux_ptr
->data
= aux
;
1951 ret
= vp
->num_allocated
++;
1953 /* Add bitfield length if it exists.
1955 NOTE: Mips documentation claims bitfield goes at the end of the
1956 AUX record, but the DECstation compiler emits it here.
1957 (This would only make a difference for enum bitfields.)
1959 Also note: We use the last size given since gcc may emit 2
1960 for an enum bitfield. */
1963 (void) add_aux_sym_symint ((symint_t
)t
->sizes
[t
->num_sizes
-1]);
1966 /* Add tag information if needed. Structure, union, and enum
1967 references add 2 aux symbols: a [file index, symbol index]
1968 pointer to the structure type, and the current file index. */
1970 if (t
->basic_type
== bt_Struct
1971 || t
->basic_type
== bt_Union
1972 || t
->basic_type
== bt_Enum
)
1974 register symint_t file_index
= t
->tag_ptr
->ifd
;
1975 register localsym_t
*sym
= t
->tag_ptr
->sym
;
1976 register forward_t
*forward_ref
= allocate_forward ();
1978 if (sym
!= (localsym_t
*) NULL
)
1980 forward_ref
->next
= sym
->forward_ref
;
1981 sym
->forward_ref
= forward_ref
;
1985 forward_ref
->next
= t
->tag_ptr
->forward_ref
;
1986 t
->tag_ptr
->forward_ref
= forward_ref
;
1989 (void) add_aux_sym_rndx (ST_RFDESCAPE
, indexNil
);
1990 forward_ref
->index_ptr
1991 = &vp
->last
->datum
->aux
[ vp
->objects_last_page
- 1];
1993 (void) add_aux_sym_symint (file_index
);
1994 forward_ref
->ifd_ptr
1995 = &vp
->last
->datum
->aux
[ vp
->objects_last_page
- 1];
1998 /* Add information about array bounds if they exist. */
1999 for (i
= 0; i
< t
->num_dims
; i
++)
2001 (void) add_aux_sym_rndx (ST_RFDESCAPE
,
2002 cur_file_ptr
->int_type
);
2004 (void) add_aux_sym_symint (cur_file_ptr
->file_index
); /* file index*/
2005 (void) add_aux_sym_symint ((symint_t
) 0); /* low bound */
2006 (void) add_aux_sym_symint (t
->dimensions
[i
] - 1); /* high bound*/
2007 (void) add_aux_sym_symint ((t
->dimensions
[i
] == 0) /* stride */
2009 : (t
->sizes
[i
] * 8) / t
->dimensions
[i
]);
2012 /* NOTE: Mips documentation claims that the bitfield width goes here.
2013 But it needs to be emitted earlier. */
2018 /* Add a tag to the tag table (unless it already exists). */
2021 get_tag (tag
, sym
, basic_type
)
2022 const char *tag
; /* tag name */
2023 localsym_t
*sym
; /* tag start block */
2024 bt_t basic_type
; /* bt_Struct, bt_Union, or bt_Enum */
2030 if (cur_file_ptr
== (efdr_t
*) NULL
)
2031 as_fatal ("no current file pointer");
2033 hash_ptr
= (shash_t
*) hash_find (tag_hash
, tag
);
2035 if (hash_ptr
!= (shash_t
*) NULL
2036 && hash_ptr
->tag_ptr
!= (tag_t
*) NULL
)
2038 tag_ptr
= hash_ptr
->tag_ptr
;
2039 if (sym
!= (localsym_t
*) NULL
)
2041 tag_ptr
->basic_type
= basic_type
;
2042 tag_ptr
->ifd
= cur_file_ptr
->file_index
;
2048 if (hash_ptr
== (shash_t
*) NULL
)
2052 perm
= xmalloc ((unsigned long) (strlen (tag
) + 1));
2054 hash_ptr
= allocate_shash ();
2055 err
= hash_insert (tag_hash
, perm
, (char *) hash_ptr
);
2057 as_fatal ("Inserting \"%s\" into tag hash table: %s",
2059 hash_ptr
->string
= perm
;
2062 tag_ptr
= allocate_tag ();
2063 tag_ptr
->forward_ref
= (forward_t
*) NULL
;
2064 tag_ptr
->hash_ptr
= hash_ptr
;
2065 tag_ptr
->same_name
= hash_ptr
->tag_ptr
;
2066 tag_ptr
->basic_type
= basic_type
;
2068 tag_ptr
->ifd
= ((sym
== (localsym_t
*) NULL
)
2070 : cur_file_ptr
->file_index
);
2071 tag_ptr
->same_block
= cur_tag_head
->first_tag
;
2073 cur_tag_head
->first_tag
= tag_ptr
;
2074 hash_ptr
->tag_ptr
= tag_ptr
;
2079 /* Add an unknown {struct, union, enum} tag. */
2082 add_unknown_tag (ptag
)
2083 tag_t
*ptag
; /* pointer to tag information */
2085 shash_t
*hash_ptr
= ptag
->hash_ptr
;
2086 char *name
= hash_ptr
->string
;
2093 char *agg_type
= "{unknown aggregate type}";
2094 switch (ptag
->basic_type
)
2096 case bt_Struct
: agg_type
= "struct"; break;
2097 case bt_Union
: agg_type
= "union"; break;
2098 case bt_Enum
: agg_type
= "enum"; break;
2102 fprintf (stderr
, "unknown %s %.*s found\n", agg_type
,
2103 hash_ptr
->len
, name_start
);
2107 sym
= add_ecoff_symbol (name
,
2115 (void) add_ecoff_symbol (name
,
2123 for (pf
= &sym
->forward_ref
; *pf
!= (forward_t
*) NULL
; pf
= &(*pf
)->next
)
2125 *pf
= ptag
->forward_ref
;
2128 /* Add a procedure to the current file's list of procedures, and record
2129 this is the current procedure. */
2132 add_procedure (func
)
2133 char *func
; /* func name */
2135 register varray_t
*vp
;
2136 register proc_t
*new_proc_ptr
;
2140 fputc ('\n', stderr
);
2143 if (cur_file_ptr
== (efdr_t
*) NULL
)
2144 as_fatal ("no current file pointer");
2146 vp
= &cur_file_ptr
->procs
;
2148 if (vp
->objects_last_page
== vp
->objects_per_page
)
2149 add_varray_page (vp
);
2151 cur_proc_ptr
= new_proc_ptr
= &vp
->last
->datum
->proc
[vp
->objects_last_page
++];
2153 if (first_proc_ptr
== (proc_t
*) NULL
)
2154 first_proc_ptr
= new_proc_ptr
;
2156 vp
->num_allocated
++;
2158 new_proc_ptr
->pdr
.isym
= -1;
2159 new_proc_ptr
->pdr
.iline
= -1;
2160 new_proc_ptr
->pdr
.lnLow
= -1;
2161 new_proc_ptr
->pdr
.lnHigh
= -1;
2163 /* Push the start of the function. */
2164 new_proc_ptr
->sym
= add_ecoff_symbol ((const char *) NULL
, st_Proc
, sc_Text
,
2165 symbol_find_or_make (func
),
2166 (bfd_vma
) 0, (symint_t
) 0,
2171 /* Fill in the linenos preceding the .ent, if any. */
2172 if (noproc_lineno
!= (lineno_list_t
*) NULL
)
2176 for (l
= noproc_lineno
; l
!= (lineno_list_t
*) NULL
; l
= l
->next
)
2177 l
->proc
= new_proc_ptr
;
2178 *last_lineno_ptr
= noproc_lineno
;
2179 while (*last_lineno_ptr
!= NULL
)
2180 last_lineno_ptr
= &(*last_lineno_ptr
)->next
;
2181 noproc_lineno
= (lineno_list_t
*) NULL
;
2185 /* Add a new filename, and set up all of the file relative
2186 virtual arrays (strings, symbols, aux syms, etc.). Record
2187 where the current file structure lives. */
2190 add_file (file_name
, indx
, fake
)
2191 const char *file_name
; /* file name */
2195 register int first_ch
;
2196 register efdr_t
*fil_ptr
;
2200 fprintf (stderr
, "\tfile\t%.*s\n", len
, file_start
);
2203 /* If the file name is NULL, then no .file symbol appeared, and we
2204 want to use the actual file name. */
2205 if (file_name
== (const char *) NULL
)
2209 if (first_file
!= (efdr_t
*) NULL
)
2210 as_fatal ("fake .file after real one");
2211 as_where (&file
, (unsigned int *) NULL
);
2212 file_name
= (const char *) file
;
2214 if (! symbol_table_frozen
)
2215 generate_asm_lineno
= 1;
2218 generate_asm_lineno
= 0;
2222 listing_source_file (file_name
);
2225 current_stabs_filename
= file_name
;
2227 /* If we're creating stabs, then we don't actually make a new FDR.
2228 Instead, we just create a stabs symbol. */
2231 (void) add_ecoff_symbol (file_name
, st_Nil
, sc_Nil
,
2232 symbol_new ("L0\001", now_seg
,
2233 (valueT
) frag_now_fix (),
2235 (bfd_vma
) 0, 0, ECOFF_MARK_STAB (N_SOL
));
2239 first_ch
= *file_name
;
2241 /* ??? This is ifdefed out, because it results in incorrect line number
2242 debugging info when multiple .file pseudo-ops are merged into one file
2243 descriptor. See for instance ecoff_build_lineno, which will
2244 end up setting all file->fdr.* fields multiple times, resulting in
2245 incorrect debug info. In order to make this work right, all line number
2246 and symbol info for the same source file has to be adjacent in the object
2247 file, so that a single file descriptor can be used to point to them.
2248 This would require maintaining file specific lists of line numbers and
2249 symbols for each file, so that they can be merged together (or output
2250 together) when two .file pseudo-ops are merged into one file
2254 /* See if the file has already been created. */
2255 for (fil_ptr
= first_file
;
2256 fil_ptr
!= (efdr_t
*) NULL
;
2257 fil_ptr
= fil_ptr
->next_file
)
2259 if (first_ch
== fil_ptr
->name
[0]
2260 && strcmp (file_name
, fil_ptr
->name
) == 0)
2262 cur_file_ptr
= fil_ptr
;
2264 cur_file_ptr
->fake
= 0;
2269 fil_ptr
= (efdr_t
*) NULL
;
2272 /* If this is a new file, create it. */
2273 if (fil_ptr
== (efdr_t
*) NULL
)
2275 if (file_desc
.objects_last_page
== file_desc
.objects_per_page
)
2276 add_varray_page (&file_desc
);
2278 fil_ptr
= cur_file_ptr
=
2279 &file_desc
.last
->datum
->file
[file_desc
.objects_last_page
++];
2280 *fil_ptr
= init_file
;
2282 fil_ptr
->file_index
= current_file_idx
++;
2283 ++file_desc
.num_allocated
;
2285 fil_ptr
->fake
= fake
;
2287 /* Allocate the string hash table. */
2288 fil_ptr
->str_hash
= hash_new ();
2290 /* Make sure 0 byte in string table is null */
2291 add_string (&fil_ptr
->strings
,
2296 if (strlen (file_name
) > PAGE_USIZE
- 2)
2297 as_fatal ("Filename goes over one page boundary.");
2299 /* Push the start of the filename. We assume that the filename
2300 will be stored at string offset 1. */
2301 (void) add_ecoff_symbol (file_name
, st_File
, sc_Text
,
2302 (symbolS
*) NULL
, (bfd_vma
) 0,
2303 (symint_t
) 0, (symint_t
) 0);
2304 fil_ptr
->fdr
.rss
= 1;
2305 fil_ptr
->name
= &fil_ptr
->strings
.last
->datum
->byte
[1];
2307 /* Update the linked list of file descriptors. */
2308 *last_file_ptr
= fil_ptr
;
2309 last_file_ptr
= &fil_ptr
->next_file
;
2311 /* Add void & int types to the file (void should be first to catch
2312 errant 0's within the index fields). */
2313 fil_ptr
->void_type
= add_aux_sym_tir (&void_type_info
,
2315 &cur_file_ptr
->thash_head
[0]);
2317 fil_ptr
->int_type
= add_aux_sym_tir (&int_type_info
,
2319 &cur_file_ptr
->thash_head
[0]);
2320 /* gas used to have a bug that if the file does not have any
2321 symbol, it either will abort or will not build the file,
2322 the following is to get around that problem. ---kung*/
2324 if (generate_asm_lineno
)
2327 (void) add_ecoff_symbol (file_name
, st_Nil
, sc_Nil
,
2328 symbol_new ("L0\001", now_seg
,
2329 (valueT
) frag_now_fix (),
2331 (bfd_vma
) 0, 0, ECOFF_MARK_STAB (N_SO
));
2332 (void) add_ecoff_symbol ("void:t1=1", st_Nil
, sc_Nil
,
2333 (symbolS
*) NULL
, (bfd_vma
) 0, 0,
2334 ECOFF_MARK_STAB (N_LSYM
));
2342 /* Convert storage class to string. */
2345 sc_to_string(storage_class
)
2348 switch(storage_class
)
2350 case sc_Nil
: return "Nil,";
2351 case sc_Text
: return "Text,";
2352 case sc_Data
: return "Data,";
2353 case sc_Bss
: return "Bss,";
2354 case sc_Register
: return "Register,";
2355 case sc_Abs
: return "Abs,";
2356 case sc_Undefined
: return "Undefined,";
2357 case sc_CdbLocal
: return "CdbLocal,";
2358 case sc_Bits
: return "Bits,";
2359 case sc_CdbSystem
: return "CdbSystem,";
2360 case sc_RegImage
: return "RegImage,";
2361 case sc_Info
: return "Info,";
2362 case sc_UserStruct
: return "UserStruct,";
2363 case sc_SData
: return "SData,";
2364 case sc_SBss
: return "SBss,";
2365 case sc_RData
: return "RData,";
2366 case sc_Var
: return "Var,";
2367 case sc_Common
: return "Common,";
2368 case sc_SCommon
: return "SCommon,";
2369 case sc_VarRegister
: return "VarRegister,";
2370 case sc_Variant
: return "Variant,";
2371 case sc_SUndefined
: return "SUndefined,";
2372 case sc_Init
: return "Init,";
2373 case sc_Max
: return "Max,";
2383 /* Convert symbol type to string. */
2386 st_to_string(symbol_type
)
2391 case st_Nil
: return "Nil,";
2392 case st_Global
: return "Global,";
2393 case st_Static
: return "Static,";
2394 case st_Param
: return "Param,";
2395 case st_Local
: return "Local,";
2396 case st_Label
: return "Label,";
2397 case st_Proc
: return "Proc,";
2398 case st_Block
: return "Block,";
2399 case st_End
: return "End,";
2400 case st_Member
: return "Member,";
2401 case st_Typedef
: return "Typedef,";
2402 case st_File
: return "File,";
2403 case st_RegReloc
: return "RegReloc,";
2404 case st_Forward
: return "Forward,";
2405 case st_StaticProc
: return "StaticProc,";
2406 case st_Constant
: return "Constant,";
2407 case st_Str
: return "String,";
2408 case st_Number
: return "Number,";
2409 case st_Expr
: return "Expr,";
2410 case st_Type
: return "Type,";
2411 case st_Max
: return "Max,";
2419 /* Parse .begin directives which have a label as the first argument
2420 which gives the location of the start of the block. */
2423 ecoff_directive_begin (ignore
)
2429 if (cur_file_ptr
== (efdr_t
*) NULL
)
2431 as_warn (".begin directive without a preceding .file directive");
2432 demand_empty_rest_of_line ();
2436 if (cur_proc_ptr
== (proc_t
*) NULL
)
2438 as_warn (".begin directive without a preceding .ent directive");
2439 demand_empty_rest_of_line ();
2443 name
= input_line_pointer
;
2444 name_end
= get_symbol_end ();
2446 (void) add_ecoff_symbol ((const char *) NULL
, st_Block
, sc_Text
,
2447 symbol_find_or_make (name
),
2448 (bfd_vma
) 0, (symint_t
) 0, (symint_t
) 0);
2450 *input_line_pointer
= name_end
;
2452 /* The line number follows, but we don't use it. */
2453 (void) get_absolute_expression ();
2454 demand_empty_rest_of_line ();
2457 /* Parse .bend directives which have a label as the first argument
2458 which gives the location of the end of the block. */
2461 ecoff_directive_bend (ignore
)
2468 if (cur_file_ptr
== (efdr_t
*) NULL
)
2470 as_warn (".bend directive without a preceding .file directive");
2471 demand_empty_rest_of_line ();
2475 if (cur_proc_ptr
== (proc_t
*) NULL
)
2477 as_warn (".bend directive without a preceding .ent directive");
2478 demand_empty_rest_of_line ();
2482 name
= input_line_pointer
;
2483 name_end
= get_symbol_end ();
2485 /* The value is the distance between the .bend directive and the
2486 corresponding symbol. We fill in the offset when we write out
2488 endsym
= symbol_find (name
);
2489 if (endsym
== (symbolS
*) NULL
)
2490 as_warn (".bend directive names unknown symbol");
2492 (void) add_ecoff_symbol ((const char *) NULL
, st_End
, sc_Text
, endsym
,
2493 (bfd_vma
) 0, (symint_t
) 0, (symint_t
) 0);
2495 *input_line_pointer
= name_end
;
2497 /* The line number follows, but we don't use it. */
2498 (void) get_absolute_expression ();
2499 demand_empty_rest_of_line ();
2502 /* COFF debugging information is provided as a series of directives
2503 (.def, .scl, etc.). We build up information as we read the
2504 directives in the following static variables, and file it away when
2505 we reach the .endef directive. */
2506 static char *coff_sym_name
;
2507 static type_info_t coff_type
;
2508 static sc_t coff_storage_class
;
2509 static st_t coff_symbol_typ
;
2510 static int coff_is_function
;
2511 static char *coff_tag
;
2512 static valueT coff_value
;
2513 static symbolS
*coff_sym_value
;
2514 static bfd_vma coff_sym_addend
;
2515 static int coff_inside_enumeration
;
2517 /* Handle a .def directive: start defining a symbol. */
2520 ecoff_directive_def (ignore
)
2526 ecoff_debugging_seen
= 1;
2530 name
= input_line_pointer
;
2531 name_end
= get_symbol_end ();
2533 if (coff_sym_name
!= (char *) NULL
)
2534 as_warn (".def pseudo-op used inside of .def/.endef; ignored");
2535 else if (*name
== '\0')
2536 as_warn ("Empty symbol name in .def; ignored");
2539 if (coff_sym_name
!= (char *) NULL
)
2540 free (coff_sym_name
);
2541 if (coff_tag
!= (char *) NULL
)
2543 coff_sym_name
= (char *) xmalloc ((unsigned long) (strlen (name
) + 1));
2544 strcpy (coff_sym_name
, name
);
2545 coff_type
= type_info_init
;
2546 coff_storage_class
= sc_Nil
;
2547 coff_symbol_typ
= st_Nil
;
2548 coff_is_function
= 0;
2549 coff_tag
= (char *) NULL
;
2551 coff_sym_value
= (symbolS
*) NULL
;
2552 coff_sym_addend
= 0;
2555 *input_line_pointer
= name_end
;
2557 demand_empty_rest_of_line ();
2560 /* Handle a .dim directive, used to give dimensions for an array. The
2561 arguments are comma separated numbers. mips-tfile assumes that
2562 there will not be more than 6 dimensions, and gdb won't read any
2563 more than that anyhow, so I will also make that assumption. */
2566 ecoff_directive_dim (ignore
)
2572 if (coff_sym_name
== (char *) NULL
)
2574 as_warn (".dim pseudo-op used outside of .def/.endef; ignored");
2575 demand_empty_rest_of_line ();
2579 for (i
= 0; i
< N_TQ
; i
++)
2582 dimens
[i
] = get_absolute_expression ();
2583 if (*input_line_pointer
== ',')
2584 ++input_line_pointer
;
2587 if (*input_line_pointer
!= '\n'
2588 && *input_line_pointer
!= ';')
2589 as_warn ("Badly formed .dim directive");
2597 /* The dimensions are stored away in reverse order. */
2600 if (coff_type
.num_dims
>= N_TQ
)
2602 as_warn ("Too many .dim entries");
2605 coff_type
.dimensions
[coff_type
.num_dims
] = dimens
[i
];
2606 ++coff_type
.num_dims
;
2609 demand_empty_rest_of_line ();
2612 /* Handle a .scl directive, which sets the COFF storage class of the
2616 ecoff_directive_scl (ignore
)
2621 if (coff_sym_name
== (char *) NULL
)
2623 as_warn (".scl pseudo-op used outside of .def/.endef; ignored");
2624 demand_empty_rest_of_line ();
2628 val
= get_absolute_expression ();
2630 coff_symbol_typ
= map_coff_sym_type
[val
];
2631 coff_storage_class
= map_coff_storage
[val
];
2633 demand_empty_rest_of_line ();
2636 /* Handle a .size directive. For some reason mips-tfile.c thinks that
2637 .size can have multiple arguments. We humor it, although gcc will
2638 never generate more than one argument. */
2641 ecoff_directive_size (ignore
)
2647 if (coff_sym_name
== (char *) NULL
)
2649 as_warn (".size pseudo-op used outside of .def/.endef; ignored");
2650 demand_empty_rest_of_line ();
2654 for (i
= 0; i
< N_TQ
; i
++)
2657 sizes
[i
] = get_absolute_expression ();
2658 if (*input_line_pointer
== ',')
2659 ++input_line_pointer
;
2662 if (*input_line_pointer
!= '\n'
2663 && *input_line_pointer
!= ';')
2664 as_warn ("Badly formed .size directive");
2672 /* The sizes are stored away in reverse order. */
2675 if (coff_type
.num_sizes
>= N_TQ
)
2677 as_warn ("Too many .size entries");
2680 coff_type
.sizes
[coff_type
.num_sizes
] = sizes
[i
];
2681 ++coff_type
.num_sizes
;
2684 demand_empty_rest_of_line ();
2687 /* Handle the .type directive, which gives the COFF type of the
2691 ecoff_directive_type (ignore
)
2698 if (coff_sym_name
== (char *) NULL
)
2700 as_warn (".type pseudo-op used outside of .def/.endef; ignored");
2701 demand_empty_rest_of_line ();
2705 val
= get_absolute_expression ();
2707 coff_type
.orig_type
= BTYPE (val
);
2708 coff_type
.basic_type
= map_coff_types
[coff_type
.orig_type
];
2710 tq_ptr
= &coff_type
.type_qualifiers
[N_TQ
];
2711 while (val
&~ N_BTMASK
)
2713 if (tq_ptr
== &coff_type
.type_qualifiers
[0])
2715 /* FIXME: We could handle this by setting the continued bit.
2716 There would still be a limit: the .type argument can not
2718 as_warn ("The type of %s is too complex; it will be simplified",
2724 else if (ISFCN (val
))
2725 *--tq_ptr
= tq_Proc
;
2726 else if (ISARY (val
))
2727 *--tq_ptr
= tq_Array
;
2729 as_fatal ("Unrecognized .type argument");
2734 tq_shft
= &coff_type
.type_qualifiers
[0];
2735 while (tq_ptr
!= &coff_type
.type_qualifiers
[N_TQ
])
2736 *tq_shft
++ = *tq_ptr
++;
2738 if (tq_shft
!= &coff_type
.type_qualifiers
[0] && tq_shft
[-1] == tq_Proc
)
2740 /* If this is a function, ignore it, so that we don't get two
2741 entries (one from the .ent, and one for the .def that
2742 precedes it). Save the type information so that the end
2743 block can properly add it after the begin block index. For
2744 MIPS knows what reason, we must strip off the function type
2746 coff_is_function
= 1;
2747 tq_shft
[-1] = tq_Nil
;
2750 while (tq_shft
!= &coff_type
.type_qualifiers
[N_TQ
])
2751 *tq_shft
++ = tq_Nil
;
2753 demand_empty_rest_of_line ();
2756 /* Handle the .tag directive, which gives the name of a structure,
2760 ecoff_directive_tag (ignore
)
2766 if (coff_sym_name
== (char *) NULL
)
2768 as_warn (".tag pseudo-op used outside of .def/.endef; ignored");
2769 demand_empty_rest_of_line ();
2773 name
= input_line_pointer
;
2774 name_end
= get_symbol_end ();
2776 coff_tag
= (char *) xmalloc ((unsigned long) (strlen (name
) + 1));
2777 strcpy (coff_tag
, name
);
2779 *input_line_pointer
= name_end
;
2781 demand_empty_rest_of_line ();
2784 /* Handle the .val directive, which gives the value of the symbol. It
2785 may be the name of a static or global symbol. */
2788 ecoff_directive_val (ignore
)
2793 if (coff_sym_name
== (char *) NULL
)
2795 as_warn (".val pseudo-op used outside of .def/.endef; ignored");
2796 demand_empty_rest_of_line ();
2801 if (exp
.X_op
!= O_constant
&& exp
.X_op
!= O_symbol
)
2803 as_bad (".val expression is too copmlex");
2804 demand_empty_rest_of_line ();
2808 if (exp
.X_op
== O_constant
)
2809 coff_value
= exp
.X_add_number
;
2812 coff_sym_value
= exp
.X_add_symbol
;
2813 coff_sym_addend
= exp
.X_add_number
;
2816 demand_empty_rest_of_line ();
2819 /* Handle the .endef directive, which terminates processing of COFF
2820 debugging information for a symbol. */
2823 ecoff_directive_endef (ignore
)
2830 demand_empty_rest_of_line ();
2832 if (coff_sym_name
== (char *) NULL
)
2834 as_warn (".endef pseudo-op used before .def; ignored");
2838 name
= coff_sym_name
;
2839 coff_sym_name
= (char *) NULL
;
2841 /* If the symbol is a static or external, we have already gotten the
2842 appropriate type and class, so make sure we don't override those
2843 values. This is needed because there are some type and classes
2844 that are not in COFF, such as short data, etc. */
2845 if (coff_sym_value
!= (symbolS
*) NULL
)
2847 coff_symbol_typ
= st_Nil
;
2848 coff_storage_class
= sc_Nil
;
2851 coff_type
.extra_sizes
= coff_tag
!= (char *) NULL
;
2852 if (coff_type
.num_dims
> 0)
2854 int diff
= coff_type
.num_dims
- coff_type
.num_sizes
;
2855 int i
= coff_type
.num_dims
- 1;
2858 if (coff_type
.num_sizes
!= 1 || diff
< 0)
2860 as_warn ("Bad COFF debugging info");
2864 /* If this is an array, make sure the same number of dimensions
2865 and sizes were passed, creating extra sizes for multiply
2866 dimensioned arrays if not passed. */
2867 coff_type
.extra_sizes
= 0;
2870 j
= (sizeof (coff_type
.sizes
) / sizeof (coff_type
.sizes
[0])) - 1;
2873 coff_type
.sizes
[j
] = (((j
- diff
) >= 0)
2874 ? coff_type
.sizes
[j
- diff
]
2879 coff_type
.num_sizes
= i
+ 1;
2880 for (i
--; i
>= 0; i
--)
2881 coff_type
.sizes
[i
] = (coff_type
.sizes
[i
+ 1]
2882 / coff_type
.dimensions
[i
+ 1]);
2885 else if (coff_symbol_typ
== st_Member
2886 && coff_type
.num_sizes
- coff_type
.extra_sizes
== 1)
2888 /* Is this a bitfield? This is indicated by a structure memeber
2889 having a size field that isn't an array. */
2890 coff_type
.bitfield
= 1;
2893 /* Except for enumeration members & begin/ending of scopes, put the
2894 type word in the aux. symbol table. */
2895 if (coff_symbol_typ
== st_Block
|| coff_symbol_typ
== st_End
)
2897 else if (coff_inside_enumeration
)
2898 indx
= cur_file_ptr
->void_type
;
2901 if (coff_type
.basic_type
== bt_Struct
2902 || coff_type
.basic_type
== bt_Union
2903 || coff_type
.basic_type
== bt_Enum
)
2905 if (coff_tag
== (char *) NULL
)
2907 as_warn ("No tag specified for %s", name
);
2911 coff_type
.tag_ptr
= get_tag (coff_tag
, (localsym_t
*) NULL
,
2912 coff_type
.basic_type
);
2915 if (coff_is_function
)
2917 last_func_type_info
= coff_type
;
2918 last_func_sym_value
= coff_sym_value
;
2922 indx
= add_aux_sym_tir (&coff_type
,
2924 &cur_file_ptr
->thash_head
[0]);
2927 /* Do any last minute adjustments that are necessary. */
2928 switch (coff_symbol_typ
)
2933 /* For the beginning of structs, unions, and enumerations, the
2934 size info needs to be passed in the value field. */
2936 if (coff_type
.num_sizes
- coff_type
.num_dims
- coff_type
.extra_sizes
2939 as_warn ("Bad COFF debugging information");
2943 coff_value
= coff_type
.sizes
[0];
2945 coff_inside_enumeration
= (coff_type
.orig_type
== T_ENUM
);
2948 /* For the end of structs, unions, and enumerations, omit the
2949 name which is always ".eos". This needs to be done last, so
2950 that any error reporting above gives the correct name. */
2953 name
= (char *) NULL
;
2955 coff_inside_enumeration
= 0;
2958 /* Members of structures and unions that aren't bitfields, need
2959 to adjust the value from a byte offset to a bit offset.
2960 Members of enumerations do not have the value adjusted, and
2961 can be distinguished by indx == indexNil. For enumerations,
2962 update the maximum enumeration value. */
2964 if (! coff_type
.bitfield
&& ! coff_inside_enumeration
)
2970 /* Add the symbol. */
2971 sym
= add_ecoff_symbol (name
,
2976 (symint_t
) coff_value
,
2979 /* deal with struct, union, and enum tags. */
2980 if (coff_symbol_typ
== st_Block
)
2982 /* Create or update the tag information. */
2983 tag_t
*tag_ptr
= get_tag (name
,
2985 coff_type
.basic_type
);
2988 /* Remember any forward references. */
2989 for (pf
= &sym
->forward_ref
;
2990 *pf
!= (forward_t
*) NULL
;
2993 *pf
= tag_ptr
->forward_ref
;
2994 tag_ptr
->forward_ref
= (forward_t
*) NULL
;
2998 /* Parse .end directives. */
3001 ecoff_directive_end (ignore
)
3009 if (cur_file_ptr
== (efdr_t
*) NULL
)
3011 as_warn (".end directive without a preceding .file directive");
3012 demand_empty_rest_of_line ();
3016 if (cur_proc_ptr
== (proc_t
*) NULL
)
3018 as_warn (".end directive without a preceding .ent directive");
3019 demand_empty_rest_of_line ();
3023 name
= input_line_pointer
;
3024 name_end
= get_symbol_end ();
3027 if (! is_name_beginner (ch
))
3029 as_warn (".end directive has no name");
3030 *input_line_pointer
= name_end
;
3031 demand_empty_rest_of_line ();
3035 /* The value is the distance between the .end directive and the
3036 corresponding symbol. We create a fake symbol to hold the
3037 current location, and put in the offset when we write out the
3039 ent
= symbol_find (name
);
3040 if (ent
== (symbolS
*) NULL
)
3041 as_warn (".end directive names unknown symbol");
3044 (void) add_ecoff_symbol ((const char *) NULL
, st_End
, sc_Text
,
3045 symbol_new ("L0\001", now_seg
,
3046 (valueT
) frag_now_fix (),
3048 (bfd_vma
) 0, (symint_t
) 0, (symint_t
) 0);
3050 if (stabs_seen
&& generate_asm_lineno
)
3054 n
= xmalloc (strlen (name
) + 4);
3057 (void) add_ecoff_symbol ((const char *) n
, stGlobal
, scText
,
3058 ent
, (bfd_vma
) 0, 0,
3059 ECOFF_MARK_STAB (N_FUN
));
3063 cur_proc_ptr
= (proc_t
*) NULL
;
3065 *input_line_pointer
= name_end
;
3066 demand_empty_rest_of_line ();
3069 /* Parse .ent directives. */
3072 ecoff_directive_ent (ignore
)
3079 if (cur_file_ptr
== (efdr_t
*) NULL
)
3080 add_file ((const char *) NULL
, 0, 1);
3082 if (cur_proc_ptr
!= (proc_t
*) NULL
)
3084 as_warn ("second .ent directive found before .end directive");
3085 demand_empty_rest_of_line ();
3089 name
= input_line_pointer
;
3090 name_end
= get_symbol_end ();
3093 if (! is_name_beginner (ch
))
3095 as_warn (".ent directive has no name");
3096 *input_line_pointer
= name_end
;
3097 demand_empty_rest_of_line ();
3101 add_procedure (name
);
3103 *input_line_pointer
= name_end
;
3105 /* The .ent directive is sometimes followed by a number. I'm not
3106 really sure what the number means. I don't see any way to store
3107 the information in the PDR. The Irix 4 assembler seems to ignore
3110 if (*input_line_pointer
== ',')
3112 ++input_line_pointer
;
3115 if (isdigit (*input_line_pointer
) || *input_line_pointer
== '-')
3116 (void) get_absolute_expression ();
3118 demand_empty_rest_of_line ();
3121 /* Parse .extern directives. */
3124 ecoff_directive_extern (ignore
)
3132 name
= input_line_pointer
;
3133 c
= get_symbol_end ();
3134 symbolp
= symbol_find_or_make (name
);
3135 *input_line_pointer
= c
;
3137 S_SET_EXTERNAL (symbolp
);
3139 if (*input_line_pointer
== ',')
3140 ++input_line_pointer
;
3141 size
= get_absolute_expression ();
3143 symbolp
->ecoff_extern_size
= size
;
3146 /* Parse .file directives. */
3149 ecoff_directive_file (ignore
)
3156 if (cur_proc_ptr
!= (proc_t
*) NULL
)
3158 as_warn ("No way to handle .file within .ent/.end section");
3159 demand_empty_rest_of_line ();
3163 indx
= (int) get_absolute_expression ();
3165 /* FIXME: we don't have to save the name here. */
3166 name
= demand_copy_C_string (&len
);
3168 add_file (name
, indx
- 1, 0);
3170 demand_empty_rest_of_line ();
3173 /* Parse .fmask directives. */
3176 ecoff_directive_fmask (ignore
)
3181 if (cur_proc_ptr
== (proc_t
*) NULL
)
3183 as_warn (".fmask outside of .ent");
3184 demand_empty_rest_of_line ();
3188 if (get_absolute_expression_and_terminator (&val
) != ',')
3190 as_warn ("Bad .fmask directive");
3191 --input_line_pointer
;
3192 demand_empty_rest_of_line ();
3196 cur_proc_ptr
->pdr
.fregmask
= val
;
3197 cur_proc_ptr
->pdr
.fregoffset
= get_absolute_expression ();
3199 demand_empty_rest_of_line ();
3202 /* Parse .frame directives. */
3205 ecoff_directive_frame (ignore
)
3210 if (cur_proc_ptr
== (proc_t
*) NULL
)
3212 as_warn (".frame outside of .ent");
3213 demand_empty_rest_of_line ();
3217 cur_proc_ptr
->pdr
.framereg
= tc_get_register (1);
3220 if (*input_line_pointer
++ != ','
3221 || get_absolute_expression_and_terminator (&val
) != ',')
3223 as_warn ("Bad .frame directive");
3224 --input_line_pointer
;
3225 demand_empty_rest_of_line ();
3229 cur_proc_ptr
->pdr
.frameoffset
= val
;
3231 cur_proc_ptr
->pdr
.pcreg
= tc_get_register (0);
3233 #if 0 /* Alpha-OSF1 adds "the offset of saved $a0 from $sp", according
3234 to Sandro. I don't yet know where this value should be stored, if
3236 demand_empty_rest_of_line ();
3242 /* Parse .mask directives. */
3245 ecoff_directive_mask (ignore
)
3250 if (cur_proc_ptr
== (proc_t
*) NULL
)
3252 as_warn (".mask outside of .ent");
3253 demand_empty_rest_of_line ();
3257 if (get_absolute_expression_and_terminator (&val
) != ',')
3259 as_warn ("Bad .mask directive");
3260 --input_line_pointer
;
3261 demand_empty_rest_of_line ();
3265 cur_proc_ptr
->pdr
.regmask
= val
;
3266 cur_proc_ptr
->pdr
.regoffset
= get_absolute_expression ();
3268 demand_empty_rest_of_line ();
3271 /* Parse .loc directives. */
3274 ecoff_directive_loc (ignore
)
3277 lineno_list_t
*list
;
3280 if (cur_file_ptr
== (efdr_t
*) NULL
)
3282 as_warn (".loc before .file");
3283 demand_empty_rest_of_line ();
3287 if (now_seg
!= text_section
)
3289 as_warn (".loc outside of .text");
3290 demand_empty_rest_of_line ();
3294 /* Skip the file number. */
3296 get_absolute_expression ();
3299 lineno
= get_absolute_expression ();
3303 listing_source_line (lineno
);
3306 /* If we're building stabs, then output a special label rather than
3307 ECOFF line number info. */
3310 (void) add_ecoff_symbol ((char *) NULL
, st_Label
, sc_Text
,
3311 symbol_new ("L0\001", now_seg
,
3312 (valueT
) frag_now_fix (),
3314 (bfd_vma
) 0, 0, lineno
);
3318 list
= allocate_lineno_list ();
3320 list
->next
= (lineno_list_t
*) NULL
;
3321 list
->file
= cur_file_ptr
;
3322 list
->proc
= cur_proc_ptr
;
3323 list
->frag
= frag_now
;
3324 list
->paddr
= frag_now_fix ();
3325 list
->lineno
= lineno
;
3327 /* A .loc directive will sometimes appear before a .ent directive,
3328 which means that cur_proc_ptr will be NULL here. Arrange to
3330 if (cur_proc_ptr
== (proc_t
*) NULL
)
3334 pl
= &noproc_lineno
;
3335 while (*pl
!= (lineno_list_t
*) NULL
)
3341 *last_lineno_ptr
= list
;
3342 last_lineno_ptr
= &list
->next
;
3346 /* Make sure the @stabs symbol is emitted. */
3354 /* Add a dummy @stabs dymbol. */
3356 (void) add_ecoff_symbol (stabs_symbol
, stNil
, scInfo
,
3358 (bfd_vma
) 0, (symint_t
) -1,
3359 ECOFF_MARK_STAB (0));
3363 /* Parse .weakext directives. */
3366 ecoff_directive_weakext (ignore
)
3374 name
= input_line_pointer
;
3375 c
= get_symbol_end ();
3376 symbolP
= symbol_find_or_make (name
);
3377 *input_line_pointer
= c
;
3383 if (S_IS_DEFINED (symbolP
))
3385 as_bad ("Ignoring attempt to redefine symbol `%s'.",
3386 S_GET_NAME (symbolP
));
3387 ignore_rest_of_line ();
3391 ++input_line_pointer
;
3393 if (! is_end_of_line
[(unsigned char) *input_line_pointer
])
3396 if (exp
.X_op
!= O_symbol
)
3398 as_bad ("bad .weakext directive");
3399 ignore_rest_of_line();
3402 symbolP
->sy_value
= exp
;
3406 S_SET_WEAK (symbolP
);
3408 demand_empty_rest_of_line ();
3411 /* Handle .stabs directives. The actual parsing routine is done by a
3412 generic routine. This routine is called via OBJ_PROCESS_STAB.
3413 When this is called, input_line_pointer will be pointing at the
3414 value field of the stab.
3416 .stabs directives have five fields:
3417 "string" a string, encoding the type information.
3418 code a numeric code, defined in <stab.h>
3420 desc a zero or line number
3421 value a numeric value or an address.
3423 If the value is relocatable, we transform this into:
3424 iss points as an index into string space
3425 value value from lookup of the name
3426 st st from lookup of the name
3427 sc sc from lookup of the name
3428 index code|CODE_MASK
3430 If the value is not relocatable, we transform this into:
3431 iss points as an index into string space
3435 index code|CODE_MASK
3437 .stabn directives have four fields (string is null):
3438 code a numeric code, defined in <stab.h>
3440 desc a zero or a line number
3441 value a numeric value or an address. */
3444 ecoff_stab (sec
, what
, string
, type
, other
, desc
)
3452 efdr_t
*save_file_ptr
= cur_file_ptr
;
3458 localsym_t
*hold
= NULL
;
3460 ecoff_debugging_seen
= 1;
3462 /* We don't handle .stabd. */
3463 if (what
!= 's' && what
!= 'n')
3465 as_bad (".stab%c is not supported", what
);
3469 /* A .stabn uses a null name, not an empty string. */
3473 /* We ignore the other field. */
3475 as_warn (".stab%c: ignoring non-zero other field", what
);
3477 /* Make sure we have a current file. */
3478 if (cur_file_ptr
== (efdr_t
*) NULL
)
3480 add_file ((const char *) NULL
, 0, 1);
3481 save_file_ptr
= cur_file_ptr
;
3484 /* For stabs in ECOFF, the first symbol must be @stabs. This is a
3486 if (stabs_seen
== 0)
3489 /* Line number stabs are handled differently, since they have two
3490 values, the line number and the address of the label. We use the
3491 index field (aka desc) to hold the line number, and the value
3492 field to hold the address. The symbol type is st_Label, which
3493 should be different from the other stabs, so that gdb can
3495 if (type
== N_SLINE
)
3503 listing_source_line ((unsigned int) desc
);
3506 dummy_symr
.index
= desc
;
3507 if (dummy_symr
.index
!= desc
)
3509 as_warn ("Line number (%d) for .stab%c directive cannot fit in index field (20 bits)",
3514 name
= input_line_pointer
;
3515 name_end
= get_symbol_end ();
3517 sym
= symbol_find_or_make (name
);
3518 *input_line_pointer
= name_end
;
3528 if (listing
&& (type
== N_SO
|| type
== N_SOL
))
3529 listing_source_file (string
);
3532 if (isdigit (*input_line_pointer
)
3533 || *input_line_pointer
== '-'
3534 || *input_line_pointer
== '+')
3538 sym
= (symbolS
*) NULL
;
3539 value
= get_absolute_expression ();
3541 else if (! is_name_beginner ((unsigned char) *input_line_pointer
))
3543 as_warn ("Illegal .stab%c directive, bad character", what
);
3558 name
= input_line_pointer
;
3559 name_end
= get_symbol_end ();
3560 sym
= symbol_find_or_make (name
);
3561 *input_line_pointer
= name_end
;
3565 sym
= symbol_find_or_make (string
);
3566 expression (&sym
->sy_value
);
3570 indx
= ECOFF_MARK_STAB (type
);
3573 /* Don't store the stabs symbol we are creating as the type of the
3574 ECOFF symbol. We want to compute the type of the ECOFF symbol
3576 if (sym
!= (symbolS
*) NULL
)
3577 hold
= sym
->ecoff_symbol
;
3579 (void) add_ecoff_symbol (string
, st
, sc
, sym
, (bfd_vma
) 0, value
, indx
);
3581 if (sym
!= (symbolS
*) NULL
)
3582 sym
->ecoff_symbol
= hold
;
3584 /* Restore normal file type. */
3585 cur_file_ptr
= save_file_ptr
;
3588 /* Frob an ECOFF symbol. Small common symbols go into a special
3589 .scommon section rather than bfd_com_section. */
3592 ecoff_frob_symbol (sym
)
3595 if (S_IS_COMMON (sym
)
3596 && S_GET_VALUE (sym
) > 0
3597 && S_GET_VALUE (sym
) <= bfd_get_gp_size (stdoutput
))
3599 static asection scom_section
;
3600 static asymbol scom_symbol
;
3602 /* We must construct a fake section similar to bfd_com_section
3603 but with the name .scommon. */
3604 if (scom_section
.name
== NULL
)
3606 scom_section
= bfd_com_section
;
3607 scom_section
.name
= ".scommon";
3608 scom_section
.output_section
= &scom_section
;
3609 scom_section
.symbol
= &scom_symbol
;
3610 scom_section
.symbol_ptr_ptr
= &scom_section
.symbol
;
3611 scom_symbol
= *bfd_com_section
.symbol
;
3612 scom_symbol
.name
= ".scommon";
3613 scom_symbol
.section
= &scom_section
;
3615 S_SET_SEGMENT (sym
, &scom_section
);
3618 /* Double check weak symbols. */
3619 if (sym
->bsym
->flags
& BSF_WEAK
)
3621 if (S_IS_COMMON (sym
))
3622 as_bad ("Symbol `%s' can not be both weak and common",
3627 /* Add bytes to the symbolic information buffer. */
3630 ecoff_add_bytes (buf
, bufend
, bufptr
, need
)
3640 need
-= *bufend
- bufptr
;
3641 if (need
< PAGE_SIZE
)
3643 want
= (*bufend
- *buf
) + need
;
3644 *buf
= xrealloc (*buf
, want
);
3645 *bufend
= *buf
+ want
;
3649 /* Adjust the symbolic information buffer to the alignment required
3650 for the ECOFF target debugging information. */
3652 static unsigned long
3653 ecoff_padding_adjust (backend
, buf
, bufend
, offset
, bufptrptr
)
3654 const struct ecoff_debug_swap
*backend
;
3657 unsigned long offset
;
3660 bfd_size_type align
;
3662 align
= backend
->debug_align
;
3663 if ((offset
& (align
- 1)) != 0)
3667 add
= align
- (offset
& (align
- 1));
3668 if (*bufend
- (*buf
+ offset
) < add
)
3669 (void) ecoff_add_bytes (buf
, bufend
, *buf
+ offset
, add
);
3670 memset (*buf
+ offset
, 0, add
);
3672 if (bufptrptr
!= (char **) NULL
)
3673 *bufptrptr
= *buf
+ offset
;
3679 /* Build the line number information. */
3681 static unsigned long
3682 ecoff_build_lineno (backend
, buf
, bufend
, offset
, linecntptr
)
3683 const struct ecoff_debug_swap
*backend
;
3686 unsigned long offset
;
3690 register lineno_list_t
*l
;
3691 lineno_list_t
*last
;
3697 lineno_list_t first
;
3699 if (linecntptr
!= (long *) NULL
)
3702 bufptr
= *buf
+ offset
;
3704 file
= (efdr_t
*) NULL
;
3705 proc
= (proc_t
*) NULL
;
3706 last
= (lineno_list_t
*) NULL
;
3711 /* For some reason the address of the first procedure is ignored
3712 when reading line numbers. This doesn't matter if the address of
3713 the first procedure is 0, but when gcc is generating MIPS
3714 embedded PIC code, it will put strings in the .text section
3715 before the first procedure. We cope by inserting a dummy line if
3716 the address of the first procedure is not 0. Hopefully this
3717 won't screw things up too badly. */
3718 if (first_proc_ptr
!= (proc_t
*) NULL
3719 && first_lineno
!= (lineno_list_t
*) NULL
3720 && ((S_GET_VALUE (first_proc_ptr
->sym
->as_sym
)
3721 + bfd_get_section_vma (stdoutput
,
3722 S_GET_SEGMENT (first_proc_ptr
->sym
->as_sym
)))
3725 first
.file
= first_lineno
->file
;
3726 first
.proc
= first_lineno
->proc
;
3727 first
.frag
= &zero_address_frag
;
3731 first
.next
= first_lineno
;
3732 first_lineno
= &first
;
3735 for (l
= first_lineno
; l
!= (lineno_list_t
*) NULL
; l
= l
->next
)
3740 /* Get the offset to the memory address of the next line number
3741 (in words). Do this first, so that we can skip ahead to the
3742 next useful line number entry. */
3743 if (l
->next
== (lineno_list_t
*) NULL
)
3745 /* We want a count of zero, but it will be decremented
3746 before it is used. */
3751 count
= ((l
->next
->frag
->fr_address
+ l
->next
->paddr
3752 - (l
->frag
->fr_address
+ l
->paddr
))
3756 /* Don't change last, so we still get the right delta. */
3761 if (l
->file
!= file
|| l
->proc
!= proc
)
3763 if (l
->proc
!= proc
&& proc
!= (proc_t
*) NULL
)
3764 proc
->pdr
.lnHigh
= last
->lineno
;
3765 if (l
->file
!= file
&& file
!= (efdr_t
*) NULL
)
3767 file
->fdr
.cbLine
= c
- file
->fdr
.cbLineOffset
;
3768 file
->fdr
.cline
= totcount
+ count
;
3769 if (linecntptr
!= (long *) NULL
)
3770 *linecntptr
+= totcount
+ count
;
3774 if (l
->file
!= file
)
3776 efdr_t
*last_file
= file
;
3779 if (last_file
!= (efdr_t
*) NULL
)
3781 = last_file
->fdr
.ilineBase
+ last_file
->fdr
.cline
;
3783 file
->fdr
.ilineBase
= 0;
3784 file
->fdr
.cbLineOffset
= c
;
3786 if (l
->proc
!= proc
)
3789 if (proc
!= (proc_t
*) NULL
)
3791 proc
->pdr
.lnLow
= l
->lineno
;
3792 proc
->pdr
.cbLineOffset
= c
- file
->fdr
.cbLineOffset
;
3793 proc
->pdr
.iline
= totcount
;
3797 last
= (lineno_list_t
*) NULL
;
3802 /* Get the offset to this line number. */
3803 if (last
== (lineno_list_t
*) NULL
)
3806 delta
= l
->lineno
- last
->lineno
;
3808 /* Put in the offset to this line number. */
3813 /* 1 is added to each count read. */
3815 /* We can only adjust the word count by up to 15 words at a
3827 if (delta
>= -7 && delta
<= 7)
3829 if (bufptr
>= *bufend
)
3830 bufptr
= ecoff_add_bytes (buf
, bufend
, bufptr
, (long) 1);
3831 *bufptr
++ = setcount
+ (delta
<< 4);
3839 if (*bufend
- bufptr
< 3)
3840 bufptr
= ecoff_add_bytes (buf
, bufend
, bufptr
, (long) 3);
3841 *bufptr
++ = setcount
+ (8 << 4);
3842 if (delta
< -0x8000)
3847 else if (delta
> 0x7fff)
3857 *bufptr
++ = set
>> 8;
3858 *bufptr
++ = set
& 0xffff;
3863 /* Finish adjusting the count. */
3866 if (bufptr
>= *bufend
)
3867 bufptr
= ecoff_add_bytes (buf
, bufend
, bufptr
, (long) 1);
3868 /* 1 is added to each count read. */
3887 if (proc
!= (proc_t
*) NULL
)
3888 proc
->pdr
.lnHigh
= last
->lineno
;
3889 if (file
!= (efdr_t
*) NULL
)
3891 file
->fdr
.cbLine
= c
- file
->fdr
.cbLineOffset
;
3892 file
->fdr
.cline
= totcount
;
3895 if (linecntptr
!= (long *) NULL
)
3896 *linecntptr
+= totcount
;
3898 c
= ecoff_padding_adjust (backend
, buf
, bufend
, c
, &bufptr
);
3903 /* Build and swap out the symbols. */
3905 static unsigned long
3906 ecoff_build_symbols (backend
, buf
, bufend
, offset
)
3907 const struct ecoff_debug_swap
*backend
;
3910 unsigned long offset
;
3912 const bfd_size_type external_sym_size
= backend
->external_sym_size
;
3913 void (* const swap_sym_out
) PARAMS ((bfd
*, const SYMR
*, PTR
))
3914 = backend
->swap_sym_out
;
3917 vlinks_t
*file_link
;
3919 sym_out
= *buf
+ offset
;
3923 /* The symbols are stored by file. */
3924 for (file_link
= file_desc
.first
;
3925 file_link
!= (vlinks_t
*) NULL
;
3926 file_link
= file_link
->next
)
3933 if (file_link
->next
== (vlinks_t
*) NULL
)
3934 fil_cnt
= file_desc
.objects_last_page
;
3936 fil_cnt
= file_desc
.objects_per_page
;
3937 fil_ptr
= file_link
->datum
->file
;
3938 fil_end
= fil_ptr
+ fil_cnt
;
3939 for (; fil_ptr
< fil_end
; fil_ptr
++)
3943 fil_ptr
->fdr
.isymBase
= isym
;
3945 for (sym_link
= fil_ptr
->symbols
.first
;
3946 sym_link
!= (vlinks_t
*) NULL
;
3947 sym_link
= sym_link
->next
)
3950 localsym_t
*sym_ptr
;
3951 localsym_t
*sym_end
;
3953 if (sym_link
->next
== (vlinks_t
*) NULL
)
3954 sym_cnt
= fil_ptr
->symbols
.objects_last_page
;
3956 sym_cnt
= fil_ptr
->symbols
.objects_per_page
;
3957 sym_ptr
= sym_link
->datum
->sym
;
3958 sym_end
= sym_ptr
+ sym_cnt
;
3959 for (; sym_ptr
< sym_end
; sym_ptr
++)
3965 know (sym_ptr
->file_ptr
== fil_ptr
);
3967 /* If there is no associated gas symbol, then this
3968 is a pure debugging symbol. We have already
3969 added the name (if any) to fil_ptr->strings.
3970 Otherwise we must decide whether this is an
3971 external or a local symbol (actually, it may be
3972 both if the local provides additional debugging
3973 information for the external). */
3975 as_sym
= sym_ptr
->as_sym
;
3976 if (as_sym
!= (symbolS
*) NULL
)
3980 /* The value of a block start symbol is the
3981 offset from the start of the procedure. For
3982 other symbols we just use the gas value (but
3983 we must offset it by the vma of the section,
3984 just as BFD does, because BFD will not see
3986 if (sym_ptr
->ecoff_sym
.asym
.st
== (int) st_Block
3987 && sym_ptr
->ecoff_sym
.asym
.sc
== (int) sc_Text
)
3991 know (sym_ptr
->proc_ptr
!= (proc_t
*) NULL
);
3992 begin_sym
= sym_ptr
->proc_ptr
->sym
->as_sym
;
3993 if (S_GET_SEGMENT (as_sym
)
3994 != S_GET_SEGMENT (begin_sym
))
3995 as_warn (".begin/.bend in different segments");
3996 sym_ptr
->ecoff_sym
.asym
.value
=
3997 S_GET_VALUE (as_sym
) - S_GET_VALUE (begin_sym
);
4000 sym_ptr
->ecoff_sym
.asym
.value
=
4001 (S_GET_VALUE (as_sym
)
4002 + bfd_get_section_vma (stdoutput
,
4003 S_GET_SEGMENT (as_sym
))
4006 sym_ptr
->ecoff_sym
.weakext
= S_IS_WEAK (as_sym
);
4008 /* Set st_Proc to st_StaticProc for local
4010 if (sym_ptr
->ecoff_sym
.asym
.st
== st_Proc
4011 && S_IS_DEFINED (as_sym
)
4012 && ! S_IS_EXTERNAL (as_sym
)
4013 && ! S_IS_WEAK (as_sym
))
4014 sym_ptr
->ecoff_sym
.asym
.st
= st_StaticProc
;
4016 /* Get the type and storage class based on where
4017 the symbol actually wound up. Traditionally,
4018 N_LBRAC and N_RBRAC are *not* relocated. */
4019 indx
= sym_ptr
->ecoff_sym
.asym
.index
;
4020 if (sym_ptr
->ecoff_sym
.asym
.st
== st_Nil
4021 && sym_ptr
->ecoff_sym
.asym
.sc
== sc_Nil
4022 && (! ECOFF_IS_STAB (&sym_ptr
->ecoff_sym
.asym
)
4023 || ((ECOFF_UNMARK_STAB (indx
) != N_LBRAC
)
4024 && (ECOFF_UNMARK_STAB (indx
) != N_RBRAC
))))
4027 const char *segname
;
4031 seg
= S_GET_SEGMENT (as_sym
);
4032 segname
= segment_name (seg
);
4034 if (! ECOFF_IS_STAB (&sym_ptr
->ecoff_sym
.asym
)
4035 && (S_IS_EXTERNAL (as_sym
)
4036 || S_IS_WEAK (as_sym
)
4037 || ! S_IS_DEFINED (as_sym
)))
4039 if ((as_sym
->bsym
->flags
& BSF_FUNCTION
) != 0)
4044 else if (seg
== text_section
)
4049 if (! S_IS_DEFINED (as_sym
))
4051 if (as_sym
->ecoff_extern_size
== 0
4052 || (as_sym
->ecoff_extern_size
4053 > bfd_get_gp_size (stdoutput
)))
4058 sym_ptr
->ecoff_sym
.asym
.value
=
4059 as_sym
->ecoff_extern_size
;
4062 else if (S_IS_COMMON (as_sym
))
4064 if (S_GET_VALUE (as_sym
) > 0
4065 && (S_GET_VALUE (as_sym
)
4066 <= bfd_get_gp_size (stdoutput
)))
4071 else if (seg
== text_section
)
4073 else if (seg
== data_section
)
4075 else if (strcmp (segname
, ".rdata") == 0
4076 || strcmp (segname
, ".rodata") == 0)
4078 else if (strcmp (segname
, ".sdata") == 0)
4080 else if (seg
== bss_section
)
4082 else if (strcmp (segname
, ".sbss") == 0)
4084 else if (seg
== &bfd_abs_section
)
4088 /* This must be a user named section.
4089 This is not possible in ECOFF, but it
4094 sym_ptr
->ecoff_sym
.asym
.st
= (int) st
;
4095 sym_ptr
->ecoff_sym
.asym
.sc
= (int) sc
;
4098 /* This is just an external symbol if it is
4099 outside a procedure and it has a type.
4100 FIXME: g++ will generate symbols which have
4101 different names in the debugging information
4102 than the actual symbol. Should we handle
4104 if ((S_IS_EXTERNAL (as_sym
)
4105 || S_IS_WEAK (as_sym
)
4106 || ! S_IS_DEFINED (as_sym
))
4107 && sym_ptr
->proc_ptr
== (proc_t
*) NULL
4108 && sym_ptr
->ecoff_sym
.asym
.st
!= (int) st_Nil
4109 && ! ECOFF_IS_STAB (&sym_ptr
->ecoff_sym
.asym
))
4112 /* If an st_end symbol has an associated gas
4113 symbol, then it is a local label created for
4114 a .bend or .end directive. Stabs line
4115 numbers will have \001 in the names. */
4117 && sym_ptr
->ecoff_sym
.asym
.st
!= st_End
4118 && strchr (sym_ptr
->name
, '\001') == 0)
4119 sym_ptr
->ecoff_sym
.asym
.iss
=
4120 add_string (&fil_ptr
->strings
,
4126 /* We now know the index of this symbol; fill in
4127 locations that have been waiting for that
4129 if (sym_ptr
->begin_ptr
!= (localsym_t
*) NULL
)
4131 localsym_t
*begin_ptr
;
4135 begin_ptr
= sym_ptr
->begin_ptr
;
4136 know (begin_ptr
->sym_index
!= -1);
4137 sym_ptr
->ecoff_sym
.asym
.index
= begin_ptr
->sym_index
;
4138 if (sym_ptr
->ecoff_sym
.asym
.sc
!= (int) sc_Info
)
4139 sym_ptr
->ecoff_sym
.asym
.iss
=
4140 begin_ptr
->ecoff_sym
.asym
.iss
;
4142 begin_type
= begin_ptr
->ecoff_sym
.asym
.st
;
4143 if (begin_type
== st_File
4144 || begin_type
== st_Block
)
4146 begin_ptr
->ecoff_sym
.asym
.index
=
4147 isym
- ifilesym
+ 1;
4148 (*swap_sym_out
) (stdoutput
,
4149 &begin_ptr
->ecoff_sym
.asym
,
4152 + (begin_ptr
->sym_index
4153 * external_sym_size
)));
4157 know (begin_ptr
->index_ptr
!= (aux_t
*) NULL
);
4158 begin_ptr
->index_ptr
->data
.isym
=
4159 isym
- ifilesym
+ 1;
4162 /* The value of the symbol marking the end of a
4163 procedure is the size of the procedure. The
4164 value of the symbol marking the end of a
4165 block is the offset from the start of the
4166 procedure to the block. */
4167 if (begin_type
== st_Proc
4168 || begin_type
== st_StaticProc
)
4170 know (as_sym
!= (symbolS
*) NULL
);
4171 know (begin_ptr
->as_sym
!= (symbolS
*) NULL
);
4172 if (S_GET_SEGMENT (as_sym
)
4173 != S_GET_SEGMENT (begin_ptr
->as_sym
))
4174 as_warn (".begin/.bend in different segments");
4175 sym_ptr
->ecoff_sym
.asym
.value
=
4176 (S_GET_VALUE (as_sym
)
4177 - S_GET_VALUE (begin_ptr
->as_sym
));
4179 else if (begin_type
== st_Block
4180 && sym_ptr
->ecoff_sym
.asym
.sc
!= (int) sc_Info
)
4184 know (as_sym
!= (symbolS
*) NULL
);
4185 know (sym_ptr
->proc_ptr
!= (proc_t
*) NULL
);
4186 begin_sym
= sym_ptr
->proc_ptr
->sym
->as_sym
;
4187 if (S_GET_SEGMENT (as_sym
)
4188 != S_GET_SEGMENT (begin_sym
))
4189 as_warn (".begin/.bend in different segments");
4190 sym_ptr
->ecoff_sym
.asym
.value
=
4191 S_GET_VALUE (as_sym
) - S_GET_VALUE (begin_sym
);
4195 for (f
= sym_ptr
->forward_ref
;
4196 f
!= (forward_t
*) NULL
;
4200 f
->ifd_ptr
->data
.isym
= fil_ptr
->file_index
;
4201 f
->index_ptr
->data
.rndx
.index
= isym
- ifilesym
;
4206 if (*bufend
- sym_out
< external_sym_size
)
4207 sym_out
= ecoff_add_bytes (buf
, bufend
,
4210 (*swap_sym_out
) (stdoutput
, &sym_ptr
->ecoff_sym
.asym
,
4212 sym_out
+= external_sym_size
;
4214 sym_ptr
->sym_index
= isym
;
4216 if (sym_ptr
->proc_ptr
!= (proc_t
*) NULL
4217 && sym_ptr
->proc_ptr
->sym
== sym_ptr
)
4218 sym_ptr
->proc_ptr
->pdr
.isym
= isym
- ifilesym
;
4223 /* Record the local symbol index and file number in
4224 case this is an external symbol. Note that this
4225 destroys the asym.index field. */
4226 if (as_sym
!= (symbolS
*) NULL
4227 && as_sym
->ecoff_symbol
== sym_ptr
)
4229 if ((sym_ptr
->ecoff_sym
.asym
.st
== st_Proc
4230 || sym_ptr
->ecoff_sym
.asym
.st
== st_StaticProc
)
4232 sym_ptr
->ecoff_sym
.asym
.index
= isym
- ifilesym
- 1;
4233 sym_ptr
->ecoff_sym
.ifd
= fil_ptr
->file_index
;
4237 fil_ptr
->fdr
.csym
= isym
- fil_ptr
->fdr
.isymBase
;
4241 return offset
+ isym
* external_sym_size
;
4244 /* Swap out the procedure information. */
4246 static unsigned long
4247 ecoff_build_procs (backend
, buf
, bufend
, offset
)
4248 const struct ecoff_debug_swap
*backend
;
4251 unsigned long offset
;
4253 const bfd_size_type external_pdr_size
= backend
->external_pdr_size
;
4254 void (* const swap_pdr_out
) PARAMS ((bfd
*, const PDR
*, PTR
))
4255 = backend
->swap_pdr_out
;
4258 vlinks_t
*file_link
;
4260 pdr_out
= *buf
+ offset
;
4264 /* The procedures are stored by file. */
4265 for (file_link
= file_desc
.first
;
4266 file_link
!= (vlinks_t
*) NULL
;
4267 file_link
= file_link
->next
)
4273 if (file_link
->next
== (vlinks_t
*) NULL
)
4274 fil_cnt
= file_desc
.objects_last_page
;
4276 fil_cnt
= file_desc
.objects_per_page
;
4277 fil_ptr
= file_link
->datum
->file
;
4278 fil_end
= fil_ptr
+ fil_cnt
;
4279 for (; fil_ptr
< fil_end
; fil_ptr
++)
4281 vlinks_t
*proc_link
;
4284 fil_ptr
->fdr
.ipdFirst
= iproc
;
4286 for (proc_link
= fil_ptr
->procs
.first
;
4287 proc_link
!= (vlinks_t
*) NULL
;
4288 proc_link
= proc_link
->next
)
4294 if (proc_link
->next
== (vlinks_t
*) NULL
)
4295 prc_cnt
= fil_ptr
->procs
.objects_last_page
;
4297 prc_cnt
= fil_ptr
->procs
.objects_per_page
;
4298 proc_ptr
= proc_link
->datum
->proc
;
4299 proc_end
= proc_ptr
+ prc_cnt
;
4300 for (; proc_ptr
< proc_end
; proc_ptr
++)
4305 adr_sym
= proc_ptr
->sym
->as_sym
;
4306 adr
= (S_GET_VALUE (adr_sym
)
4307 + bfd_get_section_vma (stdoutput
,
4308 S_GET_SEGMENT (adr_sym
)));
4311 /* This code used to force the adr of the very
4312 first fdr to be 0. However, the native tools
4313 don't do that, and I can't remember why it
4314 used to work that way, so I took it out. */
4315 fil_ptr
->fdr
.adr
= adr
;
4318 proc_ptr
->pdr
.adr
= adr
- fil_ptr
->fdr
.adr
;
4319 if (*bufend
- pdr_out
< external_pdr_size
)
4320 pdr_out
= ecoff_add_bytes (buf
, bufend
,
4323 (*swap_pdr_out
) (stdoutput
, &proc_ptr
->pdr
, pdr_out
);
4324 pdr_out
+= external_pdr_size
;
4328 fil_ptr
->fdr
.cpd
= iproc
- fil_ptr
->fdr
.ipdFirst
;
4332 return offset
+ iproc
* external_pdr_size
;
4335 /* Swap out the aux information. */
4337 static unsigned long
4338 ecoff_build_aux (backend
, buf
, bufend
, offset
)
4339 const struct ecoff_debug_swap
*backend
;
4342 unsigned long offset
;
4345 union aux_ext
*aux_out
;
4347 vlinks_t
*file_link
;
4349 bigendian
= bfd_big_endian (stdoutput
);
4351 aux_out
= (union aux_ext
*) (*buf
+ offset
);
4355 /* The aux entries are stored by file. */
4356 for (file_link
= file_desc
.first
;
4357 file_link
!= (vlinks_t
*) NULL
;
4358 file_link
= file_link
->next
)
4364 if (file_link
->next
== (vlinks_t
*) NULL
)
4365 fil_cnt
= file_desc
.objects_last_page
;
4367 fil_cnt
= file_desc
.objects_per_page
;
4368 fil_ptr
= file_link
->datum
->file
;
4369 fil_end
= fil_ptr
+ fil_cnt
;
4370 for (; fil_ptr
< fil_end
; fil_ptr
++)
4374 fil_ptr
->fdr
.fBigendian
= bigendian
;
4375 fil_ptr
->fdr
.iauxBase
= iaux
;
4376 for (aux_link
= fil_ptr
->aux_syms
.first
;
4377 aux_link
!= (vlinks_t
*) NULL
;
4378 aux_link
= aux_link
->next
)
4384 if (aux_link
->next
== (vlinks_t
*) NULL
)
4385 aux_cnt
= fil_ptr
->aux_syms
.objects_last_page
;
4387 aux_cnt
= fil_ptr
->aux_syms
.objects_per_page
;
4388 aux_ptr
= aux_link
->datum
->aux
;
4389 aux_end
= aux_ptr
+ aux_cnt
;
4390 for (; aux_ptr
< aux_end
; aux_ptr
++)
4392 if (*bufend
- (char *) aux_out
< sizeof (union aux_ext
))
4393 aux_out
= ((union aux_ext
*)
4394 ecoff_add_bytes (buf
, bufend
,
4396 sizeof (union aux_ext
)));
4397 switch (aux_ptr
->type
)
4400 (*backend
->swap_tir_out
) (bigendian
,
4405 (*backend
->swap_rndx_out
) (bigendian
,
4406 &aux_ptr
->data
.rndx
,
4410 AUX_PUT_DNLOW (bigendian
, aux_ptr
->data
.dnLow
,
4414 AUX_PUT_DNHIGH (bigendian
, aux_ptr
->data
.dnHigh
,
4418 AUX_PUT_ISYM (bigendian
, aux_ptr
->data
.isym
,
4422 AUX_PUT_ISS (bigendian
, aux_ptr
->data
.iss
,
4426 AUX_PUT_WIDTH (bigendian
, aux_ptr
->data
.width
,
4430 AUX_PUT_COUNT (bigendian
, aux_ptr
->data
.count
,
4439 fil_ptr
->fdr
.caux
= iaux
- fil_ptr
->fdr
.iauxBase
;
4443 return ecoff_padding_adjust (backend
, buf
, bufend
,
4444 offset
+ iaux
* sizeof (union aux_ext
),
4448 /* Copy out the strings from a varray_t. This returns the number of
4449 bytes copied, rather than the new offset. */
4451 static unsigned long
4452 ecoff_build_strings (buf
, bufend
, offset
, vp
)
4455 unsigned long offset
;
4462 str_out
= *buf
+ offset
;
4466 for (str_link
= vp
->first
;
4467 str_link
!= (vlinks_t
*) NULL
;
4468 str_link
= str_link
->next
)
4470 unsigned long str_cnt
;
4472 if (str_link
->next
== (vlinks_t
*) NULL
)
4473 str_cnt
= vp
->objects_last_page
;
4475 str_cnt
= vp
->objects_per_page
;
4477 if (*bufend
- str_out
< str_cnt
)
4478 str_out
= ecoff_add_bytes (buf
, bufend
, str_out
, str_cnt
);
4480 memcpy (str_out
, str_link
->datum
->byte
, str_cnt
);
4488 /* Dump out the local strings. */
4490 static unsigned long
4491 ecoff_build_ss (backend
, buf
, bufend
, offset
)
4492 const struct ecoff_debug_swap
*backend
;
4495 unsigned long offset
;
4498 vlinks_t
*file_link
;
4502 for (file_link
= file_desc
.first
;
4503 file_link
!= (vlinks_t
*) NULL
;
4504 file_link
= file_link
->next
)
4510 if (file_link
->next
== (vlinks_t
*) NULL
)
4511 fil_cnt
= file_desc
.objects_last_page
;
4513 fil_cnt
= file_desc
.objects_per_page
;
4514 fil_ptr
= file_link
->datum
->file
;
4515 fil_end
= fil_ptr
+ fil_cnt
;
4516 for (; fil_ptr
< fil_end
; fil_ptr
++)
4520 fil_ptr
->fdr
.issBase
= iss
;
4521 ss_cnt
= ecoff_build_strings (buf
, bufend
, offset
+ iss
,
4523 fil_ptr
->fdr
.cbSs
= ss_cnt
;
4528 return ecoff_padding_adjust (backend
, buf
, bufend
, offset
+ iss
,
4532 /* Swap out the file descriptors. */
4534 static unsigned long
4535 ecoff_build_fdr (backend
, buf
, bufend
, offset
)
4536 const struct ecoff_debug_swap
*backend
;
4539 unsigned long offset
;
4541 const bfd_size_type external_fdr_size
= backend
->external_fdr_size
;
4542 void (* const swap_fdr_out
) PARAMS ((bfd
*, const FDR
*, PTR
))
4543 = backend
->swap_fdr_out
;
4546 vlinks_t
*file_link
;
4550 fdr_out
= *buf
+ offset
;
4552 for (file_link
= file_desc
.first
;
4553 file_link
!= (vlinks_t
*) NULL
;
4554 file_link
= file_link
->next
)
4560 if (file_link
->next
== (vlinks_t
*) NULL
)
4561 fil_cnt
= file_desc
.objects_last_page
;
4563 fil_cnt
= file_desc
.objects_per_page
;
4564 fil_ptr
= file_link
->datum
->file
;
4565 fil_end
= fil_ptr
+ fil_cnt
;
4566 for (; fil_ptr
< fil_end
; fil_ptr
++)
4568 if (*bufend
- fdr_out
< external_fdr_size
)
4569 fdr_out
= ecoff_add_bytes (buf
, bufend
, fdr_out
,
4571 (*swap_fdr_out
) (stdoutput
, &fil_ptr
->fdr
, fdr_out
);
4572 fdr_out
+= external_fdr_size
;
4577 return offset
+ ifile
* external_fdr_size
;
4580 /* Set up the external symbols. These are supposed to be handled by
4581 the backend. This routine just gets the right information and
4582 calls a backend function to deal with it. */
4587 register symbolS
*sym
;
4589 for (sym
= symbol_rootP
; sym
!= (symbolS
*) NULL
; sym
= symbol_next (sym
))
4591 if (sym
->ecoff_symbol
== NULL
)
4594 /* If this is a local symbol, then force the fields to zero. */
4595 if (! S_IS_EXTERNAL (sym
)
4596 && ! S_IS_WEAK (sym
)
4597 && S_IS_DEFINED (sym
))
4599 sym
->ecoff_symbol
->ecoff_sym
.asym
.value
= 0;
4600 sym
->ecoff_symbol
->ecoff_sym
.asym
.st
= (int) st_Nil
;
4601 sym
->ecoff_symbol
->ecoff_sym
.asym
.sc
= (int) sc_Nil
;
4602 sym
->ecoff_symbol
->ecoff_sym
.asym
.index
= indexNil
;
4605 obj_ecoff_set_ext (sym
, &sym
->ecoff_symbol
->ecoff_sym
);
4609 /* Build the ECOFF debugging information. */
4612 ecoff_build_debug (hdr
, bufp
, backend
)
4615 const struct ecoff_debug_swap
*backend
;
4617 const bfd_size_type external_pdr_size
= backend
->external_pdr_size
;
4622 efdr_t
*hold_file_ptr
;
4623 proc_t
* hold_proc_ptr
;
4627 unsigned long offset
;
4629 /* Make sure we have a file. */
4630 if (first_file
== (efdr_t
*) NULL
)
4631 add_file ((const char *) NULL
, 0, 1);
4633 /* Handle any top level tags. */
4634 for (ptag
= top_tag_head
->first_tag
;
4635 ptag
!= (tag_t
*) NULL
;
4638 if (ptag
->forward_ref
!= (forward_t
*) NULL
)
4639 add_unknown_tag (ptag
);
4641 ptag_next
= ptag
->same_block
;
4642 ptag
->hash_ptr
->tag_ptr
= ptag
->same_name
;
4646 free_thead (top_tag_head
);
4648 /* Look through the symbols. Add debugging information for each
4649 symbol that has not already received it. */
4650 hold_file_ptr
= cur_file_ptr
;
4651 hold_proc_ptr
= cur_proc_ptr
;
4652 cur_proc_ptr
= (proc_t
*) NULL
;
4653 for (sym
= symbol_rootP
; sym
!= (symbolS
*) NULL
; sym
= symbol_next (sym
))
4655 if (sym
->ecoff_symbol
!= NULL
4656 || sym
->ecoff_file
== (efdr_t
*) NULL
4657 || (sym
->bsym
->flags
& BSF_SECTION_SYM
) != 0)
4660 cur_file_ptr
= sym
->ecoff_file
;
4661 add_ecoff_symbol ((const char *) NULL
, st_Nil
, sc_Nil
, sym
,
4662 (bfd_vma
) 0, S_GET_VALUE (sym
), indexNil
);
4664 cur_proc_ptr
= hold_proc_ptr
;
4665 cur_file_ptr
= hold_file_ptr
;
4667 /* Output an ending symbol for all the files. We have to do this
4668 here for the last file, so we may as well do it for all of the
4671 for (fil_ptr
= first_file
;
4672 fil_ptr
!= (efdr_t
*) NULL
;
4673 fil_ptr
= fil_ptr
->next_file
)
4675 cur_file_ptr
= fil_ptr
;
4676 while (cur_file_ptr
->cur_scope
!= (scope_t
*) NULL
4677 && cur_file_ptr
->cur_scope
->prev
!= (scope_t
*) NULL
)
4679 cur_file_ptr
->cur_scope
= cur_file_ptr
->cur_scope
->prev
;
4680 if (! end_warning
&& ! cur_file_ptr
->fake
)
4682 as_warn ("Missing .end or .bend at end of file");
4686 if (cur_file_ptr
->cur_scope
!= (scope_t
*) NULL
)
4687 (void) add_ecoff_symbol ((const char *) NULL
,
4695 /* Build the symbolic information. */
4697 buf
= xmalloc (PAGE_SIZE
);
4698 bufend
= buf
+ PAGE_SIZE
;
4700 /* Build the line number information. */
4701 hdr
->cbLineOffset
= offset
;
4702 offset
= ecoff_build_lineno (backend
, &buf
, &bufend
, offset
,
4704 hdr
->cbLine
= offset
- hdr
->cbLineOffset
;
4706 /* We don't use dense numbers at all. */
4708 hdr
->cbDnOffset
= 0;
4710 /* We can't build the PDR table until we have built the symbols,
4711 because a PDR contains a symbol index. However, we set aside
4712 space at this point. */
4713 hdr
->ipdMax
= proc_cnt
;
4714 hdr
->cbPdOffset
= offset
;
4715 if (bufend
- (buf
+ offset
) < proc_cnt
* external_pdr_size
)
4716 (void) ecoff_add_bytes (&buf
, &bufend
, buf
+ offset
,
4717 proc_cnt
* external_pdr_size
);
4718 offset
+= proc_cnt
* external_pdr_size
;
4720 /* Build the local symbols. */
4721 hdr
->cbSymOffset
= offset
;
4722 offset
= ecoff_build_symbols (backend
, &buf
, &bufend
, offset
);
4723 hdr
->isymMax
= (offset
- hdr
->cbSymOffset
) / backend
->external_sym_size
;
4725 /* Building the symbols initializes the symbol index in the PDR's.
4726 Now we can swap out the PDR's. */
4727 (void) ecoff_build_procs (backend
, &buf
, &bufend
, hdr
->cbPdOffset
);
4729 /* We don't use optimization symbols. */
4731 hdr
->cbOptOffset
= 0;
4733 /* Swap out the auxiliary type information. */
4734 hdr
->cbAuxOffset
= offset
;
4735 offset
= ecoff_build_aux (backend
, &buf
, &bufend
, offset
);
4736 hdr
->iauxMax
= (offset
- hdr
->cbAuxOffset
) / sizeof (union aux_ext
);
4738 /* Copy out the local strings. */
4739 hdr
->cbSsOffset
= offset
;
4740 offset
= ecoff_build_ss (backend
, &buf
, &bufend
, offset
);
4741 hdr
->issMax
= offset
- hdr
->cbSsOffset
;
4743 /* We don't use relative file descriptors. */
4745 hdr
->cbRfdOffset
= 0;
4747 /* Swap out the file descriptors. */
4748 hdr
->cbFdOffset
= offset
;
4749 offset
= ecoff_build_fdr (backend
, &buf
, &bufend
, offset
);
4750 hdr
->ifdMax
= (offset
- hdr
->cbFdOffset
) / backend
->external_fdr_size
;
4752 /* Set up the external symbols, which are handled by the BFD back
4755 hdr
->cbSsExtOffset
= 0;
4757 hdr
->cbExtOffset
= 0;
4760 know ((offset
& (backend
->debug_align
- 1)) == 0);
4762 /* FIXME: This value should be determined from the .verstamp directive,
4763 with reasonable defaults in config files. */
4765 hdr
->vstamp
= 0x030b;
4767 hdr
->vstamp
= 0x020b;
4774 /* Allocate a cluster of pages. */
4776 #ifndef MALLOC_CHECK
4779 allocate_cluster (npages
)
4780 unsigned long npages
;
4782 register page_t
*value
= (page_t
*) xmalloc (npages
* PAGE_USIZE
);
4786 fprintf (stderr
, "\talloc\tnpages = %d, value = 0x%.8x\n", npages
, value
);
4789 memset (value
, 0, npages
* PAGE_USIZE
);
4795 static page_t
*cluster_ptr
= NULL
;
4796 static unsigned long pages_left
= 0;
4798 #endif /* MALLOC_CHECK */
4800 /* Allocate one page (which is initialized to 0). */
4805 #ifndef MALLOC_CHECK
4807 if (pages_left
== 0)
4809 pages_left
= MAX_CLUSTER_PAGES
;
4810 cluster_ptr
= allocate_cluster (pages_left
);
4814 return cluster_ptr
++;
4816 #else /* MALLOC_CHECK */
4820 ptr
= xmalloc (PAGE_USIZE
);
4821 memset (ptr
, 0, PAGE_USIZE
);
4824 #endif /* MALLOC_CHECK */
4827 /* Allocate scoping information. */
4832 register scope_t
*ptr
;
4833 static scope_t initial_scope
;
4835 #ifndef MALLOC_CHECK
4837 ptr
= alloc_counts
[(int)alloc_type_scope
].free_list
.f_scope
;
4838 if (ptr
!= (scope_t
*) NULL
)
4839 alloc_counts
[ (int)alloc_type_scope
].free_list
.f_scope
= ptr
->free
;
4842 register int unallocated
= alloc_counts
[(int)alloc_type_scope
].unallocated
;
4843 register page_t
*cur_page
= alloc_counts
[(int)alloc_type_scope
].cur_page
;
4845 if (unallocated
== 0)
4847 unallocated
= PAGE_SIZE
/ sizeof (scope_t
);
4848 alloc_counts
[(int)alloc_type_scope
].cur_page
= cur_page
= allocate_page ();
4849 alloc_counts
[(int)alloc_type_scope
].total_pages
++;
4852 ptr
= &cur_page
->scope
[--unallocated
];
4853 alloc_counts
[(int)alloc_type_scope
].unallocated
= unallocated
;
4858 ptr
= (scope_t
*) xmalloc (sizeof (scope_t
));
4862 alloc_counts
[(int)alloc_type_scope
].total_alloc
++;
4863 *ptr
= initial_scope
;
4867 /* Free scoping information. */
4873 alloc_counts
[(int)alloc_type_scope
].total_free
++;
4875 #ifndef MALLOC_CHECK
4876 ptr
->free
= alloc_counts
[(int)alloc_type_scope
].free_list
.f_scope
;
4877 alloc_counts
[(int)alloc_type_scope
].free_list
.f_scope
= ptr
;
4883 /* Allocate links for pages in a virtual array. */
4888 register vlinks_t
*ptr
;
4889 static vlinks_t initial_vlinks
;
4891 #ifndef MALLOC_CHECK
4893 register int unallocated
= alloc_counts
[(int)alloc_type_vlinks
].unallocated
;
4894 register page_t
*cur_page
= alloc_counts
[(int)alloc_type_vlinks
].cur_page
;
4896 if (unallocated
== 0)
4898 unallocated
= PAGE_SIZE
/ sizeof (vlinks_t
);
4899 alloc_counts
[(int)alloc_type_vlinks
].cur_page
= cur_page
= allocate_page ();
4900 alloc_counts
[(int)alloc_type_vlinks
].total_pages
++;
4903 ptr
= &cur_page
->vlinks
[--unallocated
];
4904 alloc_counts
[(int)alloc_type_vlinks
].unallocated
= unallocated
;
4908 ptr
= (vlinks_t
*) xmalloc (sizeof (vlinks_t
));
4912 alloc_counts
[(int)alloc_type_vlinks
].total_alloc
++;
4913 *ptr
= initial_vlinks
;
4917 /* Allocate string hash buckets. */
4922 register shash_t
*ptr
;
4923 static shash_t initial_shash
;
4925 #ifndef MALLOC_CHECK
4927 register int unallocated
= alloc_counts
[(int)alloc_type_shash
].unallocated
;
4928 register page_t
*cur_page
= alloc_counts
[(int)alloc_type_shash
].cur_page
;
4930 if (unallocated
== 0)
4932 unallocated
= PAGE_SIZE
/ sizeof (shash_t
);
4933 alloc_counts
[(int)alloc_type_shash
].cur_page
= cur_page
= allocate_page ();
4934 alloc_counts
[(int)alloc_type_shash
].total_pages
++;
4937 ptr
= &cur_page
->shash
[--unallocated
];
4938 alloc_counts
[(int)alloc_type_shash
].unallocated
= unallocated
;
4942 ptr
= (shash_t
*) xmalloc (sizeof (shash_t
));
4946 alloc_counts
[(int)alloc_type_shash
].total_alloc
++;
4947 *ptr
= initial_shash
;
4951 /* Allocate type hash buckets. */
4956 register thash_t
*ptr
;
4957 static thash_t initial_thash
;
4959 #ifndef MALLOC_CHECK
4961 register int unallocated
= alloc_counts
[(int)alloc_type_thash
].unallocated
;
4962 register page_t
*cur_page
= alloc_counts
[(int)alloc_type_thash
].cur_page
;
4964 if (unallocated
== 0)
4966 unallocated
= PAGE_SIZE
/ sizeof (thash_t
);
4967 alloc_counts
[(int)alloc_type_thash
].cur_page
= cur_page
= allocate_page ();
4968 alloc_counts
[(int)alloc_type_thash
].total_pages
++;
4971 ptr
= &cur_page
->thash
[--unallocated
];
4972 alloc_counts
[(int)alloc_type_thash
].unallocated
= unallocated
;
4976 ptr
= (thash_t
*) xmalloc (sizeof (thash_t
));
4980 alloc_counts
[(int)alloc_type_thash
].total_alloc
++;
4981 *ptr
= initial_thash
;
4985 /* Allocate structure, union, or enum tag information. */
4990 register tag_t
*ptr
;
4991 static tag_t initial_tag
;
4993 #ifndef MALLOC_CHECK
4995 ptr
= alloc_counts
[(int)alloc_type_tag
].free_list
.f_tag
;
4996 if (ptr
!= (tag_t
*) NULL
)
4997 alloc_counts
[(int)alloc_type_tag
].free_list
.f_tag
= ptr
->free
;
5000 register int unallocated
= alloc_counts
[(int)alloc_type_tag
].unallocated
;
5001 register page_t
*cur_page
= alloc_counts
[(int)alloc_type_tag
].cur_page
;
5003 if (unallocated
== 0)
5005 unallocated
= PAGE_SIZE
/ sizeof (tag_t
);
5006 alloc_counts
[(int)alloc_type_tag
].cur_page
= cur_page
= allocate_page ();
5007 alloc_counts
[(int)alloc_type_tag
].total_pages
++;
5010 ptr
= &cur_page
->tag
[--unallocated
];
5011 alloc_counts
[(int)alloc_type_tag
].unallocated
= unallocated
;
5016 ptr
= (tag_t
*) xmalloc (sizeof (tag_t
));
5020 alloc_counts
[(int)alloc_type_tag
].total_alloc
++;
5025 /* Free scoping information. */
5031 alloc_counts
[(int)alloc_type_tag
].total_free
++;
5033 #ifndef MALLOC_CHECK
5034 ptr
->free
= alloc_counts
[(int)alloc_type_tag
].free_list
.f_tag
;
5035 alloc_counts
[(int)alloc_type_tag
].free_list
.f_tag
= ptr
;
5041 /* Allocate forward reference to a yet unknown tag. */
5046 register forward_t
*ptr
;
5047 static forward_t initial_forward
;
5049 #ifndef MALLOC_CHECK
5051 register int unallocated
= alloc_counts
[(int)alloc_type_forward
].unallocated
;
5052 register page_t
*cur_page
= alloc_counts
[(int)alloc_type_forward
].cur_page
;
5054 if (unallocated
== 0)
5056 unallocated
= PAGE_SIZE
/ sizeof (forward_t
);
5057 alloc_counts
[(int)alloc_type_forward
].cur_page
= cur_page
= allocate_page ();
5058 alloc_counts
[(int)alloc_type_forward
].total_pages
++;
5061 ptr
= &cur_page
->forward
[--unallocated
];
5062 alloc_counts
[(int)alloc_type_forward
].unallocated
= unallocated
;
5066 ptr
= (forward_t
*) xmalloc (sizeof (forward_t
));
5070 alloc_counts
[(int)alloc_type_forward
].total_alloc
++;
5071 *ptr
= initial_forward
;
5075 /* Allocate head of type hash list. */
5080 register thead_t
*ptr
;
5081 static thead_t initial_thead
;
5083 #ifndef MALLOC_CHECK
5085 ptr
= alloc_counts
[(int)alloc_type_thead
].free_list
.f_thead
;
5086 if (ptr
!= (thead_t
*) NULL
)
5087 alloc_counts
[ (int)alloc_type_thead
].free_list
.f_thead
= ptr
->free
;
5090 register int unallocated
= alloc_counts
[(int)alloc_type_thead
].unallocated
;
5091 register page_t
*cur_page
= alloc_counts
[(int)alloc_type_thead
].cur_page
;
5093 if (unallocated
== 0)
5095 unallocated
= PAGE_SIZE
/ sizeof (thead_t
);
5096 alloc_counts
[(int)alloc_type_thead
].cur_page
= cur_page
= allocate_page ();
5097 alloc_counts
[(int)alloc_type_thead
].total_pages
++;
5100 ptr
= &cur_page
->thead
[--unallocated
];
5101 alloc_counts
[(int)alloc_type_thead
].unallocated
= unallocated
;
5106 ptr
= (thead_t
*) xmalloc (sizeof (thead_t
));
5110 alloc_counts
[(int)alloc_type_thead
].total_alloc
++;
5111 *ptr
= initial_thead
;
5115 /* Free scoping information. */
5121 alloc_counts
[(int)alloc_type_thead
].total_free
++;
5123 #ifndef MALLOC_CHECK
5124 ptr
->free
= (thead_t
*) alloc_counts
[(int)alloc_type_thead
].free_list
.f_thead
;
5125 alloc_counts
[(int)alloc_type_thead
].free_list
.f_thead
= ptr
;
5131 static lineno_list_t
*
5132 allocate_lineno_list ()
5134 register lineno_list_t
*ptr
;
5135 static lineno_list_t initial_lineno_list
;
5137 #ifndef MALLOC_CHECK
5139 register int unallocated
= alloc_counts
[(int)alloc_type_lineno
].unallocated
;
5140 register page_t
*cur_page
= alloc_counts
[(int)alloc_type_lineno
].cur_page
;
5142 if (unallocated
== 0)
5144 unallocated
= PAGE_SIZE
/ sizeof (lineno_list_t
);
5145 alloc_counts
[(int)alloc_type_lineno
].cur_page
= cur_page
= allocate_page ();
5146 alloc_counts
[(int)alloc_type_lineno
].total_pages
++;
5149 ptr
= &cur_page
->lineno
[--unallocated
];
5150 alloc_counts
[(int)alloc_type_lineno
].unallocated
= unallocated
;
5154 ptr
= (lineno_list_t
*) xmalloc (sizeof (lineno_list_t
));
5158 alloc_counts
[(int)alloc_type_lineno
].total_alloc
++;
5159 *ptr
= initial_lineno_list
;
5164 ecoff_set_gp_prolog_size (sz
)
5167 if (cur_proc_ptr
== 0)
5170 cur_proc_ptr
->pdr
.gp_prologue
= sz
;
5171 if (cur_proc_ptr
->pdr
.gp_prologue
!= sz
)
5173 as_warn ("GP prologue size exceeds field size, using 0 instead");
5174 cur_proc_ptr
->pdr
.gp_prologue
= 0;
5177 cur_proc_ptr
->pdr
.gp_used
= 1;
5181 generate_ecoff_stab (what
, string
, type
, other
, desc
)
5188 efdr_t
*save_file_ptr
= cur_file_ptr
;
5194 localsym_t
*hold
= NULL
;
5196 /* We don't handle .stabd. */
5197 if (what
!= 's' && what
!= 'n')
5199 as_bad (".stab%c is not supported", what
);
5203 /* We ignore the other field. */
5205 as_warn (".stab%c: ignoring non-zero other field", what
);
5207 /* Make sure we have a current file. */
5208 if (cur_file_ptr
== (efdr_t
*) NULL
)
5210 add_file ((const char *) NULL
, 0, 1);
5211 save_file_ptr
= cur_file_ptr
;
5214 /* For stabs in ECOFF, the first symbol must be @stabs. This is a
5216 if (stabs_seen
== 0)
5219 /* Line number stabs are handled differently, since they have two
5220 values, the line number and the address of the label. We use the
5221 index field (aka desc) to hold the line number, and the value
5222 field to hold the address. The symbol type is st_Label, which
5223 should be different from the other stabs, so that gdb can
5225 if (type
== N_SLINE
)
5231 listing_source_line ((unsigned int) desc
);
5234 dummy_symr
.index
= desc
;
5235 if (dummy_symr
.index
!= desc
)
5237 as_warn ("Line number (%d) for .stab%c directive cannot fit in index field (20 bits)",
5242 sym
= symbol_find_or_make ((char *)string
);
5251 if (listing
&& (type
== N_SO
|| type
== N_SOL
))
5252 listing_source_file (string
);
5255 sym
= symbol_find_or_make ((char *)string
);
5259 indx
= ECOFF_MARK_STAB (type
);
5262 /* Don't store the stabs symbol we are creating as the type of the
5263 ECOFF symbol. We want to compute the type of the ECOFF symbol
5265 if (sym
!= (symbolS
*) NULL
)
5266 hold
= sym
->ecoff_symbol
;
5268 (void) add_ecoff_symbol (string
, st
, sc
, sym
, (bfd_vma
) 0, value
, indx
);
5270 if (sym
!= (symbolS
*) NULL
)
5271 sym
->ecoff_symbol
= hold
;
5273 /* Restore normal file type. */
5274 cur_file_ptr
= save_file_ptr
;
5278 ecoff_no_current_file ()
5280 return cur_file_ptr
== (efdr_t
*) NULL
;
5284 ecoff_generate_asm_lineno (filename
, lineno
)
5285 const char *filename
;
5288 lineno_list_t
*list
;
5290 /* this potential can cause problem, when we start to see stab half the
5291 way thru the file */
5294 ecoff_generate_asm_line_stab(filename, lineno);
5297 if (current_stabs_filename
== (char *)NULL
|| strcmp (current_stabs_filename
, filename
))
5299 add_file (filename
, 0, 1);
5300 generate_asm_lineno
= 1;
5303 list
= allocate_lineno_list ();
5305 list
->next
= (lineno_list_t
*) NULL
;
5306 list
->file
= cur_file_ptr
;
5307 list
->proc
= cur_proc_ptr
;
5308 list
->frag
= frag_now
;
5309 list
->paddr
= frag_now_fix ();
5310 list
->lineno
= lineno
;
5312 /* A .loc directive will sometimes appear before a .ent directive,
5313 which means that cur_proc_ptr will be NULL here. Arrange to
5315 if (cur_proc_ptr
== (proc_t
*) NULL
)
5319 pl
= &noproc_lineno
;
5320 while (*pl
!= (lineno_list_t
*) NULL
)
5326 *last_lineno_ptr
= list
;
5327 last_lineno_ptr
= &list
->next
;
5331 static int line_label_cnt
= 0;
5333 ecoff_generate_asm_line_stab (filename
, lineno
)
5339 if (strcmp (current_stabs_filename
, filename
))
5341 add_file (filename
, 0, 1);
5342 generate_asm_lineno
= 1;
5346 /* generate local label $LMnn */
5348 sprintf(ll
, "$LM%d", line_label_cnt
);
5351 /* generate stab for the line */
5352 generate_ecoff_stab ('n', ll
, N_SLINE
, 0, lineno
);
5356 #endif /* ECOFF_DEBUGGING */