bfd/ieee.c

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