1
/* ECOFF debugging support.
2
Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
3
Free Software Foundation, Inc.
4
Contributed by Cygnus Support.
5
This file was put together by Ian Lance Taylor <ian@cygnus.com>. A
6
good deal of it comes directly from mips-tfile.c, by Michael
7
Meissner <meissner@osf.org>.
9
This file is part of GAS.
11
GAS is free software; you can redistribute it and/or modify
12
it under the terms of the GNU General Public License as published by
13
the Free Software Foundation; either version 2, or (at your option)
16
GAS is distributed in the hope that it will be useful,
17
but WITHOUT ANY WARRANTY; without even the implied warranty of
18
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19
GNU General Public License for more details.
21
You should have received a copy of the GNU General Public License
22
along with GAS; see the file COPYING. If not, write to the Free
23
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
28
/* This file is compiled conditionally for those targets which use
29
ECOFF debugging information (e.g., MIPS ECOFF, MIPS ELF, Alpha
34
#ifdef ECOFF_DEBUGGING
36
#include "coff/internal.h"
37
#include "coff/symconst.h"
38
#include "aout/stab_gnu.h"
40
#include "safe-ctype.h"
42
/* Why isn't this in coff/sym.h? */
43
#define ST_RFDESCAPE 0xfff
45
/* This file constructs the information used by the ECOFF debugging
46
format. It just builds a large block of data.
48
We support both ECOFF style debugging and stabs debugging (the
49
stabs symbols are encapsulated in ECOFF symbols). This should let
50
us handle anything the compiler might throw at us. */
52
/* Here is a brief description of the MIPS ECOFF symbol table, by
53
Michael Meissner. The MIPS symbol table has the following pieces:
59
+-- Dense number table
67
+-- Relative file descriptors
79
The symbolic header points to each of the other tables, and also
80
contains the number of entries. It also contains a magic number
81
and MIPS compiler version number, such as 2.0.
83
The auxiliary table is a series of 32 bit integers, that are
84
referenced as needed from the local symbol table. Unlike standard
85
COFF, the aux. information does not follow the symbol that uses
86
it, but rather is a separate table. In theory, this would allow
87
the MIPS compilers to collapse duplicate aux. entries, but I've not
88
noticed this happening with the 1.31 compiler suite. The different
89
types of aux. entries are:
91
1) dnLow: Low bound on array dimension.
93
2) dnHigh: High bound on array dimension.
95
3) isym: Index to the local symbol which is the start of the
96
function for the end of function first aux. entry.
98
4) width: Width of structures and bitfields.
100
5) count: Count of ranges for variant part.
102
6) rndx: A relative index into the symbol table. The relative
103
index field has two parts: rfd which is a pointer into the
104
relative file index table or ST_RFDESCAPE which says the next
105
aux. entry is the file number, and index: which is the pointer
106
into the local symbol within a given file table. This is for
107
things like references to types defined in another file.
109
7) Type information: This is like the COFF type bits, except it
110
is 32 bits instead of 16; they still have room to add new
111
basic types; and they can handle more than 6 levels of array,
112
pointer, function, etc. Each type information field contains
113
the following structure members:
115
a) fBitfield: a bit that says this is a bitfield, and the
116
size in bits follows as the next aux. entry.
118
b) continued: a bit that says the next aux. entry is a
119
continuation of the current type information (in case
120
there are more than 6 levels of array/ptr/function).
122
c) bt: an integer containing the base type before adding
123
array, pointer, function, etc. qualifiers. The
124
current base types that I have documentation for are:
127
btAdr -- address - integer same size as ptr
129
btUChar -- unsigned character
131
btUShort -- unsigned short
133
btUInt -- unsigned int
135
btULong -- unsigned long
136
btFloat -- float (real)
137
btDouble -- Double (real)
138
btStruct -- Structure (Record)
139
btUnion -- Union (variant)
141
btTypedef -- defined via a typedef isymRef
142
btRange -- subrange of int
144
btComplex -- fortran complex
145
btDComplex -- fortran double complex
146
btIndirect -- forward or unnamed typedef
147
btFixedDec -- Fixed Decimal
148
btFloatDec -- Float Decimal
149
btString -- Varying Length Character String
150
btBit -- Aligned Bit String
152
btVoid -- Void (MIPS cc revision >= 2.00)
154
d) tq0 - tq5: type qualifier fields as needed. The
155
current type qualifier fields I have documentation for
158
tqNil -- no more qualifiers
162
tqFar -- 8086 far pointers
165
The dense number table is used in the front ends, and disappears by
166
the time the .o is created.
168
With the 1.31 compiler suite, the optimization symbols don't seem
169
to be used as far as I can tell.
171
The linker is the first entity that creates the relative file
172
descriptor table, and I believe it is used so that the individual
173
file table pointers don't have to be rewritten when the objects are
174
merged together into the program file.
176
Unlike COFF, the basic symbol & string tables are split into
177
external and local symbols/strings. The relocation information
178
only goes off of the external symbol table, and the debug
179
information only goes off of the internal symbol table. The
180
external symbols can have links to an appropriate file index and
181
symbol within the file to give it the appropriate type information.
182
Because of this, the external symbols are actually larger than the
183
internal symbols (to contain the link information), and contain the
184
local symbol structure as a member, though this member is not the
185
first member of the external symbol structure (!). I suspect this
186
split is to make strip easier to deal with.
188
Each file table has offsets for where the line numbers, local
189
strings, local symbols, and procedure table starts from within the
190
global tables, and the indexs are reset to 0 for each of those
193
The procedure table contains the binary equivalents of the .ent
194
(start of the function address), .frame (what register is the
195
virtual frame pointer, constant offset from the register to obtain
196
the VFP, and what register holds the return address), .mask/.fmask
197
(bitmask of saved registers, and where the first register is stored
198
relative to the VFP) assembler directives. It also contains the
199
low and high bounds of the line numbers if debugging is turned on.
201
The line number table is a compressed form of the normal COFF line
202
table. Each line number entry is either 1 or 3 bytes long, and
203
contains a signed delta from the previous line, and an unsigned
204
count of the number of instructions this statement takes.
206
The local symbol table contains the following fields:
208
1) iss: index to the local string table giving the name of the
211
2) value: value of the symbol (address, register number, etc.).
213
3) st: symbol type. The current symbol types are:
215
stNil -- Nuthin' special
216
stGlobal -- external symbol
218
stParam -- procedure argument
219
stLocal -- local variable
221
stProc -- External Procedure
222
stBlock -- beginning of block
223
stEnd -- end (of anything)
224
stMember -- member (of anything)
225
stTypedef -- type definition
227
stRegReloc -- register relocation
228
stForward -- forwarding address
229
stStaticProc -- Static procedure
232
4) sc: storage class. The current storage classes are:
234
scText -- text symbol
235
scData -- initialized data symbol
236
scBss -- un-initialized data symbol
237
scRegister -- value of symbol is register number
238
scAbs -- value of symbol is absolute
239
scUndefined -- who knows?
240
scCdbLocal -- variable's value is IN se->va.??
241
scBits -- this is a bit field
242
scCdbSystem -- value is IN debugger's address space
243
scRegImage -- register value saved on stack
244
scInfo -- symbol contains debugger information
245
scUserStruct -- addr in struct user for current process
246
scSData -- load time only small data
247
scSBss -- load time only small common
248
scRData -- load time only read only data
249
scVar -- Var parameter (fortranpascal)
250
scCommon -- common variable
251
scSCommon -- small common
252
scVarRegister -- Var parameter in a register
253
scVariant -- Variant record
254
scSUndefined -- small undefined(external) data
255
scInit -- .init section symbol
257
5) index: pointer to a local symbol or aux. entry.
259
For the following program:
264
printf("Hello World!\n");
268
Mips-tdump produces the following information:
273
timestamp 645311799, Wed Jun 13 17:16:39 1990
274
symbolic header offset 284
275
symbolic header size 96
279
Symbolic header, magic number = 0x7009, vstamp = 1.31:
281
Info Offset Number Bytes
282
==== ====== ====== =====
284
Line numbers 380 4 4 [13]
286
Procedures Tables 384 1 52
287
Local Symbols 436 16 192
288
Optimization Symbols 0 0 0
289
Auxiliary Symbols 628 39 156
290
Local Strings 784 80 80
291
External Strings 864 144 144
292
File Tables 1008 2 144
294
External Symbols 1152 20 320
298
Name index = 1 Readin = No
299
Merge = No Endian = LITTLE
300
Debug level = G2 Language = C
303
Info Start Number Size Offset
304
==== ===== ====== ==== ======
305
Local strings 0 15 15 784
306
Local symbols 0 6 72 436
307
Line numbers 0 13 13 380
308
Optimization symbols 0 0 0 0
309
Procedures 0 1 52 384
310
Auxiliary symbols 0 14 56 628
311
Relative Files 0 0 0 0
313
There are 6 local symbols, starting at 436
315
Symbol# 0: "hello2.c"
318
Storage class = Text Index = 6
319
Symbol type = File Value = 0
325
Storage class = Text Index = 12
326
Symbol type = Proc Value = 0
331
Storage class = Text Index = 4
332
Symbol type = Block Value = 8
337
Storage class = Text Index = 2
338
Symbol type = End Value = 28
343
Storage class = Text Index = 1
344
Symbol type = End Value = 52
346
Symbol# 5: "hello2.c"
349
Storage class = Text Index = 0
350
Symbol type = End Value = 0
352
There are 14 auxiliary table entries, starting at 628.
354
* #0 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
355
* #1 24, [ 24/ 0], [ 6 0:0 0:0:0:0:0:0]
356
* #2 8, [ 8/ 0], [ 2 0:0 0:0:0:0:0:0]
357
* #3 16, [ 16/ 0], [ 4 0:0 0:0:0:0:0:0]
358
* #4 24, [ 24/ 0], [ 6 0:0 0:0:0:0:0:0]
359
* #5 32, [ 32/ 0], [ 8 0:0 0:0:0:0:0:0]
360
* #6 40, [ 40/ 0], [10 0:0 0:0:0:0:0:0]
361
* #7 44, [ 44/ 0], [11 0:0 0:0:0:0:0:0]
362
* #8 12, [ 12/ 0], [ 3 0:0 0:0:0:0:0:0]
363
* #9 20, [ 20/ 0], [ 5 0:0 0:0:0:0:0:0]
364
* #10 28, [ 28/ 0], [ 7 0:0 0:0:0:0:0:0]
365
* #11 36, [ 36/ 0], [ 9 0:0 0:0:0:0:0:0]
366
#12 5, [ 5/ 0], [ 1 1:0 0:0:0:0:0:0]
367
#13 24, [ 24/ 0], [ 6 0:0 0:0:0:0:0:0]
369
There are 1 procedure descriptor entries, starting at 0.
371
Procedure descriptor 0:
372
Name index = 10 Name = "main"
373
.mask 0x80000000,-4 .fmask 0x00000000,0
375
Opt. start = -1 Symbols start = 1
376
First line # = 3 Last line # = 6
377
Line Offset = 0 Address = 0x00000000
379
There are 4 bytes holding line numbers, starting at 380.
380
Line 3, delta 0, count 2
381
Line 4, delta 1, count 3
382
Line 5, delta 1, count 2
383
Line 6, delta 1, count 6
385
File #1, "/usr/include/stdio.h"
387
Name index = 1 Readin = No
388
Merge = Yes Endian = LITTLE
389
Debug level = G2 Language = C
392
Info Start Number Size Offset
393
==== ===== ====== ==== ======
394
Local strings 15 65 65 799
395
Local symbols 6 10 120 508
396
Line numbers 0 0 0 380
397
Optimization symbols 0 0 0 0
399
Auxiliary symbols 14 25 100 684
400
Relative Files 0 0 0 0
402
There are 10 local symbols, starting at 442
404
Symbol# 0: "/usr/include/stdio.h"
407
Storage class = Text Index = 10
408
Symbol type = File Value = 0
413
Storage class = Info Index = 9
414
Symbol type = Block Value = 20
419
Storage class = Info Index = 4
420
Symbol type = Member Value = 0
425
Storage class = Info Index = 15
426
Symbol type = Member Value = 32
431
Storage class = Info Index = 16
432
Symbol type = Member Value = 64
437
Storage class = Info Index = 4
438
Symbol type = Member Value = 96
443
Storage class = Info Index = 3
444
Symbol type = Member Value = 128
449
Storage class = Info Index = 2
450
Symbol type = Member Value = 144
455
Storage class = Info Index = 1
456
Symbol type = End Value = 0
458
Symbol# 9: "/usr/include/stdio.h"
461
Storage class = Text Index = 0
462
Symbol type = End Value = 0
464
There are 25 auxiliary table entries, starting at 642.
466
* #14 -1, [4095/1048575], [63 1:1 f:f:f:f:f:f]
467
#15 65544, [ 8/ 16], [ 2 0:0 1:0:0:0:0:0]
468
#16 65544, [ 8/ 16], [ 2 0:0 1:0:0:0:0:0]
469
* #17 196656, [ 48/ 48], [12 0:0 3:0:0:0:0:0]
470
* #18 8191, [4095/ 1], [63 1:1 0:0:0:0:f:1]
471
* #19 1, [ 1/ 0], [ 0 1:0 0:0:0:0:0:0]
472
* #20 20479, [4095/ 4], [63 1:1 0:0:0:0:f:4]
473
* #21 1, [ 1/ 0], [ 0 1:0 0:0:0:0:0:0]
474
* #22 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
475
* #23 2, [ 2/ 0], [ 0 0:1 0:0:0:0:0:0]
476
* #24 160, [ 160/ 0], [40 0:0 0:0:0:0:0:0]
477
* #25 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
478
* #26 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
479
* #27 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
480
* #28 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
481
* #29 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
482
* #30 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
483
* #31 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
484
* #32 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
485
* #33 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
486
* #34 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
487
* #35 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
488
* #36 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
489
* #37 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
490
* #38 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
492
There are 0 procedure descriptor entries, starting at 1.
494
There are 20 external symbols, starting at 1152
497
Type = array [3 {160}] of struct _iobuf { ifd = 1, index = 1 }
498
String index = 0 Ifd = 1
499
Storage class = Nil Index = 17
500
Symbol type = Global Value = 60
503
String index = 5 Ifd = 1
504
Storage class = Nil Index = 1048575
505
Symbol type = Proc Value = 0
508
String index = 11 Ifd = 1
509
Storage class = Nil Index = 1048575
510
Symbol type = Proc Value = 0
513
String index = 18 Ifd = 1
514
Storage class = Nil Index = 1048575
515
Symbol type = Proc Value = 0
518
String index = 26 Ifd = 1
519
Storage class = Nil Index = 1048575
520
Symbol type = Proc Value = 0
523
String index = 32 Ifd = 1
524
Storage class = Nil Index = 1048575
525
Symbol type = Proc Value = 0
528
String index = 40 Ifd = 1
529
Storage class = Nil Index = 1048575
530
Symbol type = Proc Value = 0
533
String index = 46 Ifd = 1
534
Storage class = Nil Index = 1048575
535
Symbol type = Proc Value = 0
538
String index = 53 Ifd = 1
539
Storage class = Nil Index = 1048575
540
Symbol type = Proc Value = 0
542
Symbol# 9: "setbuffer"
543
String index = 60 Ifd = 1
544
Storage class = Nil Index = 1048575
545
Symbol type = Proc Value = 0
547
Symbol# 10: "setlinebuf"
548
String index = 70 Ifd = 1
549
Storage class = Nil Index = 1048575
550
Symbol type = Proc Value = 0
553
String index = 81 Ifd = 1
554
Storage class = Nil Index = 1048575
555
Symbol type = Proc Value = 0
558
String index = 87 Ifd = 1
559
Storage class = Nil Index = 1048575
560
Symbol type = Proc Value = 0
562
Symbol# 13: "ctermid"
563
String index = 92 Ifd = 1
564
Storage class = Nil Index = 1048575
565
Symbol type = Proc Value = 0
567
Symbol# 14: "cuserid"
568
String index = 100 Ifd = 1
569
Storage class = Nil Index = 1048575
570
Symbol type = Proc Value = 0
572
Symbol# 15: "tempnam"
573
String index = 108 Ifd = 1
574
Storage class = Nil Index = 1048575
575
Symbol type = Proc Value = 0
578
String index = 116 Ifd = 1
579
Storage class = Nil Index = 1048575
580
Symbol type = Proc Value = 0
582
Symbol# 17: "sprintf"
583
String index = 123 Ifd = 1
584
Storage class = Nil Index = 1048575
585
Symbol type = Proc Value = 0
589
String index = 131 Ifd = 0
590
Storage class = Text Index = 1
591
Symbol type = Proc Value = 0
594
String index = 136 Ifd = 0
595
Storage class = Undefined Index = 1048575
596
Symbol type = Proc Value = 0
598
The following auxiliary table entries were unused:
602
#3 16 0x00000010 short
604
#5 32 0x00000020 long
605
#6 40 0x00000028 float
606
#7 44 0x0000002c double
607
#8 12 0x0000000c unsigned char
608
#9 20 0x00000014 unsigned short
609
#10 28 0x0000001c unsigned int
610
#11 36 0x00000024 unsigned long
611
#14 0 0x00000000 void
612
#15 24 0x00000018 int
613
#19 32 0x00000020 long
614
#20 40 0x00000028 float
615
#21 44 0x0000002c double
616
#22 12 0x0000000c unsigned char
617
#23 20 0x00000014 unsigned short
618
#24 28 0x0000001c unsigned int
619
#25 36 0x00000024 unsigned long
620
#26 48 0x00000030 struct no name { ifd = -1, index = 1048575 }
623
/* Redefinition of of storage classes as an enumeration for better
627
sc_Nil = scNil, /* no storage class */
628
sc_Text = scText, /* text symbol */
629
sc_Data = scData, /* initialized data symbol */
630
sc_Bss = scBss, /* un-initialized data symbol */
631
sc_Register = scRegister, /* value of symbol is register number */
632
sc_Abs = scAbs, /* value of symbol is absolute */
633
sc_Undefined = scUndefined, /* who knows? */
634
sc_CdbLocal = scCdbLocal, /* variable's value is IN se->va.?? */
635
sc_Bits = scBits, /* this is a bit field */
636
sc_CdbSystem = scCdbSystem, /* value is IN CDB's address space */
637
sc_RegImage = scRegImage, /* register value saved on stack */
638
sc_Info = scInfo, /* symbol contains debugger information */
639
sc_UserStruct = scUserStruct, /* addr in struct user for current process */
640
sc_SData = scSData, /* load time only small data */
641
sc_SBss = scSBss, /* load time only small common */
642
sc_RData = scRData, /* load time only read only data */
643
sc_Var = scVar, /* Var parameter (fortran,pascal) */
644
sc_Common = scCommon, /* common variable */
645
sc_SCommon = scSCommon, /* small common */
646
sc_VarRegister = scVarRegister, /* Var parameter in a register */
647
sc_Variant = scVariant, /* Variant record */
648
sc_SUndefined = scSUndefined, /* small undefined(external) data */
649
sc_Init = scInit, /* .init section symbol */
650
sc_Max = scMax /* Max storage class+1 */
653
/* Redefinition of symbol type. */
656
st_Nil = stNil, /* Nuthin' special */
657
st_Global = stGlobal, /* external symbol */
658
st_Static = stStatic, /* static */
659
st_Param = stParam, /* procedure argument */
660
st_Local = stLocal, /* local variable */
661
st_Label = stLabel, /* label */
662
st_Proc = stProc, /* " " Procedure */
663
st_Block = stBlock, /* beginning of block */
664
st_End = stEnd, /* end (of anything) */
665
st_Member = stMember, /* member (of anything - struct/union/enum */
666
st_Typedef = stTypedef, /* type definition */
667
st_File = stFile, /* file name */
668
st_RegReloc = stRegReloc, /* register relocation */
669
st_Forward = stForward, /* forwarding address */
670
st_StaticProc = stStaticProc, /* load time only static procs */
671
st_Constant = stConstant, /* const */
672
st_Str = stStr, /* string */
673
st_Number = stNumber, /* pure number (ie. 4 NOR 2+2) */
674
st_Expr = stExpr, /* 2+2 vs. 4 */
675
st_Type = stType, /* post-coercion SER */
676
st_Max = stMax /* max type+1 */
679
/* Redefinition of type qualifiers. */
682
tq_Nil = tqNil, /* bt is what you see */
683
tq_Ptr = tqPtr, /* pointer */
684
tq_Proc = tqProc, /* procedure */
685
tq_Array = tqArray, /* duh */
686
tq_Far = tqFar, /* longer addressing - 8086/8 land */
687
tq_Vol = tqVol, /* volatile */
688
tq_Max = tqMax /* Max type qualifier+1 */
691
/* Redefinition of basic types. */
694
bt_Nil = btNil, /* undefined */
695
bt_Adr = btAdr, /* address - integer same size as pointer */
696
bt_Char = btChar, /* character */
697
bt_UChar = btUChar, /* unsigned character */
698
bt_Short = btShort, /* short */
699
bt_UShort = btUShort, /* unsigned short */
700
bt_Int = btInt, /* int */
701
bt_UInt = btUInt, /* unsigned int */
702
bt_Long = btLong, /* long */
703
bt_ULong = btULong, /* unsigned long */
704
bt_Float = btFloat, /* float (real) */
705
bt_Double = btDouble, /* Double (real) */
706
bt_Struct = btStruct, /* Structure (Record) */
707
bt_Union = btUnion, /* Union (variant) */
708
bt_Enum = btEnum, /* Enumerated */
709
bt_Typedef = btTypedef, /* defined via a typedef, isymRef points */
710
bt_Range = btRange, /* subrange of int */
711
bt_Set = btSet, /* pascal sets */
712
bt_Complex = btComplex, /* fortran complex */
713
bt_DComplex = btDComplex, /* fortran double complex */
714
bt_Indirect = btIndirect, /* forward or unnamed typedef */
715
bt_FixedDec = btFixedDec, /* Fixed Decimal */
716
bt_FloatDec = btFloatDec, /* Float Decimal */
717
bt_String = btString, /* Varying Length Character String */
718
bt_Bit = btBit, /* Aligned Bit String */
719
bt_Picture = btPicture, /* Picture */
720
bt_Void = btVoid, /* Void */
721
bt_Max = btMax /* Max basic type+1 */
726
/* States for whether to hash type or not. */
727
typedef enum hash_state {
728
hash_no = 0, /* Don't hash type */
729
hash_yes = 1, /* OK to hash type, or use previous hash */
730
hash_record = 2 /* OK to record hash, but don't use prev. */
733
/* Types of different sized allocation requests. */
735
alloc_type_none, /* dummy value */
736
alloc_type_scope, /* nested scopes linked list */
737
alloc_type_vlinks, /* glue linking pages in varray */
738
alloc_type_shash, /* string hash element */
739
alloc_type_thash, /* type hash element */
740
alloc_type_tag, /* struct/union/tag element */
741
alloc_type_forward, /* element to hold unknown tag */
742
alloc_type_thead, /* head of type hash list */
743
alloc_type_varray, /* general varray allocation */
744
alloc_type_lineno, /* line number list */
745
alloc_type_last /* last+1 element for array bounds */
748
/* Types of auxiliary type information. */
750
aux_tir, /* TIR type information */
751
aux_rndx, /* relative index into symbol table */
752
aux_dnLow, /* low dimension */
753
aux_dnHigh, /* high dimension */
754
aux_isym, /* symbol table index (end of proc) */
755
aux_iss, /* index into string space (not used) */
756
aux_width, /* width for non-default sized struc fields */
757
aux_count /* count of ranges for variant arm */
760
/* Structures to provide n-number of virtual arrays, each of which can
761
grow linearly, and which are written in the object file as
762
sequential pages. On systems with a BSD malloc, the
763
MAX_CLUSTER_PAGES should be 1 less than a power of two, since
764
malloc adds it's overhead, and rounds up to the next power of 2.
765
Pages are linked together via a linked list.
767
If PAGE_SIZE is > 4096, the string length in the shash_t structure
768
can't be represented (assuming there are strings > 4096 bytes). */
770
/* FIXME: Yes, there can be such strings while emitting C++ class debug
771
info. Templates are the offender here, the test case in question
772
having a mangled class name of
774
t7rb_tree4Z4xkeyZt4pair2ZC4xkeyZt7xsocket1Z4UserZt9select1st2Zt4pair\
775
2ZC4xkeyZt7xsocket1Z4UserZ4xkeyZt4less1Z4xkey
777
Repeat that a couple dozen times while listing the class members and
778
you've got strings over 4k. Hack around this for now by increasing
779
the page size. A proper solution would abandon this structure scheme
780
certainly for very large strings, and possibly entirely. */
783
#define PAGE_SIZE (8*1024) /* size of varray pages */
786
#define PAGE_USIZE ((unsigned long) PAGE_SIZE)
788
#ifndef MAX_CLUSTER_PAGES /* # pages to get from system */
789
#define MAX_CLUSTER_PAGES 63
792
/* Linked list connecting separate page allocations. */
793
typedef struct vlinks {
794
struct vlinks *prev; /* previous set of pages */
795
struct vlinks *next; /* next set of pages */
796
union page *datum; /* start of page */
797
unsigned long start_index; /* starting index # of page */
800
/* Virtual array header. */
801
typedef struct varray {
802
vlinks_t *first; /* first page link */
803
vlinks_t *last; /* last page link */
804
unsigned long num_allocated; /* # objects allocated */
805
unsigned short object_size; /* size in bytes of each object */
806
unsigned short objects_per_page; /* # objects that can fit on a page */
807
unsigned short objects_last_page; /* # objects allocated on last page */
811
#define OBJECTS_PER_PAGE(type) (PAGE_SIZE / sizeof (type))
813
#define OBJECTS_PER_PAGE(type) ((sizeof (type) > 1) ? 1 : PAGE_SIZE)
816
#define INIT_VARRAY(type) { /* macro to initialize a varray */ \
817
(vlinks_t *)0, /* first */ \
818
(vlinks_t *)0, /* last */ \
819
0, /* num_allocated */ \
820
sizeof (type), /* object_size */ \
821
OBJECTS_PER_PAGE (type), /* objects_per_page */ \
822
OBJECTS_PER_PAGE (type), /* objects_last_page */ \
825
/* Master type for indexes within the symbol table. */
826
typedef unsigned long symint_t;
828
/* Linked list support for nested scopes (file, block, structure, etc.). */
829
typedef struct scope {
830
struct scope *prev; /* previous scope level */
831
struct scope *free; /* free list pointer */
832
struct localsym *lsym; /* pointer to local symbol node */
833
st_t type; /* type of the node */
836
/* For a local symbol we store a gas symbol as well as the debugging
837
information we generate. The gas symbol will be NULL if this is
838
only a debugging symbol. */
839
typedef struct localsym {
840
const char *name; /* symbol name */
841
symbolS *as_sym; /* symbol as seen by gas */
842
bfd_vma addend; /* addend to as_sym value */
843
struct efdr *file_ptr; /* file pointer */
844
struct ecoff_proc *proc_ptr; /* proc pointer */
845
struct localsym *begin_ptr; /* symbol at start of block */
846
struct ecoff_aux *index_ptr; /* index value to be filled in */
847
struct forward *forward_ref; /* forward references to this symbol */
848
long sym_index; /* final symbol index */
849
EXTR ecoff_sym; /* ECOFF debugging symbol */
852
/* For aux information we keep the type and the data. */
853
typedef struct ecoff_aux {
854
enum aux_type type; /* aux type */
855
AUXU data; /* aux data */
858
/* For a procedure we store the gas symbol as well as the PDR
859
debugging information. */
860
typedef struct ecoff_proc {
861
localsym_t *sym; /* associated symbol */
862
PDR pdr; /* ECOFF debugging info */
865
/* Number of proc_t structures allocated. */
866
static unsigned long proc_cnt;
868
/* Forward reference list for tags referenced, but not yet defined. */
869
typedef struct forward {
870
struct forward *next; /* next forward reference */
871
struct forward *free; /* free list pointer */
872
aux_t *ifd_ptr; /* pointer to store file index */
873
aux_t *index_ptr; /* pointer to store symbol index */
876
/* Linked list support for tags. The first tag in the list is always
877
the current tag for that block. */
879
struct tag *free; /* free list pointer */
880
struct shash *hash_ptr; /* pointer to the hash table head */
881
struct tag *same_name; /* tag with same name in outer scope */
882
struct tag *same_block; /* next tag defined in the same block. */
883
struct forward *forward_ref; /* list of forward references */
884
bt_t basic_type; /* bt_Struct, bt_Union, or bt_Enum */
885
symint_t ifd; /* file # tag defined in */
886
localsym_t *sym; /* file's local symbols */
889
/* Head of a block's linked list of tags. */
890
typedef struct thead {
891
struct thead *prev; /* previous block */
892
struct thead *free; /* free list pointer */
893
struct tag *first_tag; /* first tag in block defined */
896
/* Union containing pointers to each the small structures which are freed up. */
897
typedef union small_free {
898
scope_t *f_scope; /* scope structure */
899
thead_t *f_thead; /* tag head structure */
900
tag_t *f_tag; /* tag element structure */
901
forward_t *f_forward; /* forward tag reference */
904
/* String hash table entry. */
906
typedef struct shash {
907
char *string; /* string we are hashing */
908
symint_t indx; /* index within string table */
909
EXTR *esym_ptr; /* global symbol pointer */
910
localsym_t *sym_ptr; /* local symbol pointer */
911
localsym_t *end_ptr; /* symbol pointer to end block */
912
tag_t *tag_ptr; /* tag pointer */
913
proc_t *proc_ptr; /* procedure descriptor pointer */
916
/* Type hash table support. The size of the hash table must fit
917
within a page with the other extended file descriptor information.
918
Because unique types which are hashed are fewer in number than
919
strings, we use a smaller hash value. */
924
#define THASH_SIZE 113
927
typedef struct thash {
928
struct thash *next; /* next hash value */
929
AUXU type; /* type we are hashing */
930
symint_t indx; /* index within string table */
933
/* Extended file descriptor that contains all of the support necessary
934
to add things to each file separately. */
935
typedef struct efdr {
936
FDR fdr; /* File header to be written out */
937
FDR *orig_fdr; /* original file header */
938
char *name; /* filename */
939
int fake; /* whether this is faked .file */
940
symint_t void_type; /* aux. pointer to 'void' type */
941
symint_t int_type; /* aux. pointer to 'int' type */
942
scope_t *cur_scope; /* current nested scopes */
943
symint_t file_index; /* current file number */
944
int nested_scopes; /* # nested scopes */
945
varray_t strings; /* local strings */
946
varray_t symbols; /* local symbols */
947
varray_t procs; /* procedures */
948
varray_t aux_syms; /* auxiliary symbols */
949
struct efdr *next_file; /* next file descriptor */
950
/* string/type hash tables */
951
struct hash_control *str_hash; /* string hash table */
952
thash_t *thash_head[THASH_SIZE];
955
/* Pre-initialized extended file structure. */
956
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 = xstrdup (tag);
2041
hash_ptr = allocate_shash ();
2042
err = hash_insert (tag_hash, perm, (char *) hash_ptr);
2044
as_fatal (_("inserting \"%s\" into tag hash table: %s"),
2046
hash_ptr->string = perm;
2049
tag_ptr = allocate_tag ();
2050
tag_ptr->forward_ref = (forward_t *) NULL;
2051
tag_ptr->hash_ptr = hash_ptr;
2052
tag_ptr->same_name = hash_ptr->tag_ptr;
2053
tag_ptr->basic_type = basic_type;
2055
tag_ptr->ifd = ((sym == (localsym_t *) NULL)
2057
: cur_file_ptr->file_index);
2058
tag_ptr->same_block = cur_tag_head->first_tag;
2060
cur_tag_head->first_tag = tag_ptr;
2061
hash_ptr->tag_ptr = tag_ptr;
2066
/* Add an unknown {struct, union, enum} tag. */
2069
add_unknown_tag (ptag)
2070
tag_t *ptag; /* pointer to tag information */
2072
shash_t *hash_ptr = ptag->hash_ptr;
2073
char *name = hash_ptr->string;
2080
char *agg_type = "{unknown aggregate type}";
2081
switch (ptag->basic_type)
2083
case bt_Struct: agg_type = "struct"; break;
2084
case bt_Union: agg_type = "union"; break;
2085
case bt_Enum: agg_type = "enum"; break;
2089
fprintf (stderr, "unknown %s %.*s found\n", agg_type,
2090
hash_ptr->len, name_start);
2094
sym = add_ecoff_symbol (name,
2102
(void) add_ecoff_symbol (name,
2110
for (pf = &sym->forward_ref; *pf != (forward_t *) NULL; pf = &(*pf)->next)
2112
*pf = ptag->forward_ref;
2115
/* Add a procedure to the current file's list of procedures, and record
2116
this is the current procedure. */
2119
add_procedure (func)
2120
char *func; /* func name */
2122
register varray_t *vp;
2123
register proc_t *new_proc_ptr;
2128
fputc ('\n', stderr);
2131
if (cur_file_ptr == (efdr_t *) NULL)
2132
as_fatal (_("no current file pointer"));
2134
vp = &cur_file_ptr->procs;
2136
if (vp->objects_last_page == vp->objects_per_page)
2137
add_varray_page (vp);
2139
cur_proc_ptr = new_proc_ptr = &vp->last->datum->proc[vp->objects_last_page++];
2141
if (first_proc_ptr == (proc_t *) NULL)
2142
first_proc_ptr = new_proc_ptr;
2144
vp->num_allocated++;
2146
new_proc_ptr->pdr.isym = -1;
2147
new_proc_ptr->pdr.iline = -1;
2148
new_proc_ptr->pdr.lnLow = -1;
2149
new_proc_ptr->pdr.lnHigh = -1;
2151
/* Set the BSF_FUNCTION flag for the symbol. */
2152
sym = symbol_find_or_make (func);
2153
symbol_get_bfdsym (sym)->flags |= BSF_FUNCTION;
2155
/* Push the start of the function. */
2156
new_proc_ptr->sym = add_ecoff_symbol ((const char *) NULL, st_Proc, sc_Text,
2157
sym, (bfd_vma) 0, (symint_t) 0,
2162
/* Fill in the linenos preceding the .ent, if any. */
2163
if (noproc_lineno != (lineno_list_t *) NULL)
2167
for (l = noproc_lineno; l != (lineno_list_t *) NULL; l = l->next)
2168
l->proc = new_proc_ptr;
2169
*last_lineno_ptr = noproc_lineno;
2170
while (*last_lineno_ptr != NULL)
2172
last_lineno = *last_lineno_ptr;
2173
last_lineno_ptr = &last_lineno->next;
2175
noproc_lineno = (lineno_list_t *) NULL;
2180
ecoff_get_cur_proc_sym ()
2182
return (cur_proc_ptr ? cur_proc_ptr->sym->as_sym : NULL);
2185
/* Add a new filename, and set up all of the file relative
2186
virtual arrays (strings, symbols, aux syms, etc.). Record
2187
where the current file structure lives. */
2190
add_file (file_name, indx, fake)
2191
const char *file_name; /* file name */
2192
int indx ATTRIBUTE_UNUSED;
2195
register int first_ch;
2196
register efdr_t *fil_ptr;
2200
fprintf (stderr, "\tfile\t%.*s\n", len, file_start);
2203
/* If the file name is NULL, then no .file symbol appeared, and we
2204
want to use the actual file name. */
2205
if (file_name == (const char *) NULL)
2209
if (first_file != (efdr_t *) NULL)
2210
as_fatal (_("fake .file after real one"));
2211
as_where (&file, (unsigned int *) NULL);
2212
file_name = (const char *) file;
2214
/* Automatically generate ECOFF debugging information, since I
2215
think that's what other ECOFF assemblers do. We don't do
2216
this if we see a .file directive with a string, since that
2217
implies that some sort of debugging information is being
2219
if (! symbol_table_frozen && debug_type == DEBUG_UNSPECIFIED)
2220
debug_type = DEBUG_ECOFF;
2222
else if (debug_type == DEBUG_UNSPECIFIED)
2223
debug_type = DEBUG_NONE;
2227
listing_source_file (file_name);
2230
current_stabs_filename = file_name;
2232
/* If we're creating stabs, then we don't actually make a new FDR.
2233
Instead, we just create a stabs symbol. */
2236
(void) add_ecoff_symbol (file_name, st_Nil, sc_Nil,
2237
symbol_new ("L0\001", now_seg,
2238
(valueT) frag_now_fix (),
2240
(bfd_vma) 0, 0, ECOFF_MARK_STAB (N_SOL));
2244
first_ch = *file_name;
2246
/* FIXME: We can't safely merge files which have line number
2247
information (fMerge will be zero in this case). Otherwise, we
2248
get incorrect line number debugging info. See for instance
2249
ecoff_build_lineno, which will end up setting all file->fdr.*
2250
fields multiple times, resulting in incorrect debug info. In
2251
order to make this work right, all line number and symbol info
2252
for the same source file has to be adjacent in the object file,
2253
so that a single file descriptor can be used to point to them.
2254
This would require maintaining file specific lists of line
2255
numbers and symbols for each file, so that they can be merged
2256
together (or output together) when two .file pseudo-ops are
2257
merged into one file descriptor. */
2259
/* See if the file has already been created. */
2260
for (fil_ptr = first_file;
2261
fil_ptr != (efdr_t *) NULL;
2262
fil_ptr = fil_ptr->next_file)
2264
if (first_ch == fil_ptr->name[0]
2265
&& strcmp (file_name, fil_ptr->name) == 0
2266
&& fil_ptr->fdr.fMerge)
2268
cur_file_ptr = fil_ptr;
2270
cur_file_ptr->fake = 0;
2275
/* If this is a new file, create it. */
2276
if (fil_ptr == (efdr_t *) NULL)
2278
if (file_desc.objects_last_page == file_desc.objects_per_page)
2279
add_varray_page (&file_desc);
2281
fil_ptr = cur_file_ptr =
2282
&file_desc.last->datum->file[file_desc.objects_last_page++];
2283
*fil_ptr = init_file;
2285
fil_ptr->file_index = current_file_idx++;
2286
++file_desc.num_allocated;
2288
fil_ptr->fake = fake;
2290
/* Allocate the string hash table. */
2291
fil_ptr->str_hash = hash_new ();
2293
/* Make sure 0 byte in string table is null */
2294
add_string (&fil_ptr->strings,
2299
if (strlen (file_name) > PAGE_USIZE - 2)
2300
as_fatal (_("filename goes over one page boundary"));
2302
/* Push the start of the filename. We assume that the filename
2303
will be stored at string offset 1. */
2304
(void) add_ecoff_symbol (file_name, st_File, sc_Text,
2305
(symbolS *) NULL, (bfd_vma) 0,
2306
(symint_t) 0, (symint_t) 0);
2307
fil_ptr->fdr.rss = 1;
2308
fil_ptr->name = &fil_ptr->strings.last->datum->byte[1];
2310
/* Update the linked list of file descriptors. */
2311
*last_file_ptr = fil_ptr;
2312
last_file_ptr = &fil_ptr->next_file;
2314
/* Add void & int types to the file (void should be first to catch
2315
errant 0's within the index fields). */
2316
fil_ptr->void_type = add_aux_sym_tir (&void_type_info,
2318
&cur_file_ptr->thash_head[0]);
2320
fil_ptr->int_type = add_aux_sym_tir (&int_type_info,
2322
&cur_file_ptr->thash_head[0]);
2326
/* This function is called when the assembler notices a preprocessor
2327
directive switching to a new file. This will not happen in
2328
compiler output, only in hand coded assembler. */
2331
ecoff_new_file (name)
2334
if (cur_file_ptr != NULL && strcmp (cur_file_ptr->name, name) == 0)
2336
add_file (name, 0, 0);
2338
/* This is a hand coded assembler file, so automatically turn on
2339
debugging information. */
2340
if (debug_type == DEBUG_UNSPECIFIED)
2341
debug_type = DEBUG_ECOFF;
2346
/* Convert storage class to string. */
2349
sc_to_string (storage_class)
2352
switch (storage_class)
2354
case sc_Nil: return "Nil,";
2355
case sc_Text: return "Text,";
2356
case sc_Data: return "Data,";
2357
case sc_Bss: return "Bss,";
2358
case sc_Register: return "Register,";
2359
case sc_Abs: return "Abs,";
2360
case sc_Undefined: return "Undefined,";
2361
case sc_CdbLocal: return "CdbLocal,";
2362
case sc_Bits: return "Bits,";
2363
case sc_CdbSystem: return "CdbSystem,";
2364
case sc_RegImage: return "RegImage,";
2365
case sc_Info: return "Info,";
2366
case sc_UserStruct: return "UserStruct,";
2367
case sc_SData: return "SData,";
2368
case sc_SBss: return "SBss,";
2369
case sc_RData: return "RData,";
2370
case sc_Var: return "Var,";
2371
case sc_Common: return "Common,";
2372
case sc_SCommon: return "SCommon,";
2373
case sc_VarRegister: return "VarRegister,";
2374
case sc_Variant: return "Variant,";
2375
case sc_SUndefined: return "SUndefined,";
2376
case sc_Init: return "Init,";
2377
case sc_Max: return "Max,";
2387
/* Convert symbol type to string. */
2390
st_to_string (symbol_type)
2393
switch (symbol_type)
2395
case st_Nil: return "Nil,";
2396
case st_Global: return "Global,";
2397
case st_Static: return "Static,";
2398
case st_Param: return "Param,";
2399
case st_Local: return "Local,";
2400
case st_Label: return "Label,";
2401
case st_Proc: return "Proc,";
2402
case st_Block: return "Block,";
2403
case st_End: return "End,";
2404
case st_Member: return "Member,";
2405
case st_Typedef: return "Typedef,";
2406
case st_File: return "File,";
2407
case st_RegReloc: return "RegReloc,";
2408
case st_Forward: return "Forward,";
2409
case st_StaticProc: return "StaticProc,";
2410
case st_Constant: return "Constant,";
2411
case st_Str: return "String,";
2412
case st_Number: return "Number,";
2413
case st_Expr: return "Expr,";
2414
case st_Type: return "Type,";
2415
case st_Max: return "Max,";
2423
/* Parse .begin directives which have a label as the first argument
2424
which gives the location of the start of the block. */
2427
ecoff_directive_begin (ignore)
2428
int ignore ATTRIBUTE_UNUSED;
2433
if (cur_file_ptr == (efdr_t *) NULL)
2435
as_warn (_(".begin directive without a preceding .file directive"));
2436
demand_empty_rest_of_line ();
2440
if (cur_proc_ptr == (proc_t *) NULL)
2442
as_warn (_(".begin directive without a preceding .ent directive"));
2443
demand_empty_rest_of_line ();
2447
name = input_line_pointer;
2448
name_end = get_symbol_end ();
2450
(void) add_ecoff_symbol ((const char *) NULL, st_Block, sc_Text,
2451
symbol_find_or_make (name),
2452
(bfd_vma) 0, (symint_t) 0, (symint_t) 0);
2454
*input_line_pointer = name_end;
2456
/* The line number follows, but we don't use it. */
2457
(void) get_absolute_expression ();
2458
demand_empty_rest_of_line ();
2461
/* Parse .bend directives which have a label as the first argument
2462
which gives the location of the end of the block. */
2465
ecoff_directive_bend (ignore)
2466
int ignore ATTRIBUTE_UNUSED;
2472
if (cur_file_ptr == (efdr_t *) NULL)
2474
as_warn (_(".bend directive without a preceding .file directive"));
2475
demand_empty_rest_of_line ();
2479
if (cur_proc_ptr == (proc_t *) NULL)
2481
as_warn (_(".bend directive without a preceding .ent directive"));
2482
demand_empty_rest_of_line ();
2486
name = input_line_pointer;
2487
name_end = get_symbol_end ();
2489
/* The value is the distance between the .bend directive and the
2490
corresponding symbol. We fill in the offset when we write out
2492
endsym = symbol_find (name);
2493
if (endsym == (symbolS *) NULL)
2494
as_warn (_(".bend directive names unknown symbol"));
2496
(void) add_ecoff_symbol ((const char *) NULL, st_End, sc_Text, endsym,
2497
(bfd_vma) 0, (symint_t) 0, (symint_t) 0);
2499
*input_line_pointer = name_end;
2501
/* The line number follows, but we don't use it. */
2502
(void) get_absolute_expression ();
2503
demand_empty_rest_of_line ();
2506
/* COFF debugging information is provided as a series of directives
2507
(.def, .scl, etc.). We build up information as we read the
2508
directives in the following static variables, and file it away when
2509
we reach the .endef directive. */
2510
static char *coff_sym_name;
2511
static type_info_t coff_type;
2512
static sc_t coff_storage_class;
2513
static st_t coff_symbol_typ;
2514
static int coff_is_function;
2515
static char *coff_tag;
2516
static valueT coff_value;
2517
static symbolS *coff_sym_value;
2518
static bfd_vma coff_sym_addend;
2519
static int coff_inside_enumeration;
2521
/* Handle a .def directive: start defining a symbol. */
2524
ecoff_directive_def (ignore)
2525
int ignore ATTRIBUTE_UNUSED;
2530
ecoff_debugging_seen = 1;
2534
name = input_line_pointer;
2535
name_end = get_symbol_end ();
2537
if (coff_sym_name != (char *) NULL)
2538
as_warn (_(".def pseudo-op used inside of .def/.endef; ignored"));
2539
else if (*name == '\0')
2540
as_warn (_("empty symbol name in .def; ignored"));
2543
if (coff_sym_name != (char *) NULL)
2544
free (coff_sym_name);
2545
if (coff_tag != (char *) NULL)
2548
coff_sym_name = xstrdup (name);
2549
coff_type = type_info_init;
2550
coff_storage_class = sc_Nil;
2551
coff_symbol_typ = st_Nil;
2552
coff_is_function = 0;
2553
coff_tag = (char *) NULL;
2555
coff_sym_value = (symbolS *) NULL;
2556
coff_sym_addend = 0;
2559
*input_line_pointer = name_end;
2561
demand_empty_rest_of_line ();
2564
/* Handle a .dim directive, used to give dimensions for an array. The
2565
arguments are comma separated numbers. mips-tfile assumes that
2566
there will not be more than 6 dimensions, and gdb won't read any
2567
more than that anyhow, so I will also make that assumption. */
2570
ecoff_directive_dim (ignore)
2571
int ignore ATTRIBUTE_UNUSED;
2576
if (coff_sym_name == (char *) NULL)
2578
as_warn (_(".dim pseudo-op used outside of .def/.endef; ignored"));
2579
demand_empty_rest_of_line ();
2583
for (i = 0; i < N_TQ; i++)
2586
dimens[i] = get_absolute_expression ();
2587
if (*input_line_pointer == ',')
2588
++input_line_pointer;
2591
if (*input_line_pointer != '\n'
2592
&& *input_line_pointer != ';')
2593
as_warn (_("badly formed .dim directive"));
2601
/* The dimensions are stored away in reverse order. */
2604
if (coff_type.num_dims >= N_TQ)
2606
as_warn (_("too many .dim entries"));
2609
coff_type.dimensions[coff_type.num_dims] = dimens[i];
2610
++coff_type.num_dims;
2613
demand_empty_rest_of_line ();
2616
/* Handle a .scl directive, which sets the COFF storage class of the
2620
ecoff_directive_scl (ignore)
2621
int ignore ATTRIBUTE_UNUSED;
2625
if (coff_sym_name == (char *) NULL)
2627
as_warn (_(".scl pseudo-op used outside of .def/.endef; ignored"));
2628
demand_empty_rest_of_line ();
2632
val = get_absolute_expression ();
2634
coff_symbol_typ = map_coff_sym_type[val];
2635
coff_storage_class = map_coff_storage[val];
2637
demand_empty_rest_of_line ();
2640
/* Handle a .size directive. For some reason mips-tfile.c thinks that
2641
.size can have multiple arguments. We humor it, although gcc will
2642
never generate more than one argument. */
2645
ecoff_directive_size (ignore)
2646
int ignore ATTRIBUTE_UNUSED;
2651
if (coff_sym_name == (char *) NULL)
2653
as_warn (_(".size pseudo-op used outside of .def/.endef; ignored"));
2654
demand_empty_rest_of_line ();
2658
for (i = 0; i < N_TQ; i++)
2661
sizes[i] = get_absolute_expression ();
2662
if (*input_line_pointer == ',')
2663
++input_line_pointer;
2666
if (*input_line_pointer != '\n'
2667
&& *input_line_pointer != ';')
2668
as_warn (_("badly formed .size directive"));
2676
/* The sizes are stored away in reverse order. */
2679
if (coff_type.num_sizes >= N_TQ)
2681
as_warn (_("too many .size entries"));
2684
coff_type.sizes[coff_type.num_sizes] = sizes[i];
2685
++coff_type.num_sizes;
2688
demand_empty_rest_of_line ();
2691
/* Handle the .type directive, which gives the COFF type of the
2695
ecoff_directive_type (ignore)
2696
int ignore ATTRIBUTE_UNUSED;
2702
if (coff_sym_name == (char *) NULL)
2704
as_warn (_(".type pseudo-op used outside of .def/.endef; ignored"));
2705
demand_empty_rest_of_line ();
2709
val = get_absolute_expression ();
2711
coff_type.orig_type = BTYPE (val);
2712
coff_type.basic_type = map_coff_types[coff_type.orig_type];
2714
tq_ptr = &coff_type.type_qualifiers[N_TQ];
2715
while (val & ~N_BTMASK)
2717
if (tq_ptr == &coff_type.type_qualifiers[0])
2719
/* FIXME: We could handle this by setting the continued bit.
2720
There would still be a limit: the .type argument can not
2722
as_warn (_("the type of %s is too complex; it will be simplified"),
2728
else if (ISFCN (val))
2729
*--tq_ptr = tq_Proc;
2730
else if (ISARY (val))
2731
*--tq_ptr = tq_Array;
2733
as_fatal (_("Unrecognized .type argument"));
2738
tq_shft = &coff_type.type_qualifiers[0];
2739
while (tq_ptr != &coff_type.type_qualifiers[N_TQ])
2740
*tq_shft++ = *tq_ptr++;
2742
if (tq_shft != &coff_type.type_qualifiers[0] && tq_shft[-1] == tq_Proc)
2744
/* If this is a function, ignore it, so that we don't get two
2745
entries (one from the .ent, and one for the .def that
2746
precedes it). Save the type information so that the end
2747
block can properly add it after the begin block index. For
2748
MIPS knows what reason, we must strip off the function type
2750
coff_is_function = 1;
2751
tq_shft[-1] = tq_Nil;
2754
while (tq_shft != &coff_type.type_qualifiers[N_TQ])
2755
*tq_shft++ = tq_Nil;
2757
demand_empty_rest_of_line ();
2760
/* Handle the .tag directive, which gives the name of a structure,
2764
ecoff_directive_tag (ignore)
2765
int ignore ATTRIBUTE_UNUSED;
2770
if (coff_sym_name == (char *) NULL)
2772
as_warn (_(".tag pseudo-op used outside of .def/.endef; ignored"));
2773
demand_empty_rest_of_line ();
2777
name = input_line_pointer;
2778
name_end = get_symbol_end ();
2780
coff_tag = xstrdup (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)
2792
int ignore ATTRIBUTE_UNUSED;
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)
2827
int ignore ATTRIBUTE_UNUSED;
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 information"));
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)
3007
int ignore ATTRIBUTE_UNUSED;
3013
if (cur_file_ptr == (efdr_t *) NULL)
3015
as_warn (_(".end directive without a preceding .file directive"));
3016
demand_empty_rest_of_line ();
3020
if (cur_proc_ptr == (proc_t *) NULL)
3022
as_warn (_(".end directive without a preceding .ent directive"));
3023
demand_empty_rest_of_line ();
3027
name = input_line_pointer;
3028
name_end = get_symbol_end ();
3030
if (name == input_line_pointer)
3032
as_warn (_(".end directive has no name"));
3033
*input_line_pointer = name_end;
3034
demand_empty_rest_of_line ();
3038
/* The value is the distance between the .end directive and the
3039
corresponding symbol. We create a fake symbol to hold the
3040
current location, and put in the offset when we write out the
3042
ent = symbol_find (name);
3043
if (ent == (symbolS *) NULL)
3044
as_warn (_(".end directive names unknown symbol"));
3046
(void) add_ecoff_symbol ((const char *) NULL, st_End, sc_Text,
3047
symbol_new ("L0\001", now_seg,
3048
(valueT) frag_now_fix (),
3050
(bfd_vma) 0, (symint_t) 0, (symint_t) 0);
3052
cur_proc_ptr = (proc_t *) NULL;
3054
*input_line_pointer = name_end;
3055
demand_empty_rest_of_line ();
3058
/* Parse .ent directives. */
3061
ecoff_directive_ent (ignore)
3062
int ignore ATTRIBUTE_UNUSED;
3067
if (cur_file_ptr == (efdr_t *) NULL)
3068
add_file ((const char *) NULL, 0, 1);
3070
if (cur_proc_ptr != (proc_t *) NULL)
3072
as_warn (_("second .ent directive found before .end directive"));
3073
demand_empty_rest_of_line ();
3077
name = input_line_pointer;
3078
name_end = get_symbol_end ();
3080
if (name == input_line_pointer)
3082
as_warn (_(".ent directive has no name"));
3083
*input_line_pointer = name_end;
3084
demand_empty_rest_of_line ();
3088
add_procedure (name);
3090
*input_line_pointer = name_end;
3092
/* The .ent directive is sometimes followed by a number. I'm not
3093
really sure what the number means. I don't see any way to store
3094
the information in the PDR. The Irix 4 assembler seems to ignore
3097
if (*input_line_pointer == ',')
3099
++input_line_pointer;
3102
if (ISDIGIT (*input_line_pointer)
3103
|| *input_line_pointer == '-')
3104
(void) get_absolute_expression ();
3106
demand_empty_rest_of_line ();
3109
/* Parse .extern directives. */
3112
ecoff_directive_extern (ignore)
3113
int ignore ATTRIBUTE_UNUSED;
3120
name = input_line_pointer;
3121
c = get_symbol_end ();
3122
symbolp = symbol_find_or_make (name);
3123
*input_line_pointer = c;
3125
S_SET_EXTERNAL (symbolp);
3127
if (*input_line_pointer == ',')
3128
++input_line_pointer;
3129
size = get_absolute_expression ();
3131
symbol_get_obj (symbolp)->ecoff_extern_size = size;
3134
/* Parse .file directives. */
3137
ecoff_directive_file (ignore)
3138
int ignore ATTRIBUTE_UNUSED;
3144
if (cur_proc_ptr != (proc_t *) NULL)
3146
as_warn (_("no way to handle .file within .ent/.end section"));
3147
demand_empty_rest_of_line ();
3151
indx = (int) get_absolute_expression ();
3153
/* FIXME: we don't have to save the name here. */
3154
name = demand_copy_C_string (&len);
3156
add_file (name, indx - 1, 0);
3158
demand_empty_rest_of_line ();
3161
/* Parse .fmask directives. */
3164
ecoff_directive_fmask (ignore)
3165
int ignore ATTRIBUTE_UNUSED;
3169
if (cur_proc_ptr == (proc_t *) NULL)
3171
as_warn (_(".fmask outside of .ent"));
3172
demand_empty_rest_of_line ();
3176
if (get_absolute_expression_and_terminator (&val) != ',')
3178
as_warn (_("bad .fmask directive"));
3179
--input_line_pointer;
3180
demand_empty_rest_of_line ();
3184
cur_proc_ptr->pdr.fregmask = val;
3185
cur_proc_ptr->pdr.fregoffset = get_absolute_expression ();
3187
demand_empty_rest_of_line ();
3190
/* Parse .frame directives. */
3193
ecoff_directive_frame (ignore)
3194
int ignore ATTRIBUTE_UNUSED;
3198
if (cur_proc_ptr == (proc_t *) NULL)
3200
as_warn (_(".frame outside of .ent"));
3201
demand_empty_rest_of_line ();
3205
cur_proc_ptr->pdr.framereg = tc_get_register (1);
3208
if (*input_line_pointer++ != ','
3209
|| get_absolute_expression_and_terminator (&val) != ',')
3211
as_warn (_("bad .frame directive"));
3212
--input_line_pointer;
3213
demand_empty_rest_of_line ();
3217
cur_proc_ptr->pdr.frameoffset = val;
3219
cur_proc_ptr->pdr.pcreg = tc_get_register (0);
3222
/* Alpha-OSF1 adds "the offset of saved $a0 from $sp", according to
3223
Sandro. I don't yet know where this value should be stored, if
3225
demand_empty_rest_of_line ();
3231
/* Parse .mask directives. */
3234
ecoff_directive_mask (ignore)
3235
int ignore ATTRIBUTE_UNUSED;
3239
if (cur_proc_ptr == (proc_t *) NULL)
3241
as_warn (_(".mask outside of .ent"));
3242
demand_empty_rest_of_line ();
3246
if (get_absolute_expression_and_terminator (&val) != ',')
3248
as_warn (_("bad .mask directive"));
3249
--input_line_pointer;
3250
demand_empty_rest_of_line ();
3254
cur_proc_ptr->pdr.regmask = val;
3255
cur_proc_ptr->pdr.regoffset = get_absolute_expression ();
3257
demand_empty_rest_of_line ();
3260
/* Parse .loc directives. */
3263
ecoff_directive_loc (ignore)
3264
int ignore ATTRIBUTE_UNUSED;
3266
lineno_list_t *list;
3269
if (cur_file_ptr == (efdr_t *) NULL)
3271
as_warn (_(".loc before .file"));
3272
demand_empty_rest_of_line ();
3276
if (now_seg != text_section)
3278
as_warn (_(".loc outside of .text"));
3279
demand_empty_rest_of_line ();
3283
/* Skip the file number. */
3285
get_absolute_expression ();
3288
lineno = get_absolute_expression ();
3292
listing_source_line (lineno);
3295
/* If we're building stabs, then output a special label rather than
3296
ECOFF line number info. */
3299
(void) add_ecoff_symbol ((char *) NULL, st_Label, sc_Text,
3300
symbol_new ("L0\001", now_seg,
3301
(valueT) frag_now_fix (),
3303
(bfd_vma) 0, 0, lineno);
3307
list = allocate_lineno_list ();
3309
list->next = (lineno_list_t *) NULL;
3310
list->file = cur_file_ptr;
3311
list->proc = cur_proc_ptr;
3312
list->frag = frag_now;
3313
list->paddr = frag_now_fix ();
3314
list->lineno = lineno;
3316
/* We don't want to merge files which have line numbers. */
3317
cur_file_ptr->fdr.fMerge = 0;
3319
/* A .loc directive will sometimes appear before a .ent directive,
3320
which means that cur_proc_ptr will be NULL here. Arrange to
3322
if (cur_proc_ptr == (proc_t *) NULL)
3326
pl = &noproc_lineno;
3327
while (*pl != (lineno_list_t *) NULL)
3334
*last_lineno_ptr = list;
3335
last_lineno_ptr = &list->next;
3339
/* The MIPS assembler sometimes inserts nop instructions in the
3340
instruction stream. When this happens, we must patch up the .loc
3341
information so that it points to the instruction after the nop. */
3344
ecoff_fix_loc (old_frag, old_frag_offset)
3346
unsigned long old_frag_offset;
3348
if (last_lineno != NULL
3349
&& last_lineno->frag == old_frag
3350
&& last_lineno->paddr == old_frag_offset)
3352
last_lineno->frag = frag_now;
3353
last_lineno->paddr = frag_now_fix ();
3357
/* Make sure the @stabs symbol is emitted. */
3361
int ignore ATTRIBUTE_UNUSED;
3365
/* Add a dummy @stabs dymbol. */
3367
(void) add_ecoff_symbol (stabs_symbol, stNil, scInfo,
3369
(bfd_vma) 0, (symint_t) -1,
3370
ECOFF_MARK_STAB (0));
3374
/* Parse .weakext directives. */
3376
/* For TC_MIPS use the version in tc-mips.c. */
3378
ecoff_directive_weakext (ignore)
3379
int ignore ATTRIBUTE_UNUSED;
3386
name = input_line_pointer;
3387
c = get_symbol_end ();
3388
symbolP = symbol_find_or_make (name);
3389
*input_line_pointer = c;
3393
if (*input_line_pointer == ',')
3395
if (S_IS_DEFINED (symbolP))
3397
as_bad (_("symbol `%s' is already defined"),
3398
S_GET_NAME (symbolP));
3399
ignore_rest_of_line ();
3403
++input_line_pointer;
3405
if (! is_end_of_line[(unsigned char) *input_line_pointer])
3408
if (exp.X_op != O_symbol)
3410
as_bad (_("bad .weakext directive"));
3411
ignore_rest_of_line ();
3414
symbol_set_value_expression (symbolP, &exp);
3418
S_SET_WEAK (symbolP);
3420
demand_empty_rest_of_line ();
3422
#endif /* not TC_MIPS */
3424
/* Handle .stabs directives. The actual parsing routine is done by a
3425
generic routine. This routine is called via OBJ_PROCESS_STAB.
3426
When this is called, input_line_pointer will be pointing at the
3427
value field of the stab.
3429
.stabs directives have five fields:
3430
"string" a string, encoding the type information.
3431
code a numeric code, defined in <stab.h>
3433
desc a zero or line number
3434
value a numeric value or an address.
3436
If the value is relocatable, we transform this into:
3437
iss points as an index into string space
3438
value value from lookup of the name
3439
st st from lookup of the name
3440
sc sc from lookup of the name
3441
index code|CODE_MASK
3443
If the value is not relocatable, we transform this into:
3444
iss points as an index into string space
3448
index code|CODE_MASK
3450
.stabn directives have four fields (string is null):
3451
code a numeric code, defined in <stab.h>
3453
desc a zero or a line number
3454
value a numeric value or an address. */
3457
ecoff_stab (sec, what, string, type, other, desc)
3458
segT sec ATTRIBUTE_UNUSED;
3465
efdr_t *save_file_ptr = cur_file_ptr;
3472
localsym_t *hold = NULL;
3474
ecoff_debugging_seen = 1;
3476
/* We don't handle .stabd. */
3477
if (what != 's' && what != 'n')
3479
as_bad (_(".stab%c is not supported"), what);
3483
/* A .stabn uses a null name, not an empty string. */
3487
/* We ignore the other field. */
3489
as_warn (_(".stab%c: ignoring non-zero other field"), what);
3491
/* Make sure we have a current file. */
3492
if (cur_file_ptr == (efdr_t *) NULL)
3494
add_file ((const char *) NULL, 0, 1);
3495
save_file_ptr = cur_file_ptr;
3498
/* For stabs in ECOFF, the first symbol must be @stabs. This is a
3500
if (stabs_seen == 0)
3503
/* Line number stabs are handled differently, since they have two
3504
values, the line number and the address of the label. We use the
3505
index field (aka desc) to hold the line number, and the value
3506
field to hold the address. The symbol type is st_Label, which
3507
should be different from the other stabs, so that gdb can
3509
if (type == N_SLINE)
3517
listing_source_line ((unsigned int) desc);
3520
dummy_symr.index = desc;
3521
if (dummy_symr.index != desc)
3523
as_warn (_("line number (%d) for .stab%c directive cannot fit in index field (20 bits)"),
3528
name = input_line_pointer;
3529
name_end = get_symbol_end ();
3531
sym = symbol_find_or_make (name);
3532
*input_line_pointer = name_end;
3543
if (listing && (type == N_SO || type == N_SOL))
3544
listing_source_file (string);
3547
if (ISDIGIT (*input_line_pointer)
3548
|| *input_line_pointer == '-'
3549
|| *input_line_pointer == '+')
3553
sym = (symbolS *) NULL;
3554
value = get_absolute_expression ();
3557
else if (! is_name_beginner ((unsigned char) *input_line_pointer))
3559
as_warn (_("illegal .stab%c directive, bad character"), what);
3570
if (exp.X_op == O_constant)
3573
value = exp.X_add_number;
3576
else if (exp.X_op == O_symbol)
3578
sym = exp.X_add_symbol;
3580
addend = exp.X_add_number;
3584
sym = make_expr_symbol (&exp);
3590
indx = ECOFF_MARK_STAB (type);
3593
/* Don't store the stabs symbol we are creating as the type of the
3594
ECOFF symbol. We want to compute the type of the ECOFF symbol
3596
if (sym != (symbolS *) NULL)
3597
hold = symbol_get_obj (sym)->ecoff_symbol;
3599
(void) add_ecoff_symbol (string, st, sc, sym, addend, value, indx);
3601
if (sym != (symbolS *) NULL)
3602
symbol_get_obj (sym)->ecoff_symbol = hold;
3604
/* Restore normal file type. */
3605
cur_file_ptr = save_file_ptr;
3608
/* Frob an ECOFF symbol. Small common symbols go into a special
3609
.scommon section rather than bfd_com_section. */
3612
ecoff_frob_symbol (sym)
3615
if (S_IS_COMMON (sym)
3616
&& S_GET_VALUE (sym) > 0
3617
&& S_GET_VALUE (sym) <= bfd_get_gp_size (stdoutput))
3619
static asection scom_section;
3620
static asymbol scom_symbol;
3622
/* We must construct a fake section similar to bfd_com_section
3623
but with the name .scommon. */
3624
if (scom_section.name == NULL)
3626
scom_section = bfd_com_section;
3627
scom_section.name = ".scommon";
3628
scom_section.output_section = &scom_section;
3629
scom_section.symbol = &scom_symbol;
3630
scom_section.symbol_ptr_ptr = &scom_section.symbol;
3631
scom_symbol = *bfd_com_section.symbol;
3632
scom_symbol.name = ".scommon";
3633
scom_symbol.section = &scom_section;
3635
S_SET_SEGMENT (sym, &scom_section);
3638
/* Double check weak symbols. */
3639
if (S_IS_WEAK (sym))
3641
if (S_IS_COMMON (sym))
3642
as_bad (_("symbol `%s' can not be both weak and common"),
3647
/* Add bytes to the symbolic information buffer. */
3650
ecoff_add_bytes (buf, bufend, bufptr, need)
3660
need -= *bufend - bufptr;
3661
if (need < PAGE_SIZE)
3663
want = (*bufend - *buf) + need;
3664
*buf = xrealloc (*buf, want);
3665
*bufend = *buf + want;
3669
/* Adjust the symbolic information buffer to the alignment required
3670
for the ECOFF target debugging information. */
3672
static unsigned long
3673
ecoff_padding_adjust (backend, buf, bufend, offset, bufptrptr)
3674
const struct ecoff_debug_swap *backend;
3677
unsigned long offset;
3680
bfd_size_type align;
3682
align = backend->debug_align;
3683
if ((offset & (align - 1)) != 0)
3687
add = align - (offset & (align - 1));
3688
if ((unsigned long) (*bufend - (*buf + offset)) < add)
3689
(void) ecoff_add_bytes (buf, bufend, *buf + offset, add);
3690
memset (*buf + offset, 0, add);
3692
if (bufptrptr != (char **) NULL)
3693
*bufptrptr = *buf + offset;
3699
/* Build the line number information. */
3701
static unsigned long
3702
ecoff_build_lineno (backend, buf, bufend, offset, linecntptr)
3703
const struct ecoff_debug_swap *backend;
3706
unsigned long offset;
3710
register lineno_list_t *l;
3711
lineno_list_t *last;
3717
lineno_list_t first;
3718
lineno_list_t *local_first_lineno = first_lineno;
3720
if (linecntptr != (long *) NULL)
3723
bufptr = *buf + offset;
3725
file = (efdr_t *) NULL;
3726
proc = (proc_t *) NULL;
3727
last = (lineno_list_t *) NULL;
3732
/* For some reason the address of the first procedure is ignored
3733
when reading line numbers. This doesn't matter if the address of
3734
the first procedure is 0, but when gcc is generating MIPS
3735
embedded PIC code, it will put strings in the .text section
3736
before the first procedure. We cope by inserting a dummy line if
3737
the address of the first procedure is not 0. Hopefully this
3738
won't screw things up too badly.
3740
Don't do this for ECOFF assembly source line numbers. They work
3741
without this extra attention. */
3742
if (debug_type != DEBUG_ECOFF
3743
&& first_proc_ptr != (proc_t *) NULL
3744
&& local_first_lineno != (lineno_list_t *) NULL
3745
&& ((S_GET_VALUE (first_proc_ptr->sym->as_sym)
3746
+ bfd_get_section_vma (stdoutput,
3747
S_GET_SEGMENT (first_proc_ptr->sym->as_sym)))
3750
first.file = local_first_lineno->file;
3751
first.proc = local_first_lineno->proc;
3752
first.frag = &zero_address_frag;
3756
first.next = local_first_lineno;
3757
local_first_lineno = &first;
3760
for (l = local_first_lineno; l != (lineno_list_t *) NULL; l = l->next)
3765
/* Get the offset to the memory address of the next line number
3766
(in words). Do this first, so that we can skip ahead to the
3767
next useful line number entry. */
3768
if (l->next == (lineno_list_t *) NULL)
3770
/* We want a count of zero, but it will be decremented
3771
before it is used. */
3774
else if (l->next->frag->fr_address + l->next->paddr
3775
> l->frag->fr_address + l->paddr)
3777
count = ((l->next->frag->fr_address + l->next->paddr
3778
- (l->frag->fr_address + l->paddr))
3783
/* Don't change last, so we still get the right delta. */
3787
if (l->file != file || l->proc != proc)
3789
if (l->proc != proc && proc != (proc_t *) NULL)
3790
proc->pdr.lnHigh = last->lineno;
3791
if (l->file != file && file != (efdr_t *) NULL)
3793
file->fdr.cbLine = c - file->fdr.cbLineOffset;
3794
file->fdr.cline = totcount + count;
3795
if (linecntptr != (long *) NULL)
3796
*linecntptr += totcount + count;
3800
if (l->file != file)
3802
efdr_t *last_file = file;
3805
if (last_file != (efdr_t *) NULL)
3807
= last_file->fdr.ilineBase + last_file->fdr.cline;
3809
file->fdr.ilineBase = 0;
3810
file->fdr.cbLineOffset = c;
3812
if (l->proc != proc)
3815
if (proc != (proc_t *) NULL)
3817
proc->pdr.lnLow = l->lineno;
3818
proc->pdr.cbLineOffset = c - file->fdr.cbLineOffset;
3819
proc->pdr.iline = totcount;
3823
last = (lineno_list_t *) NULL;
3828
/* Get the offset to this line number. */
3829
if (last == (lineno_list_t *) NULL)
3832
delta = l->lineno - last->lineno;
3834
/* Put in the offset to this line number. */
3839
/* 1 is added to each count read. */
3841
/* We can only adjust the word count by up to 15 words at a
3853
if (delta >= -7 && delta <= 7)
3855
if (bufptr >= *bufend)
3856
bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1);
3857
*bufptr++ = setcount + (delta << 4);
3865
if (*bufend - bufptr < 3)
3866
bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 3);
3867
*bufptr++ = setcount + (8 << 4);
3868
if (delta < -0x8000)
3873
else if (delta > 0x7fff)
3883
*bufptr++ = set >> 8;
3884
*bufptr++ = set & 0xffff;
3889
/* Finish adjusting the count. */
3892
if (bufptr >= *bufend)
3893
bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1);
3894
/* 1 is added to each count read. */
3913
if (proc != (proc_t *) NULL)
3914
proc->pdr.lnHigh = last->lineno;
3915
if (file != (efdr_t *) NULL)
3917
file->fdr.cbLine = c - file->fdr.cbLineOffset;
3918
file->fdr.cline = totcount;
3921
if (linecntptr != (long *) NULL)
3922
*linecntptr += totcount;
3924
c = ecoff_padding_adjust (backend, buf, bufend, c, &bufptr);
3929
/* Build and swap out the symbols. */
3931
static unsigned long
3932
ecoff_build_symbols (backend, buf, bufend, offset)
3933
const struct ecoff_debug_swap *backend;
3936
unsigned long offset;
3938
const bfd_size_type external_sym_size = backend->external_sym_size;
3939
void (* const swap_sym_out) PARAMS ((bfd *, const SYMR *, PTR))
3940
= backend->swap_sym_out;
3943
vlinks_t *file_link;
3945
sym_out = *buf + offset;
3949
/* The symbols are stored by file. */
3950
for (file_link = file_desc.first;
3951
file_link != (vlinks_t *) NULL;
3952
file_link = file_link->next)
3959
if (file_link->next == (vlinks_t *) NULL)
3960
fil_cnt = file_desc.objects_last_page;
3962
fil_cnt = file_desc.objects_per_page;
3963
fil_ptr = file_link->datum->file;
3964
fil_end = fil_ptr + fil_cnt;
3965
for (; fil_ptr < fil_end; fil_ptr++)
3969
fil_ptr->fdr.isymBase = isym;
3971
for (sym_link = fil_ptr->symbols.first;
3972
sym_link != (vlinks_t *) NULL;
3973
sym_link = sym_link->next)
3976
localsym_t *sym_ptr;
3977
localsym_t *sym_end;
3979
if (sym_link->next == (vlinks_t *) NULL)
3980
sym_cnt = fil_ptr->symbols.objects_last_page;
3982
sym_cnt = fil_ptr->symbols.objects_per_page;
3983
sym_ptr = sym_link->datum->sym;
3984
sym_end = sym_ptr + sym_cnt;
3985
for (; sym_ptr < sym_end; sym_ptr++)
3991
know (sym_ptr->file_ptr == fil_ptr);
3993
/* If there is no associated gas symbol, then this
3994
is a pure debugging symbol. We have already
3995
added the name (if any) to fil_ptr->strings.
3996
Otherwise we must decide whether this is an
3997
external or a local symbol (actually, it may be
3998
both if the local provides additional debugging
3999
information for the external). */
4001
as_sym = sym_ptr->as_sym;
4002
if (as_sym != (symbolS *) NULL)
4006
/* The value of a block start symbol is the
4007
offset from the start of the procedure. For
4008
other symbols we just use the gas value (but
4009
we must offset it by the vma of the section,
4010
just as BFD does, because BFD will not see
4012
if (sym_ptr->ecoff_sym.asym.st == (int) st_Block
4013
&& sym_ptr->ecoff_sym.asym.sc == (int) sc_Text)
4017
know (sym_ptr->proc_ptr != (proc_t *) NULL);
4018
begin_sym = sym_ptr->proc_ptr->sym->as_sym;
4019
if (S_GET_SEGMENT (as_sym)
4020
!= S_GET_SEGMENT (begin_sym))
4021
as_warn (_(".begin/.bend in different segments"));
4022
sym_ptr->ecoff_sym.asym.value =
4023
S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym);
4026
sym_ptr->ecoff_sym.asym.value =
4027
(S_GET_VALUE (as_sym)
4028
+ bfd_get_section_vma (stdoutput,
4029
S_GET_SEGMENT (as_sym))
4032
sym_ptr->ecoff_sym.weakext = S_IS_WEAK (as_sym);
4034
/* Set st_Proc to st_StaticProc for local
4036
if (sym_ptr->ecoff_sym.asym.st == st_Proc
4037
&& S_IS_DEFINED (as_sym)
4038
&& ! S_IS_EXTERNAL (as_sym)
4039
&& ! S_IS_WEAK (as_sym))
4040
sym_ptr->ecoff_sym.asym.st = st_StaticProc;
4042
/* Get the type and storage class based on where
4043
the symbol actually wound up. Traditionally,
4044
N_LBRAC and N_RBRAC are *not* relocated. */
4045
indx = sym_ptr->ecoff_sym.asym.index;
4046
if (sym_ptr->ecoff_sym.asym.st == st_Nil
4047
&& sym_ptr->ecoff_sym.asym.sc == sc_Nil
4048
&& (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym)
4049
|| ((ECOFF_UNMARK_STAB (indx) != N_LBRAC)
4050
&& (ECOFF_UNMARK_STAB (indx) != N_RBRAC))))
4053
const char *segname;
4057
seg = S_GET_SEGMENT (as_sym);
4058
segname = segment_name (seg);
4060
if (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym)
4061
&& (S_IS_EXTERNAL (as_sym)
4062
|| S_IS_WEAK (as_sym)
4063
|| ! S_IS_DEFINED (as_sym)))
4065
if ((symbol_get_bfdsym (as_sym)->flags
4066
& BSF_FUNCTION) != 0)
4071
else if (seg == text_section)
4076
if (! S_IS_DEFINED (as_sym))
4080
s = symbol_get_obj (as_sym)->ecoff_extern_size;
4082
|| s > bfd_get_gp_size (stdoutput))
4087
sym_ptr->ecoff_sym.asym.value = s;
4090
S_SET_SIZE (as_sym, s);
4093
else if (S_IS_COMMON (as_sym))
4095
if (S_GET_VALUE (as_sym) > 0
4096
&& (S_GET_VALUE (as_sym)
4097
<= bfd_get_gp_size (stdoutput)))
4102
else if (seg == text_section)
4104
else if (seg == data_section)
4106
else if (strcmp (segname, ".rdata") == 0
4107
|| strcmp (segname, ".rodata") == 0)
4109
else if (strcmp (segname, ".sdata") == 0)
4111
else if (seg == bss_section)
4113
else if (strcmp (segname, ".sbss") == 0)
4115
else if (seg == &bfd_abs_section)
4119
/* This must be a user named section.
4120
This is not possible in ECOFF, but it
4125
sym_ptr->ecoff_sym.asym.st = (int) st;
4126
sym_ptr->ecoff_sym.asym.sc = (int) sc;
4129
/* This is just an external symbol if it is
4130
outside a procedure and it has a type.
4131
FIXME: g++ will generate symbols which have
4132
different names in the debugging information
4133
than the actual symbol. Should we handle
4135
if ((S_IS_EXTERNAL (as_sym)
4136
|| S_IS_WEAK (as_sym)
4137
|| ! S_IS_DEFINED (as_sym))
4138
&& sym_ptr->proc_ptr == (proc_t *) NULL
4139
&& sym_ptr->ecoff_sym.asym.st != (int) st_Nil
4140
&& ! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym))
4143
/* This is just an external symbol if it is a
4145
if (S_IS_COMMON (as_sym))
4148
/* If an st_end symbol has an associated gas
4149
symbol, then it is a local label created for
4150
a .bend or .end directive. Stabs line
4151
numbers will have \001 in the names. */
4153
&& sym_ptr->ecoff_sym.asym.st != st_End
4154
&& strchr (sym_ptr->name, '\001') == 0)
4155
sym_ptr->ecoff_sym.asym.iss =
4156
add_string (&fil_ptr->strings,
4162
/* We now know the index of this symbol; fill in
4163
locations that have been waiting for that
4165
if (sym_ptr->begin_ptr != (localsym_t *) NULL)
4167
localsym_t *begin_ptr;
4171
begin_ptr = sym_ptr->begin_ptr;
4172
know (begin_ptr->sym_index != -1);
4173
sym_ptr->ecoff_sym.asym.index = begin_ptr->sym_index;
4174
if (sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
4175
sym_ptr->ecoff_sym.asym.iss =
4176
begin_ptr->ecoff_sym.asym.iss;
4178
begin_type = begin_ptr->ecoff_sym.asym.st;
4179
if (begin_type == st_File
4180
|| begin_type == st_Block)
4182
begin_ptr->ecoff_sym.asym.index =
4183
isym - ifilesym + 1;
4184
(*swap_sym_out) (stdoutput,
4185
&begin_ptr->ecoff_sym.asym,
4188
+ (begin_ptr->sym_index
4189
* external_sym_size)));
4193
know (begin_ptr->index_ptr != (aux_t *) NULL);
4194
begin_ptr->index_ptr->data.isym =
4195
isym - ifilesym + 1;
4198
/* The value of the symbol marking the end of a
4199
procedure is the size of the procedure. The
4200
value of the symbol marking the end of a
4201
block is the offset from the start of the
4202
procedure to the block. */
4203
if (begin_type == st_Proc
4204
|| begin_type == st_StaticProc)
4206
know (as_sym != (symbolS *) NULL);
4207
know (begin_ptr->as_sym != (symbolS *) NULL);
4208
if (S_GET_SEGMENT (as_sym)
4209
!= S_GET_SEGMENT (begin_ptr->as_sym))
4210
as_warn (_(".begin/.bend in different segments"));
4211
sym_ptr->ecoff_sym.asym.value =
4212
(S_GET_VALUE (as_sym)
4213
- S_GET_VALUE (begin_ptr->as_sym));
4215
/* If the size is odd, this is probably a
4216
mips16 function; force it to be even. */
4217
if ((sym_ptr->ecoff_sym.asym.value & 1) != 0)
4218
++sym_ptr->ecoff_sym.asym.value;
4221
S_SET_SIZE (begin_ptr->as_sym,
4222
sym_ptr->ecoff_sym.asym.value);
4225
else if (begin_type == st_Block
4226
&& sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
4230
know (as_sym != (symbolS *) NULL);
4231
know (sym_ptr->proc_ptr != (proc_t *) NULL);
4232
begin_sym = sym_ptr->proc_ptr->sym->as_sym;
4233
if (S_GET_SEGMENT (as_sym)
4234
!= S_GET_SEGMENT (begin_sym))
4235
as_warn (_(".begin/.bend in different segments"));
4236
sym_ptr->ecoff_sym.asym.value =
4237
S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym);
4241
for (f = sym_ptr->forward_ref;
4242
f != (forward_t *) NULL;
4246
f->ifd_ptr->data.isym = fil_ptr->file_index;
4247
f->index_ptr->data.rndx.index = isym - ifilesym;
4252
if ((bfd_size_type)(*bufend - sym_out) < external_sym_size)
4253
sym_out = ecoff_add_bytes (buf, bufend,
4256
(*swap_sym_out) (stdoutput, &sym_ptr->ecoff_sym.asym,
4258
sym_out += external_sym_size;
4260
sym_ptr->sym_index = isym;
4262
if (sym_ptr->proc_ptr != (proc_t *) NULL
4263
&& sym_ptr->proc_ptr->sym == sym_ptr)
4264
sym_ptr->proc_ptr->pdr.isym = isym - ifilesym;
4269
/* Record the local symbol index and file number in
4270
case this is an external symbol. Note that this
4271
destroys the asym.index field. */
4272
if (as_sym != (symbolS *) NULL
4273
&& symbol_get_obj (as_sym)->ecoff_symbol == sym_ptr)
4275
if ((sym_ptr->ecoff_sym.asym.st == st_Proc
4276
|| sym_ptr->ecoff_sym.asym.st == st_StaticProc)
4278
sym_ptr->ecoff_sym.asym.index = isym - ifilesym - 1;
4279
sym_ptr->ecoff_sym.ifd = fil_ptr->file_index;
4281
/* Don't try to merge an FDR which has an
4282
external symbol attached to it. */
4283
if (S_IS_EXTERNAL (as_sym) || S_IS_WEAK (as_sym))
4284
fil_ptr->fdr.fMerge = 0;
4288
fil_ptr->fdr.csym = isym - fil_ptr->fdr.isymBase;
4292
return offset + isym * external_sym_size;
4295
/* Swap out the procedure information. */
4297
static unsigned long
4298
ecoff_build_procs (backend, buf, bufend, offset)
4299
const struct ecoff_debug_swap *backend;
4302
unsigned long offset;
4304
const bfd_size_type external_pdr_size = backend->external_pdr_size;
4305
void (* const swap_pdr_out) PARAMS ((bfd *, const PDR *, PTR))
4306
= backend->swap_pdr_out;
4309
vlinks_t *file_link;
4311
pdr_out = *buf + offset;
4315
/* The procedures are stored by file. */
4316
for (file_link = file_desc.first;
4317
file_link != (vlinks_t *) NULL;
4318
file_link = file_link->next)
4324
if (file_link->next == (vlinks_t *) NULL)
4325
fil_cnt = file_desc.objects_last_page;
4327
fil_cnt = file_desc.objects_per_page;
4328
fil_ptr = file_link->datum->file;
4329
fil_end = fil_ptr + fil_cnt;
4330
for (; fil_ptr < fil_end; fil_ptr++)
4332
vlinks_t *proc_link;
4335
fil_ptr->fdr.ipdFirst = iproc;
4337
for (proc_link = fil_ptr->procs.first;
4338
proc_link != (vlinks_t *) NULL;
4339
proc_link = proc_link->next)
4345
if (proc_link->next == (vlinks_t *) NULL)
4346
prc_cnt = fil_ptr->procs.objects_last_page;
4348
prc_cnt = fil_ptr->procs.objects_per_page;
4349
proc_ptr = proc_link->datum->proc;
4350
proc_end = proc_ptr + prc_cnt;
4351
for (; proc_ptr < proc_end; proc_ptr++)
4356
adr_sym = proc_ptr->sym->as_sym;
4357
adr = (S_GET_VALUE (adr_sym)
4358
+ bfd_get_section_vma (stdoutput,
4359
S_GET_SEGMENT (adr_sym)));
4362
/* This code used to force the adr of the very
4363
first fdr to be 0. However, the native tools
4364
don't do that, and I can't remember why it
4365
used to work that way, so I took it out. */
4366
fil_ptr->fdr.adr = adr;
4369
proc_ptr->pdr.adr = adr - fil_ptr->fdr.adr;
4370
if ((bfd_size_type)(*bufend - pdr_out) < external_pdr_size)
4371
pdr_out = ecoff_add_bytes (buf, bufend,
4374
(*swap_pdr_out) (stdoutput, &proc_ptr->pdr, pdr_out);
4375
pdr_out += external_pdr_size;
4379
fil_ptr->fdr.cpd = iproc - fil_ptr->fdr.ipdFirst;
4383
return offset + iproc * external_pdr_size;
4386
/* Swap out the aux information. */
4388
static unsigned long
4389
ecoff_build_aux (backend, buf, bufend, offset)
4390
const struct ecoff_debug_swap *backend;
4393
unsigned long offset;
4396
union aux_ext *aux_out;
4398
vlinks_t *file_link;
4400
bigendian = bfd_big_endian (stdoutput);
4402
aux_out = (union aux_ext *) (*buf + offset);
4406
/* The aux entries are stored by file. */
4407
for (file_link = file_desc.first;
4408
file_link != (vlinks_t *) NULL;
4409
file_link = file_link->next)
4415
if (file_link->next == (vlinks_t *) NULL)
4416
fil_cnt = file_desc.objects_last_page;
4418
fil_cnt = file_desc.objects_per_page;
4419
fil_ptr = file_link->datum->file;
4420
fil_end = fil_ptr + fil_cnt;
4421
for (; fil_ptr < fil_end; fil_ptr++)
4425
fil_ptr->fdr.fBigendian = bigendian;
4426
fil_ptr->fdr.iauxBase = iaux;
4427
for (aux_link = fil_ptr->aux_syms.first;
4428
aux_link != (vlinks_t *) NULL;
4429
aux_link = aux_link->next)
4435
if (aux_link->next == (vlinks_t *) NULL)
4436
aux_cnt = fil_ptr->aux_syms.objects_last_page;
4438
aux_cnt = fil_ptr->aux_syms.objects_per_page;
4439
aux_ptr = aux_link->datum->aux;
4440
aux_end = aux_ptr + aux_cnt;
4441
for (; aux_ptr < aux_end; aux_ptr++)
4443
if ((unsigned long) (*bufend - (char *) aux_out)
4444
< sizeof (union aux_ext))
4445
aux_out = ((union aux_ext *)
4446
ecoff_add_bytes (buf, bufend,
4448
sizeof (union aux_ext)));
4449
switch (aux_ptr->type)
4452
(*backend->swap_tir_out) (bigendian,
4457
(*backend->swap_rndx_out) (bigendian,
4458
&aux_ptr->data.rndx,
4462
AUX_PUT_DNLOW (bigendian, aux_ptr->data.dnLow,
4466
AUX_PUT_DNHIGH (bigendian, aux_ptr->data.dnHigh,
4470
AUX_PUT_ISYM (bigendian, aux_ptr->data.isym,
4474
AUX_PUT_ISS (bigendian, aux_ptr->data.iss,
4478
AUX_PUT_WIDTH (bigendian, aux_ptr->data.width,
4482
AUX_PUT_COUNT (bigendian, aux_ptr->data.count,
4491
fil_ptr->fdr.caux = iaux - fil_ptr->fdr.iauxBase;
4495
return ecoff_padding_adjust (backend, buf, bufend,
4496
offset + iaux * sizeof (union aux_ext),
4500
/* Copy out the strings from a varray_t. This returns the number of
4501
bytes copied, rather than the new offset. */
4503
static unsigned long
4504
ecoff_build_strings (buf, bufend, offset, vp)
4507
unsigned long offset;
4514
str_out = *buf + offset;
4518
for (str_link = vp->first;
4519
str_link != (vlinks_t *) NULL;
4520
str_link = str_link->next)
4522
unsigned long str_cnt;
4524
if (str_link->next == (vlinks_t *) NULL)
4525
str_cnt = vp->objects_last_page;
4527
str_cnt = vp->objects_per_page;
4529
if ((unsigned long)(*bufend - str_out) < str_cnt)
4530
str_out = ecoff_add_bytes (buf, bufend, str_out, str_cnt);
4532
memcpy (str_out, str_link->datum->byte, str_cnt);
4540
/* Dump out the local strings. */
4542
static unsigned long
4543
ecoff_build_ss (backend, buf, bufend, offset)
4544
const struct ecoff_debug_swap *backend;
4547
unsigned long offset;
4550
vlinks_t *file_link;
4554
for (file_link = file_desc.first;
4555
file_link != (vlinks_t *) NULL;
4556
file_link = file_link->next)
4562
if (file_link->next == (vlinks_t *) NULL)
4563
fil_cnt = file_desc.objects_last_page;
4565
fil_cnt = file_desc.objects_per_page;
4566
fil_ptr = file_link->datum->file;
4567
fil_end = fil_ptr + fil_cnt;
4568
for (; fil_ptr < fil_end; fil_ptr++)
4572
fil_ptr->fdr.issBase = iss;
4573
ss_cnt = ecoff_build_strings (buf, bufend, offset + iss,
4575
fil_ptr->fdr.cbSs = ss_cnt;
4580
return ecoff_padding_adjust (backend, buf, bufend, offset + iss,
4584
/* Swap out the file descriptors. */
4586
static unsigned long
4587
ecoff_build_fdr (backend, buf, bufend, offset)
4588
const struct ecoff_debug_swap *backend;
4591
unsigned long offset;
4593
const bfd_size_type external_fdr_size = backend->external_fdr_size;
4594
void (* const swap_fdr_out) PARAMS ((bfd *, const FDR *, PTR))
4595
= backend->swap_fdr_out;
4598
vlinks_t *file_link;
4602
fdr_out = *buf + offset;
4604
for (file_link = file_desc.first;
4605
file_link != (vlinks_t *) NULL;
4606
file_link = file_link->next)
4612
if (file_link->next == (vlinks_t *) NULL)
4613
fil_cnt = file_desc.objects_last_page;
4615
fil_cnt = file_desc.objects_per_page;
4616
fil_ptr = file_link->datum->file;
4617
fil_end = fil_ptr + fil_cnt;
4618
for (; fil_ptr < fil_end; fil_ptr++)
4620
if ((bfd_size_type)(*bufend - fdr_out) < external_fdr_size)
4621
fdr_out = ecoff_add_bytes (buf, bufend, fdr_out,
4623
(*swap_fdr_out) (stdoutput, &fil_ptr->fdr, fdr_out);
4624
fdr_out += external_fdr_size;
4629
return offset + ifile * external_fdr_size;
4632
/* Set up the external symbols. These are supposed to be handled by
4633
the backend. This routine just gets the right information and
4634
calls a backend function to deal with it. */
4639
register symbolS *sym;
4641
for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
4643
if (symbol_get_obj (sym)->ecoff_symbol == NULL)
4646
/* If this is a local symbol, then force the fields to zero. */
4647
if (! S_IS_EXTERNAL (sym)
4648
&& ! S_IS_WEAK (sym)
4649
&& S_IS_DEFINED (sym))
4651
struct localsym *lsym;
4653
lsym = symbol_get_obj (sym)->ecoff_symbol;
4654
lsym->ecoff_sym.asym.value = 0;
4655
lsym->ecoff_sym.asym.st = (int) st_Nil;
4656
lsym->ecoff_sym.asym.sc = (int) sc_Nil;
4657
lsym->ecoff_sym.asym.index = indexNil;
4660
obj_ecoff_set_ext (sym, &symbol_get_obj (sym)->ecoff_symbol->ecoff_sym);
4664
/* Build the ECOFF debugging information. */
4667
ecoff_build_debug (hdr, bufp, backend)
4670
const struct ecoff_debug_swap *backend;
4672
const bfd_size_type external_pdr_size = backend->external_pdr_size;
4677
efdr_t *hold_file_ptr;
4678
proc_t *hold_proc_ptr;
4682
unsigned long offset;
4684
/* Make sure we have a file. */
4685
if (first_file == (efdr_t *) NULL)
4686
add_file ((const char *) NULL, 0, 1);
4688
/* Handle any top level tags. */
4689
for (ptag = top_tag_head->first_tag;
4690
ptag != (tag_t *) NULL;
4693
if (ptag->forward_ref != (forward_t *) NULL)
4694
add_unknown_tag (ptag);
4696
ptag_next = ptag->same_block;
4697
ptag->hash_ptr->tag_ptr = ptag->same_name;
4701
free_thead (top_tag_head);
4703
/* Look through the symbols. Add debugging information for each
4704
symbol that has not already received it. */
4705
hold_file_ptr = cur_file_ptr;
4706
hold_proc_ptr = cur_proc_ptr;
4707
cur_proc_ptr = (proc_t *) NULL;
4708
for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
4710
if (symbol_get_obj (sym)->ecoff_symbol != NULL
4711
|| symbol_get_obj (sym)->ecoff_file == (efdr_t *) NULL
4712
|| (symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) != 0)
4715
cur_file_ptr = symbol_get_obj (sym)->ecoff_file;
4716
add_ecoff_symbol ((const char *) NULL, st_Nil, sc_Nil, sym,
4717
(bfd_vma) 0, S_GET_VALUE (sym), indexNil);
4719
cur_proc_ptr = hold_proc_ptr;
4720
cur_file_ptr = hold_file_ptr;
4722
/* Output an ending symbol for all the files. We have to do this
4723
here for the last file, so we may as well do it for all of the
4726
for (fil_ptr = first_file;
4727
fil_ptr != (efdr_t *) NULL;
4728
fil_ptr = fil_ptr->next_file)
4730
cur_file_ptr = fil_ptr;
4731
while (cur_file_ptr->cur_scope != (scope_t *) NULL
4732
&& cur_file_ptr->cur_scope->prev != (scope_t *) NULL)
4734
cur_file_ptr->cur_scope = cur_file_ptr->cur_scope->prev;
4735
if (! end_warning && ! cur_file_ptr->fake)
4737
as_warn (_("missing .end or .bend at end of file"));
4741
if (cur_file_ptr->cur_scope != (scope_t *) NULL)
4742
(void) add_ecoff_symbol ((const char *) NULL,
4750
/* Build the symbolic information. */
4752
buf = xmalloc (PAGE_SIZE);
4753
bufend = buf + PAGE_SIZE;
4755
/* Build the line number information. */
4756
hdr->cbLineOffset = offset;
4757
offset = ecoff_build_lineno (backend, &buf, &bufend, offset,
4759
hdr->cbLine = offset - hdr->cbLineOffset;
4761
/* We don't use dense numbers at all. */
4763
hdr->cbDnOffset = 0;
4765
/* We can't build the PDR table until we have built the symbols,
4766
because a PDR contains a symbol index. However, we set aside
4767
space at this point. */
4768
hdr->ipdMax = proc_cnt;
4769
hdr->cbPdOffset = offset;
4770
if ((bfd_size_type)(bufend - (buf + offset)) < proc_cnt * external_pdr_size)
4771
(void) ecoff_add_bytes (&buf, &bufend, buf + offset,
4772
proc_cnt * external_pdr_size);
4773
offset += proc_cnt * external_pdr_size;
4775
/* Build the local symbols. */
4776
hdr->cbSymOffset = offset;
4777
offset = ecoff_build_symbols (backend, &buf, &bufend, offset);
4778
hdr->isymMax = (offset - hdr->cbSymOffset) / backend->external_sym_size;
4780
/* Building the symbols initializes the symbol index in the PDR's.
4781
Now we can swap out the PDR's. */
4782
(void) ecoff_build_procs (backend, &buf, &bufend, hdr->cbPdOffset);
4784
/* We don't use optimization symbols. */
4786
hdr->cbOptOffset = 0;
4788
/* Swap out the auxiliary type information. */
4789
hdr->cbAuxOffset = offset;
4790
offset = ecoff_build_aux (backend, &buf, &bufend, offset);
4791
hdr->iauxMax = (offset - hdr->cbAuxOffset) / sizeof (union aux_ext);
4793
/* Copy out the local strings. */
4794
hdr->cbSsOffset = offset;
4795
offset = ecoff_build_ss (backend, &buf, &bufend, offset);
4796
hdr->issMax = offset - hdr->cbSsOffset;
4798
/* We don't use relative file descriptors. */
4800
hdr->cbRfdOffset = 0;
4802
/* Swap out the file descriptors. */
4803
hdr->cbFdOffset = offset;
4804
offset = ecoff_build_fdr (backend, &buf, &bufend, offset);
4805
hdr->ifdMax = (offset - hdr->cbFdOffset) / backend->external_fdr_size;
4807
/* Set up the external symbols, which are handled by the BFD back
4810
hdr->cbSsExtOffset = 0;
4812
hdr->cbExtOffset = 0;
4815
know ((offset & (backend->debug_align - 1)) == 0);
4817
/* FIXME: This value should be determined from the .verstamp directive,
4818
with reasonable defaults in config files. */
4820
hdr->vstamp = 0x030b;
4822
hdr->vstamp = 0x020b;
4829
/* Allocate a cluster of pages. */
4831
#ifndef MALLOC_CHECK
4834
allocate_cluster (npages)
4835
unsigned long npages;
4837
register page_type *value = (page_type *) xmalloc (npages * PAGE_USIZE);
4841
fprintf (stderr, "\talloc\tnpages = %d, value = 0x%.8x\n", npages, value);
4844
memset (value, 0, npages * PAGE_USIZE);
4849
static page_type *cluster_ptr = NULL;
4850
static unsigned long pages_left = 0;
4852
#endif /* MALLOC_CHECK */
4854
/* Allocate one page (which is initialized to 0). */
4859
#ifndef MALLOC_CHECK
4861
if (pages_left == 0)
4863
pages_left = MAX_CLUSTER_PAGES;
4864
cluster_ptr = allocate_cluster (pages_left);
4868
return cluster_ptr++;
4870
#else /* MALLOC_CHECK */
4874
ptr = xmalloc (PAGE_USIZE);
4875
memset (ptr, 0, PAGE_USIZE);
4878
#endif /* MALLOC_CHECK */
4881
/* Allocate scoping information. */
4886
register scope_t *ptr;
4887
static scope_t initial_scope;
4889
#ifndef MALLOC_CHECK
4891
ptr = alloc_counts[(int) alloc_type_scope].free_list.f_scope;
4892
if (ptr != (scope_t *) NULL)
4893
alloc_counts[(int) alloc_type_scope].free_list.f_scope = ptr->free;
4896
register int unallocated = alloc_counts[(int) alloc_type_scope].unallocated;
4897
register page_type *cur_page = alloc_counts[(int) alloc_type_scope].cur_page;
4899
if (unallocated == 0)
4901
unallocated = PAGE_SIZE / sizeof (scope_t);
4902
alloc_counts[(int) alloc_type_scope].cur_page = cur_page = allocate_page ();
4903
alloc_counts[(int) alloc_type_scope].total_pages++;
4906
ptr = &cur_page->scope[--unallocated];
4907
alloc_counts[(int) alloc_type_scope].unallocated = unallocated;
4912
ptr = (scope_t *) xmalloc (sizeof (scope_t));
4916
alloc_counts[(int) alloc_type_scope].total_alloc++;
4917
*ptr = initial_scope;
4921
/* Free scoping information. */
4927
alloc_counts[(int) alloc_type_scope].total_free++;
4929
#ifndef MALLOC_CHECK
4930
ptr->free = alloc_counts[(int) alloc_type_scope].free_list.f_scope;
4931
alloc_counts[(int) alloc_type_scope].free_list.f_scope = ptr;
4937
/* Allocate links for pages in a virtual array. */
4942
register vlinks_t *ptr;
4943
static vlinks_t initial_vlinks;
4945
#ifndef MALLOC_CHECK
4947
register int unallocated = alloc_counts[(int) alloc_type_vlinks].unallocated;
4948
register page_type *cur_page = alloc_counts[(int) alloc_type_vlinks].cur_page;
4950
if (unallocated == 0)
4952
unallocated = PAGE_SIZE / sizeof (vlinks_t);
4953
alloc_counts[(int) alloc_type_vlinks].cur_page = cur_page = allocate_page ();
4954
alloc_counts[(int) alloc_type_vlinks].total_pages++;
4957
ptr = &cur_page->vlinks[--unallocated];
4958
alloc_counts[(int) alloc_type_vlinks].unallocated = unallocated;
4962
ptr = (vlinks_t *) xmalloc (sizeof (vlinks_t));
4966
alloc_counts[(int) alloc_type_vlinks].total_alloc++;
4967
*ptr = initial_vlinks;
4971
/* Allocate string hash buckets. */
4976
register shash_t *ptr;
4977
static shash_t initial_shash;
4979
#ifndef MALLOC_CHECK
4981
register int unallocated = alloc_counts[(int) alloc_type_shash].unallocated;
4982
register page_type *cur_page = alloc_counts[(int) alloc_type_shash].cur_page;
4984
if (unallocated == 0)
4986
unallocated = PAGE_SIZE / sizeof (shash_t);
4987
alloc_counts[(int) alloc_type_shash].cur_page = cur_page = allocate_page ();
4988
alloc_counts[(int) alloc_type_shash].total_pages++;
4991
ptr = &cur_page->shash[--unallocated];
4992
alloc_counts[(int) alloc_type_shash].unallocated = unallocated;
4996
ptr = (shash_t *) xmalloc (sizeof (shash_t));
5000
alloc_counts[(int) alloc_type_shash].total_alloc++;
5001
*ptr = initial_shash;
5005
/* Allocate type hash buckets. */
5010
register thash_t *ptr;
5011
static thash_t initial_thash;
5013
#ifndef MALLOC_CHECK
5015
register int unallocated = alloc_counts[(int) alloc_type_thash].unallocated;
5016
register page_type *cur_page = alloc_counts[(int) alloc_type_thash].cur_page;
5018
if (unallocated == 0)
5020
unallocated = PAGE_SIZE / sizeof (thash_t);
5021
alloc_counts[(int) alloc_type_thash].cur_page = cur_page = allocate_page ();
5022
alloc_counts[(int) alloc_type_thash].total_pages++;
5025
ptr = &cur_page->thash[--unallocated];
5026
alloc_counts[(int) alloc_type_thash].unallocated = unallocated;
5030
ptr = (thash_t *) xmalloc (sizeof (thash_t));
5034
alloc_counts[(int) alloc_type_thash].total_alloc++;
5035
*ptr = initial_thash;
5039
/* Allocate structure, union, or enum tag information. */
5044
register tag_t *ptr;
5045
static tag_t initial_tag;
5047
#ifndef MALLOC_CHECK
5049
ptr = alloc_counts[(int) alloc_type_tag].free_list.f_tag;
5050
if (ptr != (tag_t *) NULL)
5051
alloc_counts[(int) alloc_type_tag].free_list.f_tag = ptr->free;
5054
register int unallocated = alloc_counts[(int) alloc_type_tag].unallocated;
5055
register page_type *cur_page = alloc_counts[(int) alloc_type_tag].cur_page;
5057
if (unallocated == 0)
5059
unallocated = PAGE_SIZE / sizeof (tag_t);
5060
alloc_counts[(int) alloc_type_tag].cur_page = cur_page = allocate_page ();
5061
alloc_counts[(int) alloc_type_tag].total_pages++;
5064
ptr = &cur_page->tag[--unallocated];
5065
alloc_counts[(int) alloc_type_tag].unallocated = unallocated;
5070
ptr = (tag_t *) xmalloc (sizeof (tag_t));
5074
alloc_counts[(int) alloc_type_tag].total_alloc++;
5079
/* Free scoping information. */
5085
alloc_counts[(int) alloc_type_tag].total_free++;
5087
#ifndef MALLOC_CHECK
5088
ptr->free = alloc_counts[(int) alloc_type_tag].free_list.f_tag;
5089
alloc_counts[(int) alloc_type_tag].free_list.f_tag = ptr;
5095
/* Allocate forward reference to a yet unknown tag. */
5100
register forward_t *ptr;
5101
static forward_t initial_forward;
5103
#ifndef MALLOC_CHECK
5105
register int unallocated = alloc_counts[(int) alloc_type_forward].unallocated;
5106
register page_type *cur_page = alloc_counts[(int) alloc_type_forward].cur_page;
5108
if (unallocated == 0)
5110
unallocated = PAGE_SIZE / sizeof (forward_t);
5111
alloc_counts[(int) alloc_type_forward].cur_page = cur_page = allocate_page ();
5112
alloc_counts[(int) alloc_type_forward].total_pages++;
5115
ptr = &cur_page->forward[--unallocated];
5116
alloc_counts[(int) alloc_type_forward].unallocated = unallocated;
5120
ptr = (forward_t *) xmalloc (sizeof (forward_t));
5124
alloc_counts[(int) alloc_type_forward].total_alloc++;
5125
*ptr = initial_forward;
5129
/* Allocate head of type hash list. */
5134
register thead_t *ptr;
5135
static thead_t initial_thead;
5137
#ifndef MALLOC_CHECK
5139
ptr = alloc_counts[(int) alloc_type_thead].free_list.f_thead;
5140
if (ptr != (thead_t *) NULL)
5141
alloc_counts[(int) alloc_type_thead].free_list.f_thead = ptr->free;
5144
register int unallocated = alloc_counts[(int) alloc_type_thead].unallocated;
5145
register page_type *cur_page = alloc_counts[(int) alloc_type_thead].cur_page;
5147
if (unallocated == 0)
5149
unallocated = PAGE_SIZE / sizeof (thead_t);
5150
alloc_counts[(int) alloc_type_thead].cur_page = cur_page = allocate_page ();
5151
alloc_counts[(int) alloc_type_thead].total_pages++;
5154
ptr = &cur_page->thead[--unallocated];
5155
alloc_counts[(int) alloc_type_thead].unallocated = unallocated;
5160
ptr = (thead_t *) xmalloc (sizeof (thead_t));
5164
alloc_counts[(int) alloc_type_thead].total_alloc++;
5165
*ptr = initial_thead;
5169
/* Free scoping information. */
5175
alloc_counts[(int) alloc_type_thead].total_free++;
5177
#ifndef MALLOC_CHECK
5178
ptr->free = (thead_t *) alloc_counts[(int) alloc_type_thead].free_list.f_thead;
5179
alloc_counts[(int) alloc_type_thead].free_list.f_thead = ptr;
5185
static lineno_list_t *
5186
allocate_lineno_list ()
5188
register lineno_list_t *ptr;
5189
static lineno_list_t initial_lineno_list;
5191
#ifndef MALLOC_CHECK
5193
register int unallocated = alloc_counts[(int) alloc_type_lineno].unallocated;
5194
register page_type *cur_page = alloc_counts[(int) alloc_type_lineno].cur_page;
5196
if (unallocated == 0)
5198
unallocated = PAGE_SIZE / sizeof (lineno_list_t);
5199
alloc_counts[(int) alloc_type_lineno].cur_page = cur_page = allocate_page ();
5200
alloc_counts[(int) alloc_type_lineno].total_pages++;
5203
ptr = &cur_page->lineno[--unallocated];
5204
alloc_counts[(int) alloc_type_lineno].unallocated = unallocated;
5208
ptr = (lineno_list_t *) xmalloc (sizeof (lineno_list_t));
5212
alloc_counts[(int) alloc_type_lineno].total_alloc++;
5213
*ptr = initial_lineno_list;
5218
ecoff_set_gp_prolog_size (sz)
5221
if (cur_proc_ptr == 0)
5224
cur_proc_ptr->pdr.gp_prologue = sz;
5225
if (cur_proc_ptr->pdr.gp_prologue != sz)
5227
as_warn (_("GP prologue size exceeds field size, using 0 instead"));
5228
cur_proc_ptr->pdr.gp_prologue = 0;
5231
cur_proc_ptr->pdr.gp_used = 1;
5235
ecoff_no_current_file ()
5237
return cur_file_ptr == (efdr_t *) NULL;
5241
ecoff_generate_asm_lineno ()
5243
unsigned int lineno;
5245
lineno_list_t *list;
5247
as_where (&filename, &lineno);
5249
if (current_stabs_filename == (char *) NULL
5250
|| strcmp (current_stabs_filename, filename))
5251
add_file (filename, 0, 1);
5253
list = allocate_lineno_list ();
5255
list->next = (lineno_list_t *) NULL;
5256
list->file = cur_file_ptr;
5257
list->proc = cur_proc_ptr;
5258
list->frag = frag_now;
5259
list->paddr = frag_now_fix ();
5260
list->lineno = lineno;
5262
/* We don't want to merge files which have line numbers. */
5263
cur_file_ptr->fdr.fMerge = 0;
5265
/* A .loc directive will sometimes appear before a .ent directive,
5266
which means that cur_proc_ptr will be NULL here. Arrange to
5268
if (cur_proc_ptr == (proc_t *) NULL)
5272
pl = &noproc_lineno;
5273
while (*pl != (lineno_list_t *) NULL)
5280
*last_lineno_ptr = list;
5281
last_lineno_ptr = &list->next;
5288
ecoff_generate_asm_lineno ()
5292
#endif /* ECOFF_DEBUGGING */
added
removed
gas/ecoff.c
