bfd/ieee.c

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