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