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                     ieee_symbol_index_type symbol;
1501                     unsigned int extra;
1502                     boolean pcrel;
1503                     next_byte(&(ieee->h));
1504                     must_parse_int(&(ieee->h)); /* Thow away section #*/
1505                     parse_expression(ieee, &value,
1506                                      &symbol,
1507                                      &pcrel, &extra,
1508                                      0);
1509                     current_map->pc = value;
1510                     BFD_ASSERT((unsigned)(value - s->vma) <= s->_raw_size);
1511                   }
1512                 break;
1513
1514               case ieee_value_starting_address_enum & 0xff:
1515                 /* We've got to the end of the data now - */
1516                 return true;
1517               default:
1518                 BFD_FAIL();
1519                 return true;
1520               }
1521           break;
1522         case ieee_repeat_data_enum:
1523             {
1524               /* Repeat the following LD or LR n times - we do this by
1525                  remembering the stream pointer before running it and
1526                  resetting it and running it n times. We special case
1527                  the repetition of a repeat_data/load_constant
1528                  */
1529
1530               unsigned int iterations ;
1531               uint8e_type *start ;
1532               next_byte(&(ieee->h));
1533               iterations = must_parse_int(&(ieee->h));
1534               start =  ieee->h.input_p;
1535               if (start[0] == (int)ieee_load_constant_bytes_enum &&
1536                   start[1] == 1) {
1537                 while (iterations != 0) {
1538                   location_ptr[current_map->pc++] = start[2];
1539                   iterations--;
1540                 }
1541                 next_byte(&(ieee->h));
1542                 next_byte(&(ieee->h));
1543                 next_byte(&(ieee->h));
1544               }
1545               else {
1546                 while (iterations != 0) {
1547                   ieee->h.input_p = start;
1548                   do_one(ieee, current_map, location_ptr,s);
1549                   iterations --;
1550                 }
1551               }
1552             }
1553           break;
1554         case ieee_load_constant_bytes_enum:
1555         case ieee_load_with_relocation_enum:
1556             {
1557               do_one(ieee, current_map, location_ptr,s);
1558             }
1559         }
1560   }
1561 }
1562
1563
1564
1565
1566
1567 boolean
1568 DEFUN(ieee_new_section_hook,(abfd, newsect),
1569       bfd *abfd AND
1570       asection *newsect)
1571 {
1572   newsect->used_by_bfd = (PTR)
1573     bfd_alloc(abfd, sizeof(ieee_per_section_type));
1574   ieee_per_section( newsect)->data = (bfd_byte *)NULL;
1575   ieee_per_section(newsect)->section = newsect;
1576   return true;
1577 }
1578
1579
1580 unsigned int
1581 DEFUN(ieee_get_reloc_upper_bound,(abfd, asect),
1582       bfd *abfd AND
1583       sec_ptr asect)
1584 {
1585   ieee_slurp_section_data(abfd);
1586   return (asect->reloc_count+1) * sizeof(arelent *);
1587 }
1588
1589 static boolean
1590 DEFUN(ieee_get_section_contents,(abfd, section, location, offset, count),
1591       bfd *abfd AND
1592       sec_ptr section AND
1593       PTR location AND
1594       file_ptr offset AND
1595       bfd_size_type count)
1596 {
1597   ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;
1598   ieee_slurp_section_data(abfd);
1599   (void)  memcpy((PTR)location, (PTR)(p->data + offset), (unsigned)count);
1600   return true;
1601 }
1602
1603
1604 unsigned int
1605 DEFUN(ieee_canonicalize_reloc,(abfd, section, relptr, symbols),
1606       bfd *abfd AND
1607       sec_ptr section AND
1608       arelent **relptr AND
1609       asymbol **symbols)
1610 {
1611 /*  ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;*/
1612   ieee_reloc_type *src = (ieee_reloc_type *)(section->relocation);
1613   ieee_data_type *ieee = IEEE_DATA(abfd);
1614
1615   while (src != (ieee_reloc_type *)NULL) {
1616     /* Work out which symbol to attach it this reloc to */
1617     switch (src->symbol.letter) {
1618     case 'X':
1619       src->relent.sym_ptr_ptr =
1620         symbols + src->symbol.index +  ieee->external_reference_base_offset;
1621       break;
1622     case 0:
1623       src->relent.sym_ptr_ptr =
1624        src->relent.sym_ptr_ptr[0]->section->symbol_ptr_ptr;
1625       break;
1626     default:
1627
1628       BFD_FAIL();
1629     }
1630     *relptr++ = &src->relent;
1631     src = src->next;
1632   }
1633   *relptr = (arelent *)NULL;
1634   return section->reloc_count;
1635 }
1636
1637
1638
1639 static int
1640 DEFUN(comp,(ap, bp),
1641      CONST PTR ap AND
1642      CONST PTR bp)
1643 {
1644   arelent *a = *((arelent **)ap);
1645   arelent *b = *((arelent **)bp);
1646   return a->address - b->address;
1647 }
1648
1649 /*
1650 Write the section headers
1651 */
1652
1653 static void
1654 DEFUN(ieee_write_section_part,(abfd),
1655       bfd *abfd)
1656 {
1657   ieee_data_type *ieee = IEEE_DATA(abfd);
1658   asection *s;
1659   ieee->w.r.section_part = bfd_tell(abfd);
1660   for (s = abfd->sections; s != (asection *)NULL; s=s->next) {
1661       if (s != &bfd_abs_section)
1662       {
1663
1664         ieee_write_byte(abfd, ieee_section_type_enum);
1665         ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
1666
1667         if (abfd->flags & EXEC_P)
1668         {
1669           /* This image is executable, so output absolute sections */
1670           ieee_write_byte(abfd, ieee_variable_A_enum);
1671           ieee_write_byte(abfd, ieee_variable_S_enum);
1672         }
1673         else
1674         {
1675           ieee_write_byte(abfd, ieee_variable_C_enum);
1676         }
1677
1678         switch (s->flags &(SEC_CODE | SEC_DATA | SEC_ROM))
1679         {
1680         case SEC_CODE | SEC_LOAD:
1681         case SEC_CODE:
1682           ieee_write_byte(abfd, ieee_variable_P_enum);
1683           break;
1684         case SEC_DATA:
1685         default:
1686           ieee_write_byte(abfd, ieee_variable_D_enum);
1687           break;
1688         case SEC_ROM:
1689         case SEC_ROM | SEC_DATA:
1690         case SEC_ROM | SEC_LOAD:
1691         case SEC_ROM | SEC_DATA | SEC_LOAD:
1692
1693           ieee_write_byte(abfd, ieee_variable_R_enum);
1694         }
1695
1696
1697         ieee_write_id(abfd, s->name);
1698 #if 0
1699         ieee_write_int(abfd, 0); /* Parent */
1700         ieee_write_int(abfd, 0); /* Brother */
1701         ieee_write_int(abfd, 0); /* Context */
1702 #endif
1703         /* Alignment */
1704         ieee_write_byte(abfd, ieee_section_alignment_enum);
1705         ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
1706         ieee_write_int(abfd, 1 << s->alignment_power);
1707
1708         /* Size */
1709         ieee_write_2bytes(abfd, ieee_section_size_enum);
1710         ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
1711         ieee_write_int(abfd, s->_raw_size);
1712         if (abfd->flags & EXEC_P) {
1713             /* Relocateable sections don't have asl records */
1714             /* Vma */
1715             ieee_write_2bytes(abfd, ieee_section_base_address_enum);
1716             ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
1717             ieee_write_int(abfd, s->vma);
1718           }
1719       }
1720
1721     }
1722 }
1723
1724
1725
1726 static void
1727 DEFUN(do_with_relocs,(abfd, s),
1728       bfd *abfd AND
1729       asection *s)
1730 {
1731   unsigned int relocs_to_go = s->reloc_count;
1732
1733
1734   bfd_byte *stream = ieee_per_section(s)->data;
1735   arelent **p = s->orelocation;
1736
1737   bfd_size_type current_byte_index = 0;
1738
1739   qsort(s->orelocation,
1740         relocs_to_go,
1741         sizeof(arelent **),
1742         comp);
1743
1744   /* Output the section preheader */
1745   ieee_write_byte(abfd, ieee_set_current_section_enum);
1746   ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
1747
1748   ieee_write_twobyte(abfd, ieee_set_current_pc_enum);
1749   ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
1750   ieee_write_expression(abfd, 0, s->symbol, 0, 0);
1751
1752   if (relocs_to_go == 0)
1753       {
1754         /* If there arn't any relocations then output the load constant byte
1755            opcode rather than the load with relocation opcode */
1756
1757         while (current_byte_index < s->_raw_size) {
1758           bfd_size_type run;
1759           unsigned int MAXRUN  = 32;
1760           run = MAXRUN;
1761           if (run > s->_raw_size - current_byte_index) {
1762             run = s->_raw_size - current_byte_index;
1763           }
1764
1765           if (run != 0) {
1766             ieee_write_byte(abfd, ieee_load_constant_bytes_enum);
1767             /* Output a stream of bytes */
1768             ieee_write_int(abfd, run);
1769             bfd_write((PTR)(stream + current_byte_index),
1770                       1,
1771                       run,
1772                       abfd);
1773             current_byte_index += run;
1774           }
1775         }
1776       }
1777   else
1778       {
1779         ieee_write_byte(abfd, ieee_load_with_relocation_enum);
1780
1781
1782         /* Output the data stream as the longest sequence of bytes
1783            possible, allowing for the a reasonable packet size and
1784            relocation stuffs */
1785
1786         if ((PTR)stream == (PTR)NULL) {
1787           /* Outputting a section without data, fill it up */
1788           stream = (uint8e_type *)(bfd_alloc(abfd, s->_raw_size));
1789           memset((PTR)stream, 0, s->_raw_size);
1790         }
1791         while (current_byte_index < s->_raw_size) {
1792           bfd_size_type run;
1793           unsigned int MAXRUN = 32;
1794           if (relocs_to_go) {
1795             run = (*p)->address - current_byte_index;
1796           }
1797           else {
1798             run = MAXRUN;
1799           }
1800           if (run > s->_raw_size - current_byte_index) {
1801             run = s->_raw_size - current_byte_index;
1802           }
1803
1804           if (run != 0) {
1805             /* Output a stream of bytes */
1806             ieee_write_int(abfd, run);
1807             bfd_write((PTR)(stream + current_byte_index),
1808                       1,
1809                       run,
1810                       abfd);
1811             current_byte_index += run;
1812           }
1813           /* Output any relocations here */
1814           if (relocs_to_go && (*p) && (*p)->address == current_byte_index) {
1815             while (relocs_to_go && (*p) && (*p)->address == current_byte_index) {
1816
1817               arelent *r = *p;
1818               bfd_vma ov;
1819
1820 #if 0
1821               if (r->howto->pc_relative) {
1822                 r->addend += current_byte_index ;
1823               }
1824 #endif
1825
1826               switch (r->howto->size) {
1827               case 2:
1828
1829                 ov = bfd_get_32(abfd,
1830                                 stream+current_byte_index);
1831                 current_byte_index +=4;
1832                 break;
1833               case 1:
1834                 ov = bfd_get_16(abfd,
1835                                 stream+current_byte_index);
1836                 current_byte_index +=2;
1837                 break;
1838               case 0:
1839                 ov = bfd_get_8(abfd,
1840                                stream+current_byte_index);
1841                 current_byte_index ++;
1842                 break;
1843               default:
1844                 ov = 0;
1845                 BFD_FAIL();
1846               }
1847               ieee_write_byte(abfd, ieee_function_either_open_b_enum);
1848 /*            abort();*/
1849
1850               if (r->sym_ptr_ptr != (asymbol **)NULL) {
1851                 ieee_write_expression(abfd, r->addend + ov,
1852                                       *(r->sym_ptr_ptr),
1853                                       r->howto->pc_relative, s->index);
1854               }
1855               else {
1856                 ieee_write_expression(abfd, r->addend + ov,
1857                                       (asymbol *)NULL,
1858                                       r->howto->pc_relative, s->index);
1859               }
1860
1861               if (1 || r->howto->size != 2) {
1862                 ieee_write_byte(abfd, ieee_comma);
1863                 ieee_write_int(abfd, 1<< r->howto->size);
1864               }
1865               ieee_write_byte(abfd,
1866                               ieee_function_either_close_b_enum);
1867
1868               relocs_to_go --;
1869               p++;
1870             }
1871
1872           }
1873         }
1874       }
1875 }
1876
1877 /* If there are no relocations in the output section then we can
1878 be clever about how we write. We block items up into a max of 127
1879 bytes */
1880
1881 static void
1882 DEFUN(do_as_repeat, (abfd, s),
1883       bfd *abfd AND
1884       asection *s)
1885 {
1886   if (s->_raw_size) {
1887     ieee_write_byte(abfd, ieee_set_current_section_enum);
1888     ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
1889     ieee_write_byte(abfd, ieee_set_current_pc_enum >> 8);
1890     ieee_write_byte(abfd, ieee_set_current_pc_enum  & 0xff);
1891     ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE);
1892     ieee_write_int(abfd,  s->vma );
1893
1894     ieee_write_byte(abfd,ieee_repeat_data_enum);
1895     ieee_write_int(abfd, s->_raw_size);
1896     ieee_write_byte(abfd, ieee_load_constant_bytes_enum);
1897     ieee_write_byte(abfd, 1);
1898     ieee_write_byte(abfd, 0);
1899   }
1900 }
1901
1902 static void
1903 DEFUN(do_without_relocs, (abfd, s),
1904       bfd *abfd AND
1905       asection *s)
1906 {
1907   bfd_byte *stream = ieee_per_section(s)->data;
1908
1909   if (stream == 0 || ((s->flags & SEC_LOAD) == 0))
1910       {
1911         do_as_repeat(abfd, s);
1912       }
1913   else
1914       {
1915         unsigned int i;
1916         for (i = 0; i < s->_raw_size; i++) {
1917           if (stream[i] != 0) {
1918             do_with_relocs(abfd, s);
1919             return;
1920           }
1921         }
1922         do_as_repeat(abfd, s);
1923       }
1924
1925 }
1926
1927
1928 static unsigned char *output_ptr_start;
1929 static unsigned char *output_ptr;
1930 static unsigned char *output_ptr_end;
1931 static unsigned char *input_ptr_start;
1932 static unsigned char *input_ptr;
1933 static unsigned char *input_ptr_end;
1934 static bfd *input_bfd;
1935 static bfd *output_bfd;
1936 static int output_buffer;
1937
1938 static void fill()
1939 {
1940   bfd_read((PTR)input_ptr_start, 1, input_ptr_end - input_ptr_start, input_bfd);
1941   input_ptr = input_ptr_start;
1942 }
1943 static void flush()
1944 {
1945   bfd_write((PTR)(output_ptr_start),1,output_ptr - output_ptr_start, output_bfd);
1946   output_ptr = output_ptr_start;
1947   output_buffer++;
1948 }
1949
1950 #define THIS() ( *input_ptr )
1951 #define NEXT() { input_ptr++; if (input_ptr == input_ptr_end) fill(); }
1952 #define OUT(x) { *output_ptr++ = (x); if(output_ptr == output_ptr_end)  flush(); }
1953
1954 static void write_int(value)
1955 int value;
1956 {
1957   if (value >= 0 && value <= 127) {
1958     OUT(value);
1959   }
1960   else {
1961     unsigned int length;
1962     /* How many significant bytes ? */
1963     /* FIXME FOR LONGER INTS */
1964     if (value & 0xff000000) {
1965       length = 4;
1966     }
1967     else if (value & 0x00ff0000) {
1968       length  = 3;
1969     }
1970     else if (value & 0x0000ff00) {
1971       length = 2;
1972     }
1973     else length = 1;
1974
1975     OUT((int)ieee_number_repeat_start_enum + length);
1976     switch (length) {
1977     case 4:
1978       OUT( value >> 24);
1979     case 3:
1980       OUT( value >> 16);
1981     case 2:
1982       OUT( value >> 8);
1983     case 1:
1984       OUT( value);
1985     }
1986
1987   }
1988 }
1989 static void copy_id()
1990 {
1991   int length  = THIS();
1992   char ch;
1993   OUT(length);
1994   NEXT();
1995   while (length--) {
1996     ch = THIS();
1997     OUT(ch);
1998     NEXT();
1999   }
2000 }
2001 #define VAR(x) ((x | 0x80))
2002 static void copy_expression()
2003 {
2004   int stack[10];
2005   int *tos = stack;
2006   int value = 0;
2007   while (1) {
2008     switch (THIS()) {
2009     case 0x84:
2010       NEXT();
2011       value =  THIS(); NEXT();
2012       value = (value << 8) | THIS(); NEXT();
2013       value = (value << 8) | THIS(); NEXT();
2014       value = (value << 8) | THIS(); NEXT();
2015       *tos ++ = value;
2016       break;
2017     case 0x83:
2018       NEXT();
2019       value =  THIS(); NEXT();
2020       value = (value << 8) | THIS(); NEXT();
2021       value = (value << 8) | THIS(); NEXT();
2022       *tos ++ = value;
2023       break;
2024     case 0x82:
2025       NEXT();
2026       value =  THIS(); NEXT();
2027       value = (value << 8) | THIS(); NEXT();
2028       *tos ++ = value;
2029       break;
2030     case 0x81:
2031       NEXT();
2032       value =  THIS(); NEXT();
2033       *tos ++ = value;
2034       break;
2035       case 0x80:
2036       NEXT();
2037       *tos ++ = 0;
2038       break;
2039     default:
2040       if (THIS() >0x84) {
2041         /* Not a number, just bug out with the answer */
2042         write_int(*(--tos));
2043         return;
2044       }
2045       *tos++ = THIS();
2046 NEXT();
2047       value = 0;
2048       break;
2049     case 0xa5:
2050       /* PLUS anything */
2051         {
2052           int value = *(--tos);
2053           value += *(--tos);
2054           *tos++ = value;
2055           NEXT();
2056         }
2057       break;
2058     case VAR('R') :
2059         {
2060           int section_number ;
2061           ieee_data_type *ieee;
2062           asection *s;
2063           NEXT();
2064           section_number = THIS();
2065
2066           NEXT();
2067           ieee= IEEE_DATA(input_bfd);
2068           s =   ieee->section_table[section_number];
2069           if (s->output_section) {
2070             value = s->output_section->vma ;
2071           } else { value = 0; }
2072           value += s->output_offset;
2073           *tos++ = value;
2074           value = 0;
2075         }
2076       break;
2077     case 0x90:
2078         {
2079           NEXT();
2080           write_int(*(--tos));
2081           OUT(0x90);
2082           return;
2083
2084         }
2085     }
2086   }
2087
2088 }
2089
2090 /* Drop the int in the buffer, and copy a null into the gap, which we
2091    will overwrite later */
2092
2093 struct output_buffer_struct {
2094 unsigned  char *ptrp;
2095   int buffer;
2096 } ;
2097
2098 static void
2099 DEFUN(fill_int,(buf),
2100       struct output_buffer_struct *buf)
2101 {
2102   if (buf->buffer == output_buffer) {
2103     /* Still a chance to output the size */
2104     int value = output_ptr - buf->ptrp + 3;
2105     buf->ptrp[0] =  value >> 24;
2106     buf->ptrp[1] =  value >> 16;
2107     buf->ptrp[2] =  value >> 8;
2108     buf->ptrp[3] =  value >> 0;
2109   }
2110
2111 }
2112 static void
2113 DEFUN(drop_int,(buf),
2114       struct output_buffer_struct *buf)
2115 {
2116   int type = THIS();
2117   int ch;
2118   if (type <= 0x84) {
2119     NEXT();
2120     switch(type) {
2121     case 0x84: ch = THIS(); NEXT();
2122     case 0x83: ch = THIS(); NEXT();
2123     case 0x82: ch = THIS(); NEXT();
2124     case 0x81: ch = THIS(); NEXT();
2125     case 0x80: break;
2126     }
2127   }
2128   OUT(0x84);
2129   buf->ptrp = output_ptr;
2130   buf->buffer  = output_buffer;
2131   OUT(0);OUT(0);OUT(0);OUT(0);
2132 }
2133
2134 static void copy_int()
2135 {
2136   int type = THIS();
2137   int ch;
2138   if (type <= 0x84) {
2139     OUT(type);
2140     NEXT();
2141     switch(type) {
2142     case 0x84: ch = THIS(); NEXT(); OUT(ch);
2143     case 0x83: ch = THIS(); NEXT(); OUT(ch);
2144     case 0x82: ch = THIS(); NEXT(); OUT(ch);
2145     case 0x81: ch = THIS(); NEXT(); OUT(ch);
2146     case 0x80: break;
2147     }
2148   }
2149 }
2150
2151 #define ID copy_id()
2152 #define INT copy_int()
2153 #define EXP copy_expression()
2154 static void copy_till_end();
2155 #define INTn(q) copy_int()
2156 #define EXPn(q) copy_expression()
2157 static void f1_record()
2158 {
2159   int ch;
2160   /* ATN record */
2161   NEXT();
2162   ch = THIS();
2163   switch (ch)
2164       {
2165       default:
2166         OUT(0xf1); OUT(ch);
2167         break;
2168       case 0xc9:
2169         NEXT();
2170         OUT(0xf1); OUT(0xc9);
2171         INT; INT; ch = THIS();
2172         switch (ch)
2173             {
2174             case 0x16: NEXT();break;
2175             case 0x01: NEXT();break;
2176             case 0x00: NEXT(); INT; break;
2177             case 0x03: NEXT(); INT; break;
2178             case 0x13: EXPn(instruction address); break;
2179             default:
2180               break;
2181             }
2182         break;
2183       case 0xd8:
2184         /* EXternal ref */
2185         NEXT();
2186         OUT(0xf1); OUT(0xd8);
2187         EXP ; EXP; EXP; EXP;
2188         break;
2189       case 0xce:
2190         NEXT();
2191         OUT(0xf1);OUT(0xce); INT; INT; ch = THIS(); INT;
2192         switch (ch) {
2193         case 0x01:
2194           INT; INT; break;
2195         case 0x02:
2196           INT; break;
2197         case 0x04:
2198           EXPn(external function); break;
2199         case 0x05:
2200           break;
2201         case 0x07: INTn(line number); INT;
2202         case 0x08: break;
2203         case 0x0a: INTn(locked register); INT; break;
2204         case 0x3f: copy_till_end(); break;
2205         case 0x3e: copy_till_end(); break;
2206         case 0x40: copy_till_end(); break;
2207         case 0x41: ID; break;
2208         }
2209       }
2210
2211 }
2212 static void f0_record()
2213 {
2214   /* Attribute record */
2215   NEXT();
2216   OUT(0xf0);
2217   INTn(Symbol name );
2218   ID;
2219 }
2220 static void copy_till_end()
2221 {
2222   int  ch = THIS();
2223   while (1) {
2224     while (ch <= 0x80)
2225         {
2226           OUT(ch);
2227           NEXT();
2228           ch = THIS();
2229         }
2230     switch (ch) {
2231     case 0x84:
2232       OUT(THIS());
2233       NEXT();
2234     case 0x83:
2235       OUT(THIS());
2236       NEXT();
2237     case 0x82:
2238       OUT(THIS());
2239       NEXT();
2240     case 0x81:
2241       OUT(THIS());
2242       NEXT();
2243       OUT(THIS());
2244       NEXT();
2245
2246       ch = THIS();
2247       break;
2248     default:
2249       return;
2250     }
2251   }
2252
2253 }
2254
2255 static void f2_record()
2256 {
2257   NEXT();
2258   OUT(0xf2);
2259   INT ;
2260   NEXT();
2261   OUT(0xce);
2262   INT ;
2263   copy_till_end();
2264 }
2265
2266
2267 static void block();
2268 static void f8_record()
2269 {
2270   int ch;
2271   NEXT();
2272   ch = THIS();
2273   switch (ch)
2274       {
2275       case 0x01:
2276       case 0x02:
2277       case 0x03:
2278         /* Unique typedefs for module */
2279         /* GLobal typedefs  */
2280         /* High level module scope beginning */
2281           {
2282             struct output_buffer_struct ob;
2283             NEXT();
2284             OUT(0xf8); OUT(ch);
2285             drop_int(&ob); ID ;
2286
2287             block();
2288
2289             NEXT();
2290             fill_int(&ob);
2291             OUT(0xf9);
2292           }
2293         break;
2294       case 0x04:
2295         /* Global function */
2296           {
2297             struct output_buffer_struct ob;
2298             NEXT();
2299             OUT(0xf8); OUT(0x04);
2300             drop_int(&ob); ID ; INTn(stack size); INTn(ret val);
2301             EXPn(offset);
2302
2303             block();
2304
2305             NEXT();
2306             OUT(0xf9);
2307             EXPn(size of block);
2308             fill_int(&ob);
2309           }
2310         break;
2311
2312       case 0x05:
2313         /* File name for source line numbers */
2314           {
2315             struct output_buffer_struct ob;
2316             NEXT();
2317             OUT(0xf8); OUT(0x05);
2318             drop_int(&ob);
2319             ID; INTn(year); INTn(month); INTn(day);
2320             INTn(hour); INTn(monute); INTn(second);
2321             block();
2322             NEXT();
2323             OUT(0xf9);
2324             fill_int(&ob);
2325           }
2326         break;
2327
2328       case 0x06:
2329         /* Local function */
2330           { struct output_buffer_struct ob;
2331             NEXT(); OUT(0xf8); OUT(0x06);
2332             drop_int(&ob);
2333             ID; INTn(stack size); INTn(type return);
2334             EXPn(offset);
2335             block();
2336             NEXT();
2337             OUT(0xf9);
2338             EXPn(size);
2339             fill_int(&ob);
2340           }
2341         break;
2342
2343       case 0x0a:
2344         /* Assembler module scope beginning -*/
2345           { struct output_buffer_struct ob;
2346
2347             NEXT();
2348             OUT(0xf8); OUT(0x0a);
2349             drop_int(&ob);
2350               ID; ID; INT; ID; INT; INT; INT; INT; INT; INT;
2351
2352             block();
2353
2354             NEXT();
2355             OUT(0xf9);
2356             fill_int(&ob);
2357           }
2358         break;
2359       case 0x0b:
2360           {
2361             struct output_buffer_struct ob;
2362             NEXT();
2363             OUT(0xf8); OUT(0x0b);
2364             drop_int(&ob); ID ; INT; INTn(section index); EXPn(offset); INTn(stuff);
2365
2366             block();
2367
2368             OUT(0xf9);
2369             NEXT();
2370             EXPn(Size in Maus);
2371             fill_int(&ob);
2372           }
2373         break;
2374       }
2375 }
2376
2377 static void e2_record()
2378 {
2379   OUT(0xe2);
2380   NEXT();
2381   OUT(0xce);
2382   NEXT();
2383   INT;
2384   EXP;
2385 }
2386
2387 static void DEFUN_VOID(block)
2388 {
2389   int ch ;
2390   while (1) {
2391     ch = THIS();
2392     switch (ch) {
2393     case 0xe1:
2394     case 0xe5:
2395       return;
2396     case 0xf9:
2397       return;
2398     case 0xf0:
2399       f0_record();
2400       break;
2401     case 0xf1:
2402       f1_record();
2403       break;
2404     case 0xf2:
2405       f2_record();
2406       break;
2407     case 0xf8:
2408       f8_record();
2409       break;
2410     case 0xe2:
2411       e2_record();
2412       break;
2413
2414     }
2415   }
2416 }
2417
2418
2419
2420 /* relocate_debug,
2421    moves all the debug information from the source bfd to the output
2422    bfd, and relocates any expressions it finds
2423 */
2424
2425 static void
2426 DEFUN(relocate_debug,(output, input),
2427       bfd *output AND
2428       bfd *input)
2429 {
2430 #define IBS 400
2431 #define OBS 400
2432   unsigned char input_buffer[IBS];
2433
2434   input_ptr_start = input_ptr = input_buffer;
2435   input_ptr_end = input_buffer + IBS;
2436   input_bfd = input;
2437   bfd_read((PTR)input_ptr_start, 1, IBS, input);
2438   block();
2439 }
2440 /*
2441   During linking, we we told about the bfds which made up our
2442   contents, we have a list of them. They will still be open, so go to
2443   the debug info in each, and copy it out, relocating it as we go.
2444 */
2445
2446 static void
2447 DEFUN(ieee_write_debug_part, (abfd),
2448       bfd *abfd)
2449 {
2450   ieee_data_type *ieee = IEEE_DATA(abfd);
2451   bfd_chain_type *chain = ieee->chain_root;
2452   unsigned char output_buffer[OBS];
2453   boolean some_debug = false;
2454   file_ptr here = bfd_tell(abfd);
2455
2456   output_ptr_start = output_ptr = output_buffer ;
2457   output_ptr_end = output_buffer + OBS;
2458   output_ptr = output_buffer;
2459   output_bfd = abfd;
2460
2461   if (chain == (bfd_chain_type *)NULL) {
2462 #if 0
2463       /* There is no debug info, so we'll fake some up */
2464       CONST static char fake[] = {
2465           0xf8, 0xa, 0, 5, 't', 't', 't', 't', 't', 0, 2, 3,
2466           '1','.','1',0x82, 1991>>8, 1991 & 0xff, 9, 20, 11, 07,50 };
2467       ieee->w.r.debug_information_part = 0;
2468
2469
2470       here;
2471
2472
2473       /*    bfd_write(fake, 1, sizeof(fake), abfd);*/
2474       /* Now write a header for each section */
2475     {
2476       int i = 0;
2477       asection *s = abfd->sections;
2478       while (s) {
2479           if (s != abfd->abs_section)
2480           {
2481
2482             ieee_write_byte(abfd, 0xf8);
2483             ieee_write_byte(abfd, 0x0b);
2484             ieee_write_byte(abfd, 0);
2485             ieee_write_byte(abfd, 0);
2486             ieee_write_byte(abfd, 1);
2487             ieee_write_byte(abfd, i + IEEE_SECTION_NUMBER_BASE);
2488             ieee_write_expression(abfd, 0, s->symbol, 0, 0, 0);
2489             ieee_write_byte(abfd,0);
2490             ieee_write_byte(abfd, 0xf9);
2491             ieee_write_expression(abfd, s->size,
2492                                   bfd_abs_section.symbol, 0, 0, 0);
2493             i++;
2494           }
2495
2496           s = s->next;
2497
2498         }
2499       /* Close the scope */
2500       ieee_write_byte(abfd, 0xf9);
2501     }
2502 #endif
2503     }
2504   else{
2505       while (chain != (bfd_chain_type *)NULL) {
2506           bfd *entry = chain->this;
2507           ieee_data_type *entry_ieee = IEEE_DATA(entry);
2508           if (entry_ieee->w.r.debug_information_part) {
2509               bfd_seek(entry, entry_ieee->w.r.debug_information_part, SEEK_SET);
2510               relocate_debug(abfd, entry);
2511             }
2512
2513           chain = chain->next;
2514         }
2515       if (some_debug) {
2516           ieee->w.r.debug_information_part = here;
2517         }
2518       else {
2519           ieee->w.r.debug_information_part = 0;
2520         }
2521     }
2522   flush();
2523
2524 }
2525 /* write the data in an ieee way */
2526 static void
2527 DEFUN(ieee_write_data_part,(abfd),
2528       bfd *abfd)
2529 {
2530   asection *s;
2531   ieee_data_type *ieee = IEEE_DATA(abfd);
2532   ieee->w.r.data_part = bfd_tell(abfd);
2533   for (s = abfd->sections; s != (asection *)NULL; s = s->next)
2534       {
2535         /* Sort the reloc records so we can insert them in the correct
2536            places */
2537         if (s->reloc_count != 0)
2538             {
2539              do_with_relocs(abfd, s);
2540             }
2541         else
2542             {
2543               do_without_relocs(abfd, s);
2544             }
2545       }
2546 }
2547
2548
2549
2550 static void
2551 DEFUN(init_for_output,(abfd),
2552       bfd *abfd)
2553 {
2554   asection *s;
2555   for (s = abfd->sections; s != (asection *)NULL; s = s->next) {
2556     if (s->_raw_size != 0) {
2557       ieee_per_section(s)->data = (bfd_byte *)(bfd_alloc(abfd, s->_raw_size));
2558     }
2559   }
2560 }
2561
2562 /** exec and core file sections */
2563
2564 /* set section contents is complicated with IEEE since the format is
2565 * not a byte image, but a record stream.
2566 */
2567 boolean
2568 DEFUN(ieee_set_section_contents,(abfd, section, location, offset, count),
2569       bfd *abfd AND
2570       sec_ptr section AND
2571       PTR location AND
2572       file_ptr offset AND
2573       bfd_size_type count)
2574 {
2575   if (ieee_per_section(section)->data == (bfd_byte *)NULL) {
2576     init_for_output(abfd);
2577   }
2578   (void) memcpy((PTR)(ieee_per_section(section)->data + offset),
2579                 (PTR)location,
2580                 (unsigned int)count);
2581   return true;
2582 }
2583
2584 /*
2585 write the external symbols of a file, IEEE considers two sorts of
2586 external symbols, public, and referenced. It uses to internal forms
2587 to index them as well. When we write them out we turn their symbol
2588 values into indexes from the right base.
2589 */
2590 static void
2591 DEFUN(ieee_write_external_part,(abfd),
2592       bfd *abfd)
2593 {
2594   asymbol **q;
2595   ieee_data_type *ieee = IEEE_DATA(abfd);
2596
2597   unsigned int reference_index = IEEE_REFERENCE_BASE;
2598   unsigned int public_index = IEEE_PUBLIC_BASE+2;
2599   file_ptr here = bfd_tell(abfd);
2600   boolean hadone = false;
2601   if (abfd->outsymbols != (asymbol **)NULL) {
2602
2603     for (q = abfd->outsymbols; *q  != (asymbol *)NULL; q++) {
2604       asymbol *p = *q;
2605       hadone = true;
2606       if (p->section == &bfd_und_section) {
2607         /* This must be a symbol reference .. */
2608         ieee_write_byte(abfd, ieee_external_reference_enum);
2609         ieee_write_int(abfd, reference_index);
2610         ieee_write_id(abfd, p->name);
2611         p->value = reference_index;
2612         reference_index++;
2613       }
2614       else if (bfd_is_com_section (p->section)) {
2615         /* This is a weak reference */
2616         ieee_write_byte(abfd, ieee_external_reference_enum);
2617         ieee_write_int(abfd, reference_index);
2618         ieee_write_id(abfd, p->name);
2619         ieee_write_byte(abfd, ieee_weak_external_reference_enum);
2620         ieee_write_int(abfd, reference_index);
2621         ieee_write_int(abfd, p->value);
2622         ieee_write_int(abfd, BFD_FORT_COMM_DEFAULT_VALUE);
2623         p->value = reference_index;
2624         reference_index++;
2625       }
2626       else if(p->flags & BSF_GLOBAL) {
2627         /* This must be a symbol definition */
2628
2629
2630         ieee_write_byte(abfd, ieee_external_symbol_enum);
2631         ieee_write_int(abfd, public_index );
2632         ieee_write_id(abfd, p->name);
2633
2634         ieee_write_twobyte(abfd, ieee_attribute_record_enum);
2635         ieee_write_int(abfd, public_index );
2636         ieee_write_byte(abfd, 15);       /* instruction address */
2637         ieee_write_byte(abfd, 19);      /* static symbol */
2638         ieee_write_byte(abfd, 1);       /* one of them */
2639
2640
2641         /* Write out the value */
2642         ieee_write_2bytes(abfd, ieee_value_record_enum);
2643         ieee_write_int(abfd, public_index);
2644         if (p->section != &bfd_abs_section)
2645             {
2646               if (abfd->flags & EXEC_P)
2647               {
2648                 /* If fully linked, then output all symbols
2649                    relocated */
2650                 ieee_write_int(abfd,
2651                                p->value + p->section->output_offset+ p->section->output_section->vma);
2652
2653               }
2654               else {
2655                   ieee_write_expression(abfd,
2656                                         p->value + p->section->output_offset,
2657                                         p->section->output_section->symbol
2658                                         , false, 0);
2659                 }
2660             }
2661         else
2662             {
2663               ieee_write_expression(abfd,
2664                                     p->value,
2665                                     bfd_abs_section.symbol,
2666                                     false, 0);
2667             }
2668         p->value = public_index;
2669         public_index++;
2670       }
2671       else {
2672         /* This can happen - when there are gaps in the symbols read */
2673         /* from an input ieee file */
2674       }
2675     }
2676   }
2677   if (hadone)
2678     ieee->w.r.external_part = here;
2679
2680 }
2681
2682
2683 CONST static unsigned char exten[] =
2684   {
2685     0xf0, 0x20, 0x00,
2686     0xf1, 0xce, 0x20, 0x00, 37, 3, 3,   /* Set version 3 rev 3          */
2687     0xf1, 0xce, 0x20, 0x00, 39, 2,      /* keep symbol in  original case */
2688     0xf1, 0xce, 0x20, 0x00, 38          /* set object type relocateable to x */
2689   };
2690
2691 CONST static unsigned char envi[] =
2692   {
2693     0xf0, 0x21, 0x00,
2694
2695 /*    0xf1, 0xce, 0x21, 00, 50, 0x82, 0x07, 0xc7, 0x09, 0x11, 0x11,
2696     0x19, 0x2c,
2697 */
2698     0xf1, 0xce, 0x21, 00, 52, 0x00, /* exec ok */
2699
2700     0xf1, 0xce, 0x21, 0, 53, 0x03,      /* host unix */
2701 /*    0xf1, 0xce, 0x21, 0, 54, 2,1,1    tool & version # */
2702   };
2703
2704 static
2705 void
2706 DEFUN(ieee_write_me_part,(abfd),
2707       bfd *abfd)
2708 {
2709   ieee_data_type *ieee= IEEE_DATA(abfd);
2710   ieee->w.r.trailer_part = bfd_tell(abfd);
2711   if (abfd->start_address) {
2712     ieee->w.r.me_record = bfd_tell(abfd);
2713     ieee_write_2bytes(abfd, ieee_value_starting_address_enum);
2714     ieee_write_byte(abfd, ieee_function_either_open_b_enum);
2715     ieee_write_int(abfd, abfd->start_address);
2716     ieee_write_byte(abfd, ieee_function_either_close_b_enum);
2717   }
2718   else {
2719     ieee->w.r.me_record = bfd_tell(abfd);
2720   }
2721   ieee_write_byte(abfd, ieee_module_end_enum);
2722
2723 }
2724 boolean
2725 DEFUN(ieee_write_object_contents,(abfd),
2726       bfd *abfd)
2727 {
2728   ieee_data_type *ieee = IEEE_DATA(abfd);
2729   unsigned int i;
2730   file_ptr   old;
2731   /* Fast forward over the header area */
2732   bfd_seek(abfd, (file_ptr) 0, SEEK_SET);
2733   ieee_write_byte(abfd, ieee_module_beginning_enum);
2734
2735   ieee_write_id(abfd, bfd_printable_name(abfd));
2736   ieee_write_id(abfd, abfd->filename);
2737
2738   /* Fast forward over the variable bits */
2739   ieee_write_byte(abfd, ieee_address_descriptor_enum);
2740
2741   /* Bits per MAU */
2742   ieee_write_byte(abfd, bfd_arch_bits_per_byte(abfd));
2743   /* MAU's per address */
2744   ieee_write_byte(abfd, bfd_arch_bits_per_address(abfd)  /
2745                   bfd_arch_bits_per_byte(abfd));
2746
2747   old = bfd_tell(abfd);
2748   bfd_seek(abfd, (file_ptr) (8 * N_W_VARIABLES), SEEK_CUR);
2749
2750   ieee->w.r.extension_record = bfd_tell(abfd);
2751   bfd_write((char *)exten, 1, sizeof(exten), abfd);
2752   if (abfd->flags & EXEC_P)
2753     ieee_write_byte(abfd, 0x1); /* Absolute */
2754   else
2755     ieee_write_byte(abfd, 0x2); /* Relocateable */
2756
2757   ieee->w.r.environmental_record = bfd_tell(abfd);
2758   bfd_write((char *)envi, 1, sizeof(envi), abfd);
2759   output_bfd = abfd;
2760   flush();
2761
2762   ieee_write_section_part(abfd);
2763   /*
2764     First write the symbols, this changes their values into table
2765     indeces so we cant use it after this point
2766     */
2767   ieee_write_external_part(abfd);
2768   /*  ieee_write_byte(abfd, ieee_record_seperator_enum);*/
2769
2770
2771   /*  ieee_write_byte(abfd, ieee_record_seperator_enum);*/
2772
2773
2774   /*
2775     Write any debugs we have been told about
2776     */
2777   ieee_write_debug_part(abfd);
2778
2779   /*
2780     Can only write the data once the symbols have been written since
2781     the data contains relocation information which points to the
2782     symbols
2783     */
2784   ieee_write_data_part(abfd);
2785
2786
2787   /*
2788     At the end we put the end !
2789     */
2790   ieee_write_me_part(abfd);
2791
2792
2793   /* Generate the header */
2794   bfd_seek(abfd, old, SEEK_SET);
2795
2796   for (i= 0; i < N_W_VARIABLES; i++) {
2797     ieee_write_2bytes(abfd,ieee_assign_value_to_variable_enum);
2798     ieee_write_byte(abfd, i);
2799     ieee_write_int5_out(abfd, ieee->w.offset[i]);
2800   }
2801   return true;
2802 }
2803
2804
2805
2806 \f
2807 /* Native-level interface to symbols. */
2808
2809 /* We read the symbols into a buffer, which is discarded when this
2810 function exits.  We read the strings into a buffer large enough to
2811 hold them all plus all the cached symbol entries. */
2812
2813 asymbol *
2814 DEFUN(ieee_make_empty_symbol,(abfd),
2815       bfd *abfd)
2816 {
2817
2818   ieee_symbol_type  *new =
2819     (ieee_symbol_type *)zalloc (sizeof (ieee_symbol_type));
2820   new->symbol.the_bfd = abfd;
2821   return &new->symbol;
2822
2823 }
2824
2825 static bfd *
2826 DEFUN(ieee_openr_next_archived_file,(arch, prev),
2827       bfd *arch AND
2828       bfd *prev)
2829 {
2830   ieee_ar_data_type *ar = IEEE_AR_DATA(arch);
2831   /* take the next one from the arch state, or reset */
2832   if (prev == (bfd *)NULL) {
2833     /* Reset the index - the first two entries are bogus*/
2834     ar->element_index = 2;
2835   }
2836   while (true) {
2837     ieee_ar_obstack_type *p = ar->elements + ar->element_index;
2838     ar->element_index++;
2839     if (ar->element_index <= ar->element_count) {
2840       if (p->file_offset != (file_ptr)0) {
2841         if (p->abfd == (bfd *)NULL) {
2842           p->abfd = _bfd_create_empty_archive_element_shell(arch);
2843           p->abfd->origin = p->file_offset;
2844         }
2845         return p->abfd;
2846       }
2847     }
2848     else {
2849       bfd_error = no_more_archived_files;
2850       return (bfd *)NULL;
2851     }
2852
2853   }
2854 }
2855
2856 static boolean
2857 ieee_find_nearest_line(abfd,
2858                          section,
2859                          symbols,
2860                          offset,
2861                          filename_ptr,
2862                          functionname_ptr,
2863                          line_ptr)
2864 bfd *abfd;
2865 asection *section;
2866 asymbol **symbols;
2867 bfd_vma offset;
2868 char **filename_ptr;
2869 char **functionname_ptr;
2870 int *line_ptr;
2871 {
2872   return false;
2873 }
2874
2875
2876 static int
2877 ieee_generic_stat_arch_elt(abfd, buf)
2878 bfd *abfd;
2879 struct stat *buf;
2880 {
2881   ieee_ar_data_type *ar = abfd->my_archive->tdata.ieee_ar_data;
2882   if (ar == (ieee_ar_data_type *)NULL) {
2883     bfd_error = invalid_operation;
2884     return -1;
2885   }
2886   else {
2887     buf->st_size = 0x1;
2888     buf->st_mode = 0666;
2889     return !    ieee_object_p(abfd);
2890   }
2891 }
2892 static int
2893 DEFUN(ieee_sizeof_headers,(abfd, x),
2894       bfd *abfd AND
2895       boolean x)
2896 {
2897   return 0;
2898 }
2899
2900
2901
2902 static void
2903 DEFUN(ieee_bfd_debug_info_start,(abfd),
2904       bfd *abfd)
2905   {
2906
2907   }
2908
2909 static void
2910 DEFUN(ieee_bfd_debug_info_end,(abfd),
2911       bfd *abfd)
2912   {
2913
2914   }
2915
2916
2917 /* Add this section to the list of sections we have debug info for, to
2918    be ready to output it at close time
2919    */
2920 static void
2921 DEFUN(ieee_bfd_debug_info_accumulate,(abfd, section),
2922       bfd *abfd AND
2923       asection *section)
2924 {
2925   ieee_data_type *ieee = IEEE_DATA(section->owner);
2926   ieee_data_type *output_ieee = IEEE_DATA(abfd);
2927   /* can only accumulate data from other ieee bfds */
2928   if (section->owner->xvec != abfd->xvec)
2929     return;
2930   /* Only bother once per bfd */
2931   if (ieee->done_debug == true)
2932     return;
2933   ieee->done_debug = true;
2934
2935   /* Don't bother if there is no debug info */
2936   if (ieee->w.r.debug_information_part == 0)
2937     return;
2938
2939
2940   /* Add to chain */
2941     {
2942       bfd_chain_type *n = (bfd_chain_type *) bfd_alloc(abfd, sizeof(bfd_chain_type));
2943       n->this = section->owner;
2944       n->next = (bfd_chain_type *)NULL;
2945
2946       if (output_ieee->chain_head) {
2947         output_ieee->chain_head->next = n;
2948       }
2949       else {
2950         output_ieee->chain_root = n;
2951
2952       }
2953         output_ieee->chain_head = n;
2954     }
2955 }
2956
2957
2958
2959
2960
2961
2962 #define FOO PROTO
2963 #define ieee_core_file_failing_command (char *(*)())(bfd_nullvoidptr)
2964 #define ieee_core_file_failing_signal (int (*)())bfd_0
2965 #define ieee_core_file_matches_executable_p ( FOO(boolean, (*),(bfd *, bfd *)))bfd_false
2966 #define ieee_slurp_armap bfd_true
2967 #define ieee_slurp_extended_name_table bfd_true
2968 #define ieee_truncate_arname (void (*)())bfd_nullvoidptr
2969 #define ieee_write_armap  (FOO( boolean, (*),(bfd *, unsigned int, struct orl *, unsigned int, int))) bfd_nullvoidptr
2970 #define ieee_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
2971 #define ieee_close_and_cleanup          bfd_generic_close_and_cleanup
2972 #define ieee_set_arch_mach bfd_default_set_arch_mach
2973 #define ieee_bfd_get_relocated_section_contents  bfd_generic_get_relocated_section_contents
2974 #define ieee_bfd_relax_section bfd_generic_relax_section
2975 #define ieee_bfd_seclet_link bfd_generic_seclet_link
2976 #define ieee_bfd_reloc_type_lookup \
2977   ((CONST struct reloc_howto_struct *(*) PARAMS ((bfd *, bfd_reloc_code_real_type))) bfd_nullvoidptr)
2978 #define ieee_bfd_make_debug_symbol \
2979   ((asymbol *(*) PARAMS ((bfd *, void *, unsigned long))) bfd_nullvoidptr)
2980
2981 /*SUPPRESS 460 */
2982 bfd_target ieee_vec =
2983 {
2984   "ieee",                       /* name */
2985   bfd_target_ieee_flavour,
2986   true,                         /* target byte order */
2987   true,                         /* target headers byte order */
2988   (HAS_RELOC | EXEC_P |         /* object flags */
2989    HAS_LINENO | HAS_DEBUG |
2990    HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
2991   ( SEC_CODE|SEC_DATA|SEC_ROM|SEC_HAS_CONTENTS
2992    |SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
2993    0,                           /* leading underscore */
2994   ' ',                          /* ar_pad_char */
2995   16,                           /* ar_max_namelen */
2996     1,                          /* minimum alignment */
2997 _do_getb64, _do_putb64, _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* data */
2998 _do_getb64, _do_putb64,  _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* hdrs */
2999
3000   { _bfd_dummy_target,
3001      ieee_object_p,             /* bfd_check_format */
3002      ieee_archive_p,
3003     _bfd_dummy_target,
3004      },
3005   {
3006     bfd_false,
3007     ieee_mkobject,
3008     _bfd_generic_mkarchive,
3009     bfd_false
3010     },
3011   {
3012     bfd_false,
3013     ieee_write_object_contents,
3014     _bfd_write_archive_contents,
3015     bfd_false,
3016   },
3017   JUMP_TABLE(ieee),
3018   (PTR) 0
3019 };
3020