bfd/ieee.c

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