bfd/ieee.c

   1 /* BFD back-end for ieee-695 objects.
   2    Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
   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 ATTRIBUTE_UNUSED;
 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               case ieee_atn_record_enum:
 809                 /* We may get call optimization information here,
 810                    which we just ignore.  The format is
 811                    {$F1}${CE}{index}{$00}{$3F}{$3F}{#_of_ASNs} */
 812                 parse_int (&ieee->h, &value);
 813                 parse_int (&ieee->h, &value);
 814                 parse_int (&ieee->h, &value);
 815                 if (value != 0x3f)
 816                   {
 817                     (*_bfd_error_handler)
 818                       (_("%s: unexpected ATN type %d in external part"),
 819                          bfd_get_filename (abfd), (int) value);
 820                     bfd_set_error (bfd_error_bad_value);
 821                     return false;
 822                   }
 823                 parse_int (&ieee->h, &value);
 824                 parse_int (&ieee->h, &value);
 825                 while (value > 0)
 826                   {
 827                     bfd_vma val1;
 828
 829                     --value;
 830
 831                     switch (read_2bytes (ieee))
 832                       {
 833                       case ieee_asn_record_enum:
 834                         parse_int (&ieee->h, &val1);
 835                         parse_int (&ieee->h, &val1);
 836                         break;
 837
 838                       default:
 839                         (*_bfd_error_handler)
 840                           (_("%s: unexpected type after ATN"),
 841                              bfd_get_filename (abfd));
 842                         bfd_set_error (bfd_error_bad_value);
 843                         return false;
 844                       }
 845                   }
 846               }
 847           }
 848           break;
 849         case ieee_value_record_enum >> 8:
 850           {
 851             unsigned int symbol_name_index;
 852             ieee_symbol_index_type symbol_ignore;
 853             boolean pcrel_ignore;
 854             unsigned int extra;
 855             next_byte (&(ieee->h));
 856             next_byte (&(ieee->h));
 857
 858             symbol_name_index = must_parse_int (&(ieee->h));
 859             parse_expression (ieee,
 860                               &symbol->symbol.value,
 861                               &symbol_ignore,
 862                               &pcrel_ignore,
 863                               &extra,
 864                               &symbol->symbol.section);
 865
 866             /* Fully linked IEEE-695 files tend to give every symbol
 867                an absolute value.  Try to convert that back into a
 868                section relative value.  FIXME: This won't always to
 869                the right thing.  */
 870             if (bfd_is_abs_section (symbol->symbol.section)
 871                 && (abfd->flags & HAS_RELOC) == 0)
 872               {
 873                 bfd_vma val;
 874                 asection *s;
 875
 876                 val = symbol->symbol.value;
 877                 for (s = abfd->sections; s != NULL; s = s->next)
 878                   {
 879                     if (val >= s->vma && val < s->vma + s->_raw_size)
 880                       {
 881                         symbol->symbol.section = s;
 882                         symbol->symbol.value -= s->vma;
 883                         break;
 884                       }
 885                   }
 886               }
 887
 888             symbol->symbol.flags = BSF_GLOBAL | BSF_EXPORT;
 889
 890           }
 891           break;
 892         case ieee_weak_external_reference_enum:
 893           {
 894             bfd_vma size;
 895             bfd_vma value;
 896             next_byte (&(ieee->h));
 897             /* Throw away the external reference index */
 898             (void) must_parse_int (&(ieee->h));
 899             /* Fetch the default size if not resolved */
 900             size = must_parse_int (&(ieee->h));
 901             /* Fetch the defautlt value if available */
 902             if (parse_int (&(ieee->h), &value) == false)
 903               {
 904                 value = 0;
 905               }
 906             /* This turns into a common */
 907             symbol->symbol.section = bfd_com_section_ptr;
 908             symbol->symbol.value = size;
 909           }
 910           break;
 911
 912         case ieee_external_reference_enum:
 913           next_byte (&(ieee->h));
 914
 915           symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
 916                                &prev_reference_ptr,
 917                                &ieee->external_reference_max_index, 'X');
 918           if (symbol == NULL)
 919             return false;
 920
 921           symbol->symbol.the_bfd = abfd;
 922           symbol->symbol.name = read_id (&(ieee->h));
 923           symbol->symbol.udata.p = (PTR) NULL;
 924           symbol->symbol.section = bfd_und_section_ptr;
 925           symbol->symbol.value = (bfd_vma) 0;
 926           symbol->symbol.flags = 0;
 927
 928           BFD_ASSERT (symbol->index >= ieee->external_reference_min_index);
 929           break;
 930
 931         default:
 932           loop = false;
 933         }
 934     }
 935
 936   if (ieee->external_symbol_max_index != 0)
 937     {
 938       ieee->external_symbol_count =
 939         ieee->external_symbol_max_index -
 940         ieee->external_symbol_min_index + 1;
 941     }
 942   else
 943     {
 944       ieee->external_symbol_count = 0;
 945     }
 946
 947   if (ieee->external_reference_max_index != 0)
 948     {
 949       ieee->external_reference_count =
 950         ieee->external_reference_max_index -
 951         ieee->external_reference_min_index + 1;
 952     }
 953   else
 954     {
 955       ieee->external_reference_count = 0;
 956     }
 957
 958   abfd->symcount =
 959     ieee->external_reference_count + ieee->external_symbol_count;
 960
 961   if (symbol_count != abfd->symcount)
 962     {
 963       /* There are gaps in the table -- */
 964       ieee->symbol_table_full = false;
 965     }
 966
 967   *prev_symbols_ptr = (ieee_symbol_type *) NULL;
 968   *prev_reference_ptr = (ieee_symbol_type *) NULL;
 969
 970   return true;
 971 }
 972
 973 static boolean
 974 ieee_slurp_symbol_table (abfd)
 975      bfd *abfd;
 976 {
 977   if (IEEE_DATA (abfd)->read_symbols == false)
 978     {
 979       if (! ieee_slurp_external_symbols (abfd))
 980         return false;
 981       IEEE_DATA (abfd)->read_symbols = true;
 982     }
 983   return true;
 984 }
 985
 986 long
 987 ieee_get_symtab_upper_bound (abfd)
 988      bfd *abfd;
 989 {
 990   if (! ieee_slurp_symbol_table (abfd))
 991     return -1;
 992
 993   return (abfd->symcount != 0) ?
 994     (abfd->symcount + 1) * (sizeof (ieee_symbol_type *)) : 0;
 995 }
 996
 997 /*
 998 Move from our internal lists to the canon table, and insert in
 999 symbol index order
1000 */
1001
1002 extern const bfd_target ieee_vec;
1003
1004 long
1005 ieee_get_symtab (abfd, location)
1006      bfd *abfd;
1007      asymbol **location;
1008 {
1009   ieee_symbol_type *symp;
1010   static bfd dummy_bfd;
1011   static asymbol empty_symbol =
1012   /* the_bfd, name, value, attr, section */
1013   {&dummy_bfd, " ieee empty", (symvalue) 0, BSF_DEBUGGING, bfd_abs_section_ptr, { 0 }};
1014
1015   if (abfd->symcount)
1016     {
1017       ieee_data_type *ieee = IEEE_DATA (abfd);
1018       dummy_bfd.xvec = &ieee_vec;
1019       if (! ieee_slurp_symbol_table (abfd))
1020         return -1;
1021
1022       if (ieee->symbol_table_full == false)
1023         {
1024           /* Arrgh - there are gaps in the table, run through and fill them */
1025           /* up with pointers to a null place */
1026           unsigned int i;
1027           for (i = 0; i < abfd->symcount; i++)
1028             {
1029               location[i] = &empty_symbol;
1030             }
1031         }
1032
1033       ieee->external_symbol_base_offset = -ieee->external_symbol_min_index;
1034       for (symp = IEEE_DATA (abfd)->external_symbols;
1035            symp != (ieee_symbol_type *) NULL;
1036            symp = symp->next)
1037         {
1038           /* Place into table at correct index locations */
1039           location[symp->index + ieee->external_symbol_base_offset] = &symp->symbol;
1040         }
1041
1042       /* The external refs are indexed in a bit */
1043       ieee->external_reference_base_offset =
1044         -ieee->external_reference_min_index + ieee->external_symbol_count;
1045
1046       for (symp = IEEE_DATA (abfd)->external_reference;
1047            symp != (ieee_symbol_type *) NULL;
1048            symp = symp->next)
1049         {
1050           location[symp->index + ieee->external_reference_base_offset] =
1051             &symp->symbol;
1052
1053         }
1054     }
1055   if (abfd->symcount)
1056     {
1057       location[abfd->symcount] = (asymbol *) NULL;
1058     }
1059   return abfd->symcount;
1060 }
1061
1062 static asection *
1063 get_section_entry (abfd, ieee, index)
1064      bfd *abfd;
1065      ieee_data_type *ieee;
1066      unsigned int index;
1067 {
1068   if (index >= ieee->section_table_size)
1069     {
1070       unsigned int c, i;
1071       asection **n;
1072
1073       c = ieee->section_table_size;
1074       if (c == 0)
1075         c = 20;
1076       while (c <= index)
1077         c *= 2;
1078
1079       n = ((asection **)
1080            bfd_realloc (ieee->section_table, c * sizeof (asection *)));
1081       if (n == NULL)
1082         return NULL;
1083
1084       for (i = ieee->section_table_size; i < c; i++)
1085         n[i] = NULL;
1086
1087       ieee->section_table = n;
1088       ieee->section_table_size = c;
1089     }
1090
1091   if (ieee->section_table[index] == (asection *) NULL)
1092     {
1093       char *tmp = bfd_alloc (abfd, 11);
1094       asection *section;
1095
1096       if (!tmp)
1097         return NULL;
1098       sprintf (tmp, " fsec%4d", index);
1099       section = bfd_make_section (abfd, tmp);
1100       ieee->section_table[index] = section;
1101       section->flags = SEC_NO_FLAGS;
1102       section->target_index = index;
1103       ieee->section_table[index] = section;
1104     }
1105   return ieee->section_table[index];
1106 }
1107
1108 static void
1109 ieee_slurp_sections (abfd)
1110      bfd *abfd;
1111 {
1112   ieee_data_type *ieee = IEEE_DATA (abfd);
1113   file_ptr offset = ieee->w.r.section_part;
1114   asection *section = (asection *) NULL;
1115   char *name;
1116
1117   if (offset != 0)
1118     {
1119       bfd_byte section_type[3];
1120       ieee_seek (abfd, offset);
1121       while (true)
1122         {
1123           switch (this_byte (&(ieee->h)))
1124             {
1125             case ieee_section_type_enum:
1126               {
1127                 unsigned int section_index;
1128                 next_byte (&(ieee->h));
1129                 section_index = must_parse_int (&(ieee->h));
1130
1131                 section = get_section_entry (abfd, ieee, section_index);
1132
1133                 section_type[0] = this_byte_and_next (&(ieee->h));
1134
1135                 /* Set minimal section attributes. Attributes are
1136                    extended later, based on section contents. */
1137
1138                 switch (section_type[0])
1139                   {
1140                   case 0xC1:
1141                     /* Normal attributes for absolute sections  */
1142                     section_type[1] = this_byte (&(ieee->h));
1143                     section->flags = SEC_ALLOC;
1144                     switch (section_type[1])
1145                       {
1146                       case 0xD3:        /* AS Absolute section attributes */
1147                         next_byte (&(ieee->h));
1148                         section_type[2] = this_byte (&(ieee->h));
1149                         switch (section_type[2])
1150                           {
1151                           case 0xD0:
1152                             /* Normal code */
1153                             next_byte (&(ieee->h));
1154                             section->flags |= SEC_CODE;
1155                             break;
1156                           case 0xC4:
1157                             /* Normal data */
1158                             next_byte (&(ieee->h));
1159                             section->flags |= SEC_DATA;
1160                             break;
1161                           case 0xD2:
1162                             next_byte (&(ieee->h));
1163                             /* Normal rom data */
1164                             section->flags |= SEC_ROM | SEC_DATA;
1165                             break;
1166                           default:
1167                             break;
1168                           }
1169                       }
1170                     break;
1171                   case 0xC3:    /* Named relocatable sections (type C) */
1172                     section_type[1] = this_byte (&(ieee->h));
1173                     section->flags = SEC_ALLOC;
1174                     switch (section_type[1])
1175                       {
1176                       case 0xD0:        /* Normal code (CP) */
1177                         next_byte (&(ieee->h));
1178                         section->flags |= SEC_CODE;
1179                         break;
1180                       case 0xC4:        /* Normal data (CD) */
1181                         next_byte (&(ieee->h));
1182                         section->flags |= SEC_DATA;
1183                         break;
1184                       case 0xD2:        /* Normal rom data (CR) */
1185                         next_byte (&(ieee->h));
1186                         section->flags |= SEC_ROM | SEC_DATA;
1187                         break;
1188                       default:
1189                         break;
1190                       }
1191                   }
1192
1193                 /* Read section name, use it if non empty. */
1194                 name = read_id (&ieee->h);
1195                 if (name[0])
1196                   section->name = name;
1197
1198                 /* Skip these fields, which we don't care about */
1199                 {
1200                   bfd_vma parent, brother, context;
1201                   parse_int (&(ieee->h), &parent);
1202                   parse_int (&(ieee->h), &brother);
1203                   parse_int (&(ieee->h), &context);
1204                 }
1205               }
1206               break;
1207             case ieee_section_alignment_enum:
1208               {
1209                 unsigned int section_index;
1210                 bfd_vma value;
1211                 asection *section;
1212                 next_byte (&(ieee->h));
1213                 section_index = must_parse_int (&ieee->h);
1214                 section = get_section_entry (abfd, ieee, section_index);
1215                 if (section_index > ieee->section_count)
1216                   {
1217                     ieee->section_count = section_index;
1218                   }
1219                 section->alignment_power =
1220                   bfd_log2 (must_parse_int (&ieee->h));
1221                 (void) parse_int (&(ieee->h), &value);
1222               }
1223               break;
1224             case ieee_e2_first_byte_enum:
1225               {
1226                 ieee_record_enum_type t = (ieee_record_enum_type) (read_2bytes (&(ieee->h)));
1227
1228                 switch (t)
1229                   {
1230                   case ieee_section_size_enum:
1231                     section = ieee->section_table[must_parse_int (&(ieee->h))];
1232                     section->_raw_size = must_parse_int (&(ieee->h));
1233                     break;
1234                   case ieee_physical_region_size_enum:
1235                     section = ieee->section_table[must_parse_int (&(ieee->h))];
1236                     section->_raw_size = must_parse_int (&(ieee->h));
1237                     break;
1238                   case ieee_region_base_address_enum:
1239                     section = ieee->section_table[must_parse_int (&(ieee->h))];
1240                     section->vma = must_parse_int (&(ieee->h));
1241                     section->lma = section->vma;
1242                     break;
1243                   case ieee_mau_size_enum:
1244                     must_parse_int (&(ieee->h));
1245                     must_parse_int (&(ieee->h));
1246                     break;
1247                   case ieee_m_value_enum:
1248                     must_parse_int (&(ieee->h));
1249                     must_parse_int (&(ieee->h));
1250                     break;
1251                   case ieee_section_base_address_enum:
1252                     section = ieee->section_table[must_parse_int (&(ieee->h))];
1253                     section->vma = must_parse_int (&(ieee->h));
1254                     section->lma = section->vma;
1255                     break;
1256                   case ieee_section_offset_enum:
1257                     (void) must_parse_int (&(ieee->h));
1258                     (void) must_parse_int (&(ieee->h));
1259                     break;
1260                   default:
1261                     return;
1262                   }
1263               }
1264               break;
1265             default:
1266               return;
1267             }
1268         }
1269     }
1270 }
1271
1272 /* Make a section for the debugging information, if any.  We don't try
1273    to interpret the debugging information; we just point the section
1274    at the area in the file so that program which understand can dig it
1275    out.  */
1276
1277 static boolean
1278 ieee_slurp_debug (abfd)
1279      bfd *abfd;
1280 {
1281   ieee_data_type *ieee = IEEE_DATA (abfd);
1282   asection *sec;
1283
1284   if (ieee->w.r.debug_information_part == 0)
1285     return true;
1286
1287   sec = bfd_make_section (abfd, ".debug");
1288   if (sec == NULL)
1289     return false;
1290   sec->flags |= SEC_DEBUGGING | SEC_HAS_CONTENTS;
1291   sec->filepos = ieee->w.r.debug_information_part;
1292   sec->_raw_size = ieee->w.r.data_part - ieee->w.r.debug_information_part;
1293
1294   return true;
1295 }
1296 \f
1297 /***********************************************************************
1298 *  archive stuff
1299 */
1300
1301 const bfd_target *
1302 ieee_archive_p (abfd)
1303      bfd *abfd;
1304 {
1305   char *library;
1306   unsigned int i;
1307   unsigned char buffer[512];
1308   file_ptr buffer_offset = 0;
1309   ieee_ar_data_type *save = abfd->tdata.ieee_ar_data;
1310   ieee_ar_data_type *ieee;
1311   unsigned int alc_elts;
1312   ieee_ar_obstack_type *elts = NULL;
1313
1314   abfd->tdata.ieee_ar_data =
1315     (ieee_ar_data_type *) bfd_alloc (abfd, sizeof (ieee_ar_data_type));
1316   if (!abfd->tdata.ieee_ar_data)
1317     goto error_return;
1318   ieee = IEEE_AR_DATA (abfd);
1319
1320   /* FIXME: Check return value.  I'm not sure whether it needs to read
1321      the entire buffer or not.  */
1322   bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd);
1323
1324   ieee->h.first_byte = buffer;
1325   ieee->h.input_p = buffer;
1326
1327   ieee->h.abfd = abfd;
1328
1329   if (this_byte (&(ieee->h)) != Module_Beginning)
1330     {
1331       abfd->tdata.ieee_ar_data = save;
1332       goto error_return;
1333     }
1334
1335   next_byte (&(ieee->h));
1336   library = read_id (&(ieee->h));
1337   if (strcmp (library, "LIBRARY") != 0)
1338     {
1339       bfd_release (abfd, ieee);
1340       abfd->tdata.ieee_ar_data = save;
1341       goto error_return;
1342     }
1343   /* Throw away the filename */
1344   read_id (&(ieee->h));
1345
1346   ieee->element_count = 0;
1347   ieee->element_index = 0;
1348
1349   next_byte (&(ieee->h));       /* Drop the ad part */
1350   must_parse_int (&(ieee->h));  /* And the two dummy numbers */
1351   must_parse_int (&(ieee->h));
1352
1353   alc_elts = 10;
1354   elts = (ieee_ar_obstack_type *) bfd_malloc (alc_elts * sizeof *elts);
1355   if (elts == NULL)
1356     goto error_return;
1357
1358   /* Read the index of the BB table */
1359   while (1)
1360     {
1361       int rec;
1362       ieee_ar_obstack_type *t;
1363
1364       rec = read_2bytes (&(ieee->h));
1365       if (rec != (int) ieee_assign_value_to_variable_enum)
1366         break;
1367
1368       if (ieee->element_count >= alc_elts)
1369         {
1370           ieee_ar_obstack_type *n;
1371
1372           alc_elts *= 2;
1373           n = ((ieee_ar_obstack_type *)
1374                bfd_realloc (elts, alc_elts * sizeof *elts));
1375           if (n == NULL)
1376             goto error_return;
1377           elts = n;
1378         }
1379
1380       t = &elts[ieee->element_count];
1381       ieee->element_count++;
1382
1383       must_parse_int (&(ieee->h));
1384       t->file_offset = must_parse_int (&(ieee->h));
1385       t->abfd = (bfd *) NULL;
1386
1387       /* Make sure that we don't go over the end of the buffer */
1388
1389       if ((size_t) ieee_pos (abfd) > sizeof (buffer) / 2)
1390         {
1391           /* Past half way, reseek and reprime */
1392           buffer_offset += ieee_pos (abfd);
1393           if (bfd_seek (abfd, buffer_offset, SEEK_SET) != 0)
1394             goto error_return;
1395           /* FIXME: Check return value.  I'm not sure whether it needs
1396              to read the entire buffer or not.  */
1397           bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd);
1398           ieee->h.first_byte = buffer;
1399           ieee->h.input_p = buffer;
1400         }
1401     }
1402
1403   ieee->elements = ((ieee_ar_obstack_type *)
1404                     bfd_alloc (abfd,
1405                                ieee->element_count * sizeof *ieee->elements));
1406   if (ieee->elements == NULL)
1407     goto error_return;
1408   memcpy (ieee->elements, elts,
1409           ieee->element_count * sizeof *ieee->elements);
1410   free (elts);
1411   elts = NULL;
1412
1413   /* Now scan the area again, and replace BB offsets with file */
1414   /* offsets */
1415
1416   for (i = 2; i < ieee->element_count; i++)
1417     {
1418       if (bfd_seek (abfd, ieee->elements[i].file_offset, SEEK_SET) != 0)
1419         goto error_return;
1420       /* FIXME: Check return value.  I'm not sure whether it needs to
1421          read the entire buffer or not.  */
1422       bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd);
1423       ieee->h.first_byte = buffer;
1424       ieee->h.input_p = buffer;
1425
1426       next_byte (&(ieee->h));   /* Drop F8 */
1427       next_byte (&(ieee->h));   /* Drop 14 */
1428       must_parse_int (&(ieee->h));      /* Drop size of block */
1429       if (must_parse_int (&(ieee->h)) != 0)
1430         {
1431           /* This object has been deleted */
1432           ieee->elements[i].file_offset = 0;
1433         }
1434       else
1435         {
1436           ieee->elements[i].file_offset = must_parse_int (&(ieee->h));
1437         }
1438     }
1439
1440   /*  abfd->has_armap = ;*/
1441
1442   return abfd->xvec;
1443
1444  error_return:
1445   if (elts != NULL)
1446     free (elts);
1447   return NULL;
1448 }
1449
1450 static boolean
1451 ieee_mkobject (abfd)
1452      bfd *abfd;
1453 {
1454   abfd->tdata.ieee_data = (ieee_data_type *) bfd_zalloc (abfd, sizeof (ieee_data_type));
1455   return abfd->tdata.ieee_data ? true : false;
1456 }
1457
1458 const bfd_target *
1459 ieee_object_p (abfd)
1460      bfd *abfd;
1461 {
1462   char *processor;
1463   unsigned int part;
1464   ieee_data_type *ieee;
1465   unsigned char buffer[300];
1466   ieee_data_type *save = IEEE_DATA (abfd);
1467
1468   abfd->tdata.ieee_data = 0;
1469   ieee_mkobject (abfd);
1470
1471   ieee = IEEE_DATA (abfd);
1472   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
1473     goto fail;
1474   /* Read the first few bytes in to see if it makes sense */
1475   /* FIXME: Check return value.  I'm not sure whether it needs to read
1476      the entire buffer or not.  */
1477   bfd_read ((PTR) buffer, 1, sizeof (buffer), abfd);
1478
1479   ieee->h.input_p = buffer;
1480   if (this_byte_and_next (&(ieee->h)) != Module_Beginning)
1481     goto got_wrong_format;
1482
1483   ieee->read_symbols = false;
1484   ieee->read_data = false;
1485   ieee->section_count = 0;
1486   ieee->external_symbol_max_index = 0;
1487   ieee->external_symbol_min_index = IEEE_PUBLIC_BASE;
1488   ieee->external_reference_min_index = IEEE_REFERENCE_BASE;
1489   ieee->external_reference_max_index = 0;
1490   ieee->h.abfd = abfd;
1491   ieee->section_table = NULL;
1492   ieee->section_table_size = 0;
1493
1494   processor = ieee->mb.processor = read_id (&(ieee->h));
1495   if (strcmp (processor, "LIBRARY") == 0)
1496     goto got_wrong_format;
1497   ieee->mb.module_name = read_id (&(ieee->h));
1498   if (abfd->filename == (CONST char *) NULL)
1499     {
1500       abfd->filename = ieee->mb.module_name;
1501     }
1502   /* Determine the architecture and machine type of the object file.
1503      */
1504   {
1505     const bfd_arch_info_type *arch;
1506     char family[10];
1507
1508     /* IEEE does not specify the format of the processor identificaton
1509        string, so the compiler is free to put in it whatever it wants.
1510        We try here to recognize different processors belonging to the
1511        m68k family.  Code for other processors can be added here.  */
1512     if ((processor[0] == '6') && (processor[1] == '8'))
1513       {
1514         if (processor[2] == '3')            /* 683xx integrated processors */
1515           {
1516             switch (processor[3])
1517               {
1518               case '0':                     /* 68302, 68306, 68307 */
1519               case '2':                     /* 68322, 68328 */
1520               case '5':                     /* 68356 */
1521                 strcpy (family, "68000");   /* MC68000-based controllers */
1522                 break;
1523
1524               case '3':                     /* 68330, 68331, 68332, 68333,
1525                                                68334, 68335, 68336, 68338 */
1526               case '6':                     /* 68360 */
1527               case '7':                     /* 68376 */
1528                 strcpy (family, "68332");   /* CPU32 and CPU32+ */
1529                 break;
1530
1531               case '4':
1532                 if (processor[4] == '9')    /* 68349 */
1533                   strcpy (family, "68030"); /* CPU030 */
1534                 else                        /* 68340, 68341 */
1535                   strcpy (family, "68332"); /* CPU32 and CPU32+ */
1536                 break;
1537
1538               default:                      /* Does not exist yet */
1539                 strcpy (family, "68332");   /* Guess it will be CPU32 */
1540               }
1541           }
1542         else if (toupper (processor[3]) == 'F')   /* 68F333 */
1543           strcpy (family, "68332");               /* CPU32 */
1544         else if ((toupper (processor[3]) == 'C')  /* Embedded controllers */
1545                  && ((toupper (processor[2]) == 'E')
1546                      || (toupper (processor[2]) == 'H')
1547                      || (toupper (processor[2]) == 'L')))
1548           {
1549             strcpy (family, "68");
1550             strncat (family, processor + 4, 7);
1551             family[9] = '\0';
1552           }
1553         else                             /* "Regular" processors */
1554           {
1555             strncpy (family, processor, 9);
1556             family[9] = '\0';
1557           }
1558       }
1559     else if ((strncmp (processor, "cpu32", 5) == 0) /* CPU32 and CPU32+ */
1560              || (strncmp (processor, "CPU32", 5) == 0))
1561       strcpy (family, "68332");
1562     else
1563       {
1564         strncpy (family, processor, 9);
1565         family[9] = '\0';
1566       }
1567
1568     arch = bfd_scan_arch (family);
1569     if (arch == 0)
1570       goto got_wrong_format;
1571     abfd->arch_info = arch;
1572   }
1573
1574   if (this_byte (&(ieee->h)) != (int) ieee_address_descriptor_enum)
1575     {
1576       goto fail;
1577     }
1578   next_byte (&(ieee->h));
1579
1580   if (parse_int (&(ieee->h), &ieee->ad.number_of_bits_mau) == false)
1581     {
1582       goto fail;
1583     }
1584   if (parse_int (&(ieee->h), &ieee->ad.number_of_maus_in_address) == false)
1585     {
1586       goto fail;
1587     }
1588
1589   /* If there is a byte order info, take it */
1590   if (this_byte (&(ieee->h)) == (int) ieee_variable_L_enum ||
1591       this_byte (&(ieee->h)) == (int) ieee_variable_M_enum)
1592     next_byte (&(ieee->h));
1593
1594   for (part = 0; part < N_W_VARIABLES; part++)
1595     {
1596       boolean ok;
1597       if (read_2bytes (&(ieee->h)) != (int) ieee_assign_value_to_variable_enum)
1598         {
1599           goto fail;
1600         }
1601       if (this_byte_and_next (&(ieee->h)) != part)
1602         {
1603           goto fail;
1604         }
1605
1606       ieee->w.offset[part] = parse_i (&(ieee->h), &ok);
1607       if (ok == false)
1608         {
1609           goto fail;
1610         }
1611
1612     }
1613
1614   if (ieee->w.r.external_part != 0)
1615     abfd->flags = HAS_SYMS;
1616
1617   /* By now we know that this is a real IEEE file, we're going to read
1618      the whole thing into memory so that we can run up and down it
1619      quickly.  We can work out how big the file is from the trailer
1620      record */
1621
1622   IEEE_DATA (abfd)->h.first_byte =
1623     (unsigned char *) bfd_alloc (ieee->h.abfd, ieee->w.r.me_record + 1);
1624   if (!IEEE_DATA (abfd)->h.first_byte)
1625     goto fail;
1626   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
1627     goto fail;
1628   /* FIXME: Check return value.  I'm not sure whether it needs to read
1629      the entire buffer or not.  */
1630   bfd_read ((PTR) (IEEE_DATA (abfd)->h.first_byte), 1,
1631             ieee->w.r.me_record + 1, abfd);
1632
1633   ieee_slurp_sections (abfd);
1634
1635   if (! ieee_slurp_debug (abfd))
1636     goto fail;
1637
1638   /* Parse section data to activate file and section flags implied by
1639      section contents. */
1640
1641   if (! ieee_slurp_section_data (abfd))
1642     goto fail;
1643
1644   return abfd->xvec;
1645 got_wrong_format:
1646   bfd_set_error (bfd_error_wrong_format);
1647 fail:
1648   (void) bfd_release (abfd, ieee);
1649   abfd->tdata.ieee_data = save;
1650   return (const bfd_target *) NULL;
1651 }
1652
1653 void
1654 ieee_get_symbol_info (ignore_abfd, symbol, ret)
1655      bfd *ignore_abfd ATTRIBUTE_UNUSED;
1656      asymbol *symbol;
1657      symbol_info *ret;
1658 {
1659   bfd_symbol_info (symbol, ret);
1660   if (symbol->name[0] == ' ')
1661     ret->name = "* empty table entry ";
1662   if (!symbol->section)
1663     ret->type = (symbol->flags & BSF_LOCAL) ? 'a' : 'A';
1664 }
1665
1666 void
1667 ieee_print_symbol (ignore_abfd, afile, symbol, how)
1668      bfd *ignore_abfd ATTRIBUTE_UNUSED;
1669      PTR afile;
1670      asymbol *symbol;
1671      bfd_print_symbol_type how;
1672 {
1673   FILE *file = (FILE *) afile;
1674
1675   switch (how)
1676     {
1677     case bfd_print_symbol_name:
1678       fprintf (file, "%s", symbol->name);
1679       break;
1680     case bfd_print_symbol_more:
1681 #if 0
1682       fprintf (file, "%4x %2x", aout_symbol (symbol)->desc & 0xffff,
1683                aout_symbol (symbol)->other & 0xff);
1684 #endif
1685       BFD_FAIL ();
1686       break;
1687     case bfd_print_symbol_all:
1688       {
1689         const char *section_name =
1690           (symbol->section == (asection *) NULL
1691            ? "*abs"
1692            : symbol->section->name);
1693         if (symbol->name[0] == ' ')
1694           {
1695             fprintf (file, "* empty table entry ");
1696           }
1697         else
1698           {
1699             bfd_print_symbol_vandf ((PTR) file, symbol);
1700
1701             fprintf (file, " %-5s %04x %02x %s",
1702                      section_name,
1703                      (unsigned) ieee_symbol (symbol)->index,
1704                      (unsigned) 0,
1705                      symbol->name);
1706           }
1707       }
1708       break;
1709     }
1710 }
1711
1712 static boolean
1713 do_one (ieee, current_map, location_ptr, s, iterations)
1714      ieee_data_type *ieee;
1715      ieee_per_section_type *current_map;
1716      unsigned char *location_ptr;
1717      asection *s;
1718      int iterations;
1719 {
1720   switch (this_byte (&(ieee->h)))
1721     {
1722     case ieee_load_constant_bytes_enum:
1723       {
1724         unsigned int number_of_maus;
1725         unsigned int i;
1726         next_byte (&(ieee->h));
1727         number_of_maus = must_parse_int (&(ieee->h));
1728
1729         for (i = 0; i < number_of_maus; i++)
1730           {
1731             location_ptr[current_map->pc++] = this_byte (&(ieee->h));
1732             next_byte (&(ieee->h));
1733           }
1734       }
1735       break;
1736
1737     case ieee_load_with_relocation_enum:
1738       {
1739         boolean loop = true;
1740         next_byte (&(ieee->h));
1741         while (loop)
1742           {
1743             switch (this_byte (&(ieee->h)))
1744               {
1745               case ieee_variable_R_enum:
1746
1747               case ieee_function_signed_open_b_enum:
1748               case ieee_function_unsigned_open_b_enum:
1749               case ieee_function_either_open_b_enum:
1750                 {
1751                   unsigned int extra = 4;
1752                   boolean pcrel = false;
1753                   asection *section;
1754                   ieee_reloc_type *r =
1755                   (ieee_reloc_type *) bfd_alloc (ieee->h.abfd,
1756                                                  sizeof (ieee_reloc_type));
1757                   if (!r)
1758                     return false;
1759
1760                   *(current_map->reloc_tail_ptr) = r;
1761                   current_map->reloc_tail_ptr = &r->next;
1762                   r->next = (ieee_reloc_type *) NULL;
1763                   next_byte (&(ieee->h));
1764 /*                          abort();*/
1765                   r->relent.sym_ptr_ptr = 0;
1766                   parse_expression (ieee,
1767                                     &r->relent.addend,
1768                                     &r->symbol,
1769                                     &pcrel, &extra, &section);
1770                   r->relent.address = current_map->pc;
1771                   s->flags |= SEC_RELOC;
1772                   s->owner->flags |= HAS_RELOC;
1773                   s->reloc_count++;
1774                   if (r->relent.sym_ptr_ptr == NULL && section != NULL)
1775                     r->relent.sym_ptr_ptr = section->symbol_ptr_ptr;
1776
1777                   if (this_byte (&(ieee->h)) == (int) ieee_comma)
1778                     {
1779                       next_byte (&(ieee->h));
1780                       /* Fetch number of bytes to pad */
1781                       extra = must_parse_int (&(ieee->h));
1782                     };
1783
1784                   switch (this_byte (&(ieee->h)))
1785                     {
1786                     case ieee_function_signed_close_b_enum:
1787                       next_byte (&(ieee->h));
1788                       break;
1789                     case ieee_function_unsigned_close_b_enum:
1790                       next_byte (&(ieee->h));
1791                       break;
1792                     case ieee_function_either_close_b_enum:
1793                       next_byte (&(ieee->h));
1794                       break;
1795                     default:
1796                       break;
1797                     }
1798                   /* Build a relocation entry for this type */
1799                   /* If pc rel then stick -ve pc into instruction
1800                      and take out of reloc ..
1801
1802                      I've changed this. It's all too complicated. I
1803                      keep 0 in the instruction now.  */
1804
1805                   switch (extra)
1806                     {
1807                     case 0:
1808                     case 4:
1809
1810                       if (pcrel == true)
1811                         {
1812 #if KEEPMINUSPCININST
1813                           bfd_put_32 (ieee->h.abfd, -current_map->pc, location_ptr +
1814                                       current_map->pc);
1815                           r->relent.howto = &rel32_howto;
1816                           r->relent.addend -=
1817                             current_map->pc;
1818 #else
1819                           bfd_put_32 (ieee->h.abfd, 0, location_ptr +
1820                                       current_map->pc);
1821                           r->relent.howto = &rel32_howto;
1822 #endif
1823                         }
1824                       else
1825                         {
1826                           bfd_put_32 (ieee->h.abfd, 0, location_ptr +
1827                                       current_map->pc);
1828                           r->relent.howto = &abs32_howto;
1829                         }
1830                       current_map->pc += 4;
1831                       break;
1832                     case 2:
1833                       if (pcrel == true)
1834                         {
1835 #if KEEPMINUSPCININST
1836                           bfd_put_16 (ieee->h.abfd, (int) (-current_map->pc), location_ptr + current_map->pc);
1837                           r->relent.addend -= current_map->pc;
1838                           r->relent.howto = &rel16_howto;
1839 #else
1840
1841                           bfd_put_16 (ieee->h.abfd, 0, location_ptr + current_map->pc);
1842                           r->relent.howto = &rel16_howto;
1843 #endif
1844                         }
1845
1846                       else
1847                         {
1848                           bfd_put_16 (ieee->h.abfd, 0, location_ptr + current_map->pc);
1849                           r->relent.howto = &abs16_howto;
1850                         }
1851                       current_map->pc += 2;
1852                       break;
1853                     case 1:
1854                       if (pcrel == true)
1855                         {
1856 #if KEEPMINUSPCININST
1857                           bfd_put_8 (ieee->h.abfd, (int) (-current_map->pc), location_ptr + current_map->pc);
1858                           r->relent.addend -= current_map->pc;
1859                           r->relent.howto = &rel8_howto;
1860 #else
1861                           bfd_put_8 (ieee->h.abfd, 0, location_ptr + current_map->pc);
1862                           r->relent.howto = &rel8_howto;
1863 #endif
1864                         }
1865                       else
1866                         {
1867                           bfd_put_8 (ieee->h.abfd, 0, location_ptr + current_map->pc);
1868                           r->relent.howto = &abs8_howto;
1869                         }
1870                       current_map->pc += 1;
1871                       break;
1872
1873                     default:
1874                       BFD_FAIL ();
1875                       return false;
1876                     }
1877                 }
1878                 break;
1879               default:
1880                 {
1881                   bfd_vma this_size;
1882                   if (parse_int (&(ieee->h), &this_size) == true)
1883                     {
1884                       unsigned int i;
1885                       for (i = 0; i < this_size; i++)
1886                         {
1887                           location_ptr[current_map->pc++] = this_byte (&(ieee->h));
1888                           next_byte (&(ieee->h));
1889                         }
1890                     }
1891                   else
1892                     {
1893                       loop = false;
1894                     }
1895                 }
1896               }
1897
1898             /* Prevent more than the first load-item of an LR record
1899                from being repeated (MRI convention). */
1900             if (iterations != 1)
1901               loop = false;
1902           }
1903       }
1904     }
1905   return true;
1906 }
1907
1908 /* Read in all the section data and relocation stuff too */
1909 static boolean
1910 ieee_slurp_section_data (abfd)
1911      bfd *abfd;
1912 {
1913   bfd_byte *location_ptr = (bfd_byte *) NULL;
1914   ieee_data_type *ieee = IEEE_DATA (abfd);
1915   unsigned int section_number;
1916
1917   ieee_per_section_type *current_map = (ieee_per_section_type *) NULL;
1918   asection *s;
1919   /* Seek to the start of the data area */
1920   if (ieee->read_data == true)
1921     return true;
1922   ieee->read_data = true;
1923   ieee_seek (abfd, ieee->w.r.data_part);
1924
1925   /* Allocate enough space for all the section contents */
1926
1927   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1928     {
1929       ieee_per_section_type *per = (ieee_per_section_type *) s->used_by_bfd;
1930       if ((s->flags & SEC_DEBUGGING) != 0)
1931         continue;
1932       per->data = (bfd_byte *) bfd_alloc (ieee->h.abfd, s->_raw_size);
1933       if (!per->data)
1934         return false;
1935       /*SUPPRESS 68*/
1936       per->reloc_tail_ptr =
1937         (ieee_reloc_type **) & (s->relocation);
1938     }
1939
1940   while (true)
1941     {
1942       switch (this_byte (&(ieee->h)))
1943         {
1944           /* IF we see anything strange then quit */
1945         default:
1946           return true;
1947
1948         case ieee_set_current_section_enum:
1949           next_byte (&(ieee->h));
1950           section_number = must_parse_int (&(ieee->h));
1951           s = ieee->section_table[section_number];
1952           s->flags |= SEC_LOAD | SEC_HAS_CONTENTS;
1953           current_map = (ieee_per_section_type *) s->used_by_bfd;
1954           location_ptr = current_map->data - s->vma;
1955           /* The document I have says that Microtec's compilers reset */
1956           /* this after a sec section, even though the standard says not */
1957           /* to. SO .. */
1958           current_map->pc = s->vma;
1959           break;
1960
1961         case ieee_e2_first_byte_enum:
1962           next_byte (&(ieee->h));
1963           switch (this_byte (&(ieee->h)))
1964             {
1965             case ieee_set_current_pc_enum & 0xff:
1966               {
1967                 bfd_vma value;
1968                 ieee_symbol_index_type symbol;
1969                 unsigned int extra;
1970                 boolean pcrel;
1971                 next_byte (&(ieee->h));
1972                 must_parse_int (&(ieee->h));    /* Thow away section #*/
1973                 parse_expression (ieee, &value,
1974                                   &symbol,
1975                                   &pcrel, &extra,
1976                                   0);
1977                 current_map->pc = value;
1978                 BFD_ASSERT ((unsigned) (value - s->vma) <= s->_raw_size);
1979               }
1980               break;
1981
1982             case ieee_value_starting_address_enum & 0xff:
1983               next_byte (&(ieee->h));
1984               if (this_byte (&(ieee->h)) == ieee_function_either_open_b_enum)
1985                 next_byte (&(ieee->h));
1986               abfd->start_address = must_parse_int (&(ieee->h));
1987               /* We've got to the end of the data now - */
1988               return true;
1989             default:
1990               BFD_FAIL ();
1991               return false;
1992             }
1993           break;
1994         case ieee_repeat_data_enum:
1995           {
1996             /* Repeat the following LD or LR n times - we do this by
1997                  remembering the stream pointer before running it and
1998                  resetting it and running it n times. We special case
1999                  the repetition of a repeat_data/load_constant
2000                  */
2001
2002             unsigned int iterations;
2003             unsigned char *start;
2004             next_byte (&(ieee->h));
2005             iterations = must_parse_int (&(ieee->h));
2006             start = ieee->h.input_p;
2007             if (start[0] == (int) ieee_load_constant_bytes_enum &&
2008                 start[1] == 1)
2009               {
2010                 while (iterations != 0)
2011                   {
2012                     location_ptr[current_map->pc++] = start[2];
2013                     iterations--;
2014                   }
2015                 next_byte (&(ieee->h));
2016                 next_byte (&(ieee->h));
2017                 next_byte (&(ieee->h));
2018               }
2019             else
2020               {
2021                 while (iterations != 0)
2022                   {
2023                     ieee->h.input_p = start;
2024                     if (!do_one (ieee, current_map, location_ptr, s,
2025                                  iterations))
2026                       return false;
2027                     iterations--;
2028                   }
2029               }
2030           }
2031           break;
2032         case ieee_load_constant_bytes_enum:
2033         case ieee_load_with_relocation_enum:
2034           {
2035             if (!do_one (ieee, current_map, location_ptr, s, 1))
2036               return false;
2037           }
2038         }
2039     }
2040 }
2041
2042 boolean
2043 ieee_new_section_hook (abfd, newsect)
2044      bfd *abfd;
2045      asection *newsect;
2046 {
2047   newsect->used_by_bfd = (PTR)
2048     bfd_alloc (abfd, sizeof (ieee_per_section_type));
2049   if (!newsect->used_by_bfd)
2050     return false;
2051   ieee_per_section (newsect)->data = (bfd_byte *) NULL;
2052   ieee_per_section (newsect)->section = newsect;
2053   return true;
2054 }
2055
2056 long
2057 ieee_get_reloc_upper_bound (abfd, asect)
2058      bfd *abfd;
2059      sec_ptr asect;
2060 {
2061   if ((asect->flags & SEC_DEBUGGING) != 0)
2062     return 0;
2063   if (! ieee_slurp_section_data (abfd))
2064     return -1;
2065   return (asect->reloc_count + 1) * sizeof (arelent *);
2066 }
2067
2068 static boolean
2069 ieee_get_section_contents (abfd, section, location, offset, count)
2070      bfd *abfd;
2071      sec_ptr section;
2072      PTR location;
2073      file_ptr offset;
2074      bfd_size_type count;
2075 {
2076   ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;
2077   if ((section->flags & SEC_DEBUGGING) != 0)
2078     return _bfd_generic_get_section_contents (abfd, section, location,
2079                                               offset, count);
2080   ieee_slurp_section_data (abfd);
2081   (void) memcpy ((PTR) location, (PTR) (p->data + offset), (unsigned) count);
2082   return true;
2083 }
2084
2085 long
2086 ieee_canonicalize_reloc (abfd, section, relptr, symbols)
2087      bfd *abfd;
2088      sec_ptr section;
2089      arelent **relptr;
2090      asymbol **symbols;
2091 {
2092 /*  ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;*/
2093   ieee_reloc_type *src = (ieee_reloc_type *) (section->relocation);
2094   ieee_data_type *ieee = IEEE_DATA (abfd);
2095
2096   if ((section->flags & SEC_DEBUGGING) != 0)
2097     return 0;
2098
2099   while (src != (ieee_reloc_type *) NULL)
2100     {
2101       /* Work out which symbol to attach it this reloc to */
2102       switch (src->symbol.letter)
2103         {
2104         case 'I':
2105           src->relent.sym_ptr_ptr =
2106             symbols + src->symbol.index + ieee->external_symbol_base_offset;
2107           break;
2108         case 'X':
2109           src->relent.sym_ptr_ptr =
2110             symbols + src->symbol.index + ieee->external_reference_base_offset;
2111           break;
2112         case 0:
2113           if (src->relent.sym_ptr_ptr != NULL)
2114             src->relent.sym_ptr_ptr =
2115               src->relent.sym_ptr_ptr[0]->section->symbol_ptr_ptr;
2116           break;
2117         default:
2118
2119           BFD_FAIL ();
2120         }
2121       *relptr++ = &src->relent;
2122       src = src->next;
2123     }
2124   *relptr = (arelent *) NULL;
2125   return section->reloc_count;
2126 }
2127
2128 static int
2129 comp (ap, bp)
2130      CONST PTR ap;
2131      CONST PTR bp;
2132 {
2133   arelent *a = *((arelent **) ap);
2134   arelent *b = *((arelent **) bp);
2135   return a->address - b->address;
2136 }
2137
2138 /* Write the section headers.  */
2139
2140 static boolean
2141 ieee_write_section_part (abfd)
2142      bfd *abfd;
2143 {
2144   ieee_data_type *ieee = IEEE_DATA (abfd);
2145   asection *s;
2146   ieee->w.r.section_part = bfd_tell (abfd);
2147   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
2148     {
2149       if (! bfd_is_abs_section (s)
2150           && (s->flags & SEC_DEBUGGING) == 0)
2151         {
2152           if (! ieee_write_byte (abfd, ieee_section_type_enum)
2153               || ! ieee_write_byte (abfd,
2154                                     (bfd_byte) (s->index
2155                                                 + IEEE_SECTION_NUMBER_BASE)))
2156             return false;
2157
2158           if (abfd->flags & EXEC_P)
2159             {
2160               /* This image is executable, so output absolute sections */
2161               if (! ieee_write_byte (abfd, ieee_variable_A_enum)
2162                   || ! ieee_write_byte (abfd, ieee_variable_S_enum))
2163                 return false;
2164             }
2165           else
2166             {
2167               if (! ieee_write_byte (abfd, ieee_variable_C_enum))
2168                 return false;
2169             }
2170
2171           switch (s->flags & (SEC_CODE | SEC_DATA | SEC_ROM))
2172             {
2173             case SEC_CODE | SEC_LOAD:
2174             case SEC_CODE:
2175               if (! ieee_write_byte (abfd, ieee_variable_P_enum))
2176                 return false;
2177               break;
2178             case SEC_DATA:
2179             default:
2180               if (! ieee_write_byte (abfd, ieee_variable_D_enum))
2181                 return false;
2182               break;
2183             case SEC_ROM:
2184             case SEC_ROM | SEC_DATA:
2185             case SEC_ROM | SEC_LOAD:
2186             case SEC_ROM | SEC_DATA | SEC_LOAD:
2187               if (! ieee_write_byte (abfd, ieee_variable_R_enum))
2188                 return false;
2189             }
2190
2191
2192           if (! ieee_write_id (abfd, s->name))
2193             return false;
2194 #if 0
2195           ieee_write_int (abfd, 0);     /* Parent */
2196           ieee_write_int (abfd, 0);     /* Brother */
2197           ieee_write_int (abfd, 0);     /* Context */
2198 #endif
2199           /* Alignment */
2200           if (! ieee_write_byte (abfd, ieee_section_alignment_enum)
2201               || ! ieee_write_byte (abfd,
2202                                     (bfd_byte) (s->index
2203                                                 + IEEE_SECTION_NUMBER_BASE))
2204               || ! ieee_write_int (abfd, 1 << s->alignment_power))
2205             return false;
2206
2207           /* Size */
2208           if (! ieee_write_2bytes (abfd, ieee_section_size_enum)
2209               || ! ieee_write_byte (abfd,
2210                                     (bfd_byte) (s->index
2211                                                 + IEEE_SECTION_NUMBER_BASE))
2212               || ! ieee_write_int (abfd, s->_raw_size))
2213             return false;
2214           if (abfd->flags & EXEC_P)
2215             {
2216               /* Relocateable sections don't have asl records */
2217               /* Vma */
2218               if (! ieee_write_2bytes (abfd, ieee_section_base_address_enum)
2219                   || ! ieee_write_byte (abfd,
2220                                         ((bfd_byte)
2221                                          (s->index
2222                                           + IEEE_SECTION_NUMBER_BASE)))
2223                   || ! ieee_write_int (abfd, s->lma))
2224                 return false;
2225             }
2226         }
2227     }
2228
2229   return true;
2230 }
2231
2232
2233 static boolean
2234 do_with_relocs (abfd, s)
2235      bfd *abfd;
2236      asection *s;
2237 {
2238   unsigned int number_of_maus_in_address =
2239     bfd_arch_bits_per_address (abfd) / bfd_arch_bits_per_byte (abfd);
2240   unsigned int relocs_to_go = s->reloc_count;
2241   bfd_byte *stream = ieee_per_section (s)->data;
2242   arelent **p = s->orelocation;
2243   bfd_size_type current_byte_index = 0;
2244
2245   qsort (s->orelocation,
2246          relocs_to_go,
2247          sizeof (arelent **),
2248          comp);
2249
2250   /* Output the section preheader */
2251   if (! ieee_write_byte (abfd, ieee_set_current_section_enum)
2252       || ! ieee_write_byte (abfd,
2253                             (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE))
2254       || ! ieee_write_2bytes (abfd, ieee_set_current_pc_enum)
2255       || ! ieee_write_byte (abfd,
2256                             (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE)))
2257     return false;
2258   if ((abfd->flags & EXEC_P) != 0 && relocs_to_go == 0)
2259     {
2260       if (! ieee_write_int (abfd, s->lma))
2261         return false;
2262     }
2263   else
2264     {
2265       if (! ieee_write_expression (abfd, 0, s->symbol, 0, 0))
2266         return false;
2267     }
2268
2269   if (relocs_to_go == 0)
2270     {
2271       /* If there aren't any relocations then output the load constant
2272          byte opcode rather than the load with relocation opcode */
2273
2274       while (current_byte_index < s->_raw_size)
2275         {
2276           bfd_size_type run;
2277           unsigned int MAXRUN = 127;
2278           run = MAXRUN;
2279           if (run > s->_raw_size - current_byte_index)
2280             {
2281               run = s->_raw_size - current_byte_index;
2282             }
2283
2284           if (run != 0)
2285             {
2286               if (! ieee_write_byte (abfd, ieee_load_constant_bytes_enum))
2287                 return false;
2288               /* Output a stream of bytes */
2289               if (! ieee_write_int (abfd, run))
2290                 return false;
2291               if (bfd_write ((PTR) (stream + current_byte_index),
2292                              1,
2293                              run,
2294                              abfd)
2295                   != run)
2296                 return false;
2297               current_byte_index += run;
2298             }
2299         }
2300     }
2301   else
2302     {
2303       if (! ieee_write_byte (abfd, ieee_load_with_relocation_enum))
2304         return false;
2305
2306       /* Output the data stream as the longest sequence of bytes
2307          possible, allowing for the a reasonable packet size and
2308          relocation stuffs.  */
2309
2310       if ((PTR) stream == (PTR) NULL)
2311         {
2312           /* Outputting a section without data, fill it up */
2313           stream = (unsigned char *) (bfd_alloc (abfd, s->_raw_size));
2314           if (!stream)
2315             return false;
2316           memset ((PTR) stream, 0, (size_t) s->_raw_size);
2317         }
2318       while (current_byte_index < s->_raw_size)
2319         {
2320           bfd_size_type run;
2321           unsigned int MAXRUN = 127;
2322           if (relocs_to_go)
2323             {
2324               run = (*p)->address - current_byte_index;
2325               if (run > MAXRUN)
2326                 run = MAXRUN;
2327             }
2328           else
2329             {
2330               run = MAXRUN;
2331             }
2332           if (run > s->_raw_size - current_byte_index)
2333             {
2334               run = s->_raw_size - current_byte_index;
2335             }
2336
2337           if (run != 0)
2338             {
2339               /* Output a stream of bytes */
2340               if (! ieee_write_int (abfd, run))
2341                 return false;
2342               if (bfd_write ((PTR) (stream + current_byte_index),
2343                              1,
2344                              run,
2345                              abfd)
2346                   != run)
2347                 return false;
2348               current_byte_index += run;
2349             }
2350           /* Output any relocations here */
2351           if (relocs_to_go && (*p) && (*p)->address == current_byte_index)
2352             {
2353               while (relocs_to_go
2354                      && (*p) && (*p)->address == current_byte_index)
2355                 {
2356                   arelent *r = *p;
2357                   bfd_signed_vma ov;
2358
2359 #if 0
2360                   if (r->howto->pc_relative)
2361                     {
2362                       r->addend += current_byte_index;
2363                     }
2364 #endif
2365
2366                   switch (r->howto->size)
2367                     {
2368                     case 2:
2369
2370                       ov = bfd_get_signed_32 (abfd,
2371                                               stream + current_byte_index);
2372                       current_byte_index += 4;
2373                       break;
2374                     case 1:
2375                       ov = bfd_get_signed_16 (abfd,
2376                                               stream + current_byte_index);
2377                       current_byte_index += 2;
2378                       break;
2379                     case 0:
2380                       ov = bfd_get_signed_8 (abfd,
2381                                              stream + current_byte_index);
2382                       current_byte_index++;
2383                       break;
2384                     default:
2385                       ov = 0;
2386                       BFD_FAIL ();
2387                       return false;
2388                     }
2389
2390                   ov &= r->howto->src_mask;
2391
2392                   if (r->howto->pc_relative
2393                       && ! r->howto->pcrel_offset)
2394                     ov += r->address;
2395
2396                   if (! ieee_write_byte (abfd,
2397                                          ieee_function_either_open_b_enum))
2398                     return false;
2399
2400 /*                abort();*/
2401
2402                   if (r->sym_ptr_ptr != (asymbol **) NULL)
2403                     {
2404                       if (! ieee_write_expression (abfd, r->addend + ov,
2405                                                    *(r->sym_ptr_ptr),
2406                                                    r->howto->pc_relative,
2407                                                    s->index))
2408                         return false;
2409                     }
2410                   else
2411                     {
2412                       if (! ieee_write_expression (abfd, r->addend + ov,
2413                                                    (asymbol *) NULL,
2414                                                    r->howto->pc_relative,
2415                                                    s->index))
2416                         return false;
2417                     }
2418
2419                   if (number_of_maus_in_address
2420                       != bfd_get_reloc_size (r->howto))
2421                     {
2422                       if (! ieee_write_int (abfd,
2423                                             bfd_get_reloc_size (r->howto)))
2424                         return false;
2425                     }
2426                   if (! ieee_write_byte (abfd,
2427                                          ieee_function_either_close_b_enum))
2428                     return false;
2429
2430                   relocs_to_go--;
2431                   p++;
2432                 }
2433
2434             }
2435         }
2436     }
2437
2438   return true;
2439 }
2440
2441 /* If there are no relocations in the output section then we can be
2442    clever about how we write.  We block items up into a max of 127
2443    bytes.  */
2444
2445 static boolean
2446 do_as_repeat (abfd, s)
2447      bfd *abfd;
2448      asection *s;
2449 {
2450   if (s->_raw_size)
2451     {
2452       if (! ieee_write_byte (abfd, ieee_set_current_section_enum)
2453           || ! ieee_write_byte (abfd,
2454                                 (bfd_byte) (s->index
2455                                             + IEEE_SECTION_NUMBER_BASE))
2456           || ! ieee_write_byte (abfd, ieee_set_current_pc_enum >> 8)
2457           || ! ieee_write_byte (abfd, ieee_set_current_pc_enum & 0xff)
2458           || ! ieee_write_byte (abfd,
2459                                 (bfd_byte) (s->index
2460                                             + IEEE_SECTION_NUMBER_BASE))
2461           || ! ieee_write_int (abfd, s->lma)
2462           || ! ieee_write_byte (abfd, ieee_repeat_data_enum)
2463           || ! ieee_write_int (abfd, s->_raw_size)
2464           || ! ieee_write_byte (abfd, ieee_load_constant_bytes_enum)
2465           || ! ieee_write_byte (abfd, 1)
2466           || ! ieee_write_byte (abfd, 0))
2467         return false;
2468     }
2469
2470   return true;
2471 }
2472
2473 static boolean
2474 do_without_relocs (abfd, s)
2475      bfd *abfd;
2476      asection *s;
2477 {
2478   bfd_byte *stream = ieee_per_section (s)->data;
2479
2480   if (stream == 0 || ((s->flags & SEC_LOAD) == 0))
2481     {
2482       if (! do_as_repeat (abfd, s))
2483         return false;
2484     }
2485   else
2486     {
2487       unsigned int i;
2488       for (i = 0; i < s->_raw_size; i++)
2489         {
2490           if (stream[i] != 0)
2491             {
2492               if (! do_with_relocs (abfd, s))
2493                 return false;
2494               return true;
2495             }
2496         }
2497       if (! do_as_repeat (abfd, s))
2498         return false;
2499     }
2500
2501   return true;
2502 }
2503
2504
2505 static unsigned char *output_ptr_start;
2506 static unsigned char *output_ptr;
2507 static unsigned char *output_ptr_end;
2508 static unsigned char *input_ptr_start;
2509 static unsigned char *input_ptr;
2510 static unsigned char *input_ptr_end;
2511 static bfd *input_bfd;
2512 static bfd *output_bfd;
2513 static int output_buffer;
2514
2515 static void
2516 fill ()
2517 {
2518   /* FIXME: Check return value.  I'm not sure whether it needs to read
2519      the entire buffer or not.  */
2520   bfd_read ((PTR) input_ptr_start, 1, input_ptr_end - input_ptr_start, input_bfd);
2521   input_ptr = input_ptr_start;
2522 }
2523 static void
2524 flush ()
2525 {
2526   if (bfd_write ((PTR) (output_ptr_start), 1, output_ptr - output_ptr_start,
2527                  output_bfd)
2528       != (bfd_size_type) (output_ptr - output_ptr_start))
2529     abort ();
2530   output_ptr = output_ptr_start;
2531   output_buffer++;
2532 }
2533
2534 #define THIS() ( *input_ptr )
2535 #define NEXT() { input_ptr++; if (input_ptr == input_ptr_end) fill(); }
2536 #define OUT(x) { *output_ptr++ = (x); if(output_ptr == output_ptr_end)  flush(); }
2537
2538 static void
2539 write_int (value)
2540      int value;
2541 {
2542   if (value >= 0 && value <= 127)
2543     {
2544       OUT (value);
2545     }
2546   else
2547     {
2548       unsigned int length;
2549       /* How many significant bytes ? */
2550       /* FIXME FOR LONGER INTS */
2551       if (value & 0xff000000)
2552         {
2553           length = 4;
2554         }
2555       else if (value & 0x00ff0000)
2556         {
2557           length = 3;
2558         }
2559       else if (value & 0x0000ff00)
2560         {
2561           length = 2;
2562         }
2563       else
2564         length = 1;
2565
2566       OUT ((int) ieee_number_repeat_start_enum + length);
2567       switch (length)
2568         {
2569         case 4:
2570           OUT (value >> 24);
2571         case 3:
2572           OUT (value >> 16);
2573         case 2:
2574           OUT (value >> 8);
2575         case 1:
2576           OUT (value);
2577         }
2578
2579     }
2580 }
2581
2582 static void
2583 copy_id ()
2584 {
2585   int length = THIS ();
2586   char ch;
2587   OUT (length);
2588   NEXT ();
2589   while (length--)
2590     {
2591       ch = THIS ();
2592       OUT (ch);
2593       NEXT ();
2594     }
2595 }
2596
2597 #define VAR(x) ((x | 0x80))
2598 static void
2599 copy_expression ()
2600 {
2601   int stack[10];
2602   int *tos = stack;
2603   int value = 0;
2604   while (1)
2605     {
2606       switch (THIS ())
2607         {
2608         case 0x84:
2609           NEXT ();
2610           value = THIS ();
2611           NEXT ();
2612           value = (value << 8) | THIS ();
2613           NEXT ();
2614           value = (value << 8) | THIS ();
2615           NEXT ();
2616           value = (value << 8) | THIS ();
2617           NEXT ();
2618           *tos++ = value;
2619           break;
2620         case 0x83:
2621           NEXT ();
2622           value = THIS ();
2623           NEXT ();
2624           value = (value << 8) | THIS ();
2625           NEXT ();
2626           value = (value << 8) | THIS ();
2627           NEXT ();
2628           *tos++ = value;
2629           break;
2630         case 0x82:
2631           NEXT ();
2632           value = THIS ();
2633           NEXT ();
2634           value = (value << 8) | THIS ();
2635           NEXT ();
2636           *tos++ = value;
2637           break;
2638         case 0x81:
2639           NEXT ();
2640           value = THIS ();
2641           NEXT ();
2642           *tos++ = value;
2643           break;
2644         case 0x80:
2645           NEXT ();
2646           *tos++ = 0;
2647           break;
2648         default:
2649           if (THIS () > 0x84)
2650             {
2651               /* Not a number, just bug out with the answer */
2652               write_int (*(--tos));
2653               return;
2654             }
2655           *tos++ = THIS ();
2656           NEXT ();
2657           value = 0;
2658           break;
2659         case 0xa5:
2660           /* PLUS anything */
2661           {
2662             int value = *(--tos);
2663             value += *(--tos);
2664             *tos++ = value;
2665             NEXT ();
2666           }
2667           break;
2668         case VAR ('R'):
2669           {
2670             int section_number;
2671             ieee_data_type *ieee;
2672             asection *s;
2673             NEXT ();
2674             section_number = THIS ();
2675
2676             NEXT ();
2677             ieee = IEEE_DATA (input_bfd);
2678             s = ieee->section_table[section_number];
2679             if (s->output_section)
2680               {
2681                 value = s->output_section->lma;
2682               }
2683             else
2684               {
2685                 value = 0;
2686               }
2687             value += s->output_offset;
2688             *tos++ = value;
2689             value = 0;
2690           }
2691           break;
2692         case 0x90:
2693           {
2694             NEXT ();
2695             write_int (*(--tos));
2696             OUT (0x90);
2697             return;
2698
2699           }
2700         }
2701     }
2702
2703 }
2704
2705 /* Drop the int in the buffer, and copy a null into the gap, which we
2706    will overwrite later */
2707
2708 struct output_buffer_struct
2709 {
2710   unsigned char *ptrp;
2711   int buffer;
2712 };
2713
2714 static void
2715 fill_int (buf)
2716      struct output_buffer_struct *buf;
2717 {
2718   if (buf->buffer == output_buffer)
2719     {
2720       /* Still a chance to output the size */
2721       int value = output_ptr - buf->ptrp + 3;
2722       buf->ptrp[0] = value >> 24;
2723       buf->ptrp[1] = value >> 16;
2724       buf->ptrp[2] = value >> 8;
2725       buf->ptrp[3] = value >> 0;
2726     }
2727 }
2728
2729 static void
2730 drop_int (buf)
2731      struct output_buffer_struct *buf;
2732 {
2733   int type = THIS ();
2734   int ch;
2735   if (type <= 0x84)
2736     {
2737       NEXT ();
2738       switch (type)
2739         {
2740         case 0x84:
2741           ch = THIS ();
2742           NEXT ();
2743         case 0x83:
2744           ch = THIS ();
2745           NEXT ();
2746         case 0x82:
2747           ch = THIS ();
2748           NEXT ();
2749         case 0x81:
2750           ch = THIS ();
2751           NEXT ();
2752         case 0x80:
2753           break;
2754         }
2755     }
2756   OUT (0x84);
2757   buf->ptrp = output_ptr;
2758   buf->buffer = output_buffer;
2759   OUT (0);
2760   OUT (0);
2761   OUT (0);
2762   OUT (0);
2763 }
2764
2765 static void
2766 copy_int ()
2767 {
2768   int type = THIS ();
2769   int ch;
2770   if (type <= 0x84)
2771     {
2772       OUT (type);
2773       NEXT ();
2774       switch (type)
2775         {
2776         case 0x84:
2777           ch = THIS ();
2778           NEXT ();
2779           OUT (ch);
2780         case 0x83:
2781           ch = THIS ();
2782           NEXT ();
2783           OUT (ch);
2784         case 0x82:
2785           ch = THIS ();
2786           NEXT ();
2787           OUT (ch);
2788         case 0x81:
2789           ch = THIS ();
2790           NEXT ();
2791           OUT (ch);
2792         case 0x80:
2793           break;
2794         }
2795     }
2796 }
2797
2798 #define ID copy_id()
2799 #define INT copy_int()
2800 #define EXP copy_expression()
2801 static void copy_till_end ();
2802 #define INTn(q) copy_int()
2803 #define EXPn(q) copy_expression()
2804
2805 static void
2806 f1_record ()
2807 {
2808   int ch;
2809   /* ATN record */
2810   NEXT ();
2811   ch = THIS ();
2812   switch (ch)
2813     {
2814     default:
2815       OUT (0xf1);
2816       OUT (ch);
2817       break;
2818     case 0xc9:
2819       NEXT ();
2820       OUT (0xf1);
2821       OUT (0xc9);
2822       INT;
2823       INT;
2824       ch = THIS ();
2825       switch (ch)
2826         {
2827         case 0x16:
2828           NEXT ();
2829           break;
2830         case 0x01:
2831           NEXT ();
2832           break;
2833         case 0x00:
2834           NEXT ();
2835           INT;
2836           break;
2837         case 0x03:
2838           NEXT ();
2839           INT;
2840           break;
2841         case 0x13:
2842           EXPn (instruction address);
2843           break;
2844         default:
2845           break;
2846         }
2847       break;
2848     case 0xd8:
2849       /* EXternal ref */
2850       NEXT ();
2851       OUT (0xf1);
2852       OUT (0xd8);
2853       EXP;
2854       EXP;
2855       EXP;
2856       EXP;
2857       break;
2858     case 0xce:
2859       NEXT ();
2860       OUT (0xf1);
2861       OUT (0xce);
2862       INT;
2863       INT;
2864       ch = THIS ();
2865       INT;
2866       switch (ch)
2867         {
2868         case 0x01:
2869           INT;
2870           INT;
2871           break;
2872         case 0x02:
2873           INT;
2874           break;
2875         case 0x04:
2876           EXPn (external function);
2877           break;
2878         case 0x05:
2879           break;
2880         case 0x07:
2881           INTn (line number);
2882           INT;
2883         case 0x08:
2884           break;
2885         case 0x0a:
2886           INTn (locked register);
2887           INT;
2888           break;
2889         case 0x3f:
2890           copy_till_end ();
2891           break;
2892         case 0x3e:
2893           copy_till_end ();
2894           break;
2895         case 0x40:
2896           copy_till_end ();
2897           break;
2898         case 0x41:
2899           ID;
2900           break;
2901         }
2902     }
2903
2904 }
2905
2906 static void
2907 f0_record ()
2908 {
2909   /* Attribute record */
2910   NEXT ();
2911   OUT (0xf0);
2912   INTn (Symbol name);
2913   ID;
2914 }
2915
2916 static void
2917 copy_till_end ()
2918 {
2919   int ch = THIS ();
2920   while (1)
2921     {
2922       while (ch <= 0x80)
2923         {
2924           OUT (ch);
2925           NEXT ();
2926           ch = THIS ();
2927         }
2928       switch (ch)
2929         {
2930         case 0x84:
2931           OUT (THIS ());
2932           NEXT ();
2933         case 0x83:
2934           OUT (THIS ());
2935           NEXT ();
2936         case 0x82:
2937           OUT (THIS ());
2938           NEXT ();
2939         case 0x81:
2940           OUT (THIS ());
2941           NEXT ();
2942           OUT (THIS ());
2943           NEXT ();
2944
2945           ch = THIS ();
2946           break;
2947         default:
2948           return;
2949         }
2950     }
2951
2952 }
2953
2954 static void
2955 f2_record ()
2956 {
2957   NEXT ();
2958   OUT (0xf2);
2959   INT;
2960   NEXT ();
2961   OUT (0xce);
2962   INT;
2963   copy_till_end ();
2964 }
2965
2966
2967 static void block ();
2968 static void
2969 f8_record ()
2970 {
2971   int ch;
2972   NEXT ();
2973   ch = THIS ();
2974   switch (ch)
2975     {
2976     case 0x01:
2977     case 0x02:
2978     case 0x03:
2979       /* Unique typedefs for module */
2980       /* GLobal typedefs  */
2981       /* High level module scope beginning */
2982       {
2983         struct output_buffer_struct ob;
2984         NEXT ();
2985         OUT (0xf8);
2986         OUT (ch);
2987         drop_int (&ob);
2988         ID;
2989
2990         block ();
2991
2992         NEXT ();
2993         fill_int (&ob);
2994         OUT (0xf9);
2995       }
2996       break;
2997     case 0x04:
2998       /* Global function */
2999       {
3000         struct output_buffer_struct ob;
3001         NEXT ();
3002         OUT (0xf8);
3003         OUT (0x04);
3004         drop_int (&ob);
3005         ID;
3006         INTn (stack size);
3007         INTn (ret val);
3008         EXPn (offset);
3009
3010         block ();
3011
3012         NEXT ();
3013         OUT (0xf9);
3014         EXPn (size of block);
3015         fill_int (&ob);
3016       }
3017       break;
3018
3019     case 0x05:
3020       /* File name for source line numbers */
3021       {
3022         struct output_buffer_struct ob;
3023         NEXT ();
3024         OUT (0xf8);
3025         OUT (0x05);
3026         drop_int (&ob);
3027         ID;
3028         INTn (year);
3029         INTn (month);
3030         INTn (day);
3031         INTn (hour);
3032         INTn (monute);
3033         INTn (second);
3034         block ();
3035         NEXT ();
3036         OUT (0xf9);
3037         fill_int (&ob);
3038       }
3039       break;
3040
3041     case 0x06:
3042       /* Local function */
3043       {
3044         struct output_buffer_struct ob;
3045         NEXT ();
3046         OUT (0xf8);
3047         OUT (0x06);
3048         drop_int (&ob);
3049         ID;
3050         INTn (stack size);
3051         INTn (type return);
3052         EXPn (offset);
3053         block ();
3054         NEXT ();
3055         OUT (0xf9);
3056         EXPn (size);
3057         fill_int (&ob);
3058       }
3059       break;
3060
3061     case 0x0a:
3062       /* Assembler module scope beginning -*/
3063       {
3064         struct output_buffer_struct ob;
3065
3066         NEXT ();
3067         OUT (0xf8);
3068         OUT (0x0a);
3069         drop_int (&ob);
3070         ID;
3071         ID;
3072         INT;
3073         ID;
3074         INT;
3075         INT;
3076         INT;
3077         INT;
3078         INT;
3079         INT;
3080
3081         block ();
3082
3083         NEXT ();
3084         OUT (0xf9);
3085         fill_int (&ob);
3086       }
3087       break;
3088     case 0x0b:
3089       {
3090         struct output_buffer_struct ob;
3091         NEXT ();
3092         OUT (0xf8);
3093         OUT (0x0b);
3094         drop_int (&ob);
3095         ID;
3096         INT;
3097         INTn (section index);
3098         EXPn (offset);
3099         INTn (stuff);
3100
3101         block ();
3102
3103         OUT (0xf9);
3104         NEXT ();
3105         EXPn (Size in Maus);
3106         fill_int (&ob);
3107       }
3108       break;
3109     }
3110 }
3111
3112 static void
3113 e2_record ()
3114 {
3115   OUT (0xe2);
3116   NEXT ();
3117   OUT (0xce);
3118   NEXT ();
3119   INT;
3120   EXP;
3121 }
3122
3123 static void
3124 block ()
3125 {
3126   int ch;
3127   while (1)
3128     {
3129       ch = THIS ();
3130       switch (ch)
3131         {
3132         case 0xe1:
3133         case 0xe5:
3134           return;
3135         case 0xf9:
3136           return;
3137         case 0xf0:
3138           f0_record ();
3139           break;
3140         case 0xf1:
3141           f1_record ();
3142           break;
3143         case 0xf2:
3144           f2_record ();
3145           break;
3146         case 0xf8:
3147           f8_record ();
3148           break;
3149         case 0xe2:
3150           e2_record ();
3151           break;
3152
3153         }
3154     }
3155 }
3156
3157
3158
3159 /* relocate_debug,
3160    moves all the debug information from the source bfd to the output
3161    bfd, and relocates any expressions it finds
3162 */
3163
3164 static void
3165 relocate_debug (output, input)
3166      bfd *output ATTRIBUTE_UNUSED;
3167      bfd *input;
3168 {
3169 #define IBS 400
3170 #define OBS 400
3171   unsigned char input_buffer[IBS];
3172
3173   input_ptr_start = input_ptr = input_buffer;
3174   input_ptr_end = input_buffer + IBS;
3175   input_bfd = input;
3176   /* FIXME: Check return value.  I'm not sure whether it needs to read
3177      the entire buffer or not.  */
3178   bfd_read ((PTR) input_ptr_start, 1, IBS, input);
3179   block ();
3180 }
3181
3182 /*
3183   During linking, we we told about the bfds which made up our
3184   contents, we have a list of them. They will still be open, so go to
3185   the debug info in each, and copy it out, relocating it as we go.
3186 */
3187
3188 static boolean
3189 ieee_write_debug_part (abfd)
3190      bfd *abfd;
3191 {
3192   ieee_data_type *ieee = IEEE_DATA (abfd);
3193   bfd_chain_type *chain = ieee->chain_root;
3194   unsigned char output_buffer[OBS];
3195   boolean some_debug = false;
3196   file_ptr here = bfd_tell (abfd);
3197
3198   output_ptr_start = output_ptr = output_buffer;
3199   output_ptr_end = output_buffer + OBS;
3200   output_ptr = output_buffer;
3201   output_bfd = abfd;
3202
3203   if (chain == (bfd_chain_type *) NULL)
3204     {
3205       asection *s;
3206
3207       for (s = abfd->sections; s != NULL; s = s->next)
3208         if ((s->flags & SEC_DEBUGGING) != 0)
3209           break;
3210       if (s == NULL)
3211         {
3212           ieee->w.r.debug_information_part = 0;
3213           return true;
3214         }
3215
3216       ieee->w.r.debug_information_part = here;
3217       if (bfd_write (s->contents, 1, s->_raw_size, abfd) != s->_raw_size)
3218         return false;
3219     }
3220   else
3221     {
3222       while (chain != (bfd_chain_type *) NULL)
3223         {
3224           bfd *entry = chain->this;
3225           ieee_data_type *entry_ieee = IEEE_DATA (entry);
3226           if (entry_ieee->w.r.debug_information_part)
3227             {
3228               if (bfd_seek (entry, entry_ieee->w.r.debug_information_part,
3229                             SEEK_SET)
3230                   != 0)
3231                 return false;
3232               relocate_debug (abfd, entry);
3233             }
3234
3235           chain = chain->next;
3236         }
3237       if (some_debug)
3238         {
3239           ieee->w.r.debug_information_part = here;
3240         }
3241       else
3242         {
3243           ieee->w.r.debug_information_part = 0;
3244         }
3245
3246       flush ();
3247     }
3248
3249   return true;
3250 }
3251
3252 /* Write the data in an ieee way.  */
3253
3254 static boolean
3255 ieee_write_data_part (abfd)
3256      bfd *abfd;
3257 {
3258   asection *s;
3259   ieee_data_type *ieee = IEEE_DATA (abfd);
3260   ieee->w.r.data_part = bfd_tell (abfd);
3261   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
3262     {
3263       /* Skip sections that have no loadable contents (.bss,
3264          debugging, etc.)  */
3265       if ((s->flags & SEC_LOAD) == 0)
3266         continue;
3267
3268       /* Sort the reloc records so we can insert them in the correct
3269          places */
3270       if (s->reloc_count != 0)
3271         {
3272           if (! do_with_relocs (abfd, s))
3273             return false;
3274         }
3275       else
3276         {
3277           if (! do_without_relocs (abfd, s))
3278             return false;
3279         }
3280     }
3281
3282   return true;
3283 }
3284
3285
3286 static boolean
3287 init_for_output (abfd)
3288      bfd *abfd;
3289 {
3290   asection *s;
3291   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
3292     {
3293       if ((s->flags & SEC_DEBUGGING) != 0)
3294         continue;
3295       if (s->_raw_size != 0)
3296         {
3297           ieee_per_section (s)->data = (bfd_byte *) (bfd_alloc (abfd, s->_raw_size));
3298           if (!ieee_per_section (s)->data)
3299             return false;
3300         }
3301     }
3302   return true;
3303 }
3304 \f
3305 /** exec and core file sections */
3306
3307 /* set section contents is complicated with IEEE since the format is
3308 * not a byte image, but a record stream.
3309 */
3310 boolean
3311 ieee_set_section_contents (abfd, section, location, offset, count)
3312      bfd *abfd;
3313      sec_ptr section;
3314      PTR location;
3315      file_ptr offset;
3316      bfd_size_type count;
3317 {
3318   if ((section->flags & SEC_DEBUGGING) != 0)
3319     {
3320       if (section->contents == NULL)
3321         {
3322           section->contents = ((unsigned char *)
3323                                bfd_alloc (abfd, section->_raw_size));
3324           if (section->contents == NULL)
3325             return false;
3326         }
3327       /* bfd_set_section_contents has already checked that everything
3328          is within range.  */
3329       memcpy (section->contents + offset, location, count);
3330       return true;
3331     }
3332
3333   if (ieee_per_section (section)->data == (bfd_byte *) NULL)
3334     {
3335       if (!init_for_output (abfd))
3336         return false;
3337     }
3338   memcpy ((PTR) (ieee_per_section (section)->data + offset),
3339           (PTR) location,
3340           (unsigned int) count);
3341   return true;
3342 }
3343
3344 /* Write the external symbols of a file.  IEEE considers two sorts of
3345    external symbols, public, and referenced.  It uses to internal
3346    forms to index them as well.  When we write them out we turn their
3347    symbol values into indexes from the right base.  */
3348
3349 static boolean
3350 ieee_write_external_part (abfd)
3351      bfd *abfd;
3352 {
3353   asymbol **q;
3354   ieee_data_type *ieee = IEEE_DATA (abfd);
3355
3356   unsigned int reference_index = IEEE_REFERENCE_BASE;
3357   unsigned int public_index = IEEE_PUBLIC_BASE + 2;
3358   file_ptr here = bfd_tell (abfd);
3359   boolean hadone = false;
3360   if (abfd->outsymbols != (asymbol **) NULL)
3361     {
3362
3363       for (q = abfd->outsymbols; *q != (asymbol *) NULL; q++)
3364         {
3365           asymbol *p = *q;
3366           if (bfd_is_und_section (p->section))
3367             {
3368               /* This must be a symbol reference .. */
3369               if (! ieee_write_byte (abfd, ieee_external_reference_enum)
3370                   || ! ieee_write_int (abfd, reference_index)
3371                   || ! ieee_write_id (abfd, p->name))
3372                 return false;
3373               p->value = reference_index;
3374               reference_index++;
3375               hadone = true;
3376             }
3377           else if (bfd_is_com_section (p->section))
3378             {
3379               /* This is a weak reference */
3380               if (! ieee_write_byte (abfd, ieee_external_reference_enum)
3381                   || ! ieee_write_int (abfd, reference_index)
3382                   || ! ieee_write_id (abfd, p->name)
3383                   || ! ieee_write_byte (abfd,
3384                                         ieee_weak_external_reference_enum)
3385                   || ! ieee_write_int (abfd, reference_index)
3386                   || ! ieee_write_int (abfd, p->value))
3387                 return false;
3388               p->value = reference_index;
3389               reference_index++;
3390               hadone = true;
3391             }
3392           else if (p->flags & BSF_GLOBAL)
3393             {
3394               /* This must be a symbol definition */
3395
3396               if (! ieee_write_byte (abfd, ieee_external_symbol_enum)
3397                   || ! ieee_write_int (abfd, public_index)
3398                   || ! ieee_write_id (abfd, p->name)
3399                   || ! ieee_write_2bytes (abfd, ieee_attribute_record_enum)
3400                   || ! ieee_write_int (abfd, public_index)
3401                   || ! ieee_write_byte (abfd, 15) /* instruction address */
3402                   || ! ieee_write_byte (abfd, 19) /* static symbol */
3403                   || ! ieee_write_byte (abfd, 1)) /* one of them */
3404                 return false;
3405
3406               /* Write out the value */
3407               if (! ieee_write_2bytes (abfd, ieee_value_record_enum)
3408                   || ! ieee_write_int (abfd, public_index))
3409                 return false;
3410               if (! bfd_is_abs_section (p->section))
3411                 {
3412                   if (abfd->flags & EXEC_P)
3413                     {
3414                       /* If fully linked, then output all symbols
3415                          relocated */
3416                       if (! (ieee_write_int
3417                              (abfd,
3418                               (p->value
3419                                + p->section->output_offset
3420                                + p->section->output_section->vma))))
3421                         return false;
3422                     }
3423                   else
3424                     {
3425                       if (! (ieee_write_expression
3426                              (abfd,
3427                               p->value + p->section->output_offset,
3428                               p->section->output_section->symbol,
3429                               false, 0)))
3430                         return false;
3431                     }
3432                 }
3433               else
3434                 {
3435                   if (! ieee_write_expression (abfd,
3436                                                p->value,
3437                                                bfd_abs_section_ptr->symbol,
3438                                                false, 0))
3439                     return false;
3440                 }
3441               p->value = public_index;
3442               public_index++;
3443               hadone = true;
3444             }
3445           else
3446             {
3447               /* This can happen - when there are gaps in the symbols read */
3448               /* from an input ieee file */
3449             }
3450         }
3451     }
3452   if (hadone)
3453     ieee->w.r.external_part = here;
3454
3455   return true;
3456 }
3457
3458
3459 static CONST unsigned char exten[] =
3460 {
3461   0xf0, 0x20, 0x00,
3462   0xf1, 0xce, 0x20, 0x00, 37, 3, 3,     /* Set version 3 rev 3          */
3463   0xf1, 0xce, 0x20, 0x00, 39, 2,/* keep symbol in  original case */
3464   0xf1, 0xce, 0x20, 0x00, 38    /* set object type relocateable to x */
3465 };
3466
3467 static CONST unsigned char envi[] =
3468 {
3469   0xf0, 0x21, 0x00,
3470
3471 /*    0xf1, 0xce, 0x21, 00, 50, 0x82, 0x07, 0xc7, 0x09, 0x11, 0x11,
3472     0x19, 0x2c,
3473 */
3474   0xf1, 0xce, 0x21, 00, 52, 0x00,       /* exec ok */
3475
3476   0xf1, 0xce, 0x21, 0, 53, 0x03,/* host unix */
3477 /*    0xf1, 0xce, 0x21, 0, 54, 2,1,1    tool & version # */
3478 };
3479
3480 static boolean
3481 ieee_write_me_part (abfd)
3482      bfd *abfd;
3483 {
3484   ieee_data_type *ieee = IEEE_DATA (abfd);
3485   ieee->w.r.trailer_part = bfd_tell (abfd);
3486   if (abfd->start_address)
3487     {
3488       if (! ieee_write_2bytes (abfd, ieee_value_starting_address_enum)
3489           || ! ieee_write_byte (abfd, ieee_function_either_open_b_enum)
3490           || ! ieee_write_int (abfd, abfd->start_address)
3491           || ! ieee_write_byte (abfd, ieee_function_either_close_b_enum))
3492         return false;
3493     }
3494   ieee->w.r.me_record = bfd_tell (abfd);
3495   if (! ieee_write_byte (abfd, ieee_module_end_enum))
3496     return false;
3497   return true;
3498 }
3499
3500 /* Write out the IEEE processor ID.  */
3501
3502 static boolean
3503 ieee_write_processor (abfd)
3504      bfd *abfd;
3505 {
3506   const bfd_arch_info_type *arch;
3507
3508   arch = bfd_get_arch_info (abfd);
3509   switch (arch->arch)
3510     {
3511     default:
3512       if (! ieee_write_id (abfd, bfd_printable_name (abfd)))
3513         return false;
3514       break;
3515
3516     case bfd_arch_a29k:
3517       if (! ieee_write_id (abfd, "29000"))
3518         return false;
3519       break;
3520
3521     case bfd_arch_h8300:
3522       if (! ieee_write_id (abfd, "H8/300"))
3523         return false;
3524       break;
3525
3526     case bfd_arch_h8500:
3527       if (! ieee_write_id (abfd, "H8/500"))
3528         return false;
3529       break;
3530
3531     case bfd_arch_i960:
3532       switch (arch->mach)
3533         {
3534         default:
3535         case bfd_mach_i960_core:
3536         case bfd_mach_i960_ka_sa:
3537           if (! ieee_write_id (abfd, "80960KA"))
3538             return false;
3539           break;
3540
3541         case bfd_mach_i960_kb_sb:
3542           if (! ieee_write_id (abfd, "80960KB"))
3543             return false;
3544           break;
3545
3546         case bfd_mach_i960_ca:
3547           if (! ieee_write_id (abfd, "80960CA"))
3548             return false;
3549           break;
3550
3551         case bfd_mach_i960_mc:
3552         case bfd_mach_i960_xa:
3553           if (! ieee_write_id (abfd, "80960MC"))
3554             return false;
3555           break;
3556         }
3557       break;
3558
3559     case bfd_arch_m68k:
3560       {
3561         const char *id;
3562
3563         switch (arch->mach)
3564           {
3565           default:              id = "68020"; break;
3566           case bfd_mach_m68000: id = "68000"; break;
3567           case bfd_mach_m68008: id = "68008"; break;
3568           case bfd_mach_m68010: id = "68010"; break;
3569           case bfd_mach_m68020: id = "68020"; break;
3570           case bfd_mach_m68030: id = "68030"; break;
3571           case bfd_mach_m68040: id = "68040"; break;
3572           case bfd_mach_m68060: id = "68060"; break;
3573           case bfd_mach_cpu32:  id = "cpu32"; break;
3574           }
3575
3576         if (! ieee_write_id (abfd, id))
3577           return false;
3578       }
3579       break;
3580     }
3581
3582   return true;
3583 }
3584
3585 boolean
3586 ieee_write_object_contents (abfd)
3587      bfd *abfd;
3588 {
3589   ieee_data_type *ieee = IEEE_DATA (abfd);
3590   unsigned int i;
3591   file_ptr old;
3592
3593   /* Fast forward over the header area */
3594   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
3595     return false;
3596
3597   if (! ieee_write_byte (abfd, ieee_module_beginning_enum)
3598       || ! ieee_write_processor (abfd)
3599       || ! ieee_write_id (abfd, abfd->filename))
3600     return false;
3601
3602   /* Fast forward over the variable bits */
3603   if (! ieee_write_byte (abfd, ieee_address_descriptor_enum))
3604     return false;
3605
3606   /* Bits per MAU */
3607   if (! ieee_write_byte (abfd, (bfd_byte) (bfd_arch_bits_per_byte (abfd))))
3608     return false;
3609   /* MAU's per address */
3610   if (! ieee_write_byte (abfd,
3611                          (bfd_byte) (bfd_arch_bits_per_address (abfd)
3612                                      / bfd_arch_bits_per_byte (abfd))))
3613     return false;
3614
3615   old = bfd_tell (abfd);
3616   if (bfd_seek (abfd, (file_ptr) (8 * N_W_VARIABLES), SEEK_CUR) != 0)
3617     return false;
3618
3619   ieee->w.r.extension_record = bfd_tell (abfd);
3620   if (bfd_write ((char *) exten, 1, sizeof (exten), abfd) != sizeof (exten))
3621     return false;
3622   if (abfd->flags & EXEC_P)
3623     {
3624       if (! ieee_write_byte (abfd, 0x1)) /* Absolute */
3625         return false;
3626     }
3627   else
3628     {
3629       if (! ieee_write_byte (abfd, 0x2)) /* Relocateable */
3630         return false;
3631     }
3632
3633   ieee->w.r.environmental_record = bfd_tell (abfd);
3634   if (bfd_write ((char *) envi, 1, sizeof (envi), abfd) != sizeof (envi))
3635     return false;
3636
3637   /* The HP emulator database requires a timestamp in the file.  */
3638   {
3639     time_t now;
3640     const struct tm *t;
3641
3642     time (&now);
3643     t = (struct tm *) localtime (&now);
3644     if (! ieee_write_2bytes (abfd, (int) ieee_atn_record_enum)
3645         || ! ieee_write_byte (abfd, 0x21)
3646         || ! ieee_write_byte (abfd, 0)
3647         || ! ieee_write_byte (abfd, 50)
3648         || ! ieee_write_int (abfd, t->tm_year + 1900)
3649         || ! ieee_write_int (abfd, t->tm_mon + 1)
3650         || ! ieee_write_int (abfd, t->tm_mday)
3651         || ! ieee_write_int (abfd, t->tm_hour)
3652         || ! ieee_write_int (abfd, t->tm_min)
3653         || ! ieee_write_int (abfd, t->tm_sec))
3654       return false;
3655   }
3656
3657   output_bfd = abfd;
3658
3659   flush ();
3660
3661   if (! ieee_write_section_part (abfd))
3662     return false;
3663   /* First write the symbols.  This changes their values into table
3664     indeces so we cant use it after this point.  */
3665   if (! ieee_write_external_part (abfd))
3666     return false;
3667
3668   /*  ieee_write_byte(abfd, ieee_record_seperator_enum);*/
3669
3670   /*  ieee_write_byte(abfd, ieee_record_seperator_enum);*/
3671
3672
3673   /* Write any debugs we have been told about.  */
3674   if (! ieee_write_debug_part (abfd))
3675     return false;
3676
3677   /* Can only write the data once the symbols have been written, since
3678      the data contains relocation information which points to the
3679      symbols.  */
3680   if (! ieee_write_data_part (abfd))
3681     return false;
3682
3683   /* At the end we put the end!  */
3684   if (! ieee_write_me_part (abfd))
3685     return false;
3686
3687   /* Generate the header */
3688   if (bfd_seek (abfd, old, SEEK_SET) != 0)
3689     return false;
3690
3691   for (i = 0; i < N_W_VARIABLES; i++)
3692     {
3693       if (! ieee_write_2bytes (abfd, ieee_assign_value_to_variable_enum)
3694           || ! ieee_write_byte (abfd, (bfd_byte) i)
3695           || ! ieee_write_int5_out (abfd, ieee->w.offset[i]))
3696         return false;
3697     }
3698
3699   return true;
3700 }
3701 \f
3702 /* Native-level interface to symbols. */
3703
3704 /* We read the symbols into a buffer, which is discarded when this
3705    function exits.  We read the strings into a buffer large enough to
3706    hold them all plus all the cached symbol entries. */
3707
3708 asymbol *
3709 ieee_make_empty_symbol (abfd)
3710      bfd *abfd;
3711 {
3712   ieee_symbol_type *new =
3713     (ieee_symbol_type *) bfd_zmalloc (sizeof (ieee_symbol_type));
3714   if (!new)
3715     return NULL;
3716   new->symbol.the_bfd = abfd;
3717   return &new->symbol;
3718 }
3719
3720 static bfd *
3721 ieee_openr_next_archived_file (arch, prev)
3722      bfd *arch;
3723      bfd *prev;
3724 {
3725   ieee_ar_data_type *ar = IEEE_AR_DATA (arch);
3726   /* take the next one from the arch state, or reset */
3727   if (prev == (bfd *) NULL)
3728     {
3729       /* Reset the index - the first two entries are bogus*/
3730       ar->element_index = 2;
3731     }
3732   while (true)
3733     {
3734       ieee_ar_obstack_type *p = ar->elements + ar->element_index;
3735       ar->element_index++;
3736       if (ar->element_index <= ar->element_count)
3737         {
3738           if (p->file_offset != (file_ptr) 0)
3739             {
3740               if (p->abfd == (bfd *) NULL)
3741                 {
3742                   p->abfd = _bfd_create_empty_archive_element_shell (arch);
3743                   p->abfd->origin = p->file_offset;
3744                 }
3745               return p->abfd;
3746             }
3747         }
3748       else
3749         {
3750           bfd_set_error (bfd_error_no_more_archived_files);
3751           return (bfd *) NULL;
3752         }
3753
3754     }
3755 }
3756
3757 static boolean
3758 ieee_find_nearest_line (abfd,
3759                         section,
3760                         symbols,
3761                         offset,
3762                         filename_ptr,
3763                         functionname_ptr,
3764                         line_ptr)
3765      bfd *abfd ATTRIBUTE_UNUSED;
3766      asection *section ATTRIBUTE_UNUSED;
3767      asymbol **symbols ATTRIBUTE_UNUSED;
3768      bfd_vma offset ATTRIBUTE_UNUSED;
3769      const char **filename_ptr ATTRIBUTE_UNUSED;
3770      const char **functionname_ptr ATTRIBUTE_UNUSED;
3771      unsigned int *line_ptr ATTRIBUTE_UNUSED;
3772 {
3773   return false;
3774 }
3775
3776 static int
3777 ieee_generic_stat_arch_elt (abfd, buf)
3778      bfd *abfd;
3779      struct stat *buf;
3780 {
3781   ieee_ar_data_type *ar = (ieee_ar_data_type *) NULL;
3782   ieee_data_type *ieee;
3783
3784   if (abfd->my_archive != NULL)
3785     ar = abfd->my_archive->tdata.ieee_ar_data;
3786   if (ar == (ieee_ar_data_type *) NULL)
3787     {
3788       bfd_set_error (bfd_error_invalid_operation);
3789       return -1;
3790     }
3791
3792   if (IEEE_DATA (abfd) == NULL)
3793     {
3794       if (ieee_object_p (abfd) == NULL)
3795         {
3796           bfd_set_error (bfd_error_wrong_format);
3797           return -1;
3798         }
3799     }
3800
3801   ieee = IEEE_DATA (abfd);
3802
3803   buf->st_size = ieee->w.r.me_record + 1;
3804   buf->st_mode = 0644;
3805   return 0;
3806 }
3807
3808 static int
3809 ieee_sizeof_headers (abfd, x)
3810      bfd *abfd ATTRIBUTE_UNUSED;
3811      boolean x ATTRIBUTE_UNUSED;
3812 {
3813   return 0;
3814 }
3815
3816
3817 /* The debug info routines are never used.  */
3818 #if 0
3819
3820 static void
3821 ieee_bfd_debug_info_start (abfd)
3822      bfd *abfd;
3823 {
3824
3825 }
3826
3827 static void
3828 ieee_bfd_debug_info_end (abfd)
3829      bfd *abfd;
3830 {
3831
3832 }
3833
3834
3835 /* Add this section to the list of sections we have debug info for, to
3836    be ready to output it at close time
3837    */
3838 static void
3839 ieee_bfd_debug_info_accumulate (abfd, section)
3840      bfd *abfd;
3841      asection *section;
3842 {
3843   ieee_data_type *ieee = IEEE_DATA (section->owner);
3844   ieee_data_type *output_ieee = IEEE_DATA (abfd);
3845   /* can only accumulate data from other ieee bfds */
3846   if (section->owner->xvec != abfd->xvec)
3847     return;
3848   /* Only bother once per bfd */
3849   if (ieee->done_debug == true)
3850     return;
3851   ieee->done_debug = true;
3852
3853   /* Don't bother if there is no debug info */
3854   if (ieee->w.r.debug_information_part == 0)
3855     return;
3856
3857
3858   /* Add to chain */
3859   {
3860     bfd_chain_type *n = (bfd_chain_type *) bfd_alloc (abfd, sizeof (bfd_chain_type));
3861     if (!n)
3862       abort ();         /* FIXME */
3863     n->this = section->owner;
3864     n->next = (bfd_chain_type *) NULL;
3865
3866     if (output_ieee->chain_head)
3867       {
3868         output_ieee->chain_head->next = n;
3869       }
3870     else
3871       {
3872         output_ieee->chain_root = n;
3873
3874       }
3875     output_ieee->chain_head = n;
3876   }
3877 }
3878
3879 #endif
3880
3881 #define ieee_close_and_cleanup _bfd_generic_close_and_cleanup
3882 #define ieee_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
3883
3884 #define ieee_slurp_armap bfd_true
3885 #define ieee_slurp_extended_name_table bfd_true
3886 #define ieee_construct_extended_name_table \
3887   ((boolean (*) PARAMS ((bfd *, char **, bfd_size_type *, const char **))) \
3888    bfd_true)
3889 #define ieee_truncate_arname bfd_dont_truncate_arname
3890 #define ieee_write_armap \
3891   ((boolean (*) \
3892     PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int))) \
3893    bfd_true)
3894 #define ieee_read_ar_hdr bfd_nullvoidptr
3895 #define ieee_update_armap_timestamp bfd_true
3896 #define ieee_get_elt_at_index _bfd_generic_get_elt_at_index
3897
3898 #define ieee_bfd_is_local_label_name bfd_generic_is_local_label_name
3899 #define ieee_get_lineno _bfd_nosymbols_get_lineno
3900 #define ieee_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
3901 #define ieee_read_minisymbols _bfd_generic_read_minisymbols
3902 #define ieee_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
3903
3904 #define ieee_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
3905
3906 #define ieee_set_arch_mach _bfd_generic_set_arch_mach
3907
3908 #define ieee_get_section_contents_in_window \
3909   _bfd_generic_get_section_contents_in_window
3910 #define ieee_bfd_get_relocated_section_contents \
3911   bfd_generic_get_relocated_section_contents
3912 #define ieee_bfd_relax_section bfd_generic_relax_section
3913 #define ieee_bfd_gc_sections bfd_generic_gc_sections
3914 #define ieee_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
3915 #define ieee_bfd_link_add_symbols _bfd_generic_link_add_symbols
3916 #define ieee_bfd_final_link _bfd_generic_final_link
3917 #define ieee_bfd_link_split_section  _bfd_generic_link_split_section
3918
3919 /*SUPPRESS 460 */
3920 const bfd_target ieee_vec =
3921 {
3922   "ieee",                       /* name */
3923   bfd_target_ieee_flavour,
3924   BFD_ENDIAN_UNKNOWN,           /* target byte order */
3925   BFD_ENDIAN_UNKNOWN,           /* target headers byte order */
3926   (HAS_RELOC | EXEC_P |         /* object flags */
3927    HAS_LINENO | HAS_DEBUG |
3928    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
3929   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
3930    | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
3931   '_',                          /* leading underscore */
3932   ' ',                          /* ar_pad_char */
3933   16,                           /* ar_max_namelen */
3934   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
3935   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
3936   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* data */
3937   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
3938   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
3939   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* hdrs */
3940
3941   {_bfd_dummy_target,
3942    ieee_object_p,               /* bfd_check_format */
3943    ieee_archive_p,
3944    _bfd_dummy_target,
3945   },
3946   {
3947     bfd_false,
3948     ieee_mkobject,
3949     _bfd_generic_mkarchive,
3950     bfd_false
3951   },
3952   {
3953     bfd_false,
3954     ieee_write_object_contents,
3955     _bfd_write_archive_contents,
3956     bfd_false,
3957   },
3958
3959   BFD_JUMP_TABLE_GENERIC (ieee),
3960   BFD_JUMP_TABLE_COPY (_bfd_generic),
3961   BFD_JUMP_TABLE_CORE (_bfd_nocore),
3962   BFD_JUMP_TABLE_ARCHIVE (ieee),
3963   BFD_JUMP_TABLE_SYMBOLS (ieee),
3964   BFD_JUMP_TABLE_RELOCS (ieee),
3965   BFD_JUMP_TABLE_WRITE (ieee),
3966   BFD_JUMP_TABLE_LINK (ieee),
3967   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
3968
3969   (PTR) 0
3970 };