projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Use <= in ecoff_frob_symbol, not <.
[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 /* Frob an ECOFF symbol. A .extern symbol will have a value, but is
3425 not common. Small common symbols go into a special .scommon
3426 section rather than bfd_com_section. */
3427
3428 void
3429 ecoff_frob_symbol (sym)
3430 symbolS *sym;
3431 {
3432 if (sym->ecoff_undefined)
3433 S_SET_SEGMENT (sym, undefined_section);
3434 else if (S_IS_COMMON (sym)
3435 && S_GET_VALUE (sym) > 0
3436 && S_GET_VALUE (sym) <= bfd_get_gp_size (stdoutput))
3437 {
3438 static asection scom_section;
3439 static asymbol scom_symbol;
3440
3441 /* We must construct a fake section similar to bfd_com_section
3442 but with the name .scommon. */
3443 if (scom_section.name == NULL)
3444 {
3445 scom_section = bfd_com_section;
3446 scom_section.name = ".scommon";
3447 scom_section.output_section = &scom_section;
3448 scom_section.symbol = &scom_symbol;
3449 scom_section.symbol_ptr_ptr = &scom_section.symbol;
3450 scom_symbol = *bfd_com_section.symbol;
3451 scom_symbol.name = ".scommon";
3452 scom_symbol.section = &scom_section;
3453 }
3454 S_SET_SEGMENT (sym, &scom_section);
3455 }
3456 }
3457 \f
3458 /* Add bytes to the symbolic information buffer. */
3459
3460 static char *
3461 ecoff_add_bytes (buf, bufend, bufptr, need)
3462 char **buf;
3463 char **bufend;
3464 char *bufptr;
3465 unsigned long need;
3466 {
3467 unsigned long at;
3468 unsigned long want;
3469
3470 at = bufptr - *buf;
3471 need -= *bufend - bufptr;
3472 if (need < PAGE_SIZE)
3473 need = PAGE_SIZE;
3474 want = (*bufend - *buf) + need;
3475 *buf = xrealloc (*buf, want);
3476 *bufend = *buf + want;
3477 return *buf + at;
3478 }
3479
3480 /* Adjust the symbolic information buffer to the alignment required
3481 for the ECOFF target debugging information. */
3482
3483 static unsigned long
3484 ecoff_padding_adjust (backend, buf, bufend, offset, bufptrptr)
3485 const struct ecoff_debug_swap *backend;
3486 char **buf;
3487 char **bufend;
3488 unsigned long offset;
3489 char **bufptrptr;
3490 {
3491 bfd_size_type align;
3492
3493 align = backend->debug_align;
3494 if ((offset & (align - 1)) != 0)
3495 {
3496 unsigned long add;
3497
3498 add = align - (offset & (align - 1));
3499 if (*bufend - (*buf + offset) < add)
3500 (void) ecoff_add_bytes (buf, bufend, *buf + offset, add);
3501 memset (*buf + offset, 0, add);
3502 offset += add;
3503 if (bufptrptr != (char **) NULL)
3504 *bufptrptr = *buf + offset;
3505 }
3506
3507 return offset;
3508 }
3509
3510 /* Build the line number information. */
3511
3512 static unsigned long
3513 ecoff_build_lineno (backend, buf, bufend, offset, linecntptr)
3514 const struct ecoff_debug_swap *backend;
3515 char **buf;
3516 char **bufend;
3517 unsigned long offset;
3518 long *linecntptr;
3519 {
3520 char *bufptr;
3521 register lineno_list_t *l;
3522 lineno_list_t *last;
3523 efdr_t *file;
3524 proc_t *proc;
3525 unsigned long c;
3526 long iline;
3527 long totcount;
3528
3529 if (linecntptr != (long *) NULL)
3530 *linecntptr = 0;
3531
3532 bufptr = *buf + offset;
3533
3534 file = (efdr_t *) NULL;
3535 proc = (proc_t *) NULL;
3536 last = (lineno_list_t *) NULL;
3537 c = offset;
3538 iline = 0;
3539 totcount = 0;
3540 for (l = first_lineno; l != (lineno_list_t *) NULL; l = l->next)
3541 {
3542 long count;
3543 long delta;
3544
3545 /* Get the offset to the memory address of the next line number
3546 (in words). Do this first, so that we can skip ahead to the
3547 next useful line number entry. */
3548 if (l->next == (lineno_list_t *) NULL)
3549 count = 0;
3550 else
3551 {
3552 count = ((l->next->frag->fr_address + l->next->paddr
3553 - (l->frag->fr_address + l->paddr))
3554 >> 2);
3555 if (count <= 0)
3556 {
3557 /* Don't change last, so we still get the right delta. */
3558 continue;
3559 }
3560 }
3561
3562 if (l->file != file || l->proc != proc)
3563 {
3564 if (l->proc != proc && proc != (proc_t *) NULL)
3565 proc->pdr.lnHigh = last->lineno;
3566 if (l->file != file && file != (efdr_t *) NULL)
3567 {
3568 file->fdr.cbLine = c - file->fdr.cbLineOffset;
3569 /* The cline field is ill-documented. This is a guess
3570 at the right value. */
3571 file->fdr.cline = totcount + count;
3572 if (linecntptr != (long *) NULL)
3573 *linecntptr += totcount + count;
3574 totcount = 0;
3575 }
3576
3577 if (l->file != file)
3578 {
3579 file = l->file;
3580 file->fdr.ilineBase = iline;
3581 file->fdr.cbLineOffset = c;
3582 }
3583 if (l->proc != proc)
3584 {
3585 proc = l->proc;
3586 if (proc != (proc_t *) NULL)
3587 {
3588 proc->pdr.lnLow = l->lineno;
3589 proc->pdr.cbLineOffset = c - file->fdr.cbLineOffset;
3590 /* The iline field is ill-documented. This is a
3591 guess at the right value. */
3592 proc->pdr.iline = totcount;
3593 }
3594 }
3595
3596 last = (lineno_list_t *) NULL;
3597 }
3598
3599 totcount += count;
3600
3601 /* Get the offset to this line number. */
3602 if (last == (lineno_list_t *) NULL)
3603 delta = 0;
3604 else
3605 delta = l->lineno - last->lineno;
3606
3607 /* Put in the offset to this line number. */
3608 while (delta != 0)
3609 {
3610 int setcount;
3611
3612 /* 1 is added to each count read. */
3613 --count;
3614 /* We can only adjust the word count by up to 15 words at a
3615 time. */
3616 if (count <= 0x0f)
3617 {
3618 setcount = count;
3619 count = 0;
3620 }
3621 else
3622 {
3623 setcount = 0x0f;
3624 count -= 0x0f;
3625 }
3626 if (delta >= -7 && delta <= 7)
3627 {
3628 if (bufptr >= *bufend)
3629 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1);
3630 *bufptr++ = setcount + (delta << 4);
3631 delta = 0;
3632 ++c;
3633 }
3634 else
3635 {
3636 int set;
3637
3638 if (*bufend - bufptr < 3)
3639 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 3);
3640 *bufptr++ = setcount + (8 << 4);
3641 if (delta < -0x8000)
3642 {
3643 set = -0x8000;
3644 delta += 0x8000;
3645 }
3646 else if (delta > 0x7fff)
3647 {
3648 set = 0x7fff;
3649 delta -= 0x7fff;
3650 }
3651 else
3652 {
3653 set = delta;
3654 delta = 0;
3655 }
3656 *bufptr++ = set >> 8;
3657 *bufptr++ = set & 0xffff;
3658 c += 3;
3659 }
3660 }
3661
3662 /* Finish adjusting the count. */
3663 while (count > 0)
3664 {
3665 if (bufptr >= *bufend)
3666 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1);
3667 /* 1 is added to each count read. */
3668 --count;
3669 if (count > 0x0f)
3670 {
3671 *bufptr++ = 0x0f;
3672 count -= 0x0f;
3673 }
3674 else
3675 {
3676 *bufptr++ = count;
3677 count = 0;
3678 }
3679 ++c;
3680 }
3681
3682 ++iline;
3683 last = l;
3684 }
3685
3686 if (proc != (proc_t *) NULL)
3687 proc->pdr.lnHigh = last->lineno;
3688 if (file != (efdr_t *) NULL)
3689 {
3690 file->fdr.cbLine = c - file->fdr.cbLineOffset;
3691 file->fdr.cline = totcount;
3692 }
3693
3694 if (linecntptr != (long *) NULL)
3695 *linecntptr += totcount;
3696
3697 c = ecoff_padding_adjust (backend, buf, bufend, c, &bufptr);
3698
3699 return c;
3700 }
3701
3702 /* Build and swap out the symbols. */
3703
3704 static unsigned long
3705 ecoff_build_symbols (backend, buf, bufend, offset)
3706 const struct ecoff_debug_swap *backend;
3707 char **buf;
3708 char **bufend;
3709 unsigned long offset;
3710 {
3711 const bfd_size_type external_sym_size = backend->external_sym_size;
3712 void (* const swap_sym_out) PARAMS ((bfd *, const SYMR *, PTR))
3713 = backend->swap_sym_out;
3714 char *sym_out;
3715 long isym;
3716 vlinks_t *file_link;
3717
3718 sym_out = *buf + offset;
3719
3720 isym = 0;
3721
3722 /* The symbols are stored by file. */
3723 for (file_link = file_desc.first;
3724 file_link != (vlinks_t *) NULL;
3725 file_link = file_link->next)
3726 {
3727 int ifilesym;
3728 int fil_cnt;
3729 efdr_t *fil_ptr;
3730 efdr_t *fil_end;
3731
3732 if (file_link->next == (vlinks_t *) NULL)
3733 fil_cnt = file_desc.objects_last_page;
3734 else
3735 fil_cnt = file_desc.objects_per_page;
3736 fil_ptr = file_link->datum->file;
3737 fil_end = fil_ptr + fil_cnt;
3738 for (; fil_ptr < fil_end; fil_ptr++)
3739 {
3740 vlinks_t *sym_link;
3741
3742 fil_ptr->fdr.isymBase = isym;
3743 ifilesym = isym;
3744 for (sym_link = fil_ptr->symbols.first;
3745 sym_link != (vlinks_t *) NULL;
3746 sym_link = sym_link->next)
3747 {
3748 int sym_cnt;
3749 localsym_t *sym_ptr;
3750 localsym_t *sym_end;
3751
3752 if (sym_link->next == (vlinks_t *) NULL)
3753 sym_cnt = fil_ptr->symbols.objects_last_page;
3754 else
3755 sym_cnt = fil_ptr->symbols.objects_per_page;
3756 sym_ptr = sym_link->datum->sym;
3757 sym_end = sym_ptr + sym_cnt;
3758 for (; sym_ptr < sym_end; sym_ptr++)
3759 {
3760 int local;
3761 symbolS *as_sym;
3762 forward_t *f;
3763
3764 know (sym_ptr->file_ptr == fil_ptr);
3765
3766 /* If there is no associated gas symbol, then this
3767 is a pure debugging symbol. We have already
3768 added the name (if any) to fil_ptr->strings.
3769 Otherwise we must decide whether this is an
3770 external or a local symbol (actually, it may be
3771 both if the local provides additional debugging
3772 information for the external). */
3773 local = 1;
3774 as_sym = sym_ptr->as_sym;
3775 if (as_sym != (symbolS *) NULL)
3776 {
3777 symint_t indx;
3778
3779 /* The value of a block start symbol is the
3780 offset from the start of the procedure. For
3781 other symbols we just use the gas value (but
3782 we must offset it by the vma of the section,
3783 just as BFD does, because BFD will not see
3784 this value). */
3785 if (sym_ptr->ecoff_sym.asym.st == (int) st_Block
3786 && sym_ptr->ecoff_sym.asym.sc == (int) sc_Text)
3787 {
3788 symbolS *begin_sym;
3789
3790 know (sym_ptr->proc_ptr != (proc_t *) NULL);
3791 begin_sym = sym_ptr->proc_ptr->sym->as_sym;
3792 if (S_GET_SEGMENT (as_sym)
3793 != S_GET_SEGMENT (begin_sym))
3794 as_warn (".begin/.bend in different segments");
3795 sym_ptr->ecoff_sym.asym.value =
3796 S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym);
3797 }
3798 else
3799 sym_ptr->ecoff_sym.asym.value =
3800 (S_GET_VALUE (as_sym)
3801 + bfd_get_section_vma (stdoutput,
3802 S_GET_SEGMENT (as_sym)));
3803
3804 /* Set st_Proc to st_StaticProc for local
3805 functions. */
3806 if (sym_ptr->ecoff_sym.asym.st == st_Proc
3807 && S_IS_DEFINED (as_sym)
3808 && ! S_IS_EXTERNAL (as_sym))
3809 sym_ptr->ecoff_sym.asym.st = st_StaticProc;
3810
3811 /* Get the type and storage class based on where
3812 the symbol actually wound up. Traditionally,
3813 N_LBRAC and N_RBRAC are *not* relocated. */
3814 indx = sym_ptr->ecoff_sym.asym.index;
3815 if (sym_ptr->ecoff_sym.asym.st == st_Nil
3816 && sym_ptr->ecoff_sym.asym.sc == sc_Nil
3817 && (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym)
3818 || ((ECOFF_UNMARK_STAB (indx) != N_LBRAC)
3819 && (ECOFF_UNMARK_STAB (indx) != N_RBRAC))))
3820 {
3821 segT seg;
3822 const char *segname;
3823 st_t st;
3824 sc_t sc;
3825
3826 seg = S_GET_SEGMENT (as_sym);
3827 segname = segment_name (seg);
3828
3829 if (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym)
3830 && (S_IS_EXTERNAL (as_sym)
3831 || ! S_IS_DEFINED (as_sym)))
3832 st = st_Global;
3833 else if (seg == text_section)
3834 st = st_Label;
3835 else
3836 st = st_Static;
3837
3838 if (! S_IS_DEFINED (as_sym)
3839 || as_sym->ecoff_undefined)
3840 {
3841 if (S_GET_VALUE (as_sym) > 0
3842 && (S_GET_VALUE (as_sym)
3843 <= bfd_get_gp_size (stdoutput)))
3844 sc = sc_SUndefined;
3845 else
3846 sc = sc_Undefined;
3847 }
3848 else if (S_IS_COMMON (as_sym))
3849 {
3850 if (S_GET_VALUE (as_sym) > 0
3851 && (S_GET_VALUE (as_sym)
3852 <= bfd_get_gp_size (stdoutput)))
3853 sc = sc_SCommon;
3854 else
3855 sc = sc_Common;
3856 }
3857 else if (seg == text_section)
3858 sc = sc_Text;
3859 else if (seg == data_section)
3860 sc = sc_Data;
3861 else if (strcmp (segname, ".rdata") == 0
3862 || strcmp (segname, ".rodata") == 0)
3863 sc = sc_RData;
3864 else if (strcmp (segname, ".sdata") == 0)
3865 sc = sc_SData;
3866 else if (seg == bss_section)
3867 sc = sc_Bss;
3868 else if (strcmp (segname, ".sbss") == 0)
3869 sc = sc_SBss;
3870 else if (seg == &bfd_abs_section)
3871 sc = sc_Abs;
3872 else
3873 abort ();
3874
3875 sym_ptr->ecoff_sym.asym.st = (int) st;
3876 sym_ptr->ecoff_sym.asym.sc = (int) sc;
3877 }
3878
3879 /* This is just an external symbol if it is
3880 outside a procedure and it has a type.
3881 FIXME: g++ will generate symbols which have
3882 different names in the debugging information
3883 than the actual symbol. Should we handle
3884 them here? */
3885 if ((S_IS_EXTERNAL (as_sym)
3886 || ! S_IS_DEFINED (as_sym))
3887 && sym_ptr->proc_ptr == (proc_t *) NULL
3888 && sym_ptr->ecoff_sym.asym.st != (int) st_Nil
3889 && ! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym))
3890 local = 0;
3891
3892 /* If an st_end symbol has an associated gas
3893 symbol, then it is a local label created for
3894 a .bend or .end directive. Stabs line
3895 numbers will have \001 in the names. */
3896 if (local
3897 && sym_ptr->ecoff_sym.asym.st != st_End
3898 && strchr (sym_ptr->name, '\001') == 0)
3899 sym_ptr->ecoff_sym.asym.iss =
3900 add_string (&fil_ptr->strings,
3901 fil_ptr->str_hash,
3902 sym_ptr->name,
3903 (shash_t **) NULL);
3904 }
3905
3906 /* We now know the index of this symbol; fill in
3907 locations that have been waiting for that
3908 information. */
3909 if (sym_ptr->begin_ptr != (localsym_t *) NULL)
3910 {
3911 localsym_t *begin_ptr;
3912 st_t begin_type;
3913
3914 know (local);
3915 begin_ptr = sym_ptr->begin_ptr;
3916 know (begin_ptr->sym_index != -1);
3917 sym_ptr->ecoff_sym.asym.index = begin_ptr->sym_index;
3918 if (sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
3919 sym_ptr->ecoff_sym.asym.iss =
3920 begin_ptr->ecoff_sym.asym.iss;
3921
3922 begin_type = begin_ptr->ecoff_sym.asym.st;
3923 if (begin_type == st_File
3924 || begin_type == st_Block)
3925 {
3926 begin_ptr->ecoff_sym.asym.index =
3927 isym - ifilesym + 1;
3928 (*swap_sym_out) (stdoutput,
3929 &begin_ptr->ecoff_sym.asym,
3930 (*buf
3931 + offset
3932 + (begin_ptr->sym_index
3933 * external_sym_size)));
3934 }
3935 else
3936 {
3937 know (begin_ptr->index_ptr != (aux_t *) NULL);
3938 begin_ptr->index_ptr->data.isym =
3939 isym - ifilesym + 1;
3940 }
3941
3942 /* The value of the symbol marking the end of a
3943 procedure is the size of the procedure. The
3944 value of the symbol marking the end of a
3945 block is the offset from the start of the
3946 procedure to the block. */
3947 if (begin_type == st_Proc
3948 || begin_type == st_StaticProc)
3949 {
3950 know (as_sym != (symbolS *) NULL);
3951 know (begin_ptr->as_sym != (symbolS *) NULL);
3952 if (S_GET_SEGMENT (as_sym)
3953 != S_GET_SEGMENT (begin_ptr->as_sym))
3954 as_warn (".begin/.bend in different segments");
3955 sym_ptr->ecoff_sym.asym.value =
3956 (S_GET_VALUE (as_sym)
3957 - S_GET_VALUE (begin_ptr->as_sym));
3958 }
3959 else if (begin_type == st_Block
3960 && sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
3961 {
3962 symbolS *begin_sym;
3963
3964 know (as_sym != (symbolS *) NULL);
3965 know (sym_ptr->proc_ptr != (proc_t *) NULL);
3966 begin_sym = sym_ptr->proc_ptr->sym->as_sym;
3967 if (S_GET_SEGMENT (as_sym)
3968 != S_GET_SEGMENT (begin_sym))
3969 as_warn (".begin/.bend in different segments");
3970 sym_ptr->ecoff_sym.asym.value =
3971 S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym);
3972 }
3973 }
3974
3975 for (f = sym_ptr->forward_ref;
3976 f != (forward_t *) NULL;
3977 f = f->next)
3978 {
3979 know (local);
3980 f->ifd_ptr->data.isym = fil_ptr->file_index;
3981 f->index_ptr->data.rndx.index = isym - ifilesym;
3982 }
3983
3984 if (local)
3985 {
3986 if (*bufend - sym_out < external_sym_size)
3987 sym_out = ecoff_add_bytes (buf, bufend,
3988 sym_out,
3989 external_sym_size);
3990 (*swap_sym_out) (stdoutput, &sym_ptr->ecoff_sym.asym,
3991 sym_out);
3992 sym_out += external_sym_size;
3993
3994 sym_ptr->sym_index = isym;
3995
3996 if (sym_ptr->proc_ptr != (proc_t *) NULL
3997 && sym_ptr->proc_ptr->sym == sym_ptr)
3998 sym_ptr->proc_ptr->pdr.isym = isym - ifilesym;
3999
4000 ++isym;
4001 }
4002
4003 /* Record the local symbol index and file number in
4004 case this is an external symbol. Note that this
4005 destroys the asym.index field. */
4006 if (as_sym != (symbolS *) NULL
4007 && as_sym->ecoff_symbol == sym_ptr)
4008 {
4009 if (sym_ptr->ecoff_sym.asym.st == st_Proc
4010 || sym_ptr->ecoff_sym.asym.st == st_StaticProc)
4011 {
4012 know (local);
4013 sym_ptr->ecoff_sym.asym.index = isym - ifilesym - 1;
4014 }
4015 sym_ptr->ecoff_sym.ifd = fil_ptr->file_index;
4016 }
4017 }
4018 }
4019 fil_ptr->fdr.csym = isym - fil_ptr->fdr.isymBase;
4020 }
4021 }
4022
4023 return offset + isym * external_sym_size;
4024 }
4025
4026 /* Swap out the procedure information. */
4027
4028 static unsigned long
4029 ecoff_build_procs (backend, buf, bufend, offset)
4030 const struct ecoff_debug_swap *backend;
4031 char **buf;
4032 char **bufend;
4033 unsigned long offset;
4034 {
4035 const bfd_size_type external_pdr_size = backend->external_pdr_size;
4036 void (* const swap_pdr_out) PARAMS ((bfd *, const PDR *, PTR))
4037 = backend->swap_pdr_out;
4038 char *pdr_out;
4039 int first_fil;
4040 long iproc;
4041 vlinks_t *file_link;
4042
4043 pdr_out = *buf + offset;
4044
4045 first_fil = 1;
4046 iproc = 0;
4047
4048 /* The procedures are stored by file. */
4049 for (file_link = file_desc.first;
4050 file_link != (vlinks_t *) NULL;
4051 file_link = file_link->next)
4052 {
4053 int fil_cnt;
4054 efdr_t *fil_ptr;
4055 efdr_t *fil_end;
4056
4057 if (file_link->next == (vlinks_t *) NULL)
4058 fil_cnt = file_desc.objects_last_page;
4059 else
4060 fil_cnt = file_desc.objects_per_page;
4061 fil_ptr = file_link->datum->file;
4062 fil_end = fil_ptr + fil_cnt;
4063 for (; fil_ptr < fil_end; fil_ptr++)
4064 {
4065 vlinks_t *proc_link;
4066 int first;
4067
4068 fil_ptr->fdr.ipdFirst = iproc;
4069 first = 1;
4070 for (proc_link = fil_ptr->procs.first;
4071 proc_link != (vlinks_t *) NULL;
4072 proc_link = proc_link->next)
4073 {
4074 int prc_cnt;
4075 proc_t *proc_ptr;
4076 proc_t *proc_end;
4077
4078 if (proc_link->next == (vlinks_t *) NULL)
4079 prc_cnt = fil_ptr->procs.objects_last_page;
4080 else
4081 prc_cnt = fil_ptr->procs.objects_per_page;
4082 proc_ptr = proc_link->datum->proc;
4083 proc_end = proc_ptr + prc_cnt;
4084 for (; proc_ptr < proc_end; proc_ptr++)
4085 {
4086 symbolS *adr_sym;
4087 unsigned long adr;
4088
4089 adr_sym = proc_ptr->sym->as_sym;
4090 adr = (S_GET_VALUE (adr_sym)
4091 + bfd_get_section_vma (stdoutput,
4092 S_GET_SEGMENT (adr_sym)));
4093 if (first)
4094 {
4095 if (first_fil)
4096 first_fil = 0;
4097 else
4098 fil_ptr->fdr.adr = adr;
4099 first = 0;
4100 }
4101 proc_ptr->pdr.adr = adr - fil_ptr->fdr.adr;
4102 if (*bufend - pdr_out < external_pdr_size)
4103 pdr_out = ecoff_add_bytes (buf, bufend,
4104 pdr_out,
4105 external_pdr_size);
4106 (*swap_pdr_out) (stdoutput, &proc_ptr->pdr, pdr_out);
4107 pdr_out += external_pdr_size;
4108 ++iproc;
4109 }
4110 }
4111 fil_ptr->fdr.cpd = iproc - fil_ptr->fdr.ipdFirst;
4112 }
4113 }
4114
4115 return offset + iproc * external_pdr_size;
4116 }
4117
4118 /* Swap out the aux information. */
4119
4120 static unsigned long
4121 ecoff_build_aux (backend, buf, bufend, offset)
4122 const struct ecoff_debug_swap *backend;
4123 char **buf;
4124 char **bufend;
4125 unsigned long offset;
4126 {
4127 int bigendian;
4128 union aux_ext *aux_out;
4129 long iaux;
4130 vlinks_t *file_link;
4131
4132 bigendian = stdoutput->xvec->header_byteorder_big_p;
4133
4134 aux_out = (union aux_ext *) (*buf + offset);
4135
4136 iaux = 0;
4137
4138 /* The aux entries are stored by file. */
4139 for (file_link = file_desc.first;
4140 file_link != (vlinks_t *) NULL;
4141 file_link = file_link->next)
4142 {
4143 int fil_cnt;
4144 efdr_t *fil_ptr;
4145 efdr_t *fil_end;
4146
4147 if (file_link->next == (vlinks_t *) NULL)
4148 fil_cnt = file_desc.objects_last_page;
4149 else
4150 fil_cnt = file_desc.objects_per_page;
4151 fil_ptr = file_link->datum->file;
4152 fil_end = fil_ptr + fil_cnt;
4153 for (; fil_ptr < fil_end; fil_ptr++)
4154 {
4155 vlinks_t *aux_link;
4156
4157 fil_ptr->fdr.fBigendian = bigendian;
4158 fil_ptr->fdr.iauxBase = iaux;
4159 for (aux_link = fil_ptr->aux_syms.first;
4160 aux_link != (vlinks_t *) NULL;
4161 aux_link = aux_link->next)
4162 {
4163 int aux_cnt;
4164 aux_t *aux_ptr;
4165 aux_t *aux_end;
4166
4167 if (aux_link->next == (vlinks_t *) NULL)
4168 aux_cnt = fil_ptr->aux_syms.objects_last_page;
4169 else
4170 aux_cnt = fil_ptr->aux_syms.objects_per_page;
4171 aux_ptr = aux_link->datum->aux;
4172 aux_end = aux_ptr + aux_cnt;
4173 for (; aux_ptr < aux_end; aux_ptr++)
4174 {
4175 if (*bufend - (char *) aux_out < sizeof (union aux_ext))
4176 aux_out = ((union aux_ext *)
4177 ecoff_add_bytes (buf, bufend,
4178 (char *) aux_out,
4179 sizeof (union aux_ext)));
4180 switch (aux_ptr->type)
4181 {
4182 case aux_tir:
4183 ecoff_swap_tir_out (bigendian, &aux_ptr->data.ti,
4184 &aux_out->a_ti);
4185 break;
4186 case aux_rndx:
4187 ecoff_swap_rndx_out (bigendian, &aux_ptr->data.rndx,
4188 &aux_out->a_rndx);
4189 break;
4190 case aux_dnLow:
4191 AUX_PUT_DNLOW (bigendian, aux_ptr->data.dnLow,
4192 aux_out);
4193 break;
4194 case aux_dnHigh:
4195 AUX_PUT_DNHIGH (bigendian, aux_ptr->data.dnHigh,
4196 aux_out);
4197 break;
4198 case aux_isym:
4199 AUX_PUT_ISYM (bigendian, aux_ptr->data.isym,
4200 aux_out);
4201 break;
4202 case aux_iss:
4203 AUX_PUT_ISS (bigendian, aux_ptr->data.iss,
4204 aux_out);
4205 break;
4206 case aux_width:
4207 AUX_PUT_WIDTH (bigendian, aux_ptr->data.width,
4208 aux_out);
4209 break;
4210 case aux_count:
4211 AUX_PUT_COUNT (bigendian, aux_ptr->data.count,
4212 aux_out);
4213 break;
4214 }
4215
4216 ++aux_out;
4217 ++iaux;
4218 }
4219 }
4220 fil_ptr->fdr.caux = iaux - fil_ptr->fdr.iauxBase;
4221 }
4222 }
4223
4224 return ecoff_padding_adjust (backend, buf, bufend,
4225 offset + iaux * sizeof (union aux_ext),
4226 (char **) NULL);
4227 }
4228
4229 /* Copy out the strings from a varray_t. This returns the number of
4230 bytes copied, rather than the new offset. */
4231
4232 static unsigned long
4233 ecoff_build_strings (buf, bufend, offset, vp)
4234 char **buf;
4235 char **bufend;
4236 unsigned long offset;
4237 varray_t *vp;
4238 {
4239 unsigned long istr;
4240 char *str_out;
4241 vlinks_t *str_link;
4242
4243 str_out = *buf + offset;
4244
4245 istr = 0;
4246
4247 for (str_link = vp->first;
4248 str_link != (vlinks_t *) NULL;
4249 str_link = str_link->next)
4250 {
4251 unsigned long str_cnt;
4252
4253 if (str_link->next == (vlinks_t *) NULL)
4254 str_cnt = vp->objects_last_page;
4255 else
4256 str_cnt = vp->objects_per_page;
4257
4258 if (*bufend - str_out < str_cnt)
4259 str_out = ecoff_add_bytes (buf, bufend, str_out, str_cnt);
4260
4261 memcpy (str_out, str_link->datum->byte, str_cnt);
4262 str_out += str_cnt;
4263 istr += str_cnt;
4264 }
4265
4266 return istr;
4267 }
4268
4269 /* Dump out the local strings. */
4270
4271 static unsigned long
4272 ecoff_build_ss (backend, buf, bufend, offset)
4273 const struct ecoff_debug_swap *backend;
4274 char **buf;
4275 char **bufend;
4276 unsigned long offset;
4277 {
4278 long iss;
4279 vlinks_t *file_link;
4280
4281 iss = 0;
4282
4283 for (file_link = file_desc.first;
4284 file_link != (vlinks_t *) NULL;
4285 file_link = file_link->next)
4286 {
4287 int fil_cnt;
4288 efdr_t *fil_ptr;
4289 efdr_t *fil_end;
4290
4291 if (file_link->next == (vlinks_t *) NULL)
4292 fil_cnt = file_desc.objects_last_page;
4293 else
4294 fil_cnt = file_desc.objects_per_page;
4295 fil_ptr = file_link->datum->file;
4296 fil_end = fil_ptr + fil_cnt;
4297 for (; fil_ptr < fil_end; fil_ptr++)
4298 {
4299 long ss_cnt;
4300
4301 fil_ptr->fdr.issBase = iss;
4302 ss_cnt = ecoff_build_strings (buf, bufend, offset + iss,
4303 &fil_ptr->strings);
4304 fil_ptr->fdr.cbSs = ss_cnt;
4305 iss += ss_cnt;
4306 }
4307 }
4308
4309 return ecoff_padding_adjust (backend, buf, bufend, offset + iss,
4310 (char **) NULL);
4311 }
4312
4313 /* Swap out the file descriptors. */
4314
4315 static unsigned long
4316 ecoff_build_fdr (backend, buf, bufend, offset)
4317 const struct ecoff_debug_swap *backend;
4318 char **buf;
4319 char **bufend;
4320 unsigned long offset;
4321 {
4322 const bfd_size_type external_fdr_size = backend->external_fdr_size;
4323 void (* const swap_fdr_out) PARAMS ((bfd *, const FDR *, PTR))
4324 = backend->swap_fdr_out;
4325 long ifile;
4326 char *fdr_out;
4327 vlinks_t *file_link;
4328
4329 ifile = 0;
4330
4331 fdr_out = *buf + offset;
4332
4333 for (file_link = file_desc.first;
4334 file_link != (vlinks_t *) NULL;
4335 file_link = file_link->next)
4336 {
4337 int fil_cnt;
4338 efdr_t *fil_ptr;
4339 efdr_t *fil_end;
4340
4341 if (file_link->next == (vlinks_t *) NULL)
4342 fil_cnt = file_desc.objects_last_page;
4343 else
4344 fil_cnt = file_desc.objects_per_page;
4345 fil_ptr = file_link->datum->file;
4346 fil_end = fil_ptr + fil_cnt;
4347 for (; fil_ptr < fil_end; fil_ptr++)
4348 {
4349 if (*bufend - fdr_out < external_fdr_size)
4350 fdr_out = ecoff_add_bytes (buf, bufend, fdr_out,
4351 external_fdr_size);
4352 (*swap_fdr_out) (stdoutput, &fil_ptr->fdr, fdr_out);
4353 fdr_out += external_fdr_size;
4354 ++ifile;
4355 }
4356 }
4357
4358 return offset + ifile * external_fdr_size;
4359 }
4360
4361 /* Set up the external symbols. These are supposed to be handled by
4362 the backend. This routine just gets the right information and
4363 calls a backend function to deal with it. */
4364
4365 static void
4366 ecoff_setup_ext ()
4367 {
4368 register symbolS *sym;
4369
4370 for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
4371 {
4372 if (sym->ecoff_symbol == NULL)
4373 continue;
4374
4375 /* If this is a local symbol, then force the fields to zero. */
4376 if (! S_IS_EXTERNAL (sym)
4377 && S_IS_DEFINED (sym))
4378 {
4379 sym->ecoff_symbol->ecoff_sym.asym.value = 0;
4380 sym->ecoff_symbol->ecoff_sym.asym.st = (int) st_Nil;
4381 sym->ecoff_symbol->ecoff_sym.asym.sc = (int) sc_Nil;
4382 sym->ecoff_symbol->ecoff_sym.asym.index = indexNil;
4383 }
4384
4385 obj_ecoff_set_ext (sym, &sym->ecoff_symbol->ecoff_sym);
4386 }
4387 }
4388
4389 /* Build the ECOFF dbeugging information. */
4390
4391 unsigned long
4392 ecoff_build_debug (hdr, bufp, backend)
4393 HDRR *hdr;
4394 char **bufp;
4395 const struct ecoff_debug_swap *backend;
4396 {
4397 const bfd_size_type external_pdr_size = backend->external_pdr_size;
4398 tag_t *ptag;
4399 tag_t *ptag_next;
4400 efdr_t *fil_ptr;
4401 int end_warning;
4402 efdr_t *hold_file_ptr;
4403 proc_t * hold_proc_ptr;
4404 symbolS *sym;
4405 char *buf;
4406 char *bufend;
4407 unsigned long offset;
4408
4409 /* Make sure we have a file. */
4410 if (first_file == (efdr_t *) NULL)
4411 add_file ((const char *) NULL, 0);
4412
4413 /* Handle any top level tags. */
4414 for (ptag = top_tag_head->first_tag;
4415 ptag != (tag_t *) NULL;
4416 ptag = ptag_next)
4417 {
4418 if (ptag->forward_ref != (forward_t *) NULL)
4419 add_unknown_tag (ptag);
4420
4421 ptag_next = ptag->same_block;
4422 ptag->hash_ptr->tag_ptr = ptag->same_name;
4423 free_tag (ptag);
4424 }
4425
4426 free_thead (top_tag_head);
4427
4428 /* Look through the symbols. Add debugging information for each
4429 symbol that has not already received it. */
4430 hold_file_ptr = cur_file_ptr;
4431 hold_proc_ptr = cur_proc_ptr;
4432 cur_proc_ptr = (proc_t *) NULL;
4433 for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
4434 {
4435 if (sym->ecoff_symbol != NULL
4436 || sym->ecoff_file == (efdr_t *) NULL
4437 || (sym->bsym->flags & BSF_SECTION_SYM) != 0)
4438 continue;
4439
4440 cur_file_ptr = sym->ecoff_file;
4441 add_ecoff_symbol ((const char *) NULL, st_Nil, sc_Nil, sym,
4442 S_GET_VALUE (sym), indexNil);
4443 }
4444 cur_proc_ptr = hold_proc_ptr;
4445 cur_file_ptr = hold_file_ptr;
4446
4447 /* Output an ending symbol for all the files. We have to do this
4448 here for the last file, so we may as well do it for all of the
4449 files. */
4450 end_warning = 0;
4451 for (fil_ptr = first_file;
4452 fil_ptr != (efdr_t *) NULL;
4453 fil_ptr = fil_ptr->next_file)
4454 {
4455 cur_file_ptr = fil_ptr;
4456 while (cur_file_ptr->cur_scope->prev != (scope_t *) NULL)
4457 {
4458 cur_file_ptr->cur_scope = cur_file_ptr->cur_scope->prev;
4459 if (! end_warning)
4460 {
4461 as_warn ("Missing .end or .bend at end of file");
4462 end_warning = 1;
4463 }
4464 }
4465 (void) add_ecoff_symbol ((const char *) NULL,
4466 st_End, sc_Text,
4467 (symbolS *) NULL,
4468 (symint_t) 0,
4469 (symint_t) 0);
4470 }
4471
4472 /* Build the symbolic information. */
4473 offset = 0;
4474 buf = xmalloc (PAGE_SIZE);
4475 bufend = buf + PAGE_SIZE;
4476
4477 /* Build the line number information. */
4478 hdr->cbLineOffset = offset;
4479 offset = ecoff_build_lineno (backend, &buf, &bufend, offset,
4480 &hdr->ilineMax);
4481 hdr->cbLine = offset - hdr->cbLineOffset;
4482
4483 /* We don't use dense numbers at all. */
4484 hdr->idnMax = 0;
4485 hdr->cbDnOffset = 0;
4486
4487 /* We can't build the PDR table until we have built the symbols,
4488 because a PDR contains a symbol index. However, we set aside
4489 space at this point. */
4490 hdr->ipdMax = proc_cnt;
4491 hdr->cbPdOffset = offset;
4492 if (bufend - (buf + offset) < proc_cnt * external_pdr_size)
4493 (void) ecoff_add_bytes (&buf, &bufend, buf + offset,
4494 proc_cnt * external_pdr_size);
4495 offset += proc_cnt * external_pdr_size;
4496
4497 /* Build the local symbols. */
4498 hdr->cbSymOffset = offset;
4499 offset = ecoff_build_symbols (backend, &buf, &bufend, offset);
4500 hdr->isymMax = (offset - hdr->cbSymOffset) / backend->external_sym_size;
4501
4502 /* Building the symbols initializes the symbol index in the PDR's.
4503 Now we can swap out the PDR's. */
4504 (void) ecoff_build_procs (backend, &buf, &bufend, hdr->cbPdOffset);
4505
4506 /* We don't use optimization symbols. */
4507 hdr->ioptMax = 0;
4508 hdr->cbOptOffset = 0;
4509
4510 /* Swap out the auxiliary type information. */
4511 hdr->cbAuxOffset = offset;
4512 offset = ecoff_build_aux (backend, &buf, &bufend, offset);
4513 hdr->iauxMax = (offset - hdr->cbAuxOffset) / sizeof (union aux_ext);
4514
4515 /* Copy out the local strings. */
4516 hdr->cbSsOffset = offset;
4517 offset = ecoff_build_ss (backend, &buf, &bufend, offset);
4518 hdr->issMax = offset - hdr->cbSsOffset;
4519
4520 /* We don't use relative file descriptors. */
4521 hdr->crfd = 0;
4522 hdr->cbRfdOffset = 0;
4523
4524 /* Swap out the file descriptors. */
4525 hdr->cbFdOffset = offset;
4526 offset = ecoff_build_fdr (backend, &buf, &bufend, offset);
4527 hdr->ifdMax = (offset - hdr->cbFdOffset) / backend->external_fdr_size;
4528
4529 /* Set up the external symbols, which are handled by the BFD back
4530 end. */
4531 hdr->issExtMax = 0;
4532 hdr->cbSsExtOffset = 0;
4533 hdr->iextMax = 0;
4534 hdr->cbExtOffset = 0;
4535 ecoff_setup_ext ();
4536
4537 know ((offset & (backend->debug_align - 1)) == 0);
4538
4539 hdr->magic = backend->sym_magic;
4540 /* FIXME: what should hdr->vstamp be? */
4541 hdr->vstamp = 0x020b;
4542
4543 *bufp = buf;
4544 return offset;
4545 }
4546 \f
4547 /* Allocate a cluster of pages. */
4548
4549 #ifndef MALLOC_CHECK
4550
4551 static page_t *
4552 allocate_cluster (npages)
4553 unsigned long npages;
4554 {
4555 register page_t *value = (page_t *) xmalloc (npages * PAGE_USIZE);
4556
4557 #ifdef ECOFF_DEBUG
4558 if (debug > 3)
4559 fprintf (stderr, "\talloc\tnpages = %d, value = 0x%.8x\n", npages, value);
4560 #endif
4561
4562 memset (value, 0, npages * PAGE_USIZE);
4563
4564 return value;
4565 }
4566
4567
4568 static page_t *cluster_ptr = NULL;
4569 static unsigned long pages_left = 0;
4570
4571 #endif /* MALLOC_CHECK */
4572
4573 /* Allocate one page (which is initialized to 0). */
4574
4575 static page_t *
4576 allocate_page ()
4577 {
4578 #ifndef MALLOC_CHECK
4579
4580 if (pages_left == 0)
4581 {
4582 pages_left = MAX_CLUSTER_PAGES;
4583 cluster_ptr = allocate_cluster (pages_left);
4584 }
4585
4586 pages_left--;
4587 return cluster_ptr++;
4588
4589 #else /* MALLOC_CHECK */
4590
4591 page_t *ptr;
4592
4593 ptr = xmalloc (PAGE_USIZE);
4594 memset (ptr, 0, PAGE_USIZE);
4595 return ptr;
4596
4597 #endif /* MALLOC_CHECK */
4598 }
4599 \f
4600 /* Allocate scoping information. */
4601
4602 static scope_t *
4603 allocate_scope ()
4604 {
4605 register scope_t *ptr;
4606 static scope_t initial_scope;
4607
4608 #ifndef MALLOC_CHECK
4609
4610 ptr = alloc_counts[(int)alloc_type_scope].free_list.f_scope;
4611 if (ptr != (scope_t *) NULL)
4612 alloc_counts[ (int)alloc_type_scope ].free_list.f_scope = ptr->free;
4613 else
4614 {
4615 register int unallocated = alloc_counts[(int)alloc_type_scope].unallocated;
4616 register page_t *cur_page = alloc_counts[(int)alloc_type_scope].cur_page;
4617
4618 if (unallocated == 0)
4619 {
4620 unallocated = PAGE_SIZE / sizeof (scope_t);
4621 alloc_counts[(int)alloc_type_scope].cur_page = cur_page = allocate_page ();
4622 alloc_counts[(int)alloc_type_scope].total_pages++;
4623 }
4624
4625 ptr = &cur_page->scope[--unallocated];
4626 alloc_counts[(int)alloc_type_scope].unallocated = unallocated;
4627 }
4628
4629 #else
4630
4631 ptr = (scope_t *) xmalloc (sizeof (scope_t));
4632
4633 #endif
4634
4635 alloc_counts[(int)alloc_type_scope].total_alloc++;
4636 *ptr = initial_scope;
4637 return ptr;
4638 }
4639
4640 /* Free scoping information. */
4641
4642 static void
4643 free_scope (ptr)
4644 scope_t *ptr;
4645 {
4646 alloc_counts[(int)alloc_type_scope].total_free++;
4647
4648 #ifndef MALLOC_CHECK
4649 ptr->free = alloc_counts[(int)alloc_type_scope].free_list.f_scope;
4650 alloc_counts[(int)alloc_type_scope].free_list.f_scope = ptr;
4651 #else
4652 free ((PTR) ptr);
4653 #endif
4654 }
4655 \f
4656 /* Allocate links for pages in a virtual array. */
4657
4658 static vlinks_t *
4659 allocate_vlinks ()
4660 {
4661 register vlinks_t *ptr;
4662 static vlinks_t initial_vlinks;
4663
4664 #ifndef MALLOC_CHECK
4665
4666 register int unallocated = alloc_counts[(int)alloc_type_vlinks].unallocated;
4667 register page_t *cur_page = alloc_counts[(int)alloc_type_vlinks].cur_page;
4668
4669 if (unallocated == 0)
4670 {
4671 unallocated = PAGE_SIZE / sizeof (vlinks_t);
4672 alloc_counts[(int)alloc_type_vlinks].cur_page = cur_page = allocate_page ();
4673 alloc_counts[(int)alloc_type_vlinks].total_pages++;
4674 }
4675
4676 ptr = &cur_page->vlinks[--unallocated];
4677 alloc_counts[(int)alloc_type_vlinks].unallocated = unallocated;
4678
4679 #else
4680
4681 ptr = (vlinks_t *) xmalloc (sizeof (vlinks_t));
4682
4683 #endif
4684
4685 alloc_counts[(int)alloc_type_vlinks].total_alloc++;
4686 *ptr = initial_vlinks;
4687 return ptr;
4688 }
4689 \f
4690 /* Allocate string hash buckets. */
4691
4692 static shash_t *
4693 allocate_shash ()
4694 {
4695 register shash_t *ptr;
4696 static shash_t initial_shash;
4697
4698 #ifndef MALLOC_CHECK
4699
4700 register int unallocated = alloc_counts[(int)alloc_type_shash].unallocated;
4701 register page_t *cur_page = alloc_counts[(int)alloc_type_shash].cur_page;
4702
4703 if (unallocated == 0)
4704 {
4705 unallocated = PAGE_SIZE / sizeof (shash_t);
4706 alloc_counts[(int)alloc_type_shash].cur_page = cur_page = allocate_page ();
4707 alloc_counts[(int)alloc_type_shash].total_pages++;
4708 }
4709
4710 ptr = &cur_page->shash[--unallocated];
4711 alloc_counts[(int)alloc_type_shash].unallocated = unallocated;
4712
4713 #else
4714
4715 ptr = (shash_t *) xmalloc (sizeof (shash_t));
4716
4717 #endif
4718
4719 alloc_counts[(int)alloc_type_shash].total_alloc++;
4720 *ptr = initial_shash;
4721 return ptr;
4722 }
4723 \f
4724 /* Allocate type hash buckets. */
4725
4726 static thash_t *
4727 allocate_thash ()
4728 {
4729 register thash_t *ptr;
4730 static thash_t initial_thash;
4731
4732 #ifndef MALLOC_CHECK
4733
4734 register int unallocated = alloc_counts[(int)alloc_type_thash].unallocated;
4735 register page_t *cur_page = alloc_counts[(int)alloc_type_thash].cur_page;
4736
4737 if (unallocated == 0)
4738 {
4739 unallocated = PAGE_SIZE / sizeof (thash_t);
4740 alloc_counts[(int)alloc_type_thash].cur_page = cur_page = allocate_page ();
4741 alloc_counts[(int)alloc_type_thash].total_pages++;
4742 }
4743
4744 ptr = &cur_page->thash[--unallocated];
4745 alloc_counts[(int)alloc_type_thash].unallocated = unallocated;
4746
4747 #else
4748
4749 ptr = (thash_t *) xmalloc (sizeof (thash_t));
4750
4751 #endif
4752
4753 alloc_counts[(int)alloc_type_thash].total_alloc++;
4754 *ptr = initial_thash;
4755 return ptr;
4756 }
4757 \f
4758 /* Allocate structure, union, or enum tag information. */
4759
4760 static tag_t *
4761 allocate_tag ()
4762 {
4763 register tag_t *ptr;
4764 static tag_t initial_tag;
4765
4766 #ifndef MALLOC_CHECK
4767
4768 ptr = alloc_counts[(int)alloc_type_tag].free_list.f_tag;
4769 if (ptr != (tag_t *) NULL)
4770 alloc_counts[(int)alloc_type_tag].free_list.f_tag = ptr->free;
4771 else
4772 {
4773 register int unallocated = alloc_counts[(int)alloc_type_tag].unallocated;
4774 register page_t *cur_page = alloc_counts[(int)alloc_type_tag].cur_page;
4775
4776 if (unallocated == 0)
4777 {
4778 unallocated = PAGE_SIZE / sizeof (tag_t);
4779 alloc_counts[(int)alloc_type_tag].cur_page = cur_page = allocate_page ();
4780 alloc_counts[(int)alloc_type_tag].total_pages++;
4781 }
4782
4783 ptr = &cur_page->tag[--unallocated];
4784 alloc_counts[(int)alloc_type_tag].unallocated = unallocated;
4785 }
4786
4787 #else
4788
4789 ptr = (tag_t *) xmalloc (sizeof (tag_t));
4790
4791 #endif
4792
4793 alloc_counts[(int)alloc_type_tag].total_alloc++;
4794 *ptr = initial_tag;
4795 return ptr;
4796 }
4797
4798 /* Free scoping information. */
4799
4800 static void
4801 free_tag (ptr)
4802 tag_t *ptr;
4803 {
4804 alloc_counts[(int)alloc_type_tag].total_free++;
4805
4806 #ifndef MALLOC_CHECK
4807 ptr->free = alloc_counts[(int)alloc_type_tag].free_list.f_tag;
4808 alloc_counts[(int)alloc_type_tag].free_list.f_tag = ptr;
4809 #else
4810 free ((PTR_T) ptr);
4811 #endif
4812 }
4813 \f
4814 /* Allocate forward reference to a yet unknown tag. */
4815
4816 static forward_t *
4817 allocate_forward ()
4818 {
4819 register forward_t *ptr;
4820 static forward_t initial_forward;
4821
4822 #ifndef MALLOC_CHECK
4823
4824 register int unallocated = alloc_counts[(int)alloc_type_forward].unallocated;
4825 register page_t *cur_page = alloc_counts[(int)alloc_type_forward].cur_page;
4826
4827 if (unallocated == 0)
4828 {
4829 unallocated = PAGE_SIZE / sizeof (forward_t);
4830 alloc_counts[(int)alloc_type_forward].cur_page = cur_page = allocate_page ();
4831 alloc_counts[(int)alloc_type_forward].total_pages++;
4832 }
4833
4834 ptr = &cur_page->forward[--unallocated];
4835 alloc_counts[(int)alloc_type_forward].unallocated = unallocated;
4836
4837 #else
4838
4839 ptr = (forward_t *) xmalloc (sizeof (forward_t));
4840
4841 #endif
4842
4843 alloc_counts[(int)alloc_type_forward].total_alloc++;
4844 *ptr = initial_forward;
4845 return ptr;
4846 }
4847 \f
4848 /* Allocate head of type hash list. */
4849
4850 static thead_t *
4851 allocate_thead ()
4852 {
4853 register thead_t *ptr;
4854 static thead_t initial_thead;
4855
4856 #ifndef MALLOC_CHECK
4857
4858 ptr = alloc_counts[(int)alloc_type_thead].free_list.f_thead;
4859 if (ptr != (thead_t *) NULL)
4860 alloc_counts[ (int)alloc_type_thead ].free_list.f_thead = ptr->free;
4861 else
4862 {
4863 register int unallocated = alloc_counts[(int)alloc_type_thead].unallocated;
4864 register page_t *cur_page = alloc_counts[(int)alloc_type_thead].cur_page;
4865
4866 if (unallocated == 0)
4867 {
4868 unallocated = PAGE_SIZE / sizeof (thead_t);
4869 alloc_counts[(int)alloc_type_thead].cur_page = cur_page = allocate_page ();
4870 alloc_counts[(int)alloc_type_thead].total_pages++;
4871 }
4872
4873 ptr = &cur_page->thead[--unallocated];
4874 alloc_counts[(int)alloc_type_thead].unallocated = unallocated;
4875 }
4876
4877 #else
4878
4879 ptr = (thead_t *) xmalloc (sizeof (thead_t));
4880
4881 #endif
4882
4883 alloc_counts[(int)alloc_type_thead].total_alloc++;
4884 *ptr = initial_thead;
4885 return ptr;
4886 }
4887
4888 /* Free scoping information. */
4889
4890 static void
4891 free_thead (ptr)
4892 thead_t *ptr;
4893 {
4894 alloc_counts[(int)alloc_type_thead].total_free++;
4895
4896 #ifndef MALLOC_CHECK
4897 ptr->free = (thead_t *) alloc_counts[(int)alloc_type_thead].free_list.f_thead;
4898 alloc_counts[(int)alloc_type_thead].free_list.f_thead = ptr;
4899 #else
4900 free ((PTR_T) ptr);
4901 #endif
4902 }
4903 \f
4904 static lineno_list_t *
4905 allocate_lineno_list ()
4906 {
4907 register lineno_list_t *ptr;
4908 static lineno_list_t initial_lineno_list;
4909
4910 #ifndef MALLOC_CHECK
4911
4912 register int unallocated = alloc_counts[(int)alloc_type_lineno].unallocated;
4913 register page_t *cur_page = alloc_counts[(int)alloc_type_lineno].cur_page;
4914
4915 if (unallocated == 0)
4916 {
4917 unallocated = PAGE_SIZE / sizeof (lineno_list_t);
4918 alloc_counts[(int)alloc_type_lineno].cur_page = cur_page = allocate_page ();
4919 alloc_counts[(int)alloc_type_lineno].total_pages++;
4920 }
4921
4922 ptr = &cur_page->lineno[--unallocated];
4923 alloc_counts[(int)alloc_type_lineno].unallocated = unallocated;
4924
4925 #else
4926
4927 ptr = (lineno_list_t *) xmalloc (sizeof (lineno_list_t));
4928
4929 #endif
4930
4931 alloc_counts[(int)alloc_type_lineno].total_alloc++;
4932 *ptr = initial_lineno_list;
4933 return ptr;
4934 }
4935
4936 void
4937 ecoff_set_gp_prolog_size (sz)
4938 int sz;
4939 {
4940 if (cur_proc_ptr == 0)
4941 abort ();
4942
4943 cur_proc_ptr->pdr.gp_prologue = sz;
4944 if (cur_proc_ptr->pdr.gp_prologue != sz)
4945 {
4946 as_warn ("GP prologue size exceeds field size, using 0 instead");
4947 cur_proc_ptr->pdr.gp_prologue = 0;
4948 }
4949
4950 cur_proc_ptr->pdr.gp_used = 1;
4951 }
4952
4953 #endif /* ECOFF_DEBUGGING */
GDB Binutils - Deliverables
This page took 0.131891 seconds and 5 git commands to generate.