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