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