bfd/ieee.c

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