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