source: trunk/src/binutils/gas/ecoff.c@ 1470

Last change on this file since 1470 was 610, checked in by bird, 22 years ago

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