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