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