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