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