bfd/ieee.c

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