OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [gas/] [ecoff.c] - Blame information for rev 856

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.