1 /* ECOFF debugging support.
2 Copyright (C) 1993, 94, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
3 Contributed by Cygnus Support.
4 This file was put together by Ian Lance Taylor <ian@cygnus.com>. A
5 good deal of it comes directly from mips-tfile.c, by Michael
6 Meissner <meissner@osf.org>.
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
33 #ifdef ECOFF_DEBUGGING
35 #include "coff/internal.h"
36 #include "coff/symconst.h"
37 #include "aout/stab_gnu.h"
41 /* Why isn't this in coff/sym.h? */
42 #define ST_RFDESCAPE 0xfff
44 /* This file constructs the information used by the ECOFF debugging
45 format. It just builds a large block of data.
47 We support both ECOFF style debugging and stabs debugging (the
48 stabs symbols are encapsulated in ECOFF symbols). This should let
49 us handle anything the compiler might throw at us. */
51 /* Here is a brief description of the MIPS ECOFF symbol table, by
52 Michael Meissner. The MIPS symbol table has the following pieces:
58 +-- Dense number table
66 +-- Relative file descriptors
78 The symbolic header points to each of the other tables, and also
79 contains the number of entries. It also contains a magic number
80 and MIPS compiler version number, such as 2.0.
82 The auxiliary table is a series of 32 bit integers, that are
83 referenced as needed from the local symbol table. Unlike standard
84 COFF, the aux. information does not follow the symbol that uses
85 it, but rather is a separate table. In theory, this would allow
86 the MIPS compilers to collapse duplicate aux. entries, but I've not
87 noticed this happening with the 1.31 compiler suite. The different
88 types of aux. entries are:
90 1) dnLow: Low bound on array dimension.
92 2) dnHigh: High bound on array dimension.
94 3) isym: Index to the local symbol which is the start of the
95 function for the end of function first aux. entry.
97 4) width: Width of structures and bitfields.
99 5) count: Count of ranges for variant part.
101 6) rndx: A relative index into the symbol table. The relative
102 index field has two parts: rfd which is a pointer into the
103 relative file index table or ST_RFDESCAPE which says the next
104 aux. entry is the file number, and index: which is the pointer
105 into the local symbol within a given file table. This is for
106 things like references to types defined in another file.
108 7) Type information: This is like the COFF type bits, except it
109 is 32 bits instead of 16; they still have room to add new
110 basic types; and they can handle more than 6 levels of array,
111 pointer, function, etc. Each type information field contains
112 the following structure members:
114 a) fBitfield: a bit that says this is a bitfield, and the
115 size in bits follows as the next aux. entry.
117 b) continued: a bit that says the next aux. entry is a
118 continuation of the current type information (in case
119 there are more than 6 levels of array/ptr/function).
121 c) bt: an integer containing the base type before adding
122 array, pointer, function, etc. qualifiers. The
123 current base types that I have documentation for are:
126 btAdr -- address - integer same size as ptr
128 btUChar -- unsigned character
130 btUShort -- unsigned short
132 btUInt -- unsigned int
134 btULong -- unsigned long
135 btFloat -- float (real)
136 btDouble -- Double (real)
137 btStruct -- Structure (Record)
138 btUnion -- Union (variant)
140 btTypedef -- defined via a typedef isymRef
141 btRange -- subrange of int
143 btComplex -- fortran complex
144 btDComplex -- fortran double complex
145 btIndirect -- forward or unnamed typedef
146 btFixedDec -- Fixed Decimal
147 btFloatDec -- Float Decimal
148 btString -- Varying Length Character String
149 btBit -- Aligned Bit String
151 btVoid -- Void (MIPS cc revision >= 2.00)
153 d) tq0 - tq5: type qualifier fields as needed. The
154 current type qualifier fields I have documentation for
157 tqNil -- no more qualifiers
161 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.
258 For the following program:
263 printf("Hello World!\n");
267 Mips-tdump produces the following information:
272 timestamp 645311799, Wed Jun 13 17:16:39 1990
273 symbolic header offset 284
274 symbolic header size 96
278 Symbolic header, magic number = 0x7009, vstamp = 1.31:
280 Info Offset Number Bytes
281 ==== ====== ====== =====
283 Line numbers 380 4 4 [13]
285 Procedures Tables 384 1 52
286 Local Symbols 436 16 192
287 Optimization Symbols 0 0 0
288 Auxiliary Symbols 628 39 156
289 Local Strings 784 80 80
290 External Strings 864 144 144
291 File Tables 1008 2 144
293 External Symbols 1152 20 320
297 Name index = 1 Readin = No
298 Merge = No Endian = LITTLE
299 Debug level = G2 Language = C
302 Info Start Number Size Offset
303 ==== ===== ====== ==== ======
304 Local strings 0 15 15 784
305 Local symbols 0 6 72 436
306 Line numbers 0 13 13 380
307 Optimization symbols 0 0 0 0
308 Procedures 0 1 52 384
309 Auxiliary symbols 0 14 56 628
310 Relative Files 0 0 0 0
312 There are 6 local symbols, starting at 436
314 Symbol# 0: "hello2.c"
317 Storage class = Text Index = 6
318 Symbol type = File Value = 0
324 Storage class = Text Index = 12
325 Symbol type = Proc Value = 0
330 Storage class = Text Index = 4
331 Symbol type = Block Value = 8
336 Storage class = Text Index = 2
337 Symbol type = End Value = 28
342 Storage class = Text Index = 1
343 Symbol type = End Value = 52
345 Symbol# 5: "hello2.c"
348 Storage class = Text Index = 0
349 Symbol type = End Value = 0
351 There are 14 auxiliary table entries, starting at 628.
353 * #0 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
354 * #1 24, [ 24/ 0], [ 6 0:0 0:0:0:0:0:0]
355 * #2 8, [ 8/ 0], [ 2 0:0 0:0:0:0:0:0]
356 * #3 16, [ 16/ 0], [ 4 0:0 0:0:0:0:0:0]
357 * #4 24, [ 24/ 0], [ 6 0:0 0:0:0:0:0:0]
358 * #5 32, [ 32/ 0], [ 8 0:0 0:0:0:0:0:0]
359 * #6 40, [ 40/ 0], [10 0:0 0:0:0:0:0:0]
360 * #7 44, [ 44/ 0], [11 0:0 0:0:0:0:0:0]
361 * #8 12, [ 12/ 0], [ 3 0:0 0:0:0:0:0:0]
362 * #9 20, [ 20/ 0], [ 5 0:0 0:0:0:0:0:0]
363 * #10 28, [ 28/ 0], [ 7 0:0 0:0:0:0:0:0]
364 * #11 36, [ 36/ 0], [ 9 0:0 0:0:0:0:0:0]
365 #12 5, [ 5/ 0], [ 1 1:0 0:0:0:0:0:0]
366 #13 24, [ 24/ 0], [ 6 0:0 0:0:0:0:0:0]
368 There are 1 procedure descriptor entries, starting at 0.
370 Procedure descriptor 0:
371 Name index = 10 Name = "main"
372 .mask 0x80000000,-4 .fmask 0x00000000,0
374 Opt. start = -1 Symbols start = 1
375 First line # = 3 Last line # = 6
376 Line Offset = 0 Address = 0x00000000
378 There are 4 bytes holding line numbers, starting at 380.
379 Line 3, delta 0, count 2
380 Line 4, delta 1, count 3
381 Line 5, delta 1, count 2
382 Line 6, delta 1, count 6
384 File #1, "/usr/include/stdio.h"
386 Name index = 1 Readin = No
387 Merge = Yes Endian = LITTLE
388 Debug level = G2 Language = C
391 Info Start Number Size Offset
392 ==== ===== ====== ==== ======
393 Local strings 15 65 65 799
394 Local symbols 6 10 120 508
395 Line numbers 0 0 0 380
396 Optimization symbols 0 0 0 0
398 Auxiliary symbols 14 25 100 684
399 Relative Files 0 0 0 0
401 There are 10 local symbols, starting at 442
403 Symbol# 0: "/usr/include/stdio.h"
406 Storage class = Text Index = 10
407 Symbol type = File Value = 0
412 Storage class = Info Index = 9
413 Symbol type = Block Value = 20
418 Storage class = Info Index = 4
419 Symbol type = Member Value = 0
424 Storage class = Info Index = 15
425 Symbol type = Member Value = 32
430 Storage class = Info Index = 16
431 Symbol type = Member Value = 64
436 Storage class = Info Index = 4
437 Symbol type = Member Value = 96
442 Storage class = Info Index = 3
443 Symbol type = Member Value = 128
448 Storage class = Info Index = 2
449 Symbol type = Member Value = 144
454 Storage class = Info Index = 1
455 Symbol type = End Value = 0
457 Symbol# 9: "/usr/include/stdio.h"
460 Storage class = Text Index = 0
461 Symbol type = End Value = 0
463 There are 25 auxiliary table entries, starting at 642.
465 * #14 -1, [4095/1048575], [63 1:1 f:f:f:f:f:f]
466 #15 65544, [ 8/ 16], [ 2 0:0 1:0:0:0:0:0]
467 #16 65544, [ 8/ 16], [ 2 0:0 1:0:0:0:0:0]
468 * #17 196656, [ 48/ 48], [12 0:0 3:0:0:0:0:0]
469 * #18 8191, [4095/ 1], [63 1:1 0:0:0:0:f:1]
470 * #19 1, [ 1/ 0], [ 0 1:0 0:0:0:0:0:0]
471 * #20 20479, [4095/ 4], [63 1:1 0:0:0:0:f:4]
472 * #21 1, [ 1/ 0], [ 0 1:0 0:0:0:0:0:0]
473 * #22 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
474 * #23 2, [ 2/ 0], [ 0 0:1 0:0:0:0:0:0]
475 * #24 160, [ 160/ 0], [40 0:0 0:0:0:0:0:0]
476 * #25 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
477 * #26 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
478 * #27 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
479 * #28 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
480 * #29 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
481 * #30 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
482 * #31 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
483 * #32 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
484 * #33 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
485 * #34 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
486 * #35 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
487 * #36 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
488 * #37 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
489 * #38 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
491 There are 0 procedure descriptor entries, starting at 1.
493 There are 20 external symbols, starting at 1152
496 Type = array [3 {160}] of struct _iobuf { ifd = 1, index = 1 }
497 String index = 0 Ifd = 1
498 Storage class = Nil Index = 17
499 Symbol type = Global Value = 60
502 String index = 5 Ifd = 1
503 Storage class = Nil Index = 1048575
504 Symbol type = Proc Value = 0
507 String index = 11 Ifd = 1
508 Storage class = Nil Index = 1048575
509 Symbol type = Proc Value = 0
512 String index = 18 Ifd = 1
513 Storage class = Nil Index = 1048575
514 Symbol type = Proc Value = 0
517 String index = 26 Ifd = 1
518 Storage class = Nil Index = 1048575
519 Symbol type = Proc Value = 0
522 String index = 32 Ifd = 1
523 Storage class = Nil Index = 1048575
524 Symbol type = Proc Value = 0
527 String index = 40 Ifd = 1
528 Storage class = Nil Index = 1048575
529 Symbol type = Proc Value = 0
532 String index = 46 Ifd = 1
533 Storage class = Nil Index = 1048575
534 Symbol type = Proc Value = 0
537 String index = 53 Ifd = 1
538 Storage class = Nil Index = 1048575
539 Symbol type = Proc Value = 0
541 Symbol# 9: "setbuffer"
542 String index = 60 Ifd = 1
543 Storage class = Nil Index = 1048575
544 Symbol type = Proc Value = 0
546 Symbol# 10: "setlinebuf"
547 String index = 70 Ifd = 1
548 Storage class = Nil Index = 1048575
549 Symbol type = Proc Value = 0
552 String index = 81 Ifd = 1
553 Storage class = Nil Index = 1048575
554 Symbol type = Proc Value = 0
557 String index = 87 Ifd = 1
558 Storage class = Nil Index = 1048575
559 Symbol type = Proc Value = 0
561 Symbol# 13: "ctermid"
562 String index = 92 Ifd = 1
563 Storage class = Nil Index = 1048575
564 Symbol type = Proc Value = 0
566 Symbol# 14: "cuserid"
567 String index = 100 Ifd = 1
568 Storage class = Nil Index = 1048575
569 Symbol type = Proc Value = 0
571 Symbol# 15: "tempnam"
572 String index = 108 Ifd = 1
573 Storage class = Nil Index = 1048575
574 Symbol type = Proc Value = 0
577 String index = 116 Ifd = 1
578 Storage class = Nil Index = 1048575
579 Symbol type = Proc Value = 0
581 Symbol# 17: "sprintf"
582 String index = 123 Ifd = 1
583 Storage class = Nil Index = 1048575
584 Symbol type = Proc Value = 0
588 String index = 131 Ifd = 0
589 Storage class = Text Index = 1
590 Symbol type = Proc Value = 0
593 String index = 136 Ifd = 0
594 Storage class = Undefined Index = 1048575
595 Symbol type = Proc Value = 0
597 The following auxiliary table entries were unused:
601 #3 16 0x00000010 short
603 #5 32 0x00000020 long
604 #6 40 0x00000028 float
605 #7 44 0x0000002c double
606 #8 12 0x0000000c unsigned char
607 #9 20 0x00000014 unsigned short
608 #10 28 0x0000001c unsigned int
609 #11 36 0x00000024 unsigned long
610 #14 0 0x00000000 void
611 #15 24 0x00000018 int
612 #19 32 0x00000020 long
613 #20 40 0x00000028 float
614 #21 44 0x0000002c double
615 #22 12 0x0000000c unsigned char
616 #23 20 0x00000014 unsigned short
617 #24 28 0x0000001c unsigned int
618 #25 36 0x00000024 unsigned long
619 #26 48 0x00000030 struct no name { ifd = -1, index = 1048575 }
622 /* Redefinition of of storage classes as an enumeration for better
626 sc_Nil
= scNil
, /* no storage class */
627 sc_Text
= scText
, /* text symbol */
628 sc_Data
= scData
, /* initialized data symbol */
629 sc_Bss
= scBss
, /* un-initialized data symbol */
630 sc_Register
= scRegister
, /* value of symbol is register number */
631 sc_Abs
= scAbs
, /* value of symbol is absolute */
632 sc_Undefined
= scUndefined
, /* who knows? */
633 sc_CdbLocal
= scCdbLocal
, /* variable's value is IN se->va.?? */
634 sc_Bits
= scBits
, /* this is a bit field */
635 sc_CdbSystem
= scCdbSystem
, /* value is IN CDB's address space */
636 sc_RegImage
= scRegImage
, /* register value saved on stack */
637 sc_Info
= scInfo
, /* symbol contains debugger information */
638 sc_UserStruct
= scUserStruct
, /* addr in struct user for current process */
639 sc_SData
= scSData
, /* load time only small data */
640 sc_SBss
= scSBss
, /* load time only small common */
641 sc_RData
= scRData
, /* load time only read only data */
642 sc_Var
= scVar
, /* Var parameter (fortran,pascal) */
643 sc_Common
= scCommon
, /* common variable */
644 sc_SCommon
= scSCommon
, /* small common */
645 sc_VarRegister
= scVarRegister
, /* Var parameter in a register */
646 sc_Variant
= scVariant
, /* Variant record */
647 sc_SUndefined
= scSUndefined
, /* small undefined(external) data */
648 sc_Init
= scInit
, /* .init section symbol */
649 sc_Max
= scMax
/* Max storage class+1 */
652 /* Redefinition of symbol type. */
655 st_Nil
= stNil
, /* Nuthin' special */
656 st_Global
= stGlobal
, /* external symbol */
657 st_Static
= stStatic
, /* static */
658 st_Param
= stParam
, /* procedure argument */
659 st_Local
= stLocal
, /* local variable */
660 st_Label
= stLabel
, /* label */
661 st_Proc
= stProc
, /* " " Procedure */
662 st_Block
= stBlock
, /* beginning of block */
663 st_End
= stEnd
, /* end (of anything) */
664 st_Member
= stMember
, /* member (of anything - struct/union/enum */
665 st_Typedef
= stTypedef
, /* type definition */
666 st_File
= stFile
, /* file name */
667 st_RegReloc
= stRegReloc
, /* register relocation */
668 st_Forward
= stForward
, /* forwarding address */
669 st_StaticProc
= stStaticProc
, /* load time only static procs */
670 st_Constant
= stConstant
, /* const */
671 st_Str
= stStr
, /* string */
672 st_Number
= stNumber
, /* pure number (ie. 4 NOR 2+2) */
673 st_Expr
= stExpr
, /* 2+2 vs. 4 */
674 st_Type
= stType
, /* post-coercion SER */
675 st_Max
= stMax
/* max type+1 */
678 /* Redefinition of type qualifiers. */
681 tq_Nil
= tqNil
, /* bt is what you see */
682 tq_Ptr
= tqPtr
, /* pointer */
683 tq_Proc
= tqProc
, /* procedure */
684 tq_Array
= tqArray
, /* duh */
685 tq_Far
= tqFar
, /* longer addressing - 8086/8 land */
686 tq_Vol
= tqVol
, /* volatile */
687 tq_Max
= tqMax
/* Max type qualifier+1 */
690 /* Redefinition of basic types. */
693 bt_Nil
= btNil
, /* undefined */
694 bt_Adr
= btAdr
, /* address - integer same size as pointer */
695 bt_Char
= btChar
, /* character */
696 bt_UChar
= btUChar
, /* unsigned character */
697 bt_Short
= btShort
, /* short */
698 bt_UShort
= btUShort
, /* unsigned short */
699 bt_Int
= btInt
, /* int */
700 bt_UInt
= btUInt
, /* unsigned int */
701 bt_Long
= btLong
, /* long */
702 bt_ULong
= btULong
, /* unsigned long */
703 bt_Float
= btFloat
, /* float (real) */
704 bt_Double
= btDouble
, /* Double (real) */
705 bt_Struct
= btStruct
, /* Structure (Record) */
706 bt_Union
= btUnion
, /* Union (variant) */
707 bt_Enum
= btEnum
, /* Enumerated */
708 bt_Typedef
= btTypedef
, /* defined via a typedef, isymRef points */
709 bt_Range
= btRange
, /* subrange of int */
710 bt_Set
= btSet
, /* pascal sets */
711 bt_Complex
= btComplex
, /* fortran complex */
712 bt_DComplex
= btDComplex
, /* fortran double complex */
713 bt_Indirect
= btIndirect
, /* forward or unnamed typedef */
714 bt_FixedDec
= btFixedDec
, /* Fixed Decimal */
715 bt_FloatDec
= btFloatDec
, /* Float Decimal */
716 bt_String
= btString
, /* Varying Length Character String */
717 bt_Bit
= btBit
, /* Aligned Bit String */
718 bt_Picture
= btPicture
, /* Picture */
719 bt_Void
= btVoid
, /* Void */
720 bt_Max
= btMax
/* Max basic type+1 */
725 /* States for whether to hash type or not. */
726 typedef enum hash_state
{
727 hash_no
= 0, /* Don't hash type */
728 hash_yes
= 1, /* OK to hash type, or use previous hash */
729 hash_record
= 2 /* OK to record hash, but don't use prev. */
732 /* Types of different sized allocation requests. */
734 alloc_type_none
, /* dummy value */
735 alloc_type_scope
, /* nested scopes linked list */
736 alloc_type_vlinks
, /* glue linking pages in varray */
737 alloc_type_shash
, /* string hash element */
738 alloc_type_thash
, /* type hash element */
739 alloc_type_tag
, /* struct/union/tag element */
740 alloc_type_forward
, /* element to hold unknown tag */
741 alloc_type_thead
, /* head of type hash list */
742 alloc_type_varray
, /* general varray allocation */
743 alloc_type_lineno
, /* line number list */
744 alloc_type_last
/* last+1 element for array bounds */
747 /* Types of auxiliary type information. */
749 aux_tir
, /* TIR type information */
750 aux_rndx
, /* relative index into symbol table */
751 aux_dnLow
, /* low dimension */
752 aux_dnHigh
, /* high dimension */
753 aux_isym
, /* symbol table index (end of proc) */
754 aux_iss
, /* index into string space (not used) */
755 aux_width
, /* width for non-default sized struc fields */
756 aux_count
/* count of ranges for variant arm */
759 /* Structures to provide n-number of virtual arrays, each of which can
760 grow linearly, and which are written in the object file as
761 sequential pages. On systems with a BSD malloc, the
762 MAX_CLUSTER_PAGES should be 1 less than a power of two, since
763 malloc adds it's overhead, and rounds up to the next power of 2.
764 Pages are linked together via a linked list.
766 If PAGE_SIZE is > 4096, the string length in the shash_t structure
767 can't be represented (assuming there are strings > 4096 bytes). */
769 /* FIXME: Yes, there can be such strings while emitting C++ class debug
770 info. Templates are the offender here, the test case in question
771 having a mangled class name of
773 t7rb_tree4Z4xkeyZt4pair2ZC4xkeyZt7xsocket1Z4UserZt9select1st2Zt4pair\
774 2ZC4xkeyZt7xsocket1Z4UserZ4xkeyZt4less1Z4xkey
776 Repeat that a couple dozen times while listing the class members and
777 you've got strings over 4k. Hack around this for now by increasing
778 the page size. A proper solution would abandon this structure scheme
779 certainly for very large strings, and possibly entirely. */
782 #define PAGE_SIZE (8*1024) /* size of varray pages */
785 #define PAGE_USIZE ((unsigned long) PAGE_SIZE)
787 #ifndef MAX_CLUSTER_PAGES /* # pages to get from system */
788 #define MAX_CLUSTER_PAGES 63
791 /* Linked list connecting separate page allocations. */
792 typedef struct vlinks
{
793 struct vlinks
*prev
; /* previous set of pages */
794 struct vlinks
*next
; /* next set of pages */
795 union page
*datum
; /* start of page */
796 unsigned long start_index
; /* starting index # of page */
799 /* Virtual array header. */
800 typedef struct varray
{
801 vlinks_t
*first
; /* first page link */
802 vlinks_t
*last
; /* last page link */
803 unsigned long num_allocated
; /* # objects allocated */
804 unsigned short object_size
; /* size in bytes of each object */
805 unsigned short objects_per_page
; /* # objects that can fit on a page */
806 unsigned short objects_last_page
; /* # objects allocated on last page */
810 #define OBJECTS_PER_PAGE(type) (PAGE_SIZE / sizeof (type))
812 #define OBJECTS_PER_PAGE(type) ((sizeof (type) > 1) ? 1 : PAGE_SIZE)
815 #define INIT_VARRAY(type) { /* macro to initialize a varray */ \
816 (vlinks_t *)0, /* first */ \
817 (vlinks_t *)0, /* last */ \
818 0, /* num_allocated */ \
819 sizeof (type), /* object_size */ \
820 OBJECTS_PER_PAGE (type), /* objects_per_page */ \
821 OBJECTS_PER_PAGE (type), /* objects_last_page */ \
824 /* Master type for indexes within the symbol table. */
825 typedef unsigned long symint_t
;
827 /* Linked list support for nested scopes (file, block, structure, etc.). */
828 typedef struct scope
{
829 struct scope
*prev
; /* previous scope level */
830 struct scope
*free
; /* free list pointer */
831 struct localsym
*lsym
; /* pointer to local symbol node */
832 st_t type
; /* type of the node */
835 /* For a local symbol we store a gas symbol as well as the debugging
836 information we generate. The gas symbol will be NULL if this is
837 only a debugging symbol. */
838 typedef struct localsym
{
839 const char *name
; /* symbol name */
840 symbolS
*as_sym
; /* symbol as seen by gas */
841 bfd_vma addend
; /* addend to as_sym value */
842 struct efdr
*file_ptr
; /* file pointer */
843 struct ecoff_proc
*proc_ptr
; /* proc pointer */
844 struct localsym
*begin_ptr
; /* symbol at start of block */
845 struct ecoff_aux
*index_ptr
; /* index value to be filled in */
846 struct forward
*forward_ref
; /* forward references to this symbol */
847 long sym_index
; /* final symbol index */
848 EXTR ecoff_sym
; /* ECOFF debugging symbol */
851 /* For aux information we keep the type and the data. */
852 typedef struct ecoff_aux
{
853 enum aux_type type
; /* aux type */
854 AUXU data
; /* aux data */
857 /* For a procedure we store the gas symbol as well as the PDR
858 debugging information. */
859 typedef struct ecoff_proc
{
860 localsym_t
*sym
; /* associated symbol */
861 PDR pdr
; /* ECOFF debugging info */
864 /* Number of proc_t structures allocated. */
865 static unsigned long proc_cnt
;
867 /* Forward reference list for tags referenced, but not yet defined. */
868 typedef struct forward
{
869 struct forward
*next
; /* next forward reference */
870 struct forward
*free
; /* free list pointer */
871 aux_t
*ifd_ptr
; /* pointer to store file index */
872 aux_t
*index_ptr
; /* pointer to store symbol index */
875 /* Linked list support for tags. The first tag in the list is always
876 the current tag for that block. */
878 struct tag
*free
; /* free list pointer */
879 struct shash
*hash_ptr
; /* pointer to the hash table head */
880 struct tag
*same_name
; /* tag with same name in outer scope */
881 struct tag
*same_block
; /* next tag defined in the same block. */
882 struct forward
*forward_ref
; /* list of forward references */
883 bt_t basic_type
; /* bt_Struct, bt_Union, or bt_Enum */
884 symint_t ifd
; /* file # tag defined in */
885 localsym_t
*sym
; /* file's local symbols */
888 /* Head of a block's linked list of tags. */
889 typedef struct thead
{
890 struct thead
*prev
; /* previous block */
891 struct thead
*free
; /* free list pointer */
892 struct tag
*first_tag
; /* first tag in block defined */
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 */
903 /* String hash table entry. */
905 typedef struct shash
{
906 char *string
; /* string we are hashing */
907 symint_t indx
; /* index within string table */
908 EXTR
*esym_ptr
; /* global symbol pointer */
909 localsym_t
*sym_ptr
; /* local symbol pointer */
910 localsym_t
*end_ptr
; /* symbol pointer to end block */
911 tag_t
*tag_ptr
; /* tag pointer */
912 proc_t
*proc_ptr
; /* procedure descriptor pointer */
915 /* Type hash table support. The size of the hash table must fit
916 within a page with the other extended file descriptor information.
917 Because unique types which are hashed are fewer in number than
918 strings, we use a smaller hash value. */
923 #define THASH_SIZE 113
926 typedef struct thash
{
927 struct thash
*next
; /* next hash value */
928 AUXU type
; /* type we are hashing */
929 symint_t indx
; /* index within string table */
932 /* Extended file descriptor that contains all of the support necessary
933 to add things to each file separately. */
934 typedef struct efdr
{
935 FDR fdr
; /* File header to be written out */
936 FDR
*orig_fdr
; /* original file header */
937 char *name
; /* filename */
938 int fake
; /* whether this is faked .file */
939 symint_t void_type
; /* aux. pointer to 'void' type */
940 symint_t int_type
; /* aux. pointer to 'int' type */
941 scope_t
*cur_scope
; /* current nested scopes */
942 symint_t file_index
; /* current file number */
943 int nested_scopes
; /* # nested scopes */
944 varray_t strings
; /* local strings */
945 varray_t symbols
; /* local symbols */
946 varray_t procs
; /* procedures */
947 varray_t aux_syms
; /* auxiliary symbols */
948 struct efdr
*next_file
; /* next file descriptor */
949 /* string/type hash tables */
950 struct hash_control
*str_hash
; /* string hash table */
951 thash_t
*thash_head
[THASH_SIZE
];
954 /* Pre-initialized extended file structure. */
955 static const efdr_t init_file
=
957 { /* FDR structure */
958 0, /* adr: memory address of beginning of file */
959 0, /* rss: file name (of source, if known) */
960 0, /* issBase: file's string space */
961 0, /* cbSs: number of bytes in the ss */
962 0, /* isymBase: beginning of symbols */
963 0, /* csym: count file's of symbols */
964 0, /* ilineBase: file's line symbols */
965 0, /* cline: count of file's line symbols */
966 0, /* ioptBase: file's optimization entries */
967 0, /* copt: count of file's optimization entries */
968 0, /* ipdFirst: start of procedures for this file */
969 0, /* cpd: count of procedures for this file */
970 0, /* iauxBase: file's auxiliary entries */
971 0, /* caux: count of file's auxiliary entries */
972 0, /* rfdBase: index into the file indirect table */
973 0, /* crfd: count file indirect entries */
974 langC
, /* lang: language for this file */
975 1, /* fMerge: whether this file can be merged */
976 0, /* fReadin: true if read in (not just created) */
977 TARGET_BYTES_BIG_ENDIAN
, /* fBigendian: if 1, compiled on big endian machine */
978 GLEVEL_2
, /* glevel: level this file was compiled with */
979 0, /* reserved: reserved for future use */
980 0, /* cbLineOffset: byte offset from header for this file ln's */
981 0, /* cbLine: size of lines for this file */
984 (FDR
*)0, /* orig_fdr: original file header pointer */
985 (char *)0, /* name: pointer to filename */
986 0, /* fake: whether this is a faked .file */
987 0, /* void_type: ptr to aux node for void type */
988 0, /* int_type: ptr to aux node for int type */
989 (scope_t
*)0, /* cur_scope: current scope being processed */
990 0, /* file_index: current file # */
991 0, /* nested_scopes: # nested scopes */
992 INIT_VARRAY (char), /* strings: local string varray */
993 INIT_VARRAY (localsym_t
), /* symbols: local symbols varray */
994 INIT_VARRAY (proc_t
), /* procs: procedure varray */
995 INIT_VARRAY (aux_t
), /* aux_syms: auxiliary symbols varray */
997 (struct efdr
*)0, /* next_file: next file structure */
999 (struct hash_control
*)0, /* str_hash: string hash table */
1000 { 0 }, /* thash_head: type hash table */
1003 static efdr_t
*first_file
; /* first file descriptor */
1004 static efdr_t
**last_file_ptr
= &first_file
; /* file descriptor tail */
1006 /* Line number information is kept in a list until the assembly is
1008 typedef struct lineno_list
{
1009 struct lineno_list
*next
; /* next element in list */
1010 efdr_t
*file
; /* file this line is in */
1011 proc_t
*proc
; /* procedure this line is in */
1012 fragS
*frag
; /* fragment this line number is in */
1013 unsigned long paddr
; /* offset within fragment */
1014 long lineno
; /* actual line number */
1017 static lineno_list_t
*first_lineno
;
1018 static lineno_list_t
*last_lineno
;
1019 static lineno_list_t
**last_lineno_ptr
= &first_lineno
;
1021 /* Sometimes there will be some .loc statements before a .ent. We
1022 keep them in this list so that we can fill in the procedure pointer
1023 after we see the .ent. */
1024 static lineno_list_t
*noproc_lineno
;
1026 /* Union of various things that are held in pages. */
1027 typedef union page
{
1028 char byte
[ PAGE_SIZE
];
1029 unsigned char ubyte
[ PAGE_SIZE
];
1030 efdr_t file
[ PAGE_SIZE
/ sizeof (efdr_t
) ];
1031 FDR ofile
[ PAGE_SIZE
/ sizeof (FDR
) ];
1032 proc_t proc
[ PAGE_SIZE
/ sizeof (proc_t
) ];
1033 localsym_t sym
[ PAGE_SIZE
/ sizeof (localsym_t
) ];
1034 aux_t aux
[ PAGE_SIZE
/ sizeof (aux_t
) ];
1035 DNR dense
[ PAGE_SIZE
/ sizeof (DNR
) ];
1036 scope_t scope
[ PAGE_SIZE
/ sizeof (scope_t
) ];
1037 vlinks_t vlinks
[ PAGE_SIZE
/ sizeof (vlinks_t
) ];
1038 shash_t shash
[ PAGE_SIZE
/ sizeof (shash_t
) ];
1039 thash_t thash
[ PAGE_SIZE
/ sizeof (thash_t
) ];
1040 tag_t tag
[ PAGE_SIZE
/ sizeof (tag_t
) ];
1041 forward_t forward
[ PAGE_SIZE
/ sizeof (forward_t
) ];
1042 thead_t thead
[ PAGE_SIZE
/ sizeof (thead_t
) ];
1043 lineno_list_t lineno
[ PAGE_SIZE
/ sizeof (lineno_list_t
) ];
1046 /* Structure holding allocation information for small sized structures. */
1047 typedef struct alloc_info
{
1048 char *alloc_name
; /* name of this allocation type (must be first) */
1049 page_type
*cur_page
; /* current page being allocated from */
1050 small_free_t free_list
; /* current free list if any */
1051 int unallocated
; /* number of elements unallocated on page */
1052 int total_alloc
; /* total number of allocations */
1053 int total_free
; /* total number of frees */
1054 int total_pages
; /* total number of pages allocated */
1057 /* Type information collected together. */
1058 typedef struct type_info
{
1059 bt_t basic_type
; /* basic type */
1060 int orig_type
; /* original COFF-based type */
1061 int num_tq
; /* # type qualifiers */
1062 int num_dims
; /* # dimensions */
1063 int num_sizes
; /* # sizes */
1064 int extra_sizes
; /* # extra sizes not tied with dims */
1065 tag_t
* tag_ptr
; /* tag pointer */
1066 int bitfield
; /* symbol is a bitfield */
1067 tq_t type_qualifiers
[N_TQ
]; /* type qualifiers (ptr, func, array)*/
1068 symint_t dimensions
[N_TQ
]; /* dimensions for each array */
1069 symint_t sizes
[N_TQ
+2]; /* sizes of each array slice + size of
1070 struct/union/enum + bitfield size */
1073 /* Pre-initialized type_info struct. */
1074 static const type_info_t type_info_init
= {
1075 bt_Nil
, /* basic type */
1076 T_NULL
, /* original COFF-based type */
1077 0, /* # type qualifiers */
1078 0, /* # dimensions */
1080 0, /* sizes not tied with dims */
1081 NULL
, /* ptr to tag */
1083 { /* type qualifiers */
1111 /* Global hash table for the tags table and global table for file
1114 static varray_t file_desc
= INIT_VARRAY (efdr_t
);
1116 static struct hash_control
*tag_hash
;
1118 /* Static types for int and void. Also, remember the last function's
1119 type (which is set up when we encounter the declaration for the
1120 function, and used when the end block for the function is emitted. */
1122 static type_info_t int_type_info
;
1123 static type_info_t void_type_info
;
1124 static type_info_t last_func_type_info
;
1125 static symbolS
*last_func_sym_value
;
1127 /* Convert COFF basic type to ECOFF basic type. The T_NULL type
1128 really should use bt_Void, but this causes the current ecoff GDB to
1129 issue unsupported type messages, and the Ultrix 4.00 dbx (aka MIPS
1130 2.0) doesn't understand it, even though the compiler generates it.
1131 Maybe this will be fixed in 2.10 or 2.20 of the MIPS compiler
1132 suite, but for now go with what works.
1134 It would make sense for the .type and .scl directives to use the
1135 ECOFF numbers directly, rather than using the COFF numbers and
1136 mapping them. Unfortunately, this is historically what mips-tfile
1137 expects, and changing gcc now would be a considerable pain (the
1138 native compiler generates debugging information internally, rather
1139 than via the assembler, so it will never use .type or .scl). */
1141 static const bt_t map_coff_types
[] = {
1142 bt_Nil
, /* T_NULL */
1144 bt_Char
, /* T_CHAR */
1145 bt_Short
, /* T_SHORT */
1147 bt_Long
, /* T_LONG */
1148 bt_Float
, /* T_FLOAT */
1149 bt_Double
, /* T_DOUBLE */
1150 bt_Struct
, /* T_STRUCT */
1151 bt_Union
, /* T_UNION */
1152 bt_Enum
, /* T_ENUM */
1153 bt_Enum
, /* T_MOE */
1154 bt_UChar
, /* T_UCHAR */
1155 bt_UShort
, /* T_USHORT */
1156 bt_UInt
, /* T_UINT */
1157 bt_ULong
/* T_ULONG */
1160 /* Convert COFF storage class to ECOFF storage class. */
1161 static const sc_t map_coff_storage
[] = {
1162 sc_Nil
, /* 0: C_NULL */
1163 sc_Abs
, /* 1: C_AUTO auto var */
1164 sc_Undefined
, /* 2: C_EXT external */
1165 sc_Data
, /* 3: C_STAT static */
1166 sc_Register
, /* 4: C_REG register */
1167 sc_Undefined
, /* 5: C_EXTDEF ??? */
1168 sc_Text
, /* 6: C_LABEL label */
1169 sc_Text
, /* 7: C_ULABEL user label */
1170 sc_Info
, /* 8: C_MOS member of struct */
1171 sc_Abs
, /* 9: C_ARG argument */
1172 sc_Info
, /* 10: C_STRTAG struct tag */
1173 sc_Info
, /* 11: C_MOU member of union */
1174 sc_Info
, /* 12: C_UNTAG union tag */
1175 sc_Info
, /* 13: C_TPDEF typedef */
1176 sc_Data
, /* 14: C_USTATIC ??? */
1177 sc_Info
, /* 15: C_ENTAG enum tag */
1178 sc_Info
, /* 16: C_MOE member of enum */
1179 sc_Register
, /* 17: C_REGPARM register parameter */
1180 sc_Bits
, /* 18; C_FIELD bitfield */
1262 sc_Text
, /* 100: C_BLOCK block start/end */
1263 sc_Text
, /* 101: C_FCN function start/end */
1264 sc_Info
, /* 102: C_EOS end of struct/union/enum */
1265 sc_Nil
, /* 103: C_FILE file start */
1266 sc_Nil
, /* 104: C_LINE line number */
1267 sc_Nil
, /* 105: C_ALIAS combined type info */
1268 sc_Nil
, /* 106: C_HIDDEN ??? */
1271 /* Convert COFF storage class to ECOFF symbol type. */
1272 static const st_t map_coff_sym_type
[] = {
1273 st_Nil
, /* 0: C_NULL */
1274 st_Local
, /* 1: C_AUTO auto var */
1275 st_Global
, /* 2: C_EXT external */
1276 st_Static
, /* 3: C_STAT static */
1277 st_Local
, /* 4: C_REG register */
1278 st_Global
, /* 5: C_EXTDEF ??? */
1279 st_Label
, /* 6: C_LABEL label */
1280 st_Label
, /* 7: C_ULABEL user label */
1281 st_Member
, /* 8: C_MOS member of struct */
1282 st_Param
, /* 9: C_ARG argument */
1283 st_Block
, /* 10: C_STRTAG struct tag */
1284 st_Member
, /* 11: C_MOU member of union */
1285 st_Block
, /* 12: C_UNTAG union tag */
1286 st_Typedef
, /* 13: C_TPDEF typedef */
1287 st_Static
, /* 14: C_USTATIC ??? */
1288 st_Block
, /* 15: C_ENTAG enum tag */
1289 st_Member
, /* 16: C_MOE member of enum */
1290 st_Param
, /* 17: C_REGPARM register parameter */
1291 st_Member
, /* 18; C_FIELD bitfield */
1373 st_Block
, /* 100: C_BLOCK block start/end */
1374 st_Proc
, /* 101: C_FCN function start/end */
1375 st_End
, /* 102: C_EOS end of struct/union/enum */
1376 st_File
, /* 103: C_FILE file start */
1377 st_Nil
, /* 104: C_LINE line number */
1378 st_Nil
, /* 105: C_ALIAS combined type info */
1379 st_Nil
, /* 106: C_HIDDEN ??? */
1382 /* Keep track of different sized allocation requests. */
1383 static alloc_info_t alloc_counts
[(int) alloc_type_last
];
1385 /* Record whether we have seen any debugging information. */
1386 int ecoff_debugging_seen
= 0;
1388 /* Various statics. */
1389 static efdr_t
*cur_file_ptr
= (efdr_t
*) 0; /* current file desc. header */
1390 static proc_t
*cur_proc_ptr
= (proc_t
*) 0; /* current procedure header */
1391 static proc_t
*first_proc_ptr
= (proc_t
*) 0; /* first procedure header */
1392 static thead_t
*top_tag_head
= (thead_t
*) 0; /* top level tag head */
1393 static thead_t
*cur_tag_head
= (thead_t
*) 0; /* current tag head */
1395 static int debug
= 0; /* trace functions */
1397 static int stabs_seen
= 0; /* != 0 if stabs have been seen */
1399 static int current_file_idx
;
1400 static const char *current_stabs_filename
;
1402 /* Pseudo symbol to use when putting stabs into the symbol table. */
1403 #ifndef STABS_SYMBOL
1404 #define STABS_SYMBOL "@stabs"
1407 static char stabs_symbol
[] = STABS_SYMBOL
;
1409 /* Prototypes for functions defined in this file. */
1411 static void add_varray_page
PARAMS ((varray_t
*vp
));
1412 static symint_t add_string
PARAMS ((varray_t
*vp
,
1413 struct hash_control
*hash_tbl
,
1415 shash_t
**ret_hash
));
1416 static localsym_t
*add_ecoff_symbol
PARAMS ((const char *str
, st_t type
,
1417 sc_t storage
, symbolS
*sym
,
1418 bfd_vma addend
, symint_t value
,
1420 static symint_t add_aux_sym_symint
PARAMS ((symint_t aux_word
));
1421 static symint_t add_aux_sym_rndx
PARAMS ((int file_index
,
1422 symint_t sym_index
));
1423 static symint_t add_aux_sym_tir
PARAMS ((type_info_t
*t
,
1425 thash_t
**hash_tbl
));
1426 static tag_t
*get_tag
PARAMS ((const char *tag
, localsym_t
*sym
,
1428 static void add_unknown_tag
PARAMS ((tag_t
*ptag
));
1429 static void add_procedure
PARAMS ((char *func
));
1430 static void add_file
PARAMS ((const char *file_name
, int indx
, int fake
));
1432 static char *sc_to_string
PARAMS ((sc_t storage_class
));
1433 static char *st_to_string
PARAMS ((st_t symbol_type
));
1435 static void mark_stabs
PARAMS ((int));
1436 static char *ecoff_add_bytes
PARAMS ((char **buf
, char **bufend
,
1437 char *bufptr
, unsigned long need
));
1438 static unsigned long ecoff_padding_adjust
1439 PARAMS ((const struct ecoff_debug_swap
*backend
, char **buf
, char **bufend
,
1440 unsigned long offset
, char **bufptrptr
));
1441 static unsigned long ecoff_build_lineno
1442 PARAMS ((const struct ecoff_debug_swap
*backend
, char **buf
, char **bufend
,
1443 unsigned long offset
, long *linecntptr
));
1444 static unsigned long ecoff_build_symbols
1445 PARAMS ((const struct ecoff_debug_swap
*backend
, char **buf
, char **bufend
,
1446 unsigned long offset
));
1447 static unsigned long ecoff_build_procs
1448 PARAMS ((const struct ecoff_debug_swap
*backend
, char **buf
, char **bufend
,
1449 unsigned long offset
));
1450 static unsigned long ecoff_build_aux
1451 PARAMS ((const struct ecoff_debug_swap
*backend
, char **buf
, char **bufend
,
1452 unsigned long offset
));
1453 static unsigned long ecoff_build_strings
PARAMS ((char **buf
, char **bufend
,
1454 unsigned long offset
,
1456 static unsigned long ecoff_build_ss
1457 PARAMS ((const struct ecoff_debug_swap
*backend
, char **buf
, char **bufend
,
1458 unsigned long offset
));
1459 static unsigned long ecoff_build_fdr
1460 PARAMS ((const struct ecoff_debug_swap
*backend
, char **buf
, char **bufend
,
1461 unsigned long offset
));
1462 static void ecoff_setup_ext
PARAMS ((void));
1463 static page_type
*allocate_cluster
PARAMS ((unsigned long npages
));
1464 static page_type
*allocate_page
PARAMS ((void));
1465 static scope_t
*allocate_scope
PARAMS ((void));
1466 static void free_scope
PARAMS ((scope_t
*ptr
));
1467 static vlinks_t
*allocate_vlinks
PARAMS ((void));
1468 static shash_t
*allocate_shash
PARAMS ((void));
1469 static thash_t
*allocate_thash
PARAMS ((void));
1470 static tag_t
*allocate_tag
PARAMS ((void));
1471 static void free_tag
PARAMS ((tag_t
*ptr
));
1472 static forward_t
*allocate_forward
PARAMS ((void));
1473 static thead_t
*allocate_thead
PARAMS ((void));
1474 static void free_thead
PARAMS ((thead_t
*ptr
));
1475 static lineno_list_t
*allocate_lineno_list
PARAMS ((void));
1477 /* This function should be called when the assembler starts up. */
1480 ecoff_read_begin_hook ()
1482 tag_hash
= hash_new ();
1483 top_tag_head
= allocate_thead ();
1484 top_tag_head
->first_tag
= (tag_t
*) NULL
;
1485 top_tag_head
->free
= (thead_t
*) NULL
;
1486 top_tag_head
->prev
= cur_tag_head
;
1487 cur_tag_head
= top_tag_head
;
1490 /* This function should be called when a symbol is created. */
1493 ecoff_symbol_new_hook (symbolP
)
1496 OBJ_SYMFIELD_TYPE
*obj
;
1498 /* Make sure that we have a file pointer, but only if we have seen a
1499 file. If we haven't seen a file, then this is a probably special
1500 symbol created by md_begin which may required special handling at
1501 some point. Creating a dummy file with a dummy name is certainly
1503 if (cur_file_ptr
== (efdr_t
*) NULL
1504 && seen_at_least_1_file ())
1505 add_file ((const char *) NULL
, 0, 1);
1506 obj
= symbol_get_obj (symbolP
);
1507 obj
->ecoff_file
= cur_file_ptr
;
1508 obj
->ecoff_symbol
= NULL
;
1509 obj
->ecoff_extern_size
= 0;
1512 /* Add a page to a varray object. */
1515 add_varray_page (vp
)
1516 varray_t
*vp
; /* varray to add page to */
1518 vlinks_t
*new_links
= allocate_vlinks ();
1521 if (vp
->object_size
> 1)
1522 new_links
->datum
= (page_type
*) xcalloc (1, vp
->object_size
);
1525 new_links
->datum
= allocate_page ();
1527 alloc_counts
[(int) alloc_type_varray
].total_alloc
++;
1528 alloc_counts
[(int) alloc_type_varray
].total_pages
++;
1530 new_links
->start_index
= vp
->num_allocated
;
1531 vp
->objects_last_page
= 0;
1533 if (vp
->first
== (vlinks_t
*) NULL
) /* first allocation? */
1534 vp
->first
= vp
->last
= new_links
;
1536 { /* 2nd or greater allocation */
1537 new_links
->prev
= vp
->last
;
1538 vp
->last
->next
= new_links
;
1539 vp
->last
= new_links
;
1543 /* Add a string (and null pad) to one of the string tables. */
1546 add_string (vp
, hash_tbl
, str
, ret_hash
)
1547 varray_t
*vp
; /* string obstack */
1548 struct hash_control
*hash_tbl
; /* ptr to hash table */
1549 const char *str
; /* string */
1550 shash_t
**ret_hash
; /* return hash pointer */
1552 register unsigned long len
= strlen (str
);
1553 register shash_t
*hash_ptr
;
1555 if (len
>= PAGE_USIZE
)
1556 as_fatal (_("String too big (%lu bytes)"), len
);
1558 hash_ptr
= (shash_t
*) hash_find (hash_tbl
, str
);
1559 if (hash_ptr
== (shash_t
*) NULL
)
1561 register const char *err
;
1563 if (vp
->objects_last_page
+ len
>= PAGE_USIZE
)
1566 ((vp
->num_allocated
+ PAGE_USIZE
- 1) / PAGE_USIZE
) * PAGE_USIZE
;
1567 add_varray_page (vp
);
1570 hash_ptr
= allocate_shash ();
1571 hash_ptr
->indx
= vp
->num_allocated
;
1573 hash_ptr
->string
= &vp
->last
->datum
->byte
[vp
->objects_last_page
];
1575 vp
->objects_last_page
+= len
+ 1;
1576 vp
->num_allocated
+= len
+ 1;
1578 strcpy (hash_ptr
->string
, str
);
1580 err
= hash_insert (hash_tbl
, str
, (char *) hash_ptr
);
1582 as_fatal (_("Inserting \"%s\" into string hash table: %s"),
1586 if (ret_hash
!= (shash_t
**) NULL
)
1587 *ret_hash
= hash_ptr
;
1589 return hash_ptr
->indx
;
1592 /* Add debugging information for a symbol. */
1595 add_ecoff_symbol (str
, type
, storage
, sym_value
, addend
, value
, indx
)
1596 const char *str
; /* symbol name */
1597 st_t type
; /* symbol type */
1598 sc_t storage
; /* storage class */
1599 symbolS
*sym_value
; /* associated symbol. */
1600 bfd_vma addend
; /* addend to sym_value. */
1601 symint_t value
; /* value of symbol */
1602 symint_t indx
; /* index to local/aux. syms */
1605 register scope_t
*pscope
;
1606 register thead_t
*ptag_head
;
1607 register tag_t
*ptag
;
1608 register tag_t
*ptag_next
;
1609 register varray_t
*vp
;
1610 register int scope_delta
= 0;
1611 shash_t
*hash_ptr
= (shash_t
*) NULL
;
1613 if (cur_file_ptr
== (efdr_t
*) NULL
)
1614 as_fatal (_("no current file pointer"));
1616 vp
= &cur_file_ptr
->symbols
;
1618 if (vp
->objects_last_page
== vp
->objects_per_page
)
1619 add_varray_page (vp
);
1621 psym
= &vp
->last
->datum
->sym
[vp
->objects_last_page
++];
1623 if (str
== (const char *) NULL
&& sym_value
!= (symbolS
*) NULL
)
1624 psym
->name
= S_GET_NAME (sym_value
);
1627 psym
->as_sym
= sym_value
;
1628 if (sym_value
!= (symbolS
*) NULL
)
1629 symbol_get_obj (sym_value
)->ecoff_symbol
= psym
;
1630 psym
->addend
= addend
;
1631 psym
->file_ptr
= cur_file_ptr
;
1632 psym
->proc_ptr
= cur_proc_ptr
;
1633 psym
->begin_ptr
= (localsym_t
*) NULL
;
1634 psym
->index_ptr
= (aux_t
*) NULL
;
1635 psym
->forward_ref
= (forward_t
*) NULL
;
1636 psym
->sym_index
= -1;
1637 memset (&psym
->ecoff_sym
, 0, sizeof (EXTR
));
1638 psym
->ecoff_sym
.asym
.value
= value
;
1639 psym
->ecoff_sym
.asym
.st
= (unsigned) type
;
1640 psym
->ecoff_sym
.asym
.sc
= (unsigned) storage
;
1641 psym
->ecoff_sym
.asym
.index
= indx
;
1643 /* If there is an associated symbol, we wait until the end of the
1644 assembly before deciding where to put the name (it may be just an
1645 external symbol). Otherwise, this is just a debugging symbol and
1646 the name should go with the current file. */
1647 if (sym_value
== (symbolS
*) NULL
)
1648 psym
->ecoff_sym
.asym
.iss
= ((str
== (const char *) NULL
)
1650 : add_string (&cur_file_ptr
->strings
,
1651 cur_file_ptr
->str_hash
,
1655 ++vp
->num_allocated
;
1657 if (ECOFF_IS_STAB (&psym
->ecoff_sym
.asym
))
1660 /* Save the symbol within the hash table if this is a static
1661 item, and it has a name. */
1662 if (hash_ptr
!= (shash_t
*) NULL
1663 && (type
== st_Global
|| type
== st_Static
|| type
== st_Label
1664 || type
== st_Proc
|| type
== st_StaticProc
))
1665 hash_ptr
->sym_ptr
= psym
;
1667 /* push or pop a scope if appropriate. */
1673 case st_File
: /* beginning of file */
1674 case st_Proc
: /* procedure */
1675 case st_StaticProc
: /* static procedure */
1676 case st_Block
: /* begin scope */
1677 pscope
= allocate_scope ();
1678 pscope
->prev
= cur_file_ptr
->cur_scope
;
1679 pscope
->lsym
= psym
;
1680 pscope
->type
= type
;
1681 cur_file_ptr
->cur_scope
= pscope
;
1683 if (type
!= st_File
)
1686 /* For every block type except file, struct, union, or
1687 enumeration blocks, push a level on the tag stack. We omit
1688 file types, so that tags can span file boundaries. */
1689 if (type
!= st_File
&& storage
!= sc_Info
)
1691 ptag_head
= allocate_thead ();
1692 ptag_head
->first_tag
= 0;
1693 ptag_head
->prev
= cur_tag_head
;
1694 cur_tag_head
= ptag_head
;
1699 pscope
= cur_file_ptr
->cur_scope
;
1700 if (pscope
== (scope_t
*) NULL
)
1701 as_fatal (_("too many st_End's"));
1704 st_t begin_type
= (st_t
) pscope
->lsym
->ecoff_sym
.asym
.st
;
1706 psym
->begin_ptr
= pscope
->lsym
;
1708 if (begin_type
!= st_File
)
1711 /* Except for file, structure, union, or enumeration end
1712 blocks remove all tags created within this scope. */
1713 if (begin_type
!= st_File
&& storage
!= sc_Info
)
1715 ptag_head
= cur_tag_head
;
1716 cur_tag_head
= ptag_head
->prev
;
1718 for (ptag
= ptag_head
->first_tag
;
1719 ptag
!= (tag_t
*) NULL
;
1722 if (ptag
->forward_ref
!= (forward_t
*) NULL
)
1723 add_unknown_tag (ptag
);
1725 ptag_next
= ptag
->same_block
;
1726 ptag
->hash_ptr
->tag_ptr
= ptag
->same_name
;
1730 free_thead (ptag_head
);
1733 cur_file_ptr
->cur_scope
= pscope
->prev
;
1735 /* block begin gets next sym #. This is set when we know
1736 the symbol index value. */
1738 /* Functions push two or more aux words as follows:
1739 1st word: index+1 of the end symbol (filled in later).
1740 2nd word: type of the function (plus any aux words needed).
1741 Also, tie the external pointer back to the function begin symbol. */
1742 if (begin_type
!= st_File
&& begin_type
!= st_Block
)
1745 varray_t
*svp
= &cur_file_ptr
->aux_syms
;
1747 pscope
->lsym
->ecoff_sym
.asym
.index
= add_aux_sym_symint (0);
1748 pscope
->lsym
->index_ptr
=
1749 &svp
->last
->datum
->aux
[svp
->objects_last_page
- 1];
1750 ty
= add_aux_sym_tir (&last_func_type_info
,
1752 &cur_file_ptr
->thash_head
[0]);
1754 /* This seems to be unnecessary. I'm not even sure what it is
1755 * intended to do. It's from mips-tfile.
1756 * if (last_func_sym_value != (symbolS *) NULL)
1758 * last_func_sym_value->ifd = cur_file_ptr->file_index;
1759 * last_func_sym_value->index = ty;
1764 free_scope (pscope
);
1768 cur_file_ptr
->nested_scopes
+= scope_delta
;
1771 if (debug
&& type
!= st_File
1772 && (debug
> 2 || type
== st_Block
|| type
== st_End
1773 || type
== st_Proc
|| type
== st_StaticProc
))
1775 char *sc_str
= sc_to_string (storage
);
1776 char *st_str
= st_to_string (type
);
1777 int depth
= cur_file_ptr
->nested_scopes
+ (scope_delta
< 0);
1780 "\tlsym\tv= %10ld, depth= %2d, sc= %-12s",
1781 value
, depth
, sc_str
);
1783 if (str_start
&& str_end_p1
- str_start
> 0)
1784 fprintf (stderr
, " st= %-11s name= %.*s\n",
1785 st_str
, str_end_p1
- str_start
, str_start
);
1788 unsigned long len
= strlen (st_str
);
1789 fprintf (stderr
, " st= %.*s\n", len
- 1, st_str
);
1797 /* Add an auxiliary symbol (passing a symint). This is actually used
1798 for integral aux types, not just symints. */
1801 add_aux_sym_symint (aux_word
)
1802 symint_t aux_word
; /* auxiliary information word */
1804 register varray_t
*vp
;
1805 register aux_t
*aux_ptr
;
1807 if (cur_file_ptr
== (efdr_t
*) NULL
)
1808 as_fatal (_("no current file pointer"));
1810 vp
= &cur_file_ptr
->aux_syms
;
1812 if (vp
->objects_last_page
== vp
->objects_per_page
)
1813 add_varray_page (vp
);
1815 aux_ptr
= &vp
->last
->datum
->aux
[vp
->objects_last_page
++];
1816 aux_ptr
->type
= aux_isym
;
1817 aux_ptr
->data
.isym
= aux_word
;
1819 return vp
->num_allocated
++;
1822 /* Add an auxiliary symbol (passing a file/symbol index combo). */
1825 add_aux_sym_rndx (file_index
, sym_index
)
1829 register varray_t
*vp
;
1830 register aux_t
*aux_ptr
;
1832 if (cur_file_ptr
== (efdr_t
*) NULL
)
1833 as_fatal (_("no current file pointer"));
1835 vp
= &cur_file_ptr
->aux_syms
;
1837 if (vp
->objects_last_page
== vp
->objects_per_page
)
1838 add_varray_page (vp
);
1840 aux_ptr
= &vp
->last
->datum
->aux
[vp
->objects_last_page
++];
1841 aux_ptr
->type
= aux_rndx
;
1842 aux_ptr
->data
.rndx
.rfd
= file_index
;
1843 aux_ptr
->data
.rndx
.index
= sym_index
;
1845 return vp
->num_allocated
++;
1848 /* Add an auxiliary symbol (passing the basic type and possibly
1849 type qualifiers). */
1852 add_aux_sym_tir (t
, state
, hash_tbl
)
1853 type_info_t
*t
; /* current type information */
1854 hash_state_t state
; /* whether to hash type or not */
1855 thash_t
**hash_tbl
; /* pointer to hash table to use */
1857 register varray_t
*vp
;
1858 register aux_t
*aux_ptr
;
1859 static AUXU init_aux
;
1864 if (cur_file_ptr
== (efdr_t
*) NULL
)
1865 as_fatal (_("no current file pointer"));
1867 vp
= &cur_file_ptr
->aux_syms
;
1870 aux
.ti
.bt
= (int) t
->basic_type
;
1871 aux
.ti
.continued
= 0;
1872 aux
.ti
.fBitfield
= t
->bitfield
;
1874 aux
.ti
.tq0
= (int) t
->type_qualifiers
[0];
1875 aux
.ti
.tq1
= (int) t
->type_qualifiers
[1];
1876 aux
.ti
.tq2
= (int) t
->type_qualifiers
[2];
1877 aux
.ti
.tq3
= (int) t
->type_qualifiers
[3];
1878 aux
.ti
.tq4
= (int) t
->type_qualifiers
[4];
1879 aux
.ti
.tq5
= (int) t
->type_qualifiers
[5];
1881 /* For anything that adds additional information, we must not hash,
1882 so check here, and reset our state. */
1884 if (state
!= hash_no
1885 && (t
->type_qualifiers
[0] == tq_Array
1886 || t
->type_qualifiers
[1] == tq_Array
1887 || t
->type_qualifiers
[2] == tq_Array
1888 || t
->type_qualifiers
[3] == tq_Array
1889 || t
->type_qualifiers
[4] == tq_Array
1890 || t
->type_qualifiers
[5] == tq_Array
1891 || t
->basic_type
== bt_Struct
1892 || t
->basic_type
== bt_Union
1893 || t
->basic_type
== bt_Enum
1895 || t
->num_dims
> 0))
1898 /* See if we can hash this type, and save some space, but some types
1899 can't be hashed (because they contain arrays or continuations),
1900 and others can be put into the hash list, but cannot use existing
1901 types because other aux entries precede this one. */
1903 if (state
!= hash_no
)
1905 register thash_t
*hash_ptr
;
1906 register symint_t hi
;
1908 hi
= aux
.isym
& ((1 << HASHBITS
) - 1);
1911 for (hash_ptr
= hash_tbl
[hi
];
1912 hash_ptr
!= (thash_t
*)0;
1913 hash_ptr
= hash_ptr
->next
)
1915 if (aux
.isym
== hash_ptr
->type
.isym
)
1919 if (hash_ptr
!= (thash_t
*) NULL
&& state
== hash_yes
)
1920 return hash_ptr
->indx
;
1922 if (hash_ptr
== (thash_t
*) NULL
)
1924 hash_ptr
= allocate_thash ();
1925 hash_ptr
->next
= hash_tbl
[hi
];
1926 hash_ptr
->type
= aux
;
1927 hash_ptr
->indx
= vp
->num_allocated
;
1928 hash_tbl
[hi
] = hash_ptr
;
1932 /* Everything is set up, add the aux symbol. */
1933 if (vp
->objects_last_page
== vp
->objects_per_page
)
1934 add_varray_page (vp
);
1936 aux_ptr
= &vp
->last
->datum
->aux
[vp
->objects_last_page
++];
1937 aux_ptr
->type
= aux_tir
;
1938 aux_ptr
->data
= aux
;
1940 ret
= vp
->num_allocated
++;
1942 /* Add bitfield length if it exists.
1944 NOTE: Mips documentation claims bitfield goes at the end of the
1945 AUX record, but the DECstation compiler emits it here.
1946 (This would only make a difference for enum bitfields.)
1948 Also note: We use the last size given since gcc may emit 2
1949 for an enum bitfield. */
1952 (void) add_aux_sym_symint ((symint_t
) t
->sizes
[t
->num_sizes
- 1]);
1954 /* Add tag information if needed. Structure, union, and enum
1955 references add 2 aux symbols: a [file index, symbol index]
1956 pointer to the structure type, and the current file index. */
1958 if (t
->basic_type
== bt_Struct
1959 || t
->basic_type
== bt_Union
1960 || t
->basic_type
== bt_Enum
)
1962 register symint_t file_index
= t
->tag_ptr
->ifd
;
1963 register localsym_t
*sym
= t
->tag_ptr
->sym
;
1964 register forward_t
*forward_ref
= allocate_forward ();
1966 if (sym
!= (localsym_t
*) NULL
)
1968 forward_ref
->next
= sym
->forward_ref
;
1969 sym
->forward_ref
= forward_ref
;
1973 forward_ref
->next
= t
->tag_ptr
->forward_ref
;
1974 t
->tag_ptr
->forward_ref
= forward_ref
;
1977 (void) add_aux_sym_rndx (ST_RFDESCAPE
, indexNil
);
1978 forward_ref
->index_ptr
1979 = &vp
->last
->datum
->aux
[vp
->objects_last_page
- 1];
1981 (void) add_aux_sym_symint (file_index
);
1982 forward_ref
->ifd_ptr
1983 = &vp
->last
->datum
->aux
[vp
->objects_last_page
- 1];
1986 /* Add information about array bounds if they exist. */
1987 for (i
= 0; i
< t
->num_dims
; i
++)
1989 (void) add_aux_sym_rndx (ST_RFDESCAPE
,
1990 cur_file_ptr
->int_type
);
1992 (void) add_aux_sym_symint (cur_file_ptr
->file_index
); /* file index*/
1993 (void) add_aux_sym_symint ((symint_t
) 0); /* low bound */
1994 (void) add_aux_sym_symint (t
->dimensions
[i
] - 1); /* high bound*/
1995 (void) add_aux_sym_symint ((t
->dimensions
[i
] == 0) /* stride */
1997 : (t
->sizes
[i
] * 8) / t
->dimensions
[i
]);
2000 /* NOTE: Mips documentation claims that the bitfield width goes here.
2001 But it needs to be emitted earlier. */
2006 /* Add a tag to the tag table (unless it already exists). */
2009 get_tag (tag
, sym
, basic_type
)
2010 const char *tag
; /* tag name */
2011 localsym_t
*sym
; /* tag start block */
2012 bt_t basic_type
; /* bt_Struct, bt_Union, or bt_Enum */
2018 if (cur_file_ptr
== (efdr_t
*) NULL
)
2019 as_fatal (_("no current file pointer"));
2021 hash_ptr
= (shash_t
*) hash_find (tag_hash
, tag
);
2023 if (hash_ptr
!= (shash_t
*) NULL
2024 && hash_ptr
->tag_ptr
!= (tag_t
*) NULL
)
2026 tag_ptr
= hash_ptr
->tag_ptr
;
2027 if (sym
!= (localsym_t
*) NULL
)
2029 tag_ptr
->basic_type
= basic_type
;
2030 tag_ptr
->ifd
= cur_file_ptr
->file_index
;
2036 if (hash_ptr
== (shash_t
*) NULL
)
2040 perm
= xmalloc ((unsigned long) (strlen (tag
) + 1));
2042 hash_ptr
= allocate_shash ();
2043 err
= hash_insert (tag_hash
, perm
, (char *) hash_ptr
);
2045 as_fatal (_("Inserting \"%s\" into tag hash table: %s"),
2047 hash_ptr
->string
= perm
;
2050 tag_ptr
= allocate_tag ();
2051 tag_ptr
->forward_ref
= (forward_t
*) NULL
;
2052 tag_ptr
->hash_ptr
= hash_ptr
;
2053 tag_ptr
->same_name
= hash_ptr
->tag_ptr
;
2054 tag_ptr
->basic_type
= basic_type
;
2056 tag_ptr
->ifd
= ((sym
== (localsym_t
*) NULL
)
2058 : cur_file_ptr
->file_index
);
2059 tag_ptr
->same_block
= cur_tag_head
->first_tag
;
2061 cur_tag_head
->first_tag
= tag_ptr
;
2062 hash_ptr
->tag_ptr
= tag_ptr
;
2067 /* Add an unknown {struct, union, enum} tag. */
2070 add_unknown_tag (ptag
)
2071 tag_t
*ptag
; /* pointer to tag information */
2073 shash_t
*hash_ptr
= ptag
->hash_ptr
;
2074 char *name
= hash_ptr
->string
;
2081 char *agg_type
= "{unknown aggregate type}";
2082 switch (ptag
->basic_type
)
2084 case bt_Struct
: agg_type
= "struct"; break;
2085 case bt_Union
: agg_type
= "union"; break;
2086 case bt_Enum
: agg_type
= "enum"; break;
2090 fprintf (stderr
, "unknown %s %.*s found\n", agg_type
,
2091 hash_ptr
->len
, name_start
);
2095 sym
= add_ecoff_symbol (name
,
2103 (void) add_ecoff_symbol (name
,
2111 for (pf
= &sym
->forward_ref
; *pf
!= (forward_t
*) NULL
; pf
= &(*pf
)->next
)
2113 *pf
= ptag
->forward_ref
;
2116 /* Add a procedure to the current file's list of procedures, and record
2117 this is the current procedure. */
2120 add_procedure (func
)
2121 char *func
; /* func name */
2123 register varray_t
*vp
;
2124 register proc_t
*new_proc_ptr
;
2129 fputc ('\n', stderr
);
2132 if (cur_file_ptr
== (efdr_t
*) NULL
)
2133 as_fatal (_("no current file pointer"));
2135 vp
= &cur_file_ptr
->procs
;
2137 if (vp
->objects_last_page
== vp
->objects_per_page
)
2138 add_varray_page (vp
);
2140 cur_proc_ptr
= new_proc_ptr
= &vp
->last
->datum
->proc
[vp
->objects_last_page
++];
2142 if (first_proc_ptr
== (proc_t
*) NULL
)
2143 first_proc_ptr
= new_proc_ptr
;
2145 vp
->num_allocated
++;
2147 new_proc_ptr
->pdr
.isym
= -1;
2148 new_proc_ptr
->pdr
.iline
= -1;
2149 new_proc_ptr
->pdr
.lnLow
= -1;
2150 new_proc_ptr
->pdr
.lnHigh
= -1;
2152 /* Set the BSF_FUNCTION flag for the symbol. */
2153 sym
= symbol_find_or_make (func
);
2154 symbol_get_bfdsym (sym
)->flags
|= BSF_FUNCTION
;
2156 /* Push the start of the function. */
2157 new_proc_ptr
->sym
= add_ecoff_symbol ((const char *) NULL
, st_Proc
, sc_Text
,
2158 sym
, (bfd_vma
) 0, (symint_t
) 0,
2163 /* Fill in the linenos preceding the .ent, if any. */
2164 if (noproc_lineno
!= (lineno_list_t
*) NULL
)
2168 for (l
= noproc_lineno
; l
!= (lineno_list_t
*) NULL
; l
= l
->next
)
2169 l
->proc
= new_proc_ptr
;
2170 *last_lineno_ptr
= noproc_lineno
;
2171 while (*last_lineno_ptr
!= NULL
)
2173 last_lineno
= *last_lineno_ptr
;
2174 last_lineno_ptr
= &last_lineno
->next
;
2176 noproc_lineno
= (lineno_list_t
*) NULL
;
2181 ecoff_get_cur_proc_sym ()
2183 return (cur_proc_ptr
? cur_proc_ptr
->sym
->as_sym
: NULL
);
2186 /* Add a new filename, and set up all of the file relative
2187 virtual arrays (strings, symbols, aux syms, etc.). Record
2188 where the current file structure lives. */
2191 add_file (file_name
, indx
, fake
)
2192 const char *file_name
; /* file name */
2196 register int first_ch
;
2197 register efdr_t
*fil_ptr
;
2201 fprintf (stderr
, "\tfile\t%.*s\n", len
, file_start
);
2204 /* If the file name is NULL, then no .file symbol appeared, and we
2205 want to use the actual file name. */
2206 if (file_name
== (const char *) NULL
)
2210 if (first_file
!= (efdr_t
*) NULL
)
2211 as_fatal (_("fake .file after real one"));
2212 as_where (&file
, (unsigned int *) NULL
);
2213 file_name
= (const char *) file
;
2215 /* Automatically generate ECOFF debugging information, since I
2216 think that's what other ECOFF assemblers do. We don't do
2217 this if we see a .file directive with a string, since that
2218 implies that some sort of debugging information is being
2220 if (! symbol_table_frozen
&& debug_type
== DEBUG_NONE
)
2221 debug_type
= DEBUG_ECOFF
;
2226 listing_source_file (file_name
);
2229 current_stabs_filename
= file_name
;
2231 /* If we're creating stabs, then we don't actually make a new FDR.
2232 Instead, we just create a stabs symbol. */
2235 (void) add_ecoff_symbol (file_name
, st_Nil
, sc_Nil
,
2236 symbol_new ("L0\001", now_seg
,
2237 (valueT
) frag_now_fix (),
2239 (bfd_vma
) 0, 0, ECOFF_MARK_STAB (N_SOL
));
2243 first_ch
= *file_name
;
2245 /* FIXME: We can't safely merge files which have line number
2246 information (fMerge will be zero in this case). Otherwise, we
2247 get incorrect line number debugging info. See for instance
2248 ecoff_build_lineno, which will end up setting all file->fdr.*
2249 fields multiple times, resulting in incorrect debug info. In
2250 order to make this work right, all line number and symbol info
2251 for the same source file has to be adjacent in the object file,
2252 so that a single file descriptor can be used to point to them.
2253 This would require maintaining file specific lists of line
2254 numbers and symbols for each file, so that they can be merged
2255 together (or output together) when two .file pseudo-ops are
2256 merged into one file descriptor. */
2258 /* See if the file has already been created. */
2259 for (fil_ptr
= first_file
;
2260 fil_ptr
!= (efdr_t
*) NULL
;
2261 fil_ptr
= fil_ptr
->next_file
)
2263 if (first_ch
== fil_ptr
->name
[0]
2264 && strcmp (file_name
, fil_ptr
->name
) == 0
2265 && fil_ptr
->fdr
.fMerge
)
2267 cur_file_ptr
= fil_ptr
;
2269 cur_file_ptr
->fake
= 0;
2274 /* If this is a new file, create it. */
2275 if (fil_ptr
== (efdr_t
*) NULL
)
2277 if (file_desc
.objects_last_page
== file_desc
.objects_per_page
)
2278 add_varray_page (&file_desc
);
2280 fil_ptr
= cur_file_ptr
=
2281 &file_desc
.last
->datum
->file
[file_desc
.objects_last_page
++];
2282 *fil_ptr
= init_file
;
2284 fil_ptr
->file_index
= current_file_idx
++;
2285 ++file_desc
.num_allocated
;
2287 fil_ptr
->fake
= fake
;
2289 /* Allocate the string hash table. */
2290 fil_ptr
->str_hash
= hash_new ();
2292 /* Make sure 0 byte in string table is null */
2293 add_string (&fil_ptr
->strings
,
2298 if (strlen (file_name
) > PAGE_USIZE
- 2)
2299 as_fatal (_("Filename goes over one page boundary."));
2301 /* Push the start of the filename. We assume that the filename
2302 will be stored at string offset 1. */
2303 (void) add_ecoff_symbol (file_name
, st_File
, sc_Text
,
2304 (symbolS
*) NULL
, (bfd_vma
) 0,
2305 (symint_t
) 0, (symint_t
) 0);
2306 fil_ptr
->fdr
.rss
= 1;
2307 fil_ptr
->name
= &fil_ptr
->strings
.last
->datum
->byte
[1];
2309 /* Update the linked list of file descriptors. */
2310 *last_file_ptr
= fil_ptr
;
2311 last_file_ptr
= &fil_ptr
->next_file
;
2313 /* Add void & int types to the file (void should be first to catch
2314 errant 0's within the index fields). */
2315 fil_ptr
->void_type
= add_aux_sym_tir (&void_type_info
,
2317 &cur_file_ptr
->thash_head
[0]);
2319 fil_ptr
->int_type
= add_aux_sym_tir (&int_type_info
,
2321 &cur_file_ptr
->thash_head
[0]);
2325 /* This function is called when the assembler notices a preprocessor
2326 directive switching to a new file. This will not happen in
2327 compiler output, only in hand coded assembler. */
2330 ecoff_new_file (name
)
2333 if (cur_file_ptr
!= NULL
&& strcmp (cur_file_ptr
->name
, name
) == 0)
2335 add_file (name
, 0, 0);
2337 /* This is a hand coded assembler file, so automatically turn on
2338 debugging information. */
2339 if (debug_type
== DEBUG_NONE
)
2340 debug_type
= DEBUG_ECOFF
;
2345 /* Convert storage class to string. */
2348 sc_to_string (storage_class
)
2351 switch (storage_class
)
2353 case sc_Nil
: return "Nil,";
2354 case sc_Text
: return "Text,";
2355 case sc_Data
: return "Data,";
2356 case sc_Bss
: return "Bss,";
2357 case sc_Register
: return "Register,";
2358 case sc_Abs
: return "Abs,";
2359 case sc_Undefined
: return "Undefined,";
2360 case sc_CdbLocal
: return "CdbLocal,";
2361 case sc_Bits
: return "Bits,";
2362 case sc_CdbSystem
: return "CdbSystem,";
2363 case sc_RegImage
: return "RegImage,";
2364 case sc_Info
: return "Info,";
2365 case sc_UserStruct
: return "UserStruct,";
2366 case sc_SData
: return "SData,";
2367 case sc_SBss
: return "SBss,";
2368 case sc_RData
: return "RData,";
2369 case sc_Var
: return "Var,";
2370 case sc_Common
: return "Common,";
2371 case sc_SCommon
: return "SCommon,";
2372 case sc_VarRegister
: return "VarRegister,";
2373 case sc_Variant
: return "Variant,";
2374 case sc_SUndefined
: return "SUndefined,";
2375 case sc_Init
: return "Init,";
2376 case sc_Max
: return "Max,";
2386 /* Convert symbol type to string. */
2389 st_to_string (symbol_type
)
2392 switch (symbol_type
)
2394 case st_Nil
: return "Nil,";
2395 case st_Global
: return "Global,";
2396 case st_Static
: return "Static,";
2397 case st_Param
: return "Param,";
2398 case st_Local
: return "Local,";
2399 case st_Label
: return "Label,";
2400 case st_Proc
: return "Proc,";
2401 case st_Block
: return "Block,";
2402 case st_End
: return "End,";
2403 case st_Member
: return "Member,";
2404 case st_Typedef
: return "Typedef,";
2405 case st_File
: return "File,";
2406 case st_RegReloc
: return "RegReloc,";
2407 case st_Forward
: return "Forward,";
2408 case st_StaticProc
: return "StaticProc,";
2409 case st_Constant
: return "Constant,";
2410 case st_Str
: return "String,";
2411 case st_Number
: return "Number,";
2412 case st_Expr
: return "Expr,";
2413 case st_Type
: return "Type,";
2414 case st_Max
: return "Max,";
2422 /* Parse .begin directives which have a label as the first argument
2423 which gives the location of the start of the block. */
2426 ecoff_directive_begin (ignore
)
2432 if (cur_file_ptr
== (efdr_t
*) NULL
)
2434 as_warn (_(".begin directive without a preceding .file directive"));
2435 demand_empty_rest_of_line ();
2439 if (cur_proc_ptr
== (proc_t
*) NULL
)
2441 as_warn (_(".begin directive without a preceding .ent directive"));
2442 demand_empty_rest_of_line ();
2446 name
= input_line_pointer
;
2447 name_end
= get_symbol_end ();
2449 (void) add_ecoff_symbol ((const char *) NULL
, st_Block
, sc_Text
,
2450 symbol_find_or_make (name
),
2451 (bfd_vma
) 0, (symint_t
) 0, (symint_t
) 0);
2453 *input_line_pointer
= name_end
;
2455 /* The line number follows, but we don't use it. */
2456 (void) get_absolute_expression ();
2457 demand_empty_rest_of_line ();
2460 /* Parse .bend directives which have a label as the first argument
2461 which gives the location of the end of the block. */
2464 ecoff_directive_bend (ignore
)
2471 if (cur_file_ptr
== (efdr_t
*) NULL
)
2473 as_warn (_(".bend directive without a preceding .file directive"));
2474 demand_empty_rest_of_line ();
2478 if (cur_proc_ptr
== (proc_t
*) NULL
)
2480 as_warn (_(".bend directive without a preceding .ent directive"));
2481 demand_empty_rest_of_line ();
2485 name
= input_line_pointer
;
2486 name_end
= get_symbol_end ();
2488 /* The value is the distance between the .bend directive and the
2489 corresponding symbol. We fill in the offset when we write out
2491 endsym
= symbol_find (name
);
2492 if (endsym
== (symbolS
*) NULL
)
2493 as_warn (_(".bend directive names unknown symbol"));
2495 (void) add_ecoff_symbol ((const char *) NULL
, st_End
, sc_Text
, endsym
,
2496 (bfd_vma
) 0, (symint_t
) 0, (symint_t
) 0);
2498 *input_line_pointer
= name_end
;
2500 /* The line number follows, but we don't use it. */
2501 (void) get_absolute_expression ();
2502 demand_empty_rest_of_line ();
2505 /* COFF debugging information is provided as a series of directives
2506 (.def, .scl, etc.). We build up information as we read the
2507 directives in the following static variables, and file it away when
2508 we reach the .endef directive. */
2509 static char *coff_sym_name
;
2510 static type_info_t coff_type
;
2511 static sc_t coff_storage_class
;
2512 static st_t coff_symbol_typ
;
2513 static int coff_is_function
;
2514 static char *coff_tag
;
2515 static valueT coff_value
;
2516 static symbolS
*coff_sym_value
;
2517 static bfd_vma coff_sym_addend
;
2518 static int coff_inside_enumeration
;
2520 /* Handle a .def directive: start defining a symbol. */
2523 ecoff_directive_def (ignore
)
2529 ecoff_debugging_seen
= 1;
2533 name
= input_line_pointer
;
2534 name_end
= get_symbol_end ();
2536 if (coff_sym_name
!= (char *) NULL
)
2537 as_warn (_(".def pseudo-op used inside of .def/.endef; ignored"));
2538 else if (*name
== '\0')
2539 as_warn (_("Empty symbol name in .def; ignored"));
2542 if (coff_sym_name
!= (char *) NULL
)
2543 free (coff_sym_name
);
2544 if (coff_tag
!= (char *) NULL
)
2546 coff_sym_name
= (char *) xmalloc ((unsigned long) (strlen (name
) + 1));
2547 strcpy (coff_sym_name
, name
);
2548 coff_type
= type_info_init
;
2549 coff_storage_class
= sc_Nil
;
2550 coff_symbol_typ
= st_Nil
;
2551 coff_is_function
= 0;
2552 coff_tag
= (char *) NULL
;
2554 coff_sym_value
= (symbolS
*) NULL
;
2555 coff_sym_addend
= 0;
2558 *input_line_pointer
= name_end
;
2560 demand_empty_rest_of_line ();
2563 /* Handle a .dim directive, used to give dimensions for an array. The
2564 arguments are comma separated numbers. mips-tfile assumes that
2565 there will not be more than 6 dimensions, and gdb won't read any
2566 more than that anyhow, so I will also make that assumption. */
2569 ecoff_directive_dim (ignore
)
2575 if (coff_sym_name
== (char *) NULL
)
2577 as_warn (_(".dim pseudo-op used outside of .def/.endef; ignored"));
2578 demand_empty_rest_of_line ();
2582 for (i
= 0; i
< N_TQ
; i
++)
2585 dimens
[i
] = get_absolute_expression ();
2586 if (*input_line_pointer
== ',')
2587 ++input_line_pointer
;
2590 if (*input_line_pointer
!= '\n'
2591 && *input_line_pointer
!= ';')
2592 as_warn (_("Badly formed .dim directive"));
2600 /* The dimensions are stored away in reverse order. */
2603 if (coff_type
.num_dims
>= N_TQ
)
2605 as_warn (_("Too many .dim entries"));
2608 coff_type
.dimensions
[coff_type
.num_dims
] = dimens
[i
];
2609 ++coff_type
.num_dims
;
2612 demand_empty_rest_of_line ();
2615 /* Handle a .scl directive, which sets the COFF storage class of the
2619 ecoff_directive_scl (ignore
)
2624 if (coff_sym_name
== (char *) NULL
)
2626 as_warn (_(".scl pseudo-op used outside of .def/.endef; ignored"));
2627 demand_empty_rest_of_line ();
2631 val
= get_absolute_expression ();
2633 coff_symbol_typ
= map_coff_sym_type
[val
];
2634 coff_storage_class
= map_coff_storage
[val
];
2636 demand_empty_rest_of_line ();
2639 /* Handle a .size directive. For some reason mips-tfile.c thinks that
2640 .size can have multiple arguments. We humor it, although gcc will
2641 never generate more than one argument. */
2644 ecoff_directive_size (ignore
)
2650 if (coff_sym_name
== (char *) NULL
)
2652 as_warn (_(".size pseudo-op used outside of .def/.endef; ignored"));
2653 demand_empty_rest_of_line ();
2657 for (i
= 0; i
< N_TQ
; i
++)
2660 sizes
[i
] = get_absolute_expression ();
2661 if (*input_line_pointer
== ',')
2662 ++input_line_pointer
;
2665 if (*input_line_pointer
!= '\n'
2666 && *input_line_pointer
!= ';')
2667 as_warn (_("Badly formed .size directive"));
2675 /* The sizes are stored away in reverse order. */
2678 if (coff_type
.num_sizes
>= N_TQ
)
2680 as_warn (_("Too many .size entries"));
2683 coff_type
.sizes
[coff_type
.num_sizes
] = sizes
[i
];
2684 ++coff_type
.num_sizes
;
2687 demand_empty_rest_of_line ();
2690 /* Handle the .type directive, which gives the COFF type of the
2694 ecoff_directive_type (ignore
)
2701 if (coff_sym_name
== (char *) NULL
)
2703 as_warn (_(".type pseudo-op used outside of .def/.endef; ignored"));
2704 demand_empty_rest_of_line ();
2708 val
= get_absolute_expression ();
2710 coff_type
.orig_type
= BTYPE (val
);
2711 coff_type
.basic_type
= map_coff_types
[coff_type
.orig_type
];
2713 tq_ptr
= &coff_type
.type_qualifiers
[N_TQ
];
2714 while (val
& ~N_BTMASK
)
2716 if (tq_ptr
== &coff_type
.type_qualifiers
[0])
2718 /* FIXME: We could handle this by setting the continued bit.
2719 There would still be a limit: the .type argument can not
2721 as_warn (_("The type of %s is too complex; it will be simplified"),
2727 else if (ISFCN (val
))
2728 *--tq_ptr
= tq_Proc
;
2729 else if (ISARY (val
))
2730 *--tq_ptr
= tq_Array
;
2732 as_fatal (_("Unrecognized .type argument"));
2737 tq_shft
= &coff_type
.type_qualifiers
[0];
2738 while (tq_ptr
!= &coff_type
.type_qualifiers
[N_TQ
])
2739 *tq_shft
++ = *tq_ptr
++;
2741 if (tq_shft
!= &coff_type
.type_qualifiers
[0] && tq_shft
[-1] == tq_Proc
)
2743 /* If this is a function, ignore it, so that we don't get two
2744 entries (one from the .ent, and one for the .def that
2745 precedes it). Save the type information so that the end
2746 block can properly add it after the begin block index. For
2747 MIPS knows what reason, we must strip off the function type
2749 coff_is_function
= 1;
2750 tq_shft
[-1] = tq_Nil
;
2753 while (tq_shft
!= &coff_type
.type_qualifiers
[N_TQ
])
2754 *tq_shft
++ = tq_Nil
;
2756 demand_empty_rest_of_line ();
2759 /* Handle the .tag directive, which gives the name of a structure,
2763 ecoff_directive_tag (ignore
)
2769 if (coff_sym_name
== (char *) NULL
)
2771 as_warn (_(".tag pseudo-op used outside of .def/.endef; ignored"));
2772 demand_empty_rest_of_line ();
2776 name
= input_line_pointer
;
2777 name_end
= get_symbol_end ();
2779 coff_tag
= (char *) xmalloc ((unsigned long) (strlen (name
) + 1));
2780 strcpy (coff_tag
, name
);
2782 *input_line_pointer
= name_end
;
2784 demand_empty_rest_of_line ();
2787 /* Handle the .val directive, which gives the value of the symbol. It
2788 may be the name of a static or global symbol. */
2791 ecoff_directive_val (ignore
)
2796 if (coff_sym_name
== (char *) NULL
)
2798 as_warn (_(".val pseudo-op used outside of .def/.endef; ignored"));
2799 demand_empty_rest_of_line ();
2804 if (exp
.X_op
!= O_constant
&& exp
.X_op
!= O_symbol
)
2806 as_bad (_(".val expression is too copmlex"));
2807 demand_empty_rest_of_line ();
2811 if (exp
.X_op
== O_constant
)
2812 coff_value
= exp
.X_add_number
;
2815 coff_sym_value
= exp
.X_add_symbol
;
2816 coff_sym_addend
= exp
.X_add_number
;
2819 demand_empty_rest_of_line ();
2822 /* Handle the .endef directive, which terminates processing of COFF
2823 debugging information for a symbol. */
2826 ecoff_directive_endef (ignore
)
2833 demand_empty_rest_of_line ();
2835 if (coff_sym_name
== (char *) NULL
)
2837 as_warn (_(".endef pseudo-op used before .def; ignored"));
2841 name
= coff_sym_name
;
2842 coff_sym_name
= (char *) NULL
;
2844 /* If the symbol is a static or external, we have already gotten the
2845 appropriate type and class, so make sure we don't override those
2846 values. This is needed because there are some type and classes
2847 that are not in COFF, such as short data, etc. */
2848 if (coff_sym_value
!= (symbolS
*) NULL
)
2850 coff_symbol_typ
= st_Nil
;
2851 coff_storage_class
= sc_Nil
;
2854 coff_type
.extra_sizes
= coff_tag
!= (char *) NULL
;
2855 if (coff_type
.num_dims
> 0)
2857 int diff
= coff_type
.num_dims
- coff_type
.num_sizes
;
2858 int i
= coff_type
.num_dims
- 1;
2861 if (coff_type
.num_sizes
!= 1 || diff
< 0)
2863 as_warn (_("Bad COFF debugging info"));
2867 /* If this is an array, make sure the same number of dimensions
2868 and sizes were passed, creating extra sizes for multiply
2869 dimensioned arrays if not passed. */
2870 coff_type
.extra_sizes
= 0;
2873 j
= (sizeof (coff_type
.sizes
) / sizeof (coff_type
.sizes
[0])) - 1;
2876 coff_type
.sizes
[j
] = (((j
- diff
) >= 0)
2877 ? coff_type
.sizes
[j
- diff
]
2882 coff_type
.num_sizes
= i
+ 1;
2883 for (i
--; i
>= 0; i
--)
2884 coff_type
.sizes
[i
] = (coff_type
.dimensions
[i
+ 1] == 0
2886 : (coff_type
.sizes
[i
+ 1]
2887 / coff_type
.dimensions
[i
+ 1]));
2890 else if (coff_symbol_typ
== st_Member
2891 && coff_type
.num_sizes
- coff_type
.extra_sizes
== 1)
2893 /* Is this a bitfield? This is indicated by a structure memeber
2894 having a size field that isn't an array. */
2895 coff_type
.bitfield
= 1;
2898 /* Except for enumeration members & begin/ending of scopes, put the
2899 type word in the aux. symbol table. */
2900 if (coff_symbol_typ
== st_Block
|| coff_symbol_typ
== st_End
)
2902 else if (coff_inside_enumeration
)
2903 indx
= cur_file_ptr
->void_type
;
2906 if (coff_type
.basic_type
== bt_Struct
2907 || coff_type
.basic_type
== bt_Union
2908 || coff_type
.basic_type
== bt_Enum
)
2910 if (coff_tag
== (char *) NULL
)
2912 as_warn (_("No tag specified for %s"), name
);
2916 coff_type
.tag_ptr
= get_tag (coff_tag
, (localsym_t
*) NULL
,
2917 coff_type
.basic_type
);
2920 if (coff_is_function
)
2922 last_func_type_info
= coff_type
;
2923 last_func_sym_value
= coff_sym_value
;
2927 indx
= add_aux_sym_tir (&coff_type
,
2929 &cur_file_ptr
->thash_head
[0]);
2932 /* Do any last minute adjustments that are necessary. */
2933 switch (coff_symbol_typ
)
2938 /* For the beginning of structs, unions, and enumerations, the
2939 size info needs to be passed in the value field. */
2941 if (coff_type
.num_sizes
- coff_type
.num_dims
- coff_type
.extra_sizes
2944 as_warn (_("Bad COFF debugging information"));
2948 coff_value
= coff_type
.sizes
[0];
2950 coff_inside_enumeration
= (coff_type
.orig_type
== T_ENUM
);
2953 /* For the end of structs, unions, and enumerations, omit the
2954 name which is always ".eos". This needs to be done last, so
2955 that any error reporting above gives the correct name. */
2958 name
= (char *) NULL
;
2960 coff_inside_enumeration
= 0;
2963 /* Members of structures and unions that aren't bitfields, need
2964 to adjust the value from a byte offset to a bit offset.
2965 Members of enumerations do not have the value adjusted, and
2966 can be distinguished by indx == indexNil. For enumerations,
2967 update the maximum enumeration value. */
2969 if (! coff_type
.bitfield
&& ! coff_inside_enumeration
)
2975 /* Add the symbol. */
2976 sym
= add_ecoff_symbol (name
,
2981 (symint_t
) coff_value
,
2984 /* deal with struct, union, and enum tags. */
2985 if (coff_symbol_typ
== st_Block
)
2987 /* Create or update the tag information. */
2988 tag_t
*tag_ptr
= get_tag (name
,
2990 coff_type
.basic_type
);
2993 /* Remember any forward references. */
2994 for (pf
= &sym
->forward_ref
;
2995 *pf
!= (forward_t
*) NULL
;
2998 *pf
= tag_ptr
->forward_ref
;
2999 tag_ptr
->forward_ref
= (forward_t
*) NULL
;
3003 /* Parse .end directives. */
3006 ecoff_directive_end (ignore
)
3014 if (cur_file_ptr
== (efdr_t
*) NULL
)
3016 as_warn (_(".end directive without a preceding .file directive"));
3017 demand_empty_rest_of_line ();
3021 if (cur_proc_ptr
== (proc_t
*) NULL
)
3023 as_warn (_(".end directive without a preceding .ent directive"));
3024 demand_empty_rest_of_line ();
3028 name
= input_line_pointer
;
3029 name_end
= get_symbol_end ();
3032 if (! is_name_beginner (ch
))
3034 as_warn (_(".end directive has no name"));
3035 *input_line_pointer
= name_end
;
3036 demand_empty_rest_of_line ();
3040 /* The value is the distance between the .end directive and the
3041 corresponding symbol. We create a fake symbol to hold the
3042 current location, and put in the offset when we write out the
3044 ent
= symbol_find (name
);
3045 if (ent
== (symbolS
*) NULL
)
3046 as_warn (_(".end directive names unknown symbol"));
3048 (void) add_ecoff_symbol ((const char *) NULL
, st_End
, sc_Text
,
3049 symbol_new ("L0\001", now_seg
,
3050 (valueT
) frag_now_fix (),
3052 (bfd_vma
) 0, (symint_t
) 0, (symint_t
) 0);
3054 cur_proc_ptr
= (proc_t
*) NULL
;
3056 *input_line_pointer
= name_end
;
3057 demand_empty_rest_of_line ();
3060 /* Parse .ent directives. */
3063 ecoff_directive_ent (ignore
)
3070 if (cur_file_ptr
== (efdr_t
*) NULL
)
3071 add_file ((const char *) NULL
, 0, 1);
3073 if (cur_proc_ptr
!= (proc_t
*) NULL
)
3075 as_warn (_("second .ent directive found before .end directive"));
3076 demand_empty_rest_of_line ();
3080 name
= input_line_pointer
;
3081 name_end
= get_symbol_end ();
3084 if (! is_name_beginner (ch
))
3086 as_warn (_(".ent directive has no name"));
3087 *input_line_pointer
= name_end
;
3088 demand_empty_rest_of_line ();
3092 add_procedure (name
);
3094 *input_line_pointer
= name_end
;
3096 /* The .ent directive is sometimes followed by a number. I'm not
3097 really sure what the number means. I don't see any way to store
3098 the information in the PDR. The Irix 4 assembler seems to ignore
3101 if (*input_line_pointer
== ',')
3103 ++input_line_pointer
;
3106 if (isdigit ((unsigned char) *input_line_pointer
)
3107 || *input_line_pointer
== '-')
3108 (void) get_absolute_expression ();
3110 demand_empty_rest_of_line ();
3113 /* Parse .extern directives. */
3116 ecoff_directive_extern (ignore
)
3124 name
= input_line_pointer
;
3125 c
= get_symbol_end ();
3126 symbolp
= symbol_find_or_make (name
);
3127 *input_line_pointer
= c
;
3129 S_SET_EXTERNAL (symbolp
);
3131 if (*input_line_pointer
== ',')
3132 ++input_line_pointer
;
3133 size
= get_absolute_expression ();
3135 symbol_get_obj (symbolp
)->ecoff_extern_size
= size
;
3138 /* Parse .file directives. */
3141 ecoff_directive_file (ignore
)
3148 if (cur_proc_ptr
!= (proc_t
*) NULL
)
3150 as_warn (_("No way to handle .file within .ent/.end section"));
3151 demand_empty_rest_of_line ();
3155 indx
= (int) get_absolute_expression ();
3157 /* FIXME: we don't have to save the name here. */
3158 name
= demand_copy_C_string (&len
);
3160 add_file (name
, indx
- 1, 0);
3162 demand_empty_rest_of_line ();
3165 /* Parse .fmask directives. */
3168 ecoff_directive_fmask (ignore
)
3173 if (cur_proc_ptr
== (proc_t
*) NULL
)
3175 as_warn (_(".fmask outside of .ent"));
3176 demand_empty_rest_of_line ();
3180 if (get_absolute_expression_and_terminator (&val
) != ',')
3182 as_warn (_("Bad .fmask directive"));
3183 --input_line_pointer
;
3184 demand_empty_rest_of_line ();
3188 cur_proc_ptr
->pdr
.fregmask
= val
;
3189 cur_proc_ptr
->pdr
.fregoffset
= get_absolute_expression ();
3191 demand_empty_rest_of_line ();
3194 /* Parse .frame directives. */
3197 ecoff_directive_frame (ignore
)
3202 if (cur_proc_ptr
== (proc_t
*) NULL
)
3204 as_warn (_(".frame outside of .ent"));
3205 demand_empty_rest_of_line ();
3209 cur_proc_ptr
->pdr
.framereg
= tc_get_register (1);
3212 if (*input_line_pointer
++ != ','
3213 || get_absolute_expression_and_terminator (&val
) != ',')
3215 as_warn (_("Bad .frame directive"));
3216 --input_line_pointer
;
3217 demand_empty_rest_of_line ();
3221 cur_proc_ptr
->pdr
.frameoffset
= val
;
3223 cur_proc_ptr
->pdr
.pcreg
= tc_get_register (0);
3226 /* Alpha-OSF1 adds "the offset of saved $a0 from $sp", according to
3227 Sandro. I don't yet know where this value should be stored, if
3229 demand_empty_rest_of_line ();
3235 /* Parse .mask directives. */
3238 ecoff_directive_mask (ignore
)
3243 if (cur_proc_ptr
== (proc_t
*) NULL
)
3245 as_warn (_(".mask outside of .ent"));
3246 demand_empty_rest_of_line ();
3250 if (get_absolute_expression_and_terminator (&val
) != ',')
3252 as_warn (_("Bad .mask directive"));
3253 --input_line_pointer
;
3254 demand_empty_rest_of_line ();
3258 cur_proc_ptr
->pdr
.regmask
= val
;
3259 cur_proc_ptr
->pdr
.regoffset
= get_absolute_expression ();
3261 demand_empty_rest_of_line ();
3264 /* Parse .loc directives. */
3267 ecoff_directive_loc (ignore
)
3270 lineno_list_t
*list
;
3273 if (cur_file_ptr
== (efdr_t
*) NULL
)
3275 as_warn (_(".loc before .file"));
3276 demand_empty_rest_of_line ();
3280 if (now_seg
!= text_section
)
3282 as_warn (_(".loc outside of .text"));
3283 demand_empty_rest_of_line ();
3287 /* Skip the file number. */
3289 get_absolute_expression ();
3292 lineno
= get_absolute_expression ();
3296 listing_source_line (lineno
);
3299 /* If we're building stabs, then output a special label rather than
3300 ECOFF line number info. */
3303 (void) add_ecoff_symbol ((char *) NULL
, st_Label
, sc_Text
,
3304 symbol_new ("L0\001", now_seg
,
3305 (valueT
) frag_now_fix (),
3307 (bfd_vma
) 0, 0, lineno
);
3311 list
= allocate_lineno_list ();
3313 list
->next
= (lineno_list_t
*) NULL
;
3314 list
->file
= cur_file_ptr
;
3315 list
->proc
= cur_proc_ptr
;
3316 list
->frag
= frag_now
;
3317 list
->paddr
= frag_now_fix ();
3318 list
->lineno
= lineno
;
3320 /* We don't want to merge files which have line numbers. */
3321 cur_file_ptr
->fdr
.fMerge
= 0;
3323 /* A .loc directive will sometimes appear before a .ent directive,
3324 which means that cur_proc_ptr will be NULL here. Arrange to
3326 if (cur_proc_ptr
== (proc_t
*) NULL
)
3330 pl
= &noproc_lineno
;
3331 while (*pl
!= (lineno_list_t
*) NULL
)
3338 *last_lineno_ptr
= list
;
3339 last_lineno_ptr
= &list
->next
;
3343 /* The MIPS assembler sometimes inserts nop instructions in the
3344 instruction stream. When this happens, we must patch up the .loc
3345 information so that it points to the instruction after the nop. */
3348 ecoff_fix_loc (old_frag
, old_frag_offset
)
3350 unsigned long old_frag_offset
;
3352 if (last_lineno
!= NULL
3353 && last_lineno
->frag
== old_frag
3354 && last_lineno
->paddr
== old_frag_offset
)
3356 last_lineno
->frag
= frag_now
;
3357 last_lineno
->paddr
= frag_now_fix ();
3361 /* Make sure the @stabs symbol is emitted. */
3369 /* Add a dummy @stabs dymbol. */
3371 (void) add_ecoff_symbol (stabs_symbol
, stNil
, scInfo
,
3373 (bfd_vma
) 0, (symint_t
) -1,
3374 ECOFF_MARK_STAB (0));
3378 /* Parse .weakext directives. */
3380 /* For TC_MIPS use the version in tc-mips.c. */
3382 ecoff_directive_weakext (ignore
)
3390 name
= input_line_pointer
;
3391 c
= get_symbol_end ();
3392 symbolP
= symbol_find_or_make (name
);
3393 *input_line_pointer
= c
;
3397 if (*input_line_pointer
== ',')
3399 if (S_IS_DEFINED (symbolP
))
3401 as_bad (_("Ignoring attempt to redefine symbol `%s'."),
3402 S_GET_NAME (symbolP
));
3403 ignore_rest_of_line ();
3407 ++input_line_pointer
;
3409 if (! is_end_of_line
[(unsigned char) *input_line_pointer
])
3412 if (exp
.X_op
!= O_symbol
)
3414 as_bad (_("bad .weakext directive"));
3415 ignore_rest_of_line ();
3418 symbol_set_value_expression (symbolP
, &exp
);
3422 S_SET_WEAK (symbolP
);
3424 demand_empty_rest_of_line ();
3426 #endif /* not TC_MIPS */
3428 /* Handle .stabs directives. The actual parsing routine is done by a
3429 generic routine. This routine is called via OBJ_PROCESS_STAB.
3430 When this is called, input_line_pointer will be pointing at the
3431 value field of the stab.
3433 .stabs directives have five fields:
3434 "string" a string, encoding the type information.
3435 code a numeric code, defined in <stab.h>
3437 desc a zero or line number
3438 value a numeric value or an address.
3440 If the value is relocatable, we transform this into:
3441 iss points as an index into string space
3442 value value from lookup of the name
3443 st st from lookup of the name
3444 sc sc from lookup of the name
3445 index code|CODE_MASK
3447 If the value is not relocatable, we transform this into:
3448 iss points as an index into string space
3452 index code|CODE_MASK
3454 .stabn directives have four fields (string is null):
3455 code a numeric code, defined in <stab.h>
3457 desc a zero or a line number
3458 value a numeric value or an address. */
3461 ecoff_stab (sec
, what
, string
, type
, other
, desc
)
3469 efdr_t
*save_file_ptr
= cur_file_ptr
;
3476 localsym_t
*hold
= NULL
;
3478 ecoff_debugging_seen
= 1;
3480 /* We don't handle .stabd. */
3481 if (what
!= 's' && what
!= 'n')
3483 as_bad (_(".stab%c is not supported"), what
);
3487 /* A .stabn uses a null name, not an empty string. */
3491 /* We ignore the other field. */
3493 as_warn (_(".stab%c: ignoring non-zero other field"), what
);
3495 /* Make sure we have a current file. */
3496 if (cur_file_ptr
== (efdr_t
*) NULL
)
3498 add_file ((const char *) NULL
, 0, 1);
3499 save_file_ptr
= cur_file_ptr
;
3502 /* For stabs in ECOFF, the first symbol must be @stabs. This is a
3504 if (stabs_seen
== 0)
3507 /* Line number stabs are handled differently, since they have two
3508 values, the line number and the address of the label. We use the
3509 index field (aka desc) to hold the line number, and the value
3510 field to hold the address. The symbol type is st_Label, which
3511 should be different from the other stabs, so that gdb can
3513 if (type
== N_SLINE
)
3521 listing_source_line ((unsigned int) desc
);
3524 dummy_symr
.index
= desc
;
3525 if (dummy_symr
.index
!= desc
)
3527 as_warn (_("Line number (%d) for .stab%c directive cannot fit in index field (20 bits)"),
3532 name
= input_line_pointer
;
3533 name_end
= get_symbol_end ();
3535 sym
= symbol_find_or_make (name
);
3536 *input_line_pointer
= name_end
;
3547 if (listing
&& (type
== N_SO
|| type
== N_SOL
))
3548 listing_source_file (string
);
3551 if (isdigit ((unsigned char) *input_line_pointer
)
3552 || *input_line_pointer
== '-'
3553 || *input_line_pointer
== '+')
3557 sym
= (symbolS
*) NULL
;
3558 value
= get_absolute_expression ();
3561 else if (! is_name_beginner ((unsigned char) *input_line_pointer
))
3563 as_warn (_("Illegal .stab%c directive, bad character"), what
);
3574 if (exp
.X_op
== O_constant
)
3577 value
= exp
.X_add_number
;
3580 else if (exp
.X_op
== O_symbol
)
3582 sym
= exp
.X_add_symbol
;
3584 addend
= exp
.X_add_number
;
3588 sym
= make_expr_symbol (&exp
);
3594 indx
= ECOFF_MARK_STAB (type
);
3597 /* Don't store the stabs symbol we are creating as the type of the
3598 ECOFF symbol. We want to compute the type of the ECOFF symbol
3600 if (sym
!= (symbolS
*) NULL
)
3601 hold
= symbol_get_obj (sym
)->ecoff_symbol
;
3603 (void) add_ecoff_symbol (string
, st
, sc
, sym
, addend
, value
, indx
);
3605 if (sym
!= (symbolS
*) NULL
)
3606 symbol_get_obj (sym
)->ecoff_symbol
= hold
;
3608 /* Restore normal file type. */
3609 cur_file_ptr
= save_file_ptr
;
3612 /* Frob an ECOFF symbol. Small common symbols go into a special
3613 .scommon section rather than bfd_com_section. */
3616 ecoff_frob_symbol (sym
)
3619 if (S_IS_COMMON (sym
)
3620 && S_GET_VALUE (sym
) > 0
3621 && S_GET_VALUE (sym
) <= bfd_get_gp_size (stdoutput
))
3623 static asection scom_section
;
3624 static asymbol scom_symbol
;
3626 /* We must construct a fake section similar to bfd_com_section
3627 but with the name .scommon. */
3628 if (scom_section
.name
== NULL
)
3630 scom_section
= bfd_com_section
;
3631 scom_section
.name
= ".scommon";
3632 scom_section
.output_section
= &scom_section
;
3633 scom_section
.symbol
= &scom_symbol
;
3634 scom_section
.symbol_ptr_ptr
= &scom_section
.symbol
;
3635 scom_symbol
= *bfd_com_section
.symbol
;
3636 scom_symbol
.name
= ".scommon";
3637 scom_symbol
.section
= &scom_section
;
3639 S_SET_SEGMENT (sym
, &scom_section
);
3642 /* Double check weak symbols. */
3643 if (S_IS_WEAK (sym
))
3645 if (S_IS_COMMON (sym
))
3646 as_bad (_("Symbol `%s' can not be both weak and common"),
3651 /* Add bytes to the symbolic information buffer. */
3654 ecoff_add_bytes (buf
, bufend
, bufptr
, need
)
3664 need
-= *bufend
- bufptr
;
3665 if (need
< PAGE_SIZE
)
3667 want
= (*bufend
- *buf
) + need
;
3668 *buf
= xrealloc (*buf
, want
);
3669 *bufend
= *buf
+ want
;
3673 /* Adjust the symbolic information buffer to the alignment required
3674 for the ECOFF target debugging information. */
3676 static unsigned long
3677 ecoff_padding_adjust (backend
, buf
, bufend
, offset
, bufptrptr
)
3678 const struct ecoff_debug_swap
*backend
;
3681 unsigned long offset
;
3684 bfd_size_type align
;
3686 align
= backend
->debug_align
;
3687 if ((offset
& (align
- 1)) != 0)
3691 add
= align
- (offset
& (align
- 1));
3692 if (*bufend
- (*buf
+ offset
) < add
)
3693 (void) ecoff_add_bytes (buf
, bufend
, *buf
+ offset
, add
);
3694 memset (*buf
+ offset
, 0, add
);
3696 if (bufptrptr
!= (char **) NULL
)
3697 *bufptrptr
= *buf
+ offset
;
3703 /* Build the line number information. */
3705 static unsigned long
3706 ecoff_build_lineno (backend
, buf
, bufend
, offset
, linecntptr
)
3707 const struct ecoff_debug_swap
*backend
;
3710 unsigned long offset
;
3714 register lineno_list_t
*l
;
3715 lineno_list_t
*last
;
3721 lineno_list_t first
;
3722 lineno_list_t
*local_first_lineno
= first_lineno
;
3724 if (linecntptr
!= (long *) NULL
)
3727 bufptr
= *buf
+ offset
;
3729 file
= (efdr_t
*) NULL
;
3730 proc
= (proc_t
*) NULL
;
3731 last
= (lineno_list_t
*) NULL
;
3736 /* For some reason the address of the first procedure is ignored
3737 when reading line numbers. This doesn't matter if the address of
3738 the first procedure is 0, but when gcc is generating MIPS
3739 embedded PIC code, it will put strings in the .text section
3740 before the first procedure. We cope by inserting a dummy line if
3741 the address of the first procedure is not 0. Hopefully this
3742 won't screw things up too badly.
3744 Don't do this for ECOFF assembly source line numbers. They work
3745 without this extra attention. */
3746 if (debug_type
!= DEBUG_ECOFF
3747 && first_proc_ptr
!= (proc_t
*) NULL
3748 && local_first_lineno
!= (lineno_list_t
*) NULL
3749 && ((S_GET_VALUE (first_proc_ptr
->sym
->as_sym
)
3750 + bfd_get_section_vma (stdoutput
,
3751 S_GET_SEGMENT (first_proc_ptr
->sym
->as_sym
)))
3754 first
.file
= local_first_lineno
->file
;
3755 first
.proc
= local_first_lineno
->proc
;
3756 first
.frag
= &zero_address_frag
;
3760 first
.next
= local_first_lineno
;
3761 local_first_lineno
= &first
;
3764 for (l
= local_first_lineno
; l
!= (lineno_list_t
*) NULL
; l
= l
->next
)
3769 /* Get the offset to the memory address of the next line number
3770 (in words). Do this first, so that we can skip ahead to the
3771 next useful line number entry. */
3772 if (l
->next
== (lineno_list_t
*) NULL
)
3774 /* We want a count of zero, but it will be decremented
3775 before it is used. */
3778 else if (l
->next
->frag
->fr_address
+ l
->next
->paddr
3779 > l
->frag
->fr_address
+ l
->paddr
)
3781 count
= ((l
->next
->frag
->fr_address
+ l
->next
->paddr
3782 - (l
->frag
->fr_address
+ l
->paddr
))
3787 /* Don't change last, so we still get the right delta. */
3791 if (l
->file
!= file
|| l
->proc
!= proc
)
3793 if (l
->proc
!= proc
&& proc
!= (proc_t
*) NULL
)
3794 proc
->pdr
.lnHigh
= last
->lineno
;
3795 if (l
->file
!= file
&& file
!= (efdr_t
*) NULL
)
3797 file
->fdr
.cbLine
= c
- file
->fdr
.cbLineOffset
;
3798 file
->fdr
.cline
= totcount
+ count
;
3799 if (linecntptr
!= (long *) NULL
)
3800 *linecntptr
+= totcount
+ count
;
3804 if (l
->file
!= file
)
3806 efdr_t
*last_file
= file
;
3809 if (last_file
!= (efdr_t
*) NULL
)
3811 = last_file
->fdr
.ilineBase
+ last_file
->fdr
.cline
;
3813 file
->fdr
.ilineBase
= 0;
3814 file
->fdr
.cbLineOffset
= c
;
3816 if (l
->proc
!= proc
)
3819 if (proc
!= (proc_t
*) NULL
)
3821 proc
->pdr
.lnLow
= l
->lineno
;
3822 proc
->pdr
.cbLineOffset
= c
- file
->fdr
.cbLineOffset
;
3823 proc
->pdr
.iline
= totcount
;
3827 last
= (lineno_list_t
*) NULL
;
3832 /* Get the offset to this line number. */
3833 if (last
== (lineno_list_t
*) NULL
)
3836 delta
= l
->lineno
- last
->lineno
;
3838 /* Put in the offset to this line number. */
3843 /* 1 is added to each count read. */
3845 /* We can only adjust the word count by up to 15 words at a
3857 if (delta
>= -7 && delta
<= 7)
3859 if (bufptr
>= *bufend
)
3860 bufptr
= ecoff_add_bytes (buf
, bufend
, bufptr
, (long) 1);
3861 *bufptr
++ = setcount
+ (delta
<< 4);
3869 if (*bufend
- bufptr
< 3)
3870 bufptr
= ecoff_add_bytes (buf
, bufend
, bufptr
, (long) 3);
3871 *bufptr
++ = setcount
+ (8 << 4);
3872 if (delta
< -0x8000)
3877 else if (delta
> 0x7fff)
3887 *bufptr
++ = set
>> 8;
3888 *bufptr
++ = set
& 0xffff;
3893 /* Finish adjusting the count. */
3896 if (bufptr
>= *bufend
)
3897 bufptr
= ecoff_add_bytes (buf
, bufend
, bufptr
, (long) 1);
3898 /* 1 is added to each count read. */
3917 if (proc
!= (proc_t
*) NULL
)
3918 proc
->pdr
.lnHigh
= last
->lineno
;
3919 if (file
!= (efdr_t
*) NULL
)
3921 file
->fdr
.cbLine
= c
- file
->fdr
.cbLineOffset
;
3922 file
->fdr
.cline
= totcount
;
3925 if (linecntptr
!= (long *) NULL
)
3926 *linecntptr
+= totcount
;
3928 c
= ecoff_padding_adjust (backend
, buf
, bufend
, c
, &bufptr
);
3933 /* Build and swap out the symbols. */
3935 static unsigned long
3936 ecoff_build_symbols (backend
, buf
, bufend
, offset
)
3937 const struct ecoff_debug_swap
*backend
;
3940 unsigned long offset
;
3942 const bfd_size_type external_sym_size
= backend
->external_sym_size
;
3943 void (* const swap_sym_out
) PARAMS ((bfd
*, const SYMR
*, PTR
))
3944 = backend
->swap_sym_out
;
3947 vlinks_t
*file_link
;
3949 sym_out
= *buf
+ offset
;
3953 /* The symbols are stored by file. */
3954 for (file_link
= file_desc
.first
;
3955 file_link
!= (vlinks_t
*) NULL
;
3956 file_link
= file_link
->next
)
3963 if (file_link
->next
== (vlinks_t
*) NULL
)
3964 fil_cnt
= file_desc
.objects_last_page
;
3966 fil_cnt
= file_desc
.objects_per_page
;
3967 fil_ptr
= file_link
->datum
->file
;
3968 fil_end
= fil_ptr
+ fil_cnt
;
3969 for (; fil_ptr
< fil_end
; fil_ptr
++)
3973 fil_ptr
->fdr
.isymBase
= isym
;
3975 for (sym_link
= fil_ptr
->symbols
.first
;
3976 sym_link
!= (vlinks_t
*) NULL
;
3977 sym_link
= sym_link
->next
)
3980 localsym_t
*sym_ptr
;
3981 localsym_t
*sym_end
;
3983 if (sym_link
->next
== (vlinks_t
*) NULL
)
3984 sym_cnt
= fil_ptr
->symbols
.objects_last_page
;
3986 sym_cnt
= fil_ptr
->symbols
.objects_per_page
;
3987 sym_ptr
= sym_link
->datum
->sym
;
3988 sym_end
= sym_ptr
+ sym_cnt
;
3989 for (; sym_ptr
< sym_end
; sym_ptr
++)
3995 know (sym_ptr
->file_ptr
== fil_ptr
);
3997 /* If there is no associated gas symbol, then this
3998 is a pure debugging symbol. We have already
3999 added the name (if any) to fil_ptr->strings.
4000 Otherwise we must decide whether this is an
4001 external or a local symbol (actually, it may be
4002 both if the local provides additional debugging
4003 information for the external). */
4005 as_sym
= sym_ptr
->as_sym
;
4006 if (as_sym
!= (symbolS
*) NULL
)
4010 /* The value of a block start symbol is the
4011 offset from the start of the procedure. For
4012 other symbols we just use the gas value (but
4013 we must offset it by the vma of the section,
4014 just as BFD does, because BFD will not see
4016 if (sym_ptr
->ecoff_sym
.asym
.st
== (int) st_Block
4017 && sym_ptr
->ecoff_sym
.asym
.sc
== (int) sc_Text
)
4021 know (sym_ptr
->proc_ptr
!= (proc_t
*) NULL
);
4022 begin_sym
= sym_ptr
->proc_ptr
->sym
->as_sym
;
4023 if (S_GET_SEGMENT (as_sym
)
4024 != S_GET_SEGMENT (begin_sym
))
4025 as_warn (_(".begin/.bend in different segments"));
4026 sym_ptr
->ecoff_sym
.asym
.value
=
4027 S_GET_VALUE (as_sym
) - S_GET_VALUE (begin_sym
);
4030 sym_ptr
->ecoff_sym
.asym
.value
=
4031 (S_GET_VALUE (as_sym
)
4032 + bfd_get_section_vma (stdoutput
,
4033 S_GET_SEGMENT (as_sym
))
4036 sym_ptr
->ecoff_sym
.weakext
= S_IS_WEAK (as_sym
);
4038 /* Set st_Proc to st_StaticProc for local
4040 if (sym_ptr
->ecoff_sym
.asym
.st
== st_Proc
4041 && S_IS_DEFINED (as_sym
)
4042 && ! S_IS_EXTERNAL (as_sym
)
4043 && ! S_IS_WEAK (as_sym
))
4044 sym_ptr
->ecoff_sym
.asym
.st
= st_StaticProc
;
4046 /* Get the type and storage class based on where
4047 the symbol actually wound up. Traditionally,
4048 N_LBRAC and N_RBRAC are *not* relocated. */
4049 indx
= sym_ptr
->ecoff_sym
.asym
.index
;
4050 if (sym_ptr
->ecoff_sym
.asym
.st
== st_Nil
4051 && sym_ptr
->ecoff_sym
.asym
.sc
== sc_Nil
4052 && (! ECOFF_IS_STAB (&sym_ptr
->ecoff_sym
.asym
)
4053 || ((ECOFF_UNMARK_STAB (indx
) != N_LBRAC
)
4054 && (ECOFF_UNMARK_STAB (indx
) != N_RBRAC
))))
4057 const char *segname
;
4061 seg
= S_GET_SEGMENT (as_sym
);
4062 segname
= segment_name (seg
);
4064 if (! ECOFF_IS_STAB (&sym_ptr
->ecoff_sym
.asym
)
4065 && (S_IS_EXTERNAL (as_sym
)
4066 || S_IS_WEAK (as_sym
)
4067 || ! S_IS_DEFINED (as_sym
)))
4069 if ((symbol_get_bfdsym (as_sym
)->flags
4070 & BSF_FUNCTION
) != 0)
4075 else if (seg
== text_section
)
4080 if (! S_IS_DEFINED (as_sym
))
4084 s
= symbol_get_obj (as_sym
)->ecoff_extern_size
;
4086 || s
> bfd_get_gp_size (stdoutput
))
4091 sym_ptr
->ecoff_sym
.asym
.value
= s
;
4094 S_SET_SIZE (as_sym
, s
);
4097 else if (S_IS_COMMON (as_sym
))
4099 if (S_GET_VALUE (as_sym
) > 0
4100 && (S_GET_VALUE (as_sym
)
4101 <= bfd_get_gp_size (stdoutput
)))
4106 else if (seg
== text_section
)
4108 else if (seg
== data_section
)
4110 else if (strcmp (segname
, ".rdata") == 0
4111 || strcmp (segname
, ".rodata") == 0)
4113 else if (strcmp (segname
, ".sdata") == 0)
4115 else if (seg
== bss_section
)
4117 else if (strcmp (segname
, ".sbss") == 0)
4119 else if (seg
== &bfd_abs_section
)
4123 /* This must be a user named section.
4124 This is not possible in ECOFF, but it
4129 sym_ptr
->ecoff_sym
.asym
.st
= (int) st
;
4130 sym_ptr
->ecoff_sym
.asym
.sc
= (int) sc
;
4133 /* This is just an external symbol if it is
4134 outside a procedure and it has a type.
4135 FIXME: g++ will generate symbols which have
4136 different names in the debugging information
4137 than the actual symbol. Should we handle
4139 if ((S_IS_EXTERNAL (as_sym
)
4140 || S_IS_WEAK (as_sym
)
4141 || ! S_IS_DEFINED (as_sym
))
4142 && sym_ptr
->proc_ptr
== (proc_t
*) NULL
4143 && sym_ptr
->ecoff_sym
.asym
.st
!= (int) st_Nil
4144 && ! ECOFF_IS_STAB (&sym_ptr
->ecoff_sym
.asym
))
4147 /* This is just an external symbol if it is a
4149 if (S_IS_COMMON (as_sym
))
4152 /* If an st_end symbol has an associated gas
4153 symbol, then it is a local label created for
4154 a .bend or .end directive. Stabs line
4155 numbers will have \001 in the names. */
4157 && sym_ptr
->ecoff_sym
.asym
.st
!= st_End
4158 && strchr (sym_ptr
->name
, '\001') == 0)
4159 sym_ptr
->ecoff_sym
.asym
.iss
=
4160 add_string (&fil_ptr
->strings
,
4166 /* We now know the index of this symbol; fill in
4167 locations that have been waiting for that
4169 if (sym_ptr
->begin_ptr
!= (localsym_t
*) NULL
)
4171 localsym_t
*begin_ptr
;
4175 begin_ptr
= sym_ptr
->begin_ptr
;
4176 know (begin_ptr
->sym_index
!= -1);
4177 sym_ptr
->ecoff_sym
.asym
.index
= begin_ptr
->sym_index
;
4178 if (sym_ptr
->ecoff_sym
.asym
.sc
!= (int) sc_Info
)
4179 sym_ptr
->ecoff_sym
.asym
.iss
=
4180 begin_ptr
->ecoff_sym
.asym
.iss
;
4182 begin_type
= begin_ptr
->ecoff_sym
.asym
.st
;
4183 if (begin_type
== st_File
4184 || begin_type
== st_Block
)
4186 begin_ptr
->ecoff_sym
.asym
.index
=
4187 isym
- ifilesym
+ 1;
4188 (*swap_sym_out
) (stdoutput
,
4189 &begin_ptr
->ecoff_sym
.asym
,
4192 + (begin_ptr
->sym_index
4193 * external_sym_size
)));
4197 know (begin_ptr
->index_ptr
!= (aux_t
*) NULL
);
4198 begin_ptr
->index_ptr
->data
.isym
=
4199 isym
- ifilesym
+ 1;
4202 /* The value of the symbol marking the end of a
4203 procedure is the size of the procedure. The
4204 value of the symbol marking the end of a
4205 block is the offset from the start of the
4206 procedure to the block. */
4207 if (begin_type
== st_Proc
4208 || begin_type
== st_StaticProc
)
4210 know (as_sym
!= (symbolS
*) NULL
);
4211 know (begin_ptr
->as_sym
!= (symbolS
*) NULL
);
4212 if (S_GET_SEGMENT (as_sym
)
4213 != S_GET_SEGMENT (begin_ptr
->as_sym
))
4214 as_warn (_(".begin/.bend in different segments"));
4215 sym_ptr
->ecoff_sym
.asym
.value
=
4216 (S_GET_VALUE (as_sym
)
4217 - S_GET_VALUE (begin_ptr
->as_sym
));
4219 /* If the size is odd, this is probably a
4220 mips16 function; force it to be even. */
4221 if ((sym_ptr
->ecoff_sym
.asym
.value
& 1) != 0)
4222 ++sym_ptr
->ecoff_sym
.asym
.value
;
4225 S_SET_SIZE (begin_ptr
->as_sym
,
4226 sym_ptr
->ecoff_sym
.asym
.value
);
4229 else if (begin_type
== st_Block
4230 && sym_ptr
->ecoff_sym
.asym
.sc
!= (int) sc_Info
)
4234 know (as_sym
!= (symbolS
*) NULL
);
4235 know (sym_ptr
->proc_ptr
!= (proc_t
*) NULL
);
4236 begin_sym
= sym_ptr
->proc_ptr
->sym
->as_sym
;
4237 if (S_GET_SEGMENT (as_sym
)
4238 != S_GET_SEGMENT (begin_sym
))
4239 as_warn (_(".begin/.bend in different segments"));
4240 sym_ptr
->ecoff_sym
.asym
.value
=
4241 S_GET_VALUE (as_sym
) - S_GET_VALUE (begin_sym
);
4245 for (f
= sym_ptr
->forward_ref
;
4246 f
!= (forward_t
*) NULL
;
4250 f
->ifd_ptr
->data
.isym
= fil_ptr
->file_index
;
4251 f
->index_ptr
->data
.rndx
.index
= isym
- ifilesym
;
4256 if (*bufend
- sym_out
< external_sym_size
)
4257 sym_out
= ecoff_add_bytes (buf
, bufend
,
4260 (*swap_sym_out
) (stdoutput
, &sym_ptr
->ecoff_sym
.asym
,
4262 sym_out
+= external_sym_size
;
4264 sym_ptr
->sym_index
= isym
;
4266 if (sym_ptr
->proc_ptr
!= (proc_t
*) NULL
4267 && sym_ptr
->proc_ptr
->sym
== sym_ptr
)
4268 sym_ptr
->proc_ptr
->pdr
.isym
= isym
- ifilesym
;
4273 /* Record the local symbol index and file number in
4274 case this is an external symbol. Note that this
4275 destroys the asym.index field. */
4276 if (as_sym
!= (symbolS
*) NULL
4277 && symbol_get_obj (as_sym
)->ecoff_symbol
== sym_ptr
)
4279 if ((sym_ptr
->ecoff_sym
.asym
.st
== st_Proc
4280 || sym_ptr
->ecoff_sym
.asym
.st
== st_StaticProc
)
4282 sym_ptr
->ecoff_sym
.asym
.index
= isym
- ifilesym
- 1;
4283 sym_ptr
->ecoff_sym
.ifd
= fil_ptr
->file_index
;
4285 /* Don't try to merge an FDR which has an
4286 external symbol attached to it. */
4287 if (S_IS_EXTERNAL (as_sym
) || S_IS_WEAK (as_sym
))
4288 fil_ptr
->fdr
.fMerge
= 0;
4292 fil_ptr
->fdr
.csym
= isym
- fil_ptr
->fdr
.isymBase
;
4296 return offset
+ isym
* external_sym_size
;
4299 /* Swap out the procedure information. */
4301 static unsigned long
4302 ecoff_build_procs (backend
, buf
, bufend
, offset
)
4303 const struct ecoff_debug_swap
*backend
;
4306 unsigned long offset
;
4308 const bfd_size_type external_pdr_size
= backend
->external_pdr_size
;
4309 void (* const swap_pdr_out
) PARAMS ((bfd
*, const PDR
*, PTR
))
4310 = backend
->swap_pdr_out
;
4313 vlinks_t
*file_link
;
4315 pdr_out
= *buf
+ offset
;
4319 /* The procedures are stored by file. */
4320 for (file_link
= file_desc
.first
;
4321 file_link
!= (vlinks_t
*) NULL
;
4322 file_link
= file_link
->next
)
4328 if (file_link
->next
== (vlinks_t
*) NULL
)
4329 fil_cnt
= file_desc
.objects_last_page
;
4331 fil_cnt
= file_desc
.objects_per_page
;
4332 fil_ptr
= file_link
->datum
->file
;
4333 fil_end
= fil_ptr
+ fil_cnt
;
4334 for (; fil_ptr
< fil_end
; fil_ptr
++)
4336 vlinks_t
*proc_link
;
4339 fil_ptr
->fdr
.ipdFirst
= iproc
;
4341 for (proc_link
= fil_ptr
->procs
.first
;
4342 proc_link
!= (vlinks_t
*) NULL
;
4343 proc_link
= proc_link
->next
)
4349 if (proc_link
->next
== (vlinks_t
*) NULL
)
4350 prc_cnt
= fil_ptr
->procs
.objects_last_page
;
4352 prc_cnt
= fil_ptr
->procs
.objects_per_page
;
4353 proc_ptr
= proc_link
->datum
->proc
;
4354 proc_end
= proc_ptr
+ prc_cnt
;
4355 for (; proc_ptr
< proc_end
; proc_ptr
++)
4360 adr_sym
= proc_ptr
->sym
->as_sym
;
4361 adr
= (S_GET_VALUE (adr_sym
)
4362 + bfd_get_section_vma (stdoutput
,
4363 S_GET_SEGMENT (adr_sym
)));
4366 /* This code used to force the adr of the very
4367 first fdr to be 0. However, the native tools
4368 don't do that, and I can't remember why it
4369 used to work that way, so I took it out. */
4370 fil_ptr
->fdr
.adr
= adr
;
4373 proc_ptr
->pdr
.adr
= adr
- fil_ptr
->fdr
.adr
;
4374 if (*bufend
- pdr_out
< external_pdr_size
)
4375 pdr_out
= ecoff_add_bytes (buf
, bufend
,
4378 (*swap_pdr_out
) (stdoutput
, &proc_ptr
->pdr
, pdr_out
);
4379 pdr_out
+= external_pdr_size
;
4383 fil_ptr
->fdr
.cpd
= iproc
- fil_ptr
->fdr
.ipdFirst
;
4387 return offset
+ iproc
* external_pdr_size
;
4390 /* Swap out the aux information. */
4392 static unsigned long
4393 ecoff_build_aux (backend
, buf
, bufend
, offset
)
4394 const struct ecoff_debug_swap
*backend
;
4397 unsigned long offset
;
4400 union aux_ext
*aux_out
;
4402 vlinks_t
*file_link
;
4404 bigendian
= bfd_big_endian (stdoutput
);
4406 aux_out
= (union aux_ext
*) (*buf
+ offset
);
4410 /* The aux entries are stored by file. */
4411 for (file_link
= file_desc
.first
;
4412 file_link
!= (vlinks_t
*) NULL
;
4413 file_link
= file_link
->next
)
4419 if (file_link
->next
== (vlinks_t
*) NULL
)
4420 fil_cnt
= file_desc
.objects_last_page
;
4422 fil_cnt
= file_desc
.objects_per_page
;
4423 fil_ptr
= file_link
->datum
->file
;
4424 fil_end
= fil_ptr
+ fil_cnt
;
4425 for (; fil_ptr
< fil_end
; fil_ptr
++)
4429 fil_ptr
->fdr
.fBigendian
= bigendian
;
4430 fil_ptr
->fdr
.iauxBase
= iaux
;
4431 for (aux_link
= fil_ptr
->aux_syms
.first
;
4432 aux_link
!= (vlinks_t
*) NULL
;
4433 aux_link
= aux_link
->next
)
4439 if (aux_link
->next
== (vlinks_t
*) NULL
)
4440 aux_cnt
= fil_ptr
->aux_syms
.objects_last_page
;
4442 aux_cnt
= fil_ptr
->aux_syms
.objects_per_page
;
4443 aux_ptr
= aux_link
->datum
->aux
;
4444 aux_end
= aux_ptr
+ aux_cnt
;
4445 for (; aux_ptr
< aux_end
; aux_ptr
++)
4447 if (*bufend
- (char *) aux_out
< sizeof (union aux_ext
))
4448 aux_out
= ((union aux_ext
*)
4449 ecoff_add_bytes (buf
, bufend
,
4451 sizeof (union aux_ext
)));
4452 switch (aux_ptr
->type
)
4455 (*backend
->swap_tir_out
) (bigendian
,
4460 (*backend
->swap_rndx_out
) (bigendian
,
4461 &aux_ptr
->data
.rndx
,
4465 AUX_PUT_DNLOW (bigendian
, aux_ptr
->data
.dnLow
,
4469 AUX_PUT_DNHIGH (bigendian
, aux_ptr
->data
.dnHigh
,
4473 AUX_PUT_ISYM (bigendian
, aux_ptr
->data
.isym
,
4477 AUX_PUT_ISS (bigendian
, aux_ptr
->data
.iss
,
4481 AUX_PUT_WIDTH (bigendian
, aux_ptr
->data
.width
,
4485 AUX_PUT_COUNT (bigendian
, aux_ptr
->data
.count
,
4494 fil_ptr
->fdr
.caux
= iaux
- fil_ptr
->fdr
.iauxBase
;
4498 return ecoff_padding_adjust (backend
, buf
, bufend
,
4499 offset
+ iaux
* sizeof (union aux_ext
),
4503 /* Copy out the strings from a varray_t. This returns the number of
4504 bytes copied, rather than the new offset. */
4506 static unsigned long
4507 ecoff_build_strings (buf
, bufend
, offset
, vp
)
4510 unsigned long offset
;
4517 str_out
= *buf
+ offset
;
4521 for (str_link
= vp
->first
;
4522 str_link
!= (vlinks_t
*) NULL
;
4523 str_link
= str_link
->next
)
4525 unsigned long str_cnt
;
4527 if (str_link
->next
== (vlinks_t
*) NULL
)
4528 str_cnt
= vp
->objects_last_page
;
4530 str_cnt
= vp
->objects_per_page
;
4532 if (*bufend
- str_out
< str_cnt
)
4533 str_out
= ecoff_add_bytes (buf
, bufend
, str_out
, str_cnt
);
4535 memcpy (str_out
, str_link
->datum
->byte
, str_cnt
);
4543 /* Dump out the local strings. */
4545 static unsigned long
4546 ecoff_build_ss (backend
, buf
, bufend
, offset
)
4547 const struct ecoff_debug_swap
*backend
;
4550 unsigned long offset
;
4553 vlinks_t
*file_link
;
4557 for (file_link
= file_desc
.first
;
4558 file_link
!= (vlinks_t
*) NULL
;
4559 file_link
= file_link
->next
)
4565 if (file_link
->next
== (vlinks_t
*) NULL
)
4566 fil_cnt
= file_desc
.objects_last_page
;
4568 fil_cnt
= file_desc
.objects_per_page
;
4569 fil_ptr
= file_link
->datum
->file
;
4570 fil_end
= fil_ptr
+ fil_cnt
;
4571 for (; fil_ptr
< fil_end
; fil_ptr
++)
4575 fil_ptr
->fdr
.issBase
= iss
;
4576 ss_cnt
= ecoff_build_strings (buf
, bufend
, offset
+ iss
,
4578 fil_ptr
->fdr
.cbSs
= ss_cnt
;
4583 return ecoff_padding_adjust (backend
, buf
, bufend
, offset
+ iss
,
4587 /* Swap out the file descriptors. */
4589 static unsigned long
4590 ecoff_build_fdr (backend
, buf
, bufend
, offset
)
4591 const struct ecoff_debug_swap
*backend
;
4594 unsigned long offset
;
4596 const bfd_size_type external_fdr_size
= backend
->external_fdr_size
;
4597 void (* const swap_fdr_out
) PARAMS ((bfd
*, const FDR
*, PTR
))
4598 = backend
->swap_fdr_out
;
4601 vlinks_t
*file_link
;
4605 fdr_out
= *buf
+ offset
;
4607 for (file_link
= file_desc
.first
;
4608 file_link
!= (vlinks_t
*) NULL
;
4609 file_link
= file_link
->next
)
4615 if (file_link
->next
== (vlinks_t
*) NULL
)
4616 fil_cnt
= file_desc
.objects_last_page
;
4618 fil_cnt
= file_desc
.objects_per_page
;
4619 fil_ptr
= file_link
->datum
->file
;
4620 fil_end
= fil_ptr
+ fil_cnt
;
4621 for (; fil_ptr
< fil_end
; fil_ptr
++)
4623 if (*bufend
- fdr_out
< external_fdr_size
)
4624 fdr_out
= ecoff_add_bytes (buf
, bufend
, fdr_out
,
4626 (*swap_fdr_out
) (stdoutput
, &fil_ptr
->fdr
, fdr_out
);
4627 fdr_out
+= external_fdr_size
;
4632 return offset
+ ifile
* external_fdr_size
;
4635 /* Set up the external symbols. These are supposed to be handled by
4636 the backend. This routine just gets the right information and
4637 calls a backend function to deal with it. */
4642 register symbolS
*sym
;
4644 for (sym
= symbol_rootP
; sym
!= (symbolS
*) NULL
; sym
= symbol_next (sym
))
4646 if (symbol_get_obj (sym
)->ecoff_symbol
== NULL
)
4649 /* If this is a local symbol, then force the fields to zero. */
4650 if (! S_IS_EXTERNAL (sym
)
4651 && ! S_IS_WEAK (sym
)
4652 && S_IS_DEFINED (sym
))
4654 struct localsym
*lsym
;
4656 lsym
= symbol_get_obj (sym
)->ecoff_symbol
;
4657 lsym
->ecoff_sym
.asym
.value
= 0;
4658 lsym
->ecoff_sym
.asym
.st
= (int) st_Nil
;
4659 lsym
->ecoff_sym
.asym
.sc
= (int) sc_Nil
;
4660 lsym
->ecoff_sym
.asym
.index
= indexNil
;
4663 obj_ecoff_set_ext (sym
, &symbol_get_obj (sym
)->ecoff_symbol
->ecoff_sym
);
4667 /* Build the ECOFF debugging information. */
4670 ecoff_build_debug (hdr
, bufp
, backend
)
4673 const struct ecoff_debug_swap
*backend
;
4675 const bfd_size_type external_pdr_size
= backend
->external_pdr_size
;
4680 efdr_t
*hold_file_ptr
;
4681 proc_t
*hold_proc_ptr
;
4685 unsigned long offset
;
4687 /* Make sure we have a file. */
4688 if (first_file
== (efdr_t
*) NULL
)
4689 add_file ((const char *) NULL
, 0, 1);
4691 /* Handle any top level tags. */
4692 for (ptag
= top_tag_head
->first_tag
;
4693 ptag
!= (tag_t
*) NULL
;
4696 if (ptag
->forward_ref
!= (forward_t
*) NULL
)
4697 add_unknown_tag (ptag
);
4699 ptag_next
= ptag
->same_block
;
4700 ptag
->hash_ptr
->tag_ptr
= ptag
->same_name
;
4704 free_thead (top_tag_head
);
4706 /* Look through the symbols. Add debugging information for each
4707 symbol that has not already received it. */
4708 hold_file_ptr
= cur_file_ptr
;
4709 hold_proc_ptr
= cur_proc_ptr
;
4710 cur_proc_ptr
= (proc_t
*) NULL
;
4711 for (sym
= symbol_rootP
; sym
!= (symbolS
*) NULL
; sym
= symbol_next (sym
))
4713 if (symbol_get_obj (sym
)->ecoff_symbol
!= NULL
4714 || symbol_get_obj (sym
)->ecoff_file
== (efdr_t
*) NULL
4715 || (symbol_get_bfdsym (sym
)->flags
& BSF_SECTION_SYM
) != 0)
4718 cur_file_ptr
= symbol_get_obj (sym
)->ecoff_file
;
4719 add_ecoff_symbol ((const char *) NULL
, st_Nil
, sc_Nil
, sym
,
4720 (bfd_vma
) 0, S_GET_VALUE (sym
), indexNil
);
4722 cur_proc_ptr
= hold_proc_ptr
;
4723 cur_file_ptr
= hold_file_ptr
;
4725 /* Output an ending symbol for all the files. We have to do this
4726 here for the last file, so we may as well do it for all of the
4729 for (fil_ptr
= first_file
;
4730 fil_ptr
!= (efdr_t
*) NULL
;
4731 fil_ptr
= fil_ptr
->next_file
)
4733 cur_file_ptr
= fil_ptr
;
4734 while (cur_file_ptr
->cur_scope
!= (scope_t
*) NULL
4735 && cur_file_ptr
->cur_scope
->prev
!= (scope_t
*) NULL
)
4737 cur_file_ptr
->cur_scope
= cur_file_ptr
->cur_scope
->prev
;
4738 if (! end_warning
&& ! cur_file_ptr
->fake
)
4740 as_warn (_("Missing .end or .bend at end of file"));
4744 if (cur_file_ptr
->cur_scope
!= (scope_t
*) NULL
)
4745 (void) add_ecoff_symbol ((const char *) NULL
,
4753 /* Build the symbolic information. */
4755 buf
= xmalloc (PAGE_SIZE
);
4756 bufend
= buf
+ PAGE_SIZE
;
4758 /* Build the line number information. */
4759 hdr
->cbLineOffset
= offset
;
4760 offset
= ecoff_build_lineno (backend
, &buf
, &bufend
, offset
,
4762 hdr
->cbLine
= offset
- hdr
->cbLineOffset
;
4764 /* We don't use dense numbers at all. */
4766 hdr
->cbDnOffset
= 0;
4768 /* We can't build the PDR table until we have built the symbols,
4769 because a PDR contains a symbol index. However, we set aside
4770 space at this point. */
4771 hdr
->ipdMax
= proc_cnt
;
4772 hdr
->cbPdOffset
= offset
;
4773 if (bufend
- (buf
+ offset
) < proc_cnt
* external_pdr_size
)
4774 (void) ecoff_add_bytes (&buf
, &bufend
, buf
+ offset
,
4775 proc_cnt
* external_pdr_size
);
4776 offset
+= proc_cnt
* external_pdr_size
;
4778 /* Build the local symbols. */
4779 hdr
->cbSymOffset
= offset
;
4780 offset
= ecoff_build_symbols (backend
, &buf
, &bufend
, offset
);
4781 hdr
->isymMax
= (offset
- hdr
->cbSymOffset
) / backend
->external_sym_size
;
4783 /* Building the symbols initializes the symbol index in the PDR's.
4784 Now we can swap out the PDR's. */
4785 (void) ecoff_build_procs (backend
, &buf
, &bufend
, hdr
->cbPdOffset
);
4787 /* We don't use optimization symbols. */
4789 hdr
->cbOptOffset
= 0;
4791 /* Swap out the auxiliary type information. */
4792 hdr
->cbAuxOffset
= offset
;
4793 offset
= ecoff_build_aux (backend
, &buf
, &bufend
, offset
);
4794 hdr
->iauxMax
= (offset
- hdr
->cbAuxOffset
) / sizeof (union aux_ext
);
4796 /* Copy out the local strings. */
4797 hdr
->cbSsOffset
= offset
;
4798 offset
= ecoff_build_ss (backend
, &buf
, &bufend
, offset
);
4799 hdr
->issMax
= offset
- hdr
->cbSsOffset
;
4801 /* We don't use relative file descriptors. */
4803 hdr
->cbRfdOffset
= 0;
4805 /* Swap out the file descriptors. */
4806 hdr
->cbFdOffset
= offset
;
4807 offset
= ecoff_build_fdr (backend
, &buf
, &bufend
, offset
);
4808 hdr
->ifdMax
= (offset
- hdr
->cbFdOffset
) / backend
->external_fdr_size
;
4810 /* Set up the external symbols, which are handled by the BFD back
4813 hdr
->cbSsExtOffset
= 0;
4815 hdr
->cbExtOffset
= 0;
4818 know ((offset
& (backend
->debug_align
- 1)) == 0);
4820 /* FIXME: This value should be determined from the .verstamp directive,
4821 with reasonable defaults in config files. */
4823 hdr
->vstamp
= 0x030b;
4825 hdr
->vstamp
= 0x020b;
4832 /* Allocate a cluster of pages. */
4834 #ifndef MALLOC_CHECK
4837 allocate_cluster (npages
)
4838 unsigned long npages
;
4840 register page_type
*value
= (page_type
*) xmalloc (npages
* PAGE_USIZE
);
4844 fprintf (stderr
, "\talloc\tnpages = %d, value = 0x%.8x\n", npages
, value
);
4847 memset (value
, 0, npages
* PAGE_USIZE
);
4852 static page_type
*cluster_ptr
= NULL
;
4853 static unsigned long pages_left
= 0;
4855 #endif /* MALLOC_CHECK */
4857 /* Allocate one page (which is initialized to 0). */
4862 #ifndef MALLOC_CHECK
4864 if (pages_left
== 0)
4866 pages_left
= MAX_CLUSTER_PAGES
;
4867 cluster_ptr
= allocate_cluster (pages_left
);
4871 return cluster_ptr
++;
4873 #else /* MALLOC_CHECK */
4877 ptr
= xmalloc (PAGE_USIZE
);
4878 memset (ptr
, 0, PAGE_USIZE
);
4881 #endif /* MALLOC_CHECK */
4884 /* Allocate scoping information. */
4889 register scope_t
*ptr
;
4890 static scope_t initial_scope
;
4892 #ifndef MALLOC_CHECK
4894 ptr
= alloc_counts
[(int) alloc_type_scope
].free_list
.f_scope
;
4895 if (ptr
!= (scope_t
*) NULL
)
4896 alloc_counts
[(int) alloc_type_scope
].free_list
.f_scope
= ptr
->free
;
4899 register int unallocated
= alloc_counts
[(int) alloc_type_scope
].unallocated
;
4900 register page_type
*cur_page
= alloc_counts
[(int) alloc_type_scope
].cur_page
;
4902 if (unallocated
== 0)
4904 unallocated
= PAGE_SIZE
/ sizeof (scope_t
);
4905 alloc_counts
[(int) alloc_type_scope
].cur_page
= cur_page
= allocate_page ();
4906 alloc_counts
[(int) alloc_type_scope
].total_pages
++;
4909 ptr
= &cur_page
->scope
[--unallocated
];
4910 alloc_counts
[(int) alloc_type_scope
].unallocated
= unallocated
;
4915 ptr
= (scope_t
*) xmalloc (sizeof (scope_t
));
4919 alloc_counts
[(int) alloc_type_scope
].total_alloc
++;
4920 *ptr
= initial_scope
;
4924 /* Free scoping information. */
4930 alloc_counts
[(int) alloc_type_scope
].total_free
++;
4932 #ifndef MALLOC_CHECK
4933 ptr
->free
= alloc_counts
[(int) alloc_type_scope
].free_list
.f_scope
;
4934 alloc_counts
[(int) alloc_type_scope
].free_list
.f_scope
= ptr
;
4940 /* Allocate links for pages in a virtual array. */
4945 register vlinks_t
*ptr
;
4946 static vlinks_t initial_vlinks
;
4948 #ifndef MALLOC_CHECK
4950 register int unallocated
= alloc_counts
[(int) alloc_type_vlinks
].unallocated
;
4951 register page_type
*cur_page
= alloc_counts
[(int) alloc_type_vlinks
].cur_page
;
4953 if (unallocated
== 0)
4955 unallocated
= PAGE_SIZE
/ sizeof (vlinks_t
);
4956 alloc_counts
[(int) alloc_type_vlinks
].cur_page
= cur_page
= allocate_page ();
4957 alloc_counts
[(int) alloc_type_vlinks
].total_pages
++;
4960 ptr
= &cur_page
->vlinks
[--unallocated
];
4961 alloc_counts
[(int) alloc_type_vlinks
].unallocated
= unallocated
;
4965 ptr
= (vlinks_t
*) xmalloc (sizeof (vlinks_t
));
4969 alloc_counts
[(int) alloc_type_vlinks
].total_alloc
++;
4970 *ptr
= initial_vlinks
;
4974 /* Allocate string hash buckets. */
4979 register shash_t
*ptr
;
4980 static shash_t initial_shash
;
4982 #ifndef MALLOC_CHECK
4984 register int unallocated
= alloc_counts
[(int) alloc_type_shash
].unallocated
;
4985 register page_type
*cur_page
= alloc_counts
[(int) alloc_type_shash
].cur_page
;
4987 if (unallocated
== 0)
4989 unallocated
= PAGE_SIZE
/ sizeof (shash_t
);
4990 alloc_counts
[(int) alloc_type_shash
].cur_page
= cur_page
= allocate_page ();
4991 alloc_counts
[(int) alloc_type_shash
].total_pages
++;
4994 ptr
= &cur_page
->shash
[--unallocated
];
4995 alloc_counts
[(int) alloc_type_shash
].unallocated
= unallocated
;
4999 ptr
= (shash_t
*) xmalloc (sizeof (shash_t
));
5003 alloc_counts
[(int) alloc_type_shash
].total_alloc
++;
5004 *ptr
= initial_shash
;
5008 /* Allocate type hash buckets. */
5013 register thash_t
*ptr
;
5014 static thash_t initial_thash
;
5016 #ifndef MALLOC_CHECK
5018 register int unallocated
= alloc_counts
[(int) alloc_type_thash
].unallocated
;
5019 register page_type
*cur_page
= alloc_counts
[(int) alloc_type_thash
].cur_page
;
5021 if (unallocated
== 0)
5023 unallocated
= PAGE_SIZE
/ sizeof (thash_t
);
5024 alloc_counts
[(int) alloc_type_thash
].cur_page
= cur_page
= allocate_page ();
5025 alloc_counts
[(int) alloc_type_thash
].total_pages
++;
5028 ptr
= &cur_page
->thash
[--unallocated
];
5029 alloc_counts
[(int) alloc_type_thash
].unallocated
= unallocated
;
5033 ptr
= (thash_t
*) xmalloc (sizeof (thash_t
));
5037 alloc_counts
[(int) alloc_type_thash
].total_alloc
++;
5038 *ptr
= initial_thash
;
5042 /* Allocate structure, union, or enum tag information. */
5047 register tag_t
*ptr
;
5048 static tag_t initial_tag
;
5050 #ifndef MALLOC_CHECK
5052 ptr
= alloc_counts
[(int) alloc_type_tag
].free_list
.f_tag
;
5053 if (ptr
!= (tag_t
*) NULL
)
5054 alloc_counts
[(int) alloc_type_tag
].free_list
.f_tag
= ptr
->free
;
5057 register int unallocated
= alloc_counts
[(int) alloc_type_tag
].unallocated
;
5058 register page_type
*cur_page
= alloc_counts
[(int) alloc_type_tag
].cur_page
;
5060 if (unallocated
== 0)
5062 unallocated
= PAGE_SIZE
/ sizeof (tag_t
);
5063 alloc_counts
[(int) alloc_type_tag
].cur_page
= cur_page
= allocate_page ();
5064 alloc_counts
[(int) alloc_type_tag
].total_pages
++;
5067 ptr
= &cur_page
->tag
[--unallocated
];
5068 alloc_counts
[(int) alloc_type_tag
].unallocated
= unallocated
;
5073 ptr
= (tag_t
*) xmalloc (sizeof (tag_t
));
5077 alloc_counts
[(int) alloc_type_tag
].total_alloc
++;
5082 /* Free scoping information. */
5088 alloc_counts
[(int) alloc_type_tag
].total_free
++;
5090 #ifndef MALLOC_CHECK
5091 ptr
->free
= alloc_counts
[(int) alloc_type_tag
].free_list
.f_tag
;
5092 alloc_counts
[(int) alloc_type_tag
].free_list
.f_tag
= ptr
;
5098 /* Allocate forward reference to a yet unknown tag. */
5103 register forward_t
*ptr
;
5104 static forward_t initial_forward
;
5106 #ifndef MALLOC_CHECK
5108 register int unallocated
= alloc_counts
[(int) alloc_type_forward
].unallocated
;
5109 register page_type
*cur_page
= alloc_counts
[(int) alloc_type_forward
].cur_page
;
5111 if (unallocated
== 0)
5113 unallocated
= PAGE_SIZE
/ sizeof (forward_t
);
5114 alloc_counts
[(int) alloc_type_forward
].cur_page
= cur_page
= allocate_page ();
5115 alloc_counts
[(int) alloc_type_forward
].total_pages
++;
5118 ptr
= &cur_page
->forward
[--unallocated
];
5119 alloc_counts
[(int) alloc_type_forward
].unallocated
= unallocated
;
5123 ptr
= (forward_t
*) xmalloc (sizeof (forward_t
));
5127 alloc_counts
[(int) alloc_type_forward
].total_alloc
++;
5128 *ptr
= initial_forward
;
5132 /* Allocate head of type hash list. */
5137 register thead_t
*ptr
;
5138 static thead_t initial_thead
;
5140 #ifndef MALLOC_CHECK
5142 ptr
= alloc_counts
[(int) alloc_type_thead
].free_list
.f_thead
;
5143 if (ptr
!= (thead_t
*) NULL
)
5144 alloc_counts
[(int) alloc_type_thead
].free_list
.f_thead
= ptr
->free
;
5147 register int unallocated
= alloc_counts
[(int) alloc_type_thead
].unallocated
;
5148 register page_type
*cur_page
= alloc_counts
[(int) alloc_type_thead
].cur_page
;
5150 if (unallocated
== 0)
5152 unallocated
= PAGE_SIZE
/ sizeof (thead_t
);
5153 alloc_counts
[(int) alloc_type_thead
].cur_page
= cur_page
= allocate_page ();
5154 alloc_counts
[(int) alloc_type_thead
].total_pages
++;
5157 ptr
= &cur_page
->thead
[--unallocated
];
5158 alloc_counts
[(int) alloc_type_thead
].unallocated
= unallocated
;
5163 ptr
= (thead_t
*) xmalloc (sizeof (thead_t
));
5167 alloc_counts
[(int) alloc_type_thead
].total_alloc
++;
5168 *ptr
= initial_thead
;
5172 /* Free scoping information. */
5178 alloc_counts
[(int) alloc_type_thead
].total_free
++;
5180 #ifndef MALLOC_CHECK
5181 ptr
->free
= (thead_t
*) alloc_counts
[(int) alloc_type_thead
].free_list
.f_thead
;
5182 alloc_counts
[(int) alloc_type_thead
].free_list
.f_thead
= ptr
;
5188 static lineno_list_t
*
5189 allocate_lineno_list ()
5191 register lineno_list_t
*ptr
;
5192 static lineno_list_t initial_lineno_list
;
5194 #ifndef MALLOC_CHECK
5196 register int unallocated
= alloc_counts
[(int) alloc_type_lineno
].unallocated
;
5197 register page_type
*cur_page
= alloc_counts
[(int) alloc_type_lineno
].cur_page
;
5199 if (unallocated
== 0)
5201 unallocated
= PAGE_SIZE
/ sizeof (lineno_list_t
);
5202 alloc_counts
[(int) alloc_type_lineno
].cur_page
= cur_page
= allocate_page ();
5203 alloc_counts
[(int) alloc_type_lineno
].total_pages
++;
5206 ptr
= &cur_page
->lineno
[--unallocated
];
5207 alloc_counts
[(int) alloc_type_lineno
].unallocated
= unallocated
;
5211 ptr
= (lineno_list_t
*) xmalloc (sizeof (lineno_list_t
));
5215 alloc_counts
[(int) alloc_type_lineno
].total_alloc
++;
5216 *ptr
= initial_lineno_list
;
5221 ecoff_set_gp_prolog_size (sz
)
5224 if (cur_proc_ptr
== 0)
5227 cur_proc_ptr
->pdr
.gp_prologue
= sz
;
5228 if (cur_proc_ptr
->pdr
.gp_prologue
!= sz
)
5230 as_warn (_("GP prologue size exceeds field size, using 0 instead"));
5231 cur_proc_ptr
->pdr
.gp_prologue
= 0;
5234 cur_proc_ptr
->pdr
.gp_used
= 1;
5238 ecoff_no_current_file ()
5240 return cur_file_ptr
== (efdr_t
*) NULL
;
5244 ecoff_generate_asm_lineno ()
5246 unsigned int lineno
;
5248 lineno_list_t
*list
;
5250 as_where (&filename
, &lineno
);
5252 if (current_stabs_filename
== (char *) NULL
5253 || strcmp (current_stabs_filename
, filename
))
5254 add_file (filename
, 0, 1);
5256 list
= allocate_lineno_list ();
5258 list
->next
= (lineno_list_t
*) NULL
;
5259 list
->file
= cur_file_ptr
;
5260 list
->proc
= cur_proc_ptr
;
5261 list
->frag
= frag_now
;
5262 list
->paddr
= frag_now_fix ();
5263 list
->lineno
= lineno
;
5265 /* We don't want to merge files which have line numbers. */
5266 cur_file_ptr
->fdr
.fMerge
= 0;
5268 /* A .loc directive will sometimes appear before a .ent directive,
5269 which means that cur_proc_ptr will be NULL here. Arrange to
5271 if (cur_proc_ptr
== (proc_t
*) NULL
)
5275 pl
= &noproc_lineno
;
5276 while (*pl
!= (lineno_list_t
*) NULL
)
5283 *last_lineno_ptr
= list
;
5284 last_lineno_ptr
= &list
->next
;
5291 ecoff_generate_asm_lineno ()
5295 #endif /* ECOFF_DEBUGGING */