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