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