bfd/ieee.c

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