bfd/ieee.c

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