bfd/ieee.c

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