bfd/ieee.c

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