]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - gas/ecoff.c
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Tue Oct 31 16:34:28 1995 David Mosberger-Tang <davidm@azstarnet.com>
[thirdparty/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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 /* Linked list connecting separate page allocations. */
782 typedef struct vlinks {
783 struct vlinks *prev; /* previous set of pages */
784 struct vlinks *next; /* next set of pages */
785 union page *datum; /* start of page */
786 unsigned long start_index; /* starting index # of page */
787 } vlinks_t;
788
789
790 /* Virtual array header. */
791 typedef struct varray {
792 vlinks_t *first; /* first page link */
793 vlinks_t *last; /* last page link */
794 unsigned long num_allocated; /* # objects allocated */
795 unsigned short object_size; /* size in bytes of each object */
796 unsigned short objects_per_page; /* # objects that can fit on a page */
797 unsigned short objects_last_page; /* # objects allocated on last page */
798 } varray_t;
799
800 #ifndef MALLOC_CHECK
801 #define OBJECTS_PER_PAGE(type) (PAGE_SIZE / sizeof (type))
802 #else
803 #define OBJECTS_PER_PAGE(type) ((sizeof (type) > 1) ? 1 : PAGE_SIZE)
804 #endif
805
806 #define INIT_VARRAY(type) { /* macro to initialize a varray */ \
807 (vlinks_t *)0, /* first */ \
808 (vlinks_t *)0, /* last */ \
809 0, /* num_allocated */ \
810 sizeof (type), /* object_size */ \
811 OBJECTS_PER_PAGE (type), /* objects_per_page */ \
812 OBJECTS_PER_PAGE (type), /* objects_last_page */ \
813 }
814
815
816 /* Master type for indexes within the symbol table. */
817 typedef unsigned long symint_t;
818
819
820 /* Linked list support for nested scopes (file, block, structure, etc.). */
821 typedef struct scope {
822 struct scope *prev; /* previous scope level */
823 struct scope *free; /* free list pointer */
824 struct localsym *lsym; /* pointer to local symbol node */
825 st_t type; /* type of the node */
826 } scope_t;
827
828
829 /* For a local symbol we store a gas symbol as well as the debugging
830 information we generate. The gas symbol will be NULL if this is
831 only a debugging symbol. */
832 typedef struct localsym {
833 const char *name; /* symbol name */
834 symbolS *as_sym; /* symbol as seen by gas */
835 struct efdr *file_ptr; /* file pointer */
836 struct ecoff_proc *proc_ptr; /* proc pointer */
837 struct localsym *begin_ptr; /* symbol at start of block */
838 struct ecoff_aux *index_ptr; /* index value to be filled in */
839 struct forward *forward_ref; /* forward references to this symbol */
840 long sym_index; /* final symbol index */
841 EXTR ecoff_sym; /* ECOFF debugging symbol */
842 } localsym_t;
843
844
845 /* For aux information we keep the type and the data. */
846 typedef struct ecoff_aux {
847 enum aux_type type; /* aux type */
848 AUXU data; /* aux data */
849 } aux_t;
850
851 /* For a procedure we store the gas symbol as well as the PDR
852 debugging information. */
853 typedef struct ecoff_proc {
854 localsym_t *sym; /* associated symbol */
855 PDR pdr; /* ECOFF debugging info */
856 } proc_t;
857
858 /* Number of proc_t structures allocated. */
859 static unsigned long proc_cnt;
860
861
862 /* Forward reference list for tags referenced, but not yet defined. */
863 typedef struct forward {
864 struct forward *next; /* next forward reference */
865 struct forward *free; /* free list pointer */
866 aux_t *ifd_ptr; /* pointer to store file index */
867 aux_t *index_ptr; /* pointer to store symbol index */
868 } forward_t;
869
870
871 /* Linked list support for tags. The first tag in the list is always
872 the current tag for that block. */
873 typedef struct tag {
874 struct tag *free; /* free list pointer */
875 struct shash *hash_ptr; /* pointer to the hash table head */
876 struct tag *same_name; /* tag with same name in outer scope */
877 struct tag *same_block; /* next tag defined in the same block. */
878 struct forward *forward_ref; /* list of forward references */
879 bt_t basic_type; /* bt_Struct, bt_Union, or bt_Enum */
880 symint_t ifd; /* file # tag defined in */
881 localsym_t *sym; /* file's local symbols */
882 } tag_t;
883
884
885 /* Head of a block's linked list of tags. */
886 typedef struct thead {
887 struct thead *prev; /* previous block */
888 struct thead *free; /* free list pointer */
889 struct tag *first_tag; /* first tag in block defined */
890 } thead_t;
891
892
893 /* Union containing pointers to each the small structures which are freed up. */
894 typedef union small_free {
895 scope_t *f_scope; /* scope structure */
896 thead_t *f_thead; /* tag head structure */
897 tag_t *f_tag; /* tag element structure */
898 forward_t *f_forward; /* forward tag reference */
899 } small_free_t;
900
901
902 /* String hash table entry. */
903
904 typedef struct shash {
905 char *string; /* string we are hashing */
906 symint_t indx; /* index within string table */
907 EXTR *esym_ptr; /* global symbol pointer */
908 localsym_t *sym_ptr; /* local symbol pointer */
909 localsym_t *end_ptr; /* symbol pointer to end block */
910 tag_t *tag_ptr; /* tag pointer */
911 proc_t *proc_ptr; /* procedure descriptor pointer */
912 } shash_t;
913
914
915 /* Type hash table support. The size of the hash table must fit
916 within a page with the other extended file descriptor information.
917 Because unique types which are hashed are fewer in number than
918 strings, we use a smaller hash value. */
919
920 #define HASHBITS 30
921
922 #ifndef THASH_SIZE
923 #define THASH_SIZE 113
924 #endif
925
926 typedef struct thash {
927 struct thash *next; /* next hash value */
928 AUXU type; /* type we are hashing */
929 symint_t indx; /* index within string table */
930 } thash_t;
931
932
933 /* Extended file descriptor that contains all of the support necessary
934 to add things to each file separately. */
935 typedef struct efdr {
936 FDR fdr; /* File header to be written out */
937 FDR *orig_fdr; /* original file header */
938 char *name; /* filename */
939 int fake; /* whether this is faked .file */
940 symint_t void_type; /* aux. pointer to 'void' type */
941 symint_t int_type; /* aux. pointer to 'int' type */
942 scope_t *cur_scope; /* current nested scopes */
943 symint_t file_index; /* current file number */
944 int nested_scopes; /* # nested scopes */
945 varray_t strings; /* local strings */
946 varray_t symbols; /* local symbols */
947 varray_t procs; /* procedures */
948 varray_t aux_syms; /* auxiliary symbols */
949 struct efdr *next_file; /* next file descriptor */
950 /* string/type hash tables */
951 struct hash_control *str_hash; /* string hash table */
952 thash_t *thash_head[THASH_SIZE];
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, /* fake: whether this is a faked .file */
992 0, /* void_type: ptr to aux node for void type */
993 0, /* int_type: ptr to aux node for int type */
994 (scope_t *)0, /* cur_scope: current scope being processed */
995 0, /* file_index: current file # */
996 0, /* nested_scopes: # nested scopes */
997 INIT_VARRAY (char), /* strings: local string varray */
998 INIT_VARRAY (localsym_t), /* symbols: local symbols varray */
999 INIT_VARRAY (proc_t), /* procs: procedure varray */
1000 INIT_VARRAY (aux_t), /* aux_syms: auxiliary symbols varray */
1001
1002 (struct efdr *)0, /* next_file: next file structure */
1003
1004 (struct hash_control *)0, /* str_hash: string hash table */
1005 { 0 }, /* thash_head: type hash table */
1006 };
1007
1008
1009 static efdr_t *first_file; /* first file descriptor */
1010 static efdr_t **last_file_ptr = &first_file; /* file descriptor tail */
1011
1012
1013 /* Line number information is kept in a list until the assembly is
1014 finished. */
1015 typedef struct lineno_list {
1016 struct lineno_list *next; /* next element in list */
1017 efdr_t *file; /* file this line is in */
1018 proc_t *proc; /* procedure this line is in */
1019 fragS *frag; /* fragment this line number is in */
1020 unsigned long paddr; /* offset within fragment */
1021 long lineno; /* actual line number */
1022 } lineno_list_t;
1023
1024 static lineno_list_t *first_lineno;
1025 static lineno_list_t **last_lineno_ptr = &first_lineno;
1026
1027 /* Sometimes there will be some .loc statements before a .ent. We
1028 keep them in this list so that we can fill in the procedure pointer
1029 after we see the .ent. */
1030 static lineno_list_t *noproc_lineno;
1031
1032 /* Union of various things that are held in pages. */
1033 typedef union page {
1034 char byte [ PAGE_SIZE ];
1035 unsigned char ubyte [ PAGE_SIZE ];
1036 efdr_t file [ PAGE_SIZE / sizeof (efdr_t) ];
1037 FDR ofile [ PAGE_SIZE / sizeof (FDR) ];
1038 proc_t proc [ PAGE_SIZE / sizeof (proc_t) ];
1039 localsym_t sym [ PAGE_SIZE / sizeof (localsym_t) ];
1040 aux_t aux [ PAGE_SIZE / sizeof (aux_t) ];
1041 DNR dense [ PAGE_SIZE / sizeof (DNR) ];
1042 scope_t scope [ PAGE_SIZE / sizeof (scope_t) ];
1043 vlinks_t vlinks [ PAGE_SIZE / sizeof (vlinks_t) ];
1044 shash_t shash [ PAGE_SIZE / sizeof (shash_t) ];
1045 thash_t thash [ PAGE_SIZE / sizeof (thash_t) ];
1046 tag_t tag [ PAGE_SIZE / sizeof (tag_t) ];
1047 forward_t forward [ PAGE_SIZE / sizeof (forward_t) ];
1048 thead_t thead [ PAGE_SIZE / sizeof (thead_t) ];
1049 lineno_list_t lineno [ PAGE_SIZE / sizeof (lineno_list_t) ];
1050 } page_t;
1051
1052
1053 /* Structure holding allocation information for small sized structures. */
1054 typedef struct alloc_info {
1055 char *alloc_name; /* name of this allocation type (must be first) */
1056 page_t *cur_page; /* current page being allocated from */
1057 small_free_t free_list; /* current free list if any */
1058 int unallocated; /* number of elements unallocated on page */
1059 int total_alloc; /* total number of allocations */
1060 int total_free; /* total number of frees */
1061 int total_pages; /* total number of pages allocated */
1062 } alloc_info_t;
1063
1064
1065 /* Type information collected together. */
1066 typedef struct type_info {
1067 bt_t basic_type; /* basic type */
1068 int orig_type; /* original COFF-based type */
1069 int num_tq; /* # type qualifiers */
1070 int num_dims; /* # dimensions */
1071 int num_sizes; /* # sizes */
1072 int extra_sizes; /* # extra sizes not tied with dims */
1073 tag_t * tag_ptr; /* tag pointer */
1074 int bitfield; /* symbol is a bitfield */
1075 tq_t type_qualifiers[N_TQ]; /* type qualifiers (ptr, func, array)*/
1076 symint_t dimensions [N_TQ]; /* dimensions for each array */
1077 symint_t sizes [N_TQ+2]; /* sizes of each array slice + size of
1078 struct/union/enum + bitfield size */
1079 } type_info_t;
1080
1081 /* Pre-initialized type_info struct. */
1082 static const type_info_t type_info_init = {
1083 bt_Nil, /* basic type */
1084 T_NULL, /* original COFF-based type */
1085 0, /* # type qualifiers */
1086 0, /* # dimensions */
1087 0, /* # sizes */
1088 0, /* sizes not tied with dims */
1089 NULL, /* ptr to tag */
1090 0, /* bitfield */
1091 { /* type qualifiers */
1092 tq_Nil,
1093 tq_Nil,
1094 tq_Nil,
1095 tq_Nil,
1096 tq_Nil,
1097 tq_Nil,
1098 },
1099 { /* dimensions */
1100 0,
1101 0,
1102 0,
1103 0,
1104 0,
1105 0
1106 },
1107 { /* sizes */
1108 0,
1109 0,
1110 0,
1111 0,
1112 0,
1113 0,
1114 0,
1115 0,
1116 },
1117 };
1118
1119 /* Global hash table for the tags table and global table for file
1120 descriptors. */
1121
1122 static varray_t file_desc = INIT_VARRAY (efdr_t);
1123
1124 static struct hash_control *tag_hash;
1125
1126 /* Static types for int and void. Also, remember the last function's
1127 type (which is set up when we encounter the declaration for the
1128 function, and used when the end block for the function is emitted. */
1129
1130 static type_info_t int_type_info;
1131 static type_info_t void_type_info;
1132 static type_info_t last_func_type_info;
1133 static symbolS *last_func_sym_value;
1134
1135
1136 /* Convert COFF basic type to ECOFF basic type. The T_NULL type
1137 really should use bt_Void, but this causes the current ecoff GDB to
1138 issue unsupported type messages, and the Ultrix 4.00 dbx (aka MIPS
1139 2.0) doesn't understand it, even though the compiler generates it.
1140 Maybe this will be fixed in 2.10 or 2.20 of the MIPS compiler
1141 suite, but for now go with what works.
1142
1143 It would make sense for the .type and .scl directives to use the
1144 ECOFF numbers directly, rather than using the COFF numbers and
1145 mapping them. Unfortunately, this is historically what mips-tfile
1146 expects, and changing gcc now would be a considerable pain (the
1147 native compiler generates debugging information internally, rather
1148 than via the assembler, so it will never use .type or .scl). */
1149
1150 static const bt_t map_coff_types[] = {
1151 bt_Nil, /* T_NULL */
1152 bt_Nil, /* T_ARG */
1153 bt_Char, /* T_CHAR */
1154 bt_Short, /* T_SHORT */
1155 bt_Int, /* T_INT */
1156 bt_Long, /* T_LONG */
1157 bt_Float, /* T_FLOAT */
1158 bt_Double, /* T_DOUBLE */
1159 bt_Struct, /* T_STRUCT */
1160 bt_Union, /* T_UNION */
1161 bt_Enum, /* T_ENUM */
1162 bt_Enum, /* T_MOE */
1163 bt_UChar, /* T_UCHAR */
1164 bt_UShort, /* T_USHORT */
1165 bt_UInt, /* T_UINT */
1166 bt_ULong /* T_ULONG */
1167 };
1168
1169 /* Convert COFF storage class to ECOFF storage class. */
1170 static const sc_t map_coff_storage[] = {
1171 sc_Nil, /* 0: C_NULL */
1172 sc_Abs, /* 1: C_AUTO auto var */
1173 sc_Undefined, /* 2: C_EXT external */
1174 sc_Data, /* 3: C_STAT static */
1175 sc_Register, /* 4: C_REG register */
1176 sc_Undefined, /* 5: C_EXTDEF ??? */
1177 sc_Text, /* 6: C_LABEL label */
1178 sc_Text, /* 7: C_ULABEL user label */
1179 sc_Info, /* 8: C_MOS member of struct */
1180 sc_Abs, /* 9: C_ARG argument */
1181 sc_Info, /* 10: C_STRTAG struct tag */
1182 sc_Info, /* 11: C_MOU member of union */
1183 sc_Info, /* 12: C_UNTAG union tag */
1184 sc_Info, /* 13: C_TPDEF typedef */
1185 sc_Data, /* 14: C_USTATIC ??? */
1186 sc_Info, /* 15: C_ENTAG enum tag */
1187 sc_Info, /* 16: C_MOE member of enum */
1188 sc_Register, /* 17: C_REGPARM register parameter */
1189 sc_Bits, /* 18; C_FIELD bitfield */
1190 sc_Nil, /* 19 */
1191 sc_Nil, /* 20 */
1192 sc_Nil, /* 21 */
1193 sc_Nil, /* 22 */
1194 sc_Nil, /* 23 */
1195 sc_Nil, /* 24 */
1196 sc_Nil, /* 25 */
1197 sc_Nil, /* 26 */
1198 sc_Nil, /* 27 */
1199 sc_Nil, /* 28 */
1200 sc_Nil, /* 29 */
1201 sc_Nil, /* 30 */
1202 sc_Nil, /* 31 */
1203 sc_Nil, /* 32 */
1204 sc_Nil, /* 33 */
1205 sc_Nil, /* 34 */
1206 sc_Nil, /* 35 */
1207 sc_Nil, /* 36 */
1208 sc_Nil, /* 37 */
1209 sc_Nil, /* 38 */
1210 sc_Nil, /* 39 */
1211 sc_Nil, /* 40 */
1212 sc_Nil, /* 41 */
1213 sc_Nil, /* 42 */
1214 sc_Nil, /* 43 */
1215 sc_Nil, /* 44 */
1216 sc_Nil, /* 45 */
1217 sc_Nil, /* 46 */
1218 sc_Nil, /* 47 */
1219 sc_Nil, /* 48 */
1220 sc_Nil, /* 49 */
1221 sc_Nil, /* 50 */
1222 sc_Nil, /* 51 */
1223 sc_Nil, /* 52 */
1224 sc_Nil, /* 53 */
1225 sc_Nil, /* 54 */
1226 sc_Nil, /* 55 */
1227 sc_Nil, /* 56 */
1228 sc_Nil, /* 57 */
1229 sc_Nil, /* 58 */
1230 sc_Nil, /* 59 */
1231 sc_Nil, /* 60 */
1232 sc_Nil, /* 61 */
1233 sc_Nil, /* 62 */
1234 sc_Nil, /* 63 */
1235 sc_Nil, /* 64 */
1236 sc_Nil, /* 65 */
1237 sc_Nil, /* 66 */
1238 sc_Nil, /* 67 */
1239 sc_Nil, /* 68 */
1240 sc_Nil, /* 69 */
1241 sc_Nil, /* 70 */
1242 sc_Nil, /* 71 */
1243 sc_Nil, /* 72 */
1244 sc_Nil, /* 73 */
1245 sc_Nil, /* 74 */
1246 sc_Nil, /* 75 */
1247 sc_Nil, /* 76 */
1248 sc_Nil, /* 77 */
1249 sc_Nil, /* 78 */
1250 sc_Nil, /* 79 */
1251 sc_Nil, /* 80 */
1252 sc_Nil, /* 81 */
1253 sc_Nil, /* 82 */
1254 sc_Nil, /* 83 */
1255 sc_Nil, /* 84 */
1256 sc_Nil, /* 85 */
1257 sc_Nil, /* 86 */
1258 sc_Nil, /* 87 */
1259 sc_Nil, /* 88 */
1260 sc_Nil, /* 89 */
1261 sc_Nil, /* 90 */
1262 sc_Nil, /* 91 */
1263 sc_Nil, /* 92 */
1264 sc_Nil, /* 93 */
1265 sc_Nil, /* 94 */
1266 sc_Nil, /* 95 */
1267 sc_Nil, /* 96 */
1268 sc_Nil, /* 97 */
1269 sc_Nil, /* 98 */
1270 sc_Nil, /* 99 */
1271 sc_Text, /* 100: C_BLOCK block start/end */
1272 sc_Text, /* 101: C_FCN function start/end */
1273 sc_Info, /* 102: C_EOS end of struct/union/enum */
1274 sc_Nil, /* 103: C_FILE file start */
1275 sc_Nil, /* 104: C_LINE line number */
1276 sc_Nil, /* 105: C_ALIAS combined type info */
1277 sc_Nil, /* 106: C_HIDDEN ??? */
1278 };
1279
1280 /* Convert COFF storage class to ECOFF symbol type. */
1281 static const st_t map_coff_sym_type[] = {
1282 st_Nil, /* 0: C_NULL */
1283 st_Local, /* 1: C_AUTO auto var */
1284 st_Global, /* 2: C_EXT external */
1285 st_Static, /* 3: C_STAT static */
1286 st_Local, /* 4: C_REG register */
1287 st_Global, /* 5: C_EXTDEF ??? */
1288 st_Label, /* 6: C_LABEL label */
1289 st_Label, /* 7: C_ULABEL user label */
1290 st_Member, /* 8: C_MOS member of struct */
1291 st_Param, /* 9: C_ARG argument */
1292 st_Block, /* 10: C_STRTAG struct tag */
1293 st_Member, /* 11: C_MOU member of union */
1294 st_Block, /* 12: C_UNTAG union tag */
1295 st_Typedef, /* 13: C_TPDEF typedef */
1296 st_Static, /* 14: C_USTATIC ??? */
1297 st_Block, /* 15: C_ENTAG enum tag */
1298 st_Member, /* 16: C_MOE member of enum */
1299 st_Param, /* 17: C_REGPARM register parameter */
1300 st_Member, /* 18; C_FIELD bitfield */
1301 st_Nil, /* 19 */
1302 st_Nil, /* 20 */
1303 st_Nil, /* 21 */
1304 st_Nil, /* 22 */
1305 st_Nil, /* 23 */
1306 st_Nil, /* 24 */
1307 st_Nil, /* 25 */
1308 st_Nil, /* 26 */
1309 st_Nil, /* 27 */
1310 st_Nil, /* 28 */
1311 st_Nil, /* 29 */
1312 st_Nil, /* 30 */
1313 st_Nil, /* 31 */
1314 st_Nil, /* 32 */
1315 st_Nil, /* 33 */
1316 st_Nil, /* 34 */
1317 st_Nil, /* 35 */
1318 st_Nil, /* 36 */
1319 st_Nil, /* 37 */
1320 st_Nil, /* 38 */
1321 st_Nil, /* 39 */
1322 st_Nil, /* 40 */
1323 st_Nil, /* 41 */
1324 st_Nil, /* 42 */
1325 st_Nil, /* 43 */
1326 st_Nil, /* 44 */
1327 st_Nil, /* 45 */
1328 st_Nil, /* 46 */
1329 st_Nil, /* 47 */
1330 st_Nil, /* 48 */
1331 st_Nil, /* 49 */
1332 st_Nil, /* 50 */
1333 st_Nil, /* 51 */
1334 st_Nil, /* 52 */
1335 st_Nil, /* 53 */
1336 st_Nil, /* 54 */
1337 st_Nil, /* 55 */
1338 st_Nil, /* 56 */
1339 st_Nil, /* 57 */
1340 st_Nil, /* 58 */
1341 st_Nil, /* 59 */
1342 st_Nil, /* 60 */
1343 st_Nil, /* 61 */
1344 st_Nil, /* 62 */
1345 st_Nil, /* 63 */
1346 st_Nil, /* 64 */
1347 st_Nil, /* 65 */
1348 st_Nil, /* 66 */
1349 st_Nil, /* 67 */
1350 st_Nil, /* 68 */
1351 st_Nil, /* 69 */
1352 st_Nil, /* 70 */
1353 st_Nil, /* 71 */
1354 st_Nil, /* 72 */
1355 st_Nil, /* 73 */
1356 st_Nil, /* 74 */
1357 st_Nil, /* 75 */
1358 st_Nil, /* 76 */
1359 st_Nil, /* 77 */
1360 st_Nil, /* 78 */
1361 st_Nil, /* 79 */
1362 st_Nil, /* 80 */
1363 st_Nil, /* 81 */
1364 st_Nil, /* 82 */
1365 st_Nil, /* 83 */
1366 st_Nil, /* 84 */
1367 st_Nil, /* 85 */
1368 st_Nil, /* 86 */
1369 st_Nil, /* 87 */
1370 st_Nil, /* 88 */
1371 st_Nil, /* 89 */
1372 st_Nil, /* 90 */
1373 st_Nil, /* 91 */
1374 st_Nil, /* 92 */
1375 st_Nil, /* 93 */
1376 st_Nil, /* 94 */
1377 st_Nil, /* 95 */
1378 st_Nil, /* 96 */
1379 st_Nil, /* 97 */
1380 st_Nil, /* 98 */
1381 st_Nil, /* 99 */
1382 st_Block, /* 100: C_BLOCK block start/end */
1383 st_Proc, /* 101: C_FCN function start/end */
1384 st_End, /* 102: C_EOS end of struct/union/enum */
1385 st_File, /* 103: C_FILE file start */
1386 st_Nil, /* 104: C_LINE line number */
1387 st_Nil, /* 105: C_ALIAS combined type info */
1388 st_Nil, /* 106: C_HIDDEN ??? */
1389 };
1390
1391
1392 /* Keep track of different sized allocation requests. */
1393 static alloc_info_t alloc_counts[ (int)alloc_type_last ];
1394 \f
1395 /* Record whether we have seen any debugging information. */
1396 int ecoff_debugging_seen = 0;
1397
1398 /* Various statics. */
1399 static efdr_t *cur_file_ptr = (efdr_t *) 0; /* current file desc. header */
1400 static proc_t *cur_proc_ptr = (proc_t *) 0; /* current procedure header */
1401 static proc_t *first_proc_ptr = (proc_t *) 0; /* first procedure header */
1402 static thead_t *top_tag_head = (thead_t *) 0; /* top level tag head */
1403 static thead_t *cur_tag_head = (thead_t *) 0; /* current tag head */
1404 #ifdef ECOFF_DEBUG
1405 static int debug = 0; /* trace functions */
1406 #endif
1407 static int stabs_seen = 0; /* != 0 if stabs have been seen */
1408
1409 static int current_file_idx;
1410 static const char *current_stabs_filename;
1411
1412 /* Pseudo symbol to use when putting stabs into the symbol table. */
1413 #ifndef STABS_SYMBOL
1414 #define STABS_SYMBOL "@stabs"
1415 #endif
1416
1417 static char stabs_symbol[] = STABS_SYMBOL;
1418 \f
1419 /* Prototypes for functions defined in this file. */
1420
1421 static void add_varray_page PARAMS ((varray_t *vp));
1422 static symint_t add_string PARAMS ((varray_t *vp,
1423 struct hash_control *hash_tbl,
1424 const char *str,
1425 shash_t **ret_hash));
1426 static localsym_t *add_ecoff_symbol PARAMS ((const char *str, st_t type,
1427 sc_t storage, symbolS *sym,
1428 symint_t value,
1429 symint_t indx));
1430 static symint_t add_aux_sym_symint PARAMS ((symint_t aux_word));
1431 static symint_t add_aux_sym_rndx PARAMS ((int file_index,
1432 symint_t sym_index));
1433 static symint_t add_aux_sym_tir PARAMS ((type_info_t *t,
1434 hash_state_t state,
1435 thash_t **hash_tbl));
1436 static tag_t *get_tag PARAMS ((const char *tag, localsym_t *sym,
1437 bt_t basic_type));
1438 static void add_unknown_tag PARAMS ((tag_t *ptag));
1439 static void add_procedure PARAMS ((char *func));
1440 static void add_file PARAMS ((const char *file_name, int indx, int fake));
1441 #ifdef ECOFF_DEBUG
1442 static char *sc_to_string PARAMS ((sc_t storage_class));
1443 static char *st_to_string PARAMS ((st_t symbol_type));
1444 #endif
1445 static void mark_stabs PARAMS ((int));
1446 static char *ecoff_add_bytes PARAMS ((char **buf, char **bufend,
1447 char *bufptr, unsigned long need));
1448 static unsigned long ecoff_padding_adjust
1449 PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1450 unsigned long offset, char **bufptrptr));
1451 static unsigned long ecoff_build_lineno
1452 PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1453 unsigned long offset, long *linecntptr));
1454 static unsigned long ecoff_build_symbols
1455 PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1456 unsigned long offset));
1457 static unsigned long ecoff_build_procs
1458 PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1459 unsigned long offset));
1460 static unsigned long ecoff_build_aux
1461 PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1462 unsigned long offset));
1463 static unsigned long ecoff_build_strings PARAMS ((char **buf, char **bufend,
1464 unsigned long offset,
1465 varray_t *vp));
1466 static unsigned long ecoff_build_ss
1467 PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1468 unsigned long offset));
1469 static unsigned long ecoff_build_fdr
1470 PARAMS ((const struct ecoff_debug_swap *backend, char **buf, char **bufend,
1471 unsigned long offset));
1472 static void ecoff_setup_ext PARAMS ((void));
1473 static page_t *allocate_cluster PARAMS ((unsigned long npages));
1474 static page_t *allocate_page PARAMS ((void));
1475 static scope_t *allocate_scope PARAMS ((void));
1476 static void free_scope PARAMS ((scope_t *ptr));
1477 static vlinks_t *allocate_vlinks PARAMS ((void));
1478 static shash_t *allocate_shash PARAMS ((void));
1479 static thash_t *allocate_thash PARAMS ((void));
1480 static tag_t *allocate_tag PARAMS ((void));
1481 static void free_tag PARAMS ((tag_t *ptr));
1482 static forward_t *allocate_forward PARAMS ((void));
1483 static thead_t *allocate_thead PARAMS ((void));
1484 static void free_thead PARAMS ((thead_t *ptr));
1485 static lineno_list_t *allocate_lineno_list PARAMS ((void));
1486 static void generate_ecoff_stab PARAMS ((int, const char *, int, int, int));
1487 \f
1488 /* This function should be called when the assembler starts up. */
1489
1490 void
1491 ecoff_read_begin_hook ()
1492 {
1493 tag_hash = hash_new ();
1494 top_tag_head = allocate_thead ();
1495 top_tag_head->first_tag = (tag_t *) NULL;
1496 top_tag_head->free = (thead_t *) NULL;
1497 top_tag_head->prev = cur_tag_head;
1498 cur_tag_head = top_tag_head;
1499 }
1500
1501 /* This function should be called when a symbol is created. */
1502
1503 void
1504 ecoff_symbol_new_hook (symbolP)
1505 symbolS *symbolP;
1506 {
1507 /* Make sure that we have a file pointer, but only if we have seen a
1508 file. If we haven't seen a file, then this is a probably special
1509 symbol created by md_begin which may required special handling at
1510 some point. Creating a dummy file with a dummy name is certainly
1511 wrong. */
1512 if (cur_file_ptr == (efdr_t *) NULL
1513 && seen_at_least_1_file ())
1514 add_file ((const char *) NULL, 0, 1);
1515 symbolP->ecoff_file = cur_file_ptr;
1516 symbolP->ecoff_symbol = NULL;
1517 symbolP->ecoff_extern_size = 0;
1518 }
1519 \f
1520 /* Add a page to a varray object. */
1521
1522 static void
1523 add_varray_page (vp)
1524 varray_t *vp; /* varray to add page to */
1525 {
1526 vlinks_t *new_links = allocate_vlinks ();
1527
1528 #ifdef MALLOC_CHECK
1529 if (vp->object_size > 1)
1530 new_links->datum = (page_t *) xcalloc (1, vp->object_size);
1531 else
1532 #endif
1533 new_links->datum = allocate_page ();
1534
1535 alloc_counts[(int)alloc_type_varray].total_alloc++;
1536 alloc_counts[(int)alloc_type_varray].total_pages++;
1537
1538 new_links->start_index = vp->num_allocated;
1539 vp->objects_last_page = 0;
1540
1541 if (vp->first == (vlinks_t *) NULL) /* first allocation? */
1542 vp->first = vp->last = new_links;
1543 else
1544 { /* 2nd or greater allocation */
1545 new_links->prev = vp->last;
1546 vp->last->next = new_links;
1547 vp->last = new_links;
1548 }
1549 }
1550 \f
1551 /* Add a string (and null pad) to one of the string tables. */
1552
1553 static symint_t
1554 add_string (vp, hash_tbl, str, ret_hash)
1555 varray_t *vp; /* string obstack */
1556 struct hash_control *hash_tbl; /* ptr to hash table */
1557 const char *str; /* string */
1558 shash_t **ret_hash; /* return hash pointer */
1559 {
1560 register unsigned long len = strlen (str);
1561 register shash_t *hash_ptr;
1562
1563 if (len >= PAGE_USIZE)
1564 as_fatal ("String too big (%lu bytes)", len);
1565
1566 hash_ptr = (shash_t *) hash_find (hash_tbl, str);
1567 if (hash_ptr == (shash_t *) NULL)
1568 {
1569 register const char *err;
1570
1571 if (vp->objects_last_page + len >= PAGE_USIZE)
1572 {
1573 vp->num_allocated =
1574 ((vp->num_allocated + PAGE_USIZE - 1) / PAGE_USIZE) * PAGE_USIZE;
1575 add_varray_page (vp);
1576 }
1577
1578 hash_ptr = allocate_shash ();
1579 hash_ptr->indx = vp->num_allocated;
1580
1581 hash_ptr->string = &vp->last->datum->byte[vp->objects_last_page];
1582
1583 vp->objects_last_page += len + 1;
1584 vp->num_allocated += len + 1;
1585
1586 strcpy (hash_ptr->string, str);
1587
1588 err = hash_insert (hash_tbl, str, (char *) hash_ptr);
1589 if (err)
1590 as_fatal ("Inserting \"%s\" into string hash table: %s",
1591 str, err);
1592 }
1593
1594 if (ret_hash != (shash_t **) NULL)
1595 *ret_hash = hash_ptr;
1596
1597 return hash_ptr->indx;
1598 }
1599 \f
1600 /* Add debugging information for a symbol. */
1601
1602 static localsym_t *
1603 add_ecoff_symbol (str, type, storage, sym_value, value, indx)
1604 const char *str; /* symbol name */
1605 st_t type; /* symbol type */
1606 sc_t storage; /* storage class */
1607 symbolS *sym_value; /* associated symbol. */
1608 symint_t value; /* value of symbol */
1609 symint_t indx; /* index to local/aux. syms */
1610 {
1611 localsym_t *psym;
1612 register scope_t *pscope;
1613 register thead_t *ptag_head;
1614 register tag_t *ptag;
1615 register tag_t *ptag_next;
1616 register varray_t *vp;
1617 register int scope_delta = 0;
1618 shash_t *hash_ptr = (shash_t *) NULL;
1619
1620 if (cur_file_ptr == (efdr_t *) NULL)
1621 as_fatal ("no current file pointer");
1622
1623 vp = &cur_file_ptr->symbols;
1624
1625 if (vp->objects_last_page == vp->objects_per_page)
1626 add_varray_page (vp);
1627
1628 psym = &vp->last->datum->sym[ vp->objects_last_page++ ];
1629
1630 if (str == (const char *) NULL && sym_value != (symbolS *) NULL)
1631 psym->name = S_GET_NAME (sym_value);
1632 else
1633 psym->name = str;
1634 psym->as_sym = sym_value;
1635 if (sym_value != (symbolS *) NULL)
1636 sym_value->ecoff_symbol = psym;
1637 psym->file_ptr = cur_file_ptr;
1638 psym->proc_ptr = cur_proc_ptr;
1639 psym->begin_ptr = (localsym_t *) NULL;
1640 psym->index_ptr = (aux_t *) NULL;
1641 psym->forward_ref = (forward_t *) NULL;
1642 psym->sym_index = -1;
1643 memset (&psym->ecoff_sym, 0, sizeof (EXTR));
1644 psym->ecoff_sym.asym.value = value;
1645 psym->ecoff_sym.asym.st = (unsigned) type;
1646 psym->ecoff_sym.asym.sc = (unsigned) storage;
1647 psym->ecoff_sym.asym.index = indx;
1648
1649 /* If there is an associated symbol, we wait until the end of the
1650 assembly before deciding where to put the name (it may be just an
1651 external symbol). Otherwise, this is just a debugging symbol and
1652 the name should go with the current file. */
1653 if (sym_value == (symbolS *) NULL)
1654 psym->ecoff_sym.asym.iss = ((str == (const char *) NULL)
1655 ? 0
1656 : add_string (&cur_file_ptr->strings,
1657 cur_file_ptr->str_hash,
1658 str,
1659 &hash_ptr));
1660
1661 ++vp->num_allocated;
1662
1663 if (ECOFF_IS_STAB (&psym->ecoff_sym.asym))
1664 return psym;
1665
1666 /* Save the symbol within the hash table if this is a static
1667 item, and it has a name. */
1668 if (hash_ptr != (shash_t *) NULL
1669 && (type == st_Global || type == st_Static || type == st_Label
1670 || type == st_Proc || type == st_StaticProc))
1671 hash_ptr->sym_ptr = psym;
1672
1673 /* push or pop a scope if appropriate. */
1674 switch (type)
1675 {
1676 default:
1677 break;
1678
1679 case st_File: /* beginning of file */
1680 case st_Proc: /* procedure */
1681 case st_StaticProc: /* static procedure */
1682 case st_Block: /* begin scope */
1683 pscope = allocate_scope ();
1684 pscope->prev = cur_file_ptr->cur_scope;
1685 pscope->lsym = psym;
1686 pscope->type = type;
1687 cur_file_ptr->cur_scope = pscope;
1688
1689 if (type != st_File)
1690 scope_delta = 1;
1691
1692 /* For every block type except file, struct, union, or
1693 enumeration blocks, push a level on the tag stack. We omit
1694 file types, so that tags can span file boundaries. */
1695 if (type != st_File && storage != sc_Info)
1696 {
1697 ptag_head = allocate_thead ();
1698 ptag_head->first_tag = 0;
1699 ptag_head->prev = cur_tag_head;
1700 cur_tag_head = ptag_head;
1701 }
1702 break;
1703
1704 case st_End:
1705 pscope = cur_file_ptr->cur_scope;
1706 if (pscope == (scope_t *) NULL)
1707 as_fatal ("too many st_End's");
1708 else
1709 {
1710 st_t begin_type = (st_t) pscope->lsym->ecoff_sym.asym.st;
1711
1712 psym->begin_ptr = pscope->lsym;
1713
1714 if (begin_type != st_File)
1715 scope_delta = -1;
1716
1717 /* Except for file, structure, union, or enumeration end
1718 blocks remove all tags created within this scope. */
1719 if (begin_type != st_File && storage != sc_Info)
1720 {
1721 ptag_head = cur_tag_head;
1722 cur_tag_head = ptag_head->prev;
1723
1724 for (ptag = ptag_head->first_tag;
1725 ptag != (tag_t *) NULL;
1726 ptag = ptag_next)
1727 {
1728 if (ptag->forward_ref != (forward_t *) NULL)
1729 add_unknown_tag (ptag);
1730
1731 ptag_next = ptag->same_block;
1732 ptag->hash_ptr->tag_ptr = ptag->same_name;
1733 free_tag (ptag);
1734 }
1735
1736 free_thead (ptag_head);
1737 }
1738
1739 cur_file_ptr->cur_scope = pscope->prev;
1740
1741 /* block begin gets next sym #. This is set when we know
1742 the symbol index value. */
1743
1744 /* Functions push two or more aux words as follows:
1745 1st word: index+1 of the end symbol (filled in later).
1746 2nd word: type of the function (plus any aux words needed).
1747 Also, tie the external pointer back to the function begin symbol. */
1748 if (begin_type != st_File && begin_type != st_Block)
1749 {
1750 symint_t ty;
1751 varray_t *svp = &cur_file_ptr->aux_syms;
1752
1753 pscope->lsym->ecoff_sym.asym.index = add_aux_sym_symint (0);
1754 pscope->lsym->index_ptr =
1755 &svp->last->datum->aux[svp->objects_last_page - 1];
1756 ty = add_aux_sym_tir (&last_func_type_info,
1757 hash_no,
1758 &cur_file_ptr->thash_head[0]);
1759
1760 /* This seems to be unnecessary. I'm not even sure what it is
1761 * intended to do. It's from mips-tfile.
1762 * if (last_func_sym_value != (symbolS *) NULL)
1763 * {
1764 * last_func_sym_value->ifd = cur_file_ptr->file_index;
1765 * last_func_sym_value->index = ty;
1766 * }
1767 */
1768 }
1769
1770 free_scope (pscope);
1771 }
1772 }
1773
1774 cur_file_ptr->nested_scopes += scope_delta;
1775
1776 #ifdef ECOFF_DEBUG
1777 if (debug && type != st_File
1778 && (debug > 2 || type == st_Block || type == st_End
1779 || type == st_Proc || type == st_StaticProc))
1780 {
1781 char *sc_str = sc_to_string (storage);
1782 char *st_str = st_to_string (type);
1783 int depth = cur_file_ptr->nested_scopes + (scope_delta < 0);
1784
1785 fprintf (stderr,
1786 "\tlsym\tv= %10ld, depth= %2d, sc= %-12s",
1787 value, depth, sc_str);
1788
1789 if (str_start && str_end_p1 - str_start > 0)
1790 fprintf (stderr, " st= %-11s name= %.*s\n", st_str, str_end_p1 - str_start, str_start);
1791 else
1792 {
1793 unsigned long len = strlen (st_str);
1794 fprintf (stderr, " st= %.*s\n", len-1, st_str);
1795 }
1796 }
1797 #endif
1798
1799 return psym;
1800 }
1801 \f
1802 /* Add an auxiliary symbol (passing a symint). This is actually used
1803 for integral aux types, not just symints. */
1804
1805 static symint_t
1806 add_aux_sym_symint (aux_word)
1807 symint_t aux_word; /* auxiliary information word */
1808 {
1809 register varray_t *vp;
1810 register aux_t *aux_ptr;
1811
1812 if (cur_file_ptr == (efdr_t *) NULL)
1813 as_fatal ("no current file pointer");
1814
1815 vp = &cur_file_ptr->aux_syms;
1816
1817 if (vp->objects_last_page == vp->objects_per_page)
1818 add_varray_page (vp);
1819
1820 aux_ptr = &vp->last->datum->aux[vp->objects_last_page++];
1821 aux_ptr->type = aux_isym;
1822 aux_ptr->data.isym = aux_word;
1823
1824 return vp->num_allocated++;
1825 }
1826
1827
1828 /* Add an auxiliary symbol (passing a file/symbol index combo). */
1829
1830 static symint_t
1831 add_aux_sym_rndx (file_index, sym_index)
1832 int file_index;
1833 symint_t sym_index;
1834 {
1835 register varray_t *vp;
1836 register aux_t *aux_ptr;
1837
1838 if (cur_file_ptr == (efdr_t *) NULL)
1839 as_fatal ("no current file pointer");
1840
1841 vp = &cur_file_ptr->aux_syms;
1842
1843 if (vp->objects_last_page == vp->objects_per_page)
1844 add_varray_page (vp);
1845
1846 aux_ptr = &vp->last->datum->aux[vp->objects_last_page++];
1847 aux_ptr->type = aux_rndx;
1848 aux_ptr->data.rndx.rfd = file_index;
1849 aux_ptr->data.rndx.index = sym_index;
1850
1851 return vp->num_allocated++;
1852 }
1853 \f
1854 /* Add an auxiliary symbol (passing the basic type and possibly
1855 type qualifiers). */
1856
1857 static symint_t
1858 add_aux_sym_tir (t, state, hash_tbl)
1859 type_info_t *t; /* current type information */
1860 hash_state_t state; /* whether to hash type or not */
1861 thash_t **hash_tbl; /* pointer to hash table to use */
1862 {
1863 register varray_t *vp;
1864 register aux_t *aux_ptr;
1865 static AUXU init_aux;
1866 symint_t ret;
1867 int i;
1868 AUXU aux;
1869
1870 if (cur_file_ptr == (efdr_t *) NULL)
1871 as_fatal ("no current file pointer");
1872
1873 vp = &cur_file_ptr->aux_syms;
1874
1875 aux = init_aux;
1876 aux.ti.bt = (int) t->basic_type;
1877 aux.ti.continued = 0;
1878 aux.ti.fBitfield = t->bitfield;
1879
1880 aux.ti.tq0 = (int) t->type_qualifiers[0];
1881 aux.ti.tq1 = (int) t->type_qualifiers[1];
1882 aux.ti.tq2 = (int) t->type_qualifiers[2];
1883 aux.ti.tq3 = (int) t->type_qualifiers[3];
1884 aux.ti.tq4 = (int) t->type_qualifiers[4];
1885 aux.ti.tq5 = (int) t->type_qualifiers[5];
1886
1887
1888 /* For anything that adds additional information, we must not hash,
1889 so check here, and reset our state. */
1890
1891 if (state != hash_no
1892 && (t->type_qualifiers[0] == tq_Array
1893 || t->type_qualifiers[1] == tq_Array
1894 || t->type_qualifiers[2] == tq_Array
1895 || t->type_qualifiers[3] == tq_Array
1896 || t->type_qualifiers[4] == tq_Array
1897 || t->type_qualifiers[5] == tq_Array
1898 || t->basic_type == bt_Struct
1899 || t->basic_type == bt_Union
1900 || t->basic_type == bt_Enum
1901 || t->bitfield
1902 || t->num_dims > 0))
1903 state = hash_no;
1904
1905 /* See if we can hash this type, and save some space, but some types
1906 can't be hashed (because they contain arrays or continuations),
1907 and others can be put into the hash list, but cannot use existing
1908 types because other aux entries precede this one. */
1909
1910 if (state != hash_no)
1911 {
1912 register thash_t *hash_ptr;
1913 register symint_t hi;
1914
1915 hi = aux.isym & ((1 << HASHBITS) - 1);
1916 hi %= THASH_SIZE;
1917
1918 for (hash_ptr = hash_tbl[hi];
1919 hash_ptr != (thash_t *)0;
1920 hash_ptr = hash_ptr->next)
1921 {
1922 if (aux.isym == hash_ptr->type.isym)
1923 break;
1924 }
1925
1926 if (hash_ptr != (thash_t *) NULL && state == hash_yes)
1927 return hash_ptr->indx;
1928
1929 if (hash_ptr == (thash_t *) NULL)
1930 {
1931 hash_ptr = allocate_thash ();
1932 hash_ptr->next = hash_tbl[hi];
1933 hash_ptr->type = aux;
1934 hash_ptr->indx = vp->num_allocated;
1935 hash_tbl[hi] = hash_ptr;
1936 }
1937 }
1938
1939 /* Everything is set up, add the aux symbol. */
1940 if (vp->objects_last_page == vp->objects_per_page)
1941 add_varray_page (vp);
1942
1943 aux_ptr = &vp->last->datum->aux[ vp->objects_last_page++ ];
1944 aux_ptr->type = aux_tir;
1945 aux_ptr->data = aux;
1946
1947 ret = vp->num_allocated++;
1948
1949 /* Add bitfield length if it exists.
1950
1951 NOTE: Mips documentation claims bitfield goes at the end of the
1952 AUX record, but the DECstation compiler emits it here.
1953 (This would only make a difference for enum bitfields.)
1954
1955 Also note: We use the last size given since gcc may emit 2
1956 for an enum bitfield. */
1957
1958 if (t->bitfield)
1959 (void) add_aux_sym_symint ((symint_t)t->sizes[t->num_sizes-1]);
1960
1961
1962 /* Add tag information if needed. Structure, union, and enum
1963 references add 2 aux symbols: a [file index, symbol index]
1964 pointer to the structure type, and the current file index. */
1965
1966 if (t->basic_type == bt_Struct
1967 || t->basic_type == bt_Union
1968 || t->basic_type == bt_Enum)
1969 {
1970 register symint_t file_index = t->tag_ptr->ifd;
1971 register localsym_t *sym = t->tag_ptr->sym;
1972 register forward_t *forward_ref = allocate_forward ();
1973
1974 if (sym != (localsym_t *) NULL)
1975 {
1976 forward_ref->next = sym->forward_ref;
1977 sym->forward_ref = forward_ref;
1978 }
1979 else
1980 {
1981 forward_ref->next = t->tag_ptr->forward_ref;
1982 t->tag_ptr->forward_ref = forward_ref;
1983 }
1984
1985 (void) add_aux_sym_rndx (ST_RFDESCAPE, indexNil);
1986 forward_ref->index_ptr
1987 = &vp->last->datum->aux[ vp->objects_last_page - 1];
1988
1989 (void) add_aux_sym_symint (file_index);
1990 forward_ref->ifd_ptr
1991 = &vp->last->datum->aux[ vp->objects_last_page - 1];
1992 }
1993
1994 /* Add information about array bounds if they exist. */
1995 for (i = 0; i < t->num_dims; i++)
1996 {
1997 (void) add_aux_sym_rndx (ST_RFDESCAPE,
1998 cur_file_ptr->int_type);
1999
2000 (void) add_aux_sym_symint (cur_file_ptr->file_index); /* file index*/
2001 (void) add_aux_sym_symint ((symint_t) 0); /* low bound */
2002 (void) add_aux_sym_symint (t->dimensions[i] - 1); /* high bound*/
2003 (void) add_aux_sym_symint ((t->dimensions[i] == 0) /* stride */
2004 ? 0
2005 : (t->sizes[i] * 8) / t->dimensions[i]);
2006 };
2007
2008 /* NOTE: Mips documentation claims that the bitfield width goes here.
2009 But it needs to be emitted earlier. */
2010
2011 return ret;
2012 }
2013 \f
2014 /* Add a tag to the tag table (unless it already exists). */
2015
2016 static tag_t *
2017 get_tag (tag, sym, basic_type)
2018 const char *tag; /* tag name */
2019 localsym_t *sym; /* tag start block */
2020 bt_t basic_type; /* bt_Struct, bt_Union, or bt_Enum */
2021 {
2022 shash_t *hash_ptr;
2023 const char *err;
2024 tag_t *tag_ptr;
2025
2026 if (cur_file_ptr == (efdr_t *) NULL)
2027 as_fatal ("no current file pointer");
2028
2029 hash_ptr = (shash_t *) hash_find (tag_hash, tag);
2030
2031 if (hash_ptr != (shash_t *) NULL
2032 && hash_ptr->tag_ptr != (tag_t *) NULL)
2033 {
2034 tag_ptr = hash_ptr->tag_ptr;
2035 if (sym != (localsym_t *) NULL)
2036 {
2037 tag_ptr->basic_type = basic_type;
2038 tag_ptr->ifd = cur_file_ptr->file_index;
2039 tag_ptr->sym = sym;
2040 }
2041 return tag_ptr;
2042 }
2043
2044 if (hash_ptr == (shash_t *) NULL)
2045 {
2046 char *perm;
2047
2048 perm = xmalloc ((unsigned long) (strlen (tag) + 1));
2049 strcpy (perm, tag);
2050 hash_ptr = allocate_shash ();
2051 err = hash_insert (tag_hash, perm, (char *) hash_ptr);
2052 if (err)
2053 as_fatal ("Inserting \"%s\" into tag hash table: %s",
2054 tag, err);
2055 hash_ptr->string = perm;
2056 }
2057
2058 tag_ptr = allocate_tag ();
2059 tag_ptr->forward_ref = (forward_t *) NULL;
2060 tag_ptr->hash_ptr = hash_ptr;
2061 tag_ptr->same_name = hash_ptr->tag_ptr;
2062 tag_ptr->basic_type = basic_type;
2063 tag_ptr->sym = sym;
2064 tag_ptr->ifd = ((sym == (localsym_t *) NULL)
2065 ? (symint_t) -1
2066 : cur_file_ptr->file_index);
2067 tag_ptr->same_block = cur_tag_head->first_tag;
2068
2069 cur_tag_head->first_tag = tag_ptr;
2070 hash_ptr->tag_ptr = tag_ptr;
2071
2072 return tag_ptr;
2073 }
2074 \f
2075 /* Add an unknown {struct, union, enum} tag. */
2076
2077 static void
2078 add_unknown_tag (ptag)
2079 tag_t *ptag; /* pointer to tag information */
2080 {
2081 shash_t *hash_ptr = ptag->hash_ptr;
2082 char *name = hash_ptr->string;
2083 localsym_t *sym;
2084 forward_t **pf;
2085
2086 #ifdef ECOFF_DEBUG
2087 if (debug > 1)
2088 {
2089 char *agg_type = "{unknown aggregate type}";
2090 switch (ptag->basic_type)
2091 {
2092 case bt_Struct: agg_type = "struct"; break;
2093 case bt_Union: agg_type = "union"; break;
2094 case bt_Enum: agg_type = "enum"; break;
2095 default: break;
2096 }
2097
2098 fprintf (stderr, "unknown %s %.*s found\n", agg_type,
2099 hash_ptr->len, name_start);
2100 }
2101 #endif
2102
2103 sym = add_ecoff_symbol (name,
2104 st_Block,
2105 sc_Info,
2106 (symbolS *) NULL,
2107 (symint_t) 0,
2108 (symint_t) 0);
2109
2110 (void) add_ecoff_symbol (name,
2111 st_End,
2112 sc_Info,
2113 (symbolS *) NULL,
2114 (symint_t) 0,
2115 (symint_t) 0);
2116
2117 for (pf = &sym->forward_ref; *pf != (forward_t *) NULL; pf = &(*pf)->next)
2118 ;
2119 *pf = ptag->forward_ref;
2120 }
2121 \f
2122 /* Add a procedure to the current file's list of procedures, and record
2123 this is the current procedure. */
2124
2125 static void
2126 add_procedure (func)
2127 char *func; /* func name */
2128 {
2129 register varray_t *vp;
2130 register proc_t *new_proc_ptr;
2131
2132 #ifdef ECOFF_DEBUG
2133 if (debug)
2134 fputc ('\n', stderr);
2135 #endif
2136
2137 if (cur_file_ptr == (efdr_t *) NULL)
2138 as_fatal ("no current file pointer");
2139
2140 vp = &cur_file_ptr->procs;
2141
2142 if (vp->objects_last_page == vp->objects_per_page)
2143 add_varray_page (vp);
2144
2145 cur_proc_ptr = new_proc_ptr = &vp->last->datum->proc[vp->objects_last_page++];
2146
2147 if (first_proc_ptr == (proc_t *) NULL)
2148 first_proc_ptr = new_proc_ptr;
2149
2150 vp->num_allocated++;
2151
2152 new_proc_ptr->pdr.isym = -1;
2153 new_proc_ptr->pdr.iline = -1;
2154 new_proc_ptr->pdr.lnLow = -1;
2155 new_proc_ptr->pdr.lnHigh = -1;
2156
2157 /* Push the start of the function. */
2158 new_proc_ptr->sym = add_ecoff_symbol ((const char *) NULL, st_Proc, sc_Text,
2159 symbol_find_or_make (func),
2160 (symint_t) 0, (symint_t) 0);
2161
2162 ++proc_cnt;
2163
2164 /* Fill in the linenos preceding the .ent, if any. */
2165 if (noproc_lineno != (lineno_list_t *) NULL)
2166 {
2167 lineno_list_t *l;
2168
2169 for (l = noproc_lineno; l != (lineno_list_t *) NULL; l = l->next)
2170 l->proc = new_proc_ptr;
2171 *last_lineno_ptr = noproc_lineno;
2172 while (*last_lineno_ptr != NULL)
2173 last_lineno_ptr = &(*last_lineno_ptr)->next;
2174 noproc_lineno = (lineno_list_t *) NULL;
2175 }
2176 }
2177 \f
2178 /* Add a new filename, and set up all of the file relative
2179 virtual arrays (strings, symbols, aux syms, etc.). Record
2180 where the current file structure lives. */
2181
2182 static void
2183 add_file (file_name, indx, fake)
2184 const char *file_name; /* file name */
2185 int indx;
2186 int fake;
2187 {
2188 register int first_ch;
2189 register efdr_t *fil_ptr;
2190
2191 #ifdef ECOFF_DEBUG
2192 if (debug)
2193 fprintf (stderr, "\tfile\t%.*s\n", len, file_start);
2194 #endif
2195
2196 /* If the file name is NULL, then no .file symbol appeared, and we
2197 want to use the actual file name. */
2198 if (file_name == (const char *) NULL)
2199 {
2200 char *file;
2201
2202 if (first_file != (efdr_t *) NULL)
2203 as_fatal ("fake .file after real one");
2204 as_where (&file, (unsigned int *) NULL);
2205 file_name = (const char *) file;
2206
2207 if (! symbol_table_frozen)
2208 generate_asm_lineno = 1;
2209 }
2210 else
2211 generate_asm_lineno = 0;
2212
2213 #ifndef NO_LISTING
2214 if (listing)
2215 listing_source_file (file_name);
2216 #endif
2217
2218 current_stabs_filename = file_name;
2219
2220 /* If we're creating stabs, then we don't actually make a new FDR.
2221 Instead, we just create a stabs symbol. */
2222 if (stabs_seen)
2223 {
2224 (void) add_ecoff_symbol (file_name, st_Nil, sc_Nil,
2225 symbol_new ("L0\001", now_seg,
2226 (valueT) frag_now_fix (),
2227 frag_now),
2228 0, ECOFF_MARK_STAB (N_SOL));
2229 return;
2230 }
2231
2232 first_ch = *file_name;
2233
2234 /* ??? This is ifdefed out, because it results in incorrect line number
2235 debugging info when multiple .file pseudo-ops are merged into one file
2236 descriptor. See for instance ecoff_build_lineno, which will
2237 end up setting all file->fdr.* fields multiple times, resulting in
2238 incorrect debug info. In order to make this work right, all line number
2239 and symbol info for the same source file has to be adjacent in the object
2240 file, so that a single file descriptor can be used to point to them.
2241 This would require maintaining file specific lists of line numbers and
2242 symbols for each file, so that they can be merged together (or output
2243 together) when two .file pseudo-ops are merged into one file
2244 descriptor. */
2245
2246 #if 0
2247 /* See if the file has already been created. */
2248 for (fil_ptr = first_file;
2249 fil_ptr != (efdr_t *) NULL;
2250 fil_ptr = fil_ptr->next_file)
2251 {
2252 if (first_ch == fil_ptr->name[0]
2253 && strcmp (file_name, fil_ptr->name) == 0)
2254 {
2255 cur_file_ptr = fil_ptr;
2256 if (! fake)
2257 cur_file_ptr->fake = 0;
2258 break;
2259 }
2260 }
2261 #else
2262 fil_ptr = (efdr_t *) NULL;
2263 #endif
2264
2265 /* If this is a new file, create it. */
2266 if (fil_ptr == (efdr_t *) NULL)
2267 {
2268 if (file_desc.objects_last_page == file_desc.objects_per_page)
2269 add_varray_page (&file_desc);
2270
2271 fil_ptr = cur_file_ptr =
2272 &file_desc.last->datum->file[file_desc.objects_last_page++];
2273 *fil_ptr = init_file;
2274
2275 fil_ptr->file_index = current_file_idx++;
2276 ++file_desc.num_allocated;
2277
2278 fil_ptr->fake = fake;
2279
2280 /* Allocate the string hash table. */
2281 fil_ptr->str_hash = hash_new ();
2282
2283 /* Make sure 0 byte in string table is null */
2284 add_string (&fil_ptr->strings,
2285 fil_ptr->str_hash,
2286 "",
2287 (shash_t **)0);
2288
2289 if (strlen (file_name) > PAGE_USIZE - 2)
2290 as_fatal ("Filename goes over one page boundary.");
2291
2292 /* Push the start of the filename. We assume that the filename
2293 will be stored at string offset 1. */
2294 (void) add_ecoff_symbol (file_name, st_File, sc_Text,
2295 (symbolS *) NULL,
2296 (symint_t) 0, (symint_t) 0);
2297 fil_ptr->fdr.rss = 1;
2298 fil_ptr->name = &fil_ptr->strings.last->datum->byte[1];
2299
2300 /* Update the linked list of file descriptors. */
2301 *last_file_ptr = fil_ptr;
2302 last_file_ptr = &fil_ptr->next_file;
2303
2304 /* Add void & int types to the file (void should be first to catch
2305 errant 0's within the index fields). */
2306 fil_ptr->void_type = add_aux_sym_tir (&void_type_info,
2307 hash_yes,
2308 &cur_file_ptr->thash_head[0]);
2309
2310 fil_ptr->int_type = add_aux_sym_tir (&int_type_info,
2311 hash_yes,
2312 &cur_file_ptr->thash_head[0]);
2313 /* gas used to have a bug that if the file does not have any
2314 symbol, it either will abort or will not build the file,
2315 the following is to get around that problem. ---kung*/
2316 #if 0
2317 if (generate_asm_lineno)
2318 {
2319 mark_stabs (0);
2320 (void) add_ecoff_symbol (file_name, st_Nil, sc_Nil,
2321 symbol_new ("L0\001", now_seg,
2322 (valueT) frag_now_fix (),
2323 frag_now),
2324 0, ECOFF_MARK_STAB (N_SO));
2325 (void) add_ecoff_symbol ("void:t1=1", st_Nil, sc_Nil,
2326 (symbolS *) NULL, 0,
2327 ECOFF_MARK_STAB (N_LSYM));
2328 }
2329 #endif
2330 }
2331 }
2332 \f
2333 #ifdef ECOFF_DEBUG
2334
2335 /* Convert storage class to string. */
2336
2337 static char *
2338 sc_to_string(storage_class)
2339 sc_t storage_class;
2340 {
2341 switch(storage_class)
2342 {
2343 case sc_Nil: return "Nil,";
2344 case sc_Text: return "Text,";
2345 case sc_Data: return "Data,";
2346 case sc_Bss: return "Bss,";
2347 case sc_Register: return "Register,";
2348 case sc_Abs: return "Abs,";
2349 case sc_Undefined: return "Undefined,";
2350 case sc_CdbLocal: return "CdbLocal,";
2351 case sc_Bits: return "Bits,";
2352 case sc_CdbSystem: return "CdbSystem,";
2353 case sc_RegImage: return "RegImage,";
2354 case sc_Info: return "Info,";
2355 case sc_UserStruct: return "UserStruct,";
2356 case sc_SData: return "SData,";
2357 case sc_SBss: return "SBss,";
2358 case sc_RData: return "RData,";
2359 case sc_Var: return "Var,";
2360 case sc_Common: return "Common,";
2361 case sc_SCommon: return "SCommon,";
2362 case sc_VarRegister: return "VarRegister,";
2363 case sc_Variant: return "Variant,";
2364 case sc_SUndefined: return "SUndefined,";
2365 case sc_Init: return "Init,";
2366 case sc_Max: return "Max,";
2367 }
2368
2369 return "???,";
2370 }
2371
2372 #endif /* DEBUG */
2373 \f
2374 #ifdef ECOFF_DEBUG
2375
2376 /* Convert symbol type to string. */
2377
2378 static char *
2379 st_to_string(symbol_type)
2380 st_t symbol_type;
2381 {
2382 switch(symbol_type)
2383 {
2384 case st_Nil: return "Nil,";
2385 case st_Global: return "Global,";
2386 case st_Static: return "Static,";
2387 case st_Param: return "Param,";
2388 case st_Local: return "Local,";
2389 case st_Label: return "Label,";
2390 case st_Proc: return "Proc,";
2391 case st_Block: return "Block,";
2392 case st_End: return "End,";
2393 case st_Member: return "Member,";
2394 case st_Typedef: return "Typedef,";
2395 case st_File: return "File,";
2396 case st_RegReloc: return "RegReloc,";
2397 case st_Forward: return "Forward,";
2398 case st_StaticProc: return "StaticProc,";
2399 case st_Constant: return "Constant,";
2400 case st_Str: return "String,";
2401 case st_Number: return "Number,";
2402 case st_Expr: return "Expr,";
2403 case st_Type: return "Type,";
2404 case st_Max: return "Max,";
2405 }
2406
2407 return "???,";
2408 }
2409
2410 #endif /* DEBUG */
2411 \f
2412 /* Parse .begin directives which have a label as the first argument
2413 which gives the location of the start of the block. */
2414
2415 void
2416 ecoff_directive_begin (ignore)
2417 int ignore;
2418 {
2419 char *name;
2420 char name_end;
2421
2422 if (cur_file_ptr == (efdr_t *) NULL)
2423 {
2424 as_warn (".begin directive without a preceding .file directive");
2425 demand_empty_rest_of_line ();
2426 return;
2427 }
2428
2429 if (cur_proc_ptr == (proc_t *) NULL)
2430 {
2431 as_warn (".begin directive without a preceding .ent directive");
2432 demand_empty_rest_of_line ();
2433 return;
2434 }
2435
2436 name = input_line_pointer;
2437 name_end = get_symbol_end ();
2438
2439 (void) add_ecoff_symbol ((const char *) NULL, st_Block, sc_Text,
2440 symbol_find_or_make (name),
2441 (symint_t) 0, (symint_t) 0);
2442
2443 *input_line_pointer = name_end;
2444
2445 /* The line number follows, but we don't use it. */
2446 (void) get_absolute_expression ();
2447 demand_empty_rest_of_line ();
2448 }
2449 \f
2450 /* Parse .bend directives which have a label as the first argument
2451 which gives the location of the end of the block. */
2452
2453 void
2454 ecoff_directive_bend (ignore)
2455 int ignore;
2456 {
2457 char *name;
2458 char name_end;
2459 symbolS *endsym;
2460
2461 if (cur_file_ptr == (efdr_t *) NULL)
2462 {
2463 as_warn (".bend directive without a preceding .file directive");
2464 demand_empty_rest_of_line ();
2465 return;
2466 }
2467
2468 if (cur_proc_ptr == (proc_t *) NULL)
2469 {
2470 as_warn (".bend directive without a preceding .ent directive");
2471 demand_empty_rest_of_line ();
2472 return;
2473 }
2474
2475 name = input_line_pointer;
2476 name_end = get_symbol_end ();
2477
2478 /* The value is the distance between the .bend directive and the
2479 corresponding symbol. We fill in the offset when we write out
2480 the symbol. */
2481 endsym = symbol_find (name);
2482 if (endsym == (symbolS *) NULL)
2483 as_warn (".bend directive names unknown symbol");
2484 else
2485 (void) add_ecoff_symbol ((const char *) NULL, st_End, sc_Text, endsym,
2486 (symint_t) 0, (symint_t) 0);
2487
2488 *input_line_pointer = name_end;
2489
2490 /* The line number follows, but we don't use it. */
2491 (void) get_absolute_expression ();
2492 demand_empty_rest_of_line ();
2493 }
2494 \f
2495 /* COFF debugging information is provided as a series of directives
2496 (.def, .scl, etc.). We build up information as we read the
2497 directives in the following static variables, and file it away when
2498 we reach the .endef directive. */
2499 static char *coff_sym_name;
2500 static type_info_t coff_type;
2501 static sc_t coff_storage_class;
2502 static st_t coff_symbol_typ;
2503 static int coff_is_function;
2504 static char *coff_tag;
2505 static valueT coff_value;
2506 symbolS *coff_sym_value;
2507 static int coff_inside_enumeration;
2508
2509 /* Handle a .def directive: start defining a symbol. */
2510
2511 void
2512 ecoff_directive_def (ignore)
2513 int ignore;
2514 {
2515 char *name;
2516 char name_end;
2517
2518 ecoff_debugging_seen = 1;
2519
2520 SKIP_WHITESPACE ();
2521
2522 name = input_line_pointer;
2523 name_end = get_symbol_end ();
2524
2525 if (coff_sym_name != (char *) NULL)
2526 as_warn (".def pseudo-op used inside of .def/.endef; ignored");
2527 else if (*name == '\0')
2528 as_warn ("Empty symbol name in .def; ignored");
2529 else
2530 {
2531 if (coff_sym_name != (char *) NULL)
2532 free (coff_sym_name);
2533 if (coff_tag != (char *) NULL)
2534 free (coff_tag);
2535 coff_sym_name = (char *) xmalloc ((unsigned long) (strlen (name) + 1));
2536 strcpy (coff_sym_name, name);
2537 coff_type = type_info_init;
2538 coff_storage_class = sc_Nil;
2539 coff_symbol_typ = st_Nil;
2540 coff_is_function = 0;
2541 coff_tag = (char *) NULL;
2542 coff_value = 0;
2543 coff_sym_value = (symbolS *) NULL;
2544 }
2545
2546 *input_line_pointer = name_end;
2547
2548 demand_empty_rest_of_line ();
2549 }
2550
2551 /* Handle a .dim directive, used to give dimensions for an array. The
2552 arguments are comma separated numbers. mips-tfile assumes that
2553 there will not be more than 6 dimensions, and gdb won't read any
2554 more than that anyhow, so I will also make that assumption. */
2555
2556 void
2557 ecoff_directive_dim (ignore)
2558 int ignore;
2559 {
2560 int dimens[N_TQ];
2561 int i;
2562
2563 if (coff_sym_name == (char *) NULL)
2564 {
2565 as_warn (".dim pseudo-op used outside of .def/.endef; ignored");
2566 demand_empty_rest_of_line ();
2567 return;
2568 }
2569
2570 for (i = 0; i < N_TQ; i++)
2571 {
2572 SKIP_WHITESPACE ();
2573 dimens[i] = get_absolute_expression ();
2574 if (*input_line_pointer == ',')
2575 ++input_line_pointer;
2576 else
2577 {
2578 if (*input_line_pointer != '\n'
2579 && *input_line_pointer != ';')
2580 as_warn ("Badly formed .dim directive");
2581 break;
2582 }
2583 }
2584
2585 if (i == N_TQ)
2586 --i;
2587
2588 /* The dimensions are stored away in reverse order. */
2589 for (; i >= 0; i--)
2590 {
2591 if (coff_type.num_dims >= N_TQ)
2592 {
2593 as_warn ("Too many .dim entries");
2594 break;
2595 }
2596 coff_type.dimensions[coff_type.num_dims] = dimens[i];
2597 ++coff_type.num_dims;
2598 }
2599
2600 demand_empty_rest_of_line ();
2601 }
2602
2603 /* Handle a .scl directive, which sets the COFF storage class of the
2604 symbol. */
2605
2606 void
2607 ecoff_directive_scl (ignore)
2608 int ignore;
2609 {
2610 long val;
2611
2612 if (coff_sym_name == (char *) NULL)
2613 {
2614 as_warn (".scl pseudo-op used outside of .def/.endef; ignored");
2615 demand_empty_rest_of_line ();
2616 return;
2617 }
2618
2619 val = get_absolute_expression ();
2620
2621 coff_symbol_typ = map_coff_sym_type[val];
2622 coff_storage_class = map_coff_storage[val];
2623
2624 demand_empty_rest_of_line ();
2625 }
2626
2627 /* Handle a .size directive. For some reason mips-tfile.c thinks that
2628 .size can have multiple arguments. We humor it, although gcc will
2629 never generate more than one argument. */
2630
2631 void
2632 ecoff_directive_size (ignore)
2633 int ignore;
2634 {
2635 int sizes[N_TQ];
2636 int i;
2637
2638 if (coff_sym_name == (char *) NULL)
2639 {
2640 as_warn (".size pseudo-op used outside of .def/.endef; ignored");
2641 demand_empty_rest_of_line ();
2642 return;
2643 }
2644
2645 for (i = 0; i < N_TQ; i++)
2646 {
2647 SKIP_WHITESPACE ();
2648 sizes[i] = get_absolute_expression ();
2649 if (*input_line_pointer == ',')
2650 ++input_line_pointer;
2651 else
2652 {
2653 if (*input_line_pointer != '\n'
2654 && *input_line_pointer != ';')
2655 as_warn ("Badly formed .size directive");
2656 break;
2657 }
2658 }
2659
2660 if (i == N_TQ)
2661 --i;
2662
2663 /* The sizes are stored away in reverse order. */
2664 for (; i >= 0; i--)
2665 {
2666 if (coff_type.num_sizes >= N_TQ)
2667 {
2668 as_warn ("Too many .size entries");
2669 break;
2670 }
2671 coff_type.sizes[coff_type.num_sizes] = sizes[i];
2672 ++coff_type.num_sizes;
2673 }
2674
2675 demand_empty_rest_of_line ();
2676 }
2677
2678 /* Handle the .type directive, which gives the COFF type of the
2679 symbol. */
2680
2681 void
2682 ecoff_directive_type (ignore)
2683 int ignore;
2684 {
2685 long val;
2686 tq_t *tq_ptr;
2687 tq_t *tq_shft;
2688
2689 if (coff_sym_name == (char *) NULL)
2690 {
2691 as_warn (".type pseudo-op used outside of .def/.endef; ignored");
2692 demand_empty_rest_of_line ();
2693 return;
2694 }
2695
2696 val = get_absolute_expression ();
2697
2698 coff_type.orig_type = BTYPE (val);
2699 coff_type.basic_type = map_coff_types[coff_type.orig_type];
2700
2701 tq_ptr = &coff_type.type_qualifiers[N_TQ];
2702 while (val &~ N_BTMASK)
2703 {
2704 if (tq_ptr == &coff_type.type_qualifiers[0])
2705 {
2706 /* FIXME: We could handle this by setting the continued bit.
2707 There would still be a limit: the .type argument can not
2708 be infinite. */
2709 as_warn ("The type of %s is too complex; it will be simplified",
2710 coff_sym_name);
2711 break;
2712 }
2713 if (ISPTR (val))
2714 *--tq_ptr = tq_Ptr;
2715 else if (ISFCN (val))
2716 *--tq_ptr = tq_Proc;
2717 else if (ISARY (val))
2718 *--tq_ptr = tq_Array;
2719 else
2720 as_fatal ("Unrecognized .type argument");
2721
2722 val = DECREF (val);
2723 }
2724
2725 tq_shft = &coff_type.type_qualifiers[0];
2726 while (tq_ptr != &coff_type.type_qualifiers[N_TQ])
2727 *tq_shft++ = *tq_ptr++;
2728
2729 if (tq_shft != &coff_type.type_qualifiers[0] && tq_shft[-1] == tq_Proc)
2730 {
2731 /* If this is a function, ignore it, so that we don't get two
2732 entries (one from the .ent, and one for the .def that
2733 precedes it). Save the type information so that the end
2734 block can properly add it after the begin block index. For
2735 MIPS knows what reason, we must strip off the function type
2736 at this point. */
2737 coff_is_function = 1;
2738 tq_shft[-1] = tq_Nil;
2739 }
2740
2741 while (tq_shft != &coff_type.type_qualifiers[N_TQ])
2742 *tq_shft++ = tq_Nil;
2743
2744 demand_empty_rest_of_line ();
2745 }
2746
2747 /* Handle the .tag directive, which gives the name of a structure,
2748 union or enum. */
2749
2750 void
2751 ecoff_directive_tag (ignore)
2752 int ignore;
2753 {
2754 char *name;
2755 char name_end;
2756
2757 if (coff_sym_name == (char *) NULL)
2758 {
2759 as_warn (".tag pseudo-op used outside of .def/.endef; ignored");
2760 demand_empty_rest_of_line ();
2761 return;
2762 }
2763
2764 name = input_line_pointer;
2765 name_end = get_symbol_end ();
2766
2767 coff_tag = (char *) xmalloc ((unsigned long) (strlen (name) + 1));
2768 strcpy (coff_tag, name);
2769
2770 *input_line_pointer = name_end;
2771
2772 demand_empty_rest_of_line ();
2773 }
2774
2775 /* Handle the .val directive, which gives the value of the symbol. It
2776 may be the name of a static or global symbol. */
2777
2778 void
2779 ecoff_directive_val (ignore)
2780 int ignore;
2781 {
2782 if (coff_sym_name == (char *) NULL)
2783 {
2784 as_warn (".val pseudo-op used outside of .def/.endef; ignored");
2785 demand_empty_rest_of_line ();
2786 return;
2787 }
2788
2789 if (! is_name_beginner ((unsigned char) *input_line_pointer))
2790 coff_value = get_absolute_expression ();
2791 else
2792 {
2793 char *name;
2794 char name_end;
2795
2796 name = input_line_pointer;
2797 name_end = get_symbol_end ();
2798
2799 if (strcmp (name, ".") == 0)
2800 as_warn ("`.val .' not supported");
2801 else
2802 coff_sym_value = symbol_find_or_make (name);
2803
2804 *input_line_pointer = name_end;
2805
2806 /* FIXME: gcc can generate address expressions here in unusual
2807 cases (search for "obscure" in sdbout.c), although this is
2808 very unlikely for a MIPS chip. */
2809 }
2810
2811 demand_empty_rest_of_line ();
2812 }
2813
2814 /* Handle the .endef directive, which terminates processing of COFF
2815 debugging information for a symbol. */
2816
2817 void
2818 ecoff_directive_endef (ignore)
2819 int ignore;
2820 {
2821 char *name;
2822 symint_t indx;
2823 localsym_t *sym;
2824
2825 demand_empty_rest_of_line ();
2826
2827 if (coff_sym_name == (char *) NULL)
2828 {
2829 as_warn (".endef pseudo-op used before .def; ignored");
2830 return;
2831 }
2832
2833 name = coff_sym_name;
2834 coff_sym_name = (char *) NULL;
2835
2836 /* If the symbol is a static or external, we have already gotten the
2837 appropriate type and class, so make sure we don't override those
2838 values. This is needed because there are some type and classes
2839 that are not in COFF, such as short data, etc. */
2840 if (coff_sym_value != (symbolS *) NULL)
2841 {
2842 coff_symbol_typ = st_Nil;
2843 coff_storage_class = sc_Nil;
2844 }
2845
2846 coff_type.extra_sizes = coff_tag != (char *) NULL;
2847 if (coff_type.num_dims > 0)
2848 {
2849 int diff = coff_type.num_dims - coff_type.num_sizes;
2850 int i = coff_type.num_dims - 1;
2851 int j;
2852
2853 if (coff_type.num_sizes != 1 || diff < 0)
2854 {
2855 as_warn ("Bad COFF debugging info");
2856 return;
2857 }
2858
2859 /* If this is an array, make sure the same number of dimensions
2860 and sizes were passed, creating extra sizes for multiply
2861 dimensioned arrays if not passed. */
2862 coff_type.extra_sizes = 0;
2863 if (diff)
2864 {
2865 j = (sizeof (coff_type.sizes) / sizeof (coff_type.sizes[0])) - 1;
2866 while (j >= 0)
2867 {
2868 coff_type.sizes[j] = (((j - diff) >= 0)
2869 ? coff_type.sizes[j - diff]
2870 : 0);
2871 j--;
2872 }
2873
2874 coff_type.num_sizes = i + 1;
2875 for (i--; i >= 0; i--)
2876 coff_type.sizes[i] = (coff_type.sizes[i + 1]
2877 / coff_type.dimensions[i + 1]);
2878 }
2879 }
2880 else if (coff_symbol_typ == st_Member
2881 && coff_type.num_sizes - coff_type.extra_sizes == 1)
2882 {
2883 /* Is this a bitfield? This is indicated by a structure memeber
2884 having a size field that isn't an array. */
2885 coff_type.bitfield = 1;
2886 }
2887
2888 /* Except for enumeration members & begin/ending of scopes, put the
2889 type word in the aux. symbol table. */
2890 if (coff_symbol_typ == st_Block || coff_symbol_typ == st_End)
2891 indx = 0;
2892 else if (coff_inside_enumeration)
2893 indx = cur_file_ptr->void_type;
2894 else
2895 {
2896 if (coff_type.basic_type == bt_Struct
2897 || coff_type.basic_type == bt_Union
2898 || coff_type.basic_type == bt_Enum)
2899 {
2900 if (coff_tag == (char *) NULL)
2901 {
2902 as_warn ("No tag specified for %s", name);
2903 return;
2904 }
2905
2906 coff_type.tag_ptr = get_tag (coff_tag, (localsym_t *) NULL,
2907 coff_type.basic_type);
2908 }
2909
2910 if (coff_is_function)
2911 {
2912 last_func_type_info = coff_type;
2913 last_func_sym_value = coff_sym_value;
2914 return;
2915 }
2916
2917 indx = add_aux_sym_tir (&coff_type,
2918 hash_yes,
2919 &cur_file_ptr->thash_head[0]);
2920 }
2921
2922 /* Do any last minute adjustments that are necessary. */
2923 switch (coff_symbol_typ)
2924 {
2925 default:
2926 break;
2927
2928 /* For the beginning of structs, unions, and enumerations, the
2929 size info needs to be passed in the value field. */
2930 case st_Block:
2931 if (coff_type.num_sizes - coff_type.num_dims - coff_type.extra_sizes
2932 != 1)
2933 {
2934 as_warn ("Bad COFF debugging information");
2935 return;
2936 }
2937 else
2938 coff_value = coff_type.sizes[0];
2939
2940 coff_inside_enumeration = (coff_type.orig_type == T_ENUM);
2941 break;
2942
2943 /* For the end of structs, unions, and enumerations, omit the
2944 name which is always ".eos". This needs to be done last, so
2945 that any error reporting above gives the correct name. */
2946 case st_End:
2947 free (name);
2948 name = (char *) NULL;
2949 coff_value = 0;
2950 coff_inside_enumeration = 0;
2951 break;
2952
2953 /* Members of structures and unions that aren't bitfields, need
2954 to adjust the value from a byte offset to a bit offset.
2955 Members of enumerations do not have the value adjusted, and
2956 can be distinguished by indx == indexNil. For enumerations,
2957 update the maximum enumeration value. */
2958 case st_Member:
2959 if (! coff_type.bitfield && ! coff_inside_enumeration)
2960 coff_value *= 8;
2961
2962 break;
2963 }
2964
2965 /* Add the symbol. */
2966 sym = add_ecoff_symbol (name,
2967 coff_symbol_typ,
2968 coff_storage_class,
2969 coff_sym_value,
2970 (symint_t) coff_value,
2971 indx);
2972
2973 /* deal with struct, union, and enum tags. */
2974 if (coff_symbol_typ == st_Block)
2975 {
2976 /* Create or update the tag information. */
2977 tag_t *tag_ptr = get_tag (name,
2978 sym,
2979 coff_type.basic_type);
2980 forward_t **pf;
2981
2982 /* Remember any forward references. */
2983 for (pf = &sym->forward_ref;
2984 *pf != (forward_t *) NULL;
2985 pf = &(*pf)->next)
2986 ;
2987 *pf = tag_ptr->forward_ref;
2988 tag_ptr->forward_ref = (forward_t *) NULL;
2989 }
2990 }
2991 \f
2992 /* Parse .end directives. */
2993
2994 void
2995 ecoff_directive_end (ignore)
2996 int ignore;
2997 {
2998 char *name;
2999 char name_end;
3000 register int ch;
3001 symbolS *ent;
3002
3003 if (cur_file_ptr == (efdr_t *) NULL)
3004 {
3005 as_warn (".end directive without a preceding .file directive");
3006 demand_empty_rest_of_line ();
3007 return;
3008 }
3009
3010 if (cur_proc_ptr == (proc_t *) NULL)
3011 {
3012 as_warn (".end directive without a preceding .ent directive");
3013 demand_empty_rest_of_line ();
3014 return;
3015 }
3016
3017 name = input_line_pointer;
3018 name_end = get_symbol_end ();
3019
3020 ch = *name;
3021 if (! is_name_beginner (ch))
3022 {
3023 as_warn (".end directive has no name");
3024 *input_line_pointer = name_end;
3025 demand_empty_rest_of_line ();
3026 return;
3027 }
3028
3029 /* The value is the distance between the .end directive and the
3030 corresponding symbol. We create a fake symbol to hold the
3031 current location, and put in the offset when we write out the
3032 symbol. */
3033 ent = symbol_find (name);
3034 if (ent == (symbolS *) NULL)
3035 as_warn (".end directive names unknown symbol");
3036 else
3037 {
3038 (void) add_ecoff_symbol ((const char *) NULL, st_End, sc_Text,
3039 symbol_new ("L0\001", now_seg,
3040 (valueT) frag_now_fix (),
3041 frag_now),
3042 (symint_t) 0, (symint_t) 0);
3043
3044 if (stabs_seen && generate_asm_lineno)
3045 {
3046 char *n;
3047
3048 n = xmalloc (strlen (name) + 4);
3049 strcpy (n, name);
3050 strcat (n, ":F1");
3051 (void) add_ecoff_symbol ((const char *) n, stGlobal, scText,
3052 ent, 0, ECOFF_MARK_STAB (N_FUN));
3053 }
3054 }
3055
3056 cur_proc_ptr = (proc_t *) NULL;
3057
3058 *input_line_pointer = name_end;
3059 demand_empty_rest_of_line ();
3060 }
3061 \f
3062 /* Parse .ent directives. */
3063
3064 void
3065 ecoff_directive_ent (ignore)
3066 int ignore;
3067 {
3068 char *name;
3069 char name_end;
3070 register int ch;
3071
3072 if (cur_file_ptr == (efdr_t *) NULL)
3073 add_file ((const char *) NULL, 0, 1);
3074
3075 if (cur_proc_ptr != (proc_t *) NULL)
3076 {
3077 as_warn ("second .ent directive found before .end directive");
3078 demand_empty_rest_of_line ();
3079 return;
3080 }
3081
3082 name = input_line_pointer;
3083 name_end = get_symbol_end ();
3084
3085 ch = *name;
3086 if (! is_name_beginner (ch))
3087 {
3088 as_warn (".ent directive has no name");
3089 *input_line_pointer = name_end;
3090 demand_empty_rest_of_line ();
3091 return;
3092 }
3093
3094 add_procedure (name);
3095
3096 *input_line_pointer = name_end;
3097
3098 /* The .ent directive is sometimes followed by a number. I'm not
3099 really sure what the number means. I don't see any way to store
3100 the information in the PDR. The Irix 4 assembler seems to ignore
3101 the information. */
3102 SKIP_WHITESPACE ();
3103 if (*input_line_pointer == ',')
3104 {
3105 ++input_line_pointer;
3106 SKIP_WHITESPACE ();
3107 }
3108 if (isdigit (*input_line_pointer) || *input_line_pointer == '-')
3109 (void) get_absolute_expression ();
3110
3111 demand_empty_rest_of_line ();
3112 }
3113 \f
3114 /* Parse .extern directives. */
3115
3116 void
3117 ecoff_directive_extern (ignore)
3118 int ignore;
3119 {
3120 char *name;
3121 int c;
3122 symbolS *symbolp;
3123 valueT size;
3124
3125 name = input_line_pointer;
3126 c = get_symbol_end ();
3127 symbolp = symbol_find_or_make (name);
3128 *input_line_pointer = c;
3129
3130 S_SET_EXTERNAL (symbolp);
3131
3132 if (*input_line_pointer == ',')
3133 ++input_line_pointer;
3134 size = get_absolute_expression ();
3135
3136 symbolp->ecoff_extern_size = size;
3137 }
3138 \f
3139 /* Parse .file directives. */
3140
3141 void
3142 ecoff_directive_file (ignore)
3143 int ignore;
3144 {
3145 int indx;
3146 char *name;
3147 int len;
3148
3149 if (cur_proc_ptr != (proc_t *) NULL)
3150 {
3151 as_warn ("No way to handle .file within .ent/.end section");
3152 demand_empty_rest_of_line ();
3153 return;
3154 }
3155
3156 indx = (int) get_absolute_expression ();
3157
3158 /* FIXME: we don't have to save the name here. */
3159 name = demand_copy_C_string (&len);
3160
3161 add_file (name, indx - 1, 0);
3162
3163 demand_empty_rest_of_line ();
3164 }
3165 \f
3166 /* Parse .fmask directives. */
3167
3168 void
3169 ecoff_directive_fmask (ignore)
3170 int ignore;
3171 {
3172 long val;
3173
3174 if (cur_proc_ptr == (proc_t *) NULL)
3175 {
3176 as_warn (".fmask outside of .ent");
3177 demand_empty_rest_of_line ();
3178 return;
3179 }
3180
3181 if (get_absolute_expression_and_terminator (&val) != ',')
3182 {
3183 as_warn ("Bad .fmask directive");
3184 --input_line_pointer;
3185 demand_empty_rest_of_line ();
3186 return;
3187 }
3188
3189 cur_proc_ptr->pdr.fregmask = val;
3190 cur_proc_ptr->pdr.fregoffset = get_absolute_expression ();
3191
3192 demand_empty_rest_of_line ();
3193 }
3194 \f
3195 /* Parse .frame directives. */
3196
3197 void
3198 ecoff_directive_frame (ignore)
3199 int ignore;
3200 {
3201 long val;
3202
3203 if (cur_proc_ptr == (proc_t *) NULL)
3204 {
3205 as_warn (".frame outside of .ent");
3206 demand_empty_rest_of_line ();
3207 return;
3208 }
3209
3210 cur_proc_ptr->pdr.framereg = tc_get_register (1);
3211
3212 SKIP_WHITESPACE ();
3213 if (*input_line_pointer++ != ','
3214 || get_absolute_expression_and_terminator (&val) != ',')
3215 {
3216 as_warn ("Bad .frame directive");
3217 --input_line_pointer;
3218 demand_empty_rest_of_line ();
3219 return;
3220 }
3221
3222 cur_proc_ptr->pdr.frameoffset = val;
3223
3224 cur_proc_ptr->pdr.pcreg = tc_get_register (0);
3225
3226 #if 0 /* Alpha-OSF1 adds "the offset of saved $a0 from $sp", according
3227 to Sandro. I don't yet know where this value should be stored, if
3228 anywhere. */
3229 demand_empty_rest_of_line ();
3230 #else
3231 s_ignore (42);
3232 #endif
3233 }
3234 \f
3235 /* Parse .mask directives. */
3236
3237 void
3238 ecoff_directive_mask (ignore)
3239 int ignore;
3240 {
3241 long val;
3242
3243 if (cur_proc_ptr == (proc_t *) NULL)
3244 {
3245 as_warn (".mask outside of .ent");
3246 demand_empty_rest_of_line ();
3247 return;
3248 }
3249
3250 if (get_absolute_expression_and_terminator (&val) != ',')
3251 {
3252 as_warn ("Bad .mask directive");
3253 --input_line_pointer;
3254 demand_empty_rest_of_line ();
3255 return;
3256 }
3257
3258 cur_proc_ptr->pdr.regmask = val;
3259 cur_proc_ptr->pdr.regoffset = get_absolute_expression ();
3260
3261 demand_empty_rest_of_line ();
3262 }
3263 \f
3264 /* Parse .loc directives. */
3265
3266 void
3267 ecoff_directive_loc (ignore)
3268 int ignore;
3269 {
3270 lineno_list_t *list;
3271 symint_t lineno;
3272
3273 if (cur_file_ptr == (efdr_t *) NULL)
3274 {
3275 as_warn (".loc before .file");
3276 demand_empty_rest_of_line ();
3277 return;
3278 }
3279
3280 if (now_seg != text_section)
3281 {
3282 as_warn (".loc outside of .text");
3283 demand_empty_rest_of_line ();
3284 return;
3285 }
3286
3287 /* Skip the file number. */
3288 SKIP_WHITESPACE ();
3289 get_absolute_expression ();
3290 SKIP_WHITESPACE ();
3291
3292 lineno = get_absolute_expression ();
3293
3294 #ifndef NO_LISTING
3295 if (listing)
3296 listing_source_line (lineno);
3297 #endif
3298
3299 /* If we're building stabs, then output a special label rather than
3300 ECOFF line number info. */
3301 if (stabs_seen)
3302 {
3303 (void) add_ecoff_symbol ((char *) NULL, st_Label, sc_Text,
3304 symbol_new ("L0\001", now_seg,
3305 (valueT) frag_now_fix (),
3306 frag_now),
3307 0, lineno);
3308 return;
3309 }
3310
3311 list = allocate_lineno_list ();
3312
3313 list->next = (lineno_list_t *) NULL;
3314 list->file = cur_file_ptr;
3315 list->proc = cur_proc_ptr;
3316 list->frag = frag_now;
3317 list->paddr = frag_now_fix ();
3318 list->lineno = lineno;
3319
3320 /* A .loc directive will sometimes appear before a .ent directive,
3321 which means that cur_proc_ptr will be NULL here. Arrange to
3322 patch this up. */
3323 if (cur_proc_ptr == (proc_t *) NULL)
3324 {
3325 lineno_list_t **pl;
3326
3327 pl = &noproc_lineno;
3328 while (*pl != (lineno_list_t *) NULL)
3329 pl = &(*pl)->next;
3330 *pl = list;
3331 }
3332 else
3333 {
3334 *last_lineno_ptr = list;
3335 last_lineno_ptr = &list->next;
3336 }
3337 }
3338 \f
3339 /* Make sure the @stabs symbol is emitted. */
3340
3341 static void
3342 mark_stabs (ignore)
3343 int ignore;
3344 {
3345 if (! stabs_seen)
3346 {
3347 /* Add a dummy @stabs dymbol. */
3348 stabs_seen = 1;
3349 (void) add_ecoff_symbol (stabs_symbol, stNil, scInfo,
3350 (symbolS *) NULL,
3351 (symint_t) -1, ECOFF_MARK_STAB (0));
3352 }
3353 }
3354 \f
3355 /* Parse .weakext directives. */
3356
3357 void
3358 ecoff_directive_weakext (ignore)
3359 int ignore;
3360 {
3361 char *name;
3362 int c;
3363 symbolS *symbolP;
3364 expressionS exp;
3365
3366 name = input_line_pointer;
3367 c = get_symbol_end ();
3368 symbolP = symbol_find_or_make (name);
3369 *input_line_pointer = c;
3370
3371 SKIP_WHITESPACE ();
3372
3373 if (c == ',')
3374 {
3375 if (S_IS_DEFINED (symbolP))
3376 {
3377 as_bad ("Ignoring attempt to redefine symbol `%s'.",
3378 S_GET_NAME (symbolP));
3379 ignore_rest_of_line ();
3380 return;
3381 }
3382
3383 ++input_line_pointer;
3384 SKIP_WHITESPACE ();
3385 if (! is_end_of_line[(unsigned char) *input_line_pointer])
3386 {
3387 expression (&exp);
3388 if (exp.X_op != O_symbol)
3389 {
3390 as_bad ("bad .weakext directive");
3391 ignore_rest_of_line();
3392 return;
3393 }
3394 symbolP->sy_value = exp;
3395 }
3396 }
3397
3398 S_SET_WEAK (symbolP);
3399
3400 demand_empty_rest_of_line ();
3401 }
3402 \f
3403 /* Handle .stabs directives. The actual parsing routine is done by a
3404 generic routine. This routine is called via OBJ_PROCESS_STAB.
3405 When this is called, input_line_pointer will be pointing at the
3406 value field of the stab.
3407
3408 .stabs directives have five fields:
3409 "string" a string, encoding the type information.
3410 code a numeric code, defined in <stab.h>
3411 0 a zero
3412 desc a zero or line number
3413 value a numeric value or an address.
3414
3415 If the value is relocatable, we transform this into:
3416 iss points as an index into string space
3417 value value from lookup of the name
3418 st st from lookup of the name
3419 sc sc from lookup of the name
3420 index code|CODE_MASK
3421
3422 If the value is not relocatable, we transform this into:
3423 iss points as an index into string space
3424 value value
3425 st st_Nil
3426 sc sc_Nil
3427 index code|CODE_MASK
3428
3429 .stabn directives have four fields (string is null):
3430 code a numeric code, defined in <stab.h>
3431 0 a zero
3432 desc a zero or a line number
3433 value a numeric value or an address. */
3434
3435 void
3436 ecoff_stab (sec, what, string, type, other, desc)
3437 segT sec;
3438 int what;
3439 const char *string;
3440 int type;
3441 int other;
3442 int desc;
3443 {
3444 efdr_t *save_file_ptr = cur_file_ptr;
3445 symbolS *sym;
3446 symint_t value;
3447 st_t st;
3448 sc_t sc;
3449 symint_t indx;
3450 localsym_t *hold = NULL;
3451
3452 ecoff_debugging_seen = 1;
3453
3454 /* We don't handle .stabd. */
3455 if (what != 's' && what != 'n')
3456 {
3457 as_bad (".stab%c is not supported", what);
3458 return;
3459 }
3460
3461 /* A .stabn uses a null name, not an empty string. */
3462 if (what == 'n')
3463 string = NULL;
3464
3465 /* We ignore the other field. */
3466 if (other != 0)
3467 as_warn (".stab%c: ignoring non-zero other field", what);
3468
3469 /* Make sure we have a current file. */
3470 if (cur_file_ptr == (efdr_t *) NULL)
3471 {
3472 add_file ((const char *) NULL, 0, 1);
3473 save_file_ptr = cur_file_ptr;
3474 }
3475
3476 /* For stabs in ECOFF, the first symbol must be @stabs. This is a
3477 signal to gdb. */
3478 if (stabs_seen == 0)
3479 mark_stabs (0);
3480
3481 /* Line number stabs are handled differently, since they have two
3482 values, the line number and the address of the label. We use the
3483 index field (aka desc) to hold the line number, and the value
3484 field to hold the address. The symbol type is st_Label, which
3485 should be different from the other stabs, so that gdb can
3486 recognize it. */
3487 if (type == N_SLINE)
3488 {
3489 SYMR dummy_symr;
3490 char *name;
3491 char name_end;
3492
3493 #ifndef NO_LISTING
3494 if (listing)
3495 listing_source_line ((unsigned int) desc);
3496 #endif
3497
3498 dummy_symr.index = desc;
3499 if (dummy_symr.index != desc)
3500 {
3501 as_warn ("Line number (%d) for .stab%c directive cannot fit in index field (20 bits)",
3502 desc, what);
3503 return;
3504 }
3505
3506 name = input_line_pointer;
3507 name_end = get_symbol_end ();
3508
3509 sym = symbol_find_or_make (name);
3510 *input_line_pointer = name_end;
3511
3512 value = 0;
3513 st = st_Label;
3514 sc = sc_Text;
3515 indx = desc;
3516 }
3517 else
3518 {
3519 #ifndef NO_LISTING
3520 if (listing && (type == N_SO || type == N_SOL))
3521 listing_source_file (string);
3522 #endif
3523
3524 if (isdigit (*input_line_pointer)
3525 || *input_line_pointer == '-'
3526 || *input_line_pointer == '+')
3527 {
3528 st = st_Nil;
3529 sc = sc_Nil;
3530 sym = (symbolS *) NULL;
3531 value = get_absolute_expression ();
3532 }
3533 else if (! is_name_beginner ((unsigned char) *input_line_pointer))
3534 {
3535 as_warn ("Illegal .stab%c directive, bad character", what);
3536 return;
3537 }
3538 else
3539 {
3540 char *name;
3541 char name_end;
3542
3543 name = input_line_pointer;
3544 name_end = get_symbol_end ();
3545
3546 sym = symbol_find_or_make (name);
3547
3548 sc = sc_Nil;
3549 st = st_Nil;
3550 value = 0;
3551
3552 *input_line_pointer = name_end;
3553 if (name_end == '+' || name_end == '-')
3554 {
3555 ++input_line_pointer;
3556 value = get_absolute_expression ();
3557 if (name_end == '-')
3558 value = - value;
3559 }
3560 }
3561
3562 indx = ECOFF_MARK_STAB (type);
3563 }
3564
3565 /* Don't store the stabs symbol we are creating as the type of the
3566 ECOFF symbol. We want to compute the type of the ECOFF symbol
3567 independently. */
3568 if (sym != (symbolS *) NULL)
3569 hold = sym->ecoff_symbol;
3570
3571 (void) add_ecoff_symbol (string, st, sc, sym, value, indx);
3572
3573 if (sym != (symbolS *) NULL)
3574 sym->ecoff_symbol = hold;
3575
3576 /* Restore normal file type. */
3577 cur_file_ptr = save_file_ptr;
3578 }
3579 \f
3580 /* Frob an ECOFF symbol. Small common symbols go into a special
3581 .scommon section rather than bfd_com_section. */
3582
3583 void
3584 ecoff_frob_symbol (sym)
3585 symbolS *sym;
3586 {
3587 if (S_IS_COMMON (sym)
3588 && S_GET_VALUE (sym) > 0
3589 && S_GET_VALUE (sym) <= bfd_get_gp_size (stdoutput))
3590 {
3591 static asection scom_section;
3592 static asymbol scom_symbol;
3593
3594 /* We must construct a fake section similar to bfd_com_section
3595 but with the name .scommon. */
3596 if (scom_section.name == NULL)
3597 {
3598 scom_section = bfd_com_section;
3599 scom_section.name = ".scommon";
3600 scom_section.output_section = &scom_section;
3601 scom_section.symbol = &scom_symbol;
3602 scom_section.symbol_ptr_ptr = &scom_section.symbol;
3603 scom_symbol = *bfd_com_section.symbol;
3604 scom_symbol.name = ".scommon";
3605 scom_symbol.section = &scom_section;
3606 }
3607 S_SET_SEGMENT (sym, &scom_section);
3608 }
3609 }
3610 \f
3611 /* Add bytes to the symbolic information buffer. */
3612
3613 static char *
3614 ecoff_add_bytes (buf, bufend, bufptr, need)
3615 char **buf;
3616 char **bufend;
3617 char *bufptr;
3618 unsigned long need;
3619 {
3620 unsigned long at;
3621 unsigned long want;
3622
3623 at = bufptr - *buf;
3624 need -= *bufend - bufptr;
3625 if (need < PAGE_SIZE)
3626 need = PAGE_SIZE;
3627 want = (*bufend - *buf) + need;
3628 *buf = xrealloc (*buf, want);
3629 *bufend = *buf + want;
3630 return *buf + at;
3631 }
3632
3633 /* Adjust the symbolic information buffer to the alignment required
3634 for the ECOFF target debugging information. */
3635
3636 static unsigned long
3637 ecoff_padding_adjust (backend, buf, bufend, offset, bufptrptr)
3638 const struct ecoff_debug_swap *backend;
3639 char **buf;
3640 char **bufend;
3641 unsigned long offset;
3642 char **bufptrptr;
3643 {
3644 bfd_size_type align;
3645
3646 align = backend->debug_align;
3647 if ((offset & (align - 1)) != 0)
3648 {
3649 unsigned long add;
3650
3651 add = align - (offset & (align - 1));
3652 if (*bufend - (*buf + offset) < add)
3653 (void) ecoff_add_bytes (buf, bufend, *buf + offset, add);
3654 memset (*buf + offset, 0, add);
3655 offset += add;
3656 if (bufptrptr != (char **) NULL)
3657 *bufptrptr = *buf + offset;
3658 }
3659
3660 return offset;
3661 }
3662
3663 /* Build the line number information. */
3664
3665 static unsigned long
3666 ecoff_build_lineno (backend, buf, bufend, offset, linecntptr)
3667 const struct ecoff_debug_swap *backend;
3668 char **buf;
3669 char **bufend;
3670 unsigned long offset;
3671 long *linecntptr;
3672 {
3673 char *bufptr;
3674 register lineno_list_t *l;
3675 lineno_list_t *last;
3676 efdr_t *file;
3677 proc_t *proc;
3678 unsigned long c;
3679 long iline;
3680 long totcount;
3681 lineno_list_t first;
3682
3683 if (linecntptr != (long *) NULL)
3684 *linecntptr = 0;
3685
3686 bufptr = *buf + offset;
3687
3688 file = (efdr_t *) NULL;
3689 proc = (proc_t *) NULL;
3690 last = (lineno_list_t *) NULL;
3691 c = offset;
3692 iline = 0;
3693 totcount = 0;
3694
3695 /* For some reason the address of the first procedure is ignored
3696 when reading line numbers. This doesn't matter if the address of
3697 the first procedure is 0, but when gcc is generating MIPS
3698 embedded PIC code, it will put strings in the .text section
3699 before the first procedure. We cope by inserting a dummy line if
3700 the address of the first procedure is not 0. Hopefully this
3701 won't screw things up too badly. */
3702 if (first_proc_ptr != (proc_t *) NULL
3703 && first_lineno != (lineno_list_t *) NULL
3704 && ((S_GET_VALUE (first_proc_ptr->sym->as_sym)
3705 + bfd_get_section_vma (stdoutput,
3706 S_GET_SEGMENT (first_proc_ptr->sym->as_sym)))
3707 != 0))
3708 {
3709 first.file = first_lineno->file;
3710 first.proc = first_lineno->proc;
3711 first.frag = &zero_address_frag;
3712 first.paddr = 0;
3713 first.lineno = 0;
3714
3715 first.next = first_lineno;
3716 first_lineno = &first;
3717 }
3718
3719 for (l = first_lineno; l != (lineno_list_t *) NULL; l = l->next)
3720 {
3721 long count;
3722 long delta;
3723
3724 /* Get the offset to the memory address of the next line number
3725 (in words). Do this first, so that we can skip ahead to the
3726 next useful line number entry. */
3727 if (l->next == (lineno_list_t *) NULL)
3728 {
3729 /* We want a count of zero, but it will be decremented
3730 before it is used. */
3731 count = 1;
3732 }
3733 else
3734 {
3735 count = ((l->next->frag->fr_address + l->next->paddr
3736 - (l->frag->fr_address + l->paddr))
3737 >> 2);
3738 if (count <= 0)
3739 {
3740 /* Don't change last, so we still get the right delta. */
3741 continue;
3742 }
3743 }
3744
3745 if (l->file != file || l->proc != proc)
3746 {
3747 if (l->proc != proc && proc != (proc_t *) NULL)
3748 proc->pdr.lnHigh = last->lineno;
3749 if (l->file != file && file != (efdr_t *) NULL)
3750 {
3751 file->fdr.cbLine = c - file->fdr.cbLineOffset;
3752 file->fdr.cline = totcount + count;
3753 if (linecntptr != (long *) NULL)
3754 *linecntptr += totcount + count;
3755 totcount = 0;
3756 }
3757
3758 if (l->file != file)
3759 {
3760 efdr_t *last_file = file;
3761
3762 file = l->file;
3763 if (last_file != (efdr_t *) NULL)
3764 file->fdr.ilineBase
3765 = last_file->fdr.ilineBase + last_file->fdr.cline;
3766 else
3767 file->fdr.ilineBase = 0;
3768 file->fdr.cbLineOffset = c;
3769 }
3770 if (l->proc != proc)
3771 {
3772 proc = l->proc;
3773 if (proc != (proc_t *) NULL)
3774 {
3775 proc->pdr.lnLow = l->lineno;
3776 proc->pdr.cbLineOffset = c - file->fdr.cbLineOffset;
3777 proc->pdr.iline = totcount;
3778 }
3779 }
3780
3781 last = (lineno_list_t *) NULL;
3782 }
3783
3784 totcount += count;
3785
3786 /* Get the offset to this line number. */
3787 if (last == (lineno_list_t *) NULL)
3788 delta = 0;
3789 else
3790 delta = l->lineno - last->lineno;
3791
3792 /* Put in the offset to this line number. */
3793 while (delta != 0)
3794 {
3795 int setcount;
3796
3797 /* 1 is added to each count read. */
3798 --count;
3799 /* We can only adjust the word count by up to 15 words at a
3800 time. */
3801 if (count <= 0x0f)
3802 {
3803 setcount = count;
3804 count = 0;
3805 }
3806 else
3807 {
3808 setcount = 0x0f;
3809 count -= 0x0f;
3810 }
3811 if (delta >= -7 && delta <= 7)
3812 {
3813 if (bufptr >= *bufend)
3814 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1);
3815 *bufptr++ = setcount + (delta << 4);
3816 delta = 0;
3817 ++c;
3818 }
3819 else
3820 {
3821 int set;
3822
3823 if (*bufend - bufptr < 3)
3824 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 3);
3825 *bufptr++ = setcount + (8 << 4);
3826 if (delta < -0x8000)
3827 {
3828 set = -0x8000;
3829 delta += 0x8000;
3830 }
3831 else if (delta > 0x7fff)
3832 {
3833 set = 0x7fff;
3834 delta -= 0x7fff;
3835 }
3836 else
3837 {
3838 set = delta;
3839 delta = 0;
3840 }
3841 *bufptr++ = set >> 8;
3842 *bufptr++ = set & 0xffff;
3843 c += 3;
3844 }
3845 }
3846
3847 /* Finish adjusting the count. */
3848 while (count > 0)
3849 {
3850 if (bufptr >= *bufend)
3851 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1);
3852 /* 1 is added to each count read. */
3853 --count;
3854 if (count > 0x0f)
3855 {
3856 *bufptr++ = 0x0f;
3857 count -= 0x0f;
3858 }
3859 else
3860 {
3861 *bufptr++ = count;
3862 count = 0;
3863 }
3864 ++c;
3865 }
3866
3867 ++iline;
3868 last = l;
3869 }
3870
3871 if (proc != (proc_t *) NULL)
3872 proc->pdr.lnHigh = last->lineno;
3873 if (file != (efdr_t *) NULL)
3874 {
3875 file->fdr.cbLine = c - file->fdr.cbLineOffset;
3876 file->fdr.cline = totcount;
3877 }
3878
3879 if (linecntptr != (long *) NULL)
3880 *linecntptr += totcount;
3881
3882 c = ecoff_padding_adjust (backend, buf, bufend, c, &bufptr);
3883
3884 return c;
3885 }
3886
3887 /* Build and swap out the symbols. */
3888
3889 static unsigned long
3890 ecoff_build_symbols (backend, buf, bufend, offset)
3891 const struct ecoff_debug_swap *backend;
3892 char **buf;
3893 char **bufend;
3894 unsigned long offset;
3895 {
3896 const bfd_size_type external_sym_size = backend->external_sym_size;
3897 void (* const swap_sym_out) PARAMS ((bfd *, const SYMR *, PTR))
3898 = backend->swap_sym_out;
3899 char *sym_out;
3900 long isym;
3901 vlinks_t *file_link;
3902
3903 sym_out = *buf + offset;
3904
3905 isym = 0;
3906
3907 /* The symbols are stored by file. */
3908 for (file_link = file_desc.first;
3909 file_link != (vlinks_t *) NULL;
3910 file_link = file_link->next)
3911 {
3912 int ifilesym;
3913 int fil_cnt;
3914 efdr_t *fil_ptr;
3915 efdr_t *fil_end;
3916
3917 if (file_link->next == (vlinks_t *) NULL)
3918 fil_cnt = file_desc.objects_last_page;
3919 else
3920 fil_cnt = file_desc.objects_per_page;
3921 fil_ptr = file_link->datum->file;
3922 fil_end = fil_ptr + fil_cnt;
3923 for (; fil_ptr < fil_end; fil_ptr++)
3924 {
3925 vlinks_t *sym_link;
3926
3927 fil_ptr->fdr.isymBase = isym;
3928 ifilesym = isym;
3929 for (sym_link = fil_ptr->symbols.first;
3930 sym_link != (vlinks_t *) NULL;
3931 sym_link = sym_link->next)
3932 {
3933 int sym_cnt;
3934 localsym_t *sym_ptr;
3935 localsym_t *sym_end;
3936
3937 if (sym_link->next == (vlinks_t *) NULL)
3938 sym_cnt = fil_ptr->symbols.objects_last_page;
3939 else
3940 sym_cnt = fil_ptr->symbols.objects_per_page;
3941 sym_ptr = sym_link->datum->sym;
3942 sym_end = sym_ptr + sym_cnt;
3943 for (; sym_ptr < sym_end; sym_ptr++)
3944 {
3945 int local;
3946 symbolS *as_sym;
3947 forward_t *f;
3948
3949 know (sym_ptr->file_ptr == fil_ptr);
3950
3951 /* If there is no associated gas symbol, then this
3952 is a pure debugging symbol. We have already
3953 added the name (if any) to fil_ptr->strings.
3954 Otherwise we must decide whether this is an
3955 external or a local symbol (actually, it may be
3956 both if the local provides additional debugging
3957 information for the external). */
3958 local = 1;
3959 as_sym = sym_ptr->as_sym;
3960 if (as_sym != (symbolS *) NULL)
3961 {
3962 symint_t indx;
3963
3964 /* The value of a block start symbol is the
3965 offset from the start of the procedure. For
3966 other symbols we just use the gas value (but
3967 we must offset it by the vma of the section,
3968 just as BFD does, because BFD will not see
3969 this value). */
3970 if (sym_ptr->ecoff_sym.asym.st == (int) st_Block
3971 && sym_ptr->ecoff_sym.asym.sc == (int) sc_Text)
3972 {
3973 symbolS *begin_sym;
3974
3975 know (sym_ptr->proc_ptr != (proc_t *) NULL);
3976 begin_sym = sym_ptr->proc_ptr->sym->as_sym;
3977 if (S_GET_SEGMENT (as_sym)
3978 != S_GET_SEGMENT (begin_sym))
3979 as_warn (".begin/.bend in different segments");
3980 sym_ptr->ecoff_sym.asym.value =
3981 S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym);
3982 }
3983 else
3984 sym_ptr->ecoff_sym.asym.value =
3985 (S_GET_VALUE (as_sym)
3986 + bfd_get_section_vma (stdoutput,
3987 S_GET_SEGMENT (as_sym)));
3988
3989 sym_ptr->ecoff_sym.weakext = S_IS_WEAK (as_sym);
3990
3991 /* Set st_Proc to st_StaticProc for local
3992 functions. */
3993 if (sym_ptr->ecoff_sym.asym.st == st_Proc
3994 && S_IS_DEFINED (as_sym)
3995 && ! S_IS_EXTERNAL (as_sym)
3996 && ! S_IS_WEAK (as_sym))
3997 sym_ptr->ecoff_sym.asym.st = st_StaticProc;
3998
3999 /* Get the type and storage class based on where
4000 the symbol actually wound up. Traditionally,
4001 N_LBRAC and N_RBRAC are *not* relocated. */
4002 indx = sym_ptr->ecoff_sym.asym.index;
4003 if (sym_ptr->ecoff_sym.asym.st == st_Nil
4004 && sym_ptr->ecoff_sym.asym.sc == sc_Nil
4005 && (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym)
4006 || ((ECOFF_UNMARK_STAB (indx) != N_LBRAC)
4007 && (ECOFF_UNMARK_STAB (indx) != N_RBRAC))))
4008 {
4009 segT seg;
4010 const char *segname;
4011 st_t st;
4012 sc_t sc;
4013
4014 seg = S_GET_SEGMENT (as_sym);
4015 segname = segment_name (seg);
4016
4017 if (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym)
4018 && (S_IS_EXTERNAL (as_sym)
4019 || S_IS_WEAK (as_sym)
4020 || ! S_IS_DEFINED (as_sym)))
4021 {
4022 if ((as_sym->bsym->flags & BSF_FUNCTION) != 0)
4023 st = st_Proc;
4024 else
4025 st = st_Global;
4026 }
4027 else if (seg == text_section)
4028 st = st_Label;
4029 else
4030 st = st_Static;
4031
4032 if (! S_IS_DEFINED (as_sym))
4033 {
4034 if (as_sym->ecoff_extern_size == 0
4035 || (as_sym->ecoff_extern_size
4036 > bfd_get_gp_size (stdoutput)))
4037 sc = sc_Undefined;
4038 else
4039 {
4040 sc = sc_SUndefined;
4041 sym_ptr->ecoff_sym.asym.value =
4042 as_sym->ecoff_extern_size;
4043 }
4044 }
4045 else if (S_IS_COMMON (as_sym))
4046 {
4047 if (S_GET_VALUE (as_sym) > 0
4048 && (S_GET_VALUE (as_sym)
4049 <= bfd_get_gp_size (stdoutput)))
4050 sc = sc_SCommon;
4051 else
4052 sc = sc_Common;
4053 }
4054 else if (seg == text_section)
4055 sc = sc_Text;
4056 else if (seg == data_section)
4057 sc = sc_Data;
4058 else if (strcmp (segname, ".rdata") == 0
4059 || strcmp (segname, ".rodata") == 0)
4060 sc = sc_RData;
4061 else if (strcmp (segname, ".sdata") == 0)
4062 sc = sc_SData;
4063 else if (seg == bss_section)
4064 sc = sc_Bss;
4065 else if (strcmp (segname, ".sbss") == 0)
4066 sc = sc_SBss;
4067 else if (seg == &bfd_abs_section)
4068 sc = sc_Abs;
4069 else
4070 {
4071 /* This must be a user named section.
4072 This is not possible in ECOFF, but it
4073 is in ELF. */
4074 sc = sc_Data;
4075 }
4076
4077 sym_ptr->ecoff_sym.asym.st = (int) st;
4078 sym_ptr->ecoff_sym.asym.sc = (int) sc;
4079 }
4080
4081 /* This is just an external symbol if it is
4082 outside a procedure and it has a type.
4083 FIXME: g++ will generate symbols which have
4084 different names in the debugging information
4085 than the actual symbol. Should we handle
4086 them here? */
4087 if ((S_IS_EXTERNAL (as_sym)
4088 || S_IS_WEAK (as_sym)
4089 || ! S_IS_DEFINED (as_sym))
4090 && sym_ptr->proc_ptr == (proc_t *) NULL
4091 && sym_ptr->ecoff_sym.asym.st != (int) st_Nil
4092 && ! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym))
4093 local = 0;
4094
4095 /* If an st_end symbol has an associated gas
4096 symbol, then it is a local label created for
4097 a .bend or .end directive. Stabs line
4098 numbers will have \001 in the names. */
4099 if (local
4100 && sym_ptr->ecoff_sym.asym.st != st_End
4101 && strchr (sym_ptr->name, '\001') == 0)
4102 sym_ptr->ecoff_sym.asym.iss =
4103 add_string (&fil_ptr->strings,
4104 fil_ptr->str_hash,
4105 sym_ptr->name,
4106 (shash_t **) NULL);
4107 }
4108
4109 /* We now know the index of this symbol; fill in
4110 locations that have been waiting for that
4111 information. */
4112 if (sym_ptr->begin_ptr != (localsym_t *) NULL)
4113 {
4114 localsym_t *begin_ptr;
4115 st_t begin_type;
4116
4117 know (local);
4118 begin_ptr = sym_ptr->begin_ptr;
4119 know (begin_ptr->sym_index != -1);
4120 sym_ptr->ecoff_sym.asym.index = begin_ptr->sym_index;
4121 if (sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
4122 sym_ptr->ecoff_sym.asym.iss =
4123 begin_ptr->ecoff_sym.asym.iss;
4124
4125 begin_type = begin_ptr->ecoff_sym.asym.st;
4126 if (begin_type == st_File
4127 || begin_type == st_Block)
4128 {
4129 begin_ptr->ecoff_sym.asym.index =
4130 isym - ifilesym + 1;
4131 (*swap_sym_out) (stdoutput,
4132 &begin_ptr->ecoff_sym.asym,
4133 (*buf
4134 + offset
4135 + (begin_ptr->sym_index
4136 * external_sym_size)));
4137 }
4138 else
4139 {
4140 know (begin_ptr->index_ptr != (aux_t *) NULL);
4141 begin_ptr->index_ptr->data.isym =
4142 isym - ifilesym + 1;
4143 }
4144
4145 /* The value of the symbol marking the end of a
4146 procedure is the size of the procedure. The
4147 value of the symbol marking the end of a
4148 block is the offset from the start of the
4149 procedure to the block. */
4150 if (begin_type == st_Proc
4151 || begin_type == st_StaticProc)
4152 {
4153 know (as_sym != (symbolS *) NULL);
4154 know (begin_ptr->as_sym != (symbolS *) NULL);
4155 if (S_GET_SEGMENT (as_sym)
4156 != S_GET_SEGMENT (begin_ptr->as_sym))
4157 as_warn (".begin/.bend in different segments");
4158 sym_ptr->ecoff_sym.asym.value =
4159 (S_GET_VALUE (as_sym)
4160 - S_GET_VALUE (begin_ptr->as_sym));
4161 }
4162 else if (begin_type == st_Block
4163 && sym_ptr->ecoff_sym.asym.sc != (int) sc_Info)
4164 {
4165 symbolS *begin_sym;
4166
4167 know (as_sym != (symbolS *) NULL);
4168 know (sym_ptr->proc_ptr != (proc_t *) NULL);
4169 begin_sym = sym_ptr->proc_ptr->sym->as_sym;
4170 if (S_GET_SEGMENT (as_sym)
4171 != S_GET_SEGMENT (begin_sym))
4172 as_warn (".begin/.bend in different segments");
4173 sym_ptr->ecoff_sym.asym.value =
4174 S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym);
4175 }
4176 }
4177
4178 for (f = sym_ptr->forward_ref;
4179 f != (forward_t *) NULL;
4180 f = f->next)
4181 {
4182 know (local);
4183 f->ifd_ptr->data.isym = fil_ptr->file_index;
4184 f->index_ptr->data.rndx.index = isym - ifilesym;
4185 }
4186
4187 if (local)
4188 {
4189 if (*bufend - sym_out < external_sym_size)
4190 sym_out = ecoff_add_bytes (buf, bufend,
4191 sym_out,
4192 external_sym_size);
4193 (*swap_sym_out) (stdoutput, &sym_ptr->ecoff_sym.asym,
4194 sym_out);
4195 sym_out += external_sym_size;
4196
4197 sym_ptr->sym_index = isym;
4198
4199 if (sym_ptr->proc_ptr != (proc_t *) NULL
4200 && sym_ptr->proc_ptr->sym == sym_ptr)
4201 sym_ptr->proc_ptr->pdr.isym = isym - ifilesym;
4202
4203 ++isym;
4204 }
4205
4206 /* Record the local symbol index and file number in
4207 case this is an external symbol. Note that this
4208 destroys the asym.index field. */
4209 if (as_sym != (symbolS *) NULL
4210 && as_sym->ecoff_symbol == sym_ptr)
4211 {
4212 if ((sym_ptr->ecoff_sym.asym.st == st_Proc
4213 || sym_ptr->ecoff_sym.asym.st == st_StaticProc)
4214 && local)
4215 sym_ptr->ecoff_sym.asym.index = isym - ifilesym - 1;
4216 sym_ptr->ecoff_sym.ifd = fil_ptr->file_index;
4217 }
4218 }
4219 }
4220 fil_ptr->fdr.csym = isym - fil_ptr->fdr.isymBase;
4221 }
4222 }
4223
4224 return offset + isym * external_sym_size;
4225 }
4226
4227 /* Swap out the procedure information. */
4228
4229 static unsigned long
4230 ecoff_build_procs (backend, buf, bufend, offset)
4231 const struct ecoff_debug_swap *backend;
4232 char **buf;
4233 char **bufend;
4234 unsigned long offset;
4235 {
4236 const bfd_size_type external_pdr_size = backend->external_pdr_size;
4237 void (* const swap_pdr_out) PARAMS ((bfd *, const PDR *, PTR))
4238 = backend->swap_pdr_out;
4239 char *pdr_out;
4240 long iproc;
4241 vlinks_t *file_link;
4242
4243 pdr_out = *buf + offset;
4244
4245 iproc = 0;
4246
4247 /* The procedures are stored by file. */
4248 for (file_link = file_desc.first;
4249 file_link != (vlinks_t *) NULL;
4250 file_link = file_link->next)
4251 {
4252 int fil_cnt;
4253 efdr_t *fil_ptr;
4254 efdr_t *fil_end;
4255
4256 if (file_link->next == (vlinks_t *) NULL)
4257 fil_cnt = file_desc.objects_last_page;
4258 else
4259 fil_cnt = file_desc.objects_per_page;
4260 fil_ptr = file_link->datum->file;
4261 fil_end = fil_ptr + fil_cnt;
4262 for (; fil_ptr < fil_end; fil_ptr++)
4263 {
4264 vlinks_t *proc_link;
4265 int first;
4266
4267 fil_ptr->fdr.ipdFirst = iproc;
4268 first = 1;
4269 for (proc_link = fil_ptr->procs.first;
4270 proc_link != (vlinks_t *) NULL;
4271 proc_link = proc_link->next)
4272 {
4273 int prc_cnt;
4274 proc_t *proc_ptr;
4275 proc_t *proc_end;
4276
4277 if (proc_link->next == (vlinks_t *) NULL)
4278 prc_cnt = fil_ptr->procs.objects_last_page;
4279 else
4280 prc_cnt = fil_ptr->procs.objects_per_page;
4281 proc_ptr = proc_link->datum->proc;
4282 proc_end = proc_ptr + prc_cnt;
4283 for (; proc_ptr < proc_end; proc_ptr++)
4284 {
4285 symbolS *adr_sym;
4286 unsigned long adr;
4287
4288 adr_sym = proc_ptr->sym->as_sym;
4289 adr = (S_GET_VALUE (adr_sym)
4290 + bfd_get_section_vma (stdoutput,
4291 S_GET_SEGMENT (adr_sym)));
4292 if (first)
4293 {
4294 /* This code used to force the adr of the very
4295 first fdr to be 0. However, the native tools
4296 don't do that, and I can't remember why it
4297 used to work that way, so I took it out. */
4298 fil_ptr->fdr.adr = adr;
4299 first = 0;
4300 }
4301 proc_ptr->pdr.adr = adr - fil_ptr->fdr.adr;
4302 if (*bufend - pdr_out < external_pdr_size)
4303 pdr_out = ecoff_add_bytes (buf, bufend,
4304 pdr_out,
4305 external_pdr_size);
4306 (*swap_pdr_out) (stdoutput, &proc_ptr->pdr, pdr_out);
4307 pdr_out += external_pdr_size;
4308 ++iproc;
4309 }
4310 }
4311 fil_ptr->fdr.cpd = iproc - fil_ptr->fdr.ipdFirst;
4312 }
4313 }
4314
4315 return offset + iproc * external_pdr_size;
4316 }
4317
4318 /* Swap out the aux information. */
4319
4320 static unsigned long
4321 ecoff_build_aux (backend, buf, bufend, offset)
4322 const struct ecoff_debug_swap *backend;
4323 char **buf;
4324 char **bufend;
4325 unsigned long offset;
4326 {
4327 int bigendian;
4328 union aux_ext *aux_out;
4329 long iaux;
4330 vlinks_t *file_link;
4331
4332 bigendian = stdoutput->xvec->header_byteorder_big_p;
4333
4334 aux_out = (union aux_ext *) (*buf + offset);
4335
4336 iaux = 0;
4337
4338 /* The aux entries are stored by file. */
4339 for (file_link = file_desc.first;
4340 file_link != (vlinks_t *) NULL;
4341 file_link = file_link->next)
4342 {
4343 int fil_cnt;
4344 efdr_t *fil_ptr;
4345 efdr_t *fil_end;
4346
4347 if (file_link->next == (vlinks_t *) NULL)
4348 fil_cnt = file_desc.objects_last_page;
4349 else
4350 fil_cnt = file_desc.objects_per_page;
4351 fil_ptr = file_link->datum->file;
4352 fil_end = fil_ptr + fil_cnt;
4353 for (; fil_ptr < fil_end; fil_ptr++)
4354 {
4355 vlinks_t *aux_link;
4356
4357 fil_ptr->fdr.fBigendian = bigendian;
4358 fil_ptr->fdr.iauxBase = iaux;
4359 for (aux_link = fil_ptr->aux_syms.first;
4360 aux_link != (vlinks_t *) NULL;
4361 aux_link = aux_link->next)
4362 {
4363 int aux_cnt;
4364 aux_t *aux_ptr;
4365 aux_t *aux_end;
4366
4367 if (aux_link->next == (vlinks_t *) NULL)
4368 aux_cnt = fil_ptr->aux_syms.objects_last_page;
4369 else
4370 aux_cnt = fil_ptr->aux_syms.objects_per_page;
4371 aux_ptr = aux_link->datum->aux;
4372 aux_end = aux_ptr + aux_cnt;
4373 for (; aux_ptr < aux_end; aux_ptr++)
4374 {
4375 if (*bufend - (char *) aux_out < sizeof (union aux_ext))
4376 aux_out = ((union aux_ext *)
4377 ecoff_add_bytes (buf, bufend,
4378 (char *) aux_out,
4379 sizeof (union aux_ext)));
4380 switch (aux_ptr->type)
4381 {
4382 case aux_tir:
4383 (*backend->swap_tir_out) (bigendian,
4384 &aux_ptr->data.ti,
4385 &aux_out->a_ti);
4386 break;
4387 case aux_rndx:
4388 (*backend->swap_rndx_out) (bigendian,
4389 &aux_ptr->data.rndx,
4390 &aux_out->a_rndx);
4391 break;
4392 case aux_dnLow:
4393 AUX_PUT_DNLOW (bigendian, aux_ptr->data.dnLow,
4394 aux_out);
4395 break;
4396 case aux_dnHigh:
4397 AUX_PUT_DNHIGH (bigendian, aux_ptr->data.dnHigh,
4398 aux_out);
4399 break;
4400 case aux_isym:
4401 AUX_PUT_ISYM (bigendian, aux_ptr->data.isym,
4402 aux_out);
4403 break;
4404 case aux_iss:
4405 AUX_PUT_ISS (bigendian, aux_ptr->data.iss,
4406 aux_out);
4407 break;
4408 case aux_width:
4409 AUX_PUT_WIDTH (bigendian, aux_ptr->data.width,
4410 aux_out);
4411 break;
4412 case aux_count:
4413 AUX_PUT_COUNT (bigendian, aux_ptr->data.count,
4414 aux_out);
4415 break;
4416 }
4417
4418 ++aux_out;
4419 ++iaux;
4420 }
4421 }
4422 fil_ptr->fdr.caux = iaux - fil_ptr->fdr.iauxBase;
4423 }
4424 }
4425
4426 return ecoff_padding_adjust (backend, buf, bufend,
4427 offset + iaux * sizeof (union aux_ext),
4428 (char **) NULL);
4429 }
4430
4431 /* Copy out the strings from a varray_t. This returns the number of
4432 bytes copied, rather than the new offset. */
4433
4434 static unsigned long
4435 ecoff_build_strings (buf, bufend, offset, vp)
4436 char **buf;
4437 char **bufend;
4438 unsigned long offset;
4439 varray_t *vp;
4440 {
4441 unsigned long istr;
4442 char *str_out;
4443 vlinks_t *str_link;
4444
4445 str_out = *buf + offset;
4446
4447 istr = 0;
4448
4449 for (str_link = vp->first;
4450 str_link != (vlinks_t *) NULL;
4451 str_link = str_link->next)
4452 {
4453 unsigned long str_cnt;
4454
4455 if (str_link->next == (vlinks_t *) NULL)
4456 str_cnt = vp->objects_last_page;
4457 else
4458 str_cnt = vp->objects_per_page;
4459
4460 if (*bufend - str_out < str_cnt)
4461 str_out = ecoff_add_bytes (buf, bufend, str_out, str_cnt);
4462
4463 memcpy (str_out, str_link->datum->byte, str_cnt);
4464 str_out += str_cnt;
4465 istr += str_cnt;
4466 }
4467
4468 return istr;
4469 }
4470
4471 /* Dump out the local strings. */
4472
4473 static unsigned long
4474 ecoff_build_ss (backend, buf, bufend, offset)
4475 const struct ecoff_debug_swap *backend;
4476 char **buf;
4477 char **bufend;
4478 unsigned long offset;
4479 {
4480 long iss;
4481 vlinks_t *file_link;
4482
4483 iss = 0;
4484
4485 for (file_link = file_desc.first;
4486 file_link != (vlinks_t *) NULL;
4487 file_link = file_link->next)
4488 {
4489 int fil_cnt;
4490 efdr_t *fil_ptr;
4491 efdr_t *fil_end;
4492
4493 if (file_link->next == (vlinks_t *) NULL)
4494 fil_cnt = file_desc.objects_last_page;
4495 else
4496 fil_cnt = file_desc.objects_per_page;
4497 fil_ptr = file_link->datum->file;
4498 fil_end = fil_ptr + fil_cnt;
4499 for (; fil_ptr < fil_end; fil_ptr++)
4500 {
4501 long ss_cnt;
4502
4503 fil_ptr->fdr.issBase = iss;
4504 ss_cnt = ecoff_build_strings (buf, bufend, offset + iss,
4505 &fil_ptr->strings);
4506 fil_ptr->fdr.cbSs = ss_cnt;
4507 iss += ss_cnt;
4508 }
4509 }
4510
4511 return ecoff_padding_adjust (backend, buf, bufend, offset + iss,
4512 (char **) NULL);
4513 }
4514
4515 /* Swap out the file descriptors. */
4516
4517 static unsigned long
4518 ecoff_build_fdr (backend, buf, bufend, offset)
4519 const struct ecoff_debug_swap *backend;
4520 char **buf;
4521 char **bufend;
4522 unsigned long offset;
4523 {
4524 const bfd_size_type external_fdr_size = backend->external_fdr_size;
4525 void (* const swap_fdr_out) PARAMS ((bfd *, const FDR *, PTR))
4526 = backend->swap_fdr_out;
4527 long ifile;
4528 char *fdr_out;
4529 vlinks_t *file_link;
4530
4531 ifile = 0;
4532
4533 fdr_out = *buf + offset;
4534
4535 for (file_link = file_desc.first;
4536 file_link != (vlinks_t *) NULL;
4537 file_link = file_link->next)
4538 {
4539 int fil_cnt;
4540 efdr_t *fil_ptr;
4541 efdr_t *fil_end;
4542
4543 if (file_link->next == (vlinks_t *) NULL)
4544 fil_cnt = file_desc.objects_last_page;
4545 else
4546 fil_cnt = file_desc.objects_per_page;
4547 fil_ptr = file_link->datum->file;
4548 fil_end = fil_ptr + fil_cnt;
4549 for (; fil_ptr < fil_end; fil_ptr++)
4550 {
4551 if (*bufend - fdr_out < external_fdr_size)
4552 fdr_out = ecoff_add_bytes (buf, bufend, fdr_out,
4553 external_fdr_size);
4554 (*swap_fdr_out) (stdoutput, &fil_ptr->fdr, fdr_out);
4555 fdr_out += external_fdr_size;
4556 ++ifile;
4557 }
4558 }
4559
4560 return offset + ifile * external_fdr_size;
4561 }
4562
4563 /* Set up the external symbols. These are supposed to be handled by
4564 the backend. This routine just gets the right information and
4565 calls a backend function to deal with it. */
4566
4567 static void
4568 ecoff_setup_ext ()
4569 {
4570 register symbolS *sym;
4571
4572 for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
4573 {
4574 if (sym->ecoff_symbol == NULL)
4575 continue;
4576
4577 /* If this is a local symbol, then force the fields to zero. */
4578 if (! S_IS_EXTERNAL (sym)
4579 && ! S_IS_WEAK (sym)
4580 && S_IS_DEFINED (sym))
4581 {
4582 sym->ecoff_symbol->ecoff_sym.asym.value = 0;
4583 sym->ecoff_symbol->ecoff_sym.asym.st = (int) st_Nil;
4584 sym->ecoff_symbol->ecoff_sym.asym.sc = (int) sc_Nil;
4585 sym->ecoff_symbol->ecoff_sym.asym.index = indexNil;
4586 }
4587
4588 obj_ecoff_set_ext (sym, &sym->ecoff_symbol->ecoff_sym);
4589 }
4590 }
4591
4592 /* Build the ECOFF debugging information. */
4593
4594 unsigned long
4595 ecoff_build_debug (hdr, bufp, backend)
4596 HDRR *hdr;
4597 char **bufp;
4598 const struct ecoff_debug_swap *backend;
4599 {
4600 const bfd_size_type external_pdr_size = backend->external_pdr_size;
4601 tag_t *ptag;
4602 tag_t *ptag_next;
4603 efdr_t *fil_ptr;
4604 int end_warning;
4605 efdr_t *hold_file_ptr;
4606 proc_t * hold_proc_ptr;
4607 symbolS *sym;
4608 char *buf;
4609 char *bufend;
4610 unsigned long offset;
4611
4612 /* Make sure we have a file. */
4613 if (first_file == (efdr_t *) NULL)
4614 add_file ((const char *) NULL, 0, 1);
4615
4616 /* Handle any top level tags. */
4617 for (ptag = top_tag_head->first_tag;
4618 ptag != (tag_t *) NULL;
4619 ptag = ptag_next)
4620 {
4621 if (ptag->forward_ref != (forward_t *) NULL)
4622 add_unknown_tag (ptag);
4623
4624 ptag_next = ptag->same_block;
4625 ptag->hash_ptr->tag_ptr = ptag->same_name;
4626 free_tag (ptag);
4627 }
4628
4629 free_thead (top_tag_head);
4630
4631 /* Look through the symbols. Add debugging information for each
4632 symbol that has not already received it. */
4633 hold_file_ptr = cur_file_ptr;
4634 hold_proc_ptr = cur_proc_ptr;
4635 cur_proc_ptr = (proc_t *) NULL;
4636 for (sym = symbol_rootP; sym != (symbolS *) NULL; sym = symbol_next (sym))
4637 {
4638 if (sym->ecoff_symbol != NULL
4639 || sym->ecoff_file == (efdr_t *) NULL
4640 || (sym->bsym->flags & BSF_SECTION_SYM) != 0)
4641 continue;
4642
4643 cur_file_ptr = sym->ecoff_file;
4644 add_ecoff_symbol ((const char *) NULL, st_Nil, sc_Nil, sym,
4645 S_GET_VALUE (sym), indexNil);
4646 }
4647 cur_proc_ptr = hold_proc_ptr;
4648 cur_file_ptr = hold_file_ptr;
4649
4650 /* Output an ending symbol for all the files. We have to do this
4651 here for the last file, so we may as well do it for all of the
4652 files. */
4653 end_warning = 0;
4654 for (fil_ptr = first_file;
4655 fil_ptr != (efdr_t *) NULL;
4656 fil_ptr = fil_ptr->next_file)
4657 {
4658 cur_file_ptr = fil_ptr;
4659 while (cur_file_ptr->cur_scope != (scope_t *) NULL
4660 && cur_file_ptr->cur_scope->prev != (scope_t *) NULL)
4661 {
4662 cur_file_ptr->cur_scope = cur_file_ptr->cur_scope->prev;
4663 if (! end_warning && ! cur_file_ptr->fake)
4664 {
4665 as_warn ("Missing .end or .bend at end of file");
4666 end_warning = 1;
4667 }
4668 }
4669 if (cur_file_ptr->cur_scope != (scope_t *) NULL)
4670 (void) add_ecoff_symbol ((const char *) NULL,
4671 st_End, sc_Text,
4672 (symbolS *) NULL,
4673 (symint_t) 0,
4674 (symint_t) 0);
4675 }
4676
4677 /* Build the symbolic information. */
4678 offset = 0;
4679 buf = xmalloc (PAGE_SIZE);
4680 bufend = buf + PAGE_SIZE;
4681
4682 /* Build the line number information. */
4683 hdr->cbLineOffset = offset;
4684 offset = ecoff_build_lineno (backend, &buf, &bufend, offset,
4685 &hdr->ilineMax);
4686 hdr->cbLine = offset - hdr->cbLineOffset;
4687
4688 /* We don't use dense numbers at all. */
4689 hdr->idnMax = 0;
4690 hdr->cbDnOffset = 0;
4691
4692 /* We can't build the PDR table until we have built the symbols,
4693 because a PDR contains a symbol index. However, we set aside
4694 space at this point. */
4695 hdr->ipdMax = proc_cnt;
4696 hdr->cbPdOffset = offset;
4697 if (bufend - (buf + offset) < proc_cnt * external_pdr_size)
4698 (void) ecoff_add_bytes (&buf, &bufend, buf + offset,
4699 proc_cnt * external_pdr_size);
4700 offset += proc_cnt * external_pdr_size;
4701
4702 /* Build the local symbols. */
4703 hdr->cbSymOffset = offset;
4704 offset = ecoff_build_symbols (backend, &buf, &bufend, offset);
4705 hdr->isymMax = (offset - hdr->cbSymOffset) / backend->external_sym_size;
4706
4707 /* Building the symbols initializes the symbol index in the PDR's.
4708 Now we can swap out the PDR's. */
4709 (void) ecoff_build_procs (backend, &buf, &bufend, hdr->cbPdOffset);
4710
4711 /* We don't use optimization symbols. */
4712 hdr->ioptMax = 0;
4713 hdr->cbOptOffset = 0;
4714
4715 /* Swap out the auxiliary type information. */
4716 hdr->cbAuxOffset = offset;
4717 offset = ecoff_build_aux (backend, &buf, &bufend, offset);
4718 hdr->iauxMax = (offset - hdr->cbAuxOffset) / sizeof (union aux_ext);
4719
4720 /* Copy out the local strings. */
4721 hdr->cbSsOffset = offset;
4722 offset = ecoff_build_ss (backend, &buf, &bufend, offset);
4723 hdr->issMax = offset - hdr->cbSsOffset;
4724
4725 /* We don't use relative file descriptors. */
4726 hdr->crfd = 0;
4727 hdr->cbRfdOffset = 0;
4728
4729 /* Swap out the file descriptors. */
4730 hdr->cbFdOffset = offset;
4731 offset = ecoff_build_fdr (backend, &buf, &bufend, offset);
4732 hdr->ifdMax = (offset - hdr->cbFdOffset) / backend->external_fdr_size;
4733
4734 /* Set up the external symbols, which are handled by the BFD back
4735 end. */
4736 hdr->issExtMax = 0;
4737 hdr->cbSsExtOffset = 0;
4738 hdr->iextMax = 0;
4739 hdr->cbExtOffset = 0;
4740 ecoff_setup_ext ();
4741
4742 know ((offset & (backend->debug_align - 1)) == 0);
4743
4744 /* FIXME: This value should be determined from the .verstamp directive,
4745 with reasonable defaults in config files. */
4746 #ifdef TC_ALPHA
4747 hdr->vstamp = 0x030b;
4748 #else
4749 hdr->vstamp = 0x020b;
4750 #endif
4751
4752 *bufp = buf;
4753 return offset;
4754 }
4755 \f
4756 /* Allocate a cluster of pages. */
4757
4758 #ifndef MALLOC_CHECK
4759
4760 static page_t *
4761 allocate_cluster (npages)
4762 unsigned long npages;
4763 {
4764 register page_t *value = (page_t *) xmalloc (npages * PAGE_USIZE);
4765
4766 #ifdef ECOFF_DEBUG
4767 if (debug > 3)
4768 fprintf (stderr, "\talloc\tnpages = %d, value = 0x%.8x\n", npages, value);
4769 #endif
4770
4771 memset (value, 0, npages * PAGE_USIZE);
4772
4773 return value;
4774 }
4775
4776
4777 static page_t *cluster_ptr = NULL;
4778 static unsigned long pages_left = 0;
4779
4780 #endif /* MALLOC_CHECK */
4781
4782 /* Allocate one page (which is initialized to 0). */
4783
4784 static page_t *
4785 allocate_page ()
4786 {
4787 #ifndef MALLOC_CHECK
4788
4789 if (pages_left == 0)
4790 {
4791 pages_left = MAX_CLUSTER_PAGES;
4792 cluster_ptr = allocate_cluster (pages_left);
4793 }
4794
4795 pages_left--;
4796 return cluster_ptr++;
4797
4798 #else /* MALLOC_CHECK */
4799
4800 page_t *ptr;
4801
4802 ptr = xmalloc (PAGE_USIZE);
4803 memset (ptr, 0, PAGE_USIZE);
4804 return ptr;
4805
4806 #endif /* MALLOC_CHECK */
4807 }
4808 \f
4809 /* Allocate scoping information. */
4810
4811 static scope_t *
4812 allocate_scope ()
4813 {
4814 register scope_t *ptr;
4815 static scope_t initial_scope;
4816
4817 #ifndef MALLOC_CHECK
4818
4819 ptr = alloc_counts[(int)alloc_type_scope].free_list.f_scope;
4820 if (ptr != (scope_t *) NULL)
4821 alloc_counts[ (int)alloc_type_scope ].free_list.f_scope = ptr->free;
4822 else
4823 {
4824 register int unallocated = alloc_counts[(int)alloc_type_scope].unallocated;
4825 register page_t *cur_page = alloc_counts[(int)alloc_type_scope].cur_page;
4826
4827 if (unallocated == 0)
4828 {
4829 unallocated = PAGE_SIZE / sizeof (scope_t);
4830 alloc_counts[(int)alloc_type_scope].cur_page = cur_page = allocate_page ();
4831 alloc_counts[(int)alloc_type_scope].total_pages++;
4832 }
4833
4834 ptr = &cur_page->scope[--unallocated];
4835 alloc_counts[(int)alloc_type_scope].unallocated = unallocated;
4836 }
4837
4838 #else
4839
4840 ptr = (scope_t *) xmalloc (sizeof (scope_t));
4841
4842 #endif
4843
4844 alloc_counts[(int)alloc_type_scope].total_alloc++;
4845 *ptr = initial_scope;
4846 return ptr;
4847 }
4848
4849 /* Free scoping information. */
4850
4851 static void
4852 free_scope (ptr)
4853 scope_t *ptr;
4854 {
4855 alloc_counts[(int)alloc_type_scope].total_free++;
4856
4857 #ifndef MALLOC_CHECK
4858 ptr->free = alloc_counts[(int)alloc_type_scope].free_list.f_scope;
4859 alloc_counts[(int)alloc_type_scope].free_list.f_scope = ptr;
4860 #else
4861 free ((PTR) ptr);
4862 #endif
4863 }
4864 \f
4865 /* Allocate links for pages in a virtual array. */
4866
4867 static vlinks_t *
4868 allocate_vlinks ()
4869 {
4870 register vlinks_t *ptr;
4871 static vlinks_t initial_vlinks;
4872
4873 #ifndef MALLOC_CHECK
4874
4875 register int unallocated = alloc_counts[(int)alloc_type_vlinks].unallocated;
4876 register page_t *cur_page = alloc_counts[(int)alloc_type_vlinks].cur_page;
4877
4878 if (unallocated == 0)
4879 {
4880 unallocated = PAGE_SIZE / sizeof (vlinks_t);
4881 alloc_counts[(int)alloc_type_vlinks].cur_page = cur_page = allocate_page ();
4882 alloc_counts[(int)alloc_type_vlinks].total_pages++;
4883 }
4884
4885 ptr = &cur_page->vlinks[--unallocated];
4886 alloc_counts[(int)alloc_type_vlinks].unallocated = unallocated;
4887
4888 #else
4889
4890 ptr = (vlinks_t *) xmalloc (sizeof (vlinks_t));
4891
4892 #endif
4893
4894 alloc_counts[(int)alloc_type_vlinks].total_alloc++;
4895 *ptr = initial_vlinks;
4896 return ptr;
4897 }
4898 \f
4899 /* Allocate string hash buckets. */
4900
4901 static shash_t *
4902 allocate_shash ()
4903 {
4904 register shash_t *ptr;
4905 static shash_t initial_shash;
4906
4907 #ifndef MALLOC_CHECK
4908
4909 register int unallocated = alloc_counts[(int)alloc_type_shash].unallocated;
4910 register page_t *cur_page = alloc_counts[(int)alloc_type_shash].cur_page;
4911
4912 if (unallocated == 0)
4913 {
4914 unallocated = PAGE_SIZE / sizeof (shash_t);
4915 alloc_counts[(int)alloc_type_shash].cur_page = cur_page = allocate_page ();
4916 alloc_counts[(int)alloc_type_shash].total_pages++;
4917 }
4918
4919 ptr = &cur_page->shash[--unallocated];
4920 alloc_counts[(int)alloc_type_shash].unallocated = unallocated;
4921
4922 #else
4923
4924 ptr = (shash_t *) xmalloc (sizeof (shash_t));
4925
4926 #endif
4927
4928 alloc_counts[(int)alloc_type_shash].total_alloc++;
4929 *ptr = initial_shash;
4930 return ptr;
4931 }
4932 \f
4933 /* Allocate type hash buckets. */
4934
4935 static thash_t *
4936 allocate_thash ()
4937 {
4938 register thash_t *ptr;
4939 static thash_t initial_thash;
4940
4941 #ifndef MALLOC_CHECK
4942
4943 register int unallocated = alloc_counts[(int)alloc_type_thash].unallocated;
4944 register page_t *cur_page = alloc_counts[(int)alloc_type_thash].cur_page;
4945
4946 if (unallocated == 0)
4947 {
4948 unallocated = PAGE_SIZE / sizeof (thash_t);
4949 alloc_counts[(int)alloc_type_thash].cur_page = cur_page = allocate_page ();
4950 alloc_counts[(int)alloc_type_thash].total_pages++;
4951 }
4952
4953 ptr = &cur_page->thash[--unallocated];
4954 alloc_counts[(int)alloc_type_thash].unallocated = unallocated;
4955
4956 #else
4957
4958 ptr = (thash_t *) xmalloc (sizeof (thash_t));
4959
4960 #endif
4961
4962 alloc_counts[(int)alloc_type_thash].total_alloc++;
4963 *ptr = initial_thash;
4964 return ptr;
4965 }
4966 \f
4967 /* Allocate structure, union, or enum tag information. */
4968
4969 static tag_t *
4970 allocate_tag ()
4971 {
4972 register tag_t *ptr;
4973 static tag_t initial_tag;
4974
4975 #ifndef MALLOC_CHECK
4976
4977 ptr = alloc_counts[(int)alloc_type_tag].free_list.f_tag;
4978 if (ptr != (tag_t *) NULL)
4979 alloc_counts[(int)alloc_type_tag].free_list.f_tag = ptr->free;
4980 else
4981 {
4982 register int unallocated = alloc_counts[(int)alloc_type_tag].unallocated;
4983 register page_t *cur_page = alloc_counts[(int)alloc_type_tag].cur_page;
4984
4985 if (unallocated == 0)
4986 {
4987 unallocated = PAGE_SIZE / sizeof (tag_t);
4988 alloc_counts[(int)alloc_type_tag].cur_page = cur_page = allocate_page ();
4989 alloc_counts[(int)alloc_type_tag].total_pages++;
4990 }
4991
4992 ptr = &cur_page->tag[--unallocated];
4993 alloc_counts[(int)alloc_type_tag].unallocated = unallocated;
4994 }
4995
4996 #else
4997
4998 ptr = (tag_t *) xmalloc (sizeof (tag_t));
4999
5000 #endif
5001
5002 alloc_counts[(int)alloc_type_tag].total_alloc++;
5003 *ptr = initial_tag;
5004 return ptr;
5005 }
5006
5007 /* Free scoping information. */
5008
5009 static void
5010 free_tag (ptr)
5011 tag_t *ptr;
5012 {
5013 alloc_counts[(int)alloc_type_tag].total_free++;
5014
5015 #ifndef MALLOC_CHECK
5016 ptr->free = alloc_counts[(int)alloc_type_tag].free_list.f_tag;
5017 alloc_counts[(int)alloc_type_tag].free_list.f_tag = ptr;
5018 #else
5019 free ((PTR_T) ptr);
5020 #endif
5021 }
5022 \f
5023 /* Allocate forward reference to a yet unknown tag. */
5024
5025 static forward_t *
5026 allocate_forward ()
5027 {
5028 register forward_t *ptr;
5029 static forward_t initial_forward;
5030
5031 #ifndef MALLOC_CHECK
5032
5033 register int unallocated = alloc_counts[(int)alloc_type_forward].unallocated;
5034 register page_t *cur_page = alloc_counts[(int)alloc_type_forward].cur_page;
5035
5036 if (unallocated == 0)
5037 {
5038 unallocated = PAGE_SIZE / sizeof (forward_t);
5039 alloc_counts[(int)alloc_type_forward].cur_page = cur_page = allocate_page ();
5040 alloc_counts[(int)alloc_type_forward].total_pages++;
5041 }
5042
5043 ptr = &cur_page->forward[--unallocated];
5044 alloc_counts[(int)alloc_type_forward].unallocated = unallocated;
5045
5046 #else
5047
5048 ptr = (forward_t *) xmalloc (sizeof (forward_t));
5049
5050 #endif
5051
5052 alloc_counts[(int)alloc_type_forward].total_alloc++;
5053 *ptr = initial_forward;
5054 return ptr;
5055 }
5056 \f
5057 /* Allocate head of type hash list. */
5058
5059 static thead_t *
5060 allocate_thead ()
5061 {
5062 register thead_t *ptr;
5063 static thead_t initial_thead;
5064
5065 #ifndef MALLOC_CHECK
5066
5067 ptr = alloc_counts[(int)alloc_type_thead].free_list.f_thead;
5068 if (ptr != (thead_t *) NULL)
5069 alloc_counts[ (int)alloc_type_thead ].free_list.f_thead = ptr->free;
5070 else
5071 {
5072 register int unallocated = alloc_counts[(int)alloc_type_thead].unallocated;
5073 register page_t *cur_page = alloc_counts[(int)alloc_type_thead].cur_page;
5074
5075 if (unallocated == 0)
5076 {
5077 unallocated = PAGE_SIZE / sizeof (thead_t);
5078 alloc_counts[(int)alloc_type_thead].cur_page = cur_page = allocate_page ();
5079 alloc_counts[(int)alloc_type_thead].total_pages++;
5080 }
5081
5082 ptr = &cur_page->thead[--unallocated];
5083 alloc_counts[(int)alloc_type_thead].unallocated = unallocated;
5084 }
5085
5086 #else
5087
5088 ptr = (thead_t *) xmalloc (sizeof (thead_t));
5089
5090 #endif
5091
5092 alloc_counts[(int)alloc_type_thead].total_alloc++;
5093 *ptr = initial_thead;
5094 return ptr;
5095 }
5096
5097 /* Free scoping information. */
5098
5099 static void
5100 free_thead (ptr)
5101 thead_t *ptr;
5102 {
5103 alloc_counts[(int)alloc_type_thead].total_free++;
5104
5105 #ifndef MALLOC_CHECK
5106 ptr->free = (thead_t *) alloc_counts[(int)alloc_type_thead].free_list.f_thead;
5107 alloc_counts[(int)alloc_type_thead].free_list.f_thead = ptr;
5108 #else
5109 free ((PTR_T) ptr);
5110 #endif
5111 }
5112 \f
5113 static lineno_list_t *
5114 allocate_lineno_list ()
5115 {
5116 register lineno_list_t *ptr;
5117 static lineno_list_t initial_lineno_list;
5118
5119 #ifndef MALLOC_CHECK
5120
5121 register int unallocated = alloc_counts[(int)alloc_type_lineno].unallocated;
5122 register page_t *cur_page = alloc_counts[(int)alloc_type_lineno].cur_page;
5123
5124 if (unallocated == 0)
5125 {
5126 unallocated = PAGE_SIZE / sizeof (lineno_list_t);
5127 alloc_counts[(int)alloc_type_lineno].cur_page = cur_page = allocate_page ();
5128 alloc_counts[(int)alloc_type_lineno].total_pages++;
5129 }
5130
5131 ptr = &cur_page->lineno[--unallocated];
5132 alloc_counts[(int)alloc_type_lineno].unallocated = unallocated;
5133
5134 #else
5135
5136 ptr = (lineno_list_t *) xmalloc (sizeof (lineno_list_t));
5137
5138 #endif
5139
5140 alloc_counts[(int)alloc_type_lineno].total_alloc++;
5141 *ptr = initial_lineno_list;
5142 return ptr;
5143 }
5144
5145 void
5146 ecoff_set_gp_prolog_size (sz)
5147 int sz;
5148 {
5149 if (cur_proc_ptr == 0)
5150 return;
5151
5152 cur_proc_ptr->pdr.gp_prologue = sz;
5153 if (cur_proc_ptr->pdr.gp_prologue != sz)
5154 {
5155 as_warn ("GP prologue size exceeds field size, using 0 instead");
5156 cur_proc_ptr->pdr.gp_prologue = 0;
5157 }
5158
5159 cur_proc_ptr->pdr.gp_used = 1;
5160 }
5161
5162 static void
5163 generate_ecoff_stab (what, string, type, other, desc)
5164 int what;
5165 const char *string;
5166 int type;
5167 int other;
5168 int desc;
5169 {
5170 efdr_t *save_file_ptr = cur_file_ptr;
5171 symbolS *sym;
5172 symint_t value;
5173 st_t st;
5174 sc_t sc;
5175 symint_t indx;
5176 localsym_t *hold = NULL;
5177
5178 /* We don't handle .stabd. */
5179 if (what != 's' && what != 'n')
5180 {
5181 as_bad (".stab%c is not supported", what);
5182 return;
5183 }
5184
5185 /* We ignore the other field. */
5186 if (other != 0)
5187 as_warn (".stab%c: ignoring non-zero other field", what);
5188
5189 /* Make sure we have a current file. */
5190 if (cur_file_ptr == (efdr_t *) NULL)
5191 {
5192 add_file ((const char *) NULL, 0, 1);
5193 save_file_ptr = cur_file_ptr;
5194 }
5195
5196 /* For stabs in ECOFF, the first symbol must be @stabs. This is a
5197 signal to gdb. */
5198 if (stabs_seen == 0)
5199 mark_stabs (0);
5200
5201 /* Line number stabs are handled differently, since they have two
5202 values, the line number and the address of the label. We use the
5203 index field (aka desc) to hold the line number, and the value
5204 field to hold the address. The symbol type is st_Label, which
5205 should be different from the other stabs, so that gdb can
5206 recognize it. */
5207 if (type == N_SLINE)
5208 {
5209 SYMR dummy_symr;
5210
5211 #ifndef NO_LISTING
5212 if (listing)
5213 listing_source_line ((unsigned int) desc);
5214 #endif
5215
5216 dummy_symr.index = desc;
5217 if (dummy_symr.index != desc)
5218 {
5219 as_warn ("Line number (%d) for .stab%c directive cannot fit in index field (20 bits)",
5220 desc, what);
5221 return;
5222 }
5223
5224 sym = symbol_find_or_make ((char *)string);
5225 value = 0;
5226 st = st_Label;
5227 sc = sc_Text;
5228 indx = desc;
5229 }
5230 else
5231 {
5232 #ifndef NO_LISTING
5233 if (listing && (type == N_SO || type == N_SOL))
5234 listing_source_file (string);
5235 #endif
5236
5237 sym = symbol_find_or_make ((char *)string);
5238 sc = sc_Nil;
5239 st = st_Nil;
5240 value = 0;
5241 indx = ECOFF_MARK_STAB (type);
5242 }
5243
5244 /* Don't store the stabs symbol we are creating as the type of the
5245 ECOFF symbol. We want to compute the type of the ECOFF symbol
5246 independently. */
5247 if (sym != (symbolS *) NULL)
5248 hold = sym->ecoff_symbol;
5249
5250 (void) add_ecoff_symbol (string, st, sc, sym, value, indx);
5251
5252 if (sym != (symbolS *) NULL)
5253 sym->ecoff_symbol = hold;
5254
5255 /* Restore normal file type. */
5256 cur_file_ptr = save_file_ptr;
5257 }
5258
5259 int
5260 ecoff_no_current_file ()
5261 {
5262 return cur_file_ptr == (efdr_t *) NULL;
5263 }
5264
5265 void
5266 ecoff_generate_asm_lineno (filename, lineno)
5267 const char *filename;
5268 int lineno;
5269 {
5270 lineno_list_t *list;
5271
5272 /* this potential can cause problem, when we start to see stab half the
5273 way thru the file */
5274 /*
5275 if (stabs_seen)
5276 ecoff_generate_asm_line_stab(filename, lineno);
5277 */
5278
5279 if (current_stabs_filename == (char *)NULL || strcmp (current_stabs_filename, filename))
5280 {
5281 add_file (filename, 0, 1);
5282 generate_asm_lineno = 1;
5283 }
5284
5285 list = allocate_lineno_list ();
5286
5287 list->next = (lineno_list_t *) NULL;
5288 list->file = cur_file_ptr;
5289 list->proc = cur_proc_ptr;
5290 list->frag = frag_now;
5291 list->paddr = frag_now_fix ();
5292 list->lineno = lineno;
5293
5294 /* A .loc directive will sometimes appear before a .ent directive,
5295 which means that cur_proc_ptr will be NULL here. Arrange to
5296 patch this up. */
5297 if (cur_proc_ptr == (proc_t *) NULL)
5298 {
5299 lineno_list_t **pl;
5300
5301 pl = &noproc_lineno;
5302 while (*pl != (lineno_list_t *) NULL)
5303 pl = &(*pl)->next;
5304 *pl = list;
5305 }
5306 else
5307 {
5308 *last_lineno_ptr = list;
5309 last_lineno_ptr = &list->next;
5310 }
5311 }
5312
5313 static int line_label_cnt = 0;
5314 void
5315 ecoff_generate_asm_line_stab (filename, lineno)
5316 char *filename;
5317 int lineno;
5318 {
5319 char *ll;
5320
5321 if (strcmp (current_stabs_filename, filename))
5322 {
5323 add_file (filename, 0, 1);
5324 generate_asm_lineno = 1;
5325 }
5326
5327 line_label_cnt++;
5328 /* generate local label $LMnn */
5329 ll = xmalloc(10);
5330 sprintf(ll, "$LM%d", line_label_cnt);
5331 colon (ll);
5332
5333 /* generate stab for the line */
5334 generate_ecoff_stab ('n', ll, N_SLINE, 0, lineno);
5335
5336 }
5337
5338 #endif /* ECOFF_DEBUGGING */
A mirror of the official binutils-gdb repository