bfd/ieee.c

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