?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
-dA enhancement
[official-gcc.git] / gcc / mips-tfile.c
blobede35689e3fa4dbfbed817f31d8b754d65054eb6
1 /* Update the symbol table (the .T file) in a MIPS object to
2 contain debugging information specified by the GNU compiler
3 in the form of comments (the mips assembler does not support
4 assembly access to debug information).
5 Copyright (C) 1991, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2001,
6 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
7 Free Software Foundation, Inc.
8 Contributed by Michael Meissner (meissner@cygnus.com).
9
10 This file is part of GCC.
11
12 GCC is free software; you can redistribute it and/or modify it under
13 the terms of the GNU General Public License as published by the Free
14 Software Foundation; either version 3, or (at your option) any later
15 version.
16
17 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
18 WARRANTY; without even the implied warranty of MERCHANTABILITY or
19 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with GCC; see the file COPYING3. If not see
24 <http://www.gnu.org/licenses/>. */
25
26 \f
27 /* Here is a brief description of the MIPS ECOFF symbol table. The
28 MIPS symbol table has the following pieces:
29
30 Symbolic Header
31 |
32 +-- Auxiliary Symbols
33 |
34 +-- Dense number table
35 |
36 +-- Optimizer Symbols
37 |
38 +-- External Strings
39 |
40 +-- External Symbols
41 |
42 +-- Relative file descriptors
43 |
44 +-- File table
45 |
46 +-- Procedure table
47 |
48 +-- Line number table
49 |
50 +-- Local Strings
51 |
52 +-- Local Symbols
53
54 The symbolic header points to each of the other tables, and also
55 contains the number of entries. It also contains a magic number
56 and MIPS compiler version number, such as 2.0.
57
58 The auxiliary table is a series of 32 bit integers, that are
59 referenced as needed from the local symbol table. Unlike standard
60 COFF, the aux. information does not follow the symbol that uses
61 it, but rather is a separate table. In theory, this would allow
62 the MIPS compilers to collapse duplicate aux. entries, but I've not
63 noticed this happening with the 1.31 compiler suite. The different
64 types of aux. entries are:
65
66 1) dnLow: Low bound on array dimension.
67
68 2) dnHigh: High bound on array dimension.
69
70 3) isym: Index to the local symbol which is the start of the
71 function for the end of function first aux. entry.
72
73 4) width: Width of structures and bitfields.
74
75 5) count: Count of ranges for variant part.
76
77 6) rndx: A relative index into the symbol table. The relative
78 index field has two parts: rfd which is a pointer into the
79 relative file index table or ST_RFDESCAPE which says the next
80 aux. entry is the file number, and index: which is the pointer
81 into the local symbol within a given file table. This is for
82 things like references to types defined in another file.
83
84 7) Type information: This is like the COFF type bits, except it
85 is 32 bits instead of 16; they still have room to add new
86 basic types; and they can handle more than 6 levels of array,
87 pointer, function, etc. Each type information field contains
88 the following structure members:
89
90 a) fBitfield: a bit that says this is a bitfield, and the
91 size in bits follows as the next aux. entry.
92
93 b) continued: a bit that says the next aux. entry is a
94 continuation of the current type information (in case
95 there are more than 6 levels of array/ptr/function).
96
97 c) bt: an integer containing the base type before adding
98 array, pointer, function, etc. qualifiers. The
99 current base types that I have documentation for are:
100
101 btNil -- undefined
102 btAdr -- address - integer same size as ptr
103 btChar -- character
104 btUChar -- unsigned character
105 btShort -- short
106 btUShort -- unsigned short
107 btInt -- int
108 btUInt -- unsigned int
109 btLong -- long
110 btULong -- unsigned long
111 btFloat -- float (real)
112 btDouble -- Double (real)
113 btStruct -- Structure (Record)
114 btUnion -- Union (variant)
115 btEnum -- Enumerated
116 btTypedef -- defined via a typedef isymRef
117 btRange -- subrange of int
118 btSet -- pascal sets
119 btComplex -- fortran complex
120 btDComplex -- fortran double complex
121 btIndirect -- forward or unnamed typedef
122 btFixedDec -- Fixed Decimal
123 btFloatDec -- Float Decimal
124 btString -- Varying Length Character String
125 btBit -- Aligned Bit String
126 btPicture -- Picture
127 btVoid -- Void (MIPS cc revision >= 2.00)
128
129 d) tq0 - tq5: type qualifier fields as needed. The
130 current type qualifier fields I have documentation for
131 are:
132
133 tqNil -- no more qualifiers
134 tqPtr -- pointer
135 tqProc -- procedure
136 tqArray -- array
137 tqFar -- 8086 far pointers
138 tqVol -- volatile
139
140
141 The dense number table is used in the front ends, and disappears by
142 the time the .o is created.
143
144 With the 1.31 compiler suite, the optimization symbols don't seem
145 to be used as far as I can tell.
146
147 The linker is the first entity that creates the relative file
148 descriptor table, and I believe it is used so that the individual
149 file table pointers don't have to be rewritten when the objects are
150 merged together into the program file.
151
152 Unlike COFF, the basic symbol & string tables are split into
153 external and local symbols/strings. The relocation information
154 only goes off of the external symbol table, and the debug
155 information only goes off of the internal symbol table. The
156 external symbols can have links to an appropriate file index and
157 symbol within the file to give it the appropriate type information.
158 Because of this, the external symbols are actually larger than the
159 internal symbols (to contain the link information), and contain the
160 local symbol structure as a member, though this member is not the
161 first member of the external symbol structure (!). I suspect this
162 split is to make strip easier to deal with.
163
164 Each file table has offsets for where the line numbers, local
165 strings, local symbols, and procedure table starts from within the
166 global tables, and the indices are reset to 0 for each of those
167 tables for the file.
168
169 The procedure table contains the binary equivalents of the .ent
170 (start of the function address), .frame (what register is the
171 virtual frame pointer, constant offset from the register to obtain
172 the VFP, and what register holds the return address), .mask/.fmask
173 (bitmask of saved registers, and where the first register is stored
174 relative to the VFP) assembler directives. It also contains the
175 low and high bounds of the line numbers if debugging is turned on.
176
177 The line number table is a compressed form of the normal COFF line
178 table. Each line number entry is either 1 or 3 bytes long, and
179 contains a signed delta from the previous line, and an unsigned
180 count of the number of instructions this statement takes.
181
182 The local symbol table contains the following fields:
183
184 1) iss: index to the local string table giving the name of the
185 symbol.
186
187 2) value: value of the symbol (address, register number, etc.).
188
189 3) st: symbol type. The current symbol types are:
190
191 stNil -- Nuthin' special
192 stGlobal -- external symbol
193 stStatic -- static
194 stParam -- procedure argument
195 stLocal -- local variable
196 stLabel -- label
197 stProc -- External Procedure
198 stBlock -- beginning of block
199 stEnd -- end (of anything)
200 stMember -- member (of anything)
201 stTypedef -- type definition
202 stFile -- file name
203 stRegReloc -- register relocation
204 stForward -- forwarding address
205 stStaticProc -- Static procedure
206 stConstant -- const
207
208 4) sc: storage class. The current storage classes are:
209
210 scText -- text symbol
211 scData -- initialized data symbol
212 scBss -- un-initialized data symbol
213 scRegister -- value of symbol is register number
214 scAbs -- value of symbol is absolute
215 scUndefined -- who knows?
216 scCdbLocal -- variable's value is IN se->va.??
217 scBits -- this is a bit field
218 scCdbSystem -- value is IN debugger's address space
219 scRegImage -- register value saved on stack
220 scInfo -- symbol contains debugger information
221 scUserStruct -- addr in struct user for current process
222 scSData -- load time only small data
223 scSBss -- load time only small common
224 scRData -- load time only read only data
225 scVar -- Var parameter (fortranpascal)
226 scCommon -- common variable
227 scSCommon -- small common
228 scVarRegister -- Var parameter in a register
229 scVariant -- Variant record
230 scSUndefined -- small undefined(external) data
231 scInit -- .init section symbol
232
233 5) index: pointer to a local symbol or aux. entry.
234
235
236
237 For the following program:
238
239 #include <stdio.h>
240
241 main(){
242 printf("Hello World!\n");
243 return 0;
244 }
245
246 Mips-tdump produces the following information:
247
248 Global file header:
249 magic number 0x162
250 # sections 2
251 timestamp 645311799, Wed Jun 13 17:16:39 1990
252 symbolic header offset 284
253 symbolic header size 96
254 optional header 56
255 flags 0x0
256
257 Symbolic header, magic number = 0x7009, vstamp = 1.31:
258
259 Info Offset Number Bytes
260 ==== ====== ====== =====
261
262 Line numbers 380 4 4 [13]
263 Dense numbers 0 0 0
264 Procedures Tables 384 1 52
265 Local Symbols 436 16 192
266 Optimization Symbols 0 0 0
267 Auxiliary Symbols 628 39 156
268 Local Strings 784 80 80
269 External Strings 864 144 144
270 File Tables 1008 2 144
271 Relative Files 0 0 0
272 External Symbols 1152 20 320
273
274 File #0, "hello2.c"
275
276 Name index = 1 Readin = No
277 Merge = No Endian = LITTLE
278 Debug level = G2 Language = C
279 Adr = 0x00000000
280
281 Info Start Number Size Offset
282 ==== ===== ====== ==== ======
283 Local strings 0 15 15 784
284 Local symbols 0 6 72 436
285 Line numbers 0 13 13 380
286 Optimization symbols 0 0 0 0
287 Procedures 0 1 52 384
288 Auxiliary symbols 0 14 56 628
289 Relative Files 0 0 0 0
290
291 There are 6 local symbols, starting at 436
292
293 Symbol# 0: "hello2.c"
294 End+1 symbol = 6
295 String index = 1
296 Storage class = Text Index = 6
297 Symbol type = File Value = 0
298
299 Symbol# 1: "main"
300 End+1 symbol = 5
301 Type = int
302 String index = 10
303 Storage class = Text Index = 12
304 Symbol type = Proc Value = 0
305
306 Symbol# 2: ""
307 End+1 symbol = 4
308 String index = 0
309 Storage class = Text Index = 4
310 Symbol type = Block Value = 8
311
312 Symbol# 3: ""
313 First symbol = 2
314 String index = 0
315 Storage class = Text Index = 2
316 Symbol type = End Value = 28
317
318 Symbol# 4: "main"
319 First symbol = 1
320 String index = 10
321 Storage class = Text Index = 1
322 Symbol type = End Value = 52
323
324 Symbol# 5: "hello2.c"
325 First symbol = 0
326 String index = 1
327 Storage class = Text Index = 0
328 Symbol type = End Value = 0
329
330 There are 14 auxiliary table entries, starting at 628.
331
332 * #0 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
333 * #1 24, [ 24/ 0], [ 6 0:0 0:0:0:0:0:0]
334 * #2 8, [ 8/ 0], [ 2 0:0 0:0:0:0:0:0]
335 * #3 16, [ 16/ 0], [ 4 0:0 0:0:0:0:0:0]
336 * #4 24, [ 24/ 0], [ 6 0:0 0:0:0:0:0:0]
337 * #5 32, [ 32/ 0], [ 8 0:0 0:0:0:0:0:0]
338 * #6 40, [ 40/ 0], [10 0:0 0:0:0:0:0:0]
339 * #7 44, [ 44/ 0], [11 0:0 0:0:0:0:0:0]
340 * #8 12, [ 12/ 0], [ 3 0:0 0:0:0:0:0:0]
341 * #9 20, [ 20/ 0], [ 5 0:0 0:0:0:0:0:0]
342 * #10 28, [ 28/ 0], [ 7 0:0 0:0:0:0:0:0]
343 * #11 36, [ 36/ 0], [ 9 0:0 0:0:0:0:0:0]
344 #12 5, [ 5/ 0], [ 1 1:0 0:0:0:0:0:0]
345 #13 24, [ 24/ 0], [ 6 0:0 0:0:0:0:0:0]
346
347 There are 1 procedure descriptor entries, starting at 0.
348
349 Procedure descriptor 0:
350 Name index = 10 Name = "main"
351 .mask 0x80000000,-4 .fmask 0x00000000,0
352 .frame $29,24,$31
353 Opt. start = -1 Symbols start = 1
354 First line # = 3 Last line # = 6
355 Line Offset = 0 Address = 0x00000000
356
357 There are 4 bytes holding line numbers, starting at 380.
358 Line 3, delta 0, count 2
359 Line 4, delta 1, count 3
360 Line 5, delta 1, count 2
361 Line 6, delta 1, count 6
362
363 File #1, "/usr/include/stdio.h"
364
365 Name index = 1 Readin = No
366 Merge = Yes Endian = LITTLE
367 Debug level = G2 Language = C
368 Adr = 0x00000000
369
370 Info Start Number Size Offset
371 ==== ===== ====== ==== ======
372 Local strings 15 65 65 799
373 Local symbols 6 10 120 508
374 Line numbers 0 0 0 380
375 Optimization symbols 0 0 0 0
376 Procedures 1 0 0 436
377 Auxiliary symbols 14 25 100 684
378 Relative Files 0 0 0 0
379
380 There are 10 local symbols, starting at 442
381
382 Symbol# 0: "/usr/include/stdio.h"
383 End+1 symbol = 10
384 String index = 1
385 Storage class = Text Index = 10
386 Symbol type = File Value = 0
387
388 Symbol# 1: "_iobuf"
389 End+1 symbol = 9
390 String index = 22
391 Storage class = Info Index = 9
392 Symbol type = Block Value = 20
393
394 Symbol# 2: "_cnt"
395 Type = int
396 String index = 29
397 Storage class = Info Index = 4
398 Symbol type = Member Value = 0
399
400 Symbol# 3: "_ptr"
401 Type = ptr to char
402 String index = 34
403 Storage class = Info Index = 15
404 Symbol type = Member Value = 32
405
406 Symbol# 4: "_base"
407 Type = ptr to char
408 String index = 39
409 Storage class = Info Index = 16
410 Symbol type = Member Value = 64
411
412 Symbol# 5: "_bufsiz"
413 Type = int
414 String index = 45
415 Storage class = Info Index = 4
416 Symbol type = Member Value = 96
417
418 Symbol# 6: "_flag"
419 Type = short
420 String index = 53
421 Storage class = Info Index = 3
422 Symbol type = Member Value = 128
423
424 Symbol# 7: "_file"
425 Type = char
426 String index = 59
427 Storage class = Info Index = 2
428 Symbol type = Member Value = 144
429
430 Symbol# 8: ""
431 First symbol = 1
432 String index = 0
433 Storage class = Info Index = 1
434 Symbol type = End Value = 0
435
436 Symbol# 9: "/usr/include/stdio.h"
437 First symbol = 0
438 String index = 1
439 Storage class = Text Index = 0
440 Symbol type = End Value = 0
441
442 There are 25 auxiliary table entries, starting at 642.
443
444 * #14 -1, [4095/1048575], [63 1:1 f:f:f:f:f:f]
445 #15 65544, [ 8/ 16], [ 2 0:0 1:0:0:0:0:0]
446 #16 65544, [ 8/ 16], [ 2 0:0 1:0:0:0:0:0]
447 * #17 196656, [ 48/ 48], [12 0:0 3:0:0:0:0:0]
448 * #18 8191, [4095/ 1], [63 1:1 0:0:0:0:f:1]
449 * #19 1, [ 1/ 0], [ 0 1:0 0:0:0:0:0:0]
450 * #20 20479, [4095/ 4], [63 1:1 0:0:0:0:f:4]
451 * #21 1, [ 1/ 0], [ 0 1:0 0:0:0:0:0:0]
452 * #22 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
453 * #23 2, [ 2/ 0], [ 0 0:1 0:0:0:0:0:0]
454 * #24 160, [ 160/ 0], [40 0:0 0:0:0:0:0:0]
455 * #25 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
456 * #26 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
457 * #27 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
458 * #28 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
459 * #29 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
460 * #30 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
461 * #31 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
462 * #32 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
463 * #33 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
464 * #34 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
465 * #35 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
466 * #36 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
467 * #37 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
468 * #38 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0]
469
470 There are 0 procedure descriptor entries, starting at 1.
471
472 There are 20 external symbols, starting at 1152
473
474 Symbol# 0: "_iob"
475 Type = array [3 {160}] of struct _iobuf { ifd = 1, index = 1 }
476 String index = 0 Ifd = 1
477 Storage class = Nil Index = 17
478 Symbol type = Global Value = 60
479
480 Symbol# 1: "fopen"
481 String index = 5 Ifd = 1
482 Storage class = Nil Index = 1048575
483 Symbol type = Proc Value = 0
484
485 Symbol# 2: "fdopen"
486 String index = 11 Ifd = 1
487 Storage class = Nil Index = 1048575
488 Symbol type = Proc Value = 0
489
490 Symbol# 3: "freopen"
491 String index = 18 Ifd = 1
492 Storage class = Nil Index = 1048575
493 Symbol type = Proc Value = 0
494
495 Symbol# 4: "popen"
496 String index = 26 Ifd = 1
497 Storage class = Nil Index = 1048575
498 Symbol type = Proc Value = 0
499
500 Symbol# 5: "tmpfile"
501 String index = 32 Ifd = 1
502 Storage class = Nil Index = 1048575
503 Symbol type = Proc Value = 0
504
505 Symbol# 6: "ftell"
506 String index = 40 Ifd = 1
507 Storage class = Nil Index = 1048575
508 Symbol type = Proc Value = 0
509
510 Symbol# 7: "rewind"
511 String index = 46 Ifd = 1
512 Storage class = Nil Index = 1048575
513 Symbol type = Proc Value = 0
514
515 Symbol# 8: "setbuf"
516 String index = 53 Ifd = 1
517 Storage class = Nil Index = 1048575
518 Symbol type = Proc Value = 0
519
520 Symbol# 9: "setbuffer"
521 String index = 60 Ifd = 1
522 Storage class = Nil Index = 1048575
523 Symbol type = Proc Value = 0
524
525 Symbol# 10: "setlinebuf"
526 String index = 70 Ifd = 1
527 Storage class = Nil Index = 1048575
528 Symbol type = Proc Value = 0
529
530 Symbol# 11: "fgets"
531 String index = 81 Ifd = 1
532 Storage class = Nil Index = 1048575
533 Symbol type = Proc Value = 0
534
535 Symbol# 12: "gets"
536 String index = 87 Ifd = 1
537 Storage class = Nil Index = 1048575
538 Symbol type = Proc Value = 0
539
540 Symbol# 13: "ctermid"
541 String index = 92 Ifd = 1
542 Storage class = Nil Index = 1048575
543 Symbol type = Proc Value = 0
544
545 Symbol# 14: "cuserid"
546 String index = 100 Ifd = 1
547 Storage class = Nil Index = 1048575
548 Symbol type = Proc Value = 0
549
550 Symbol# 15: "tempnam"
551 String index = 108 Ifd = 1
552 Storage class = Nil Index = 1048575
553 Symbol type = Proc Value = 0
554
555 Symbol# 16: "tmpnam"
556 String index = 116 Ifd = 1
557 Storage class = Nil Index = 1048575
558 Symbol type = Proc Value = 0
559
560 Symbol# 17: "sprintf"
561 String index = 123 Ifd = 1
562 Storage class = Nil Index = 1048575
563 Symbol type = Proc Value = 0
564
565 Symbol# 18: "main"
566 Type = int
567 String index = 131 Ifd = 0
568 Storage class = Text Index = 1
569 Symbol type = Proc Value = 0
570
571 Symbol# 19: "printf"
572 String index = 136 Ifd = 0
573 Storage class = Undefined Index = 1048575
574 Symbol type = Proc Value = 0
575
576 The following auxiliary table entries were unused:
577
578 #0 0 0x00000000 void
579 #2 8 0x00000008 char
580 #3 16 0x00000010 short
581 #4 24 0x00000018 int
582 #5 32 0x00000020 long
583 #6 40 0x00000028 float
584 #7 44 0x0000002c double
585 #8 12 0x0000000c unsigned char
586 #9 20 0x00000014 unsigned short
587 #10 28 0x0000001c unsigned int
588 #11 36 0x00000024 unsigned long
589 #14 0 0x00000000 void
590 #15 24 0x00000018 int
591 #19 32 0x00000020 long
592 #20 40 0x00000028 float
593 #21 44 0x0000002c double
594 #22 12 0x0000000c unsigned char
595 #23 20 0x00000014 unsigned short
596 #24 28 0x0000001c unsigned int
597 #25 36 0x00000024 unsigned long
598 #26 48 0x00000030 struct no name { ifd = -1, index = 1048575 }
599
600 */
601 \f
602
603 #include "config.h"
604 #include "system.h"
605 #include "coretypes.h"
606 #include "tm.h"
607 #include "version.h"
608 #include "intl.h"
609 #include "filenames.h"
610
611 #ifndef __SABER__
612 #define saber_stop()
613 #endif
614
615 /* Include getopt.h for the sake of getopt_long. */
616 #include "getopt.h"
617
618 #ifndef __LINE__
619 #define __LINE__ 0
620 #endif
621
622 /* Due to size_t being defined in sys/types.h and different
623 in stddef.h, we have to do this by hand..... Note, these
624 types are correct for MIPS based systems, and may not be
625 correct for other systems. Ultrix 4.0 and Silicon Graphics
626 have this fixed, but since the following is correct, and
627 the fact that including stddef.h gets you GCC's version
628 instead of the standard one it's not worth it to fix it. */
629
630 #if defined(__OSF1__) || defined(__OSF__) || defined(__osf__)
631 #define Size_t long unsigned int
632 #else
633 #define Size_t unsigned int
634 #endif
635 #define Ptrdiff_t long
636
637 /* The following might be called from obstack or malloc,
638 so they can't be static. */
639
640 extern void pfatal_with_name (const char *) ATTRIBUTE_NORETURN;
641 extern void botch (const char *) ATTRIBUTE_NORETURN;
642
643 extern void fatal (const char *format, ...) ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN;
644 extern void error (const char *format, ...) ATTRIBUTE_PRINTF_1;
645 \f
646 #ifndef MIPS_DEBUGGING_INFO
647
648 static int line_number;
649 static int cur_line_start;
650 static int debug;
651 static int had_errors;
652 static const char *progname;
653 static const char *input_name;
654
655 int
656 main (void)
657 {
658 fprintf (stderr, "Mips-tfile should only be run on a MIPS computer!\n");
659 exit (1);
660 }
661
662 #else /* MIPS_DEBUGGING defined */
663 \f
664 /* The local and global symbols have a field index, so undo any defines
665 of index -> strchr. */
666
667 #undef index
668
669 #ifndef CROSS_DIRECTORY_STRUCTURE
670 #include <a.out.h>
671 #else
672 #include "mips/a.out.h"
673 #endif /* CROSS_DIRECTORY_STRUCTURE */
674
675 #include "gstab.h"
676
677 #ifndef MALLOC_CHECK
678 #ifdef __SABER__
679 #define MALLOC_CHECK
680 #endif
681 #endif
682
683 #define IS_ASM_IDENT(ch) \
684 (ISIDNUM (ch) || (ch) == '.' || (ch) == '$')
685
686 \f
687 /* Redefinition of storage classes as an enumeration for better
688 debugging. */
689
690 typedef enum sc {
691 sc_Nil = scNil, /* no storage class */
692 sc_Text = scText, /* text symbol */
693 sc_Data = scData, /* initialized data symbol */
694 sc_Bss = scBss, /* un-initialized data symbol */
695 sc_Register = scRegister, /* value of symbol is register number */
696 sc_Abs = scAbs, /* value of symbol is absolute */
697 sc_Undefined = scUndefined, /* who knows? */
698 sc_CdbLocal = scCdbLocal, /* variable's value is IN se->va.?? */
699 sc_Bits = scBits, /* this is a bit field */
700 sc_CdbSystem = scCdbSystem, /* value is IN CDB's address space */
701 sc_RegImage = scRegImage, /* register value saved on stack */
702 sc_Info = scInfo, /* symbol contains debugger information */
703 sc_UserStruct = scUserStruct, /* addr in struct user for current process */
704 sc_SData = scSData, /* load time only small data */
705 sc_SBss = scSBss, /* load time only small common */
706 sc_RData = scRData, /* load time only read only data */
707 sc_Var = scVar, /* Var parameter (fortran,pascal) */
708 sc_Common = scCommon, /* common variable */
709 sc_SCommon = scSCommon, /* small common */
710 sc_VarRegister = scVarRegister, /* Var parameter in a register */
711 sc_Variant = scVariant, /* Variant record */
712 sc_SUndefined = scSUndefined, /* small undefined(external) data */
713 sc_Init = scInit, /* .init section symbol */
714 sc_Max = scMax /* Max storage class+1 */
715 } sc_t;
716
717 /* Redefinition of symbol type. */
718
719 typedef enum st {
720 st_Nil = stNil, /* Nuthin' special */
721 st_Global = stGlobal, /* external symbol */
722 st_Static = stStatic, /* static */
723 st_Param = stParam, /* procedure argument */
724 st_Local = stLocal, /* local variable */
725 st_Label = stLabel, /* label */
726 st_Proc = stProc, /* " " Procedure */
727 st_Block = stBlock, /* beginning of block */
728 st_End = stEnd, /* end (of anything) */
729 st_Member = stMember, /* member (of anything - struct/union/enum */
730 st_Typedef = stTypedef, /* type definition */
731 st_File = stFile, /* file name */
732 st_RegReloc = stRegReloc, /* register relocation */
733 st_Forward = stForward, /* forwarding address */
734 st_StaticProc = stStaticProc, /* load time only static procs */
735 st_Constant = stConstant, /* const */
736 st_Str = stStr, /* string */
737 st_Number = stNumber, /* pure number (i.e. 4 NOR 2+2) */
738 st_Expr = stExpr, /* 2+2 vs. 4 */
739 st_Type = stType, /* post-coercion SER */
740 st_Max = stMax /* max type+1 */
741 } st_t;
742
743 /* Redefinition of type qualifiers. */
744
745 typedef enum tq {
746 tq_Nil = tqNil, /* bt is what you see */
747 tq_Ptr = tqPtr, /* pointer */
748 tq_Proc = tqProc, /* procedure */
749 tq_Array = tqArray, /* duh */
750 tq_Far = tqFar, /* longer addressing - 8086/8 land */
751 tq_Vol = tqVol, /* volatile */
752 tq_Max = tqMax /* Max type qualifier+1 */
753 } tq_t;
754
755 /* Redefinition of basic types. */
756
757 typedef enum bt {
758 bt_Nil = btNil, /* undefined */
759 bt_Adr = btAdr, /* address - integer same size as pointer */
760 bt_Char = btChar, /* character */
761 bt_UChar = btUChar, /* unsigned character */
762 bt_Short = btShort, /* short */
763 bt_UShort = btUShort, /* unsigned short */
764 bt_Int = btInt, /* int */
765 bt_UInt = btUInt, /* unsigned int */
766 bt_Long = btLong, /* long */
767 bt_ULong = btULong, /* unsigned long */
768 bt_Float = btFloat, /* float (real) */
769 bt_Double = btDouble, /* Double (real) */
770 bt_Struct = btStruct, /* Structure (Record) */
771 bt_Union = btUnion, /* Union (variant) */
772 bt_Enum = btEnum, /* Enumerated */
773 bt_Typedef = btTypedef, /* defined via a typedef, isymRef points */
774 bt_Range = btRange, /* subrange of int */
775 bt_Set = btSet, /* pascal sets */
776 bt_Complex = btComplex, /* fortran complex */
777 bt_DComplex = btDComplex, /* fortran double complex */
778 bt_Indirect = btIndirect, /* forward or unnamed typedef */
779 bt_FixedDec = btFixedDec, /* Fixed Decimal */
780 bt_FloatDec = btFloatDec, /* Float Decimal */
781 bt_String = btString, /* Varying Length Character String */
782 bt_Bit = btBit, /* Aligned Bit String */
783 bt_Picture = btPicture, /* Picture */
784
785 #ifdef btVoid
786 bt_Void = btVoid, /* Void */
787 #else
788 #define bt_Void bt_Nil
789 #endif
790
791 bt_Max = btMax /* Max basic type+1 */
792 } bt_t;
793
794 \f
795
796 /* Basic COFF storage classes. */
797 enum coff_storage {
798 C_EFCN = -1,
799 C_NULL = 0,
800 C_AUTO = 1,
801 C_EXT = 2,
802 C_STAT = 3,
803 C_REG = 4,
804 C_EXTDEF = 5,
805 C_LABEL = 6,
806 C_ULABEL = 7,
807 C_MOS = 8,
808 C_ARG = 9,
809 C_STRTAG = 10,
810 C_MOU = 11,
811 C_UNTAG = 12,
812 C_TPDEF = 13,
813 C_USTATIC = 14,
814 C_ENTAG = 15,
815 C_MOE = 16,
816 C_REGPARM = 17,
817 C_FIELD = 18,
818 C_BLOCK = 100,
819 C_FCN = 101,
820 C_EOS = 102,
821 C_FILE = 103,
822 C_LINE = 104,
823 C_ALIAS = 105,
824 C_HIDDEN = 106,
825 C_MAX = 107
826 } coff_storage_t;
827
828 /* Regular COFF fundamental type. */
829 typedef enum coff_type {
830 T_NULL = 0,
831 T_ARG = 1,
832 T_CHAR = 2,
833 T_SHORT = 3,
834 T_INT = 4,
835 T_LONG = 5,
836 T_FLOAT = 6,
837 T_DOUBLE = 7,
838 T_STRUCT = 8,
839 T_UNION = 9,
840 T_ENUM = 10,
841 T_MOE = 11,
842 T_UCHAR = 12,
843 T_USHORT = 13,
844 T_UINT = 14,
845 T_ULONG = 15,
846 T_MAX = 16
847 } coff_type_t;
848
849 /* Regular COFF derived types. */
850 typedef enum coff_dt {
851 DT_NON = 0,
852 DT_PTR = 1,
853 DT_FCN = 2,
854 DT_ARY = 3,
855 DT_MAX = 4
856 } coff_dt_t;
857
858 #define N_BTMASK 017 /* bitmask to isolate basic type */
859 #define N_TMASK 003 /* bitmask to isolate derived type */
860 #define N_BT_SHIFT 4 /* # bits to shift past basic type */
861 #define N_TQ_SHIFT 2 /* # bits to shift derived types */
862 #define N_TQ 6 /* # of type qualifiers */
863
864 /* States for whether to hash type or not. */
865 typedef enum hash_state {
866 hash_no = 0, /* don't hash type */
867 hash_yes = 1, /* ok to hash type, or use previous hash */
868 hash_record = 2 /* ok to record hash, but don't use prev. */
869 } hash_state_t;
870
871
872 /* Types of different sized allocation requests. */
873 enum alloc_type {
874 alloc_type_none, /* dummy value */
875 alloc_type_scope, /* nested scopes linked list */
876 alloc_type_vlinks, /* glue linking pages in varray */
877 alloc_type_shash, /* string hash element */
878 alloc_type_thash, /* type hash element */
879 alloc_type_tag, /* struct/union/tag element */
880 alloc_type_forward, /* element to hold unknown tag */
881 alloc_type_thead, /* head of type hash list */
882 alloc_type_varray, /* general varray allocation */
883 alloc_type_last /* last+1 element for array bounds */
884 };
885
886 \f
887 #define WORD_ALIGN(x) (((x) + (sizeof (long) - 1)) & ~ (sizeof (long) - 1))
888 #define DWORD_ALIGN(x) (((x) + 7) & ~7)
889
890
891 /* Structures to provide n-number of virtual arrays, each of which can
892 grow linearly, and which are written in the object file as sequential
893 pages. On systems with a BSD malloc that define USE_MALLOC, the
894 MAX_CLUSTER_PAGES should be 1 less than a power of two, since malloc
895 adds its overhead, and rounds up to the next power of 2. Pages are
896 linked together via a linked list. */
897
898 #ifndef PAGE_SIZE
899 #define PAGE_SIZE 32768 /* size of varray pages */
900 #endif
901
902 #define PAGE_USIZE ((Size_t) PAGE_SIZE)
903
904
905 #ifndef MAX_CLUSTER_PAGES /* # pages to get from system */
906 #ifndef USE_MALLOC /* in one memory request */
907 #define MAX_CLUSTER_PAGES 64
908 #else
909 #define MAX_CLUSTER_PAGES 63
910 #endif
911 #endif
912
913
914 /* Linked list connecting separate page allocations. */
915 typedef struct vlinks {
916 struct vlinks *prev; /* previous set of pages */
917 struct vlinks *next; /* next set of pages */
918 union page *datum; /* start of page */
919 unsigned long start_index; /* starting index # of page */
920 } vlinks_t;
921
922
923 /* Virtual array header. */
924 typedef struct varray {
925 vlinks_t *first; /* first page link */
926 vlinks_t *last; /* last page link */
927 unsigned long num_allocated; /* # objects allocated */
928 unsigned short object_size; /* size in bytes of each object */
929 unsigned short objects_per_page; /* # objects that can fit on a page */
930 unsigned short objects_last_page; /* # objects allocated on last page */
931 } varray_t;
932
933 #ifndef MALLOC_CHECK
934 #define OBJECTS_PER_PAGE(type) (PAGE_SIZE / sizeof (type))
935 #else
936 #define OBJECTS_PER_PAGE(type) ((sizeof (type) > 1) ? 1 : PAGE_SIZE)
937 #endif
938
939 #define INIT_VARRAY(type) { /* macro to initialize a varray */ \
940 (vlinks_t *) 0, /* first */ \
941 (vlinks_t *) 0, /* last */ \
942 0, /* num_allocated */ \
943 sizeof (type), /* object_size */ \
944 OBJECTS_PER_PAGE (type), /* objects_per_page */ \
945 OBJECTS_PER_PAGE (type), /* objects_last_page */ \
946 }
947
948 #define INITIALIZE_VARRAY(x,type) \
949 do { \
950 (x)->object_size = sizeof (type); \
951 (x)->objects_per_page = OBJECTS_PER_PAGE (type); \
952 (x)->objects_last_page = OBJECTS_PER_PAGE (type); \
953 } while (0)
954
955 /* Master type for indexes within the symbol table. */
956 typedef unsigned long symint_t;
957
958
959 /* Linked list support for nested scopes (file, block, structure, etc.). */
960 typedef struct scope {
961 struct scope *prev; /* previous scope level */
962 struct scope *free; /* free list pointer */
963 SYMR *lsym; /* pointer to local symbol node */
964 symint_t lnumber; /* lsym index */
965 st_t type; /* type of the node */
966 } scope_t;
967
968
969 /* Forward reference list for tags referenced, but not yet defined. */
970 typedef struct forward {
971 struct forward *next; /* next forward reference */
972 struct forward *free; /* free list pointer */
973 AUXU *ifd_ptr; /* pointer to store file index */
974 AUXU *index_ptr; /* pointer to store symbol index */
975 AUXU *type_ptr; /* pointer to munge type info */
976 } forward_t;
977
978
979 /* Linked list support for tags. The first tag in the list is always
980 the current tag for that block. */
981 typedef struct tag {
982 struct tag *free; /* free list pointer */
983 struct shash *hash_ptr; /* pointer to the hash table head */
984 struct tag *same_name; /* tag with same name in outer scope */
985 struct tag *same_block; /* next tag defined in the same block. */
986 struct forward *forward_ref; /* list of forward references */
987 bt_t basic_type; /* bt_Struct, bt_Union, or bt_Enum */
988 symint_t ifd; /* file # tag defined in */
989 symint_t indx; /* index within file's local symbols */
990 } tag_t;
991
992
993 /* Head of a block's linked list of tags. */
994 typedef struct thead {
995 struct thead *prev; /* previous block */
996 struct thead *free; /* free list pointer */
997 struct tag *first_tag; /* first tag in block defined */
998 } thead_t;
999
1000
1001 /* Union containing pointers to each the small structures which are freed up. */
1002 typedef union small_free {
1003 scope_t *f_scope; /* scope structure */
1004 thead_t *f_thead; /* tag head structure */
1005 tag_t *f_tag; /* tag element structure */
1006 forward_t *f_forward; /* forward tag reference */
1007 } small_free_t;
1008
1009
1010 /* String hash table support. The size of the hash table must fit
1011 within a page. */
1012
1013 #ifndef SHASH_SIZE
1014 #define SHASH_SIZE 1009
1015 #endif
1016
1017 #define HASH_LEN_MAX ((1 << 12) - 1) /* Max length we can store */
1018
1019 typedef struct shash {
1020 struct shash *next; /* next hash value */
1021 char *string; /* string we are hashing */
1022 symint_t len; /* string length */
1023 symint_t indx; /* index within string table */
1024 EXTR *esym_ptr; /* global symbol pointer */
1025 SYMR *sym_ptr; /* local symbol pointer */
1026 SYMR *end_ptr; /* symbol pointer to end block */
1027 tag_t *tag_ptr; /* tag pointer */
1028 PDR *proc_ptr; /* procedure descriptor pointer */
1029 } shash_t;
1030
1031
1032 /* Type hash table support. The size of the hash table must fit
1033 within a page with the other extended file descriptor information.
1034 Because unique types which are hashed are fewer in number than
1035 strings, we use a smaller hash value. */
1036
1037 #ifndef THASH_SIZE
1038 #define THASH_SIZE 113
1039 #endif
1040
1041 typedef struct thash {
1042 struct thash *next; /* next hash value */
1043 AUXU type; /* type we are hashing */
1044 symint_t indx; /* index within string table */
1045 } thash_t;
1046
1047
1048 /* Extended file descriptor that contains all of the support necessary
1049 to add things to each file separately. */
1050 typedef struct efdr {
1051 FDR fdr; /* File header to be written out */
1052 FDR *orig_fdr; /* original file header */
1053 char *name; /* filename */
1054 int name_len; /* length of the filename */
1055 symint_t void_type; /* aux. pointer to 'void' type */
1056 symint_t int_type; /* aux. pointer to 'int' type */
1057 scope_t *cur_scope; /* current nested scopes */
1058 symint_t file_index; /* current file number */
1059 int nested_scopes; /* # nested scopes */
1060 varray_t strings; /* local strings */
1061 varray_t symbols; /* local symbols */
1062 varray_t procs; /* procedures */
1063 varray_t aux_syms; /* auxiliary symbols */
1064 struct efdr *next_file; /* next file descriptor */
1065 /* string/type hash tables */
1066 shash_t **shash_head; /* string hash table */
1067 thash_t *thash_head[THASH_SIZE];
1068 } efdr_t;
1069
1070 /* Pre-initialized extended file structure. */
1071 static int init_file_initialized = 0;
1072 static efdr_t init_file;
1073
1074 static efdr_t *first_file; /* first file descriptor */
1075 static efdr_t **last_file_ptr = &first_file; /* file descriptor tail */
1076
1077
1078 /* Union of various things that are held in pages. */
1079 typedef union page {
1080 char byte [ PAGE_SIZE ];
1081 unsigned char ubyte [ PAGE_SIZE ];
1082 efdr_t file [ PAGE_SIZE / sizeof (efdr_t) ];
1083 FDR ofile [ PAGE_SIZE / sizeof (FDR) ];
1084 PDR proc [ PAGE_SIZE / sizeof (PDR) ];
1085 SYMR sym [ PAGE_SIZE / sizeof (SYMR) ];
1086 EXTR esym [ PAGE_SIZE / sizeof (EXTR) ];
1087 AUXU aux [ PAGE_SIZE / sizeof (AUXU) ];
1088 DNR dense [ PAGE_SIZE / sizeof (DNR) ];
1089 scope_t scope [ PAGE_SIZE / sizeof (scope_t) ];
1090 vlinks_t vlinks [ PAGE_SIZE / sizeof (vlinks_t) ];
1091 shash_t shash [ PAGE_SIZE / sizeof (shash_t) ];
1092 thash_t thash [ PAGE_SIZE / sizeof (thash_t) ];
1093 tag_t tag [ PAGE_SIZE / sizeof (tag_t) ];
1094 forward_t forward [ PAGE_SIZE / sizeof (forward_t) ];
1095 thead_t thead [ PAGE_SIZE / sizeof (thead_t) ];
1096 } page_t;
1097
1098
1099 /* Structure holding allocation information for small sized structures. */
1100 typedef struct alloc_info {
1101 const char *alloc_name; /* name of this allocation type (must be first) */
1102 page_t *cur_page; /* current page being allocated from */
1103 small_free_t free_list; /* current free list if any */
1104 int unallocated; /* number of elements unallocated on page */
1105 int total_alloc; /* total number of allocations */
1106 int total_free; /* total number of frees */
1107 int total_pages; /* total number of pages allocated */
1108 } alloc_info_t;
1109
1110 /* Type information collected together. */
1111 typedef struct type_info {
1112 bt_t basic_type; /* basic type */
1113 coff_type_t orig_type; /* original COFF-based type */
1114 int num_tq; /* # type qualifiers */
1115 int num_dims; /* # dimensions */
1116 int num_sizes; /* # sizes */
1117 int extra_sizes; /* # extra sizes not tied with dims */
1118 tag_t * tag_ptr; /* tag pointer */
1119 int bitfield; /* symbol is a bitfield */
1120 int unknown_tag; /* this is an unknown tag */
1121 tq_t type_qualifiers[N_TQ]; /* type qualifiers (ptr, func, array)*/
1122 symint_t dimensions [N_TQ]; /* dimensions for each array */
1123 symint_t sizes [N_TQ+2]; /* sizes of each array slice + size of
1124 struct/union/enum + bitfield size */
1125 } type_info_t;
1126
1127 /* Pre-initialized type_info struct. */
1128 static type_info_t type_info_init = {
1129 bt_Nil, /* basic type */
1130 T_NULL, /* original COFF-based type */
1131 0, /* # type qualifiers */
1132 0, /* # dimensions */
1133 0, /* # sizes */
1134 0, /* sizes not tied with dims */
1135 NULL, /* ptr to tag */
1136 0, /* bitfield */
1137 0, /* unknown tag */
1138 { /* type qualifiers */
1139 tq_Nil,
1140 tq_Nil,
1141 tq_Nil,
1142 tq_Nil,
1143 tq_Nil,
1144 tq_Nil,
1145 },
1146 { /* dimensions */
1147 0,
1148 0,
1149 0,
1150 0,
1151 0,
1152 0
1153 },
1154 { /* sizes */
1155 0,
1156 0,
1157 0,
1158 0,
1159 0,
1160 0,
1161 0,
1162 0,
1163 },
1164 };
1165
1166
1167 /* Global virtual arrays & hash table for external strings as well as
1168 for the tags table and global tables for file descriptors, and
1169 dense numbers. */
1170
1171 static varray_t file_desc = INIT_VARRAY (efdr_t);
1172 static varray_t dense_num = INIT_VARRAY (DNR);
1173 static varray_t tag_strings = INIT_VARRAY (char);
1174 static varray_t ext_strings = INIT_VARRAY (char);
1175 static varray_t ext_symbols = INIT_VARRAY (EXTR);
1176
1177 static shash_t *orig_str_hash[SHASH_SIZE];
1178 static shash_t *ext_str_hash [SHASH_SIZE];
1179 static shash_t *tag_hash [SHASH_SIZE];
1180
1181 /* Static types for int and void. Also, remember the last function's
1182 type (which is set up when we encounter the declaration for the
1183 function, and used when the end block for the function is emitted. */
1184
1185 static type_info_t int_type_info;
1186 static type_info_t void_type_info;
1187 static type_info_t last_func_type_info;
1188 static EXTR *last_func_eptr;
1189
1190
1191 /* Convert COFF basic type to ECOFF basic type. The T_NULL type
1192 really should use bt_Void, but this causes the current ecoff GDB to
1193 issue unsupported type messages, and the Ultrix 4.00 dbx (aka MIPS
1194 2.0) doesn't understand it, even though the compiler generates it.
1195 Maybe this will be fixed in 2.10 or 2.20 of the MIPS compiler
1196 suite, but for now go with what works. */
1197
1198 static const bt_t map_coff_types[ (int) T_MAX ] = {
1199 bt_Nil, /* T_NULL */
1200 bt_Nil, /* T_ARG */
1201 bt_Char, /* T_CHAR */
1202 bt_Short, /* T_SHORT */
1203 bt_Int, /* T_INT */
1204 bt_Long, /* T_LONG */
1205 bt_Float, /* T_FLOAT */
1206 bt_Double, /* T_DOUBLE */
1207 bt_Struct, /* T_STRUCT */
1208 bt_Union, /* T_UNION */
1209 bt_Enum, /* T_ENUM */
1210 bt_Enum, /* T_MOE */
1211 bt_UChar, /* T_UCHAR */
1212 bt_UShort, /* T_USHORT */
1213 bt_UInt, /* T_UINT */
1214 bt_ULong /* T_ULONG */
1215 };
1216
1217 /* Convert COFF storage class to ECOFF storage class. */
1218 static const sc_t map_coff_storage[ (int) C_MAX ] = {
1219 sc_Nil, /* 0: C_NULL */
1220 sc_Abs, /* 1: C_AUTO auto var */
1221 sc_Undefined, /* 2: C_EXT external */
1222 sc_Data, /* 3: C_STAT static */
1223 sc_Register, /* 4: C_REG register */
1224 sc_Undefined, /* 5: C_EXTDEF ??? */
1225 sc_Text, /* 6: C_LABEL label */
1226 sc_Text, /* 7: C_ULABEL user label */
1227 sc_Info, /* 8: C_MOS member of struct */
1228 sc_Abs, /* 9: C_ARG argument */
1229 sc_Info, /* 10: C_STRTAG struct tag */
1230 sc_Info, /* 11: C_MOU member of union */
1231 sc_Info, /* 12: C_UNTAG union tag */
1232 sc_Info, /* 13: C_TPDEF typedef */
1233 sc_Data, /* 14: C_USTATIC ??? */
1234 sc_Info, /* 15: C_ENTAG enum tag */
1235 sc_Info, /* 16: C_MOE member of enum */
1236 sc_Register, /* 17: C_REGPARM register parameter */
1237 sc_Bits, /* 18; C_FIELD bitfield */
1238 sc_Nil, /* 19 */
1239 sc_Nil, /* 20 */
1240 sc_Nil, /* 21 */
1241 sc_Nil, /* 22 */
1242 sc_Nil, /* 23 */
1243 sc_Nil, /* 24 */
1244 sc_Nil, /* 25 */
1245 sc_Nil, /* 26 */
1246 sc_Nil, /* 27 */
1247 sc_Nil, /* 28 */
1248 sc_Nil, /* 29 */
1249 sc_Nil, /* 30 */
1250 sc_Nil, /* 31 */
1251 sc_Nil, /* 32 */
1252 sc_Nil, /* 33 */
1253 sc_Nil, /* 34 */
1254 sc_Nil, /* 35 */
1255 sc_Nil, /* 36 */
1256 sc_Nil, /* 37 */
1257 sc_Nil, /* 38 */
1258 sc_Nil, /* 39 */
1259 sc_Nil, /* 40 */
1260 sc_Nil, /* 41 */
1261 sc_Nil, /* 42 */
1262 sc_Nil, /* 43 */
1263 sc_Nil, /* 44 */
1264 sc_Nil, /* 45 */
1265 sc_Nil, /* 46 */
1266 sc_Nil, /* 47 */
1267 sc_Nil, /* 48 */
1268 sc_Nil, /* 49 */
1269 sc_Nil, /* 50 */
1270 sc_Nil, /* 51 */
1271 sc_Nil, /* 52 */
1272 sc_Nil, /* 53 */
1273 sc_Nil, /* 54 */
1274 sc_Nil, /* 55 */
1275 sc_Nil, /* 56 */
1276 sc_Nil, /* 57 */
1277 sc_Nil, /* 58 */
1278 sc_Nil, /* 59 */
1279 sc_Nil, /* 60 */
1280 sc_Nil, /* 61 */
1281 sc_Nil, /* 62 */
1282 sc_Nil, /* 63 */
1283 sc_Nil, /* 64 */
1284 sc_Nil, /* 65 */
1285 sc_Nil, /* 66 */
1286 sc_Nil, /* 67 */
1287 sc_Nil, /* 68 */
1288 sc_Nil, /* 69 */
1289 sc_Nil, /* 70 */
1290 sc_Nil, /* 71 */
1291 sc_Nil, /* 72 */
1292 sc_Nil, /* 73 */
1293 sc_Nil, /* 74 */
1294 sc_Nil, /* 75 */
1295 sc_Nil, /* 76 */
1296 sc_Nil, /* 77 */
1297 sc_Nil, /* 78 */
1298 sc_Nil, /* 79 */
1299 sc_Nil, /* 80 */
1300 sc_Nil, /* 81 */
1301 sc_Nil, /* 82 */
1302 sc_Nil, /* 83 */
1303 sc_Nil, /* 84 */
1304 sc_Nil, /* 85 */
1305 sc_Nil, /* 86 */
1306 sc_Nil, /* 87 */
1307 sc_Nil, /* 88 */
1308 sc_Nil, /* 89 */
1309 sc_Nil, /* 90 */
1310 sc_Nil, /* 91 */
1311 sc_Nil, /* 92 */
1312 sc_Nil, /* 93 */
1313 sc_Nil, /* 94 */
1314 sc_Nil, /* 95 */
1315 sc_Nil, /* 96 */
1316 sc_Nil, /* 97 */
1317 sc_Nil, /* 98 */
1318 sc_Nil, /* 99 */
1319 sc_Text, /* 100: C_BLOCK block start/end */
1320 sc_Text, /* 101: C_FCN function start/end */
1321 sc_Info, /* 102: C_EOS end of struct/union/enum */
1322 sc_Nil, /* 103: C_FILE file start */
1323 sc_Nil, /* 104: C_LINE line number */
1324 sc_Nil, /* 105: C_ALIAS combined type info */
1325 sc_Nil, /* 106: C_HIDDEN ??? */
1326 };
1327
1328 /* Convert COFF storage class to ECOFF symbol type. */
1329 static const st_t map_coff_sym_type[ (int) C_MAX ] = {
1330 st_Nil, /* 0: C_NULL */
1331 st_Local, /* 1: C_AUTO auto var */
1332 st_Global, /* 2: C_EXT external */
1333 st_Static, /* 3: C_STAT static */
1334 st_Local, /* 4: C_REG register */
1335 st_Global, /* 5: C_EXTDEF ??? */
1336 st_Label, /* 6: C_LABEL label */
1337 st_Label, /* 7: C_ULABEL user label */
1338 st_Member, /* 8: C_MOS member of struct */
1339 st_Param, /* 9: C_ARG argument */
1340 st_Block, /* 10: C_STRTAG struct tag */
1341 st_Member, /* 11: C_MOU member of union */
1342 st_Block, /* 12: C_UNTAG union tag */
1343 st_Typedef, /* 13: C_TPDEF typedef */
1344 st_Static, /* 14: C_USTATIC ??? */
1345 st_Block, /* 15: C_ENTAG enum tag */
1346 st_Member, /* 16: C_MOE member of enum */
1347 st_Param, /* 17: C_REGPARM register parameter */
1348 st_Member, /* 18; C_FIELD bitfield */
1349 st_Nil, /* 19 */
1350 st_Nil, /* 20 */
1351 st_Nil, /* 21 */
1352 st_Nil, /* 22 */
1353 st_Nil, /* 23 */
1354 st_Nil, /* 24 */
1355 st_Nil, /* 25 */
1356 st_Nil, /* 26 */
1357 st_Nil, /* 27 */
1358 st_Nil, /* 28 */
1359 st_Nil, /* 29 */
1360 st_Nil, /* 30 */
1361 st_Nil, /* 31 */
1362 st_Nil, /* 32 */
1363 st_Nil, /* 33 */
1364 st_Nil, /* 34 */
1365 st_Nil, /* 35 */
1366 st_Nil, /* 36 */
1367 st_Nil, /* 37 */
1368 st_Nil, /* 38 */
1369 st_Nil, /* 39 */
1370 st_Nil, /* 40 */
1371 st_Nil, /* 41 */
1372 st_Nil, /* 42 */
1373 st_Nil, /* 43 */
1374 st_Nil, /* 44 */
1375 st_Nil, /* 45 */
1376 st_Nil, /* 46 */
1377 st_Nil, /* 47 */
1378 st_Nil, /* 48 */
1379 st_Nil, /* 49 */
1380 st_Nil, /* 50 */
1381 st_Nil, /* 51 */
1382 st_Nil, /* 52 */
1383 st_Nil, /* 53 */
1384 st_Nil, /* 54 */
1385 st_Nil, /* 55 */
1386 st_Nil, /* 56 */
1387 st_Nil, /* 57 */
1388 st_Nil, /* 58 */
1389 st_Nil, /* 59 */
1390 st_Nil, /* 60 */
1391 st_Nil, /* 61 */
1392 st_Nil, /* 62 */
1393 st_Nil, /* 63 */
1394 st_Nil, /* 64 */
1395 st_Nil, /* 65 */
1396 st_Nil, /* 66 */
1397 st_Nil, /* 67 */
1398 st_Nil, /* 68 */
1399 st_Nil, /* 69 */
1400 st_Nil, /* 70 */
1401 st_Nil, /* 71 */
1402 st_Nil, /* 72 */
1403 st_Nil, /* 73 */
1404 st_Nil, /* 74 */
1405 st_Nil, /* 75 */
1406 st_Nil, /* 76 */
1407 st_Nil, /* 77 */
1408 st_Nil, /* 78 */
1409 st_Nil, /* 79 */
1410 st_Nil, /* 80 */
1411 st_Nil, /* 81 */
1412 st_Nil, /* 82 */
1413 st_Nil, /* 83 */
1414 st_Nil, /* 84 */
1415 st_Nil, /* 85 */
1416 st_Nil, /* 86 */
1417 st_Nil, /* 87 */
1418 st_Nil, /* 88 */
1419 st_Nil, /* 89 */
1420 st_Nil, /* 90 */
1421 st_Nil, /* 91 */
1422 st_Nil, /* 92 */
1423 st_Nil, /* 93 */
1424 st_Nil, /* 94 */
1425 st_Nil, /* 95 */
1426 st_Nil, /* 96 */
1427 st_Nil, /* 97 */
1428 st_Nil, /* 98 */
1429 st_Nil, /* 99 */
1430 st_Block, /* 100: C_BLOCK block start/end */
1431 st_Proc, /* 101: C_FCN function start/end */
1432 st_End, /* 102: C_EOS end of struct/union/enum */
1433 st_File, /* 103: C_FILE file start */
1434 st_Nil, /* 104: C_LINE line number */
1435 st_Nil, /* 105: C_ALIAS combined type info */
1436 st_Nil, /* 106: C_HIDDEN ??? */
1437 };
1438
1439 /* Map COFF derived types to ECOFF type qualifiers. */
1440 static const tq_t map_coff_derived_type[ (int) DT_MAX ] = {
1441 tq_Nil, /* 0: DT_NON no more qualifiers */
1442 tq_Ptr, /* 1: DT_PTR pointer */
1443 tq_Proc, /* 2: DT_FCN function */
1444 tq_Array, /* 3: DT_ARY array */
1445 };
1446
1447
1448 /* Keep track of different sized allocation requests. */
1449 static alloc_info_t alloc_counts[ (int) alloc_type_last ];
1450
1451 \f
1452 /* Pointers and such to the original symbol table that is read in. */
1453 static struct filehdr orig_file_header; /* global object file header */
1454
1455 static HDRR orig_sym_hdr; /* symbolic header on input */
1456 static char *orig_linenum; /* line numbers */
1457 static DNR *orig_dense; /* dense numbers */
1458 static PDR *orig_procs; /* procedures */
1459 static SYMR *orig_local_syms; /* local symbols */
1460 static OPTR *orig_opt_syms; /* optimization symbols */
1461 static AUXU *orig_aux_syms; /* auxiliary symbols */
1462 static char *orig_local_strs; /* local strings */
1463 static char *orig_ext_strs; /* external strings */
1464 static FDR *orig_files; /* file descriptors */
1465 static symint_t *orig_rfds; /* relative file desc's */
1466 static EXTR *orig_ext_syms; /* external symbols */
1467
1468 /* Macros to convert an index into a given object within the original
1469 symbol table. */
1470 #define CHECK(num,max,str) \
1471 (((unsigned long) num > (unsigned long) max) ? out_of_bounds (num, max, str, __LINE__) : 0)
1472
1473 #define ORIG_LINENUM(indx) (CHECK ((indx), orig_sym_hdr.cbLine, "line#"), (indx) + orig_linenum)
1474 #define ORIG_DENSE(indx) (CHECK ((indx), orig_sym_hdr.idnMax, "dense"), (indx) + orig_dense)
1475 #define ORIG_PROCS(indx) (CHECK ((indx), orig_sym_hdr.ipdMax, "procs"), (indx) + orig_procs)
1476 #define ORIG_FILES(indx) (CHECK ((indx), orig_sym_hdr.ifdMax, "funcs"), (indx) + orig_files)
1477 #define ORIG_LSYMS(indx) (CHECK ((indx), orig_sym_hdr.isymMax, "lsyms"), (indx) + orig_local_syms)
1478 #define ORIG_LSTRS(indx) (CHECK ((indx), orig_sym_hdr.issMax, "lstrs"), (indx) + orig_local_strs)
1479 #define ORIG_ESYMS(indx) (CHECK ((indx), orig_sym_hdr.iextMax, "esyms"), (indx) + orig_ext_syms)
1480 #define ORIG_ESTRS(indx) (CHECK ((indx), orig_sym_hdr.issExtMax, "estrs"), (indx) + orig_ext_strs)
1481 #define ORIG_OPT(indx) (CHECK ((indx), orig_sym_hdr.ioptMax, "opt"), (indx) + orig_opt_syms)
1482 #define ORIG_AUX(indx) (CHECK ((indx), orig_sym_hdr.iauxMax, "aux"), (indx) + orig_aux_syms)
1483 #define ORIG_RFDS(indx) (CHECK ((indx), orig_sym_hdr.crfd, "rfds"), (indx) + orig_rfds)
1484
1485 /* Various other statics. */
1486 static HDRR symbolic_header; /* symbolic header */
1487 static efdr_t *cur_file_ptr = (efdr_t *) 0; /* current file desc. header */
1488 static PDR *cur_proc_ptr = (PDR *) 0; /* current procedure header */
1489 static SYMR *cur_oproc_begin = (SYMR *) 0; /* original proc. sym begin info */
1490 static SYMR *cur_oproc_end = (SYMR *) 0; /* original proc. sym end info */
1491 static PDR *cur_oproc_ptr = (PDR *) 0; /* current original procedure*/
1492 static thead_t *cur_tag_head = (thead_t *) 0;/* current tag head */
1493 static unsigned long file_offset = 0; /* current file offset */
1494 static unsigned long max_file_offset = 0; /* maximum file offset */
1495 static FILE *object_stream = (FILE *) 0; /* file desc. to output .o */
1496 static FILE *obj_in_stream = (FILE *) 0; /* file desc. to input .o */
1497 static char *progname = (char *) 0; /* program name for errors */
1498 static const char *input_name = "stdin"; /* name of input file */
1499 static char *object_name = (char *) 0; /* tmp. name of object file */
1500 static char *obj_in_name = (char *) 0; /* name of input object file */
1501 static char *cur_line_start = (char *) 0; /* current line read in */
1502 static char *cur_line_ptr = (char *) 0; /* ptr within current line */
1503 static unsigned cur_line_nbytes = 0; /* # bytes for current line */
1504 static unsigned cur_line_alloc = 0; /* # bytes total in buffer */
1505 static long line_number = 0; /* current input line number */
1506 static int debug = 0; /* trace functions */
1507 static int version = 0; /* print version # */
1508 static int verbose = 0;
1509 static int had_errors = 0; /* != 0 if errors were found */
1510 static int rename_output = 0; /* != 0 if rename output file*/
1511 static int delete_input = 0; /* != 0 if delete input after done */
1512 static int stabs_seen = 0; /* != 0 if stabs have been seen */
1513
1514
1515 /* Pseudo symbol to use when putting stabs into the symbol table. */
1516 #ifndef STABS_SYMBOL
1517 #define STABS_SYMBOL "@stabs"
1518 #endif
1519
1520 static const char stabs_symbol[] = STABS_SYMBOL;
1521
1522 \f
1523 /* Forward reference for functions. See the definition for more details. */
1524
1525 #ifndef STATIC
1526 #define STATIC static
1527 #endif
1528
1529 STATIC int out_of_bounds (symint_t, symint_t, const char *, int);
1530 STATIC shash_t *hash_string (const char *, Ptrdiff_t, shash_t **, symint_t *);
1531 STATIC symint_t add_string (varray_t *, shash_t **, const char *, const char *,
1532 shash_t **);
1533 STATIC symint_t add_local_symbol (const char *, const char *, st_t, sc_t,
1534 symint_t, symint_t);
1535 STATIC symint_t add_ext_symbol (EXTR *, int);
1536 STATIC symint_t add_aux_sym_symint (symint_t);
1537 STATIC symint_t add_aux_sym_rndx (int, symint_t);
1538 STATIC symint_t add_aux_sym_tir (type_info_t *, hash_state_t, thash_t **);
1539 STATIC tag_t * get_tag (const char *, const char *, symint_t, bt_t);
1540 STATIC void add_unknown_tag (tag_t *);
1541 STATIC void add_procedure (const char *, const char *);
1542 STATIC void initialize_init_file (void);
1543 STATIC void add_file (const char *, const char *);
1544 STATIC void add_bytes (varray_t *, char *, Size_t);
1545 STATIC void add_varray_page (varray_t *);
1546 STATIC void update_headers (void);
1547 STATIC void write_varray (varray_t *, off_t, const char *);
1548 STATIC void write_object (void);
1549 STATIC const char *st_to_string (st_t);
1550 STATIC const char *sc_to_string (sc_t);
1551 STATIC char *read_line (void);
1552 STATIC void parse_input (void);
1553 STATIC void mark_stabs (const char *);
1554 STATIC void parse_begin (const char *);
1555 STATIC void parse_bend (const char *);
1556 STATIC void parse_def (const char *);
1557 STATIC void parse_end (const char *);
1558 STATIC void parse_ent (const char *);
1559 STATIC void parse_file (const char *);
1560 STATIC void parse_stabs_common (const char *, const char *, const char *);
1561 STATIC void parse_stabs (const char *);
1562 STATIC void parse_stabn (const char *);
1563 STATIC page_t *read_seek (Size_t, off_t, const char *);
1564 STATIC void copy_object (void);
1565
1566 STATIC void catch_signal (int) ATTRIBUTE_NORETURN;
1567 STATIC page_t *allocate_page (void);
1568 STATIC page_t *allocate_multiple_pages (Size_t);
1569 STATIC void free_multiple_pages (page_t *, Size_t);
1570
1571 #ifndef MALLOC_CHECK
1572 STATIC page_t *allocate_cluster (Size_t);
1573 #endif
1574
1575 STATIC forward_t *allocate_forward (void);
1576 STATIC scope_t *allocate_scope (void);
1577 STATIC shash_t *allocate_shash (void);
1578 STATIC tag_t *allocate_tag (void);
1579 STATIC thash_t *allocate_thash (void);
1580 STATIC thead_t *allocate_thead (void);
1581 STATIC vlinks_t *allocate_vlinks (void);
1582
1583 STATIC void free_forward (forward_t *);
1584 STATIC void free_scope (scope_t *);
1585 STATIC void free_tag (tag_t *);
1586 STATIC void free_thead (thead_t *);
1587
1588 extern char *optarg;
1589 extern int optind;
1590 extern int opterr;
1591 \f
1592 /* List of assembler pseudo ops and beginning sequences that need
1593 special actions. Someday, this should be a hash table, and such,
1594 but for now a linear list of names and calls to memcmp will
1595 do...... */
1596
1597 typedef struct _pseudo_ops {
1598 const char *const name; /* pseudo-op in ascii */
1599 const int len; /* length of name to compare */
1600 void (*const func) (const char *); /* function to handle line */
1601 } pseudo_ops_t;
1602
1603 static const pseudo_ops_t pseudo_ops[] = {
1604 { "#.def", sizeof("#.def")-1, parse_def },
1605 { "#.begin", sizeof("#.begin")-1, parse_begin },
1606 { "#.bend", sizeof("#.bend")-1, parse_bend },
1607 { ".end", sizeof(".end")-1, parse_end },
1608 { ".ent", sizeof(".ent")-1, parse_ent },
1609 { ".file", sizeof(".file")-1, parse_file },
1610 { "#.stabs", sizeof("#.stabs")-1, parse_stabs },
1611 { "#.stabn", sizeof("#.stabn")-1, parse_stabn },
1612 { ".stabs", sizeof(".stabs")-1, parse_stabs },
1613 { ".stabn", sizeof(".stabn")-1, parse_stabn },
1614 { "#@stabs", sizeof("#@stabs")-1, mark_stabs },
1615 };
1616
1617 \f
1618 /* Command line options for getopt_long. */
1619
1620 static const struct option options[] =
1621 {
1622 { "version", 0, 0, 'V' },
1623 { "verbose", 0, 0, 'v' },
1624 { 0, 0, 0, 0 }
1625 };
1626 \f
1627 /* Add a page to a varray object. */
1628
1629 STATIC void
1630 add_varray_page (varray_t *vp)
1631 {
1632 vlinks_t *new_links = allocate_vlinks ();
1633
1634 #ifdef MALLOC_CHECK
1635 if (vp->object_size > 1)
1636 new_links->datum = xcalloc (1, vp->object_size);
1637 else
1638 #endif
1639 new_links->datum = allocate_page ();
1640
1641 alloc_counts[ (int) alloc_type_varray ].total_alloc++;
1642 alloc_counts[ (int) alloc_type_varray ].total_pages++;
1643
1644 new_links->start_index = vp->num_allocated;
1645 vp->objects_last_page = 0;
1646
1647 if (vp->first == (vlinks_t *) 0) /* first allocation? */
1648 vp->first = vp->last = new_links;
1649 else
1650 { /* 2nd or greater allocation */
1651 new_links->prev = vp->last;
1652 vp->last->next = new_links;
1653 vp->last = new_links;
1654 }
1655 }
1656
1657 \f
1658 /* Compute hash code (from tree.c) */
1659
1660 #define HASHBITS 30
1661
1662 STATIC shash_t *
1663 hash_string (const char *text, Ptrdiff_t hash_len, shash_t **hash_tbl,
1664 symint_t *ret_hash_index)
1665 {
1666 unsigned long hi;
1667 Ptrdiff_t i;
1668 shash_t *ptr;
1669 int first_ch = *text;
1670
1671 hi = hash_len;
1672 for (i = 0; i < hash_len; i++)
1673 hi = ((hi & 0x003fffff) * 613) + (text[i] & 0xff);
1674
1675 hi &= (1 << HASHBITS) - 1;
1676 hi %= SHASH_SIZE;
1677
1678 if (ret_hash_index != (symint_t *) 0)
1679 *ret_hash_index = hi;
1680
1681 for (ptr = hash_tbl[hi]; ptr != (shash_t *) 0; ptr = ptr->next)
1682 if ((symint_t) hash_len == ptr->len
1683 && first_ch == ptr->string[0]
1684 && memcmp (text, ptr->string, hash_len) == 0)
1685 break;
1686
1687 return ptr;
1688 }
1689
1690 \f
1691 /* Add a string (and null pad) to one of the string tables. A
1692 consequence of hashing strings, is that we don't let strings cross
1693 page boundaries. The extra nulls will be ignored. VP is a string
1694 virtual array, HASH_TBL a pointer to the hash table, the string
1695 starts at START and the position one byte after the string is given
1696 with END_P1, the resulting hash pointer is returned in RET_HASH. */
1697
1698 STATIC symint_t
1699 add_string (varray_t *vp, shash_t **hash_tbl, const char *start,
1700 const char *end_p1, shash_t **ret_hash)
1701 {
1702 Ptrdiff_t len = end_p1 - start;
1703 shash_t *hash_ptr;
1704 symint_t hi;
1705
1706 if (len >= (Ptrdiff_t) PAGE_USIZE)
1707 fatal ("string too big (%ld bytes)", (long) len);
1708
1709 hash_ptr = hash_string (start, len, hash_tbl, &hi);
1710 if (hash_ptr == (shash_t *) 0)
1711 {
1712 char *p;
1713
1714 if (vp->objects_last_page + len >= (long) PAGE_USIZE)
1715 {
1716 vp->num_allocated
1717 = ((vp->num_allocated + PAGE_USIZE - 1) / PAGE_USIZE) * PAGE_USIZE;
1718 add_varray_page (vp);
1719 }
1720
1721 hash_ptr = allocate_shash ();
1722 hash_ptr->next = hash_tbl[hi];
1723 hash_tbl[hi] = hash_ptr;
1724
1725 hash_ptr->len = len;
1726 hash_ptr->indx = vp->num_allocated;
1727 hash_ptr->string = p = & vp->last->datum->byte[ vp->objects_last_page ];
1728
1729 vp->objects_last_page += len+1;
1730 vp->num_allocated += len+1;
1731
1732 while (len-- > 0)
1733 *p++ = *start++;
1734
1735 *p = '\0';
1736 }
1737
1738 if (ret_hash != (shash_t **) 0)
1739 *ret_hash = hash_ptr;
1740
1741 return hash_ptr->indx;
1742 }
1743
1744 \f
1745 /* Add a local symbol. The symbol string starts at STR_START and the
1746 first byte after it is marked by STR_END_P1. The symbol has type
1747 TYPE and storage class STORAGE and value VALUE. INDX is an index
1748 to local/aux. symbols. */
1749
1750 STATIC symint_t
1751 add_local_symbol (const char *str_start, const char *str_end_p1, st_t type,
1752 sc_t storage, symint_t value, symint_t indx)
1753 {
1754 symint_t ret;
1755 SYMR *psym;
1756 scope_t *pscope;
1757 thead_t *ptag_head;
1758 tag_t *ptag;
1759 tag_t *ptag_next;
1760 varray_t *vp = &cur_file_ptr->symbols;
1761 int scope_delta = 0;
1762 shash_t *hash_ptr = (shash_t *) 0;
1763
1764 if (vp->objects_last_page == vp->objects_per_page)
1765 add_varray_page (vp);
1766
1767 psym = &vp->last->datum->sym[ vp->objects_last_page++ ];
1768
1769 psym->value = value;
1770 psym->st = (unsigned) type;
1771 psym->sc = (unsigned) storage;
1772 psym->index = indx;
1773 psym->iss = (str_start == (const char *) 0)
1774 ? 0
1775 : add_string (&cur_file_ptr->strings,
1776 &cur_file_ptr->shash_head[0],
1777 str_start,
1778 str_end_p1,
1779 &hash_ptr);
1780
1781 ret = vp->num_allocated++;
1782
1783 if (MIPS_IS_STAB (psym))
1784 return ret;
1785
1786 /* Save the symbol within the hash table if this is a static
1787 item, and it has a name. */
1788 if (hash_ptr != (shash_t *) 0
1789 && (type == st_Global || type == st_Static || type == st_Label
1790 || type == st_Proc || type == st_StaticProc))
1791 hash_ptr->sym_ptr = psym;
1792
1793 /* push or pop a scope if appropriate. */
1794 switch (type)
1795 {
1796 default:
1797 break;
1798
1799 case st_File: /* beginning of file */
1800 case st_Proc: /* procedure */
1801 case st_StaticProc: /* static procedure */
1802 case st_Block: /* begin scope */
1803 pscope = allocate_scope ();
1804 pscope->prev = cur_file_ptr->cur_scope;
1805 pscope->lsym = psym;
1806 pscope->lnumber = ret;
1807 pscope->type = type;
1808 cur_file_ptr->cur_scope = pscope;
1809
1810 if (type != st_File)
1811 scope_delta = 1;
1812
1813 /* For every block type except file, struct, union, or
1814 enumeration blocks, push a level on the tag stack. We omit
1815 file types, so that tags can span file boundaries. */
1816 if (type != st_File && storage != sc_Info)
1817 {
1818 ptag_head = allocate_thead ();
1819 ptag_head->first_tag = 0;
1820 ptag_head->prev = cur_tag_head;
1821 cur_tag_head = ptag_head;
1822 }
1823 break;
1824
1825 case st_End:
1826 pscope = cur_file_ptr->cur_scope;
1827 if (pscope == (scope_t *) 0)
1828 error ("internal error, too many st_End's");
1829
1830 else
1831 {
1832 st_t begin_type = (st_t) pscope->lsym->st;
1833
1834 if (begin_type != st_File)
1835 scope_delta = -1;
1836
1837 /* Except for file, structure, union, or enumeration end
1838 blocks remove all tags created within this scope. */
1839 if (begin_type != st_File && storage != sc_Info)
1840 {
1841 ptag_head = cur_tag_head;
1842 cur_tag_head = ptag_head->prev;
1843
1844 for (ptag = ptag_head->first_tag;
1845 ptag != (tag_t *) 0;
1846 ptag = ptag_next)
1847 {
1848 if (ptag->forward_ref != (forward_t *) 0)
1849 add_unknown_tag (ptag);
1850
1851 ptag_next = ptag->same_block;
1852 ptag->hash_ptr->tag_ptr = ptag->same_name;
1853 free_tag (ptag);
1854 }
1855
1856 free_thead (ptag_head);
1857 }
1858
1859 cur_file_ptr->cur_scope = pscope->prev;
1860 psym->index = pscope->lnumber; /* blk end gets begin sym # */
1861
1862 if (storage != sc_Info)
1863 psym->iss = pscope->lsym->iss; /* blk end gets same name */
1864
1865 if (begin_type == st_File || begin_type == st_Block)
1866 pscope->lsym->index = ret+1; /* block begin gets next sym # */
1867
1868 /* Functions push two or more aux words as follows:
1869 1st word: index+1 of the end symbol
1870 2nd word: type of the function (plus any aux words needed).
1871 Also, tie the external pointer back to the function begin symbol. */
1872 else
1873 {
1874 symint_t type;
1875 pscope->lsym->index = add_aux_sym_symint (ret+1);
1876 type = add_aux_sym_tir (&last_func_type_info,
1877 hash_no,
1878 &cur_file_ptr->thash_head[0]);
1879 if (last_func_eptr)
1880 {
1881 last_func_eptr->ifd = cur_file_ptr->file_index;
1882
1883 /* The index for an external st_Proc symbol is the index
1884 of the st_Proc symbol in the local symbol table. */
1885 last_func_eptr->asym.index = psym->index;
1886 }
1887 }
1888
1889 free_scope (pscope);
1890 }
1891 }
1892
1893 cur_file_ptr->nested_scopes += scope_delta;
1894
1895 if (debug && type != st_File
1896 && (debug > 2 || type == st_Block || type == st_End
1897 || type == st_Proc || type == st_StaticProc))
1898 {
1899 const char *sc_str = sc_to_string (storage);
1900 const char *st_str = st_to_string (type);
1901 int depth = cur_file_ptr->nested_scopes + (scope_delta < 0);
1902
1903 fprintf (stderr,
1904 "\tlsym\tv= %10ld, depth= %2d, sc= %-12s",
1905 value, depth, sc_str);
1906
1907 if (str_start && str_end_p1 - str_start > 0)
1908 fprintf (stderr, " st= %-11s name= %.*s\n",
1909 st_str, (int) (str_end_p1 - str_start), str_start);
1910 else
1911 {
1912 Size_t len = strlen (st_str);
1913 fprintf (stderr, " st= %.*s\n", (int) (len-1), st_str);
1914 }
1915 }
1916
1917 return ret;
1918 }
1919
1920 \f
1921 /* Add an external symbol with symbol pointer ESYM and file index
1922 IFD. */
1923
1924 STATIC symint_t
1925 add_ext_symbol (EXTR *esym, int ifd)
1926 {
1927 const char *str_start; /* first byte in string */
1928 const char *str_end_p1; /* first byte after string */
1929 EXTR *psym;
1930 varray_t *vp = &ext_symbols;
1931 shash_t *hash_ptr = (shash_t *) 0;
1932
1933 str_start = ORIG_ESTRS (esym->asym.iss);
1934 str_end_p1 = str_start + strlen (str_start);
1935
1936 if (debug > 1)
1937 {
1938 long value = esym->asym.value;
1939 const char *sc_str = sc_to_string ((sc_t) esym->asym.sc);
1940 const char *st_str = st_to_string ((st_t) esym->asym.st);
1941
1942 fprintf (stderr,
1943 "\tesym\tv= %10ld, ifd= %2d, sc= %-12s",
1944 value, ifd, sc_str);
1945
1946 if (str_start && str_end_p1 - str_start > 0)
1947 fprintf (stderr, " st= %-11s name= %.*s\n",
1948 st_str, (int) (str_end_p1 - str_start), str_start);
1949 else
1950 fprintf (stderr, " st= %s\n", st_str);
1951 }
1952
1953 if (vp->objects_last_page == vp->objects_per_page)
1954 add_varray_page (vp);
1955
1956 psym = &vp->last->datum->esym[ vp->objects_last_page++ ];
1957
1958 *psym = *esym;
1959 psym->ifd = ifd;
1960 psym->asym.index = indexNil;
1961 psym->asym.iss = (str_start == (const char *) 0)
1962 ? 0
1963 : add_string (&ext_strings,
1964 &ext_str_hash[0],
1965 str_start,
1966 str_end_p1,
1967 &hash_ptr);
1968
1969 hash_ptr->esym_ptr = psym;
1970 return vp->num_allocated++;
1971 }
1972
1973 \f
1974 /* Add an auxiliary symbol (passing a symint). */
1975
1976 STATIC symint_t
1977 add_aux_sym_symint (symint_t aux_word)
1978 {
1979 AUXU *aux_ptr;
1980 efdr_t *file_ptr = cur_file_ptr;
1981 varray_t *vp = &file_ptr->aux_syms;
1982
1983 if (vp->objects_last_page == vp->objects_per_page)
1984 add_varray_page (vp);
1985
1986 aux_ptr = &vp->last->datum->aux[ vp->objects_last_page++ ];
1987 aux_ptr->isym = aux_word;
1988
1989 return vp->num_allocated++;
1990 }
1991
1992
1993 /* Add an auxiliary symbol (passing a file/symbol index combo). */
1994
1995 STATIC symint_t
1996 add_aux_sym_rndx (int file_index, symint_t sym_index)
1997 {
1998 AUXU *aux_ptr;
1999 efdr_t *file_ptr = cur_file_ptr;
2000 varray_t *vp = &file_ptr->aux_syms;
2001
2002 if (vp->objects_last_page == vp->objects_per_page)
2003 add_varray_page (vp);
2004
2005 aux_ptr = &vp->last->datum->aux[ vp->objects_last_page++ ];
2006 aux_ptr->rndx.rfd = file_index;
2007 aux_ptr->rndx.index = sym_index;
2008
2009 return vp->num_allocated++;
2010 }
2011
2012 \f
2013 /* Add an auxiliary symbol (passing the basic type and possibly
2014 type qualifiers). */
2015
2016 STATIC symint_t
2017 add_aux_sym_tir (type_info_t *t, hash_state_t state, thash_t **hash_tbl)
2018 {
2019 AUXU *aux_ptr;
2020 efdr_t *file_ptr = cur_file_ptr;
2021 varray_t *vp = &file_ptr->aux_syms;
2022 static AUXU init_aux;
2023 symint_t ret;
2024 int i;
2025 AUXU aux;
2026
2027 aux = init_aux;
2028 aux.ti.bt = (int) t->basic_type;
2029 aux.ti.continued = 0;
2030 aux.ti.fBitfield = t->bitfield;
2031
2032 aux.ti.tq0 = (int) t->type_qualifiers[0];
2033 aux.ti.tq1 = (int) t->type_qualifiers[1];
2034 aux.ti.tq2 = (int) t->type_qualifiers[2];
2035 aux.ti.tq3 = (int) t->type_qualifiers[3];
2036 aux.ti.tq4 = (int) t->type_qualifiers[4];
2037 aux.ti.tq5 = (int) t->type_qualifiers[5];
2038
2039
2040 /* For anything that adds additional information, we must not hash,
2041 so check here, and reset our state. */
2042
2043 if (state != hash_no
2044 && (t->type_qualifiers[0] == tq_Array
2045 || t->type_qualifiers[1] == tq_Array
2046 || t->type_qualifiers[2] == tq_Array
2047 || t->type_qualifiers[3] == tq_Array
2048 || t->type_qualifiers[4] == tq_Array
2049 || t->type_qualifiers[5] == tq_Array
2050 || t->basic_type == bt_Struct
2051 || t->basic_type == bt_Union
2052 || t->basic_type == bt_Enum
2053 || t->bitfield
2054 || t->num_dims > 0))
2055 state = hash_no;
2056
2057 /* See if we can hash this type, and save some space, but some types
2058 can't be hashed (because they contain arrays or continuations),
2059 and others can be put into the hash list, but cannot use existing
2060 types because other aux entries precede this one. */
2061
2062 if (state != hash_no)
2063 {
2064 thash_t *hash_ptr;
2065 symint_t hi;
2066
2067 hi = aux.isym & ((1 << HASHBITS) - 1);
2068 hi %= THASH_SIZE;
2069
2070 for (hash_ptr = hash_tbl[hi];
2071 hash_ptr != (thash_t *) 0;
2072 hash_ptr = hash_ptr->next)
2073 {
2074 if (aux.isym == hash_ptr->type.isym)
2075 break;
2076 }
2077
2078 if (hash_ptr != (thash_t *) 0 && state == hash_yes)
2079 return hash_ptr->indx;
2080
2081 if (hash_ptr == (thash_t *) 0)
2082 {
2083 hash_ptr = allocate_thash ();
2084 hash_ptr->next = hash_tbl[hi];
2085 hash_ptr->type = aux;
2086 hash_ptr->indx = vp->num_allocated;
2087 hash_tbl[hi] = hash_ptr;
2088 }
2089 }
2090
2091 /* Everything is set up, add the aux symbol. */
2092 if (vp->objects_last_page == vp->objects_per_page)
2093 add_varray_page (vp);
2094
2095 aux_ptr = &vp->last->datum->aux[ vp->objects_last_page++ ];
2096 *aux_ptr = aux;
2097
2098 ret = vp->num_allocated++;
2099
2100 /* Add bitfield length if it exists.
2101
2102 NOTE: Mips documentation claims bitfield goes at the end of the
2103 AUX record, but the DECstation compiler emits it here.
2104 (This would only make a difference for enum bitfields.)
2105
2106 Also note: We use the last size given since gcc may emit 2
2107 for an enum bitfield. */
2108
2109 if (t->bitfield)
2110 (void) add_aux_sym_symint ((symint_t) t->sizes[t->num_sizes-1]);
2111
2112
2113 /* Add tag information if needed. Structure, union, and enum
2114 references add 2 aux symbols: a [file index, symbol index]
2115 pointer to the structure type, and the current file index. */
2116
2117 if (t->basic_type == bt_Struct
2118 || t->basic_type == bt_Union
2119 || t->basic_type == bt_Enum)
2120 {
2121 symint_t file_index = t->tag_ptr->ifd;
2122 symint_t sym_index = t->tag_ptr->indx;
2123
2124 if (t->unknown_tag)
2125 {
2126 (void) add_aux_sym_rndx (ST_RFDESCAPE, sym_index);
2127 (void) add_aux_sym_symint ((symint_t)-1);
2128 }
2129 else if (sym_index != indexNil)
2130 {
2131 (void) add_aux_sym_rndx (ST_RFDESCAPE, sym_index);
2132 (void) add_aux_sym_symint (file_index);
2133 }
2134 else
2135 {
2136 forward_t *forward_ref = allocate_forward ();
2137
2138 forward_ref->type_ptr = aux_ptr;
2139 forward_ref->next = t->tag_ptr->forward_ref;
2140 t->tag_ptr->forward_ref = forward_ref;
2141
2142 (void) add_aux_sym_rndx (ST_RFDESCAPE, sym_index);
2143 forward_ref->index_ptr
2144 = &vp->last->datum->aux[ vp->objects_last_page - 1];
2145
2146 (void) add_aux_sym_symint (file_index);
2147 forward_ref->ifd_ptr
2148 = &vp->last->datum->aux[ vp->objects_last_page - 1];
2149 }
2150 }
2151
2152 /* Add information about array bounds if they exist. */
2153 for (i = 0; i < t->num_dims; i++)
2154 {
2155 (void) add_aux_sym_rndx (ST_RFDESCAPE,
2156 cur_file_ptr->int_type);
2157
2158 (void) add_aux_sym_symint (cur_file_ptr->file_index); /* file index*/
2159 (void) add_aux_sym_symint ((symint_t) 0); /* low bound */
2160 (void) add_aux_sym_symint (t->dimensions[i] - 1); /* high bound*/
2161 (void) add_aux_sym_symint ((t->dimensions[i] == 0) /* stride */
2162 ? 0
2163 : (t->sizes[i] * 8) / t->dimensions[i]);
2164 };
2165
2166 /* NOTE: Mips documentation claims that the bitfield width goes here.
2167 But it needs to be emitted earlier. */
2168
2169 return ret;
2170 }
2171
2172 \f
2173 /* Add a tag to the tag table (unless it already exists). */
2174
2175 STATIC tag_t *
2176 get_tag (const char *tag_start, /* 1st byte of tag name */
2177 const char *tag_end_p1, /* 1st byte after tag name */
2178 symint_t indx, /* index of tag start block */
2179 bt_t basic_type) /* bt_Struct, bt_Union, or bt_Enum */
2180
2181 {
2182 shash_t *hash_ptr;
2183 tag_t *tag_ptr;
2184 hash_ptr = hash_string (tag_start,
2185 tag_end_p1 - tag_start,
2186 &tag_hash[0],
2187 (symint_t *) 0);
2188
2189 if (hash_ptr != (shash_t *) 0
2190 && hash_ptr->tag_ptr != (tag_t *) 0)
2191 {
2192 tag_ptr = hash_ptr->tag_ptr;
2193 if (indx != indexNil)
2194 {
2195 tag_ptr->basic_type = basic_type;
2196 tag_ptr->ifd = cur_file_ptr->file_index;
2197 tag_ptr->indx = indx;
2198 }
2199 return tag_ptr;
2200 }
2201
2202 (void) add_string (&tag_strings,
2203 &tag_hash[0],
2204 tag_start,
2205 tag_end_p1,
2206 &hash_ptr);
2207
2208 tag_ptr = allocate_tag ();
2209 tag_ptr->forward_ref = (forward_t *) 0;
2210 tag_ptr->hash_ptr = hash_ptr;
2211 tag_ptr->same_name = hash_ptr->tag_ptr;
2212 tag_ptr->basic_type = basic_type;
2213 tag_ptr->indx = indx;
2214 tag_ptr->ifd = (indx == indexNil
2215 ? (symint_t) -1 : cur_file_ptr->file_index);
2216 tag_ptr->same_block = cur_tag_head->first_tag;
2217
2218 cur_tag_head->first_tag = tag_ptr;
2219 hash_ptr->tag_ptr = tag_ptr;
2220
2221 return tag_ptr;
2222 }
2223
2224 \f
2225 /* Add an unknown {struct, union, enum} tag. */
2226
2227 STATIC void
2228 add_unknown_tag (tag_t *ptag)
2229 {
2230 shash_t *hash_ptr = ptag->hash_ptr;
2231 char *name_start = hash_ptr->string;
2232 char *name_end_p1 = name_start + hash_ptr->len;
2233 forward_t *f_next = ptag->forward_ref;
2234 forward_t *f_cur;
2235 int sym_index;
2236 int file_index = cur_file_ptr->file_index;
2237
2238 if (debug > 1)
2239 {
2240 const char *agg_type = "{unknown aggregate type}";
2241 switch (ptag->basic_type)
2242 {
2243 case bt_Struct: agg_type = "struct"; break;
2244 case bt_Union: agg_type = "union"; break;
2245 case bt_Enum: agg_type = "enum"; break;
2246 default: break;
2247 }
2248
2249 fprintf (stderr, "unknown %s %.*s found\n",
2250 agg_type, (int) hash_ptr->len, name_start);
2251 }
2252
2253 sym_index = add_local_symbol (name_start,
2254 name_end_p1,
2255 st_Block,
2256 sc_Info,
2257 (symint_t) 0,
2258 (symint_t) 0);
2259
2260 (void) add_local_symbol (name_start,
2261 name_end_p1,
2262 st_End,
2263 sc_Info,
2264 (symint_t) 0,
2265 (symint_t) 0);
2266
2267 while (f_next != (forward_t *) 0)
2268 {
2269 f_cur = f_next;
2270 f_next = f_next->next;
2271
2272 f_cur->ifd_ptr->isym = file_index;
2273 f_cur->index_ptr->rndx.index = sym_index;
2274
2275 free_forward (f_cur);
2276 }
2277
2278 return;
2279 }
2280
2281 \f
2282 /* Add a procedure to the current file's list of procedures, and record
2283 this is the current procedure. If the assembler created a PDR for
2284 this procedure, use that to initialize the current PDR. */
2285
2286 STATIC void
2287 add_procedure (const char *func_start, /* 1st byte of func name */
2288 const char *func_end_p1) /* 1st byte after func name */
2289 {
2290 PDR *new_proc_ptr;
2291 efdr_t *file_ptr = cur_file_ptr;
2292 varray_t *vp = &file_ptr->procs;
2293 symint_t value = 0;
2294 st_t proc_type = st_Proc;
2295 shash_t *shash_ptr = hash_string (func_start,
2296 func_end_p1 - func_start,
2297 &orig_str_hash[0],
2298 (symint_t *) 0);
2299
2300 if (debug)
2301 fputc ('\n', stderr);
2302
2303 if (vp->objects_last_page == vp->objects_per_page)
2304 add_varray_page (vp);
2305
2306 cur_proc_ptr = new_proc_ptr = &vp->last->datum->proc[ vp->objects_last_page++ ];
2307
2308 vp->num_allocated++;
2309
2310
2311 /* Did the assembler create this procedure? If so, get the PDR information. */
2312 cur_oproc_ptr = (PDR *) 0;
2313 if (shash_ptr != (shash_t *) 0)
2314 {
2315 PDR *old_proc_ptr = shash_ptr->proc_ptr;
2316 SYMR *sym_ptr = shash_ptr->sym_ptr;
2317
2318 if (old_proc_ptr != (PDR *) 0
2319 && sym_ptr != (SYMR *) 0
2320 && ((st_t) sym_ptr->st == st_Proc || (st_t) sym_ptr->st == st_StaticProc))
2321 {
2322 cur_oproc_begin = sym_ptr;
2323 cur_oproc_end = shash_ptr->end_ptr;
2324 value = sym_ptr->value;
2325
2326 cur_oproc_ptr = old_proc_ptr;
2327 proc_type = (st_t) sym_ptr->st;
2328 *new_proc_ptr = *old_proc_ptr; /* initialize */
2329 }
2330 }
2331
2332 if (cur_oproc_ptr == (PDR *) 0)
2333 error ("did not find a PDR block for %.*s",
2334 (int) (func_end_p1 - func_start), func_start);
2335
2336 /* Determine the start of symbols. */
2337 new_proc_ptr->isym = file_ptr->symbols.num_allocated;
2338
2339 /* Push the start of the function. */
2340 (void) add_local_symbol (func_start, func_end_p1,
2341 proc_type, sc_Text,
2342 value,
2343 (symint_t) 0);
2344 }
2345
2346 \f
2347 /* Initialize the init_file structure. */
2348
2349 STATIC void
2350 initialize_init_file (void)
2351 {
2352 union {
2353 unsigned char c[4];
2354 int i;
2355 } endian_test;
2356
2357 memset (&init_file, 0, sizeof (init_file));
2358
2359 init_file.fdr.lang = langC;
2360 init_file.fdr.fMerge = 1;
2361 init_file.fdr.glevel = GLEVEL_2;
2362
2363 /* mips-tfile doesn't attempt to perform byte swapping and always writes
2364 out integers in its native ordering. For cross-compilers, this need
2365 not be the same as either the host or the target. The simplest thing
2366 to do is skip the configury and perform an introspective test. */
2367 /* ??? Despite the name, mips-tfile is currently only used on alpha/Tru64
2368 and would/may require significant work to be used in cross-compiler
2369 configurations, so we could simply admit defeat and hard code this as
2370 little-endian, i.e. init_file.fdr.fBigendian = 0. */
2371 endian_test.i = 1;
2372 if (endian_test.c[3])
2373 init_file.fdr.fBigendian = 1;
2374
2375 INITIALIZE_VARRAY (&init_file.strings, char);
2376 INITIALIZE_VARRAY (&init_file.symbols, SYMR);
2377 INITIALIZE_VARRAY (&init_file.procs, PDR);
2378 INITIALIZE_VARRAY (&init_file.aux_syms, AUXU);
2379
2380 init_file_initialized = 1;
2381 }
2382
2383 /* Add a new filename, and set up all of the file relative
2384 virtual arrays (strings, symbols, aux syms, etc.). Record
2385 where the current file structure lives. */
2386
2387 STATIC void
2388 add_file (const char *file_start, /* first byte in string */
2389 const char *file_end_p1) /* first byte after string */
2390 {
2391 static char zero_bytes[2] = { '\0', '\0' };
2392
2393 Ptrdiff_t len = file_end_p1 - file_start;
2394 int first_ch = *file_start;
2395 efdr_t *file_ptr;
2396
2397 if (debug)
2398 fprintf (stderr, "\tfile\t%.*s\n", (int) len, file_start);
2399
2400 /* See if the file has already been created. */
2401 for (file_ptr = first_file;
2402 file_ptr != (efdr_t *) 0;
2403 file_ptr = file_ptr->next_file)
2404 {
2405 if (first_ch == file_ptr->name[0]
2406 && file_ptr->name[len] == '\0'
2407 && memcmp (file_start, file_ptr->name, len) == 0)
2408 {
2409 cur_file_ptr = file_ptr;
2410 break;
2411 }
2412 }
2413
2414 /* If this is a new file, create it. */
2415 if (file_ptr == (efdr_t *) 0)
2416 {
2417 if (file_desc.objects_last_page == file_desc.objects_per_page)
2418 add_varray_page (&file_desc);
2419
2420 if (! init_file_initialized)
2421 initialize_init_file ();
2422
2423 file_ptr = cur_file_ptr
2424 = &file_desc.last->datum->file[ file_desc.objects_last_page++ ];
2425 *file_ptr = init_file;
2426
2427 file_ptr->file_index = file_desc.num_allocated++;
2428
2429 /* Allocate the string hash table. */
2430 file_ptr->shash_head = (shash_t **) allocate_page ();
2431
2432 /* Make sure 0 byte in string table is null */
2433 add_string (&file_ptr->strings,
2434 &file_ptr->shash_head[0],
2435 &zero_bytes[0],
2436 &zero_bytes[0],
2437 (shash_t **) 0);
2438
2439 if (file_end_p1 - file_start > (long) PAGE_USIZE-2)
2440 fatal ("filename goes over one page boundary");
2441
2442 /* Push the start of the filename. We assume that the filename
2443 will be stored at string offset 1. */
2444 (void) add_local_symbol (file_start, file_end_p1, st_File, sc_Text,
2445 (symint_t) 0, (symint_t) 0);
2446 file_ptr->fdr.rss = 1;
2447 file_ptr->name = &file_ptr->strings.last->datum->byte[1];
2448 file_ptr->name_len = file_end_p1 - file_start;
2449
2450 /* Update the linked list of file descriptors. */
2451 *last_file_ptr = file_ptr;
2452 last_file_ptr = &file_ptr->next_file;
2453
2454 /* Add void & int types to the file (void should be first to catch
2455 errant 0's within the index fields). */
2456 file_ptr->void_type = add_aux_sym_tir (&void_type_info,
2457 hash_yes,
2458 &cur_file_ptr->thash_head[0]);
2459
2460 file_ptr->int_type = add_aux_sym_tir (&int_type_info,
2461 hash_yes,
2462 &cur_file_ptr->thash_head[0]);
2463 }
2464 }
2465
2466 \f
2467 /* Add a stream of random bytes to a varray. */
2468
2469 STATIC void
2470 add_bytes (varray_t *vp, /* virtual array to add too */
2471 char *input_ptr, /* start of the bytes */
2472 Size_t nitems) /* # items to move */
2473 {
2474 Size_t move_items;
2475 Size_t move_bytes;
2476 char *ptr;
2477
2478 while (nitems > 0)
2479 {
2480 if (vp->objects_last_page >= vp->objects_per_page)
2481 add_varray_page (vp);
2482
2483 ptr = &vp->last->datum->byte[ vp->objects_last_page * vp->object_size ];
2484 move_items = vp->objects_per_page - vp->objects_last_page;
2485 if (move_items > nitems)
2486 move_items = nitems;
2487
2488 move_bytes = move_items * vp->object_size;
2489 nitems -= move_items;
2490
2491 if (move_bytes >= 32)
2492 {
2493 (void) memcpy (ptr, input_ptr, move_bytes);
2494 input_ptr += move_bytes;
2495 }
2496 else
2497 {
2498 while (move_bytes-- > 0)
2499 *ptr++ = *input_ptr++;
2500 }
2501 }
2502 }
2503
2504 \f
2505 /* Convert storage class to string. */
2506
2507 STATIC const char *
2508 sc_to_string (sc_t storage_class)
2509 {
2510 switch (storage_class)
2511 {
2512 case sc_Nil: return "Nil,";
2513 case sc_Text: return "Text,";
2514 case sc_Data: return "Data,";
2515 case sc_Bss: return "Bss,";
2516 case sc_Register: return "Register,";
2517 case sc_Abs: return "Abs,";
2518 case sc_Undefined: return "Undefined,";
2519 case sc_CdbLocal: return "CdbLocal,";
2520 case sc_Bits: return "Bits,";
2521 case sc_CdbSystem: return "CdbSystem,";
2522 case sc_RegImage: return "RegImage,";
2523 case sc_Info: return "Info,";
2524 case sc_UserStruct: return "UserStruct,";
2525 case sc_SData: return "SData,";
2526 case sc_SBss: return "SBss,";
2527 case sc_RData: return "RData,";
2528 case sc_Var: return "Var,";
2529 case sc_Common: return "Common,";
2530 case sc_SCommon: return "SCommon,";
2531 case sc_VarRegister: return "VarRegister,";
2532 case sc_Variant: return "Variant,";
2533 case sc_SUndefined: return "SUndefined,";
2534 case sc_Init: return "Init,";
2535 case sc_Max: return "Max,";
2536 }
2537
2538 return "???,";
2539 }
2540
2541 \f
2542 /* Convert symbol type to string. */
2543
2544 STATIC const char *
2545 st_to_string (st_t symbol_type)
2546 {
2547 switch (symbol_type)
2548 {
2549 case st_Nil: return "Nil,";
2550 case st_Global: return "Global,";
2551 case st_Static: return "Static,";
2552 case st_Param: return "Param,";
2553 case st_Local: return "Local,";
2554 case st_Label: return "Label,";
2555 case st_Proc: return "Proc,";
2556 case st_Block: return "Block,";
2557 case st_End: return "End,";
2558 case st_Member: return "Member,";
2559 case st_Typedef: return "Typedef,";
2560 case st_File: return "File,";
2561 case st_RegReloc: return "RegReloc,";
2562 case st_Forward: return "Forward,";
2563 case st_StaticProc: return "StaticProc,";
2564 case st_Constant: return "Constant,";
2565 case st_Str: return "String,";
2566 case st_Number: return "Number,";
2567 case st_Expr: return "Expr,";
2568 case st_Type: return "Type,";
2569 case st_Max: return "Max,";
2570 }
2571
2572 return "???,";
2573 }
2574
2575 \f
2576 /* Read a line from standard input, and return the start of the buffer
2577 (which is grows if the line is too big). We split lines at the
2578 semi-colon, and return each logical line independently. */
2579
2580 STATIC char *
2581 read_line (void)
2582 {
2583 static int line_split_p = 0;
2584 int string_p = 0;
2585 int comment_p = 0;
2586 int ch;
2587 char *ptr;
2588
2589 if (cur_line_start == (char *) 0)
2590 { /* allocate initial page */
2591 cur_line_start = (char *) allocate_page ();
2592 cur_line_alloc = PAGE_SIZE;
2593 }
2594
2595 if (!line_split_p)
2596 line_number++;
2597
2598 line_split_p = 0;
2599 cur_line_nbytes = 0;
2600
2601 for (ptr = cur_line_start; (ch = getchar ()) != EOF; *ptr++ = ch)
2602 {
2603 if (++cur_line_nbytes >= cur_line_alloc-1)
2604 {
2605 int num_pages = cur_line_alloc / PAGE_SIZE;
2606 char *old_buffer = cur_line_start;
2607
2608 cur_line_alloc += PAGE_SIZE;
2609 cur_line_start = (char *) allocate_multiple_pages (num_pages+1);
2610 memcpy (cur_line_start, old_buffer, num_pages * PAGE_SIZE);
2611
2612 ptr = cur_line_start + cur_line_nbytes - 1;
2613 }
2614
2615 if (ch == '\n')
2616 {
2617 *ptr++ = '\n';
2618 *ptr = '\0';
2619 cur_line_ptr = cur_line_start;
2620 return cur_line_ptr;
2621 }
2622
2623 else if (ch == '\0')
2624 error ("null character found in input");
2625
2626 else if (!comment_p)
2627 {
2628 if (ch == '"')
2629 string_p = !string_p;
2630
2631 else if (ch == '#')
2632 comment_p++;
2633
2634 else if (ch == ';' && !string_p)
2635 {
2636 line_split_p = 1;
2637 *ptr++ = '\n';
2638 *ptr = '\0';
2639 cur_line_ptr = cur_line_start;
2640 return cur_line_ptr;
2641 }
2642 }
2643 }
2644
2645 if (ferror (stdin))
2646 pfatal_with_name (input_name);
2647
2648 cur_line_ptr = (char *) 0;
2649 return (char *) 0;
2650 }
2651
2652 \f
2653 /* Parse #.begin directives which have a label as the first argument
2654 which gives the location of the start of the block. */
2655
2656 STATIC void
2657 parse_begin (const char *start)
2658 {
2659 const char *end_p1; /* end of label */
2660 int ch;
2661 shash_t *hash_ptr; /* hash pointer to lookup label */
2662
2663 if (cur_file_ptr == (efdr_t *) 0)
2664 {
2665 error ("#.begin directive without a preceding .file directive");
2666 return;
2667 }
2668
2669 if (cur_proc_ptr == (PDR *) 0)
2670 {
2671 error ("#.begin directive without a preceding .ent directive");
2672 return;
2673 }
2674
2675 for (end_p1 = start; (ch = *end_p1) != '\0' && !ISSPACE (ch); end_p1++)
2676 ;
2677
2678 hash_ptr = hash_string (start,
2679 end_p1 - start,
2680 &orig_str_hash[0],
2681 (symint_t *) 0);
2682
2683 if (hash_ptr == (shash_t *) 0)
2684 {
2685 error ("label %.*s not found for #.begin",
2686 (int) (end_p1 - start), start);
2687 return;
2688 }
2689
2690 if (cur_oproc_begin == (SYMR *) 0)
2691 {
2692 error ("procedure table %.*s not found for #.begin",
2693 (int) (end_p1 - start), start);
2694 return;
2695 }
2696
2697 (void) add_local_symbol ((const char *) 0, (const char *) 0,
2698 st_Block, sc_Text,
2699 (symint_t) hash_ptr->sym_ptr->value - cur_oproc_begin->value,
2700 (symint_t) 0);
2701 }
2702
2703 \f
2704 /* Parse #.bend directives which have a label as the first argument
2705 which gives the location of the end of the block. */
2706
2707 STATIC void
2708 parse_bend (const char *start)
2709 {
2710 const char *end_p1; /* end of label */
2711 int ch;
2712 shash_t *hash_ptr; /* hash pointer to lookup label */
2713
2714 if (cur_file_ptr == (efdr_t *) 0)
2715 {
2716 error ("#.begin directive without a preceding .file directive");
2717 return;
2718 }
2719
2720 if (cur_proc_ptr == (PDR *) 0)
2721 {
2722 error ("#.bend directive without a preceding .ent directive");
2723 return;
2724 }
2725
2726 for (end_p1 = start; (ch = *end_p1) != '\0' && !ISSPACE (ch); end_p1++)
2727 ;
2728
2729 hash_ptr = hash_string (start,
2730 end_p1 - start,
2731 &orig_str_hash[0],
2732 (symint_t *) 0);
2733
2734 if (hash_ptr == (shash_t *) 0)
2735 {
2736 error ("label %.*s not found for #.bend", (int) (end_p1 - start), start);
2737 return;
2738 }
2739
2740 if (cur_oproc_begin == (SYMR *) 0)
2741 {
2742 error ("procedure table %.*s not found for #.bend",
2743 (int) (end_p1 - start), start);
2744 return;
2745 }
2746
2747 (void) add_local_symbol ((const char *) 0, (const char *) 0,
2748 st_End, sc_Text,
2749 (symint_t) hash_ptr->sym_ptr->value - cur_oproc_begin->value,
2750 (symint_t) 0);
2751 }
2752
2753 \f
2754 /* Parse #.def directives, which are contain standard COFF subdirectives
2755 to describe the debugging format. These subdirectives include:
2756
2757 .scl specify storage class
2758 .val specify a value
2759 .endef specify end of COFF directives
2760 .type specify the type
2761 .size specify the size of an array
2762 .dim specify an array dimension
2763 .tag specify a tag for a struct, union, or enum. */
2764
2765 STATIC void
2766 parse_def (const char *name_start)
2767 {
2768 const char *dir_start; /* start of current directive*/
2769 const char *dir_end_p1; /* end+1 of current directive*/
2770 const char *arg_start; /* start of current argument */
2771 const char *arg_end_p1; /* end+1 of current argument */
2772 const char *name_end_p1; /* end+1 of label */
2773 const char *tag_start = 0; /* start of tag name */
2774 const char *tag_end_p1 = 0; /* end+1 of tag name */
2775 sc_t storage_class = sc_Nil;
2776 st_t symbol_type = st_Nil;
2777 type_info_t t;
2778 EXTR *eptr = (EXTR *) 0; /* ext. sym equivalent to def*/
2779 int is_function = 0; /* != 0 if function */
2780 symint_t value = 0;
2781 symint_t indx = cur_file_ptr->void_type;
2782 int error_line = 0;
2783 symint_t arg_number;
2784 symint_t temp_array[ N_TQ ];
2785 int arg_was_number;
2786 int ch, i;
2787 Ptrdiff_t len;
2788
2789 static int inside_enumeration = 0; /* is this an enumeration? */
2790
2791
2792 /* Initialize the type information. */
2793 t = type_info_init;
2794
2795
2796 /* Search for the end of the name being defined. */
2797 /* Allow spaces and such in names for G++ templates, which produce stabs
2798 that look like:
2799
2800 #.def SMANIP<long unsigned int>; .scl 10; .type 0x8; .size 8; .endef */
2801
2802 for (name_end_p1 = name_start; (ch = *name_end_p1) != ';' && ch != '\0'; name_end_p1++)
2803 ;
2804
2805 if (ch == '\0')
2806 {
2807 error_line = __LINE__;
2808 saber_stop ();
2809 goto bomb_out;
2810 }
2811
2812 /* Parse the remaining subdirectives now. */
2813 dir_start = name_end_p1+1;
2814 for (;;)
2815 {
2816 while ((ch = *dir_start) == ' ' || ch == '\t')
2817 ++dir_start;
2818
2819 if (ch != '.')
2820 {
2821 error_line = __LINE__;
2822 saber_stop ();
2823 goto bomb_out;
2824 }
2825
2826 /* Are we done? */
2827 if (dir_start[1] == 'e'
2828 && memcmp (dir_start, ".endef", sizeof (".endef")-1) == 0)
2829 break;
2830
2831 /* Pick up the subdirective now. */
2832 for (dir_end_p1 = dir_start+1;
2833 (ch = *dir_end_p1) != ' ' && ch != '\t';
2834 dir_end_p1++)
2835 {
2836 if (ch == '\0' || ISSPACE (ch))
2837 {
2838 error_line = __LINE__;
2839 saber_stop ();
2840 goto bomb_out;
2841 }
2842 }
2843
2844 /* Pick up the subdirective argument now. */
2845 arg_was_number = arg_number = 0;
2846 arg_end_p1 = 0;
2847 arg_start = dir_end_p1+1;
2848 ch = *arg_start;
2849 while (ch == ' ' || ch == '\t')
2850 ch = *++arg_start;
2851
2852 if (ISDIGIT (ch) || ch == '-' || ch == '+')
2853 {
2854 int ch2;
2855 arg_number = strtol (arg_start, (char **) &arg_end_p1, 0);
2856 /* It's only a number if followed by ';' or ','. */
2857 if (arg_end_p1 != arg_start && (((ch2 = *arg_end_p1) == ';') || ch2 == ','))
2858 arg_was_number++;
2859 }
2860
2861 else if (ch == '\0' || ISSPACE (ch))
2862 {
2863 error_line = __LINE__;
2864 saber_stop ();
2865 goto bomb_out;
2866 }
2867
2868 if (!arg_was_number)
2869 {
2870 /* Allow spaces and such in names for G++ templates. */
2871 for (arg_end_p1 = arg_start+1;
2872 (ch = *arg_end_p1) != ';' && ch != '\0';
2873 arg_end_p1++)
2874 ;
2875
2876 if (ch == '\0')
2877 {
2878 error_line = __LINE__;
2879 saber_stop ();
2880 goto bomb_out;
2881 }
2882 }
2883
2884 /* Classify the directives now. */
2885 len = dir_end_p1 - dir_start;
2886 switch (dir_start[1])
2887 {
2888 default:
2889 error_line = __LINE__;
2890 saber_stop ();
2891 goto bomb_out;
2892
2893 case 'd':
2894 if (len == sizeof (".dim")-1
2895 && memcmp (dir_start, ".dim", sizeof (".dim")-1) == 0
2896 && arg_was_number)
2897 {
2898 symint_t *t_ptr = &temp_array[ N_TQ-1 ];
2899
2900 *t_ptr = arg_number;
2901 while (*arg_end_p1 == ',' && arg_was_number)
2902 {
2903 arg_start = arg_end_p1+1;
2904 ch = *arg_start;
2905 while (ch == ' ' || ch == '\t')
2906 ch = *++arg_start;
2907
2908 arg_was_number = 0;
2909 if (ISDIGIT (ch) || ch == '-' || ch == '+')
2910 {
2911 int ch2;
2912 arg_number = strtol (arg_start, (char **) &arg_end_p1, 0);
2913 if (arg_end_p1 != arg_start && (((ch2 = *arg_end_p1) == ';') || ch2 == ','))
2914 arg_was_number++;
2915
2916 if (t_ptr == &temp_array[0])
2917 {
2918 error_line = __LINE__;
2919 saber_stop ();
2920 goto bomb_out;
2921 }
2922
2923 *--t_ptr = arg_number;
2924 }
2925 }
2926
2927 /* Reverse order of dimensions. */
2928 while (t_ptr <= &temp_array[ N_TQ-1 ])
2929 {
2930 if (t.num_dims >= N_TQ-1)
2931 {
2932 error_line = __LINE__;
2933 saber_stop ();
2934 goto bomb_out;
2935 }
2936
2937 t.dimensions[ t.num_dims++ ] = *t_ptr++;
2938 }
2939 break;
2940 }
2941 else
2942 {
2943 error_line = __LINE__;
2944 saber_stop ();
2945 goto bomb_out;
2946 }
2947
2948
2949 case 's':
2950 if (len == sizeof (".scl")-1
2951 && memcmp (dir_start, ".scl", sizeof (".scl")-1) == 0
2952 && arg_was_number
2953 && arg_number < ((symint_t) C_MAX))
2954 {
2955 /* If the symbol is a static or external, we have
2956 already gotten the appropriate type and class, so
2957 make sure we don't override those values. This is
2958 needed because there are some type and classes that
2959 are not in COFF, such as short data, etc. */
2960 if (symbol_type == st_Nil)
2961 {
2962 symbol_type = map_coff_sym_type[arg_number];
2963 storage_class = map_coff_storage [arg_number];
2964 }
2965 break;
2966 }
2967
2968 else if (len == sizeof (".size")-1
2969 && memcmp (dir_start, ".size", sizeof (".size")-1) == 0
2970 && arg_was_number)
2971 {
2972 symint_t *t_ptr = &temp_array[ N_TQ-1 ];
2973
2974 *t_ptr = arg_number;
2975 while (*arg_end_p1 == ',' && arg_was_number)
2976 {
2977 arg_start = arg_end_p1+1;
2978 ch = *arg_start;
2979 while (ch == ' ' || ch == '\t')
2980 ch = *++arg_start;
2981
2982 arg_was_number = 0;
2983 if (ISDIGIT (ch) || ch == '-' || ch == '+')
2984 {
2985 int ch2;
2986 arg_number = strtol (arg_start, (char **) &arg_end_p1, 0);
2987 if (arg_end_p1 != arg_start && (((ch2 = *arg_end_p1) == ';') || ch2 == ','))
2988 arg_was_number++;
2989
2990 if (t_ptr == &temp_array[0])
2991 {
2992 error_line = __LINE__;
2993 saber_stop ();
2994 goto bomb_out;
2995 }
2996
2997 *--t_ptr = arg_number;
2998 }
2999 }
3000
3001 /* Reverse order of sizes. */
3002 while (t_ptr <= &temp_array[ N_TQ-1 ])
3003 {
3004 if (t.num_sizes >= N_TQ-1)
3005 {
3006 error_line = __LINE__;
3007 saber_stop ();
3008 goto bomb_out;
3009 }
3010
3011 t.sizes[ t.num_sizes++ ] = *t_ptr++;
3012 }
3013 break;
3014 }
3015
3016 else
3017 {
3018 error_line = __LINE__;
3019 saber_stop ();
3020 goto bomb_out;
3021 }
3022
3023
3024 case 't':
3025 if (len == sizeof (".type")-1
3026 && memcmp (dir_start, ".type", sizeof (".type")-1) == 0
3027 && arg_was_number)
3028 {
3029 tq_t *tq_ptr = &t.type_qualifiers[0];
3030
3031 t.orig_type = (coff_type_t) (arg_number & N_BTMASK);
3032 t.basic_type = map_coff_types [(int) t.orig_type];
3033 for (i = N_TQ-1; i >= 0; i--)
3034 {
3035 int dt = (arg_number >> ((i * N_TQ_SHIFT) + N_BT_SHIFT)
3036 & N_TMASK);
3037
3038 if (dt != (int) DT_NON)
3039 *tq_ptr++ = map_coff_derived_type [dt];
3040 }
3041
3042 /* If this is a function, ignore it, so that we don't get
3043 two entries (one from the .ent, and one for the .def
3044 that precedes it). Save the type information so that
3045 the end block can properly add it after the begin block
3046 index. For MIPS knows what reason, we must strip off
3047 the function type at this point. */
3048 if (tq_ptr != &t.type_qualifiers[0] && tq_ptr[-1] == tq_Proc)
3049 {
3050 is_function = 1;
3051 tq_ptr[-1] = tq_Nil;
3052 }
3053
3054 break;
3055 }
3056
3057 else if (len == sizeof (".tag")-1
3058 && memcmp (dir_start, ".tag", sizeof (".tag")-1) == 0)
3059 {
3060 tag_start = arg_start;
3061 tag_end_p1 = arg_end_p1;
3062 break;
3063 }
3064
3065 else
3066 {
3067 error_line = __LINE__;
3068 saber_stop ();
3069 goto bomb_out;
3070 }
3071
3072
3073 case 'v':
3074 if (len == sizeof (".val")-1
3075 && memcmp (dir_start, ".val", sizeof (".val")-1) == 0)
3076 {
3077 if (arg_was_number)
3078 value = arg_number;
3079
3080 /* If the value is not an integer value, it must be the
3081 name of a static or global item. Look up the name in
3082 the original symbol table to pick up the storage
3083 class, symbol type, etc. */
3084 else
3085 {
3086 shash_t *orig_hash_ptr; /* hash within orig sym table*/
3087 shash_t *ext_hash_ptr; /* hash within ext. sym table*/
3088
3089 ext_hash_ptr = hash_string (arg_start,
3090 arg_end_p1 - arg_start,
3091 &ext_str_hash[0],
3092 (symint_t *) 0);
3093
3094 if (ext_hash_ptr != (shash_t *) 0
3095 && ext_hash_ptr->esym_ptr != (EXTR *) 0)
3096 eptr = ext_hash_ptr->esym_ptr;
3097
3098 orig_hash_ptr = hash_string (arg_start,
3099 arg_end_p1 - arg_start,
3100 &orig_str_hash[0],
3101 (symint_t *) 0);
3102
3103 if ((orig_hash_ptr == (shash_t *) 0
3104 || orig_hash_ptr->sym_ptr == (SYMR *) 0)
3105 && eptr == (EXTR *) 0)
3106 {
3107 fprintf (stderr, "warning, %.*s not found in original or external symbol tables, value defaults to 0\n",
3108 (int) (arg_end_p1 - arg_start),
3109 arg_start);
3110 value = 0;
3111 }
3112 else
3113 {
3114 SYMR *ptr = (orig_hash_ptr != (shash_t *) 0
3115 && orig_hash_ptr->sym_ptr != (SYMR *) 0)
3116 ? orig_hash_ptr->sym_ptr
3117 : &eptr->asym;
3118
3119 symbol_type = (st_t) ptr->st;
3120 storage_class = (sc_t) ptr->sc;
3121 value = ptr->value;
3122 }
3123 }
3124 break;
3125 }
3126 else
3127 {
3128 error_line = __LINE__;
3129 saber_stop ();
3130 goto bomb_out;
3131 }
3132 }
3133
3134 /* Set up to find next directive. */
3135 dir_start = arg_end_p1 + 1;
3136 }
3137
3138
3139 if (storage_class == sc_Bits)
3140 {
3141 t.bitfield = 1;
3142 t.extra_sizes = 1;
3143 }
3144 else
3145 t.extra_sizes = 0;
3146
3147 if (t.num_dims > 0)
3148 {
3149 int num_real_sizes = t.num_sizes - t.extra_sizes;
3150 int diff = t.num_dims - num_real_sizes;
3151 int i = t.num_dims - 1;
3152 int j;
3153
3154 if (num_real_sizes != 1 || diff < 0)
3155 {
3156 error_line = __LINE__;
3157 saber_stop ();
3158 goto bomb_out;
3159 }
3160
3161 /* If this is an array, make sure the same number of dimensions
3162 and sizes were passed, creating extra sizes for multiply
3163 dimensioned arrays if not passed. */
3164
3165 if (diff)
3166 {
3167 for (j = ARRAY_SIZE (t.sizes) - 1; j >= 0; j--)
3168 t.sizes[ j ] = ((j-diff) >= 0) ? t.sizes[ j-diff ] : 0;
3169
3170 t.num_sizes = i + 1;
3171 for ( i--; i >= 0; i-- )
3172 {
3173 if (t.dimensions[ i+1 ])
3174 t.sizes[ i ] = t.sizes[ i+1 ] / t.dimensions[ i+1 ];
3175 else
3176 t.sizes[ i ] = t.sizes[ i+1 ];
3177 }
3178 }
3179 }
3180
3181 /* Except for enumeration members & begin/ending of scopes, put the
3182 type word in the aux. symbol table. */
3183
3184 if (symbol_type == st_Block || symbol_type == st_End)
3185 indx = 0;
3186
3187 else if (inside_enumeration)
3188 indx = cur_file_ptr->void_type;
3189
3190 else
3191 {
3192 if (t.basic_type == bt_Struct
3193 || t.basic_type == bt_Union
3194 || t.basic_type == bt_Enum)
3195 {
3196 if (tag_start == (char *) 0)
3197 {
3198 error ("no tag specified for %.*s",
3199 (int) (name_end_p1 - name_start),
3200 name_start);
3201 return;
3202 }
3203
3204 t.tag_ptr = get_tag (tag_start, tag_end_p1, (symint_t) indexNil,
3205 t.basic_type);
3206 }
3207
3208 if (is_function)
3209 {
3210 last_func_type_info = t;
3211 last_func_eptr = eptr;
3212 return;
3213 }
3214
3215 indx = add_aux_sym_tir (&t,
3216 hash_yes,
3217 &cur_file_ptr->thash_head[0]);
3218 }
3219
3220
3221 /* If this is an external or static symbol, update the appropriate
3222 external symbol. */
3223
3224 if (eptr != (EXTR *) 0
3225 && (eptr->asym.index == indexNil || cur_proc_ptr == (PDR *) 0))
3226 {
3227 eptr->ifd = cur_file_ptr->file_index;
3228 eptr->asym.index = indx;
3229 }
3230
3231
3232 /* Do any last minute adjustments that are necessary. */
3233 switch (symbol_type)
3234 {
3235 default:
3236 break;
3237
3238
3239 /* For the beginning of structs, unions, and enumerations, the
3240 size info needs to be passed in the value field. */
3241
3242 case st_Block:
3243 if (t.num_sizes - t.num_dims - t.extra_sizes != 1)
3244 {
3245 error_line = __LINE__;
3246 saber_stop ();
3247 goto bomb_out;
3248 }
3249
3250 else
3251 value = t.sizes[0];
3252
3253 inside_enumeration = (t.orig_type == T_ENUM);
3254 break;
3255
3256
3257 /* For the end of structs, unions, and enumerations, omit the
3258 name which is always ".eos". This needs to be done last, so
3259 that any error reporting above gives the correct name. */
3260
3261 case st_End:
3262 name_start = name_end_p1 = 0;
3263 value = inside_enumeration = 0;
3264 break;
3265
3266
3267 /* Members of structures and unions that aren't bitfields, need
3268 to adjust the value from a byte offset to a bit offset.
3269 Members of enumerations do not have the value adjusted, and
3270 can be distinguished by indx == indexNil. For enumerations,
3271 update the maximum enumeration value. */
3272
3273 case st_Member:
3274 if (!t.bitfield && !inside_enumeration)
3275 value *= 8;
3276
3277 break;
3278 }
3279
3280
3281 /* Add the symbol, except for global symbols outside of functions,
3282 for which the external symbol table is fine enough. */
3283
3284 if (eptr == (EXTR *) 0
3285 || eptr->asym.st == (int) st_Nil
3286 || cur_proc_ptr != (PDR *) 0)
3287 {
3288 symint_t isym = add_local_symbol (name_start, name_end_p1,
3289 symbol_type, storage_class,
3290 value,
3291 indx);
3292
3293 /* Deal with struct, union, and enum tags. */
3294 if (symbol_type == st_Block)
3295 {
3296 /* Create or update the tag information. */
3297 tag_t *tag_ptr = get_tag (name_start,
3298 name_end_p1,
3299 isym,
3300 t.basic_type);
3301
3302 /* If there are any forward references, fill in the appropriate
3303 file and symbol indexes. */
3304
3305 symint_t file_index = cur_file_ptr->file_index;
3306 forward_t *f_next = tag_ptr->forward_ref;
3307 forward_t *f_cur;
3308
3309 while (f_next != (forward_t *) 0)
3310 {
3311 f_cur = f_next;
3312 f_next = f_next->next;
3313
3314 f_cur->ifd_ptr->isym = file_index;
3315 f_cur->index_ptr->rndx.index = isym;
3316
3317 free_forward (f_cur);
3318 }
3319
3320 tag_ptr->forward_ref = (forward_t *) 0;
3321 }
3322 }
3323
3324 /* Normal return */
3325 return;
3326
3327 /* Error return, issue message. */
3328 bomb_out:
3329 if (error_line)
3330 error ("compiler error, badly formed #.def (internal line # = %d)", error_line);
3331 else
3332 error ("compiler error, badly formed #.def");
3333
3334 return;
3335 }
3336
3337 \f
3338 /* Parse .end directives. */
3339
3340 STATIC void
3341 parse_end (const char *start)
3342 {
3343 const char *start_func, *end_func_p1;
3344 int ch;
3345 symint_t value;
3346 FDR *orig_fdr;
3347
3348 if (cur_file_ptr == (efdr_t *) 0)
3349 {
3350 error (".end directive without a preceding .file directive");
3351 return;
3352 }
3353
3354 if (cur_proc_ptr == (PDR *) 0)
3355 {
3356 error (".end directive without a preceding .ent directive");
3357 return;
3358 }
3359
3360 /* Get the function name, skipping whitespace. */
3361 for (start_func = start; ISSPACE ((unsigned char)*start_func); start_func++)
3362 ;
3363
3364 ch = *start_func;
3365 if (!IS_ASM_IDENT (ch))
3366 {
3367 error (".end directive has no name");
3368 return;
3369 }
3370
3371 for (end_func_p1 = start_func; IS_ASM_IDENT (ch); ch = *++end_func_p1)
3372 ;
3373
3374
3375 /* Get the value field for creating the end from the original object
3376 file (which we find by locating the procedure start, and using the
3377 pointer to the end+1 block and backing up. The index points to a
3378 two word aux. symbol, whose first word is the index of the end
3379 symbol, and the second word is the type of the function return
3380 value. */
3381
3382 orig_fdr = cur_file_ptr->orig_fdr;
3383 value = 0;
3384 if (orig_fdr != (FDR *) 0 && cur_oproc_end != (SYMR *) 0)
3385 value = cur_oproc_end->value;
3386
3387 else
3388 error ("cannot find .end block for %.*s",
3389 (int) (end_func_p1 - start_func), start_func);
3390
3391 (void) add_local_symbol (start_func, end_func_p1,
3392 st_End, sc_Text,
3393 value,
3394 (symint_t) 0);
3395
3396 cur_proc_ptr = cur_oproc_ptr = (PDR *) 0;
3397 }
3398
3399 \f
3400 /* Parse .ent directives. */
3401
3402 STATIC void
3403 parse_ent (const char *start)
3404 {
3405 const char *start_func, *end_func_p1;
3406 int ch;
3407
3408 if (cur_file_ptr == (efdr_t *) 0)
3409 {
3410 error (".ent directive without a preceding .file directive");
3411 return;
3412 }
3413
3414 if (cur_proc_ptr != (PDR *) 0)
3415 {
3416 error ("second .ent directive found before .end directive");
3417 return;
3418 }
3419
3420 for (start_func = start; ISSPACE ((unsigned char)*start_func); start_func++)
3421 ;
3422
3423 ch = *start_func;
3424 if (!IS_ASM_IDENT (ch))
3425 {
3426 error (".ent directive has no name");
3427 return;
3428 }
3429
3430 for (end_func_p1 = start_func; IS_ASM_IDENT (ch); ch = *++end_func_p1)
3431 ;
3432
3433 (void) add_procedure (start_func, end_func_p1);
3434 }
3435
3436 \f
3437 /* Parse .file directives. */
3438
3439 STATIC void
3440 parse_file (const char *start)
3441 {
3442 char *p;
3443 char *start_name, *end_name_p1;
3444
3445 (void) strtol (start, &p, 0);
3446 if (start == p
3447 || (start_name = strchr (p, '"')) == (char *) 0
3448 || (end_name_p1 = strrchr (++start_name, '"')) == (char *) 0)
3449 {
3450 error ("invalid .file directive");
3451 return;
3452 }
3453
3454 if (cur_proc_ptr != (PDR *) 0)
3455 {
3456 error ("no way to handle .file within .ent/.end section");
3457 return;
3458 }
3459
3460 add_file (start_name, end_name_p1);
3461 }
3462
3463 \f
3464 /* Make sure the @stabs symbol is emitted. */
3465
3466 static void
3467 mark_stabs (const char *start ATTRIBUTE_UNUSED)
3468 {
3469 if (!stabs_seen)
3470 {
3471 /* Add a dummy @stabs symbol. */
3472 stabs_seen = 1;
3473 (void) add_local_symbol (stabs_symbol,
3474 stabs_symbol + sizeof (stabs_symbol),
3475 (st_t) stNil, (sc_t) scInfo, -1,
3476 MIPS_MARK_STAB (0));
3477
3478 }
3479 }
3480
3481 \f
3482 /* Parse .stabs directives.
3483
3484 .stabs directives have five fields:
3485 "string" a string, encoding the type information.
3486 code a numeric code, defined in <stab.h>
3487 0 a zero
3488 0 a zero or line number
3489 value a numeric value or an address.
3490
3491 If the value is relocatable, we transform this into:
3492 iss points as an index into string space
3493 value value from lookup of the name
3494 st st from lookup of the name
3495 sc sc from lookup of the name
3496 index code|CODE_MASK
3497
3498 If the value is not relocatable, we transform this into:
3499 iss points as an index into string space
3500 value value
3501 st st_Nil
3502 sc sc_Nil
3503 index code|CODE_MASK
3504
3505 .stabn directives have four fields (string is null):
3506 code a numeric code, defined in <stab.h>
3507 0 a zero
3508 0 a zero or a line number
3509 value a numeric value or an address. */
3510
3511 STATIC void
3512 parse_stabs_common (const char *string_start, /* start of string or NULL */
3513 const char *string_end, /* end+1 of string or NULL */
3514 const char *rest) /* rest of the directive. */
3515 {
3516 efdr_t *save_file_ptr = cur_file_ptr;
3517 symint_t code;
3518 symint_t value;
3519 char *p;
3520 st_t st;
3521 sc_t sc;
3522 int ch;
3523
3524 if (stabs_seen == 0)
3525 mark_stabs ("");
3526
3527 /* Read code from stabs. */
3528 if (!ISDIGIT (*rest))
3529 {
3530 error ("invalid .stabs/.stabn directive, code is non-numeric");
3531 return;
3532 }
3533
3534 code = strtol (rest, &p, 0);
3535
3536 /* Line number stabs are handled differently, since they have two values,
3537 the line number and the address of the label. We use the index field
3538 (aka code) to hold the line number, and the value field to hold the
3539 address. The symbol type is st_Label, which should be different from
3540 the other stabs, so that gdb can recognize it. */
3541
3542 if (code == (int) N_SLINE)
3543 {
3544 SYMR *sym_ptr, dummy_symr;
3545 shash_t *shash_ptr;
3546
3547 /* Skip ,0, */
3548 if (p[0] != ',' || p[1] != '0' || p[2] != ',' || !ISDIGIT (p[3]))
3549 {
3550 error ("invalid line number .stabs/.stabn directive");
3551 return;
3552 }
3553
3554 code = strtol (p+3, &p, 0);
3555 ch = *++p;
3556 if (p[-1] != ',' || ISDIGIT (ch) || !IS_ASM_IDENT (ch))
3557 {
3558 error ("invalid line number .stabs/.stabn directive");
3559 return;
3560 }
3561
3562 dummy_symr.index = code;
3563 if (dummy_symr.index != code)
3564 {
3565 error ("line number (%lu) for .stabs/.stabn directive cannot fit in index field (20 bits)",
3566 code);
3567
3568 return;
3569 }
3570
3571 shash_ptr = hash_string (p,
3572 strlen (p) - 1,
3573 &orig_str_hash[0],
3574 (symint_t *) 0);
3575
3576 if (shash_ptr == (shash_t *) 0
3577 || (sym_ptr = shash_ptr->sym_ptr) == (SYMR *) 0)
3578 {
3579 error ("invalid .stabs/.stabn directive, value not found");
3580 return;
3581 }
3582
3583 if ((st_t) sym_ptr->st != st_Label)
3584 {
3585 error ("invalid line number .stabs/.stabn directive");
3586 return;
3587 }
3588
3589 st = st_Label;
3590 sc = (sc_t) sym_ptr->sc;
3591 value = sym_ptr->value;
3592 }
3593 else
3594 {
3595 /* Skip ,<num>,<num>, */
3596 if (*p++ != ',')
3597 goto failure;
3598 for (; ISDIGIT (*p); p++)
3599 ;
3600 if (*p++ != ',')
3601 goto failure;
3602 for (; ISDIGIT (*p); p++)
3603 ;
3604 if (*p++ != ',')
3605 goto failure;
3606 ch = *p;
3607 if (!IS_ASM_IDENT (ch) && ch != '-')
3608 {
3609 failure:
3610 error ("invalid .stabs/.stabn directive, bad character");
3611 return;
3612 }
3613
3614 if (ISDIGIT (ch) || ch == '-')
3615 {
3616 st = st_Nil;
3617 sc = sc_Nil;
3618 value = strtol (p, &p, 0);
3619 if (*p != '\n')
3620 {
3621 error ("invalid .stabs/.stabn directive, stuff after numeric value");
3622 return;
3623 }
3624 }
3625 else if (!IS_ASM_IDENT (ch))
3626 {
3627 error ("invalid .stabs/.stabn directive, bad character");
3628 return;
3629 }
3630 else
3631 {
3632 SYMR *sym_ptr;
3633 shash_t *shash_ptr;
3634 const char *start, *end_p1;
3635
3636 start = p;
3637 if ((end_p1 = strchr (start, '+')) == (char *) 0)
3638 {
3639 if ((end_p1 = strchr (start, '-')) == (char *) 0)
3640 end_p1 = start + strlen (start) - 1;
3641 }
3642
3643 shash_ptr = hash_string (start,
3644 end_p1 - start,
3645 &orig_str_hash[0],
3646 (symint_t *) 0);
3647
3648 if (shash_ptr == (shash_t *) 0
3649 || (sym_ptr = shash_ptr->sym_ptr) == (SYMR *) 0)
3650 {
3651 shash_ptr = hash_string (start,
3652 end_p1 - start,
3653 &ext_str_hash[0],
3654 (symint_t *) 0);
3655
3656 if (shash_ptr == (shash_t *) 0
3657 || shash_ptr->esym_ptr == (EXTR *) 0)
3658 {
3659 error ("invalid .stabs/.stabn directive, value not found");
3660 return;
3661 }
3662 else
3663 sym_ptr = &(shash_ptr->esym_ptr->asym);
3664 }
3665
3666 /* Traditionally, N_LBRAC and N_RBRAC are *not* relocated. */
3667 if (code == (int) N_LBRAC || code == (int) N_RBRAC)
3668 {
3669 sc = (sc_t) scNil;
3670 st = (st_t) stNil;
3671 }
3672 else
3673 {
3674 sc = (sc_t) sym_ptr->sc;
3675 st = (st_t) sym_ptr->st;
3676 }
3677 value = sym_ptr->value;
3678
3679 ch = *end_p1++;
3680 if (ch != '\n')
3681 {
3682 if (((!ISDIGIT (*end_p1)) && (*end_p1 != '-'))
3683 || ((ch != '+') && (ch != '-')))
3684 {
3685 error ("invalid .stabs/.stabn directive, badly formed value");
3686 return;
3687 }
3688 if (ch == '+')
3689 value += strtol (end_p1, &p, 0);
3690 else if (ch == '-')
3691 value -= strtol (end_p1, &p, 0);
3692
3693 if (*p != '\n')
3694 {
3695 error ("invalid .stabs/.stabn directive, stuff after numeric value");
3696 return;
3697 }
3698 }
3699 }
3700 code = MIPS_MARK_STAB (code);
3701 }
3702
3703 (void) add_local_symbol (string_start, string_end, st, sc, value, code);
3704 /* Restore normal file type. */
3705 cur_file_ptr = save_file_ptr;
3706 }
3707
3708
3709 STATIC void
3710 parse_stabs (const char *start)
3711 {
3712 const char *end = strchr (start+1, '"');
3713
3714 if (*start != '"' || end == (const char *) 0 || end[1] != ',')
3715 {
3716 error ("invalid .stabs directive, no string");
3717 return;
3718 }
3719
3720 parse_stabs_common (start+1, end, end+2);
3721 }
3722
3723
3724 STATIC void
3725 parse_stabn (const char *start)
3726 {
3727 parse_stabs_common ((const char *) 0, (const char *) 0, start);
3728 }
3729
3730 \f
3731 /* Parse the input file, and write the lines to the output file
3732 if needed. */
3733
3734 STATIC void
3735 parse_input (void)
3736 {
3737 char *p;
3738 Size_t i;
3739 thead_t *ptag_head;
3740 tag_t *ptag;
3741 tag_t *ptag_next;
3742
3743 if (debug)
3744 fprintf (stderr, "\tinput\n");
3745
3746 /* Add a dummy scope block around the entire compilation unit for
3747 structures defined outside of blocks. */
3748 ptag_head = allocate_thead ();
3749 ptag_head->first_tag = 0;
3750 ptag_head->prev = cur_tag_head;
3751 cur_tag_head = ptag_head;
3752
3753 while ((p = read_line ()) != (char *) 0)
3754 {
3755 /* Skip leading blanks. */
3756 while (ISSPACE ((unsigned char)*p))
3757 p++;
3758
3759 /* See if it's a directive we handle. If so, dispatch handler. */
3760 for (i = 0; i < ARRAY_SIZE (pseudo_ops); i++)
3761 if (memcmp (p, pseudo_ops[i].name, pseudo_ops[i].len) == 0
3762 && ISSPACE ((unsigned char)(p[pseudo_ops[i].len])))
3763 {
3764 p += pseudo_ops[i].len; /* skip to first argument */
3765 while (ISSPACE ((unsigned char)*p))
3766 p++;
3767
3768 (*pseudo_ops[i].func)( p );
3769 break;
3770 }
3771 }
3772
3773 /* Process any tags at global level. */
3774 ptag_head = cur_tag_head;
3775 cur_tag_head = ptag_head->prev;
3776
3777 for (ptag = ptag_head->first_tag;
3778 ptag != (tag_t *) 0;
3779 ptag = ptag_next)
3780 {
3781 if (ptag->forward_ref != (forward_t *) 0)
3782 add_unknown_tag (ptag);
3783
3784 ptag_next = ptag->same_block;
3785 ptag->hash_ptr->tag_ptr = ptag->same_name;
3786 free_tag (ptag);
3787 }
3788
3789 free_thead (ptag_head);
3790
3791 }
3792
3793 \f
3794 /* Update the global headers with the final offsets in preparation
3795 to write out the .T file. */
3796
3797 STATIC void
3798 update_headers (void)
3799 {
3800 symint_t i;
3801 efdr_t *file_ptr;
3802
3803 /* Set up the symbolic header. */
3804 file_offset = sizeof (symbolic_header) + orig_file_header.f_symptr;
3805 symbolic_header.magic = orig_sym_hdr.magic;
3806 symbolic_header.vstamp = orig_sym_hdr.vstamp;
3807
3808 /* Set up global counts. */
3809 symbolic_header.issExtMax = ext_strings.num_allocated;
3810 symbolic_header.idnMax = dense_num.num_allocated;
3811 symbolic_header.ifdMax = file_desc.num_allocated;
3812 symbolic_header.iextMax = ext_symbols.num_allocated;
3813 symbolic_header.ilineMax = orig_sym_hdr.ilineMax;
3814 symbolic_header.ioptMax = orig_sym_hdr.ioptMax;
3815 symbolic_header.cbLine = orig_sym_hdr.cbLine;
3816 symbolic_header.crfd = orig_sym_hdr.crfd;
3817
3818
3819 /* Loop through each file, figuring out how many local syms,
3820 line numbers, etc. there are. Also, put out end symbol
3821 for the filename. */
3822
3823 for (file_ptr = first_file;
3824 file_ptr != (efdr_t *) 0;
3825 file_ptr = file_ptr->next_file)
3826 {
3827 SYMR *sym_start;
3828 SYMR *sym;
3829 SYMR *sym_end_p1;
3830 FDR *fd_ptr = file_ptr->orig_fdr;
3831
3832 cur_file_ptr = file_ptr;
3833
3834 /* Copy st_Static symbols from the original local symbol table if
3835 they did not get added to the new local symbol table.
3836 This happens with stabs-in-ecoff or if the source file is
3837 compiled without debugging. */
3838 sym_start = ORIG_LSYMS (fd_ptr->isymBase);
3839 sym_end_p1 = sym_start + fd_ptr->csym;
3840 for (sym = sym_start; sym < sym_end_p1; sym++)
3841 {
3842 if ((st_t) sym->st == st_Static)
3843 {
3844 char *str = ORIG_LSTRS (fd_ptr->issBase + sym->iss);
3845 Size_t len = strlen (str);
3846 shash_t *hash_ptr;
3847
3848 /* Ignore internal labels. */
3849 if (str[0] == '$' && str[1] == 'L')
3850 continue;
3851 hash_ptr = hash_string (str,
3852 (Ptrdiff_t) len,
3853 &file_ptr->shash_head[0],
3854 (symint_t *) 0);
3855 if (hash_ptr == (shash_t *) 0)
3856 {
3857 (void) add_local_symbol (str, str + len,
3858 (st_t) sym->st, (sc_t) sym->sc,
3859 (symint_t) sym->value,
3860 (symint_t) indexNil);
3861 }
3862 }
3863 }
3864 (void) add_local_symbol ((const char *) 0, (const char *) 0,
3865 st_End, sc_Text,
3866 (symint_t) 0,
3867 (symint_t) 0);
3868
3869 file_ptr->fdr.cpd = file_ptr->procs.num_allocated;
3870 file_ptr->fdr.ipdFirst = symbolic_header.ipdMax;
3871 symbolic_header.ipdMax += file_ptr->fdr.cpd;
3872
3873 file_ptr->fdr.csym = file_ptr->symbols.num_allocated;
3874 file_ptr->fdr.isymBase = symbolic_header.isymMax;
3875 symbolic_header.isymMax += file_ptr->fdr.csym;
3876
3877 file_ptr->fdr.caux = file_ptr->aux_syms.num_allocated;
3878 file_ptr->fdr.iauxBase = symbolic_header.iauxMax;
3879 symbolic_header.iauxMax += file_ptr->fdr.caux;
3880
3881 file_ptr->fdr.cbSs = file_ptr->strings.num_allocated;
3882 file_ptr->fdr.issBase = symbolic_header.issMax;
3883 symbolic_header.issMax += file_ptr->fdr.cbSs;
3884 }
3885
3886 #ifndef ALIGN_SYMTABLE_OFFSET
3887 #define ALIGN_SYMTABLE_OFFSET(OFFSET) (OFFSET)
3888 #endif
3889
3890 file_offset = ALIGN_SYMTABLE_OFFSET (file_offset);
3891 i = WORD_ALIGN (symbolic_header.cbLine); /* line numbers */
3892 if (i > 0)
3893 {
3894 symbolic_header.cbLineOffset = file_offset;
3895 file_offset += i;
3896 file_offset = ALIGN_SYMTABLE_OFFSET (file_offset);
3897 }
3898
3899 i = symbolic_header.ioptMax; /* optimization symbols */
3900 if (((long) i) > 0)
3901 {
3902 symbolic_header.cbOptOffset = file_offset;
3903 file_offset += i * sizeof (OPTR);
3904 file_offset = ALIGN_SYMTABLE_OFFSET (file_offset);
3905 }
3906
3907 i = symbolic_header.idnMax; /* dense numbers */
3908 if (i > 0)
3909 {
3910 symbolic_header.cbDnOffset = file_offset;
3911 file_offset += i * sizeof (DNR);
3912 file_offset = ALIGN_SYMTABLE_OFFSET (file_offset);
3913 }
3914
3915 i = symbolic_header.ipdMax; /* procedure tables */
3916 if (i > 0)
3917 {
3918 symbolic_header.cbPdOffset = file_offset;
3919 file_offset += i * sizeof (PDR);
3920 file_offset = ALIGN_SYMTABLE_OFFSET (file_offset);
3921 }
3922
3923 i = symbolic_header.isymMax; /* local symbols */
3924 if (i > 0)
3925 {
3926 symbolic_header.cbSymOffset = file_offset;
3927 file_offset += i * sizeof (SYMR);
3928 file_offset = ALIGN_SYMTABLE_OFFSET (file_offset);
3929 }
3930
3931 i = symbolic_header.iauxMax; /* aux syms. */
3932 if (i > 0)
3933 {
3934 symbolic_header.cbAuxOffset = file_offset;
3935 file_offset += i * sizeof (TIR);
3936 file_offset = ALIGN_SYMTABLE_OFFSET (file_offset);
3937 }
3938
3939 i = WORD_ALIGN (symbolic_header.issMax); /* local strings */
3940 if (i > 0)
3941 {
3942 symbolic_header.cbSsOffset = file_offset;
3943 file_offset += i;
3944 file_offset = ALIGN_SYMTABLE_OFFSET (file_offset);
3945 }
3946
3947 i = WORD_ALIGN (symbolic_header.issExtMax); /* external strings */
3948 if (i > 0)
3949 {
3950 symbolic_header.cbSsExtOffset = file_offset;
3951 file_offset += i;
3952 file_offset = ALIGN_SYMTABLE_OFFSET (file_offset);
3953 }
3954
3955 i = symbolic_header.ifdMax; /* file tables */
3956 if (i > 0)
3957 {
3958 symbolic_header.cbFdOffset = file_offset;
3959 file_offset += i * sizeof (FDR);
3960 file_offset = ALIGN_SYMTABLE_OFFSET (file_offset);
3961 }
3962
3963 i = symbolic_header.crfd; /* relative file descriptors */
3964 if (i > 0)
3965 {
3966 symbolic_header.cbRfdOffset = file_offset;
3967 file_offset += i * sizeof (symint_t);
3968 file_offset = ALIGN_SYMTABLE_OFFSET (file_offset);
3969 }
3970
3971 i = symbolic_header.iextMax; /* external symbols */
3972 if (i > 0)
3973 {
3974 symbolic_header.cbExtOffset = file_offset;
3975 file_offset += i * sizeof (EXTR);
3976 file_offset = ALIGN_SYMTABLE_OFFSET (file_offset);
3977 }
3978 }
3979
3980 \f
3981 /* Write out a varray at a given location. */
3982
3983 STATIC void
3984 write_varray (varray_t *vp, /* virtual array */
3985 off_t offset, /* offset to write varray to */
3986 const char *str) /* string to print out when tracing */
3987 {
3988 int num_write, sys_write;
3989 vlinks_t *ptr;
3990
3991 if (vp->num_allocated == 0)
3992 return;
3993
3994 if (debug)
3995 fprintf (stderr, "\twarray\tvp = " HOST_PTR_PRINTF
3996 ", offset = %7lu, size = %7lu, %s\n",
3997 (void *) vp, (unsigned long) offset,
3998 vp->num_allocated * vp->object_size, str);
3999
4000 if (file_offset != (unsigned long) offset
4001 && fseek (object_stream, (long) offset, SEEK_SET) < 0)
4002 pfatal_with_name (object_name);
4003
4004 for (ptr = vp->first; ptr != (vlinks_t *) 0; ptr = ptr->next)
4005 {
4006 num_write = (ptr->next == (vlinks_t *) 0)
4007 ? vp->objects_last_page * vp->object_size
4008 : vp->objects_per_page * vp->object_size;
4009
4010 sys_write = fwrite (ptr->datum, 1, num_write, object_stream);
4011 if (sys_write <= 0)
4012 pfatal_with_name (object_name);
4013
4014 else if (sys_write != num_write)
4015 fatal ("wrote %d bytes to %s, system returned %d",
4016 num_write,
4017 object_name,
4018 sys_write);
4019
4020 file_offset += num_write;
4021 }
4022 }
4023
4024 \f
4025 /* Write out the symbol table in the object file. */
4026
4027 STATIC void
4028 write_object (void)
4029 {
4030 int sys_write;
4031 efdr_t *file_ptr;
4032 off_t offset;
4033
4034 if (debug)
4035 fprintf (stderr, "\n\twrite\tvp = " HOST_PTR_PRINTF
4036 ", offset = %7u, size = %7lu, %s\n",
4037 (void *) &symbolic_header, 0,
4038 (unsigned long) sizeof (symbolic_header), "symbolic header");
4039
4040 sys_write = fwrite (&symbolic_header,
4041 1,
4042 sizeof (symbolic_header),
4043 object_stream);
4044
4045 if (sys_write < 0)
4046 pfatal_with_name (object_name);
4047
4048 else if (sys_write != sizeof (symbolic_header))
4049 fatal ("wrote %d bytes to %s, system returned %d",
4050 (int) sizeof (symbolic_header),
4051 object_name,
4052 sys_write);
4053
4054
4055 file_offset = sizeof (symbolic_header) + orig_file_header.f_symptr;
4056
4057 if (symbolic_header.cbLine > 0) /* line numbers */
4058 {
4059 long sys_write;
4060
4061 if (file_offset != (unsigned long) symbolic_header.cbLineOffset
4062 && fseek (object_stream, symbolic_header.cbLineOffset, SEEK_SET) != 0)
4063 pfatal_with_name (object_name);
4064
4065 if (debug)
4066 fprintf (stderr, "\twrite\tvp = " HOST_PTR_PRINTF
4067 ", offset = %7lu, size = %7lu, %s\n",
4068 (void *) &orig_linenum, (long) symbolic_header.cbLineOffset,
4069 (long) symbolic_header.cbLine, "Line numbers");
4070
4071 sys_write = fwrite (orig_linenum,
4072 1,
4073 symbolic_header.cbLine,
4074 object_stream);
4075
4076 if (sys_write <= 0)
4077 pfatal_with_name (object_name);
4078
4079 else if (sys_write != symbolic_header.cbLine)
4080 fatal ("wrote %ld bytes to %s, system returned %ld",
4081 (long) symbolic_header.cbLine,
4082 object_name,
4083 sys_write);
4084
4085 file_offset = symbolic_header.cbLineOffset + symbolic_header.cbLine;
4086 }
4087
4088 if (symbolic_header.ioptMax > 0) /* optimization symbols */
4089 {
4090 long sys_write;
4091 long num_write = symbolic_header.ioptMax * sizeof (OPTR);
4092
4093 if (file_offset != (unsigned long) symbolic_header.cbOptOffset
4094 && fseek (object_stream, symbolic_header.cbOptOffset, SEEK_SET) != 0)
4095 pfatal_with_name (object_name);
4096
4097 if (debug)
4098 fprintf (stderr, "\twrite\tvp = " HOST_PTR_PRINTF
4099 ", offset = %7lu, size = %7lu, %s\n",
4100 (void *) &orig_opt_syms, (long) symbolic_header.cbOptOffset,
4101 num_write, "Optimizer symbols");
4102
4103 sys_write = fwrite (orig_opt_syms,
4104 1,
4105 num_write,
4106 object_stream);
4107
4108 if (sys_write <= 0)
4109 pfatal_with_name (object_name);
4110
4111 else if (sys_write != num_write)
4112 fatal ("wrote %ld bytes to %s, system returned %ld",
4113 num_write,
4114 object_name,
4115 sys_write);
4116
4117 file_offset = symbolic_header.cbOptOffset + num_write;
4118 }
4119
4120 if (symbolic_header.idnMax > 0) /* dense numbers */
4121 write_varray (&dense_num, (off_t) symbolic_header.cbDnOffset, "Dense numbers");
4122
4123 if (symbolic_header.ipdMax > 0) /* procedure tables */
4124 {
4125 offset = symbolic_header.cbPdOffset;
4126 for (file_ptr = first_file;
4127 file_ptr != (efdr_t *) 0;
4128 file_ptr = file_ptr->next_file)
4129 {
4130 write_varray (&file_ptr->procs, offset, "Procedure tables");
4131 offset = file_offset;
4132 }
4133 }
4134
4135 if (symbolic_header.isymMax > 0) /* local symbols */
4136 {
4137 offset = symbolic_header.cbSymOffset;
4138 for (file_ptr = first_file;
4139 file_ptr != (efdr_t *) 0;
4140 file_ptr = file_ptr->next_file)
4141 {
4142 write_varray (&file_ptr->symbols, offset, "Local symbols");
4143 offset = file_offset;
4144 }
4145 }
4146
4147 if (symbolic_header.iauxMax > 0) /* aux symbols */
4148 {
4149 offset = symbolic_header.cbAuxOffset;
4150 for (file_ptr = first_file;
4151 file_ptr != (efdr_t *) 0;
4152 file_ptr = file_ptr->next_file)
4153 {
4154 write_varray (&file_ptr->aux_syms, offset, "Aux. symbols");
4155 offset = file_offset;
4156 }
4157 }
4158
4159 if (symbolic_header.issMax > 0) /* local strings */
4160 {
4161 offset = symbolic_header.cbSsOffset;
4162 for (file_ptr = first_file;
4163 file_ptr != (efdr_t *) 0;
4164 file_ptr = file_ptr->next_file)
4165 {
4166 write_varray (&file_ptr->strings, offset, "Local strings");
4167 offset = file_offset;
4168 }
4169 }
4170
4171 if (symbolic_header.issExtMax > 0) /* external strings */
4172 write_varray (&ext_strings, symbolic_header.cbSsExtOffset, "External strings");
4173
4174 if (symbolic_header.ifdMax > 0) /* file tables */
4175 {
4176 offset = symbolic_header.cbFdOffset;
4177 if (file_offset != (unsigned long) offset
4178 && fseek (object_stream, (long) offset, SEEK_SET) < 0)
4179 pfatal_with_name (object_name);
4180
4181 file_offset = offset;
4182 for (file_ptr = first_file;
4183 file_ptr != (efdr_t *) 0;
4184 file_ptr = file_ptr->next_file)
4185 {
4186 if (debug)
4187 fprintf (stderr, "\twrite\tvp = " HOST_PTR_PRINTF
4188 ", offset = %7lu, size = %7lu, %s\n",
4189 (void *) &file_ptr->fdr, file_offset,
4190 (unsigned long) sizeof (FDR), "File header");
4191
4192 sys_write = fwrite (&file_ptr->fdr,
4193 1,
4194 sizeof (FDR),
4195 object_stream);
4196
4197 if (sys_write < 0)
4198 pfatal_with_name (object_name);
4199
4200 else if (sys_write != sizeof (FDR))
4201 fatal ("wrote %d bytes to %s, system returned %d",
4202 (int) sizeof (FDR),
4203 object_name,
4204 sys_write);
4205
4206 file_offset = offset += sizeof (FDR);
4207 }
4208 }
4209
4210 if (symbolic_header.crfd > 0) /* relative file descriptors */
4211 {
4212 long sys_write;
4213 symint_t num_write = symbolic_header.crfd * sizeof (symint_t);
4214
4215 if (file_offset != (unsigned long) symbolic_header.cbRfdOffset
4216 && fseek (object_stream, symbolic_header.cbRfdOffset, SEEK_SET) != 0)
4217 pfatal_with_name (object_name);
4218
4219 if (debug)
4220 fprintf (stderr, "\twrite\tvp = " HOST_PTR_PRINTF
4221 ", offset = %7lu, size = %7lu, %s\n",
4222 (void *) &orig_rfds, (long) symbolic_header.cbRfdOffset,
4223 num_write, "Relative file descriptors");
4224
4225 sys_write = fwrite (orig_rfds,
4226 1,
4227 num_write,
4228 object_stream);
4229
4230 if (sys_write <= 0)
4231 pfatal_with_name (object_name);
4232
4233 else if (sys_write != (long) num_write)
4234 fatal ("wrote %lu bytes to %s, system returned %ld",
4235 num_write,
4236 object_name,
4237 sys_write);
4238
4239 file_offset = symbolic_header.cbRfdOffset + num_write;
4240 }
4241
4242 if (symbolic_header.issExtMax > 0) /* external symbols */
4243 write_varray (&ext_symbols, (off_t) symbolic_header.cbExtOffset, "External symbols");
4244
4245 if (fclose (object_stream) != 0)
4246 pfatal_with_name (object_name);
4247 }
4248
4249 \f
4250 /* Read some bytes at a specified location, and return a pointer. */
4251
4252 STATIC page_t *
4253 read_seek (Size_t size, /* # bytes to read */
4254 off_t offset, /* offset to read at */
4255 const char *str) /* name for tracing */
4256 {
4257 page_t *ptr;
4258 long sys_read = 0;
4259
4260 if (size == 0) /* nothing to read */
4261 return (page_t *) 0;
4262
4263 if (debug)
4264 fprintf (stderr,
4265 "\trseek\tsize = %7lu, offset = %7lu, currently at %7lu, %s\n",
4266 (unsigned long) size, (unsigned long) offset, file_offset, str);
4267
4268 #ifndef MALLOC_CHECK
4269 ptr = allocate_multiple_pages ((size + PAGE_USIZE - 1) / PAGE_USIZE);
4270 #else
4271 ptr = xcalloc (1, size);
4272 #endif
4273
4274 /* If we need to seek, and the distance is nearby, just do some reads,
4275 to speed things up. */
4276 if (file_offset != (unsigned long) offset)
4277 {
4278 symint_t difference = offset - file_offset;
4279
4280 if (difference < 8)
4281 {
4282 char small_buffer[8];
4283
4284 sys_read = fread (small_buffer, 1, difference, obj_in_stream);
4285 if (sys_read <= 0)
4286 pfatal_with_name (obj_in_name);
4287
4288 if ((symint_t) sys_read != difference)
4289 fatal ("wanted to read %lu bytes from %s, system returned %ld",
4290 (unsigned long) size,
4291 obj_in_name,
4292 sys_read);
4293 }
4294 else if (fseek (obj_in_stream, offset, SEEK_SET) < 0)
4295 pfatal_with_name (obj_in_name);
4296 }
4297
4298 sys_read = fread (ptr, 1, size, obj_in_stream);
4299 if (sys_read <= 0)
4300 pfatal_with_name (obj_in_name);
4301
4302 if (sys_read != (long) size)
4303 fatal ("wanted to read %lu bytes from %s, system returned %ld",
4304 (unsigned long) size,
4305 obj_in_name,
4306 sys_read);
4307
4308 file_offset = offset + size;
4309
4310 if (file_offset > max_file_offset)
4311 max_file_offset = file_offset;
4312
4313 return ptr;
4314 }
4315
4316 \f
4317 /* Read the existing object file (and copy to the output object file
4318 if it is different from the input object file), and remove the old
4319 symbol table. */
4320
4321 STATIC void
4322 copy_object (void)
4323 {
4324 char buffer[ PAGE_SIZE ];
4325 int sys_read;
4326 int remaining;
4327 int num_write;
4328 int sys_write;
4329 int fd, es;
4330 int delete_ifd = 0;
4331 int *remap_file_number;
4332 struct stat stat_buf;
4333
4334 if (debug)
4335 fprintf (stderr, "\tcopy\n");
4336
4337 if (fstat (fileno (obj_in_stream), &stat_buf) != 0
4338 || fseek (obj_in_stream, 0L, SEEK_SET) != 0)
4339 pfatal_with_name (obj_in_name);
4340
4341 sys_read = fread (&orig_file_header,
4342 1,
4343 sizeof (struct filehdr),
4344 obj_in_stream);
4345
4346 if (sys_read < 0)
4347 pfatal_with_name (obj_in_name);
4348
4349 else if (sys_read == 0 && feof (obj_in_stream))
4350 return; /* create a .T file sans file header */
4351
4352 else if (sys_read < (int) sizeof (struct filehdr))
4353 fatal ("wanted to read %d bytes from %s, system returned %d",
4354 (int) sizeof (struct filehdr),
4355 obj_in_name,
4356 sys_read);
4357
4358
4359 if (orig_file_header.f_nsyms != sizeof (HDRR))
4360 fatal ("%s symbolic header wrong size (%ld bytes, should be %ld)",
4361 input_name, (long) orig_file_header.f_nsyms, (long) sizeof (HDRR));
4362
4363
4364 /* Read in the current symbolic header. */
4365 if (fseek (obj_in_stream, (long) orig_file_header.f_symptr, SEEK_SET) != 0)
4366 pfatal_with_name (input_name);
4367
4368 sys_read = fread (&orig_sym_hdr,
4369 1,
4370 sizeof (orig_sym_hdr),
4371 obj_in_stream);
4372
4373 if (sys_read < 0)
4374 pfatal_with_name (object_name);
4375
4376 else if (sys_read < (int) sizeof (struct filehdr))
4377 fatal ("wanted to read %d bytes from %s, system returned %d",
4378 (int) sizeof (struct filehdr),
4379 obj_in_name,
4380 sys_read);
4381
4382
4383 /* Read in each of the sections if they exist in the object file.
4384 We read things in the order the mips assembler creates the
4385 sections, so in theory no extra seeks are done.
4386
4387 For simplicity sake, round each read up to a page boundary,
4388 we may want to revisit this later.... */
4389
4390 file_offset = orig_file_header.f_symptr + sizeof (struct filehdr);
4391
4392 if (orig_sym_hdr.cbLine > 0) /* line numbers */
4393 orig_linenum = (char *) read_seek (orig_sym_hdr.cbLine,
4394 orig_sym_hdr.cbLineOffset,
4395 "Line numbers");
4396
4397 if (orig_sym_hdr.ipdMax > 0) /* procedure tables */
4398 orig_procs = (PDR *) read_seek (orig_sym_hdr.ipdMax * sizeof (PDR),
4399 orig_sym_hdr.cbPdOffset,
4400 "Procedure tables");
4401
4402 if (orig_sym_hdr.isymMax > 0) /* local symbols */
4403 orig_local_syms = (SYMR *) read_seek (orig_sym_hdr.isymMax * sizeof (SYMR),
4404 orig_sym_hdr.cbSymOffset,
4405 "Local symbols");
4406
4407 if (orig_sym_hdr.iauxMax > 0) /* aux symbols */
4408 orig_aux_syms = (AUXU *) read_seek (orig_sym_hdr.iauxMax * sizeof (AUXU),
4409 orig_sym_hdr.cbAuxOffset,
4410 "Aux. symbols");
4411
4412 if (orig_sym_hdr.issMax > 0) /* local strings */
4413 orig_local_strs = (char *) read_seek (orig_sym_hdr.issMax,
4414 orig_sym_hdr.cbSsOffset,
4415 "Local strings");
4416
4417 if (orig_sym_hdr.issExtMax > 0) /* external strings */
4418 orig_ext_strs = (char *) read_seek (orig_sym_hdr.issExtMax,
4419 orig_sym_hdr.cbSsExtOffset,
4420 "External strings");
4421
4422 if (orig_sym_hdr.ifdMax > 0) /* file tables */
4423 orig_files = (FDR *) read_seek (orig_sym_hdr.ifdMax * sizeof (FDR),
4424 orig_sym_hdr.cbFdOffset,
4425 "File tables");
4426
4427 if (orig_sym_hdr.crfd > 0) /* relative file descriptors */
4428 orig_rfds = (symint_t *) read_seek (orig_sym_hdr.crfd * sizeof (symint_t),
4429 orig_sym_hdr.cbRfdOffset,
4430 "Relative file descriptors");
4431
4432 if (orig_sym_hdr.issExtMax > 0) /* external symbols */
4433 orig_ext_syms = (EXTR *) read_seek (orig_sym_hdr.iextMax * sizeof (EXTR),
4434 orig_sym_hdr.cbExtOffset,
4435 "External symbols");
4436
4437 if (orig_sym_hdr.idnMax > 0) /* dense numbers */
4438 {
4439 orig_dense = (DNR *) read_seek (orig_sym_hdr.idnMax * sizeof (DNR),
4440 orig_sym_hdr.cbDnOffset,
4441 "Dense numbers");
4442
4443 add_bytes (&dense_num, (char *) orig_dense, orig_sym_hdr.idnMax);
4444 }
4445
4446 if (orig_sym_hdr.ioptMax > 0) /* opt symbols */
4447 orig_opt_syms = (OPTR *) read_seek (orig_sym_hdr.ioptMax * sizeof (OPTR),
4448 orig_sym_hdr.cbOptOffset,
4449 "Optimizer symbols");
4450
4451
4452
4453 /* The symbol table should be last. */
4454 if (max_file_offset != (unsigned long) stat_buf.st_size)
4455 fatal ("symbol table is not last (symbol table ends at %ld, .o ends at %ld",
4456 max_file_offset,
4457 (long) stat_buf.st_size);
4458
4459
4460 /* If the first original file descriptor is a dummy which the assembler
4461 put out, but there are no symbols in it, skip it now. */
4462 if (orig_sym_hdr.ifdMax > 1
4463 && orig_files->csym == 2
4464 && orig_files->caux == 0)
4465 {
4466 char *filename = orig_local_strs + (orig_files->issBase + orig_files->rss);
4467 char *suffix = strrchr (filename, '.');
4468
4469 if (suffix != (char *) 0 && strcmp (suffix, ".s") == 0)
4470 delete_ifd = 1;
4471 }
4472
4473
4474 /* Create array to map original file numbers to the new file numbers
4475 (in case there are duplicate filenames, we collapse them into one
4476 file section, the MIPS assembler may or may not collapse them). */
4477
4478 remap_file_number = (int *) alloca (sizeof (int) * orig_sym_hdr.ifdMax);
4479
4480 for (fd = delete_ifd; fd < orig_sym_hdr.ifdMax; fd++)
4481 {
4482 FDR *fd_ptr = ORIG_FILES (fd);
4483 char *filename = ORIG_LSTRS (fd_ptr->issBase + fd_ptr->rss);
4484
4485 /* file support itself. */
4486 add_file (filename, filename + strlen (filename));
4487 remap_file_number[fd] = cur_file_ptr->file_index;
4488 }
4489
4490 if (delete_ifd > 0) /* just in case */
4491 remap_file_number[0] = remap_file_number[1];
4492
4493
4494 /* Loop, adding each of the external symbols. These must be in
4495 order or otherwise we would have to change the relocation
4496 entries. We don't just call add_bytes, because we need to have
4497 the names put into the external hash table. We set the type to
4498 'void' for now, and parse_def will fill in the correct type if it
4499 is in the symbol table. We must add the external symbols before
4500 the locals, since the locals do lookups against the externals. */
4501
4502 if (debug)
4503 fprintf (stderr, "\tehash\n");
4504
4505 for (es = 0; es < orig_sym_hdr.iextMax; es++)
4506 {
4507 EXTR *eptr = orig_ext_syms + es;
4508 int ifd = eptr->ifd;
4509
4510 (void) add_ext_symbol (eptr, ((long) ifd < orig_sym_hdr.ifdMax)
4511 ? remap_file_number[ ifd ] : ifd );
4512 }
4513
4514
4515 /* For each of the files in the object file, copy the symbols, and such
4516 into the varrays for the new object file. */
4517
4518 for (fd = delete_ifd; fd < orig_sym_hdr.ifdMax; fd++)
4519 {
4520 FDR *fd_ptr = ORIG_FILES (fd);
4521 char *filename = ORIG_LSTRS (fd_ptr->issBase + fd_ptr->rss);
4522 SYMR *sym_start;
4523 SYMR *sym;
4524 SYMR *sym_end_p1;
4525 PDR *proc_start;
4526 PDR *proc;
4527 PDR *proc_end_p1;
4528
4529 /* file support itself. */
4530 add_file (filename, filename + strlen (filename));
4531 cur_file_ptr->orig_fdr = fd_ptr;
4532
4533 /* Copy stuff that's just passed through (such as line #'s) */
4534 cur_file_ptr->fdr.adr = fd_ptr->adr;
4535 cur_file_ptr->fdr.ilineBase = fd_ptr->ilineBase;
4536 cur_file_ptr->fdr.cline = fd_ptr->cline;
4537 cur_file_ptr->fdr.rfdBase = fd_ptr->rfdBase;
4538 cur_file_ptr->fdr.crfd = fd_ptr->crfd;
4539 cur_file_ptr->fdr.cbLineOffset = fd_ptr->cbLineOffset;
4540 cur_file_ptr->fdr.cbLine = fd_ptr->cbLine;
4541 cur_file_ptr->fdr.fMerge = fd_ptr->fMerge;
4542 cur_file_ptr->fdr.fReadin = fd_ptr->fReadin;
4543 cur_file_ptr->fdr.glevel = fd_ptr->glevel;
4544
4545 if (debug)
4546 fprintf (stderr, "\thash\tstart, filename %s\n", filename);
4547
4548 /* For each of the static and global symbols defined, add them
4549 to the hash table of original symbols, so we can look up
4550 their values. */
4551
4552 sym_start = ORIG_LSYMS (fd_ptr->isymBase);
4553 sym_end_p1 = sym_start + fd_ptr->csym;
4554 for (sym = sym_start; sym < sym_end_p1; sym++)
4555 {
4556 switch ((st_t) sym->st)
4557 {
4558 default:
4559 break;
4560
4561 case st_Global:
4562 case st_Static:
4563 case st_Label:
4564 case st_Proc:
4565 case st_StaticProc:
4566 {
4567 auto symint_t hash_index;
4568 char *str = ORIG_LSTRS (fd_ptr->issBase + sym->iss);
4569 Size_t len = strlen (str);
4570 shash_t *shash_ptr = hash_string (str,
4571 (Ptrdiff_t) len,
4572 &orig_str_hash[0],
4573 &hash_index);
4574
4575 if (shash_ptr != (shash_t *) 0)
4576 error ("internal error, %s is already in original symbol table", str);
4577
4578 else
4579 {
4580 shash_ptr = allocate_shash ();
4581 shash_ptr->next = orig_str_hash[hash_index];
4582 orig_str_hash[hash_index] = shash_ptr;
4583
4584 shash_ptr->len = len;
4585 shash_ptr->indx = indexNil;
4586 shash_ptr->string = str;
4587 shash_ptr->sym_ptr = sym;
4588 }
4589 }
4590 break;
4591
4592 case st_End:
4593 if ((sc_t) sym->sc == sc_Text)
4594 {
4595 char *str = ORIG_LSTRS (fd_ptr->issBase + sym->iss);
4596
4597 if (*str != '\0')
4598 {
4599 Size_t len = strlen (str);
4600 shash_t *shash_ptr = hash_string (str,
4601 (Ptrdiff_t) len,
4602 &orig_str_hash[0],
4603 (symint_t *) 0);
4604
4605 if (shash_ptr != (shash_t *) 0)
4606 shash_ptr->end_ptr = sym;
4607 }
4608 }
4609 break;
4610
4611 }
4612 }
4613
4614 if (debug)
4615 {
4616 fprintf (stderr, "\thash\tdone, filename %s\n", filename);
4617 fprintf (stderr, "\tproc\tstart, filename %s\n", filename);
4618 }
4619
4620 /* Go through each of the procedures in this file, and add the
4621 procedure pointer to the hash entry for the given name. */
4622
4623 proc_start = ORIG_PROCS (fd_ptr->ipdFirst);
4624 proc_end_p1 = proc_start + fd_ptr->cpd;
4625 for (proc = proc_start; proc < proc_end_p1; proc++)
4626 {
4627 SYMR *proc_sym = ORIG_LSYMS (fd_ptr->isymBase + proc->isym);
4628 char *str = ORIG_LSTRS (fd_ptr->issBase + proc_sym->iss);
4629 Size_t len = strlen (str);
4630 shash_t *shash_ptr = hash_string (str,
4631 (Ptrdiff_t) len,
4632 &orig_str_hash[0],
4633 (symint_t *) 0);
4634
4635 if (shash_ptr == (shash_t *) 0)
4636 error ("internal error, function %s is not in original symbol table", str);
4637
4638 else
4639 shash_ptr->proc_ptr = proc;
4640 }
4641
4642 if (debug)
4643 fprintf (stderr, "\tproc\tdone, filename %s\n", filename);
4644
4645 }
4646 cur_file_ptr = first_file;
4647
4648
4649 /* Copy all of the object file up to the symbol table. Originally
4650 we were going to use ftruncate, but that doesn't seem to work
4651 on Ultrix 3.1.... */
4652
4653 if (fseek (obj_in_stream, (long) 0, SEEK_SET) != 0)
4654 pfatal_with_name (obj_in_name);
4655
4656 if (fseek (object_stream, (long) 0, SEEK_SET) != 0)
4657 pfatal_with_name (object_name);
4658
4659 for (remaining = orig_file_header.f_symptr;
4660 remaining > 0;
4661 remaining -= num_write)
4662 {
4663 num_write
4664 = (remaining <= (int) sizeof (buffer))
4665 ? remaining : (int) sizeof (buffer);
4666 sys_read = fread (buffer, 1, num_write, obj_in_stream);
4667 if (sys_read <= 0)
4668 pfatal_with_name (obj_in_name);
4669
4670 else if (sys_read != num_write)
4671 fatal ("wanted to read %d bytes from %s, system returned %d",
4672 num_write,
4673 obj_in_name,
4674 sys_read);
4675
4676 sys_write = fwrite (buffer, 1, num_write, object_stream);
4677 if (sys_write <= 0)
4678 pfatal_with_name (object_name);
4679
4680 else if (sys_write != num_write)
4681 fatal ("wrote %d bytes to %s, system returned %d",
4682 num_write,
4683 object_name,
4684 sys_write);
4685 }
4686 }
4687
4688 \f
4689 /* Ye olde main program. */
4690
4691 extern int main (int, char **);
4692
4693 int
4694 main (int argc, char **argv)
4695 {
4696 int iflag = 0;
4697 char *num_end;
4698 int option;
4699 int i;
4700
4701 progname = lbasename (argv[0]);
4702
4703 (void) signal (SIGSEGV, catch_signal);
4704 (void) signal (SIGBUS, catch_signal);
4705 (void) signal (SIGABRT, catch_signal);
4706
4707 #if !defined(__SABER__) && !defined(lint)
4708 if (sizeof (efdr_t) > PAGE_USIZE)
4709 fatal ("efdr_t has a sizeof %d bytes, when it should be less than %d",
4710 (int) sizeof (efdr_t),
4711 (int) PAGE_USIZE);
4712
4713 if (sizeof (page_t) != PAGE_USIZE)
4714 fatal ("page_t has a sizeof %d bytes, when it should be %d",
4715 (int) sizeof (page_t),
4716 (int) PAGE_USIZE);
4717
4718 #endif
4719
4720 alloc_counts[ alloc_type_none ].alloc_name = "none";
4721 alloc_counts[ alloc_type_scope ].alloc_name = "scope";
4722 alloc_counts[ alloc_type_vlinks ].alloc_name = "vlinks";
4723 alloc_counts[ alloc_type_shash ].alloc_name = "shash";
4724 alloc_counts[ alloc_type_thash ].alloc_name = "thash";
4725 alloc_counts[ alloc_type_tag ].alloc_name = "tag";
4726 alloc_counts[ alloc_type_forward ].alloc_name = "forward";
4727 alloc_counts[ alloc_type_thead ].alloc_name = "thead";
4728 alloc_counts[ alloc_type_varray ].alloc_name = "varray";
4729
4730 int_type_info = type_info_init;
4731 int_type_info.basic_type = bt_Int;
4732
4733 void_type_info = type_info_init;
4734 void_type_info.basic_type = bt_Void;
4735
4736 while ((option = getopt_long (argc, argv, "d:i:I:o:v", options, NULL)) != -1)
4737 switch (option)
4738 {
4739 default:
4740 had_errors++;
4741 break;
4742
4743 case 'd':
4744 debug = strtol (optarg, &num_end, 0);
4745 if ((unsigned) debug > 4 || num_end == optarg)
4746 had_errors++;
4747
4748 break;
4749
4750 case 'I':
4751 if (rename_output || obj_in_name != (char *) 0)
4752 had_errors++;
4753 else
4754 rename_output = 1;
4755
4756 /* Fall through to 'i' case. */
4757
4758 case 'i':
4759 if (obj_in_name == (char *) 0)
4760 {
4761 obj_in_name = optarg;
4762 iflag++;
4763 }
4764 else
4765 had_errors++;
4766 break;
4767
4768 case 'o':
4769 if (object_name == (char *) 0)
4770 object_name = optarg;
4771 else
4772 had_errors++;
4773 break;
4774
4775 case 'v':
4776 verbose++;
4777 break;
4778
4779 case 'V':
4780 version++;
4781 break;
4782 }
4783
4784 if (version)
4785 {
4786 printf (_("mips-tfile %s%s\n"), pkgversion_string, version_string);
4787 fputs ("Copyright (C) 2011 Free Software Foundation, Inc.\n", stdout);
4788 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
4789 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
4790 stdout);
4791 exit (0);
4792 }
4793
4794 if (obj_in_name == (char *) 0 && optind <= argc - 2)
4795 obj_in_name = argv[--argc];
4796
4797 if (object_name == (char *) 0 && optind <= argc - 2)
4798 object_name = argv[--argc];
4799
4800 /* If there is an output name, but no input name use
4801 the same file for both, deleting the name between
4802 opening it for input and opening it for output. */
4803 if (obj_in_name == (char *) 0 && object_name != (char *) 0)
4804 {
4805 obj_in_name = object_name;
4806 delete_input = 1;
4807 }
4808
4809 if (optind != argc - 1)
4810 had_errors++;
4811
4812 if (verbose || had_errors)
4813 fprintf (stderr, _("mips-tfile (GCC) %s\n"), version_string);
4814
4815 if (object_name == (char *) 0 || had_errors)
4816 {
4817 fprintf (stderr, _("Calling Sequence:\n"));
4818 fprintf (stderr, _("\tmips-tfile [-d <num>] [-v] [-i <o-in-file>] -o <o-out-file> <s-file> (or)\n"));
4819 fprintf (stderr, _("\tmips-tfile [-d <num>] [-v] [-I <o-in-file>] -o <o-out-file> <s-file> (or)\n"));
4820 fprintf (stderr, _("\tmips-tfile [-d <num>] [-v] <s-file> <o-in-file> <o-out-file>\n"));
4821 fprintf (stderr, "\n");
4822 fprintf (stderr, _("Debug levels are:\n"));
4823 fprintf (stderr, _(" 1\tGeneral debug + trace functions/blocks.\n"));
4824 fprintf (stderr, _(" 2\tDebug level 1 + trace externals.\n"));
4825 fprintf (stderr, _(" 3\tDebug level 2 + trace all symbols.\n"));
4826 fprintf (stderr, _(" 4\tDebug level 3 + trace memory allocations.\n"));
4827 return 1;
4828 }
4829
4830 if (obj_in_name == (char *) 0)
4831 obj_in_name = object_name;
4832
4833 if (rename_output && rename (object_name, obj_in_name) != 0)
4834 {
4835 char *buffer = (char *) allocate_multiple_pages (4);
4836 int len;
4837 int len2;
4838 int in_fd;
4839 int out_fd;
4840
4841 /* Rename failed, copy input file */
4842 in_fd = open (object_name, O_RDONLY, 0666);
4843 if (in_fd < 0)
4844 pfatal_with_name (object_name);
4845
4846 out_fd = open (obj_in_name, O_WRONLY | O_CREAT | O_TRUNC, 0666);
4847 if (out_fd < 0)
4848 pfatal_with_name (obj_in_name);
4849
4850 while ((len = read (in_fd, buffer, 4*PAGE_SIZE)) > 0)
4851 {
4852 len2 = write (out_fd, buffer, len);
4853 if (len2 < 0)
4854 pfatal_with_name (object_name);
4855
4856 if (len != len2)
4857 fatal ("wrote %d bytes to %s, expected to write %d", len2, obj_in_name, len);
4858 }
4859
4860 free_multiple_pages ((page_t *) buffer, 4);
4861
4862 if (len < 0)
4863 pfatal_with_name (object_name);
4864
4865 if (close (in_fd) < 0)
4866 pfatal_with_name (object_name);
4867
4868 if (close (out_fd) < 0)
4869 pfatal_with_name (obj_in_name);
4870 }
4871
4872 /* Must open input before output, since the output may be the same file, and
4873 we need to get the input handle before truncating it. */
4874 obj_in_stream = fopen (obj_in_name, "r");
4875 if (obj_in_stream == (FILE *) 0)
4876 pfatal_with_name (obj_in_name);
4877
4878 if (delete_input && unlink (obj_in_name) != 0)
4879 pfatal_with_name (obj_in_name);
4880
4881 object_stream = fopen (object_name, "w");
4882 if (object_stream == (FILE *) 0)
4883 pfatal_with_name (object_name);
4884
4885 if (strcmp (argv[optind], "-") != 0)
4886 {
4887 input_name = argv[optind];
4888 if (freopen (argv[optind], "r", stdin) != stdin)
4889 pfatal_with_name (argv[optind]);
4890 }
4891
4892 copy_object (); /* scan & copy object file */
4893 parse_input (); /* scan all of input */
4894
4895 update_headers (); /* write out tfile */
4896 write_object ();
4897
4898 if (debug)
4899 {
4900 fprintf (stderr, "\n\tAllocation summary:\n\n");
4901 for (i = (int) alloc_type_none; i < (int) alloc_type_last; i++)
4902 if (alloc_counts[i].total_alloc)
4903 {
4904 fprintf (stderr,
4905 "\t%s\t%5d allocation(s), %5d free(s), %2d page(s)\n",
4906 alloc_counts[i].alloc_name,
4907 alloc_counts[i].total_alloc,
4908 alloc_counts[i].total_free,
4909 alloc_counts[i].total_pages);
4910 }
4911 }
4912
4913 return (had_errors) ? 1 : 0;
4914 }
4915
4916 \f
4917 /* Catch a signal and exit without dumping core. */
4918
4919 STATIC void
4920 catch_signal (int signum)
4921 {
4922 (void) signal (signum, SIG_DFL); /* just in case... */
4923 fatal ("%s", strsignal (signum));
4924 }
4925
4926 /* Print a fatal error message. NAME is the text.
4927 Also include a system error message based on `errno'. */
4928
4929 void
4930 pfatal_with_name (const char *msg)
4931 {
4932 int save_errno = errno; /* just in case.... */
4933 if (line_number > 0)
4934 fprintf (stderr, "%s, %s:%ld ", progname, input_name, line_number);
4935 else
4936 fprintf (stderr, "%s:", progname);
4937
4938 errno = save_errno;
4939 if (errno == 0)
4940 fprintf (stderr, "[errno = 0] %s\n", msg);
4941 else
4942 perror (msg);
4943
4944 exit (1);
4945 }
4946
4947 \f
4948 /* Procedure to die with an out of bounds error message. It has
4949 type int, so it can be used with an ?: expression within the
4950 ORIG_xxx macros, but the function never returns. */
4951
4952 static int
4953 out_of_bounds (symint_t indx, /* index that is out of bounds */
4954 symint_t max, /* maximum index */
4955 const char *str, /* string to print out */
4956 int prog_line) /* line number within mips-tfile.c */
4957 {
4958 if (indx < max) /* just in case */
4959 return 0;
4960
4961 fprintf (stderr, "%s, %s:%ld index %lu is out of bounds for %s, max is %lu, mips-tfile.c line# %d\n",
4962 progname, input_name, line_number, indx, str, max, prog_line);
4963
4964 exit (1);
4965 return 0; /* turn off warning messages */
4966 }
4967
4968 \f
4969 /* Allocate a cluster of pages. USE_MALLOC says that malloc does not
4970 like sbrk's behind its back (or sbrk isn't available). If we use
4971 sbrk, we assume it gives us zeroed pages. */
4972
4973 #ifndef MALLOC_CHECK
4974 #ifdef USE_MALLOC
4975
4976 STATIC page_t *
4977 allocate_cluster (Size_t npages)
4978 {
4979 page_t *value = xcalloc (npages, PAGE_USIZE);
4980
4981 if (debug > 3)
4982 fprintf (stderr, "\talloc\tnpages = %d, value = 0x%.8x\n", npages, value);
4983
4984 return value;
4985 }
4986
4987 #else /* USE_MALLOC */
4988
4989 STATIC page_t *
4990 allocate_cluster (Size_t npages)
4991 {
4992 page_t *ptr = (page_t *) sbrk (0); /* current sbreak */
4993 unsigned long offset = ((unsigned long) ptr) & (PAGE_SIZE - 1);
4994
4995 if (offset != 0) /* align to a page boundary */
4996 {
4997 if (sbrk (PAGE_USIZE - offset) == (char *)-1)
4998 pfatal_with_name ("allocate_cluster");
4999
5000 ptr = (page_t *) (((char *) ptr) + PAGE_SIZE - offset);
5001 }
5002
5003 if (sbrk (npages * PAGE_USIZE) == (char *) -1)
5004 pfatal_with_name ("allocate_cluster");
5005
5006 if (debug > 3)
5007 fprintf (stderr, "\talloc\tnpages = %lu, value = " HOST_PTR_PRINTF "\n",
5008 (unsigned long) npages, (void *) ptr);
5009
5010 return ptr;
5011 }
5012
5013 #endif /* USE_MALLOC */
5014
5015
5016 static page_t *cluster_ptr = NULL;
5017 static unsigned pages_left = 0;
5018
5019 #endif /* MALLOC_CHECK */
5020
5021
5022 /* Allocate some pages (which is initialized to 0). */
5023
5024 STATIC page_t *
5025 allocate_multiple_pages (Size_t npages)
5026 {
5027 #ifndef MALLOC_CHECK
5028 if (pages_left == 0 && npages < MAX_CLUSTER_PAGES)
5029 {
5030 pages_left = MAX_CLUSTER_PAGES;
5031 cluster_ptr = allocate_cluster (MAX_CLUSTER_PAGES);
5032 }
5033
5034 if (npages <= pages_left)
5035 {
5036 page_t *ptr = cluster_ptr;
5037 cluster_ptr += npages;
5038 pages_left -= npages;
5039 return ptr;
5040 }
5041
5042 return allocate_cluster (npages);
5043
5044 #else /* MALLOC_CHECK */
5045 return xcalloc (npages, PAGE_SIZE);
5046
5047 #endif /* MALLOC_CHECK */
5048 }
5049
5050
5051 /* Release some pages. */
5052
5053 STATIC void
5054 free_multiple_pages (page_t *page_ptr, Size_t npages)
5055 {
5056 #ifndef MALLOC_CHECK
5057 if (pages_left == 0)
5058 {
5059 cluster_ptr = page_ptr;
5060 pages_left = npages;
5061 }
5062
5063 else if ((page_ptr + npages) == cluster_ptr)
5064 {
5065 cluster_ptr -= npages;
5066 pages_left += npages;
5067 }
5068
5069 /* otherwise the page is not freed. If more than call is
5070 done, we probably should worry about it, but at present,
5071 the free pages is done right after an allocate. */
5072
5073 #else /* MALLOC_CHECK */
5074 free (page_ptr);
5075
5076 #endif /* MALLOC_CHECK */
5077 }
5078
5079
5080 /* Allocate one page (which is initialized to 0). */
5081
5082 STATIC page_t *
5083 allocate_page (void)
5084 {
5085 #ifndef MALLOC_CHECK
5086 if (pages_left == 0)
5087 {
5088 pages_left = MAX_CLUSTER_PAGES;
5089 cluster_ptr = allocate_cluster (MAX_CLUSTER_PAGES);
5090 }
5091
5092 pages_left--;
5093 return cluster_ptr++;
5094
5095 #else /* MALLOC_CHECK */
5096 return xcalloc (1, PAGE_SIZE);
5097
5098 #endif /* MALLOC_CHECK */
5099 }
5100
5101 \f
5102 /* Allocate scoping information. */
5103
5104 STATIC scope_t *
5105 allocate_scope (void)
5106 {
5107 scope_t *ptr;
5108 static scope_t initial_scope;
5109
5110 #ifndef MALLOC_CHECK
5111 ptr = alloc_counts[ (int) alloc_type_scope ].free_list.f_scope;
5112 if (ptr != (scope_t *) 0)
5113 alloc_counts[ (int) alloc_type_scope ].free_list.f_scope = ptr->free;
5114
5115 else
5116 {
5117 int unallocated = alloc_counts[ (int) alloc_type_scope ].unallocated;
5118 page_t *cur_page = alloc_counts[ (int) alloc_type_scope ].cur_page;
5119
5120 if (unallocated == 0)
5121 {
5122 unallocated = PAGE_SIZE / sizeof (scope_t);
5123 alloc_counts[ (int) alloc_type_scope ].cur_page = cur_page = allocate_page ();
5124 alloc_counts[ (int) alloc_type_scope ].total_pages++;
5125 }
5126
5127 ptr = &cur_page->scope[ --unallocated ];
5128 alloc_counts[ (int) alloc_type_scope ].unallocated = unallocated;
5129 }
5130
5131 #else
5132 ptr = xmalloc (sizeof (scope_t));
5133
5134 #endif
5135
5136 alloc_counts[ (int) alloc_type_scope ].total_alloc++;
5137 *ptr = initial_scope;
5138 return ptr;
5139 }
5140
5141 /* Free scoping information. */
5142
5143 STATIC void
5144 free_scope (scope_t *ptr)
5145 {
5146 alloc_counts[ (int) alloc_type_scope ].total_free++;
5147
5148 #ifndef MALLOC_CHECK
5149 ptr->free = alloc_counts[ (int) alloc_type_scope ].free_list.f_scope;
5150 alloc_counts[ (int) alloc_type_scope ].free_list.f_scope = ptr;
5151
5152 #else
5153 free (ptr);
5154 #endif
5155
5156 }
5157
5158 \f
5159 /* Allocate links for pages in a virtual array. */
5160
5161 STATIC vlinks_t *
5162 allocate_vlinks (void)
5163 {
5164 vlinks_t *ptr;
5165 static vlinks_t initial_vlinks;
5166
5167 #ifndef MALLOC_CHECK
5168 int unallocated = alloc_counts[ (int) alloc_type_vlinks ].unallocated;
5169 page_t *cur_page = alloc_counts[ (int) alloc_type_vlinks ].cur_page;
5170
5171 if (unallocated == 0)
5172 {
5173 unallocated = PAGE_SIZE / sizeof (vlinks_t);
5174 alloc_counts[ (int) alloc_type_vlinks ].cur_page = cur_page = allocate_page ();
5175 alloc_counts[ (int) alloc_type_vlinks ].total_pages++;
5176 }
5177
5178 ptr = &cur_page->vlinks[ --unallocated ];
5179 alloc_counts[ (int) alloc_type_vlinks ].unallocated = unallocated;
5180
5181 #else
5182 ptr = xmalloc (sizeof (vlinks_t));
5183
5184 #endif
5185
5186 alloc_counts[ (int) alloc_type_vlinks ].total_alloc++;
5187 *ptr = initial_vlinks;
5188 return ptr;
5189 }
5190
5191 \f
5192 /* Allocate string hash buckets. */
5193
5194 STATIC shash_t *
5195 allocate_shash (void)
5196 {
5197 shash_t *ptr;
5198 static shash_t initial_shash;
5199
5200 #ifndef MALLOC_CHECK
5201 int unallocated = alloc_counts[ (int) alloc_type_shash ].unallocated;
5202 page_t *cur_page = alloc_counts[ (int) alloc_type_shash ].cur_page;
5203
5204 if (unallocated == 0)
5205 {
5206 unallocated = PAGE_SIZE / sizeof (shash_t);
5207 alloc_counts[ (int) alloc_type_shash ].cur_page = cur_page = allocate_page ();
5208 alloc_counts[ (int) alloc_type_shash ].total_pages++;
5209 }
5210
5211 ptr = &cur_page->shash[ --unallocated ];
5212 alloc_counts[ (int) alloc_type_shash ].unallocated = unallocated;
5213
5214 #else
5215 ptr = xmalloc (sizeof (shash_t));
5216
5217 #endif
5218
5219 alloc_counts[ (int) alloc_type_shash ].total_alloc++;
5220 *ptr = initial_shash;
5221 return ptr;
5222 }
5223
5224 \f
5225 /* Allocate type hash buckets. */
5226
5227 STATIC thash_t *
5228 allocate_thash (void)
5229 {
5230 thash_t *ptr;
5231 static thash_t initial_thash;
5232
5233 #ifndef MALLOC_CHECK
5234 int unallocated = alloc_counts[ (int) alloc_type_thash ].unallocated;
5235 page_t *cur_page = alloc_counts[ (int) alloc_type_thash ].cur_page;
5236
5237 if (unallocated == 0)
5238 {
5239 unallocated = PAGE_SIZE / sizeof (thash_t);
5240 alloc_counts[ (int) alloc_type_thash ].cur_page = cur_page = allocate_page ();
5241 alloc_counts[ (int) alloc_type_thash ].total_pages++;
5242 }
5243
5244 ptr = &cur_page->thash[ --unallocated ];
5245 alloc_counts[ (int) alloc_type_thash ].unallocated = unallocated;
5246
5247 #else
5248 ptr = xmalloc (sizeof (thash_t));
5249
5250 #endif
5251
5252 alloc_counts[ (int) alloc_type_thash ].total_alloc++;
5253 *ptr = initial_thash;
5254 return ptr;
5255 }
5256
5257 \f
5258 /* Allocate structure, union, or enum tag information. */
5259
5260 STATIC tag_t *
5261 allocate_tag (void)
5262 {
5263 tag_t *ptr;
5264 static tag_t initial_tag;
5265
5266 #ifndef MALLOC_CHECK
5267 ptr = alloc_counts[ (int) alloc_type_tag ].free_list.f_tag;
5268 if (ptr != (tag_t *) 0)
5269 alloc_counts[ (int) alloc_type_tag ].free_list.f_tag = ptr->free;
5270
5271 else
5272 {
5273 int unallocated = alloc_counts[ (int) alloc_type_tag ].unallocated;
5274 page_t *cur_page = alloc_counts[ (int) alloc_type_tag ].cur_page;
5275
5276 if (unallocated == 0)
5277 {
5278 unallocated = PAGE_SIZE / sizeof (tag_t);
5279 alloc_counts[ (int) alloc_type_tag ].cur_page = cur_page = allocate_page ();
5280 alloc_counts[ (int) alloc_type_tag ].total_pages++;
5281 }
5282
5283 ptr = &cur_page->tag[ --unallocated ];
5284 alloc_counts[ (int) alloc_type_tag ].unallocated = unallocated;
5285 }
5286
5287 #else
5288 ptr = xmalloc (sizeof (tag_t));
5289
5290 #endif
5291
5292 alloc_counts[ (int) alloc_type_tag ].total_alloc++;
5293 *ptr = initial_tag;
5294 return ptr;
5295 }
5296
5297 /* Free scoping information. */
5298
5299 STATIC void
5300 free_tag (tag_t *ptr)
5301 {
5302 alloc_counts[ (int) alloc_type_tag ].total_free++;
5303
5304 #ifndef MALLOC_CHECK
5305 ptr->free = alloc_counts[ (int) alloc_type_tag ].free_list.f_tag;
5306 alloc_counts[ (int) alloc_type_tag ].free_list.f_tag = ptr;
5307
5308 #else
5309 free (ptr);
5310 #endif
5311
5312 }
5313
5314 \f
5315 /* Allocate forward reference to a yet unknown tag. */
5316
5317 STATIC forward_t *
5318 allocate_forward (void)
5319 {
5320 forward_t *ptr;
5321 static forward_t initial_forward;
5322
5323 #ifndef MALLOC_CHECK
5324 ptr = alloc_counts[ (int) alloc_type_forward ].free_list.f_forward;
5325 if (ptr != (forward_t *) 0)
5326 alloc_counts[ (int) alloc_type_forward ].free_list.f_forward = ptr->free;
5327
5328 else
5329 {
5330 int unallocated = alloc_counts[ (int) alloc_type_forward ].unallocated;
5331 page_t *cur_page = alloc_counts[ (int) alloc_type_forward ].cur_page;
5332
5333 if (unallocated == 0)
5334 {
5335 unallocated = PAGE_SIZE / sizeof (forward_t);
5336 alloc_counts[ (int) alloc_type_forward ].cur_page = cur_page = allocate_page ();
5337 alloc_counts[ (int) alloc_type_forward ].total_pages++;
5338 }
5339
5340 ptr = &cur_page->forward[ --unallocated ];
5341 alloc_counts[ (int) alloc_type_forward ].unallocated = unallocated;
5342 }
5343
5344 #else
5345 ptr = xmalloc (sizeof (forward_t));
5346
5347 #endif
5348
5349 alloc_counts[ (int) alloc_type_forward ].total_alloc++;
5350 *ptr = initial_forward;
5351 return ptr;
5352 }
5353
5354 /* Free scoping information. */
5355
5356 STATIC void
5357 free_forward (forward_t *ptr)
5358 {
5359 alloc_counts[ (int) alloc_type_forward ].total_free++;
5360
5361 #ifndef MALLOC_CHECK
5362 ptr->free = alloc_counts[ (int) alloc_type_forward ].free_list.f_forward;
5363 alloc_counts[ (int) alloc_type_forward ].free_list.f_forward = ptr;
5364
5365 #else
5366 free (ptr);
5367 #endif
5368
5369 }
5370
5371 \f
5372 /* Allocate head of type hash list. */
5373
5374 STATIC thead_t *
5375 allocate_thead (void)
5376 {
5377 thead_t *ptr;
5378 static thead_t initial_thead;
5379
5380 #ifndef MALLOC_CHECK
5381 ptr = alloc_counts[ (int) alloc_type_thead ].free_list.f_thead;
5382 if (ptr != (thead_t *) 0)
5383 alloc_counts[ (int) alloc_type_thead ].free_list.f_thead = ptr->free;
5384
5385 else
5386 {
5387 int unallocated = alloc_counts[ (int) alloc_type_thead ].unallocated;
5388 page_t *cur_page = alloc_counts[ (int) alloc_type_thead ].cur_page;
5389
5390 if (unallocated == 0)
5391 {
5392 unallocated = PAGE_SIZE / sizeof (thead_t);
5393 alloc_counts[ (int) alloc_type_thead ].cur_page = cur_page = allocate_page ();
5394 alloc_counts[ (int) alloc_type_thead ].total_pages++;
5395 }
5396
5397 ptr = &cur_page->thead[ --unallocated ];
5398 alloc_counts[ (int) alloc_type_thead ].unallocated = unallocated;
5399 }
5400
5401 #else
5402 ptr = xmalloc (sizeof (thead_t));
5403
5404 #endif
5405
5406 alloc_counts[ (int) alloc_type_thead ].total_alloc++;
5407 *ptr = initial_thead;
5408 return ptr;
5409 }
5410
5411 /* Free scoping information. */
5412
5413 STATIC void
5414 free_thead (thead_t *ptr)
5415 {
5416 alloc_counts[ (int) alloc_type_thead ].total_free++;
5417
5418 #ifndef MALLOC_CHECK
5419 ptr->free = (thead_t *) alloc_counts[ (int) alloc_type_thead ].free_list.f_thead;
5420 alloc_counts[ (int) alloc_type_thead ].free_list.f_thead = ptr;
5421
5422 #else
5423 free (ptr);
5424 #endif
5425
5426 }
5427
5428 #endif /* MIPS_DEBUGGING_INFO */
5429
5430 \f
5431 /* Output an error message and exit. */
5432
5433 void
5434 fatal (const char *format, ...)
5435 {
5436 va_list ap;
5437
5438 va_start (ap, format);
5439
5440 if (line_number > 0)
5441 fprintf (stderr, "%s, %s:%ld ", progname, input_name, line_number);
5442 else
5443 fprintf (stderr, "%s:", progname);
5444
5445 vfprintf (stderr, format, ap);
5446 va_end (ap);
5447 fprintf (stderr, "\n");
5448 if (line_number > 0)
5449 fprintf (stderr, "line:\t%s\n", cur_line_start);
5450
5451 saber_stop ();
5452 exit (1);
5453 }
5454
5455 void
5456 error (const char *format, ...)
5457 {
5458 va_list ap;
5459
5460 va_start (ap, format);
5461
5462 if (line_number > 0)
5463 fprintf (stderr, "%s, %s:%ld ", progname, input_name, line_number);
5464 else
5465 fprintf (stderr, "%s:", progname);
5466
5467 vfprintf (stderr, format, ap);
5468 fprintf (stderr, "\n");
5469 if (line_number > 0)
5470 fprintf (stderr, "line:\t%s\n", cur_line_start);
5471
5472 had_errors++;
5473 va_end (ap);
5474
5475 saber_stop ();
5476 }
5477
5478 /* More 'friendly' abort that prints the line and file. */
5479
5480 void
5481 fancy_abort (const char *file, int line, const char *func)
5482 {
5483 fatal ("abort in %s, at %s:%d", func, file, line);
5484 }
5485 \f
5486
5487 /* When `malloc.c' is compiled with `rcheck' defined,
5488 it calls this function to report clobberage. */
5489
5490 void
5491 botch (const char *s)
5492 {
5493 fatal ("%s", s);
5494 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org