bfd/ieee.c

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