bfd/ieee.c

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