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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [ieee.c] - Blame information for rev 294

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

Line No. Rev Author Line
1 24 jeremybenn
/* BFD back-end for ieee-695 objects.
2
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 225 jeremybenn
   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009
4 24 jeremybenn
   Free Software Foundation, Inc.
5
 
6
   Written by Steve Chamberlain of Cygnus Support.
7
 
8
   This file is part of BFD, the Binary File Descriptor library.
9
 
10
   This program is free software; you can redistribute it and/or modify
11
   it under the terms of the GNU General Public License as published by
12
   the Free Software Foundation; either version 3 of the License, or
13
   (at your option) any later version.
14
 
15
   This program is distributed in the hope that it will be useful,
16
   but WITHOUT ANY WARRANTY; without even the implied warranty of
17
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
   GNU General Public License for more details.
19
 
20
   You should have received a copy of the GNU General Public License
21
   along with this program; if not, write to the Free Software
22
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23
   MA 02110-1301, USA.  */
24
 
25
 
26
#define KEEPMINUSPCININST 0
27
 
28
/* IEEE 695 format is a stream of records, which we parse using a simple one-
29
   token (which is one byte in this lexicon) lookahead recursive decent
30
   parser.  */
31
 
32
#include "sysdep.h"
33
#include "bfd.h"
34
#include "libbfd.h"
35
#include "ieee.h"
36
#include "libieee.h"
37
#include "safe-ctype.h"
38
 
39
struct output_buffer_struct
40
{
41
  unsigned char *ptrp;
42
  int buffer;
43
};
44
 
45
static unsigned char *output_ptr_start;
46
static unsigned char *output_ptr;
47
static unsigned char *output_ptr_end;
48
static unsigned char *input_ptr_start;
49
static unsigned char *input_ptr;
50
static unsigned char *input_ptr_end;
51
static bfd *input_bfd;
52
static bfd *output_bfd;
53
static int output_buffer;
54
 
55
 
56
static void block (void);
57
 
58
/* Functions for writing to ieee files in the strange way that the
59
   standard requires.  */
60
 
61
static bfd_boolean
62
ieee_write_byte (bfd *abfd, int barg)
63
{
64
  bfd_byte byte;
65
 
66
  byte = barg;
67
  if (bfd_bwrite ((void *) &byte, (bfd_size_type) 1, abfd) != 1)
68
    return FALSE;
69
  return TRUE;
70
}
71
 
72
static bfd_boolean
73
ieee_write_2bytes (bfd *abfd, int bytes)
74
{
75
  bfd_byte buffer[2];
76
 
77
  buffer[0] = bytes >> 8;
78
  buffer[1] = bytes & 0xff;
79
  if (bfd_bwrite ((void *) buffer, (bfd_size_type) 2, abfd) != 2)
80
    return FALSE;
81
  return TRUE;
82
}
83
 
84
static bfd_boolean
85
ieee_write_int (bfd *abfd, bfd_vma value)
86
{
87
  if (value <= 127)
88
    {
89
      if (! ieee_write_byte (abfd, (bfd_byte) value))
90
        return FALSE;
91
    }
92
  else
93
    {
94
      unsigned int length;
95
 
96
      /* How many significant bytes ?  */
97
      /* FIXME FOR LONGER INTS.  */
98
      if (value & 0xff000000)
99
        length = 4;
100
      else if (value & 0x00ff0000)
101
        length = 3;
102
      else if (value & 0x0000ff00)
103
        length = 2;
104
      else
105
        length = 1;
106
 
107
      if (! ieee_write_byte (abfd,
108
                             (bfd_byte) ((int) ieee_number_repeat_start_enum
109
                                         + length)))
110
        return FALSE;
111
      switch (length)
112
        {
113
        case 4:
114
          if (! ieee_write_byte (abfd, (bfd_byte) (value >> 24)))
115
            return FALSE;
116
          /* Fall through.  */
117
        case 3:
118
          if (! ieee_write_byte (abfd, (bfd_byte) (value >> 16)))
119
            return FALSE;
120
          /* Fall through.  */
121
        case 2:
122
          if (! ieee_write_byte (abfd, (bfd_byte) (value >> 8)))
123
            return FALSE;
124
          /* Fall through.  */
125
        case 1:
126
          if (! ieee_write_byte (abfd, (bfd_byte) (value)))
127
            return FALSE;
128
        }
129
    }
130
 
131
  return TRUE;
132
}
133
 
134
static bfd_boolean
135
ieee_write_id (bfd *abfd, const char *id)
136
{
137
  size_t length = strlen (id);
138
 
139
  if (length <= 127)
140
    {
141
      if (! ieee_write_byte (abfd, (bfd_byte) length))
142
        return FALSE;
143
    }
144
  else if (length < 255)
145
    {
146
      if (! ieee_write_byte (abfd, ieee_extension_length_1_enum)
147
          || ! ieee_write_byte (abfd, (bfd_byte) length))
148
        return FALSE;
149
    }
150
  else if (length < 65535)
151
    {
152
      if (! ieee_write_byte (abfd, ieee_extension_length_2_enum)
153
          || ! ieee_write_2bytes (abfd, (int) length))
154
        return FALSE;
155
    }
156
  else
157
    {
158
      (*_bfd_error_handler)
159
        (_("%s: string too long (%d chars, max 65535)"),
160
         bfd_get_filename (abfd), length);
161
      bfd_set_error (bfd_error_invalid_operation);
162
      return FALSE;
163
    }
164
 
165
  if (bfd_bwrite ((void *) id, (bfd_size_type) length, abfd) != length)
166
    return FALSE;
167
  return TRUE;
168
}
169
 
170
/* Functions for reading from ieee files in the strange way that the
171
   standard requires.  */
172
 
173
#define this_byte(ieee)           *((ieee)->input_p)
174
#define next_byte(ieee)            ((ieee)->input_p++)
175
#define this_byte_and_next(ieee) (*((ieee)->input_p++))
176
 
177
static unsigned short
178
read_2bytes (common_header_type *ieee)
179
{
180
  unsigned char c1 = this_byte_and_next (ieee);
181
  unsigned char c2 = this_byte_and_next (ieee);
182
 
183
  return (c1 << 8) | c2;
184
}
185
 
186
static void
187
bfd_get_string (common_header_type *ieee, char *string, size_t length)
188
{
189
  size_t i;
190
 
191
  for (i = 0; i < length; i++)
192
    string[i] = this_byte_and_next (ieee);
193
}
194
 
195
static char *
196
read_id (common_header_type *ieee)
197
{
198
  size_t length;
199
  char *string;
200
 
201
  length = this_byte_and_next (ieee);
202
  if (length <= 0x7f)
203
    /* Simple string of length 0 to 127.  */
204
    ;
205
 
206
  else if (length == 0xde)
207
    /* Length is next byte, allowing 0..255.  */
208
    length = this_byte_and_next (ieee);
209
 
210
  else if (length == 0xdf)
211
    {
212
      /* Length is next two bytes, allowing 0..65535.  */
213
      length = this_byte_and_next (ieee);
214
      length = (length * 256) + this_byte_and_next (ieee);
215
    }
216
 
217
  /* Buy memory and read string.  */
218
  string = bfd_alloc (ieee->abfd, (bfd_size_type) length + 1);
219
  if (!string)
220
    return NULL;
221
  bfd_get_string (ieee, string, length);
222
  string[length] = 0;
223
  return string;
224
}
225
 
226
static bfd_boolean
227
ieee_write_expression (bfd *abfd,
228
                       bfd_vma value,
229
                       asymbol *symbol,
230
                       bfd_boolean pcrel,
231
                       unsigned int index)
232
{
233
  unsigned int term_count = 0;
234
 
235
  if (value != 0)
236
    {
237
      if (! ieee_write_int (abfd, value))
238
        return FALSE;
239
      term_count++;
240
    }
241
 
242
  /* Badly formatted binaries can have a missing symbol,
243
     so test here to prevent a seg fault.  */
244
  if (symbol != NULL)
245
    {
246
      if (bfd_is_com_section (symbol->section)
247
          || bfd_is_und_section (symbol->section))
248
        {
249
          /* Def of a common symbol.  */
250
          if (! ieee_write_byte (abfd, ieee_variable_X_enum)
251
              || ! ieee_write_int (abfd, symbol->value))
252
            return FALSE;
253
          term_count ++;
254
        }
255
      else if (! bfd_is_abs_section (symbol->section))
256
        {
257
          /* Ref to defined symbol -  */
258
          if (symbol->flags & BSF_GLOBAL)
259
            {
260
              if (! ieee_write_byte (abfd, ieee_variable_I_enum)
261
                  || ! ieee_write_int (abfd, symbol->value))
262
                return FALSE;
263
              term_count++;
264
            }
265
          else if (symbol->flags & (BSF_LOCAL | BSF_SECTION_SYM))
266
            {
267
              /* This is a reference to a defined local symbol.  We can
268
                 easily do a local as a section+offset.  */
269
              if (! ieee_write_byte (abfd, ieee_variable_R_enum)
270
                  || ! ieee_write_byte (abfd,
271
                                        (bfd_byte) (symbol->section->index
272
                                                    + IEEE_SECTION_NUMBER_BASE)))
273
                return FALSE;
274
 
275
              term_count++;
276
              if (symbol->value != 0)
277
                {
278
                  if (! ieee_write_int (abfd, symbol->value))
279
                    return FALSE;
280
                  term_count++;
281
                }
282
            }
283
          else
284
            {
285
              (*_bfd_error_handler)
286
                (_("%s: unrecognized symbol `%s' flags 0x%x"),
287
                 bfd_get_filename (abfd), bfd_asymbol_name (symbol),
288
                 symbol->flags);
289
              bfd_set_error (bfd_error_invalid_operation);
290
              return FALSE;
291
            }
292
        }
293
    }
294
 
295
  if (pcrel)
296
    {
297
      /* Subtract the pc from here by asking for PC of this section.  */
298
      if (! ieee_write_byte (abfd, ieee_variable_P_enum)
299
          || ! ieee_write_byte (abfd,
300
                                (bfd_byte) (index + IEEE_SECTION_NUMBER_BASE))
301
          || ! ieee_write_byte (abfd, ieee_function_minus_enum))
302
        return FALSE;
303
    }
304
 
305
  /* Handle the degenerate case of a 0 address.  */
306
  if (term_count == 0)
307
    if (! ieee_write_int (abfd, (bfd_vma) 0))
308
      return FALSE;
309
 
310
  while (term_count > 1)
311
    {
312
      if (! ieee_write_byte (abfd, ieee_function_plus_enum))
313
        return FALSE;
314
      term_count--;
315
    }
316
 
317
  return TRUE;
318
}
319
 
320
/* Writes any integer into the buffer supplied and always takes 5 bytes.  */
321
 
322
static void
323
ieee_write_int5 (bfd_byte *buffer, bfd_vma value)
324
{
325
  buffer[0] = (bfd_byte) ieee_number_repeat_4_enum;
326
  buffer[1] = (value >> 24) & 0xff;
327
  buffer[2] = (value >> 16) & 0xff;
328
  buffer[3] = (value >> 8) & 0xff;
329
  buffer[4] = (value >> 0) & 0xff;
330
}
331
 
332
static bfd_boolean
333
ieee_write_int5_out (bfd *abfd, bfd_vma value)
334
{
335
  bfd_byte b[5];
336
 
337
  ieee_write_int5 (b, value);
338
  if (bfd_bwrite ((void *) b, (bfd_size_type) 5, abfd) != 5)
339
    return FALSE;
340
  return TRUE;
341
}
342
 
343
static bfd_boolean
344
parse_int (common_header_type *ieee, bfd_vma *value_ptr)
345
{
346
  int value = this_byte (ieee);
347
  int result;
348
 
349
  if (value >= 0 && value <= 127)
350
    {
351
      *value_ptr = value;
352
      next_byte (ieee);
353
      return TRUE;
354
    }
355
  else if (value >= 0x80 && value <= 0x88)
356
    {
357
      unsigned int count = value & 0xf;
358
 
359
      result = 0;
360
      next_byte (ieee);
361
      while (count)
362
        {
363
          result = (result << 8) | this_byte_and_next (ieee);
364
          count--;
365
        }
366
      *value_ptr = result;
367
      return TRUE;
368
    }
369
  return FALSE;
370
}
371
 
372
static int
373
parse_i (common_header_type *ieee, bfd_boolean *ok)
374
{
375
  bfd_vma x = 0;
376
  *ok = parse_int (ieee, &x);
377
  return x;
378
}
379
 
380
static bfd_vma
381
must_parse_int (common_header_type *ieee)
382
{
383
  bfd_vma result = 0;
384
  BFD_ASSERT (parse_int (ieee, &result));
385
  return result;
386
}
387
 
388
typedef struct
389
{
390
  bfd_vma value;
391
  asection *section;
392
  ieee_symbol_index_type symbol;
393
} ieee_value_type;
394
 
395
 
396
#if KEEPMINUSPCININST
397
 
398
#define SRC_MASK(arg) arg
399
#define PCREL_OFFSET FALSE
400
 
401
#else
402
 
403
#define SRC_MASK(arg) 0
404
#define PCREL_OFFSET TRUE
405
 
406
#endif
407
 
408
static reloc_howto_type abs32_howto =
409
  HOWTO (1,
410
         0,
411
         2,
412
         32,
413
         FALSE,
414
         0,
415
         complain_overflow_bitfield,
416
         0,
417
         "abs32",
418
         TRUE,
419
         0xffffffff,
420
         0xffffffff,
421
         FALSE);
422
 
423
static reloc_howto_type abs16_howto =
424
  HOWTO (1,
425
         0,
426
         1,
427
         16,
428
         FALSE,
429
         0,
430
         complain_overflow_bitfield,
431
         0,
432
         "abs16",
433
         TRUE,
434
         0x0000ffff,
435
         0x0000ffff,
436
         FALSE);
437
 
438
static reloc_howto_type abs8_howto =
439
  HOWTO (1,
440
         0,
441
         0,
442
         8,
443
         FALSE,
444
         0,
445
         complain_overflow_bitfield,
446
         0,
447
         "abs8",
448
         TRUE,
449
         0x000000ff,
450
         0x000000ff,
451
         FALSE);
452
 
453
static reloc_howto_type rel32_howto =
454
  HOWTO (1,
455
         0,
456
         2,
457
         32,
458
         TRUE,
459
         0,
460
         complain_overflow_signed,
461
         0,
462
         "rel32",
463
         TRUE,
464
         SRC_MASK (0xffffffff),
465
         0xffffffff,
466
         PCREL_OFFSET);
467
 
468
static reloc_howto_type rel16_howto =
469
  HOWTO (1,
470
         0,
471
         1,
472
         16,
473
         TRUE,
474
         0,
475
         complain_overflow_signed,
476
         0,
477
         "rel16",
478
         TRUE,
479
         SRC_MASK (0x0000ffff),
480
         0x0000ffff,
481
         PCREL_OFFSET);
482
 
483
static reloc_howto_type rel8_howto =
484
  HOWTO (1,
485
         0,
486
         0,
487
         8,
488
         TRUE,
489
         0,
490
         complain_overflow_signed,
491
         0,
492
         "rel8",
493
         TRUE,
494
         SRC_MASK (0x000000ff),
495
         0x000000ff,
496
         PCREL_OFFSET);
497
 
498
static ieee_symbol_index_type NOSYMBOL = {0, 0};
499
 
500
static void
501
parse_expression (ieee_data_type *ieee,
502
                  bfd_vma *value,
503
                  ieee_symbol_index_type *symbol,
504
                  bfd_boolean *pcrel,
505
                  unsigned int *extra,
506
                  asection **section)
507
 
508
{
509
  bfd_boolean loop = TRUE;
510
  ieee_value_type stack[10];
511
  ieee_value_type *sp = stack;
512
  asection *dummy;
513
 
514
#define POS sp[1]
515
#define TOS sp[0]
516
#define NOS sp[-1]
517
#define INC sp++;
518
#define DEC sp--;
519
 
520
  /* The stack pointer always points to the next unused location.  */
521
#define PUSH(x,y,z) TOS.symbol = x; TOS.section = y; TOS.value = z; INC;
522
#define POP(x,y,z)  DEC; x = TOS.symbol; y = TOS.section; z = TOS.value;
523
 
524
  while (loop && ieee->h.input_p < ieee->h.last_byte)
525
    {
526
      switch (this_byte (&(ieee->h)))
527
        {
528
        case ieee_variable_P_enum:
529
          /* P variable, current program counter for section n.  */
530
          {
531
            int section_n;
532
 
533
            next_byte (&(ieee->h));
534
            *pcrel = TRUE;
535
            section_n = must_parse_int (&(ieee->h));
536
            PUSH (NOSYMBOL, bfd_abs_section_ptr, 0);
537
            break;
538
          }
539
        case ieee_variable_L_enum:
540
          /* L variable  address of section N.  */
541
          next_byte (&(ieee->h));
542
          PUSH (NOSYMBOL, ieee->section_table[must_parse_int (&(ieee->h))], 0);
543
          break;
544
        case ieee_variable_R_enum:
545
          /* R variable, logical address of section module.  */
546
          /* FIXME, this should be different to L.  */
547
          next_byte (&(ieee->h));
548
          PUSH (NOSYMBOL, ieee->section_table[must_parse_int (&(ieee->h))], 0);
549
          break;
550
        case ieee_variable_S_enum:
551
          /* S variable, size in MAUS of section module.  */
552
          next_byte (&(ieee->h));
553
          PUSH (NOSYMBOL,
554
                0,
555
                ieee->section_table[must_parse_int (&(ieee->h))]->size);
556
          break;
557
        case ieee_variable_I_enum:
558
          /* Push the address of variable n.  */
559
          {
560
            ieee_symbol_index_type sy;
561
 
562
            next_byte (&(ieee->h));
563
            sy.index = (int) must_parse_int (&(ieee->h));
564
            sy.letter = 'I';
565
 
566
            PUSH (sy, bfd_abs_section_ptr, 0);
567
          }
568
          break;
569
        case ieee_variable_X_enum:
570
          /* Push the address of external variable n.  */
571
          {
572
            ieee_symbol_index_type sy;
573
 
574
            next_byte (&(ieee->h));
575
            sy.index = (int) (must_parse_int (&(ieee->h)));
576
            sy.letter = 'X';
577
 
578
            PUSH (sy, bfd_und_section_ptr, 0);
579
          }
580
          break;
581
        case ieee_function_minus_enum:
582
          {
583
            bfd_vma value1, value2;
584
            asection *section1, *section_dummy;
585
            ieee_symbol_index_type sy;
586
 
587
            next_byte (&(ieee->h));
588
 
589
            POP (sy, section1, value1);
590
            POP (sy, section_dummy, value2);
591
            PUSH (sy, section1 ? section1 : section_dummy, value2 - value1);
592
          }
593
          break;
594
        case ieee_function_plus_enum:
595
          {
596
            bfd_vma value1, value2;
597
            asection *section1;
598
            asection *section2;
599
            ieee_symbol_index_type sy1;
600
            ieee_symbol_index_type sy2;
601
 
602
            next_byte (&(ieee->h));
603
 
604
            POP (sy1, section1, value1);
605
            POP (sy2, section2, value2);
606
            PUSH (sy1.letter ? sy1 : sy2,
607
                  bfd_is_abs_section (section1) ? section2 : section1,
608
                  value1 + value2);
609
          }
610
          break;
611
        default:
612
          {
613
            bfd_vma va;
614
 
615
            BFD_ASSERT (this_byte (&(ieee->h)) < (int) ieee_variable_A_enum
616
                    || this_byte (&(ieee->h)) > (int) ieee_variable_Z_enum);
617
            if (parse_int (&(ieee->h), &va))
618
              {
619
                PUSH (NOSYMBOL, bfd_abs_section_ptr, va);
620
              }
621
            else
622
              /* Thats all that we can understand.  */
623
              loop = FALSE;
624
          }
625
        }
626
    }
627
 
628
  /* As far as I can see there is a bug in the Microtec IEEE output
629
     which I'm using to scan, whereby the comma operator is omitted
630
     sometimes in an expression, giving expressions with too many
631
     terms.  We can tell if that's the case by ensuring that
632
     sp == stack here.  If not, then we've pushed something too far,
633
     so we keep adding.  */
634
  while (sp != stack + 1)
635
    {
636
      asection *section1;
637
      ieee_symbol_index_type sy1;
638
 
639
      POP (sy1, section1, *extra);
640
    }
641
 
642
  POP (*symbol, dummy, *value);
643
  if (section)
644
    *section = dummy;
645
}
646
 
647
 
648
#define ieee_seek(ieee, offset) \
649
  do                                                            \
650
    {                                                           \
651
      ieee->h.input_p = ieee->h.first_byte + offset;            \
652
      ieee->h.last_byte = (ieee->h.first_byte                   \
653
                           + ieee_part_after (ieee, offset));   \
654
    }                                                           \
655
  while (0)
656
 
657
#define ieee_pos(ieee) \
658
  (ieee->h.input_p - ieee->h.first_byte)
659
 
660
/* Find the first part of the ieee file after HERE.  */
661
 
662
static file_ptr
663
ieee_part_after (ieee_data_type *ieee, file_ptr here)
664
{
665
  int part;
666
  file_ptr after = ieee->w.r.me_record;
667
 
668
  /* File parts can come in any order, except that module end is
669
     guaranteed to be last (and the header first).  */
670
  for (part = 0; part < N_W_VARIABLES; part++)
671
    if (ieee->w.offset[part] > here && after > ieee->w.offset[part])
672
      after = ieee->w.offset[part];
673
 
674
  return after;
675
}
676
 
677
static unsigned int last_index;
678
static char last_type;          /* Is the index for an X or a D.  */
679
 
680
static ieee_symbol_type *
681
get_symbol (bfd *abfd ATTRIBUTE_UNUSED,
682
            ieee_data_type *ieee,
683
            ieee_symbol_type *last_symbol,
684
            unsigned int *symbol_count,
685
            ieee_symbol_type ***pptr,
686
            unsigned int *max_index,
687
            int this_type)
688
{
689
  /* Need a new symbol.  */
690
  unsigned int new_index = must_parse_int (&(ieee->h));
691
 
692
  if (new_index != last_index || this_type != last_type)
693
    {
694
      ieee_symbol_type *new_symbol;
695
      bfd_size_type amt = sizeof (ieee_symbol_type);
696
 
697
      new_symbol = bfd_alloc (ieee->h.abfd, amt);
698
      if (!new_symbol)
699
        return NULL;
700
 
701
      new_symbol->index = new_index;
702
      last_index = new_index;
703
      (*symbol_count)++;
704
      **pptr = new_symbol;
705
      *pptr = &new_symbol->next;
706
      if (new_index > *max_index)
707
        *max_index = new_index;
708
 
709
      last_type = this_type;
710
      new_symbol->symbol.section = bfd_abs_section_ptr;
711
      return new_symbol;
712
    }
713
  return last_symbol;
714
}
715
 
716
static bfd_boolean
717
ieee_slurp_external_symbols (bfd *abfd)
718
{
719
  ieee_data_type *ieee = IEEE_DATA (abfd);
720
  file_ptr offset = ieee->w.r.external_part;
721
 
722
  ieee_symbol_type **prev_symbols_ptr = &ieee->external_symbols;
723
  ieee_symbol_type **prev_reference_ptr = &ieee->external_reference;
724
  ieee_symbol_type *symbol = NULL;
725
  unsigned int symbol_count = 0;
726
  bfd_boolean loop = TRUE;
727
 
728
  last_index = 0xffffff;
729
  ieee->symbol_table_full = TRUE;
730
 
731
  ieee_seek (ieee, offset);
732
 
733
  while (loop)
734
    {
735
      switch (this_byte (&(ieee->h)))
736
        {
737
        case ieee_nn_record:
738
          next_byte (&(ieee->h));
739
 
740
          symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
741
                               & prev_symbols_ptr,
742
                               & ieee->external_symbol_max_index, 'I');
743
          if (symbol == NULL)
744
            return FALSE;
745
 
746
          symbol->symbol.the_bfd = abfd;
747
          symbol->symbol.name = read_id (&(ieee->h));
748
          symbol->symbol.udata.p = NULL;
749
          symbol->symbol.flags = BSF_NO_FLAGS;
750
          break;
751
        case ieee_external_symbol_enum:
752
          next_byte (&(ieee->h));
753
 
754
          symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
755
                               &prev_symbols_ptr,
756
                               &ieee->external_symbol_max_index, 'D');
757
          if (symbol == NULL)
758
            return FALSE;
759
 
760
          BFD_ASSERT (symbol->index >= ieee->external_symbol_min_index);
761
 
762
          symbol->symbol.the_bfd = abfd;
763
          symbol->symbol.name = read_id (&(ieee->h));
764
          symbol->symbol.udata.p = NULL;
765
          symbol->symbol.flags = BSF_NO_FLAGS;
766
          break;
767
        case ieee_attribute_record_enum >> 8:
768
          {
769
            unsigned int symbol_name_index;
770
            unsigned int symbol_type_index;
771
            unsigned int symbol_attribute_def;
772
            bfd_vma value = 0;
773
 
774
            switch (read_2bytes (&ieee->h))
775
              {
776
              case ieee_attribute_record_enum:
777
                symbol_name_index = must_parse_int (&(ieee->h));
778
                symbol_type_index = must_parse_int (&(ieee->h));
779
                symbol_attribute_def = must_parse_int (&(ieee->h));
780
                switch (symbol_attribute_def)
781
                  {
782
                  case 8:
783
                  case 19:
784
                    parse_int (&ieee->h, &value);
785
                    break;
786
                  default:
787
                    (*_bfd_error_handler)
788
                      (_("%B: unimplemented ATI record %u for symbol %u"),
789
                       abfd, symbol_attribute_def, symbol_name_index);
790
                    bfd_set_error (bfd_error_bad_value);
791
                    return FALSE;
792
                    break;
793
                  }
794
                break;
795
              case ieee_external_reference_info_record_enum:
796
                /* Skip over ATX record.  */
797
                parse_int (&(ieee->h), &value);
798
                parse_int (&(ieee->h), &value);
799
                parse_int (&(ieee->h), &value);
800
                parse_int (&(ieee->h), &value);
801
                break;
802
              case ieee_atn_record_enum:
803
                /* We may get call optimization information here,
804
                   which we just ignore.  The format is
805
                   {$F1}${CE}{index}{$00}{$3F}{$3F}{#_of_ASNs}.  */
806
                parse_int (&ieee->h, &value);
807
                parse_int (&ieee->h, &value);
808
                parse_int (&ieee->h, &value);
809
                if (value != 0x3f)
810
                  {
811
                    (*_bfd_error_handler)
812
                      (_("%B: unexpected ATN type %d in external part"),
813
                         abfd, (int) value);
814
                    bfd_set_error (bfd_error_bad_value);
815
                    return FALSE;
816
                  }
817
                parse_int (&ieee->h, &value);
818
                parse_int (&ieee->h, &value);
819
                while (value > 0)
820
                  {
821
                    bfd_vma val1;
822
 
823
                    --value;
824
 
825
                    switch (read_2bytes (&ieee->h))
826
                      {
827
                      case ieee_asn_record_enum:
828
                        parse_int (&ieee->h, &val1);
829
                        parse_int (&ieee->h, &val1);
830
                        break;
831
 
832
                      default:
833
                        (*_bfd_error_handler)
834
                          (_("%B: unexpected type after ATN"), abfd);
835
                        bfd_set_error (bfd_error_bad_value);
836
                        return FALSE;
837
                      }
838
                  }
839
              }
840
          }
841
          break;
842
        case ieee_value_record_enum >> 8:
843
          {
844
            unsigned int symbol_name_index;
845
            ieee_symbol_index_type symbol_ignore;
846
            bfd_boolean pcrel_ignore;
847
            unsigned int extra;
848
 
849
            next_byte (&(ieee->h));
850
            next_byte (&(ieee->h));
851
 
852
            symbol_name_index = must_parse_int (&(ieee->h));
853
            parse_expression (ieee,
854
                              &symbol->symbol.value,
855
                              &symbol_ignore,
856
                              &pcrel_ignore,
857
                              &extra,
858
                              &symbol->symbol.section);
859
 
860
            /* Fully linked IEEE-695 files tend to give every symbol
861
               an absolute value.  Try to convert that back into a
862
               section relative value.  FIXME: This won't always to
863
               the right thing.  */
864
            if (bfd_is_abs_section (symbol->symbol.section)
865
                && (abfd->flags & HAS_RELOC) == 0)
866
              {
867
                bfd_vma val;
868
                asection *s;
869
 
870
                val = symbol->symbol.value;
871
                for (s = abfd->sections; s != NULL; s = s->next)
872
                  {
873
                    if (val >= s->vma && val < s->vma + s->size)
874
                      {
875
                        symbol->symbol.section = s;
876
                        symbol->symbol.value -= s->vma;
877
                        break;
878
                      }
879
                  }
880
              }
881
 
882
            symbol->symbol.flags = BSF_GLOBAL | BSF_EXPORT;
883
 
884
          }
885
          break;
886
        case ieee_weak_external_reference_enum:
887
          {
888
            bfd_vma size;
889
            bfd_vma value;
890
 
891
            next_byte (&(ieee->h));
892
            /* Throw away the external reference index.  */
893
            (void) must_parse_int (&(ieee->h));
894
            /* Fetch the default size if not resolved.  */
895
            size = must_parse_int (&(ieee->h));
896
            /* Fetch the default value if available.  */
897
            if (! parse_int (&(ieee->h), &value))
898
              value = 0;
899
            /* This turns into a common.  */
900
            symbol->symbol.section = bfd_com_section_ptr;
901
            symbol->symbol.value = size;
902
          }
903
          break;
904
 
905
        case ieee_external_reference_enum:
906
          next_byte (&(ieee->h));
907
 
908
          symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
909
                               &prev_reference_ptr,
910
                               &ieee->external_reference_max_index, 'X');
911
          if (symbol == NULL)
912
            return FALSE;
913
 
914
          symbol->symbol.the_bfd = abfd;
915
          symbol->symbol.name = read_id (&(ieee->h));
916
          symbol->symbol.udata.p = NULL;
917
          symbol->symbol.section = bfd_und_section_ptr;
918
          symbol->symbol.value = (bfd_vma) 0;
919
          symbol->symbol.flags = 0;
920
 
921
          BFD_ASSERT (symbol->index >= ieee->external_reference_min_index);
922
          break;
923
 
924
        default:
925
          loop = FALSE;
926
        }
927
    }
928
 
929
  if (ieee->external_symbol_max_index != 0)
930
    {
931
      ieee->external_symbol_count =
932
        ieee->external_symbol_max_index -
933
        ieee->external_symbol_min_index + 1;
934
    }
935
  else
936
    ieee->external_symbol_count = 0;
937
 
938
  if (ieee->external_reference_max_index != 0)
939
    {
940
      ieee->external_reference_count =
941
        ieee->external_reference_max_index -
942
        ieee->external_reference_min_index + 1;
943
    }
944
  else
945
    ieee->external_reference_count = 0;
946
 
947
  abfd->symcount =
948
    ieee->external_reference_count + ieee->external_symbol_count;
949
 
950
  if (symbol_count != abfd->symcount)
951
    /* There are gaps in the table -- */
952
    ieee->symbol_table_full = FALSE;
953
 
954
  *prev_symbols_ptr   = NULL;
955
  *prev_reference_ptr = NULL;
956
 
957
  return TRUE;
958
}
959
 
960
static bfd_boolean
961
ieee_slurp_symbol_table (bfd *abfd)
962
{
963
  if (! IEEE_DATA (abfd)->read_symbols)
964
    {
965
      if (! ieee_slurp_external_symbols (abfd))
966
        return FALSE;
967
      IEEE_DATA (abfd)->read_symbols = TRUE;
968
    }
969
  return TRUE;
970
}
971
 
972
static long
973
ieee_get_symtab_upper_bound (bfd *abfd)
974
{
975
  if (! ieee_slurp_symbol_table (abfd))
976
    return -1;
977
 
978
  return (abfd->symcount != 0) ?
979
    (abfd->symcount + 1) * (sizeof (ieee_symbol_type *)) : 0;
980
}
981
 
982
/* Move from our internal lists to the canon table, and insert in
983
   symbol index order.  */
984
 
985
extern const bfd_target ieee_vec;
986
 
987
static long
988
ieee_canonicalize_symtab (bfd *abfd, asymbol **location)
989
{
990
  ieee_symbol_type *symp;
991
  static bfd dummy_bfd;
992
  static asymbol empty_symbol =
993
  {
994
    &dummy_bfd,
995
    " ieee empty",
996
    (symvalue) 0,
997
    BSF_DEBUGGING,
998
    bfd_abs_section_ptr
999
#ifdef __STDC__
1000
    /* K&R compilers can't initialise unions.  */
1001
    , { 0 }
1002
#endif
1003
  };
1004
 
1005
  if (abfd->symcount)
1006
    {
1007
      ieee_data_type *ieee = IEEE_DATA (abfd);
1008
 
1009
      dummy_bfd.xvec = &ieee_vec;
1010
      if (! ieee_slurp_symbol_table (abfd))
1011
        return -1;
1012
 
1013
      if (! ieee->symbol_table_full)
1014
        {
1015
          /* Arrgh - there are gaps in the table, run through and fill them
1016
             up with pointers to a null place.  */
1017
          unsigned int i;
1018
 
1019
          for (i = 0; i < abfd->symcount; i++)
1020
            location[i] = &empty_symbol;
1021
        }
1022
 
1023
      ieee->external_symbol_base_offset = -ieee->external_symbol_min_index;
1024
      for (symp = IEEE_DATA (abfd)->external_symbols;
1025
           symp != (ieee_symbol_type *) NULL;
1026
           symp = symp->next)
1027
        /* Place into table at correct index locations.  */
1028
        location[symp->index + ieee->external_symbol_base_offset] = &symp->symbol;
1029
 
1030
      /* The external refs are indexed in a bit.  */
1031
      ieee->external_reference_base_offset =
1032
        -ieee->external_reference_min_index + ieee->external_symbol_count;
1033
 
1034
      for (symp = IEEE_DATA (abfd)->external_reference;
1035
           symp != (ieee_symbol_type *) NULL;
1036
           symp = symp->next)
1037
        location[symp->index + ieee->external_reference_base_offset] =
1038
          &symp->symbol;
1039
    }
1040
 
1041
  if (abfd->symcount)
1042
    location[abfd->symcount] = (asymbol *) NULL;
1043
 
1044
  return abfd->symcount;
1045
}
1046
 
1047
static asection *
1048
get_section_entry (bfd *abfd, ieee_data_type *ieee, unsigned int index)
1049
{
1050
  if (index >= ieee->section_table_size)
1051
    {
1052
      unsigned int c, i;
1053
      asection **n;
1054
      bfd_size_type amt;
1055
 
1056
      c = ieee->section_table_size;
1057
      if (c == 0)
1058
        c = 20;
1059
      while (c <= index)
1060
        c *= 2;
1061
 
1062
      amt = c;
1063
      amt *= sizeof (asection *);
1064
      n = bfd_realloc (ieee->section_table, amt);
1065
      if (n == NULL)
1066
        return NULL;
1067
 
1068
      for (i = ieee->section_table_size; i < c; i++)
1069
        n[i] = NULL;
1070
 
1071
      ieee->section_table = n;
1072
      ieee->section_table_size = c;
1073
    }
1074
 
1075
  if (ieee->section_table[index] == (asection *) NULL)
1076
    {
1077
      char *tmp = bfd_alloc (abfd, (bfd_size_type) 11);
1078
      asection *section;
1079
 
1080
      if (!tmp)
1081
        return NULL;
1082
      sprintf (tmp, " fsec%4d", index);
1083
      section = bfd_make_section (abfd, tmp);
1084
      ieee->section_table[index] = section;
1085
      section->target_index = index;
1086
      ieee->section_table[index] = section;
1087
    }
1088
  return ieee->section_table[index];
1089
}
1090
 
1091
static void
1092
ieee_slurp_sections (bfd *abfd)
1093
{
1094
  ieee_data_type *ieee = IEEE_DATA (abfd);
1095
  file_ptr offset = ieee->w.r.section_part;
1096
  char *name;
1097
 
1098
  if (offset != 0)
1099
    {
1100
      bfd_byte section_type[3];
1101
 
1102
      ieee_seek (ieee, offset);
1103
      while (TRUE)
1104
        {
1105
          switch (this_byte (&(ieee->h)))
1106
            {
1107
            case ieee_section_type_enum:
1108
              {
1109
                asection *section;
1110
                unsigned int section_index;
1111
 
1112
                next_byte (&(ieee->h));
1113
                section_index = must_parse_int (&(ieee->h));
1114
 
1115
                section = get_section_entry (abfd, ieee, section_index);
1116
 
1117
                section_type[0] = this_byte_and_next (&(ieee->h));
1118
 
1119
                /* Set minimal section attributes. Attributes are
1120
                   extended later, based on section contents.  */
1121
                switch (section_type[0])
1122
                  {
1123
                  case 0xC1:
1124
                    /* Normal attributes for absolute sections.  */
1125
                    section_type[1] = this_byte (&(ieee->h));
1126
                    section->flags = SEC_ALLOC;
1127
                    switch (section_type[1])
1128
                      {
1129
                        /* AS Absolute section attributes.  */
1130
                      case 0xD3:
1131
                        next_byte (&(ieee->h));
1132
                        section_type[2] = this_byte (&(ieee->h));
1133
                        switch (section_type[2])
1134
                          {
1135
                          case 0xD0:
1136
                            /* Normal code.  */
1137
                            next_byte (&(ieee->h));
1138
                            section->flags |= SEC_CODE;
1139
                            break;
1140
                          case 0xC4:
1141
                            /* Normal data.  */
1142
                            next_byte (&(ieee->h));
1143
                            section->flags |= SEC_DATA;
1144
                            break;
1145
                          case 0xD2:
1146
                            next_byte (&(ieee->h));
1147
                            /* Normal rom data.  */
1148
                            section->flags |= SEC_ROM | SEC_DATA;
1149
                            break;
1150
                          default:
1151
                            break;
1152
                          }
1153
                      }
1154
                    break;
1155
 
1156
                    /* Named relocatable sections (type C).  */
1157
                  case 0xC3:
1158
                    section_type[1] = this_byte (&(ieee->h));
1159
                    section->flags = SEC_ALLOC;
1160
                    switch (section_type[1])
1161
                      {
1162
                      case 0xD0:        /* Normal code (CP).  */
1163
                        next_byte (&(ieee->h));
1164
                        section->flags |= SEC_CODE;
1165
                        break;
1166
                      case 0xC4:        /* Normal data (CD).  */
1167
                        next_byte (&(ieee->h));
1168
                        section->flags |= SEC_DATA;
1169
                        break;
1170
                      case 0xD2:        /* Normal rom data (CR).  */
1171
                        next_byte (&(ieee->h));
1172
                        section->flags |= SEC_ROM | SEC_DATA;
1173
                        break;
1174
                      default:
1175
                        break;
1176
                      }
1177
                  }
1178
 
1179
                /* Read section name, use it if non empty.  */
1180
                name = read_id (&ieee->h);
1181
                if (name[0])
1182
                  section->name = name;
1183
 
1184
                /* Skip these fields, which we don't care about.  */
1185
                {
1186
                  bfd_vma parent, brother, context;
1187
 
1188
                  parse_int (&(ieee->h), &parent);
1189
                  parse_int (&(ieee->h), &brother);
1190
                  parse_int (&(ieee->h), &context);
1191
                }
1192
              }
1193
              break;
1194
            case ieee_section_alignment_enum:
1195
              {
1196
                unsigned int section_index;
1197
                bfd_vma value;
1198
                asection *section;
1199
 
1200
                next_byte (&(ieee->h));
1201
                section_index = must_parse_int (&ieee->h);
1202
                section = get_section_entry (abfd, ieee, section_index);
1203
                if (section_index > ieee->section_count)
1204
                  ieee->section_count = section_index;
1205
 
1206
                section->alignment_power =
1207
                  bfd_log2 (must_parse_int (&ieee->h));
1208
                (void) parse_int (&(ieee->h), &value);
1209
              }
1210
              break;
1211
            case ieee_e2_first_byte_enum:
1212
              {
1213
                asection *section;
1214
                ieee_record_enum_type t;
1215
 
1216
                t = (ieee_record_enum_type) (read_2bytes (&(ieee->h)));
1217
                switch (t)
1218
                  {
1219
                  case ieee_section_size_enum:
1220
                    section = ieee->section_table[must_parse_int (&(ieee->h))];
1221
                    section->size = must_parse_int (&(ieee->h));
1222
                    break;
1223
                  case ieee_physical_region_size_enum:
1224
                    section = ieee->section_table[must_parse_int (&(ieee->h))];
1225
                    section->size = must_parse_int (&(ieee->h));
1226
                    break;
1227
                  case ieee_region_base_address_enum:
1228
                    section = ieee->section_table[must_parse_int (&(ieee->h))];
1229
                    section->vma = must_parse_int (&(ieee->h));
1230
                    section->lma = section->vma;
1231
                    break;
1232
                  case ieee_mau_size_enum:
1233
                    must_parse_int (&(ieee->h));
1234
                    must_parse_int (&(ieee->h));
1235
                    break;
1236
                  case ieee_m_value_enum:
1237
                    must_parse_int (&(ieee->h));
1238
                    must_parse_int (&(ieee->h));
1239
                    break;
1240
                  case ieee_section_base_address_enum:
1241
                    section = ieee->section_table[must_parse_int (&(ieee->h))];
1242
                    section->vma = must_parse_int (&(ieee->h));
1243
                    section->lma = section->vma;
1244
                    break;
1245
                  case ieee_section_offset_enum:
1246
                    (void) must_parse_int (&(ieee->h));
1247
                    (void) must_parse_int (&(ieee->h));
1248
                    break;
1249
                  default:
1250
                    return;
1251
                  }
1252
              }
1253
              break;
1254
            default:
1255
              return;
1256
            }
1257
        }
1258
    }
1259
}
1260
 
1261
/* Make a section for the debugging information, if any.  We don't try
1262
   to interpret the debugging information; we just point the section
1263
   at the area in the file so that program which understand can dig it
1264
   out.  */
1265
 
1266
static bfd_boolean
1267
ieee_slurp_debug (bfd *abfd)
1268
{
1269
  ieee_data_type *ieee = IEEE_DATA (abfd);
1270
  asection *sec;
1271
  file_ptr debug_end;
1272
  flagword flags;
1273
 
1274
  if (ieee->w.r.debug_information_part == 0)
1275
    return TRUE;
1276
 
1277
  flags = SEC_DEBUGGING | SEC_HAS_CONTENTS;
1278
  sec = bfd_make_section_with_flags (abfd, ".debug", flags);
1279
  if (sec == NULL)
1280
    return FALSE;
1281
  sec->filepos = ieee->w.r.debug_information_part;
1282
 
1283
  debug_end = ieee_part_after (ieee, ieee->w.r.debug_information_part);
1284
  sec->size = debug_end - ieee->w.r.debug_information_part;
1285
 
1286
  return TRUE;
1287
}
1288
 
1289
/* Archive stuff.  */
1290
 
1291
static const bfd_target *
1292
ieee_archive_p (bfd *abfd)
1293
{
1294
  char *library;
1295
  unsigned int i;
1296
  unsigned char buffer[512];
1297
  file_ptr buffer_offset = 0;
1298
  ieee_ar_data_type *save = abfd->tdata.ieee_ar_data;
1299
  ieee_ar_data_type *ieee;
1300
  bfd_size_type alc_elts;
1301
  ieee_ar_obstack_type *elts = NULL;
1302
  bfd_size_type amt = sizeof (ieee_ar_data_type);
1303
 
1304
  abfd->tdata.ieee_ar_data = bfd_alloc (abfd, amt);
1305
  if (!abfd->tdata.ieee_ar_data)
1306
    goto error_ret_restore;
1307
  ieee = IEEE_AR_DATA (abfd);
1308
 
1309
  /* Ignore the return value here.  It doesn't matter if we don't read
1310
     the entire buffer.  We might have a very small ieee file.  */
1311
  bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd);
1312
 
1313
  ieee->h.first_byte = buffer;
1314
  ieee->h.input_p = buffer;
1315
 
1316
  ieee->h.abfd = abfd;
1317
 
1318
  if (this_byte (&(ieee->h)) != Module_Beginning)
1319
    goto got_wrong_format_error;
1320
 
1321
  next_byte (&(ieee->h));
1322
  library = read_id (&(ieee->h));
1323
  if (strcmp (library, "LIBRARY") != 0)
1324
    goto got_wrong_format_error;
1325
 
1326
  /* Throw away the filename.  */
1327
  read_id (&(ieee->h));
1328
 
1329
  ieee->element_count = 0;
1330
  ieee->element_index = 0;
1331
 
1332
  next_byte (&(ieee->h));       /* Drop the ad part.  */
1333
  must_parse_int (&(ieee->h));  /* And the two dummy numbers.  */
1334
  must_parse_int (&(ieee->h));
1335
 
1336
  alc_elts = 10;
1337
  elts = bfd_malloc (alc_elts * sizeof *elts);
1338
  if (elts == NULL)
1339
    goto error_return;
1340
 
1341
  /* Read the index of the BB table.  */
1342
  while (1)
1343
    {
1344
      int rec;
1345
      ieee_ar_obstack_type *t;
1346
 
1347
      rec = read_2bytes (&(ieee->h));
1348
      if (rec != (int) ieee_assign_value_to_variable_enum)
1349
        break;
1350
 
1351
      if (ieee->element_count >= alc_elts)
1352
        {
1353
          ieee_ar_obstack_type *n;
1354
 
1355
          alc_elts *= 2;
1356
          n = bfd_realloc (elts, alc_elts * sizeof (* elts));
1357
          if (n == NULL)
1358
            goto error_return;
1359
          elts = n;
1360
        }
1361
 
1362
      t = &elts[ieee->element_count];
1363
      ieee->element_count++;
1364
 
1365
      must_parse_int (&(ieee->h));
1366
      t->file_offset = must_parse_int (&(ieee->h));
1367
      t->abfd = (bfd *) NULL;
1368
 
1369
      /* Make sure that we don't go over the end of the buffer.  */
1370
      if ((size_t) ieee_pos (IEEE_DATA (abfd)) > sizeof (buffer) / 2)
1371
        {
1372
          /* Past half way, reseek and reprime.  */
1373
          buffer_offset += ieee_pos (IEEE_DATA (abfd));
1374
          if (bfd_seek (abfd, buffer_offset, SEEK_SET) != 0)
1375
            goto error_return;
1376
 
1377
          /* Again ignore return value of bfd_bread.  */
1378
          bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd);
1379
          ieee->h.first_byte = buffer;
1380
          ieee->h.input_p = buffer;
1381
        }
1382
    }
1383
 
1384
  amt = ieee->element_count;
1385
  amt *= sizeof *ieee->elements;
1386
  ieee->elements = bfd_alloc (abfd, amt);
1387
  if (ieee->elements == NULL)
1388
    goto error_return;
1389
 
1390
  memcpy (ieee->elements, elts, (size_t) amt);
1391
  free (elts);
1392
  elts = NULL;
1393
 
1394
  /* Now scan the area again, and replace BB offsets with file offsets.  */
1395
  for (i = 2; i < ieee->element_count; i++)
1396
    {
1397
      if (bfd_seek (abfd, ieee->elements[i].file_offset, SEEK_SET) != 0)
1398
        goto error_return;
1399
 
1400
      /* Again ignore return value of bfd_bread.  */
1401
      bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd);
1402
      ieee->h.first_byte = buffer;
1403
      ieee->h.input_p = buffer;
1404
 
1405
      next_byte (&(ieee->h));           /* Drop F8.  */
1406
      next_byte (&(ieee->h));           /* Drop 14.  */
1407
      must_parse_int (&(ieee->h));      /* Drop size of block.  */
1408
 
1409
      if (must_parse_int (&(ieee->h)) != 0)
1410
        /* This object has been deleted.  */
1411
        ieee->elements[i].file_offset = 0;
1412
      else
1413
        ieee->elements[i].file_offset = must_parse_int (&(ieee->h));
1414
    }
1415
 
1416
  /*  abfd->has_armap = ;*/
1417
 
1418
  return abfd->xvec;
1419
 
1420
 got_wrong_format_error:
1421
  bfd_set_error (bfd_error_wrong_format);
1422
 error_return:
1423
  if (elts != NULL)
1424
    free (elts);
1425
  bfd_release (abfd, ieee);
1426
 error_ret_restore:
1427
  abfd->tdata.ieee_ar_data = save;
1428
 
1429
  return NULL;
1430
}
1431
 
1432
static bfd_boolean
1433
ieee_mkobject (bfd *abfd)
1434
{
1435
  bfd_size_type amt;
1436
 
1437
  output_ptr_start = NULL;
1438
  output_ptr = NULL;
1439
  output_ptr_end = NULL;
1440
  input_ptr_start = NULL;
1441
  input_ptr = NULL;
1442
  input_ptr_end = NULL;
1443
  input_bfd = NULL;
1444
  output_bfd = NULL;
1445
  output_buffer = 0;
1446
  amt = sizeof (ieee_data_type);
1447
  abfd->tdata.ieee_data = bfd_zalloc (abfd, amt);
1448
  return abfd->tdata.ieee_data != NULL;
1449
}
1450
 
1451
static bfd_boolean
1452
do_one (ieee_data_type *ieee,
1453
        ieee_per_section_type *current_map,
1454
        unsigned char *location_ptr,
1455
        asection *s,
1456
        int iterations)
1457
{
1458
  switch (this_byte (&(ieee->h)))
1459
    {
1460
    case ieee_load_constant_bytes_enum:
1461
      {
1462
        unsigned int number_of_maus;
1463
        unsigned int i;
1464
 
1465
        next_byte (&(ieee->h));
1466
        number_of_maus = must_parse_int (&(ieee->h));
1467
 
1468
        for (i = 0; i < number_of_maus; i++)
1469
          {
1470
            location_ptr[current_map->pc++] = this_byte (&(ieee->h));
1471
            next_byte (&(ieee->h));
1472
          }
1473
      }
1474
      break;
1475
 
1476
    case ieee_load_with_relocation_enum:
1477
      {
1478
        bfd_boolean loop = TRUE;
1479
 
1480
        next_byte (&(ieee->h));
1481
        while (loop)
1482
          {
1483
            switch (this_byte (&(ieee->h)))
1484
              {
1485
              case ieee_variable_R_enum:
1486
 
1487
              case ieee_function_signed_open_b_enum:
1488
              case ieee_function_unsigned_open_b_enum:
1489
              case ieee_function_either_open_b_enum:
1490
                {
1491
                  unsigned int extra = 4;
1492
                  bfd_boolean pcrel = FALSE;
1493
                  asection *section;
1494
                  ieee_reloc_type *r;
1495
 
1496
                  r = bfd_alloc (ieee->h.abfd, sizeof (* r));
1497
                  if (!r)
1498
                    return FALSE;
1499
 
1500
                  *(current_map->reloc_tail_ptr) = r;
1501
                  current_map->reloc_tail_ptr = &r->next;
1502
                  r->next = (ieee_reloc_type *) NULL;
1503
                  next_byte (&(ieee->h));
1504
/*                          abort();*/
1505
                  r->relent.sym_ptr_ptr = 0;
1506
                  parse_expression (ieee,
1507
                                    &r->relent.addend,
1508
                                    &r->symbol,
1509
                                    &pcrel, &extra, &section);
1510
                  r->relent.address = current_map->pc;
1511
                  s->flags |= SEC_RELOC;
1512
                  s->owner->flags |= HAS_RELOC;
1513
                  s->reloc_count++;
1514
                  if (r->relent.sym_ptr_ptr == NULL && section != NULL)
1515
                    r->relent.sym_ptr_ptr = section->symbol_ptr_ptr;
1516
 
1517
                  if (this_byte (&(ieee->h)) == (int) ieee_comma)
1518
                    {
1519
                      next_byte (&(ieee->h));
1520
                      /* Fetch number of bytes to pad.  */
1521
                      extra = must_parse_int (&(ieee->h));
1522
                    };
1523
 
1524
                  switch (this_byte (&(ieee->h)))
1525
                    {
1526
                    case ieee_function_signed_close_b_enum:
1527
                      next_byte (&(ieee->h));
1528
                      break;
1529
                    case ieee_function_unsigned_close_b_enum:
1530
                      next_byte (&(ieee->h));
1531
                      break;
1532
                    case ieee_function_either_close_b_enum:
1533
                      next_byte (&(ieee->h));
1534
                      break;
1535
                    default:
1536
                      break;
1537
                    }
1538
                  /* Build a relocation entry for this type.  */
1539
                  /* If pc rel then stick -ve pc into instruction
1540
                     and take out of reloc ..
1541
 
1542
                     I've changed this. It's all too complicated. I
1543
                     keep 0 in the instruction now.  */
1544
 
1545
                  switch (extra)
1546
                    {
1547
                    case 0:
1548
                    case 4:
1549
 
1550
                      if (pcrel)
1551
                        {
1552
#if KEEPMINUSPCININST
1553
                          bfd_put_32 (ieee->h.abfd, -current_map->pc,
1554
                                      location_ptr + current_map->pc);
1555
                          r->relent.howto = &rel32_howto;
1556
                          r->relent.addend -= current_map->pc;
1557
#else
1558
                          bfd_put_32 (ieee->h.abfd, (bfd_vma) 0, location_ptr +
1559
                                      current_map->pc);
1560
                          r->relent.howto = &rel32_howto;
1561
#endif
1562
                        }
1563
                      else
1564
                        {
1565
                          bfd_put_32 (ieee->h.abfd, (bfd_vma) 0,
1566
                                      location_ptr + current_map->pc);
1567
                          r->relent.howto = &abs32_howto;
1568
                        }
1569
                      current_map->pc += 4;
1570
                      break;
1571
                    case 2:
1572
                      if (pcrel)
1573
                        {
1574
#if KEEPMINUSPCININST
1575
                          bfd_put_16 (ieee->h.abfd, (bfd_vma) -current_map->pc,
1576
                                      location_ptr + current_map->pc);
1577
                          r->relent.addend -= current_map->pc;
1578
                          r->relent.howto = &rel16_howto;
1579
#else
1580
 
1581
                          bfd_put_16 (ieee->h.abfd, (bfd_vma) 0,
1582
                                      location_ptr + current_map->pc);
1583
                          r->relent.howto = &rel16_howto;
1584
#endif
1585
                        }
1586
 
1587
                      else
1588
                        {
1589
                          bfd_put_16 (ieee->h.abfd, (bfd_vma) 0,
1590
                                      location_ptr + current_map->pc);
1591
                          r->relent.howto = &abs16_howto;
1592
                        }
1593
                      current_map->pc += 2;
1594
                      break;
1595
                    case 1:
1596
                      if (pcrel)
1597
                        {
1598
#if KEEPMINUSPCININST
1599
                          bfd_put_8 (ieee->h.abfd, (int) (-current_map->pc), location_ptr + current_map->pc);
1600
                          r->relent.addend -= current_map->pc;
1601
                          r->relent.howto = &rel8_howto;
1602
#else
1603
                          bfd_put_8 (ieee->h.abfd, 0, location_ptr + current_map->pc);
1604
                          r->relent.howto = &rel8_howto;
1605
#endif
1606
                        }
1607
                      else
1608
                        {
1609
                          bfd_put_8 (ieee->h.abfd, 0, location_ptr + current_map->pc);
1610
                          r->relent.howto = &abs8_howto;
1611
                        }
1612
                      current_map->pc += 1;
1613
                      break;
1614
 
1615
                    default:
1616
                      BFD_FAIL ();
1617
                      return FALSE;
1618
                    }
1619
                }
1620
                break;
1621
              default:
1622
                {
1623
                  bfd_vma this_size;
1624
 
1625
                  if (parse_int (&(ieee->h), &this_size))
1626
                    {
1627
                      unsigned int i;
1628
 
1629
                      for (i = 0; i < this_size; i++)
1630
                        {
1631
                          location_ptr[current_map->pc++] = this_byte (&(ieee->h));
1632
                          next_byte (&(ieee->h));
1633
                        }
1634
                    }
1635
                  else
1636
                    loop = FALSE;
1637
                }
1638
              }
1639
 
1640
            /* Prevent more than the first load-item of an LR record
1641
               from being repeated (MRI convention).  */
1642
            if (iterations != 1)
1643
              loop = FALSE;
1644
          }
1645
      }
1646
    }
1647
  return TRUE;
1648
}
1649
 
1650
/* Read in all the section data and relocation stuff too.  */
1651
 
1652
static bfd_boolean
1653
ieee_slurp_section_data (bfd *abfd)
1654
{
1655
  bfd_byte *location_ptr = (bfd_byte *) NULL;
1656
  ieee_data_type *ieee = IEEE_DATA (abfd);
1657
  unsigned int section_number;
1658
  ieee_per_section_type *current_map = NULL;
1659
  asection *s;
1660
 
1661
  /* Seek to the start of the data area.  */
1662
  if (ieee->read_data)
1663
    return TRUE;
1664
  ieee->read_data = TRUE;
1665
  ieee_seek (ieee, ieee->w.r.data_part);
1666
 
1667
  /* Allocate enough space for all the section contents.  */
1668
  for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1669
    {
1670
      ieee_per_section_type *per = ieee_per_section (s);
1671
      arelent **relpp;
1672
 
1673
      if ((s->flags & SEC_DEBUGGING) != 0)
1674
        continue;
1675
      per->data = bfd_alloc (ieee->h.abfd, s->size);
1676
      if (!per->data)
1677
        return FALSE;
1678
      relpp = &s->relocation;
1679
      per->reloc_tail_ptr = (ieee_reloc_type **) relpp;
1680
    }
1681
 
1682
  while (TRUE)
1683
    {
1684
      switch (this_byte (&(ieee->h)))
1685
        {
1686
          /* IF we see anything strange then quit.  */
1687
        default:
1688
          return TRUE;
1689
 
1690
        case ieee_set_current_section_enum:
1691
          next_byte (&(ieee->h));
1692
          section_number = must_parse_int (&(ieee->h));
1693
          s = ieee->section_table[section_number];
1694
          s->flags |= SEC_LOAD | SEC_HAS_CONTENTS;
1695
          current_map = ieee_per_section (s);
1696
          location_ptr = current_map->data - s->vma;
1697
          /* The document I have says that Microtec's compilers reset
1698
             this after a sec section, even though the standard says not
1699
             to, SO...  */
1700
          current_map->pc = s->vma;
1701
          break;
1702
 
1703
        case ieee_e2_first_byte_enum:
1704
          next_byte (&(ieee->h));
1705
          switch (this_byte (&(ieee->h)))
1706
            {
1707
            case ieee_set_current_pc_enum & 0xff:
1708
              {
1709
                bfd_vma value;
1710
                ieee_symbol_index_type symbol;
1711
                unsigned int extra;
1712
                bfd_boolean pcrel;
1713
 
1714
                next_byte (&(ieee->h));
1715
                must_parse_int (&(ieee->h));    /* Throw away section #.  */
1716
                parse_expression (ieee, &value,
1717
                                  &symbol,
1718
                                  &pcrel, &extra,
1719
                                  0);
1720
                current_map->pc = value;
1721
                BFD_ASSERT ((unsigned) (value - s->vma) <= s->size);
1722
              }
1723
              break;
1724
 
1725
            case ieee_value_starting_address_enum & 0xff:
1726
              next_byte (&(ieee->h));
1727
              if (this_byte (&(ieee->h)) == ieee_function_either_open_b_enum)
1728
                next_byte (&(ieee->h));
1729
              abfd->start_address = must_parse_int (&(ieee->h));
1730
              /* We've got to the end of the data now -  */
1731
              return TRUE;
1732
            default:
1733
              BFD_FAIL ();
1734
              return FALSE;
1735
            }
1736
          break;
1737
        case ieee_repeat_data_enum:
1738
          {
1739
            /* Repeat the following LD or LR n times - we do this by
1740
               remembering the stream pointer before running it and
1741
               resetting it and running it n times. We special case
1742
               the repetition of a repeat_data/load_constant.  */
1743
            unsigned int iterations;
1744
            unsigned char *start;
1745
 
1746
            next_byte (&(ieee->h));
1747
            iterations = must_parse_int (&(ieee->h));
1748
            start = ieee->h.input_p;
1749
            if (start[0] == (int) ieee_load_constant_bytes_enum
1750
                && start[1] == 1)
1751
              {
1752
                while (iterations != 0)
1753
                  {
1754
                    location_ptr[current_map->pc++] = start[2];
1755
                    iterations--;
1756
                  }
1757
                next_byte (&(ieee->h));
1758
                next_byte (&(ieee->h));
1759
                next_byte (&(ieee->h));
1760
              }
1761
            else
1762
              {
1763
                while (iterations != 0)
1764
                  {
1765
                    ieee->h.input_p = start;
1766
                    if (!do_one (ieee, current_map, location_ptr, s,
1767
                                 (int) iterations))
1768
                      return FALSE;
1769
                    iterations--;
1770
                  }
1771
              }
1772
          }
1773
          break;
1774
        case ieee_load_constant_bytes_enum:
1775
        case ieee_load_with_relocation_enum:
1776
          if (!do_one (ieee, current_map, location_ptr, s, 1))
1777
            return FALSE;
1778
        }
1779
    }
1780
}
1781
 
1782
static const bfd_target *
1783
ieee_object_p (bfd *abfd)
1784
{
1785
  char *processor;
1786
  unsigned int part;
1787
  ieee_data_type *ieee;
1788
  unsigned char buffer[300];
1789
  ieee_data_type *save = IEEE_DATA (abfd);
1790
  bfd_size_type amt;
1791
 
1792
  abfd->tdata.ieee_data = 0;
1793
  ieee_mkobject (abfd);
1794
 
1795
  ieee = IEEE_DATA (abfd);
1796
  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
1797
    goto fail;
1798
  /* Read the first few bytes in to see if it makes sense.  Ignore
1799
     bfd_bread return value;  The file might be very small.  */
1800
  bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd);
1801
 
1802
  ieee->h.input_p = buffer;
1803
  if (this_byte_and_next (&(ieee->h)) != Module_Beginning)
1804
    goto got_wrong_format;
1805
 
1806
  ieee->read_symbols = FALSE;
1807
  ieee->read_data = FALSE;
1808
  ieee->section_count = 0;
1809
  ieee->external_symbol_max_index = 0;
1810
  ieee->external_symbol_min_index = IEEE_PUBLIC_BASE;
1811
  ieee->external_reference_min_index = IEEE_REFERENCE_BASE;
1812
  ieee->external_reference_max_index = 0;
1813
  ieee->h.abfd = abfd;
1814
  ieee->section_table = NULL;
1815
  ieee->section_table_size = 0;
1816
 
1817
  processor = ieee->mb.processor = read_id (&(ieee->h));
1818
  if (strcmp (processor, "LIBRARY") == 0)
1819
    goto got_wrong_format;
1820
  ieee->mb.module_name = read_id (&(ieee->h));
1821
  if (abfd->filename == (const char *) NULL)
1822
    abfd->filename = ieee->mb.module_name;
1823
 
1824
  /* Determine the architecture and machine type of the object file.  */
1825
  {
1826
    const bfd_arch_info_type *arch;
1827
    char family[10];
1828
 
1829
    /* IEEE does not specify the format of the processor identification
1830
       string, so the compiler is free to put in it whatever it wants.
1831
       We try here to recognize different processors belonging to the
1832
       m68k family.  Code for other processors can be added here.  */
1833
    if ((processor[0] == '6') && (processor[1] == '8'))
1834
      {
1835
        if (processor[2] == '3')            /* 683xx integrated processors.  */
1836
          {
1837
            switch (processor[3])
1838
              {
1839
              case '0':                     /* 68302, 68306, 68307 */
1840
              case '2':                     /* 68322, 68328 */
1841
              case '5':                     /* 68356 */
1842
                strcpy (family, "68000");   /* MC68000-based controllers.  */
1843
                break;
1844
 
1845
              case '3':                     /* 68330, 68331, 68332, 68333,
1846
                                               68334, 68335, 68336, 68338 */
1847
              case '6':                     /* 68360 */
1848
              case '7':                     /* 68376 */
1849
                strcpy (family, "68332");   /* CPU32 and CPU32+ */
1850
                break;
1851
 
1852
              case '4':
1853
                if (processor[4] == '9')    /* 68349 */
1854
                  strcpy (family, "68030"); /* CPU030 */
1855
                else                        /* 68340, 68341 */
1856
                  strcpy (family, "68332"); /* CPU32 and CPU32+ */
1857
                break;
1858
 
1859
              default:                      /* Does not exist yet.  */
1860
                strcpy (family, "68332");   /* Guess it will be CPU32 */
1861
              }
1862
          }
1863
        else if (TOUPPER (processor[3]) == 'F')  /* 68F333 */
1864
          strcpy (family, "68332");                /* CPU32 */
1865
        else if ((TOUPPER (processor[3]) == 'C') /* Embedded controllers.  */
1866
                 && ((TOUPPER (processor[2]) == 'E')
1867
                     || (TOUPPER (processor[2]) == 'H')
1868
                     || (TOUPPER (processor[2]) == 'L')))
1869
          {
1870
            strcpy (family, "68");
1871
            strncat (family, processor + 4, 7);
1872
            family[9] = '\0';
1873
          }
1874
        else                             /* "Regular" processors.  */
1875
          {
1876
            strncpy (family, processor, 9);
1877
            family[9] = '\0';
1878
          }
1879
      }
1880
    else if ((CONST_STRNEQ (processor, "cpu32")) /* CPU32 and CPU32+  */
1881
             || (CONST_STRNEQ (processor, "CPU32")))
1882
      strcpy (family, "68332");
1883
    else
1884
      {
1885
        strncpy (family, processor, 9);
1886
        family[9] = '\0';
1887
      }
1888
 
1889
    arch = bfd_scan_arch (family);
1890
    if (arch == 0)
1891
      goto got_wrong_format;
1892
    abfd->arch_info = arch;
1893
  }
1894
 
1895
  if (this_byte (&(ieee->h)) != (int) ieee_address_descriptor_enum)
1896
    goto fail;
1897
 
1898
  next_byte (&(ieee->h));
1899
 
1900
  if (! parse_int (&(ieee->h), &ieee->ad.number_of_bits_mau))
1901
    goto fail;
1902
 
1903
  if (! parse_int (&(ieee->h), &ieee->ad.number_of_maus_in_address))
1904
    goto fail;
1905
 
1906
  /* If there is a byte order info, take it.  */
1907
  if (this_byte (&(ieee->h)) == (int) ieee_variable_L_enum
1908
      || this_byte (&(ieee->h)) == (int) ieee_variable_M_enum)
1909
    next_byte (&(ieee->h));
1910
 
1911
  for (part = 0; part < N_W_VARIABLES; part++)
1912
    {
1913
      bfd_boolean ok;
1914
 
1915
      if (read_2bytes (&(ieee->h)) != (int) ieee_assign_value_to_variable_enum)
1916
        goto fail;
1917
 
1918
      if (this_byte_and_next (&(ieee->h)) != part)
1919
        goto fail;
1920
 
1921
      ieee->w.offset[part] = parse_i (&(ieee->h), &ok);
1922
      if (! ok)
1923
        goto fail;
1924
    }
1925
 
1926
  if (ieee->w.r.external_part != 0)
1927
    abfd->flags = HAS_SYMS;
1928
 
1929
  /* By now we know that this is a real IEEE file, we're going to read
1930
     the whole thing into memory so that we can run up and down it
1931
     quickly.  We can work out how big the file is from the trailer
1932
     record.  */
1933
 
1934
  amt = ieee->w.r.me_record + 1;
1935
  IEEE_DATA (abfd)->h.first_byte = bfd_alloc (ieee->h.abfd, amt);
1936
  if (!IEEE_DATA (abfd)->h.first_byte)
1937
    goto fail;
1938
  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
1939
    goto fail;
1940
  /* FIXME: Check return value.  I'm not sure whether it needs to read
1941
     the entire buffer or not.  */
1942
  bfd_bread ((void *) (IEEE_DATA (abfd)->h.first_byte),
1943
            (bfd_size_type) ieee->w.r.me_record + 1, abfd);
1944
 
1945
  ieee_slurp_sections (abfd);
1946
 
1947
  if (! ieee_slurp_debug (abfd))
1948
    goto fail;
1949
 
1950
  /* Parse section data to activate file and section flags implied by
1951
     section contents.  */
1952
  if (! ieee_slurp_section_data (abfd))
1953
    goto fail;
1954
 
1955
  return abfd->xvec;
1956
got_wrong_format:
1957
  bfd_set_error (bfd_error_wrong_format);
1958
fail:
1959
  bfd_release (abfd, ieee);
1960
  abfd->tdata.ieee_data = save;
1961
  return (const bfd_target *) NULL;
1962
}
1963
 
1964
static void
1965
ieee_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED,
1966
                      asymbol *symbol,
1967
                      symbol_info *ret)
1968
{
1969
  bfd_symbol_info (symbol, ret);
1970
  if (symbol->name[0] == ' ')
1971
    ret->name = "* empty table entry ";
1972
  if (!symbol->section)
1973
    ret->type = (symbol->flags & BSF_LOCAL) ? 'a' : 'A';
1974
}
1975
 
1976
static void
1977
ieee_print_symbol (bfd *abfd,
1978
                   void * afile,
1979
                   asymbol *symbol,
1980
                   bfd_print_symbol_type how)
1981
{
1982
  FILE *file = (FILE *) afile;
1983
 
1984
  switch (how)
1985
    {
1986
    case bfd_print_symbol_name:
1987
      fprintf (file, "%s", symbol->name);
1988
      break;
1989
    case bfd_print_symbol_more:
1990
      BFD_FAIL ();
1991
      break;
1992
    case bfd_print_symbol_all:
1993
      {
1994
        const char *section_name =
1995
          (symbol->section == (asection *) NULL
1996
           ? "*abs"
1997
           : symbol->section->name);
1998
 
1999
        if (symbol->name[0] == ' ')
2000
          fprintf (file, "* empty table entry ");
2001
        else
2002
          {
2003
            bfd_print_symbol_vandf (abfd, (void *) file, symbol);
2004
 
2005
            fprintf (file, " %-5s %04x %02x %s",
2006
                     section_name,
2007
                     (unsigned) ieee_symbol (symbol)->index,
2008
                     (unsigned) 0,
2009
                     symbol->name);
2010
          }
2011
      }
2012
      break;
2013
    }
2014
}
2015
 
2016
static bfd_boolean
2017
ieee_new_section_hook (bfd *abfd, asection *newsect)
2018
{
2019
  if (!newsect->used_by_bfd)
2020
    {
2021
      newsect->used_by_bfd = bfd_alloc (abfd, sizeof (ieee_per_section_type));
2022
      if (!newsect->used_by_bfd)
2023
        return FALSE;
2024
    }
2025
  ieee_per_section (newsect)->data = NULL;
2026
  ieee_per_section (newsect)->section = newsect;
2027
  return _bfd_generic_new_section_hook (abfd, newsect);
2028
}
2029
 
2030
static long
2031
ieee_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
2032
{
2033
  if ((asect->flags & SEC_DEBUGGING) != 0)
2034
    return 0;
2035
  if (! ieee_slurp_section_data (abfd))
2036
    return -1;
2037
  return (asect->reloc_count + 1) * sizeof (arelent *);
2038
}
2039
 
2040
static bfd_boolean
2041
ieee_get_section_contents (bfd *abfd,
2042
                           sec_ptr section,
2043
                           void * location,
2044
                           file_ptr offset,
2045
                           bfd_size_type count)
2046
{
2047
  ieee_per_section_type *p = ieee_per_section (section);
2048
  if ((section->flags & SEC_DEBUGGING) != 0)
2049
    return _bfd_generic_get_section_contents (abfd, section, location,
2050
                                              offset, count);
2051
  ieee_slurp_section_data (abfd);
2052
  (void) memcpy ((void *) location, (void *) (p->data + offset), (unsigned) count);
2053
  return TRUE;
2054
}
2055
 
2056
static long
2057
ieee_canonicalize_reloc (bfd *abfd,
2058
                         sec_ptr section,
2059
                         arelent **relptr,
2060
                         asymbol **symbols)
2061
{
2062
  ieee_reloc_type *src = (ieee_reloc_type *) (section->relocation);
2063
  ieee_data_type *ieee = IEEE_DATA (abfd);
2064
 
2065
  if ((section->flags & SEC_DEBUGGING) != 0)
2066
    return 0;
2067
 
2068
  while (src != (ieee_reloc_type *) NULL)
2069
    {
2070
      /* Work out which symbol to attach it this reloc to.  */
2071
      switch (src->symbol.letter)
2072
        {
2073
        case 'I':
2074
          src->relent.sym_ptr_ptr =
2075
            symbols + src->symbol.index + ieee->external_symbol_base_offset;
2076
          break;
2077
        case 'X':
2078
          src->relent.sym_ptr_ptr =
2079
            symbols + src->symbol.index + ieee->external_reference_base_offset;
2080
          break;
2081
        case 0:
2082
          if (src->relent.sym_ptr_ptr != NULL)
2083
            src->relent.sym_ptr_ptr =
2084
              src->relent.sym_ptr_ptr[0]->section->symbol_ptr_ptr;
2085
          break;
2086
        default:
2087
 
2088
          BFD_FAIL ();
2089
        }
2090
      *relptr++ = &src->relent;
2091
      src = src->next;
2092
    }
2093
  *relptr = NULL;
2094
  return section->reloc_count;
2095
}
2096
 
2097
static int
2098
comp (const void * ap, const void * bp)
2099
{
2100
  arelent *a = *((arelent **) ap);
2101
  arelent *b = *((arelent **) bp);
2102
  return a->address - b->address;
2103
}
2104
 
2105
/* Write the section headers.  */
2106
 
2107
static bfd_boolean
2108
ieee_write_section_part (bfd *abfd)
2109
{
2110
  ieee_data_type *ieee = IEEE_DATA (abfd);
2111
  asection *s;
2112
 
2113
  ieee->w.r.section_part = bfd_tell (abfd);
2114
  for (s = abfd->sections; s != (asection *) NULL; s = s->next)
2115
    {
2116
      if (! bfd_is_abs_section (s)
2117
          && (s->flags & SEC_DEBUGGING) == 0)
2118
        {
2119
          if (! ieee_write_byte (abfd, ieee_section_type_enum)
2120
              || ! ieee_write_byte (abfd,
2121
                                    (bfd_byte) (s->index
2122
                                                + IEEE_SECTION_NUMBER_BASE)))
2123
            return FALSE;
2124
 
2125
          if (abfd->flags & EXEC_P)
2126
            {
2127
              /* This image is executable, so output absolute sections.  */
2128
              if (! ieee_write_byte (abfd, ieee_variable_A_enum)
2129
                  || ! ieee_write_byte (abfd, ieee_variable_S_enum))
2130
                return FALSE;
2131
            }
2132
          else
2133
            {
2134
              if (! ieee_write_byte (abfd, ieee_variable_C_enum))
2135
                return FALSE;
2136
            }
2137
 
2138
          switch (s->flags & (SEC_CODE | SEC_DATA | SEC_ROM))
2139
            {
2140
            case SEC_CODE | SEC_LOAD:
2141
            case SEC_CODE:
2142
              if (! ieee_write_byte (abfd, ieee_variable_P_enum))
2143
                return FALSE;
2144
              break;
2145
            case SEC_DATA:
2146
            default:
2147
              if (! ieee_write_byte (abfd, ieee_variable_D_enum))
2148
                return FALSE;
2149
              break;
2150
            case SEC_ROM:
2151
            case SEC_ROM | SEC_DATA:
2152
            case SEC_ROM | SEC_LOAD:
2153
            case SEC_ROM | SEC_DATA | SEC_LOAD:
2154
              if (! ieee_write_byte (abfd, ieee_variable_R_enum))
2155
                return FALSE;
2156
            }
2157
 
2158
 
2159
          if (! ieee_write_id (abfd, s->name))
2160
            return FALSE;
2161
          /* Alignment.  */
2162
          if (! ieee_write_byte (abfd, ieee_section_alignment_enum)
2163
              || ! ieee_write_byte (abfd,
2164
                                    (bfd_byte) (s->index
2165
                                                + IEEE_SECTION_NUMBER_BASE))
2166
              || ! ieee_write_int (abfd, (bfd_vma) 1 << s->alignment_power))
2167
            return FALSE;
2168
 
2169
          /* Size.  */
2170
          if (! ieee_write_2bytes (abfd, ieee_section_size_enum)
2171
              || ! ieee_write_byte (abfd,
2172
                                    (bfd_byte) (s->index
2173
                                                + IEEE_SECTION_NUMBER_BASE))
2174
              || ! ieee_write_int (abfd, s->size))
2175
            return FALSE;
2176
          if (abfd->flags & EXEC_P)
2177
            {
2178
              /* Relocateable sections don't have asl records.  */
2179
              /* Vma.  */
2180
              if (! ieee_write_2bytes (abfd, ieee_section_base_address_enum)
2181
                  || ! ieee_write_byte (abfd,
2182
                                        ((bfd_byte)
2183
                                         (s->index
2184
                                          + IEEE_SECTION_NUMBER_BASE)))
2185
                  || ! ieee_write_int (abfd, s->lma))
2186
                return FALSE;
2187
            }
2188
        }
2189
    }
2190
 
2191
  return TRUE;
2192
}
2193
 
2194
static bfd_boolean
2195
do_with_relocs (bfd *abfd, asection *s)
2196
{
2197
  unsigned int number_of_maus_in_address =
2198
    bfd_arch_bits_per_address (abfd) / bfd_arch_bits_per_byte (abfd);
2199
  unsigned int relocs_to_go = s->reloc_count;
2200
  bfd_byte *stream = ieee_per_section (s)->data;
2201
  arelent **p = s->orelocation;
2202
  bfd_size_type current_byte_index = 0;
2203
 
2204
  qsort (s->orelocation,
2205
         relocs_to_go,
2206
         sizeof (arelent **),
2207
         comp);
2208
 
2209
  /* Output the section preheader.  */
2210
  if (! ieee_write_byte (abfd, ieee_set_current_section_enum)
2211
      || ! ieee_write_byte (abfd,
2212
                            (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE))
2213
      || ! ieee_write_2bytes (abfd, ieee_set_current_pc_enum)
2214
      || ! ieee_write_byte (abfd,
2215
                            (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE)))
2216
    return FALSE;
2217
 
2218
  if ((abfd->flags & EXEC_P) != 0 && relocs_to_go == 0)
2219
    {
2220
      if (! ieee_write_int (abfd, s->lma))
2221
        return FALSE;
2222
    }
2223
  else
2224
    {
2225
      if (! ieee_write_expression (abfd, (bfd_vma) 0, s->symbol, 0, 0))
2226
        return FALSE;
2227
    }
2228
 
2229
  if (relocs_to_go == 0)
2230
    {
2231
      /* If there aren't any relocations then output the load constant
2232
         byte opcode rather than the load with relocation opcode.  */
2233
      while (current_byte_index < s->size)
2234
        {
2235
          bfd_size_type run;
2236
          unsigned int MAXRUN = 127;
2237
 
2238
          run = MAXRUN;
2239
          if (run > s->size - current_byte_index)
2240
            run = s->size - current_byte_index;
2241
 
2242
          if (run != 0)
2243
            {
2244
              if (! ieee_write_byte (abfd, ieee_load_constant_bytes_enum))
2245
                return FALSE;
2246
              /* Output a stream of bytes.  */
2247
              if (! ieee_write_int (abfd, run))
2248
                return FALSE;
2249
              if (bfd_bwrite ((void *) (stream + current_byte_index), run, abfd)
2250
                  != run)
2251
                return FALSE;
2252
              current_byte_index += run;
2253
            }
2254
        }
2255
    }
2256
  else
2257
    {
2258
      if (! ieee_write_byte (abfd, ieee_load_with_relocation_enum))
2259
        return FALSE;
2260
 
2261
      /* Output the data stream as the longest sequence of bytes
2262
         possible, allowing for the a reasonable packet size and
2263
         relocation stuffs.  */
2264
      if (stream == NULL)
2265
        {
2266
          /* Outputting a section without data, fill it up.  */
2267
          stream = bfd_zalloc (abfd, s->size);
2268
          if (!stream)
2269
            return FALSE;
2270
        }
2271
      while (current_byte_index < s->size)
2272
        {
2273
          bfd_size_type run;
2274
          unsigned int MAXRUN = 127;
2275
 
2276
          if (relocs_to_go)
2277
            {
2278
              run = (*p)->address - current_byte_index;
2279
              if (run > MAXRUN)
2280
                run = MAXRUN;
2281
            }
2282
          else
2283
            run = MAXRUN;
2284
 
2285
          if (run > s->size - current_byte_index)
2286
            run = s->size - current_byte_index;
2287
 
2288
          if (run != 0)
2289
            {
2290
              /* Output a stream of bytes.  */
2291
              if (! ieee_write_int (abfd, run))
2292
                return FALSE;
2293
              if (bfd_bwrite ((void *) (stream + current_byte_index), run, abfd)
2294
                  != run)
2295
                return FALSE;
2296
              current_byte_index += run;
2297
            }
2298
 
2299
          /* Output any relocations here.  */
2300
          if (relocs_to_go && (*p) && (*p)->address == current_byte_index)
2301
            {
2302
              while (relocs_to_go
2303
                     && (*p) && (*p)->address == current_byte_index)
2304
                {
2305
                  arelent *r = *p;
2306
                  bfd_signed_vma ov;
2307
                  switch (r->howto->size)
2308
                    {
2309
                    case 2:
2310
                      ov = bfd_get_signed_32 (abfd,
2311
                                              stream + current_byte_index);
2312
                      current_byte_index += 4;
2313
                      break;
2314
                    case 1:
2315
                      ov = bfd_get_signed_16 (abfd,
2316
                                              stream + current_byte_index);
2317
                      current_byte_index += 2;
2318
                      break;
2319
                    case 0:
2320
                      ov = bfd_get_signed_8 (abfd,
2321
                                             stream + current_byte_index);
2322
                      current_byte_index++;
2323
                      break;
2324
                    default:
2325
                      ov = 0;
2326
                      BFD_FAIL ();
2327
                      return FALSE;
2328
                    }
2329
 
2330
                  ov &= r->howto->src_mask;
2331
 
2332
                  if (r->howto->pc_relative
2333
                      && ! r->howto->pcrel_offset)
2334
                    ov += r->address;
2335
 
2336
                  if (! ieee_write_byte (abfd,
2337
                                         ieee_function_either_open_b_enum))
2338
                    return FALSE;
2339
 
2340
                  if (r->sym_ptr_ptr != (asymbol **) NULL)
2341
                    {
2342
                      if (! ieee_write_expression (abfd, r->addend + ov,
2343
                                                   *(r->sym_ptr_ptr),
2344
                                                   r->howto->pc_relative,
2345
                                                   (unsigned) s->index))
2346
                        return FALSE;
2347
                    }
2348
                  else
2349
                    {
2350
                      if (! ieee_write_expression (abfd, r->addend + ov,
2351
                                                   (asymbol *) NULL,
2352
                                                   r->howto->pc_relative,
2353
                                                   (unsigned) s->index))
2354
                        return FALSE;
2355
                    }
2356
 
2357
                  if (number_of_maus_in_address
2358
                      != bfd_get_reloc_size (r->howto))
2359
                    {
2360
                      bfd_vma rsize = bfd_get_reloc_size (r->howto);
2361
                      if (! ieee_write_int (abfd, rsize))
2362
                        return FALSE;
2363
                    }
2364
                  if (! ieee_write_byte (abfd,
2365
                                         ieee_function_either_close_b_enum))
2366
                    return FALSE;
2367
 
2368
                  relocs_to_go--;
2369
                  p++;
2370
                }
2371
 
2372
            }
2373
        }
2374
    }
2375
 
2376
  return TRUE;
2377
}
2378
 
2379
/* If there are no relocations in the output section then we can be
2380
   clever about how we write.  We block items up into a max of 127
2381
   bytes.  */
2382
 
2383
static bfd_boolean
2384
do_as_repeat (bfd *abfd, asection *s)
2385
{
2386
  if (s->size)
2387
    {
2388
      if (! ieee_write_byte (abfd, ieee_set_current_section_enum)
2389
          || ! ieee_write_byte (abfd,
2390
                                (bfd_byte) (s->index
2391
                                            + IEEE_SECTION_NUMBER_BASE))
2392
          || ! ieee_write_byte (abfd, ieee_set_current_pc_enum >> 8)
2393
          || ! ieee_write_byte (abfd, ieee_set_current_pc_enum & 0xff)
2394
          || ! ieee_write_byte (abfd,
2395
                                (bfd_byte) (s->index
2396
                                            + IEEE_SECTION_NUMBER_BASE)))
2397
        return FALSE;
2398
 
2399
      if ((abfd->flags & EXEC_P) != 0)
2400
        {
2401
          if (! ieee_write_int (abfd, s->lma))
2402
            return FALSE;
2403
        }
2404
      else
2405
        {
2406
          if (! ieee_write_expression (abfd, (bfd_vma) 0, s->symbol, 0, 0))
2407
            return FALSE;
2408
        }
2409
 
2410
      if (! ieee_write_byte (abfd, ieee_repeat_data_enum)
2411
          || ! ieee_write_int (abfd, s->size)
2412
          || ! ieee_write_byte (abfd, ieee_load_constant_bytes_enum)
2413
          || ! ieee_write_byte (abfd, 1)
2414
          || ! ieee_write_byte (abfd, 0))
2415
        return FALSE;
2416
    }
2417
 
2418
  return TRUE;
2419
}
2420
 
2421
static bfd_boolean
2422
do_without_relocs (bfd *abfd, asection *s)
2423
{
2424
  bfd_byte *stream = ieee_per_section (s)->data;
2425
 
2426
  if (stream == 0 || ((s->flags & SEC_LOAD) == 0))
2427
    {
2428
      if (! do_as_repeat (abfd, s))
2429
        return FALSE;
2430
    }
2431
  else
2432
    {
2433
      unsigned int i;
2434
 
2435
      for (i = 0; i < s->size; i++)
2436
        {
2437
          if (stream[i] != 0)
2438
            {
2439
              if (! do_with_relocs (abfd, s))
2440
                return FALSE;
2441
              return TRUE;
2442
            }
2443
        }
2444
      if (! do_as_repeat (abfd, s))
2445
        return FALSE;
2446
    }
2447
 
2448
  return TRUE;
2449
}
2450
 
2451
static void
2452
fill (void)
2453
{
2454
  bfd_size_type amt = input_ptr_end - input_ptr_start;
2455
  /* FIXME: Check return value.  I'm not sure whether it needs to read
2456
     the entire buffer or not.  */
2457
  bfd_bread ((void *) input_ptr_start, amt, input_bfd);
2458
  input_ptr = input_ptr_start;
2459
}
2460
 
2461
static void
2462
flush (void)
2463
{
2464
  bfd_size_type amt = output_ptr - output_ptr_start;
2465
 
2466
  if (bfd_bwrite ((void *) (output_ptr_start), amt, output_bfd) != amt)
2467
    abort ();
2468
  output_ptr = output_ptr_start;
2469
  output_buffer++;
2470
}
2471
 
2472
#define THIS() ( *input_ptr )
2473
#define NEXT() { input_ptr++; if (input_ptr == input_ptr_end) fill (); }
2474
#define OUT(x) { *output_ptr++ = (x); if (output_ptr == output_ptr_end)  flush (); }
2475
 
2476
static void
2477
write_int (int value)
2478
{
2479
  if (value >= 0 && value <= 127)
2480
    {
2481
      OUT (value);
2482
    }
2483
  else
2484
    {
2485
      unsigned int length;
2486
 
2487
      /* How many significant bytes ?  */
2488
      /* FIXME FOR LONGER INTS.  */
2489
      if (value & 0xff000000)
2490
        length = 4;
2491
      else if (value & 0x00ff0000)
2492
        length = 3;
2493
      else if (value & 0x0000ff00)
2494
        length = 2;
2495
      else
2496
        length = 1;
2497
 
2498
      OUT ((int) ieee_number_repeat_start_enum + length);
2499
      switch (length)
2500
        {
2501
        case 4:
2502
          OUT (value >> 24);
2503
        case 3:
2504
          OUT (value >> 16);
2505
        case 2:
2506
          OUT (value >> 8);
2507
        case 1:
2508
          OUT (value);
2509
        }
2510
    }
2511
}
2512
 
2513
static void
2514
copy_id (void)
2515
{
2516
  int length = THIS ();
2517
  char ch;
2518
 
2519
  OUT (length);
2520
  NEXT ();
2521
  while (length--)
2522
    {
2523
      ch = THIS ();
2524
      OUT (ch);
2525
      NEXT ();
2526
    }
2527
}
2528
 
2529
#define VAR(x) ((x | 0x80))
2530
static void
2531
copy_expression (void)
2532
{
2533
  int stack[10];
2534
  int *tos = stack;
2535
  int value;
2536
 
2537
  while (1)
2538
    {
2539
      switch (THIS ())
2540
        {
2541
        case 0x84:
2542
          NEXT ();
2543
          value = THIS ();
2544
          NEXT ();
2545
          value = (value << 8) | THIS ();
2546
          NEXT ();
2547
          value = (value << 8) | THIS ();
2548
          NEXT ();
2549
          value = (value << 8) | THIS ();
2550
          NEXT ();
2551
          *tos++ = value;
2552
          break;
2553
        case 0x83:
2554
          NEXT ();
2555
          value = THIS ();
2556
          NEXT ();
2557
          value = (value << 8) | THIS ();
2558
          NEXT ();
2559
          value = (value << 8) | THIS ();
2560
          NEXT ();
2561
          *tos++ = value;
2562
          break;
2563
        case 0x82:
2564
          NEXT ();
2565
          value = THIS ();
2566
          NEXT ();
2567
          value = (value << 8) | THIS ();
2568
          NEXT ();
2569
          *tos++ = value;
2570
          break;
2571
        case 0x81:
2572
          NEXT ();
2573
          value = THIS ();
2574
          NEXT ();
2575
          *tos++ = value;
2576
          break;
2577
        case 0x80:
2578
          NEXT ();
2579
          *tos++ = 0;
2580
          break;
2581
        default:
2582
          if (THIS () > 0x84)
2583
            {
2584
              /* Not a number, just bug out with the answer.  */
2585
              write_int (*(--tos));
2586
              return;
2587
            }
2588
          *tos++ = THIS ();
2589
          NEXT ();
2590
          break;
2591
        case 0xa5:
2592
          /* PLUS anything.  */
2593
          value = *(--tos);
2594
          value += *(--tos);
2595
          *tos++ = value;
2596
          NEXT ();
2597
          break;
2598
        case VAR ('R'):
2599
          {
2600
            int section_number;
2601
            ieee_data_type *ieee;
2602
            asection *s;
2603
 
2604
            NEXT ();
2605
            section_number = THIS ();
2606
 
2607
            NEXT ();
2608
            ieee = IEEE_DATA (input_bfd);
2609
            s = ieee->section_table[section_number];
2610
            value = 0;
2611
            if (s->output_section)
2612
              value = s->output_section->lma;
2613
            value += s->output_offset;
2614
            *tos++ = value;
2615
          }
2616
          break;
2617
        case 0x90:
2618
          {
2619
            NEXT ();
2620
            write_int (*(--tos));
2621
            OUT (0x90);
2622
            return;
2623
          }
2624
        }
2625
    }
2626
}
2627
 
2628
/* Drop the int in the buffer, and copy a null into the gap, which we
2629
   will overwrite later.  */
2630
 
2631
static void
2632
fill_int (struct output_buffer_struct *buf)
2633
{
2634
  if (buf->buffer == output_buffer)
2635
    {
2636
      /* Still a chance to output the size.  */
2637
      int value = output_ptr - buf->ptrp + 3;
2638
      buf->ptrp[0] = value >> 24;
2639
      buf->ptrp[1] = value >> 16;
2640
      buf->ptrp[2] = value >> 8;
2641
      buf->ptrp[3] = value >> 0;
2642
    }
2643
}
2644
 
2645
static void
2646
drop_int (struct output_buffer_struct *buf)
2647
{
2648
  int type = THIS ();
2649
  int ch;
2650
 
2651
  if (type <= 0x84)
2652
    {
2653
      NEXT ();
2654
      switch (type)
2655
        {
2656
        case 0x84:
2657
          ch = THIS ();
2658
          NEXT ();
2659
        case 0x83:
2660
          ch = THIS ();
2661
          NEXT ();
2662
        case 0x82:
2663
          ch = THIS ();
2664
          NEXT ();
2665
        case 0x81:
2666
          ch = THIS ();
2667
          NEXT ();
2668
        case 0x80:
2669
          break;
2670
        }
2671
    }
2672
  OUT (0x84);
2673
  buf->ptrp = output_ptr;
2674
  buf->buffer = output_buffer;
2675
  OUT (0);
2676
  OUT (0);
2677
  OUT (0);
2678
  OUT (0);
2679
}
2680
 
2681
static void
2682
copy_int (void)
2683
{
2684
  int type = THIS ();
2685
  int ch;
2686
  if (type <= 0x84)
2687
    {
2688
      OUT (type);
2689
      NEXT ();
2690
      switch (type)
2691
        {
2692
        case 0x84:
2693
          ch = THIS ();
2694
          NEXT ();
2695
          OUT (ch);
2696
        case 0x83:
2697
          ch = THIS ();
2698
          NEXT ();
2699
          OUT (ch);
2700
        case 0x82:
2701
          ch = THIS ();
2702
          NEXT ();
2703
          OUT (ch);
2704
        case 0x81:
2705
          ch = THIS ();
2706
          NEXT ();
2707
          OUT (ch);
2708
        case 0x80:
2709
          break;
2710
        }
2711
    }
2712
}
2713
 
2714
#define ID      copy_id ()
2715
#define INT     copy_int ()
2716
#define EXP     copy_expression ()
2717
#define INTn(q) copy_int ()
2718
#define EXPn(q) copy_expression ()
2719
 
2720
static void
2721
copy_till_end (void)
2722
{
2723
  int ch = THIS ();
2724
 
2725
  while (1)
2726
    {
2727
      while (ch <= 0x80)
2728
        {
2729
          OUT (ch);
2730
          NEXT ();
2731
          ch = THIS ();
2732
        }
2733
      switch (ch)
2734
        {
2735
        case 0x84:
2736
          OUT (THIS ());
2737
          NEXT ();
2738
        case 0x83:
2739
          OUT (THIS ());
2740
          NEXT ();
2741
        case 0x82:
2742
          OUT (THIS ());
2743
          NEXT ();
2744
        case 0x81:
2745
          OUT (THIS ());
2746
          NEXT ();
2747
          OUT (THIS ());
2748
          NEXT ();
2749
 
2750
          ch = THIS ();
2751
          break;
2752
        default:
2753
          return;
2754
        }
2755
    }
2756
 
2757
}
2758
 
2759
static void
2760
f1_record (void)
2761
{
2762
  int ch;
2763
 
2764
  /* ATN record.  */
2765
  NEXT ();
2766
  ch = THIS ();
2767
  switch (ch)
2768
    {
2769
    default:
2770
      OUT (0xf1);
2771
      OUT (ch);
2772
      break;
2773
    case 0xc9:
2774
      NEXT ();
2775
      OUT (0xf1);
2776
      OUT (0xc9);
2777
      INT;
2778
      INT;
2779
      ch = THIS ();
2780
      switch (ch)
2781
        {
2782
        case 0x16:
2783
          NEXT ();
2784
          break;
2785
        case 0x01:
2786
          NEXT ();
2787
          break;
2788
        case 0x00:
2789
          NEXT ();
2790
          INT;
2791
          break;
2792
        case 0x03:
2793
          NEXT ();
2794
          INT;
2795
          break;
2796
        case 0x13:
2797
          EXPn (instruction address);
2798
          break;
2799
        default:
2800
          break;
2801
        }
2802
      break;
2803
    case 0xd8:
2804
      /* EXternal ref.  */
2805
      NEXT ();
2806
      OUT (0xf1);
2807
      OUT (0xd8);
2808
      EXP;
2809
      EXP;
2810
      EXP;
2811
      EXP;
2812
      break;
2813
    case 0xce:
2814
      NEXT ();
2815
      OUT (0xf1);
2816
      OUT (0xce);
2817
      INT;
2818
      INT;
2819
      ch = THIS ();
2820
      INT;
2821
      switch (ch)
2822
        {
2823
        case 0x01:
2824
          INT;
2825
          INT;
2826
          break;
2827
        case 0x02:
2828
          INT;
2829
          break;
2830
        case 0x04:
2831
          EXPn (external function);
2832
          break;
2833
        case 0x05:
2834
          break;
2835
        case 0x07:
2836
          INTn (line number);
2837
          INT;
2838
        case 0x08:
2839
          break;
2840
        case 0x0a:
2841
          INTn (locked register);
2842
          INT;
2843
          break;
2844
        case 0x3f:
2845
          copy_till_end ();
2846
          break;
2847
        case 0x3e:
2848
          copy_till_end ();
2849
          break;
2850
        case 0x40:
2851
          copy_till_end ();
2852
          break;
2853
        case 0x41:
2854
          ID;
2855
          break;
2856
        }
2857
    }
2858
}
2859
 
2860
static void
2861
f0_record (void)
2862
{
2863
  /* Attribute record.  */
2864
  NEXT ();
2865
  OUT (0xf0);
2866
  INTn (Symbol name);
2867
  ID;
2868
}
2869
 
2870
static void
2871
f2_record (void)
2872
{
2873
  NEXT ();
2874
  OUT (0xf2);
2875
  INT;
2876
  NEXT ();
2877
  OUT (0xce);
2878
  INT;
2879
  copy_till_end ();
2880
}
2881
 
2882
static void
2883
f8_record (void)
2884
{
2885
  int ch;
2886
  NEXT ();
2887
  ch = THIS ();
2888
  switch (ch)
2889
    {
2890
    case 0x01:
2891
    case 0x02:
2892
    case 0x03:
2893
      /* Unique typedefs for module.  */
2894
      /* GLobal typedefs.   */
2895
      /* High level module scope beginning.  */
2896
      {
2897
        struct output_buffer_struct ob;
2898
 
2899
        NEXT ();
2900
        OUT (0xf8);
2901
        OUT (ch);
2902
        drop_int (&ob);
2903
        ID;
2904
 
2905
        block ();
2906
 
2907
        NEXT ();
2908
        fill_int (&ob);
2909
        OUT (0xf9);
2910
      }
2911
      break;
2912
    case 0x04:
2913
      /* Global function.  */
2914
      {
2915
        struct output_buffer_struct ob;
2916
 
2917
        NEXT ();
2918
        OUT (0xf8);
2919
        OUT (0x04);
2920
        drop_int (&ob);
2921
        ID;
2922
        INTn (stack size);
2923
        INTn (ret val);
2924
        EXPn (offset);
2925
 
2926
        block ();
2927
 
2928
        NEXT ();
2929
        OUT (0xf9);
2930
        EXPn (size of block);
2931
        fill_int (&ob);
2932
      }
2933
      break;
2934
 
2935
    case 0x05:
2936
      /* File name for source line numbers.  */
2937
      {
2938
        struct output_buffer_struct ob;
2939
 
2940
        NEXT ();
2941
        OUT (0xf8);
2942
        OUT (0x05);
2943
        drop_int (&ob);
2944
        ID;
2945
        INTn (year);
2946
        INTn (month);
2947
        INTn (day);
2948
        INTn (hour);
2949
        INTn (monute);
2950
        INTn (second);
2951
        block ();
2952
        NEXT ();
2953
        OUT (0xf9);
2954
        fill_int (&ob);
2955
      }
2956
      break;
2957
 
2958
    case 0x06:
2959
      /* Local function.  */
2960
      {
2961
        struct output_buffer_struct ob;
2962
 
2963
        NEXT ();
2964
        OUT (0xf8);
2965
        OUT (0x06);
2966
        drop_int (&ob);
2967
        ID;
2968
        INTn (stack size);
2969
        INTn (type return);
2970
        EXPn (offset);
2971
        block ();
2972
        NEXT ();
2973
        OUT (0xf9);
2974
        EXPn (size);
2975
        fill_int (&ob);
2976
      }
2977
      break;
2978
 
2979
    case 0x0a:
2980
      /* Assembler module scope beginning -  */
2981
      {
2982
        struct output_buffer_struct ob;
2983
 
2984
        NEXT ();
2985
        OUT (0xf8);
2986
        OUT (0x0a);
2987
        drop_int (&ob);
2988
        ID;
2989
        ID;
2990
        INT;
2991
        ID;
2992
        INT;
2993
        INT;
2994
        INT;
2995
        INT;
2996
        INT;
2997
        INT;
2998
 
2999
        block ();
3000
 
3001
        NEXT ();
3002
        OUT (0xf9);
3003
        fill_int (&ob);
3004
      }
3005
      break;
3006
    case 0x0b:
3007
      {
3008
        struct output_buffer_struct ob;
3009
 
3010
        NEXT ();
3011
        OUT (0xf8);
3012
        OUT (0x0b);
3013
        drop_int (&ob);
3014
        ID;
3015
        INT;
3016
        INTn (section index);
3017
        EXPn (offset);
3018
        INTn (stuff);
3019
 
3020
        block ();
3021
 
3022
        OUT (0xf9);
3023
        NEXT ();
3024
        EXPn (Size in Maus);
3025
        fill_int (&ob);
3026
      }
3027
      break;
3028
    }
3029
}
3030
 
3031
static void
3032
e2_record (void)
3033
{
3034
  OUT (0xe2);
3035
  NEXT ();
3036
  OUT (0xce);
3037
  NEXT ();
3038
  INT;
3039
  EXP;
3040
}
3041
 
3042
static void
3043
block (void)
3044
{
3045
  int ch;
3046
 
3047
  while (1)
3048
    {
3049
      ch = THIS ();
3050
      switch (ch)
3051
        {
3052
        case 0xe1:
3053
        case 0xe5:
3054
          return;
3055
        case 0xf9:
3056
          return;
3057
        case 0xf0:
3058
          f0_record ();
3059
          break;
3060
        case 0xf1:
3061
          f1_record ();
3062
          break;
3063
        case 0xf2:
3064
          f2_record ();
3065
          break;
3066
        case 0xf8:
3067
          f8_record ();
3068
          break;
3069
        case 0xe2:
3070
          e2_record ();
3071
          break;
3072
 
3073
        }
3074
    }
3075
}
3076
 
3077
/* Moves all the debug information from the source bfd to the output
3078
   bfd, and relocates any expressions it finds.  */
3079
 
3080
static void
3081
relocate_debug (bfd *output ATTRIBUTE_UNUSED,
3082
                bfd *input)
3083
{
3084
#define IBS 400
3085
#define OBS 400
3086
  unsigned char input_buffer[IBS];
3087
 
3088
  input_ptr_start = input_ptr = input_buffer;
3089
  input_ptr_end = input_buffer + IBS;
3090
  input_bfd = input;
3091
  /* FIXME: Check return value.  I'm not sure whether it needs to read
3092
     the entire buffer or not.  */
3093
  bfd_bread ((void *) input_ptr_start, (bfd_size_type) IBS, input);
3094
  block ();
3095
}
3096
 
3097
/* Gather together all the debug information from each input BFD into
3098
   one place, relocating it and emitting it as we go.  */
3099
 
3100
static bfd_boolean
3101
ieee_write_debug_part (bfd *abfd)
3102
{
3103
  ieee_data_type *ieee = IEEE_DATA (abfd);
3104
  bfd_chain_type *chain = ieee->chain_root;
3105
  unsigned char obuff[OBS];
3106
  bfd_boolean some_debug = FALSE;
3107
  file_ptr here = bfd_tell (abfd);
3108
 
3109
  output_ptr_start = output_ptr = obuff;
3110
  output_ptr_end = obuff + OBS;
3111
  output_ptr = obuff;
3112
  output_bfd = abfd;
3113
 
3114
  if (chain == (bfd_chain_type *) NULL)
3115
    {
3116
      asection *s;
3117
 
3118
      for (s = abfd->sections; s != NULL; s = s->next)
3119
        if ((s->flags & SEC_DEBUGGING) != 0)
3120
          break;
3121
      if (s == NULL)
3122
        {
3123
          ieee->w.r.debug_information_part = 0;
3124
          return TRUE;
3125
        }
3126
 
3127
      ieee->w.r.debug_information_part = here;
3128
      if (bfd_bwrite (s->contents, s->size, abfd) != s->size)
3129
        return FALSE;
3130
    }
3131
  else
3132
    {
3133
      while (chain != (bfd_chain_type *) NULL)
3134
        {
3135
          bfd *entry = chain->this;
3136
          ieee_data_type *entry_ieee = IEEE_DATA (entry);
3137
 
3138
          if (entry_ieee->w.r.debug_information_part)
3139
            {
3140
              if (bfd_seek (entry, entry_ieee->w.r.debug_information_part,
3141
                            SEEK_SET) != 0)
3142
                return FALSE;
3143
              relocate_debug (abfd, entry);
3144
            }
3145
 
3146
          chain = chain->next;
3147
        }
3148
 
3149
      if (some_debug)
3150
        ieee->w.r.debug_information_part = here;
3151
      else
3152
        ieee->w.r.debug_information_part = 0;
3153
 
3154
      flush ();
3155
    }
3156
 
3157
  return TRUE;
3158
}
3159
 
3160
/* Write the data in an ieee way.  */
3161
 
3162
static bfd_boolean
3163
ieee_write_data_part (bfd *abfd)
3164
{
3165
  asection *s;
3166
 
3167
  ieee_data_type *ieee = IEEE_DATA (abfd);
3168
  ieee->w.r.data_part = bfd_tell (abfd);
3169
 
3170
  for (s = abfd->sections; s != (asection *) NULL; s = s->next)
3171
    {
3172
      /* Skip sections that have no loadable contents (.bss,
3173
         debugging, etc.)  */
3174
      if ((s->flags & SEC_LOAD) == 0)
3175
        continue;
3176
 
3177
      /* Sort the reloc records so we can insert them in the correct
3178
         places.  */
3179
      if (s->reloc_count != 0)
3180
        {
3181
          if (! do_with_relocs (abfd, s))
3182
            return FALSE;
3183
        }
3184
      else
3185
        {
3186
          if (! do_without_relocs (abfd, s))
3187
            return FALSE;
3188
        }
3189
    }
3190
 
3191
  return TRUE;
3192
}
3193
 
3194
static bfd_boolean
3195
init_for_output (bfd *abfd)
3196
{
3197
  asection *s;
3198
 
3199
  for (s = abfd->sections; s != (asection *) NULL; s = s->next)
3200
    {
3201
      if ((s->flags & SEC_DEBUGGING) != 0)
3202
        continue;
3203
      if (s->size != 0)
3204
        {
3205
          bfd_size_type size = s->size;
3206
          ieee_per_section (s)->data = bfd_alloc (abfd, size);
3207
          if (!ieee_per_section (s)->data)
3208
            return FALSE;
3209
        }
3210
    }
3211
  return TRUE;
3212
}
3213
 
3214
/* Exec and core file sections.  */
3215
 
3216
/* Set section contents is complicated with IEEE since the format is
3217
   not a byte image, but a record stream.  */
3218
 
3219
static bfd_boolean
3220
ieee_set_section_contents (bfd *abfd,
3221
                           sec_ptr section,
3222
                           const void * location,
3223
                           file_ptr offset,
3224
                           bfd_size_type count)
3225
{
3226
  if ((section->flags & SEC_DEBUGGING) != 0)
3227
    {
3228
      if (section->contents == NULL)
3229
        {
3230
          bfd_size_type size = section->size;
3231
          section->contents = bfd_alloc (abfd, size);
3232
          if (section->contents == NULL)
3233
            return FALSE;
3234
        }
3235
      /* bfd_set_section_contents has already checked that everything
3236
         is within range.  */
3237
      memcpy (section->contents + offset, location, (size_t) count);
3238
      return TRUE;
3239
    }
3240
 
3241
  if (ieee_per_section (section)->data == (bfd_byte *) NULL)
3242
    {
3243
      if (!init_for_output (abfd))
3244
        return FALSE;
3245
    }
3246
  memcpy ((void *) (ieee_per_section (section)->data + offset),
3247
          (void *) location,
3248
          (unsigned int) count);
3249
  return TRUE;
3250
}
3251
 
3252
/* Write the external symbols of a file.  IEEE considers two sorts of
3253
   external symbols, public, and referenced.  It uses to internal
3254
   forms to index them as well.  When we write them out we turn their
3255
   symbol values into indexes from the right base.  */
3256
 
3257
static bfd_boolean
3258
ieee_write_external_part (bfd *abfd)
3259
{
3260
  asymbol **q;
3261
  ieee_data_type *ieee = IEEE_DATA (abfd);
3262
  unsigned int reference_index = IEEE_REFERENCE_BASE;
3263
  unsigned int public_index = IEEE_PUBLIC_BASE + 2;
3264
  file_ptr here = bfd_tell (abfd);
3265
  bfd_boolean hadone = FALSE;
3266
 
3267
  if (abfd->outsymbols != (asymbol **) NULL)
3268
    {
3269
 
3270
      for (q = abfd->outsymbols; *q != (asymbol *) NULL; q++)
3271
        {
3272
          asymbol *p = *q;
3273
 
3274
          if (bfd_is_und_section (p->section))
3275
            {
3276
              /* This must be a symbol reference.  */
3277
              if (! ieee_write_byte (abfd, ieee_external_reference_enum)
3278
                  || ! ieee_write_int (abfd, (bfd_vma) reference_index)
3279
                  || ! ieee_write_id (abfd, p->name))
3280
                return FALSE;
3281
              p->value = reference_index;
3282
              reference_index++;
3283
              hadone = TRUE;
3284
            }
3285
          else if (bfd_is_com_section (p->section))
3286
            {
3287
              /* This is a weak reference.  */
3288
              if (! ieee_write_byte (abfd, ieee_external_reference_enum)
3289
                  || ! ieee_write_int (abfd, (bfd_vma) reference_index)
3290
                  || ! ieee_write_id (abfd, p->name)
3291
                  || ! ieee_write_byte (abfd,
3292
                                        ieee_weak_external_reference_enum)
3293
                  || ! ieee_write_int (abfd, (bfd_vma) reference_index)
3294
                  || ! ieee_write_int (abfd, p->value))
3295
                return FALSE;
3296
              p->value = reference_index;
3297
              reference_index++;
3298
              hadone = TRUE;
3299
            }
3300
          else if (p->flags & BSF_GLOBAL)
3301
            {
3302
              /* This must be a symbol definition.  */
3303
              if (! ieee_write_byte (abfd, ieee_external_symbol_enum)
3304
                  || ! ieee_write_int (abfd, (bfd_vma) public_index)
3305
                  || ! ieee_write_id (abfd, p->name)
3306
                  || ! ieee_write_2bytes (abfd, ieee_attribute_record_enum)
3307
                  || ! ieee_write_int (abfd, (bfd_vma) public_index)
3308
                  || ! ieee_write_byte (abfd, 15) /* Instruction address.  */
3309
                  || ! ieee_write_byte (abfd, 19) /* Static symbol.  */
3310
                  || ! ieee_write_byte (abfd, 1)) /* One of them.  */
3311
                return FALSE;
3312
 
3313
              /* Write out the value.  */
3314
              if (! ieee_write_2bytes (abfd, ieee_value_record_enum)
3315
                  || ! ieee_write_int (abfd, (bfd_vma) public_index))
3316
                return FALSE;
3317
              if (! bfd_is_abs_section (p->section))
3318
                {
3319
                  if (abfd->flags & EXEC_P)
3320
                    {
3321
                      /* If fully linked, then output all symbols
3322
                         relocated.  */
3323
                      if (! (ieee_write_int
3324
                             (abfd,
3325
                              (p->value
3326
                               + p->section->output_offset
3327
                               + p->section->output_section->vma))))
3328
                        return FALSE;
3329
                    }
3330
                  else
3331
                    {
3332
                      if (! (ieee_write_expression
3333
                             (abfd,
3334
                              p->value + p->section->output_offset,
3335
                              p->section->output_section->symbol,
3336
                              FALSE, 0)))
3337
                        return FALSE;
3338
                    }
3339
                }
3340
              else
3341
                {
3342
                  if (! ieee_write_expression (abfd,
3343
                                               p->value,
3344
                                               bfd_abs_section_ptr->symbol,
3345
                                               FALSE, 0))
3346
                    return FALSE;
3347
                }
3348
              p->value = public_index;
3349
              public_index++;
3350
              hadone = TRUE;
3351
            }
3352
          else
3353
            {
3354
              /* This can happen - when there are gaps in the symbols read
3355
                 from an input ieee file.  */
3356
            }
3357
        }
3358
    }
3359
  if (hadone)
3360
    ieee->w.r.external_part = here;
3361
 
3362
  return TRUE;
3363
}
3364
 
3365
 
3366
static const unsigned char exten[] =
3367
{
3368
  0xf0, 0x20, 0x00,
3369
  0xf1, 0xce, 0x20, 0x00, 37, 3, 3,     /* Set version 3 rev 3.  */
3370
  0xf1, 0xce, 0x20, 0x00, 39, 2,        /* Keep symbol in  original case.  */
3371
  0xf1, 0xce, 0x20, 0x00, 38            /* Set object type relocatable to x.  */
3372
};
3373
 
3374
static const unsigned char envi[] =
3375
{
3376
  0xf0, 0x21, 0x00,
3377
 
3378
/*    0xf1, 0xce, 0x21, 00, 50, 0x82, 0x07, 0xc7, 0x09, 0x11, 0x11,
3379
    0x19, 0x2c,
3380
*/
3381
  0xf1, 0xce, 0x21, 00, 52, 0x00,       /* exec ok.  */
3382
 
3383
  0xf1, 0xce, 0x21, 0, 53, 0x03,/* host unix.  */
3384
/*    0xf1, 0xce, 0x21, 0, 54, 2,1,1    tool & version # */
3385
};
3386
 
3387
static bfd_boolean
3388
ieee_write_me_part (bfd *abfd)
3389
{
3390
  ieee_data_type *ieee = IEEE_DATA (abfd);
3391
  ieee->w.r.trailer_part = bfd_tell (abfd);
3392
  if (abfd->start_address)
3393
    {
3394
      if (! ieee_write_2bytes (abfd, ieee_value_starting_address_enum)
3395
          || ! ieee_write_byte (abfd, ieee_function_either_open_b_enum)
3396
          || ! ieee_write_int (abfd, abfd->start_address)
3397
          || ! ieee_write_byte (abfd, ieee_function_either_close_b_enum))
3398
        return FALSE;
3399
    }
3400
  ieee->w.r.me_record = bfd_tell (abfd);
3401
  if (! ieee_write_byte (abfd, ieee_module_end_enum))
3402
    return FALSE;
3403
  return TRUE;
3404
}
3405
 
3406
/* Write out the IEEE processor ID.  */
3407
 
3408
static bfd_boolean
3409
ieee_write_processor (bfd *abfd)
3410
{
3411
  const bfd_arch_info_type *arch;
3412
 
3413
  arch = bfd_get_arch_info (abfd);
3414
  switch (arch->arch)
3415
    {
3416
    default:
3417
      if (! ieee_write_id (abfd, bfd_printable_name (abfd)))
3418
        return FALSE;
3419
      break;
3420
 
3421
    case bfd_arch_h8300:
3422
      if (! ieee_write_id (abfd, "H8/300"))
3423
        return FALSE;
3424
      break;
3425
 
3426
    case bfd_arch_h8500:
3427
      if (! ieee_write_id (abfd, "H8/500"))
3428
        return FALSE;
3429
      break;
3430
 
3431
    case bfd_arch_i960:
3432
      switch (arch->mach)
3433
        {
3434
        default:
3435
        case bfd_mach_i960_core:
3436
        case bfd_mach_i960_ka_sa:
3437
          if (! ieee_write_id (abfd, "80960KA"))
3438
            return FALSE;
3439
          break;
3440
 
3441
        case bfd_mach_i960_kb_sb:
3442
          if (! ieee_write_id (abfd, "80960KB"))
3443
            return FALSE;
3444
          break;
3445
 
3446
        case bfd_mach_i960_ca:
3447
          if (! ieee_write_id (abfd, "80960CA"))
3448
            return FALSE;
3449
          break;
3450
 
3451
        case bfd_mach_i960_mc:
3452
        case bfd_mach_i960_xa:
3453
          if (! ieee_write_id (abfd, "80960MC"))
3454
            return FALSE;
3455
          break;
3456
        }
3457
      break;
3458
 
3459
    case bfd_arch_m68k:
3460
      {
3461
        const char *id;
3462
 
3463
        switch (arch->mach)
3464
          {
3465
          default:              id = "68020"; break;
3466
          case bfd_mach_m68000: id = "68000"; break;
3467
          case bfd_mach_m68008: id = "68008"; break;
3468
          case bfd_mach_m68010: id = "68010"; break;
3469
          case bfd_mach_m68020: id = "68020"; break;
3470
          case bfd_mach_m68030: id = "68030"; break;
3471
          case bfd_mach_m68040: id = "68040"; break;
3472
          case bfd_mach_m68060: id = "68060"; break;
3473
          case bfd_mach_cpu32:  id = "cpu32"; break;
3474
          case bfd_mach_mcf_isa_a_nodiv: id = "isa-a:nodiv"; break;
3475
          case bfd_mach_mcf_isa_a: id = "isa-a"; break;
3476
          case bfd_mach_mcf_isa_a_mac: id = "isa-a:mac"; break;
3477
          case bfd_mach_mcf_isa_a_emac: id = "isa-a:emac"; break;
3478
          case bfd_mach_mcf_isa_aplus: id = "isa-aplus"; break;
3479
          case bfd_mach_mcf_isa_aplus_mac: id = "isa-aplus:mac"; break;
3480
          case bfd_mach_mcf_isa_aplus_emac: id = "isa-aplus:mac"; break;
3481
          case bfd_mach_mcf_isa_b_nousp: id = "isa-b:nousp"; break;
3482
          case bfd_mach_mcf_isa_b_nousp_mac: id = "isa-b:nousp:mac"; break;
3483
          case bfd_mach_mcf_isa_b_nousp_emac: id = "isa-b:nousp:emac"; break;
3484
          case bfd_mach_mcf_isa_b: id = "isa-b"; break;
3485
          case bfd_mach_mcf_isa_b_mac: id = "isa-b:mac"; break;
3486
          case bfd_mach_mcf_isa_b_emac: id = "isa-b:emac"; break;
3487
          case bfd_mach_mcf_isa_b_float: id = "isa-b:float"; break;
3488
          case bfd_mach_mcf_isa_b_float_mac: id = "isa-b:float:mac"; break;
3489
          case bfd_mach_mcf_isa_b_float_emac: id = "isa-b:float:emac"; break;
3490
          case bfd_mach_mcf_isa_c: id = "isa-c"; break;
3491
          case bfd_mach_mcf_isa_c_mac: id = "isa-c:mac"; break;
3492
          case bfd_mach_mcf_isa_c_emac: id = "isa-c:emac"; break;
3493
          case bfd_mach_mcf_isa_c_nodiv: id = "isa-c:nodiv"; break;
3494
          case bfd_mach_mcf_isa_c_nodiv_mac: id = "isa-c:nodiv:mac"; break;
3495
          case bfd_mach_mcf_isa_c_nodiv_emac: id = "isa-c:nodiv:emac"; break;
3496
          }
3497
 
3498
        if (! ieee_write_id (abfd, id))
3499
          return FALSE;
3500
      }
3501
      break;
3502
    }
3503
 
3504
  return TRUE;
3505
}
3506
 
3507
static bfd_boolean
3508
ieee_write_object_contents (bfd *abfd)
3509
{
3510
  ieee_data_type *ieee = IEEE_DATA (abfd);
3511
  unsigned int i;
3512
  file_ptr old;
3513
 
3514
  /* Fast forward over the header area.  */
3515
  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
3516
    return FALSE;
3517
 
3518
  if (! ieee_write_byte (abfd, ieee_module_beginning_enum)
3519
      || ! ieee_write_processor (abfd)
3520
      || ! ieee_write_id (abfd, abfd->filename))
3521
    return FALSE;
3522
 
3523
  /* Fast forward over the variable bits.  */
3524
  if (! ieee_write_byte (abfd, ieee_address_descriptor_enum))
3525
    return FALSE;
3526
 
3527
  /* Bits per MAU.  */
3528
  if (! ieee_write_byte (abfd, (bfd_byte) (bfd_arch_bits_per_byte (abfd))))
3529
    return FALSE;
3530
  /* MAU's per address.  */
3531
  if (! ieee_write_byte (abfd,
3532
                         (bfd_byte) (bfd_arch_bits_per_address (abfd)
3533
                                     / bfd_arch_bits_per_byte (abfd))))
3534
    return FALSE;
3535
 
3536
  old = bfd_tell (abfd);
3537
  if (bfd_seek (abfd, (file_ptr) (8 * N_W_VARIABLES), SEEK_CUR) != 0)
3538
    return FALSE;
3539
 
3540
  ieee->w.r.extension_record = bfd_tell (abfd);
3541
  if (bfd_bwrite ((char *) exten, (bfd_size_type) sizeof (exten), abfd)
3542
      != sizeof (exten))
3543
    return FALSE;
3544
  if (abfd->flags & EXEC_P)
3545
    {
3546
      if (! ieee_write_byte (abfd, 0x1)) /* Absolute.  */
3547
        return FALSE;
3548
    }
3549
  else
3550
    {
3551
      if (! ieee_write_byte (abfd, 0x2)) /* Relocateable.  */
3552
        return FALSE;
3553
    }
3554
 
3555
  ieee->w.r.environmental_record = bfd_tell (abfd);
3556
  if (bfd_bwrite ((char *) envi, (bfd_size_type) sizeof (envi), abfd)
3557
      != sizeof (envi))
3558
    return FALSE;
3559
 
3560
  /* The HP emulator database requires a timestamp in the file.  */
3561
  {
3562
    time_t now;
3563
    const struct tm *t;
3564
 
3565
    time (&now);
3566
    t = (struct tm *) localtime (&now);
3567
    if (! ieee_write_2bytes (abfd, (int) ieee_atn_record_enum)
3568
        || ! ieee_write_byte (abfd, 0x21)
3569
        || ! ieee_write_byte (abfd, 0)
3570
        || ! ieee_write_byte (abfd, 50)
3571
        || ! ieee_write_int (abfd, (bfd_vma) (t->tm_year + 1900))
3572
        || ! ieee_write_int (abfd, (bfd_vma) (t->tm_mon + 1))
3573
        || ! ieee_write_int (abfd, (bfd_vma) t->tm_mday)
3574
        || ! ieee_write_int (abfd, (bfd_vma) t->tm_hour)
3575
        || ! ieee_write_int (abfd, (bfd_vma) t->tm_min)
3576
        || ! ieee_write_int (abfd, (bfd_vma) t->tm_sec))
3577
      return FALSE;
3578
  }
3579
 
3580
  output_bfd = abfd;
3581
 
3582
  flush ();
3583
 
3584
  if (! ieee_write_section_part (abfd))
3585
    return FALSE;
3586
  /* First write the symbols.  This changes their values into table
3587
    indeces so we cant use it after this point.  */
3588
  if (! ieee_write_external_part (abfd))
3589
    return FALSE;
3590
 
3591
  /* Write any debugs we have been told about.  */
3592
  if (! ieee_write_debug_part (abfd))
3593
    return FALSE;
3594
 
3595
  /* Can only write the data once the symbols have been written, since
3596
     the data contains relocation information which points to the
3597
     symbols.  */
3598
  if (! ieee_write_data_part (abfd))
3599
    return FALSE;
3600
 
3601
  /* At the end we put the end!  */
3602
  if (! ieee_write_me_part (abfd))
3603
    return FALSE;
3604
 
3605
  /* Generate the header.  */
3606
  if (bfd_seek (abfd, old, SEEK_SET) != 0)
3607
    return FALSE;
3608
 
3609
  for (i = 0; i < N_W_VARIABLES; i++)
3610
    {
3611
      if (! ieee_write_2bytes (abfd, ieee_assign_value_to_variable_enum)
3612
          || ! ieee_write_byte (abfd, (bfd_byte) i)
3613
          || ! ieee_write_int5_out (abfd, (bfd_vma) ieee->w.offset[i]))
3614
        return FALSE;
3615
    }
3616
 
3617
  return TRUE;
3618
}
3619
 
3620
/* Native-level interface to symbols.  */
3621
 
3622
/* We read the symbols into a buffer, which is discarded when this
3623
   function exits.  We read the strings into a buffer large enough to
3624
   hold them all plus all the cached symbol entries.  */
3625
 
3626
static asymbol *
3627
ieee_make_empty_symbol (bfd *abfd)
3628
{
3629
  bfd_size_type amt = sizeof (ieee_symbol_type);
3630 225 jeremybenn
  ieee_symbol_type *new_symbol = (ieee_symbol_type *) bfd_zalloc (abfd, amt);
3631 24 jeremybenn
 
3632 225 jeremybenn
  if (!new_symbol)
3633 24 jeremybenn
    return NULL;
3634 225 jeremybenn
  new_symbol->symbol.the_bfd = abfd;
3635
  return &new_symbol->symbol;
3636 24 jeremybenn
}
3637
 
3638
static bfd *
3639
ieee_openr_next_archived_file (bfd *arch, bfd *prev)
3640
{
3641
  ieee_ar_data_type *ar = IEEE_AR_DATA (arch);
3642
 
3643
  /* Take the next one from the arch state, or reset.  */
3644
  if (prev == (bfd *) NULL)
3645
    /* Reset the index - the first two entries are bogus.  */
3646
    ar->element_index = 2;
3647
 
3648
  while (TRUE)
3649
    {
3650
      ieee_ar_obstack_type *p = ar->elements + ar->element_index;
3651
 
3652
      ar->element_index++;
3653
      if (ar->element_index <= ar->element_count)
3654
        {
3655
          if (p->file_offset != (file_ptr) 0)
3656
            {
3657
              if (p->abfd == (bfd *) NULL)
3658
                {
3659
                  p->abfd = _bfd_create_empty_archive_element_shell (arch);
3660
                  p->abfd->origin = p->file_offset;
3661
                }
3662
              return p->abfd;
3663
            }
3664
        }
3665
      else
3666
        {
3667
          bfd_set_error (bfd_error_no_more_archived_files);
3668
          return NULL;
3669
        }
3670
    }
3671
}
3672
 
3673
static bfd_boolean
3674
ieee_find_nearest_line (bfd *abfd ATTRIBUTE_UNUSED,
3675
                        asection *section ATTRIBUTE_UNUSED,
3676
                        asymbol **symbols ATTRIBUTE_UNUSED,
3677
                        bfd_vma offset ATTRIBUTE_UNUSED,
3678
                        const char **filename_ptr ATTRIBUTE_UNUSED,
3679
                        const char **functionname_ptr ATTRIBUTE_UNUSED,
3680
                        unsigned int *line_ptr ATTRIBUTE_UNUSED)
3681
{
3682
  return FALSE;
3683
}
3684
 
3685
static bfd_boolean
3686
ieee_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
3687
                        const char **filename_ptr ATTRIBUTE_UNUSED,
3688
                        const char **functionname_ptr ATTRIBUTE_UNUSED,
3689
                        unsigned int *line_ptr ATTRIBUTE_UNUSED)
3690
{
3691
  return FALSE;
3692
}
3693
 
3694
static int
3695
ieee_generic_stat_arch_elt (bfd *abfd, struct stat *buf)
3696
{
3697
  ieee_ar_data_type *ar = (ieee_ar_data_type *) NULL;
3698
  ieee_data_type *ieee;
3699
 
3700
  if (abfd->my_archive != NULL)
3701
    ar = abfd->my_archive->tdata.ieee_ar_data;
3702
  if (ar == (ieee_ar_data_type *) NULL)
3703
    {
3704
      bfd_set_error (bfd_error_invalid_operation);
3705
      return -1;
3706
    }
3707
 
3708
  if (IEEE_DATA (abfd) == NULL)
3709
    {
3710
      if (ieee_object_p (abfd) == NULL)
3711
        {
3712
          bfd_set_error (bfd_error_wrong_format);
3713
          return -1;
3714
        }
3715
    }
3716
 
3717
  ieee = IEEE_DATA (abfd);
3718
 
3719
  buf->st_size = ieee->w.r.me_record + 1;
3720
  buf->st_mode = 0644;
3721
  return 0;
3722
}
3723
 
3724
static int
3725
ieee_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
3726
                     struct bfd_link_info *info ATTRIBUTE_UNUSED)
3727
{
3728
  return 0;
3729
}
3730
 
3731
#define ieee_close_and_cleanup _bfd_generic_close_and_cleanup
3732
#define ieee_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
3733
 
3734
#define ieee_slurp_armap bfd_true
3735
#define ieee_slurp_extended_name_table bfd_true
3736
#define ieee_construct_extended_name_table \
3737
  ((bfd_boolean (*) \
3738
    (bfd *, char **, bfd_size_type *, const char **)) \
3739
   bfd_true)
3740
#define ieee_truncate_arname bfd_dont_truncate_arname
3741
#define ieee_write_armap \
3742
  ((bfd_boolean (*) \
3743
    (bfd *, unsigned int, struct orl *, unsigned int, int)) \
3744
   bfd_true)
3745
#define ieee_read_ar_hdr bfd_nullvoidptr
3746
#define ieee_update_armap_timestamp bfd_true
3747
#define ieee_get_elt_at_index _bfd_generic_get_elt_at_index
3748
 
3749
#define ieee_bfd_is_target_special_symbol  \
3750
  ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
3751
#define ieee_bfd_is_local_label_name bfd_generic_is_local_label_name
3752
#define ieee_get_lineno _bfd_nosymbols_get_lineno
3753
#define ieee_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
3754
#define ieee_read_minisymbols _bfd_generic_read_minisymbols
3755
#define ieee_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
3756
 
3757
#define ieee_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
3758
#define ieee_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
3759
 
3760
#define ieee_set_arch_mach _bfd_generic_set_arch_mach
3761
 
3762
#define ieee_get_section_contents_in_window \
3763
  _bfd_generic_get_section_contents_in_window
3764
#define ieee_bfd_get_relocated_section_contents \
3765
  bfd_generic_get_relocated_section_contents
3766
#define ieee_bfd_relax_section bfd_generic_relax_section
3767
#define ieee_bfd_gc_sections bfd_generic_gc_sections
3768
#define ieee_bfd_merge_sections bfd_generic_merge_sections
3769
#define ieee_bfd_is_group_section bfd_generic_is_group_section
3770
#define ieee_bfd_discard_group bfd_generic_discard_group
3771
#define ieee_section_already_linked \
3772
  _bfd_generic_section_already_linked
3773 225 jeremybenn
#define ieee_bfd_define_common_symbol bfd_generic_define_common_symbol
3774 24 jeremybenn
#define ieee_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
3775
#define ieee_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
3776
#define ieee_bfd_link_add_symbols _bfd_generic_link_add_symbols
3777
#define ieee_bfd_link_just_syms _bfd_generic_link_just_syms
3778
#define ieee_bfd_final_link _bfd_generic_final_link
3779
#define ieee_bfd_link_split_section  _bfd_generic_link_split_section
3780
 
3781
const bfd_target ieee_vec =
3782
{
3783
  "ieee",                       /* Name.  */
3784
  bfd_target_ieee_flavour,
3785
  BFD_ENDIAN_UNKNOWN,           /* Target byte order.  */
3786
  BFD_ENDIAN_UNKNOWN,           /* Target headers byte order.  */
3787
  (HAS_RELOC | EXEC_P |         /* Object flags.  */
3788
   HAS_LINENO | HAS_DEBUG |
3789
   HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
3790
  (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
3791
   | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags.  */
3792
  '_',                          /* Leading underscore.  */
3793
  ' ',                          /* AR_pad_char.  */
3794
  16,                           /* AR_max_namelen.  */
3795
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
3796
  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
3797
  bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Data.  */
3798
  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
3799
  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
3800
  bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Headers.  */
3801
 
3802
  {_bfd_dummy_target,
3803
   ieee_object_p,               /* bfd_check_format.  */
3804
   ieee_archive_p,
3805
   _bfd_dummy_target,
3806
  },
3807
  {
3808
    bfd_false,
3809
    ieee_mkobject,
3810
    _bfd_generic_mkarchive,
3811
    bfd_false
3812
  },
3813
  {
3814
    bfd_false,
3815
    ieee_write_object_contents,
3816
    _bfd_write_archive_contents,
3817
    bfd_false,
3818
  },
3819
 
3820
  /* ieee_close_and_cleanup, ieee_bfd_free_cached_info, ieee_new_section_hook,
3821
     ieee_get_section_contents, ieee_get_section_contents_in_window.  */
3822
  BFD_JUMP_TABLE_GENERIC (ieee),
3823
 
3824
  BFD_JUMP_TABLE_COPY (_bfd_generic),
3825
  BFD_JUMP_TABLE_CORE (_bfd_nocore),
3826
 
3827
  /* ieee_slurp_armap, ieee_slurp_extended_name_table,
3828
     ieee_construct_extended_name_table, ieee_truncate_arname,
3829
     ieee_write_armap, ieee_read_ar_hdr, ieee_openr_next_archived_file,
3830
     ieee_get_elt_at_index, ieee_generic_stat_arch_elt,
3831
     ieee_update_armap_timestamp.  */
3832
  BFD_JUMP_TABLE_ARCHIVE (ieee),
3833
 
3834
  /* ieee_get_symtab_upper_bound, ieee_canonicalize_symtab,
3835
     ieee_make_empty_symbol, ieee_print_symbol, ieee_get_symbol_info,
3836
     ieee_bfd_is_local_label_name, ieee_get_lineno,
3837
     ieee_find_nearest_line, ieee_bfd_make_debug_symbol,
3838
     ieee_read_minisymbols, ieee_minisymbol_to_symbol.  */
3839
  BFD_JUMP_TABLE_SYMBOLS (ieee),
3840
 
3841
  /* ieee_get_reloc_upper_bound, ieee_canonicalize_reloc,
3842
     ieee_bfd_reloc_type_lookup.   */
3843
  BFD_JUMP_TABLE_RELOCS (ieee),
3844
 
3845
  /* ieee_set_arch_mach, ieee_set_section_contents.  */
3846
  BFD_JUMP_TABLE_WRITE (ieee),
3847
 
3848
  /* ieee_sizeof_headers, ieee_bfd_get_relocated_section_contents,
3849
     ieee_bfd_relax_section, ieee_bfd_link_hash_table_create,
3850
     _bfd_generic_link_hash_table_free,
3851
     ieee_bfd_link_add_symbols, ieee_bfd_final_link,
3852
     ieee_bfd_link_split_section, ieee_bfd_gc_sections,
3853
     ieee_bfd_merge_sections.  */
3854
  BFD_JUMP_TABLE_LINK (ieee),
3855
 
3856
  BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
3857
 
3858
  NULL,
3859
 
3860
  NULL
3861
};

powered by: WebSVN 2.1.0

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