projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* libbfd.c (bfd_zmalloc): Call bfd_xmalloc instead of malloc.
[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 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 <= 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 <= 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,complain_overflow_bitfield,0,"abs32",true,0xffffffff, 0xffffffff,false);
364 static
365 reloc_howto_type abs16_howto
366 = HOWTO(1,0,1,16,false,0,complain_overflow_bitfield,0,"abs16",true,0x0000ffff, 0x0000ffff,false);
367
368 static
369 reloc_howto_type abs8_howto
370 = HOWTO(1,0,0,8,false,0,complain_overflow_bitfield,0,"abs8",true,0x000000ff, 0x000000ff,false);
371
372 static
373 reloc_howto_type rel32_howto
374 = HOWTO(1,0,2,32,true,0,complain_overflow_signed,0,"rel32",true,0xffffffff,
375 0xffffffff,false);
376
377 static
378 reloc_howto_type rel16_howto
379 = HOWTO(1,0,1,16,true,0,complain_overflow_signed,0,"rel16",true,0x0000ffff, 0x0000ffff,false);
380
381 static
382 reloc_howto_type rel8_howto
383 = HOWTO(1,0,0,8,true,0,complain_overflow_signed,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 unsigned char 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 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 unsigned char buffer[300];
1126 ieee_data_type *save = IEEE_DATA(abfd);
1127
1128 abfd->tdata.ieee_data = 0;
1129 ieee_mkobject(abfd);
1130
1131 ieee = IEEE_DATA(abfd);
1132 bfd_seek(abfd, (file_ptr) 0, SEEK_SET);
1133 /* Read the first few bytes in to see if it makes sense */
1134 bfd_read((PTR)buffer, 1, sizeof(buffer), abfd);
1135
1136 ieee->h.input_p = buffer;
1137 if (this_byte_and_next(&(ieee->h)) != Module_Beginning) goto fail;
1138
1139 ieee->read_symbols= false;
1140 ieee->read_data= false;
1141 ieee->section_count = 0;
1142 ieee->external_symbol_max_index = 0;
1143 ieee->external_symbol_min_index = IEEE_PUBLIC_BASE;
1144 ieee->external_reference_min_index =IEEE_REFERENCE_BASE;
1145 ieee->external_reference_max_index = 0;
1146 ieee->h.abfd = abfd;
1147 memset((PTR)ieee->section_table, 0, sizeof(ieee->section_table));
1148
1149 processor = ieee->mb.processor = read_id(&(ieee->h));
1150 if (strcmp(processor,"LIBRARY") == 0) goto fail;
1151 ieee->mb.module_name = read_id(&(ieee->h));
1152 if (abfd->filename == (CONST char *)NULL) {
1153 abfd->filename = ieee->mb.module_name;
1154 }
1155 /* Determine the architecture and machine type of the object file.
1156 */
1157 {
1158 bfd_arch_info_type *arch = bfd_scan_arch(processor);
1159 if (arch == 0) goto fail;
1160 abfd->arch_info = arch;
1161 }
1162
1163 if (this_byte(&(ieee->h)) != (int)ieee_address_descriptor_enum) {
1164 goto fail;
1165 }
1166 next_byte(&(ieee->h));
1167
1168 if (parse_int(&(ieee->h), &ieee->ad.number_of_bits_mau) == false) {
1169 goto fail;
1170 }
1171 if(parse_int(&(ieee->h), &ieee->ad.number_of_maus_in_address) == false) {
1172 goto fail;
1173 }
1174
1175 /* If there is a byte order info, take it */
1176 if (this_byte(&(ieee->h)) == (int)ieee_variable_L_enum ||
1177 this_byte(&(ieee->h)) == (int)ieee_variable_M_enum)
1178 next_byte(&(ieee->h));
1179
1180
1181 for (part = 0; part < N_W_VARIABLES; part++) {
1182 boolean ok;
1183 if (read_2bytes(&(ieee->h)) != (int) ieee_assign_value_to_variable_enum) {
1184 goto fail;
1185 }
1186 if (this_byte_and_next(&(ieee->h)) != part) {
1187 goto fail;
1188 }
1189
1190 ieee->w.offset[part] = parse_i(&(ieee->h), &ok);
1191 if (ok==false) {
1192 goto fail;
1193 }
1194
1195 }
1196 abfd->flags = HAS_SYMS;
1197 /* By now we know that this is a real IEEE file, we're going to read
1198 the whole thing into memory so that we can run up and down it
1199 quickly. We can work out how big the file is from the trailer
1200 record */
1201
1202 IEEE_DATA(abfd)->h.first_byte = (unsigned char *) bfd_alloc(ieee->h.abfd, ieee->w.r.me_record
1203 + 50);
1204 bfd_seek(abfd, (file_ptr) 0, SEEK_SET);
1205 bfd_read((PTR)(IEEE_DATA(abfd)->h.first_byte), 1, ieee->w.r.me_record+50, abfd);
1206
1207 ieee_slurp_sections(abfd);
1208 return abfd->xvec;
1209 fail:
1210 (void) bfd_release(abfd, ieee);
1211 abfd->tdata.ieee_data = save;
1212 return (bfd_target *)NULL;
1213 }
1214
1215 void
1216 DEFUN(ieee_get_symbol_info,(ignore_abfd, symbol, ret),
1217 bfd *ignore_abfd AND
1218 asymbol *symbol AND
1219 symbol_info *ret)
1220 {
1221 bfd_symbol_info (symbol, ret);
1222 if (symbol->name[0] == ' ')
1223 ret->name = "* empty table entry ";
1224 if (!symbol->section)
1225 ret->type = (symbol->flags & BSF_LOCAL) ? 'a' : 'A';
1226 }
1227
1228 void
1229 DEFUN(ieee_print_symbol,(ignore_abfd, afile, symbol, how),
1230 bfd *ignore_abfd AND
1231 PTR afile AND
1232 asymbol *symbol AND
1233 bfd_print_symbol_type how)
1234 {
1235 FILE *file = (FILE *)afile;
1236
1237 switch (how) {
1238 case bfd_print_symbol_name:
1239 fprintf(file,"%s", symbol->name);
1240 break;
1241 case bfd_print_symbol_more:
1242 #if 0
1243 fprintf(file,"%4x %2x",aout_symbol(symbol)->desc & 0xffff,
1244 aout_symbol(symbol)->other & 0xff);
1245 #endif
1246 BFD_FAIL();
1247 break;
1248 case bfd_print_symbol_all:
1249 {
1250 CONST char *section_name = symbol->section == (asection *)NULL ?
1251 (CONST char *)"*abs" : symbol->section->name;
1252 if (symbol->name[0] == ' ') {
1253 fprintf(file,"* empty table entry ");
1254 }
1255 else {
1256 bfd_print_symbol_vandf((PTR)file,symbol);
1257
1258 fprintf(file," %-5s %04x %02x %s",
1259 section_name,
1260 (unsigned) ieee_symbol(symbol)->index,
1261 (unsigned) 0, /*
1262 aout_symbol(symbol)->desc & 0xffff,
1263 aout_symbol(symbol)->other & 0xff,*/
1264 symbol->name);
1265 }
1266 }
1267 break;
1268 }
1269 }
1270
1271
1272 static void
1273 DEFUN(do_one,(ieee, current_map, location_ptr,s),
1274 ieee_data_type *ieee AND
1275 ieee_per_section_type *current_map AND
1276 unsigned char *location_ptr AND
1277 asection *s)
1278 {
1279 switch (this_byte(&(ieee->h)))
1280 {
1281 case ieee_load_constant_bytes_enum:
1282 {
1283 unsigned int number_of_maus;
1284 unsigned int i;
1285 next_byte(&(ieee->h));
1286 number_of_maus = must_parse_int(&(ieee->h));
1287
1288 for (i = 0; i < number_of_maus; i++) {
1289 location_ptr[current_map->pc++]= this_byte(&(ieee->h));
1290 next_byte(&(ieee->h));
1291 }
1292 }
1293 break;
1294
1295 case ieee_load_with_relocation_enum:
1296 {
1297 boolean loop = true;
1298 next_byte(&(ieee->h));
1299 while (loop)
1300 {
1301 switch (this_byte(&(ieee->h)))
1302 {
1303 case ieee_variable_R_enum:
1304
1305 case ieee_function_signed_open_b_enum:
1306 case ieee_function_unsigned_open_b_enum:
1307 case ieee_function_either_open_b_enum:
1308 {
1309 unsigned int extra = 4;
1310 boolean pcrel = false;
1311 asection *section;
1312 ieee_reloc_type *r =
1313 (ieee_reloc_type *) bfd_alloc(ieee->h.abfd,
1314 sizeof(ieee_reloc_type));
1315
1316 *(current_map->reloc_tail_ptr) = r;
1317 current_map->reloc_tail_ptr= &r->next;
1318 r->next = (ieee_reloc_type *)NULL;
1319 next_byte(&(ieee->h));
1320 /* abort();*/
1321 r->relent.sym_ptr_ptr = 0;
1322 parse_expression(ieee,
1323 &r->relent.addend,
1324 &r->symbol,
1325 &pcrel, &extra, &section);
1326 r->relent.address = current_map->pc;
1327 s->reloc_count++;
1328 if (r->relent.sym_ptr_ptr == 0) {
1329 r->relent.sym_ptr_ptr = section->symbol_ptr_ptr;
1330 }
1331
1332 if (this_byte(&(ieee->h)) == (int)ieee_comma) {
1333 next_byte(&(ieee->h));
1334 /* Fetch number of bytes to pad */
1335 extra = must_parse_int(&(ieee->h));
1336 };
1337
1338 switch (this_byte(&(ieee->h))) {
1339 case ieee_function_signed_close_b_enum:
1340 next_byte(&(ieee->h));
1341 break;
1342 case ieee_function_unsigned_close_b_enum:
1343 next_byte(&(ieee->h));
1344 break;
1345 case ieee_function_either_close_b_enum:
1346 next_byte(&(ieee->h));
1347 break;
1348 default:
1349 break;
1350 }
1351 /* Build a relocation entry for this type */
1352 /* If pc rel then stick -ve pc into instruction
1353 and take out of reloc ..
1354
1355 I've changed this. It's all too
1356 complicated. I keep 0 in the
1357 instruction now.
1358 */
1359
1360 switch (extra)
1361 {
1362 case 0:
1363 case 4:
1364
1365 if (pcrel == true)
1366 {
1367 #if KEEPMINUSPCININST
1368 bfd_put_32(ieee->h.abfd, -current_map->pc, location_ptr +
1369 current_map->pc);
1370 r->relent.howto = &rel32_howto;
1371 r->relent.addend -=
1372 current_map->pc;
1373 #else
1374 bfd_put_32(ieee->h.abfd,0, location_ptr +
1375 current_map->pc);
1376 r->relent.howto = &rel32_howto;
1377 #endif
1378 }
1379 else
1380 {
1381 bfd_put_32(ieee->h.abfd, 0, location_ptr +
1382 current_map->pc);
1383 r->relent.howto = &abs32_howto;
1384 }
1385 current_map->pc +=4;
1386 break;
1387 case 2:
1388 if (pcrel == true) {
1389 #if KEEPMINUSPCININST
1390 bfd_put_16(ieee->h.abfd, (int)(-current_map->pc), location_ptr +current_map->pc);
1391 r->relent.addend -= current_map->pc;
1392 r->relent.howto = &rel16_howto;
1393 #else
1394
1395 bfd_put_16(ieee->h.abfd, 0, location_ptr +current_map->pc);
1396 r->relent.howto = &rel16_howto;
1397 #endif
1398 }
1399
1400 else {
1401 bfd_put_16(ieee->h.abfd, 0, location_ptr +current_map->pc);
1402 r->relent.howto = &abs16_howto;
1403 }
1404 current_map->pc +=2;
1405 break;
1406 case 1:
1407 if (pcrel == true) {
1408 #if KEEPMINUSPCININST
1409 bfd_put_8(ieee->h.abfd, (int)(-current_map->pc), location_ptr +current_map->pc);
1410 r->relent.addend -= current_map->pc;
1411 r->relent.howto = &rel8_howto;
1412 #else
1413 bfd_put_8(ieee->h.abfd,0, location_ptr +current_map->pc);
1414 r->relent.howto = &rel8_howto;
1415 #endif
1416 }
1417 else {
1418 bfd_put_8(ieee->h.abfd, 0, location_ptr +current_map->pc);
1419 r->relent.howto = &abs8_howto;
1420 }
1421 current_map->pc +=1;
1422 break;
1423
1424 default:
1425 BFD_FAIL();
1426 break;
1427 }
1428 }
1429 break;
1430 default:
1431 {
1432 bfd_vma this_size ;
1433 if (parse_int(&(ieee->h), &this_size) == true) {
1434 unsigned int i;
1435 for (i = 0; i < this_size; i++) {
1436 location_ptr[current_map->pc ++] = this_byte(&(ieee->h));
1437 next_byte(&(ieee->h));
1438 }
1439 }
1440 else {
1441 loop = false;
1442 }
1443 }
1444 }
1445 }
1446 }
1447 }
1448 }
1449
1450 /* Read in all the section data and relocation stuff too */
1451 static boolean
1452 DEFUN(ieee_slurp_section_data,(abfd),
1453 bfd *abfd)
1454 {
1455 bfd_byte *location_ptr = (bfd_byte *)NULL;
1456 ieee_data_type *ieee = IEEE_DATA(abfd);
1457 unsigned int section_number ;
1458
1459 ieee_per_section_type *current_map = (ieee_per_section_type *)NULL;
1460 asection *s;
1461 /* Seek to the start of the data area */
1462 if (ieee->read_data== true) return true;
1463 ieee->read_data = true;
1464 ieee_seek(abfd, ieee->w.r.data_part);
1465
1466 /* Allocate enough space for all the section contents */
1467
1468
1469 for (s = abfd->sections; s != (asection *)NULL; s = s->next) {
1470 ieee_per_section_type *per = (ieee_per_section_type *) s->used_by_bfd;
1471 per->data = (bfd_byte *) bfd_alloc(ieee->h.abfd, s->_raw_size);
1472 /*SUPPRESS 68*/
1473 per->reloc_tail_ptr =
1474 (ieee_reloc_type **)&(s->relocation);
1475 }
1476
1477
1478
1479 while (true) {
1480 switch (this_byte(&(ieee->h)))
1481 {
1482 /* IF we see anything strange then quit */
1483 default:
1484 return true;
1485
1486 case ieee_set_current_section_enum:
1487 next_byte(&(ieee->h));
1488 section_number = must_parse_int(&(ieee->h));
1489 s = ieee->section_table[section_number];
1490 current_map = (ieee_per_section_type *) s->used_by_bfd;
1491 location_ptr = current_map->data - s->vma;
1492 /* The document I have says that Microtec's compilers reset */
1493 /* this after a sec section, even though the standard says not */
1494 /* to. SO .. */
1495 current_map->pc =s->vma;
1496 break;
1497
1498
1499 case ieee_e2_first_byte_enum:
1500 next_byte(&(ieee->h));
1501 switch (this_byte(&(ieee->h)))
1502 {
1503 case ieee_set_current_pc_enum & 0xff:
1504 {
1505 bfd_vma value;
1506 ieee_symbol_index_type symbol;
1507 unsigned int extra;
1508 boolean pcrel;
1509 next_byte(&(ieee->h));
1510 must_parse_int(&(ieee->h)); /* Thow away section #*/
1511 parse_expression(ieee, &value,
1512 &symbol,
1513 &pcrel, &extra,
1514 0);
1515 current_map->pc = value;
1516 BFD_ASSERT((unsigned)(value - s->vma) <= s->_raw_size);
1517 }
1518 break;
1519
1520 case ieee_value_starting_address_enum & 0xff:
1521 /* We've got to the end of the data now - */
1522 return true;
1523 default:
1524 BFD_FAIL();
1525 return true;
1526 }
1527 break;
1528 case ieee_repeat_data_enum:
1529 {
1530 /* Repeat the following LD or LR n times - we do this by
1531 remembering the stream pointer before running it and
1532 resetting it and running it n times. We special case
1533 the repetition of a repeat_data/load_constant
1534 */
1535
1536 unsigned int iterations ;
1537 unsigned char *start ;
1538 next_byte(&(ieee->h));
1539 iterations = must_parse_int(&(ieee->h));
1540 start = ieee->h.input_p;
1541 if (start[0] == (int)ieee_load_constant_bytes_enum &&
1542 start[1] == 1) {
1543 while (iterations != 0) {
1544 location_ptr[current_map->pc++] = start[2];
1545 iterations--;
1546 }
1547 next_byte(&(ieee->h));
1548 next_byte(&(ieee->h));
1549 next_byte(&(ieee->h));
1550 }
1551 else {
1552 while (iterations != 0) {
1553 ieee->h.input_p = start;
1554 do_one(ieee, current_map, location_ptr,s);
1555 iterations --;
1556 }
1557 }
1558 }
1559 break;
1560 case ieee_load_constant_bytes_enum:
1561 case ieee_load_with_relocation_enum:
1562 {
1563 do_one(ieee, current_map, location_ptr,s);
1564 }
1565 }
1566 }
1567 }
1568
1569
1570
1571
1572
1573 boolean
1574 DEFUN(ieee_new_section_hook,(abfd, newsect),
1575 bfd *abfd AND
1576 asection *newsect)
1577 {
1578 newsect->used_by_bfd = (PTR)
1579 bfd_alloc(abfd, sizeof(ieee_per_section_type));
1580 ieee_per_section( newsect)->data = (bfd_byte *)NULL;
1581 ieee_per_section(newsect)->section = newsect;
1582 return true;
1583 }
1584
1585
1586 unsigned int
1587 DEFUN(ieee_get_reloc_upper_bound,(abfd, asect),
1588 bfd *abfd AND
1589 sec_ptr asect)
1590 {
1591 ieee_slurp_section_data(abfd);
1592 return (asect->reloc_count+1) * sizeof(arelent *);
1593 }
1594
1595 static boolean
1596 DEFUN(ieee_get_section_contents,(abfd, section, location, offset, count),
1597 bfd *abfd AND
1598 sec_ptr section AND
1599 PTR location AND
1600 file_ptr offset AND
1601 bfd_size_type count)
1602 {
1603 ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;
1604 ieee_slurp_section_data(abfd);
1605 (void) memcpy((PTR)location, (PTR)(p->data + offset), (unsigned)count);
1606 return true;
1607 }
1608
1609
1610 unsigned int
1611 DEFUN(ieee_canonicalize_reloc,(abfd, section, relptr, symbols),
1612 bfd *abfd AND
1613 sec_ptr section AND
1614 arelent **relptr AND
1615 asymbol **symbols)
1616 {
1617 /* ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd;*/
1618 ieee_reloc_type *src = (ieee_reloc_type *)(section->relocation);
1619 ieee_data_type *ieee = IEEE_DATA(abfd);
1620
1621 while (src != (ieee_reloc_type *)NULL) {
1622 /* Work out which symbol to attach it this reloc to */
1623 switch (src->symbol.letter) {
1624 case 'X':
1625 src->relent.sym_ptr_ptr =
1626 symbols + src->symbol.index + ieee->external_reference_base_offset;
1627 break;
1628 case 0:
1629 src->relent.sym_ptr_ptr =
1630 src->relent.sym_ptr_ptr[0]->section->symbol_ptr_ptr;
1631 break;
1632 default:
1633
1634 BFD_FAIL();
1635 }
1636 *relptr++ = &src->relent;
1637 src = src->next;
1638 }
1639 *relptr = (arelent *)NULL;
1640 return section->reloc_count;
1641 }
1642
1643
1644
1645 static int
1646 DEFUN(comp,(ap, bp),
1647 CONST PTR ap AND
1648 CONST PTR bp)
1649 {
1650 arelent *a = *((arelent **)ap);
1651 arelent *b = *((arelent **)bp);
1652 return a->address - b->address;
1653 }
1654
1655 /*
1656 Write the section headers
1657 */
1658
1659 static void
1660 DEFUN(ieee_write_section_part,(abfd),
1661 bfd *abfd)
1662 {
1663 ieee_data_type *ieee = IEEE_DATA(abfd);
1664 asection *s;
1665 ieee->w.r.section_part = bfd_tell(abfd);
1666 for (s = abfd->sections; s != (asection *)NULL; s=s->next) {
1667 if (s != &bfd_abs_section)
1668 {
1669
1670 ieee_write_byte(abfd, ieee_section_type_enum);
1671 ieee_write_byte(abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE));
1672
1673 if (abfd->flags & EXEC_P)
1674 {
1675 /* This image is executable, so output absolute sections */
1676 ieee_write_byte(abfd, ieee_variable_A_enum);
1677 ieee_write_byte(abfd, ieee_variable_S_enum);
1678 }
1679 else
1680 {
1681 ieee_write_byte(abfd, ieee_variable_C_enum);
1682 }
1683
1684 switch (s->flags &(SEC_CODE | SEC_DATA | SEC_ROM))
1685 {
1686 case SEC_CODE | SEC_LOAD:
1687 case SEC_CODE:
1688 ieee_write_byte(abfd, ieee_variable_P_enum);
1689 break;
1690 case SEC_DATA:
1691 default:
1692 ieee_write_byte(abfd, ieee_variable_D_enum);
1693 break;
1694 case SEC_ROM:
1695 case SEC_ROM | SEC_DATA:
1696 case SEC_ROM | SEC_LOAD:
1697 case SEC_ROM | SEC_DATA | SEC_LOAD:
1698
1699 ieee_write_byte(abfd, ieee_variable_R_enum);
1700 }
1701
1702
1703 ieee_write_id(abfd, s->name);
1704 #if 0
1705 ieee_write_int(abfd, 0); /* Parent */
1706 ieee_write_int(abfd, 0); /* Brother */
1707 ieee_write_int(abfd, 0); /* Context */
1708 #endif
1709 /* Alignment */
1710 ieee_write_byte(abfd, ieee_section_alignment_enum);
1711 ieee_write_byte(abfd, (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE));
1712 ieee_write_int(abfd, 1 << s->alignment_power);
1713
1714 /* Size */
1715 ieee_write_2bytes(abfd, ieee_section_size_enum);
1716 ieee_write_byte(abfd, (bfd_byte)(s->index + IEEE_SECTION_NUMBER_BASE));
1717 ieee_write_int(abfd, s->_raw_size);
1718 if (abfd->flags & EXEC_P) {
1719 /* Relocateable sections don't have asl records */
1720 /* Vma */
1721 ieee_write_2bytes(abfd, ieee_section_base_address_enum);
1722 ieee_write_byte(abfd,
1723 (bfd_byte)(s->index + IEEE_SECTION_NUMBER_BASE));
1724 ieee_write_int(abfd, s->vma);
1725 }
1726 }
1727
1728 }
1729 }
1730
1731
1732
1733 static void
1734 DEFUN(do_with_relocs,(abfd, s),
1735 bfd *abfd AND
1736 asection *s)
1737 {
1738 unsigned int relocs_to_go = s->reloc_count;
1739
1740
1741 bfd_byte *stream = ieee_per_section(s)->data;
1742 arelent **p = s->orelocation;
1743
1744 bfd_size_type current_byte_index = 0;
1745
1746 qsort(s->orelocation,
1747 relocs_to_go,
1748 sizeof(arelent **),
1749 comp);
1750
1751 /* Output the section preheader */
1752 ieee_write_byte(abfd, ieee_set_current_section_enum);
1753 ieee_write_byte(abfd, (bfd_byte)(s->index + IEEE_SECTION_NUMBER_BASE));
1754
1755 ieee_write_twobyte(abfd, ieee_set_current_pc_enum);
1756 ieee_write_byte(abfd, (bfd_byte)(s->index + IEEE_SECTION_NUMBER_BASE));
1757 ieee_write_expression(abfd, 0, s->symbol, 0, 0);
1758
1759 if (relocs_to_go == 0)
1760 {
1761 /* If there arn't any relocations then output the load constant byte
1762 opcode rather than the load with relocation opcode */
1763
1764 while (current_byte_index < s->_raw_size) {
1765 bfd_size_type run;
1766 unsigned int MAXRUN = 32;
1767 run = MAXRUN;
1768 if (run > s->_raw_size - current_byte_index) {
1769 run = s->_raw_size - current_byte_index;
1770 }
1771
1772 if (run != 0) {
1773 ieee_write_byte(abfd, ieee_load_constant_bytes_enum);
1774 /* Output a stream of bytes */
1775 ieee_write_int(abfd, run);
1776 bfd_write((PTR)(stream + current_byte_index),
1777 1,
1778 run,
1779 abfd);
1780 current_byte_index += run;
1781 }
1782 }
1783 }
1784 else
1785 {
1786 ieee_write_byte(abfd, ieee_load_with_relocation_enum);
1787
1788
1789 /* Output the data stream as the longest sequence of bytes
1790 possible, allowing for the a reasonable packet size and
1791 relocation stuffs */
1792
1793 if ((PTR)stream == (PTR)NULL) {
1794 /* Outputting a section without data, fill it up */
1795 stream = (unsigned char *)(bfd_alloc(abfd, s->_raw_size));
1796 memset((PTR)stream, 0, s->_raw_size);
1797 }
1798 while (current_byte_index < s->_raw_size) {
1799 bfd_size_type run;
1800 unsigned int MAXRUN = 32;
1801 if (relocs_to_go) {
1802 run = (*p)->address - current_byte_index;
1803 }
1804 else {
1805 run = MAXRUN;
1806 }
1807 if (run > s->_raw_size - current_byte_index) {
1808 run = s->_raw_size - current_byte_index;
1809 }
1810
1811 if (run != 0) {
1812 /* Output a stream of bytes */
1813 ieee_write_int(abfd, run);
1814 bfd_write((PTR)(stream + current_byte_index),
1815 1,
1816 run,
1817 abfd);
1818 current_byte_index += run;
1819 }
1820 /* Output any relocations here */
1821 if (relocs_to_go && (*p) && (*p)->address == current_byte_index) {
1822 while (relocs_to_go && (*p) && (*p)->address == current_byte_index) {
1823
1824 arelent *r = *p;
1825 bfd_vma ov;
1826
1827 #if 0
1828 if (r->howto->pc_relative) {
1829 r->addend += current_byte_index ;
1830 }
1831 #endif
1832
1833 switch (r->howto->size) {
1834 case 2:
1835
1836 ov = bfd_get_32(abfd,
1837 stream+current_byte_index);
1838 current_byte_index +=4;
1839 break;
1840 case 1:
1841 ov = bfd_get_16(abfd,
1842 stream+current_byte_index);
1843 current_byte_index +=2;
1844 break;
1845 case 0:
1846 ov = bfd_get_8(abfd,
1847 stream+current_byte_index);
1848 current_byte_index ++;
1849 break;
1850 default:
1851 ov = 0;
1852 BFD_FAIL();
1853 }
1854 ieee_write_byte(abfd, ieee_function_either_open_b_enum);
1855 /* abort();*/
1856
1857 if (r->sym_ptr_ptr != (asymbol **)NULL) {
1858 ieee_write_expression(abfd, r->addend + ov,
1859 *(r->sym_ptr_ptr),
1860 r->howto->pc_relative, s->index);
1861 }
1862 else {
1863 ieee_write_expression(abfd, r->addend + ov,
1864 (asymbol *)NULL,
1865 r->howto->pc_relative, s->index);
1866 }
1867
1868 if (1 || r->howto->size != 2) {
1869 ieee_write_byte(abfd, ieee_comma);
1870 ieee_write_int(abfd, 1<< r->howto->size);
1871 }
1872 ieee_write_byte(abfd,
1873 ieee_function_either_close_b_enum);
1874
1875 relocs_to_go --;
1876 p++;
1877 }
1878
1879 }
1880 }
1881 }
1882 }
1883
1884 /* If there are no relocations in the output section then we can
1885 be clever about how we write. We block items up into a max of 127
1886 bytes */
1887
1888 static void
1889 DEFUN(do_as_repeat, (abfd, s),
1890 bfd *abfd AND
1891 asection *s)
1892 {
1893 if (s->_raw_size) {
1894 ieee_write_byte(abfd, ieee_set_current_section_enum);
1895 ieee_write_byte(abfd, (bfd_byte)(s->index + IEEE_SECTION_NUMBER_BASE));
1896 ieee_write_byte(abfd, ieee_set_current_pc_enum >> 8);
1897 ieee_write_byte(abfd, ieee_set_current_pc_enum & 0xff);
1898 ieee_write_byte(abfd, (bfd_byte)(s->index + IEEE_SECTION_NUMBER_BASE));
1899 ieee_write_int(abfd, s->vma );
1900
1901 ieee_write_byte(abfd,ieee_repeat_data_enum);
1902 ieee_write_int(abfd, s->_raw_size);
1903 ieee_write_byte(abfd, ieee_load_constant_bytes_enum);
1904 ieee_write_byte(abfd, 1);
1905 ieee_write_byte(abfd, 0);
1906 }
1907 }
1908
1909 static void
1910 DEFUN(do_without_relocs, (abfd, s),
1911 bfd *abfd AND
1912 asection *s)
1913 {
1914 bfd_byte *stream = ieee_per_section(s)->data;
1915
1916 if (stream == 0 || ((s->flags & SEC_LOAD) == 0))
1917 {
1918 do_as_repeat(abfd, s);
1919 }
1920 else
1921 {
1922 unsigned int i;
1923 for (i = 0; i < s->_raw_size; i++) {
1924 if (stream[i] != 0) {
1925 do_with_relocs(abfd, s);
1926 return;
1927 }
1928 }
1929 do_as_repeat(abfd, s);
1930 }
1931
1932 }
1933
1934
1935 static unsigned char *output_ptr_start;
1936 static unsigned char *output_ptr;
1937 static unsigned char *output_ptr_end;
1938 static unsigned char *input_ptr_start;
1939 static unsigned char *input_ptr;
1940 static unsigned char *input_ptr_end;
1941 static bfd *input_bfd;
1942 static bfd *output_bfd;
1943 static int output_buffer;
1944
1945 static void fill()
1946 {
1947 bfd_read((PTR)input_ptr_start, 1, input_ptr_end - input_ptr_start, input_bfd);
1948 input_ptr = input_ptr_start;
1949 }
1950 static void flush()
1951 {
1952 bfd_write((PTR)(output_ptr_start),1,output_ptr - output_ptr_start, output_bfd);
1953 output_ptr = output_ptr_start;
1954 output_buffer++;
1955 }
1956
1957 #define THIS() ( *input_ptr )
1958 #define NEXT() { input_ptr++; if (input_ptr == input_ptr_end) fill(); }
1959 #define OUT(x) { *output_ptr++ = (x); if(output_ptr == output_ptr_end) flush(); }
1960
1961 static void write_int(value)
1962 int value;
1963 {
1964 if (value >= 0 && value <= 127) {
1965 OUT(value);
1966 }
1967 else {
1968 unsigned int length;
1969 /* How many significant bytes ? */
1970 /* FIXME FOR LONGER INTS */
1971 if (value & 0xff000000) {
1972 length = 4;
1973 }
1974 else if (value & 0x00ff0000) {
1975 length = 3;
1976 }
1977 else if (value & 0x0000ff00) {
1978 length = 2;
1979 }
1980 else length = 1;
1981
1982 OUT((int)ieee_number_repeat_start_enum + length);
1983 switch (length) {
1984 case 4:
1985 OUT( value >> 24);
1986 case 3:
1987 OUT( value >> 16);
1988 case 2:
1989 OUT( value >> 8);
1990 case 1:
1991 OUT( value);
1992 }
1993
1994 }
1995 }
1996 static void copy_id()
1997 {
1998 int length = THIS();
1999 char ch;
2000 OUT(length);
2001 NEXT();
2002 while (length--) {
2003 ch = THIS();
2004 OUT(ch);
2005 NEXT();
2006 }
2007 }
2008 #define VAR(x) ((x | 0x80))
2009 static void copy_expression()
2010 {
2011 int stack[10];
2012 int *tos = stack;
2013 int value = 0;
2014 while (1) {
2015 switch (THIS()) {
2016 case 0x84:
2017 NEXT();
2018 value = THIS(); NEXT();
2019 value = (value << 8) | THIS(); NEXT();
2020 value = (value << 8) | THIS(); NEXT();
2021 value = (value << 8) | THIS(); NEXT();
2022 *tos ++ = value;
2023 break;
2024 case 0x83:
2025 NEXT();
2026 value = THIS(); NEXT();
2027 value = (value << 8) | THIS(); NEXT();
2028 value = (value << 8) | THIS(); NEXT();
2029 *tos ++ = value;
2030 break;
2031 case 0x82:
2032 NEXT();
2033 value = THIS(); NEXT();
2034 value = (value << 8) | THIS(); NEXT();
2035 *tos ++ = value;
2036 break;
2037 case 0x81:
2038 NEXT();
2039 value = THIS(); NEXT();
2040 *tos ++ = value;
2041 break;
2042 case 0x80:
2043 NEXT();
2044 *tos ++ = 0;
2045 break;
2046 default:
2047 if (THIS() >0x84) {
2048 /* Not a number, just bug out with the answer */
2049 write_int(*(--tos));
2050 return;
2051 }
2052 *tos++ = THIS();
2053 NEXT();
2054 value = 0;
2055 break;
2056 case 0xa5:
2057 /* PLUS anything */
2058 {
2059 int value = *(--tos);
2060 value += *(--tos);
2061 *tos++ = value;
2062 NEXT();
2063 }
2064 break;
2065 case VAR('R') :
2066 {
2067 int section_number ;
2068 ieee_data_type *ieee;
2069 asection *s;
2070 NEXT();
2071 section_number = THIS();
2072
2073 NEXT();
2074 ieee= IEEE_DATA(input_bfd);
2075 s = ieee->section_table[section_number];
2076 if (s->output_section) {
2077 value = s->output_section->vma ;
2078 } else { value = 0; }
2079 value += s->output_offset;
2080 *tos++ = value;
2081 value = 0;
2082 }
2083 break;
2084 case 0x90:
2085 {
2086 NEXT();
2087 write_int(*(--tos));
2088 OUT(0x90);
2089 return;
2090
2091 }
2092 }
2093 }
2094
2095 }
2096
2097 /* Drop the int in the buffer, and copy a null into the gap, which we
2098 will overwrite later */
2099
2100 struct output_buffer_struct {
2101 unsigned char *ptrp;
2102 int buffer;
2103 } ;
2104
2105 static void
2106 DEFUN(fill_int,(buf),
2107 struct output_buffer_struct *buf)
2108 {
2109 if (buf->buffer == output_buffer) {
2110 /* Still a chance to output the size */
2111 int value = output_ptr - buf->ptrp + 3;
2112 buf->ptrp[0] = value >> 24;
2113 buf->ptrp[1] = value >> 16;
2114 buf->ptrp[2] = value >> 8;
2115 buf->ptrp[3] = value >> 0;
2116 }
2117
2118 }
2119 static void
2120 DEFUN(drop_int,(buf),
2121 struct output_buffer_struct *buf)
2122 {
2123 int type = THIS();
2124 int ch;
2125 if (type <= 0x84) {
2126 NEXT();
2127 switch(type) {
2128 case 0x84: ch = THIS(); NEXT();
2129 case 0x83: ch = THIS(); NEXT();
2130 case 0x82: ch = THIS(); NEXT();
2131 case 0x81: ch = THIS(); NEXT();
2132 case 0x80: break;
2133 }
2134 }
2135 OUT(0x84);
2136 buf->ptrp = output_ptr;
2137 buf->buffer = output_buffer;
2138 OUT(0);OUT(0);OUT(0);OUT(0);
2139 }
2140
2141 static void copy_int()
2142 {
2143 int type = THIS();
2144 int ch;
2145 if (type <= 0x84) {
2146 OUT(type);
2147 NEXT();
2148 switch(type) {
2149 case 0x84: ch = THIS(); NEXT(); OUT(ch);
2150 case 0x83: ch = THIS(); NEXT(); OUT(ch);
2151 case 0x82: ch = THIS(); NEXT(); OUT(ch);
2152 case 0x81: ch = THIS(); NEXT(); OUT(ch);
2153 case 0x80: break;
2154 }
2155 }
2156 }
2157
2158 #define ID copy_id()
2159 #define INT copy_int()
2160 #define EXP copy_expression()
2161 static void copy_till_end();
2162 #define INTn(q) copy_int()
2163 #define EXPn(q) copy_expression()
2164 static void f1_record()
2165 {
2166 int ch;
2167 /* ATN record */
2168 NEXT();
2169 ch = THIS();
2170 switch (ch)
2171 {
2172 default:
2173 OUT(0xf1); OUT(ch);
2174 break;
2175 case 0xc9:
2176 NEXT();
2177 OUT(0xf1); OUT(0xc9);
2178 INT; INT; ch = THIS();
2179 switch (ch)
2180 {
2181 case 0x16: NEXT();break;
2182 case 0x01: NEXT();break;
2183 case 0x00: NEXT(); INT; break;
2184 case 0x03: NEXT(); INT; break;
2185 case 0x13: EXPn(instruction address); break;
2186 default:
2187 break;
2188 }
2189 break;
2190 case 0xd8:
2191 /* EXternal ref */
2192 NEXT();
2193 OUT(0xf1); OUT(0xd8);
2194 EXP ; EXP; EXP; EXP;
2195 break;
2196 case 0xce:
2197 NEXT();
2198 OUT(0xf1);OUT(0xce); INT; INT; ch = THIS(); INT;
2199 switch (ch) {
2200 case 0x01:
2201 INT; INT; break;
2202 case 0x02:
2203 INT; break;
2204 case 0x04:
2205 EXPn(external function); break;
2206 case 0x05:
2207 break;
2208 case 0x07: INTn(line number); INT;
2209 case 0x08: break;
2210 case 0x0a: INTn(locked register); INT; break;
2211 case 0x3f: copy_till_end(); break;
2212 case 0x3e: copy_till_end(); break;
2213 case 0x40: copy_till_end(); break;
2214 case 0x41: ID; break;
2215 }
2216 }
2217
2218 }
2219 static void f0_record()
2220 {
2221 /* Attribute record */
2222 NEXT();
2223 OUT(0xf0);
2224 INTn(Symbol name );
2225 ID;
2226 }
2227 static void copy_till_end()
2228 {
2229 int ch = THIS();
2230 while (1) {
2231 while (ch <= 0x80)
2232 {
2233 OUT(ch);
2234 NEXT();
2235 ch = THIS();
2236 }
2237 switch (ch) {
2238 case 0x84:
2239 OUT(THIS());
2240 NEXT();
2241 case 0x83:
2242 OUT(THIS());
2243 NEXT();
2244 case 0x82:
2245 OUT(THIS());
2246 NEXT();
2247 case 0x81:
2248 OUT(THIS());
2249 NEXT();
2250 OUT(THIS());
2251 NEXT();
2252
2253 ch = THIS();
2254 break;
2255 default:
2256 return;
2257 }
2258 }
2259
2260 }
2261
2262 static void f2_record()
2263 {
2264 NEXT();
2265 OUT(0xf2);
2266 INT ;
2267 NEXT();
2268 OUT(0xce);
2269 INT ;
2270 copy_till_end();
2271 }
2272
2273
2274 static void block();
2275 static void f8_record()
2276 {
2277 int ch;
2278 NEXT();
2279 ch = THIS();
2280 switch (ch)
2281 {
2282 case 0x01:
2283 case 0x02:
2284 case 0x03:
2285 /* Unique typedefs for module */
2286 /* GLobal typedefs */
2287 /* High level module scope beginning */
2288 {
2289 struct output_buffer_struct ob;
2290 NEXT();
2291 OUT(0xf8); OUT(ch);
2292 drop_int(&ob); ID ;
2293
2294 block();
2295
2296 NEXT();
2297 fill_int(&ob);
2298 OUT(0xf9);
2299 }
2300 break;
2301 case 0x04:
2302 /* Global function */
2303 {
2304 struct output_buffer_struct ob;
2305 NEXT();
2306 OUT(0xf8); OUT(0x04);
2307 drop_int(&ob); ID ; INTn(stack size); INTn(ret val);
2308 EXPn(offset);
2309
2310 block();
2311
2312 NEXT();
2313 OUT(0xf9);
2314 EXPn(size of block);
2315 fill_int(&ob);
2316 }
2317 break;
2318
2319 case 0x05:
2320 /* File name for source line numbers */
2321 {
2322 struct output_buffer_struct ob;
2323 NEXT();
2324 OUT(0xf8); OUT(0x05);
2325 drop_int(&ob);
2326 ID; INTn(year); INTn(month); INTn(day);
2327 INTn(hour); INTn(monute); INTn(second);
2328 block();
2329 NEXT();
2330 OUT(0xf9);
2331 fill_int(&ob);
2332 }
2333 break;
2334
2335 case 0x06:
2336 /* Local function */
2337 { struct output_buffer_struct ob;
2338 NEXT(); OUT(0xf8); OUT(0x06);
2339 drop_int(&ob);
2340 ID; INTn(stack size); INTn(type return);
2341 EXPn(offset);
2342 block();
2343 NEXT();
2344 OUT(0xf9);
2345 EXPn(size);
2346 fill_int(&ob);
2347 }
2348 break;
2349
2350 case 0x0a:
2351 /* Assembler module scope beginning -*/
2352 { struct output_buffer_struct ob;
2353
2354 NEXT();
2355 OUT(0xf8); OUT(0x0a);
2356 drop_int(&ob);
2357 ID; ID; INT; ID; INT; INT; INT; INT; INT; INT;
2358
2359 block();
2360
2361 NEXT();
2362 OUT(0xf9);
2363 fill_int(&ob);
2364 }
2365 break;
2366 case 0x0b:
2367 {
2368 struct output_buffer_struct ob;
2369 NEXT();
2370 OUT(0xf8); OUT(0x0b);
2371 drop_int(&ob); ID ; INT; INTn(section index); EXPn(offset); INTn(stuff);
2372
2373 block();
2374
2375 OUT(0xf9);
2376 NEXT();
2377 EXPn(Size in Maus);
2378 fill_int(&ob);
2379 }
2380 break;
2381 }
2382 }
2383
2384 static void e2_record()
2385 {
2386 OUT(0xe2);
2387 NEXT();
2388 OUT(0xce);
2389 NEXT();
2390 INT;
2391 EXP;
2392 }
2393
2394 static void DEFUN_VOID(block)
2395 {
2396 int ch ;
2397 while (1) {
2398 ch = THIS();
2399 switch (ch) {
2400 case 0xe1:
2401 case 0xe5:
2402 return;
2403 case 0xf9:
2404 return;
2405 case 0xf0:
2406 f0_record();
2407 break;
2408 case 0xf1:
2409 f1_record();
2410 break;
2411 case 0xf2:
2412 f2_record();
2413 break;
2414 case 0xf8:
2415 f8_record();
2416 break;
2417 case 0xe2:
2418 e2_record();
2419 break;
2420
2421 }
2422 }
2423 }
2424
2425
2426
2427 /* relocate_debug,
2428 moves all the debug information from the source bfd to the output
2429 bfd, and relocates any expressions it finds
2430 */
2431
2432 static void
2433 DEFUN(relocate_debug,(output, input),
2434 bfd *output AND
2435 bfd *input)
2436 {
2437 #define IBS 400
2438 #define OBS 400
2439 unsigned char input_buffer[IBS];
2440
2441 input_ptr_start = input_ptr = input_buffer;
2442 input_ptr_end = input_buffer + IBS;
2443 input_bfd = input;
2444 bfd_read((PTR)input_ptr_start, 1, IBS, input);
2445 block();
2446 }
2447 /*
2448 During linking, we we told about the bfds which made up our
2449 contents, we have a list of them. They will still be open, so go to
2450 the debug info in each, and copy it out, relocating it as we go.
2451 */
2452
2453 static void
2454 DEFUN(ieee_write_debug_part, (abfd),
2455 bfd *abfd)
2456 {
2457 ieee_data_type *ieee = IEEE_DATA(abfd);
2458 bfd_chain_type *chain = ieee->chain_root;
2459 unsigned char output_buffer[OBS];
2460 boolean some_debug = false;
2461 file_ptr here = bfd_tell(abfd);
2462
2463 output_ptr_start = output_ptr = output_buffer ;
2464 output_ptr_end = output_buffer + OBS;
2465 output_ptr = output_buffer;
2466 output_bfd = abfd;
2467
2468 if (chain == (bfd_chain_type *)NULL) {
2469 #if 0
2470 /* There is no debug info, so we'll fake some up */
2471 CONST static char fake[] = {
2472 0xf8, 0xa, 0, 5, 't', 't', 't', 't', 't', 0, 2, 3,
2473 '1','.','1',0x82, 1991>>8, 1991 & 0xff, 9, 20, 11, 07,50 };
2474 ieee->w.r.debug_information_part = 0;
2475
2476
2477 here;
2478
2479
2480 /* bfd_write(fake, 1, sizeof(fake), abfd);*/
2481 /* Now write a header for each section */
2482 {
2483 int i = 0;
2484 asection *s = abfd->sections;
2485 while (s) {
2486 if (s != abfd->abs_section)
2487 {
2488
2489 ieee_write_byte(abfd, 0xf8);
2490 ieee_write_byte(abfd, 0x0b);
2491 ieee_write_byte(abfd, 0);
2492 ieee_write_byte(abfd, 0);
2493 ieee_write_byte(abfd, 1);
2494 ieee_write_byte(abfd, i + IEEE_SECTION_NUMBER_BASE);
2495 ieee_write_expression(abfd, 0, s->symbol, 0, 0, 0);
2496 ieee_write_byte(abfd,0);
2497 ieee_write_byte(abfd, 0xf9);
2498 ieee_write_expression(abfd, s->size,
2499 bfd_abs_section.symbol, 0, 0, 0);
2500 i++;
2501 }
2502
2503 s = s->next;
2504
2505 }
2506 /* Close the scope */
2507 ieee_write_byte(abfd, 0xf9);
2508 }
2509 #endif
2510 }
2511 else{
2512 while (chain != (bfd_chain_type *)NULL) {
2513 bfd *entry = chain->this;
2514 ieee_data_type *entry_ieee = IEEE_DATA(entry);
2515 if (entry_ieee->w.r.debug_information_part) {
2516 bfd_seek(entry, entry_ieee->w.r.debug_information_part, SEEK_SET);
2517 relocate_debug(abfd, entry);
2518 }
2519
2520 chain = chain->next;
2521 }
2522 if (some_debug) {
2523 ieee->w.r.debug_information_part = here;
2524 }
2525 else {
2526 ieee->w.r.debug_information_part = 0;
2527 }
2528 }
2529 flush();
2530
2531 }
2532 /* write the data in an ieee way */
2533 static void
2534 DEFUN(ieee_write_data_part,(abfd),
2535 bfd *abfd)
2536 {
2537 asection *s;
2538 ieee_data_type *ieee = IEEE_DATA(abfd);
2539 ieee->w.r.data_part = bfd_tell(abfd);
2540 for (s = abfd->sections; s != (asection *)NULL; s = s->next)
2541 {
2542 /* Sort the reloc records so we can insert them in the correct
2543 places */
2544 if (s->reloc_count != 0)
2545 {
2546 do_with_relocs(abfd, s);
2547 }
2548 else
2549 {
2550 do_without_relocs(abfd, s);
2551 }
2552 }
2553 }
2554
2555
2556
2557 static void
2558 DEFUN(init_for_output,(abfd),
2559 bfd *abfd)
2560 {
2561 asection *s;
2562 for (s = abfd->sections; s != (asection *)NULL; s = s->next) {
2563 if (s->_raw_size != 0) {
2564 ieee_per_section(s)->data = (bfd_byte *)(bfd_alloc(abfd, s->_raw_size));
2565 }
2566 }
2567 }
2568
2569 /** exec and core file sections */
2570
2571 /* set section contents is complicated with IEEE since the format is
2572 * not a byte image, but a record stream.
2573 */
2574 boolean
2575 DEFUN(ieee_set_section_contents,(abfd, section, location, offset, count),
2576 bfd *abfd AND
2577 sec_ptr section AND
2578 PTR location AND
2579 file_ptr offset AND
2580 bfd_size_type count)
2581 {
2582 if (ieee_per_section(section)->data == (bfd_byte *)NULL) {
2583 init_for_output(abfd);
2584 }
2585 (void) memcpy((PTR)(ieee_per_section(section)->data + offset),
2586 (PTR)location,
2587 (unsigned int)count);
2588 return true;
2589 }
2590
2591 /*
2592 write the external symbols of a file, IEEE considers two sorts of
2593 external symbols, public, and referenced. It uses to internal forms
2594 to index them as well. When we write them out we turn their symbol
2595 values into indexes from the right base.
2596 */
2597 static void
2598 DEFUN(ieee_write_external_part,(abfd),
2599 bfd *abfd)
2600 {
2601 asymbol **q;
2602 ieee_data_type *ieee = IEEE_DATA(abfd);
2603
2604 unsigned int reference_index = IEEE_REFERENCE_BASE;
2605 unsigned int public_index = IEEE_PUBLIC_BASE+2;
2606 file_ptr here = bfd_tell(abfd);
2607 boolean hadone = false;
2608 if (abfd->outsymbols != (asymbol **)NULL) {
2609
2610 for (q = abfd->outsymbols; *q != (asymbol *)NULL; q++) {
2611 asymbol *p = *q;
2612 hadone = true;
2613 if (p->section == &bfd_und_section) {
2614 /* This must be a symbol reference .. */
2615 ieee_write_byte(abfd, ieee_external_reference_enum);
2616 ieee_write_int(abfd, reference_index);
2617 ieee_write_id(abfd, p->name);
2618 p->value = reference_index;
2619 reference_index++;
2620 }
2621 else if (bfd_is_com_section (p->section)) {
2622 /* This is a weak reference */
2623 ieee_write_byte(abfd, ieee_external_reference_enum);
2624 ieee_write_int(abfd, reference_index);
2625 ieee_write_id(abfd, p->name);
2626 ieee_write_byte(abfd, ieee_weak_external_reference_enum);
2627 ieee_write_int(abfd, reference_index);
2628 ieee_write_int(abfd, p->value);
2629 ieee_write_int(abfd, BFD_FORT_COMM_DEFAULT_VALUE);
2630 p->value = reference_index;
2631 reference_index++;
2632 }
2633 else if(p->flags & BSF_GLOBAL) {
2634 /* This must be a symbol definition */
2635
2636
2637 ieee_write_byte(abfd, ieee_external_symbol_enum);
2638 ieee_write_int(abfd, public_index );
2639 ieee_write_id(abfd, p->name);
2640
2641 ieee_write_twobyte(abfd, ieee_attribute_record_enum);
2642 ieee_write_int(abfd, public_index );
2643 ieee_write_byte(abfd, 15); /* instruction address */
2644 ieee_write_byte(abfd, 19); /* static symbol */
2645 ieee_write_byte(abfd, 1); /* one of them */
2646
2647
2648 /* Write out the value */
2649 ieee_write_2bytes(abfd, ieee_value_record_enum);
2650 ieee_write_int(abfd, public_index);
2651 if (p->section != &bfd_abs_section)
2652 {
2653 if (abfd->flags & EXEC_P)
2654 {
2655 /* If fully linked, then output all symbols
2656 relocated */
2657 ieee_write_int(abfd,
2658 p->value + p->section->output_offset+ p->section->output_section->vma);
2659
2660 }
2661 else {
2662 ieee_write_expression(abfd,
2663 p->value + p->section->output_offset,
2664 p->section->output_section->symbol
2665 , false, 0);
2666 }
2667 }
2668 else
2669 {
2670 ieee_write_expression(abfd,
2671 p->value,
2672 bfd_abs_section.symbol,
2673 false, 0);
2674 }
2675 p->value = public_index;
2676 public_index++;
2677 }
2678 else {
2679 /* This can happen - when there are gaps in the symbols read */
2680 /* from an input ieee file */
2681 }
2682 }
2683 }
2684 if (hadone)
2685 ieee->w.r.external_part = here;
2686
2687 }
2688
2689
2690 static CONST unsigned char exten[] =
2691 {
2692 0xf0, 0x20, 0x00,
2693 0xf1, 0xce, 0x20, 0x00, 37, 3, 3, /* Set version 3 rev 3 */
2694 0xf1, 0xce, 0x20, 0x00, 39, 2, /* keep symbol in original case */
2695 0xf1, 0xce, 0x20, 0x00, 38 /* set object type relocateable to x */
2696 };
2697
2698 static CONST unsigned char envi[] =
2699 {
2700 0xf0, 0x21, 0x00,
2701
2702 /* 0xf1, 0xce, 0x21, 00, 50, 0x82, 0x07, 0xc7, 0x09, 0x11, 0x11,
2703 0x19, 0x2c,
2704 */
2705 0xf1, 0xce, 0x21, 00, 52, 0x00, /* exec ok */
2706
2707 0xf1, 0xce, 0x21, 0, 53, 0x03, /* host unix */
2708 /* 0xf1, 0xce, 0x21, 0, 54, 2,1,1 tool & version # */
2709 };
2710
2711 static
2712 void
2713 DEFUN(ieee_write_me_part,(abfd),
2714 bfd *abfd)
2715 {
2716 ieee_data_type *ieee= IEEE_DATA(abfd);
2717 ieee->w.r.trailer_part = bfd_tell(abfd);
2718 if (abfd->start_address) {
2719 ieee->w.r.me_record = bfd_tell(abfd);
2720 ieee_write_2bytes(abfd, ieee_value_starting_address_enum);
2721 ieee_write_byte(abfd, ieee_function_either_open_b_enum);
2722 ieee_write_int(abfd, abfd->start_address);
2723 ieee_write_byte(abfd, ieee_function_either_close_b_enum);
2724 }
2725 else {
2726 ieee->w.r.me_record = bfd_tell(abfd);
2727 }
2728 ieee_write_byte(abfd, ieee_module_end_enum);
2729
2730 }
2731 boolean
2732 DEFUN(ieee_write_object_contents,(abfd),
2733 bfd *abfd)
2734 {
2735 ieee_data_type *ieee = IEEE_DATA(abfd);
2736 unsigned int i;
2737 file_ptr old;
2738 /* Fast forward over the header area */
2739 bfd_seek(abfd, (file_ptr) 0, SEEK_SET);
2740 ieee_write_byte(abfd, ieee_module_beginning_enum);
2741
2742 ieee_write_id(abfd, bfd_printable_name(abfd));
2743 ieee_write_id(abfd, abfd->filename);
2744
2745 /* Fast forward over the variable bits */
2746 ieee_write_byte(abfd, ieee_address_descriptor_enum);
2747
2748 /* Bits per MAU */
2749 ieee_write_byte(abfd, (bfd_byte) (bfd_arch_bits_per_byte(abfd)));
2750 /* MAU's per address */
2751 ieee_write_byte(abfd,
2752 (bfd_byte) (bfd_arch_bits_per_address(abfd) / bfd_arch_bits_per_byte(abfd)));
2753
2754 old = bfd_tell(abfd);
2755 bfd_seek(abfd, (file_ptr) (8 * N_W_VARIABLES), SEEK_CUR);
2756
2757 ieee->w.r.extension_record = bfd_tell(abfd);
2758 bfd_write((char *)exten, 1, sizeof(exten), abfd);
2759 if (abfd->flags & EXEC_P)
2760 ieee_write_byte(abfd, 0x1); /* Absolute */
2761 else
2762 ieee_write_byte(abfd, 0x2); /* Relocateable */
2763
2764 ieee->w.r.environmental_record = bfd_tell(abfd);
2765 bfd_write((char *)envi, 1, sizeof(envi), abfd);
2766 output_bfd = abfd;
2767 flush();
2768
2769 ieee_write_section_part(abfd);
2770 /*
2771 First write the symbols, this changes their values into table
2772 indeces so we cant use it after this point
2773 */
2774 ieee_write_external_part(abfd);
2775 /* ieee_write_byte(abfd, ieee_record_seperator_enum);*/
2776
2777
2778 /* ieee_write_byte(abfd, ieee_record_seperator_enum);*/
2779
2780
2781 /*
2782 Write any debugs we have been told about
2783 */
2784 ieee_write_debug_part(abfd);
2785
2786 /*
2787 Can only write the data once the symbols have been written since
2788 the data contains relocation information which points to the
2789 symbols
2790 */
2791 ieee_write_data_part(abfd);
2792
2793
2794 /*
2795 At the end we put the end !
2796 */
2797 ieee_write_me_part(abfd);
2798
2799
2800 /* Generate the header */
2801 bfd_seek(abfd, old, SEEK_SET);
2802
2803 for (i= 0; i < N_W_VARIABLES; i++) {
2804 ieee_write_2bytes(abfd,ieee_assign_value_to_variable_enum);
2805 ieee_write_byte(abfd, (bfd_byte) i);
2806 ieee_write_int5_out(abfd, ieee->w.offset[i]);
2807 }
2808 return true;
2809 }
2810
2811
2812
2813 \f
2814 /* Native-level interface to symbols. */
2815
2816 /* We read the symbols into a buffer, which is discarded when this
2817 function exits. We read the strings into a buffer large enough to
2818 hold them all plus all the cached symbol entries. */
2819
2820 asymbol *
2821 DEFUN(ieee_make_empty_symbol,(abfd),
2822 bfd *abfd)
2823 {
2824
2825 ieee_symbol_type *new =
2826 (ieee_symbol_type *)bfd_zmalloc (sizeof (ieee_symbol_type));
2827 new->symbol.the_bfd = abfd;
2828 return &new->symbol;
2829
2830 }
2831
2832 static bfd *
2833 DEFUN(ieee_openr_next_archived_file,(arch, prev),
2834 bfd *arch AND
2835 bfd *prev)
2836 {
2837 ieee_ar_data_type *ar = IEEE_AR_DATA(arch);
2838 /* take the next one from the arch state, or reset */
2839 if (prev == (bfd *)NULL) {
2840 /* Reset the index - the first two entries are bogus*/
2841 ar->element_index = 2;
2842 }
2843 while (true) {
2844 ieee_ar_obstack_type *p = ar->elements + ar->element_index;
2845 ar->element_index++;
2846 if (ar->element_index <= ar->element_count) {
2847 if (p->file_offset != (file_ptr)0) {
2848 if (p->abfd == (bfd *)NULL) {
2849 p->abfd = _bfd_create_empty_archive_element_shell(arch);
2850 p->abfd->origin = p->file_offset;
2851 }
2852 return p->abfd;
2853 }
2854 }
2855 else {
2856 bfd_error = no_more_archived_files;
2857 return (bfd *)NULL;
2858 }
2859
2860 }
2861 }
2862
2863 static boolean
2864 ieee_find_nearest_line(abfd,
2865 section,
2866 symbols,
2867 offset,
2868 filename_ptr,
2869 functionname_ptr,
2870 line_ptr)
2871 bfd *abfd;
2872 asection *section;
2873 asymbol **symbols;
2874 bfd_vma offset;
2875 char **filename_ptr;
2876 char **functionname_ptr;
2877 int *line_ptr;
2878 {
2879 return false;
2880 }
2881
2882
2883 static int
2884 ieee_generic_stat_arch_elt(abfd, buf)
2885 bfd *abfd;
2886 struct stat *buf;
2887 {
2888 ieee_ar_data_type *ar = abfd->my_archive->tdata.ieee_ar_data;
2889 if (ar == (ieee_ar_data_type *)NULL) {
2890 bfd_error = invalid_operation;
2891 return -1;
2892 }
2893 else {
2894 buf->st_size = 0x1;
2895 buf->st_mode = 0666;
2896 return ! ieee_object_p(abfd);
2897 }
2898 }
2899 static int
2900 DEFUN(ieee_sizeof_headers,(abfd, x),
2901 bfd *abfd AND
2902 boolean x)
2903 {
2904 return 0;
2905 }
2906
2907
2908
2909 static void
2910 DEFUN(ieee_bfd_debug_info_start,(abfd),
2911 bfd *abfd)
2912 {
2913
2914 }
2915
2916 static void
2917 DEFUN(ieee_bfd_debug_info_end,(abfd),
2918 bfd *abfd)
2919 {
2920
2921 }
2922
2923
2924 /* Add this section to the list of sections we have debug info for, to
2925 be ready to output it at close time
2926 */
2927 static void
2928 DEFUN(ieee_bfd_debug_info_accumulate,(abfd, section),
2929 bfd *abfd AND
2930 asection *section)
2931 {
2932 ieee_data_type *ieee = IEEE_DATA(section->owner);
2933 ieee_data_type *output_ieee = IEEE_DATA(abfd);
2934 /* can only accumulate data from other ieee bfds */
2935 if (section->owner->xvec != abfd->xvec)
2936 return;
2937 /* Only bother once per bfd */
2938 if (ieee->done_debug == true)
2939 return;
2940 ieee->done_debug = true;
2941
2942 /* Don't bother if there is no debug info */
2943 if (ieee->w.r.debug_information_part == 0)
2944 return;
2945
2946
2947 /* Add to chain */
2948 {
2949 bfd_chain_type *n = (bfd_chain_type *) bfd_alloc(abfd, sizeof(bfd_chain_type));
2950 n->this = section->owner;
2951 n->next = (bfd_chain_type *)NULL;
2952
2953 if (output_ieee->chain_head) {
2954 output_ieee->chain_head->next = n;
2955 }
2956 else {
2957 output_ieee->chain_root = n;
2958
2959 }
2960 output_ieee->chain_head = n;
2961 }
2962 }
2963
2964
2965
2966
2967
2968
2969 #define FOO PROTO
2970 #define ieee_core_file_failing_command (char *(*)())(bfd_nullvoidptr)
2971 #define ieee_core_file_failing_signal (int (*)())bfd_0
2972 #define ieee_core_file_matches_executable_p ( FOO(boolean, (*),(bfd *, bfd *)))bfd_false
2973 #define ieee_slurp_armap bfd_true
2974 #define ieee_slurp_extended_name_table bfd_true
2975 #define ieee_truncate_arname (void (*)())bfd_nullvoidptr
2976 #define ieee_write_armap (FOO( boolean, (*),(bfd *, unsigned int, struct orl *, unsigned int, int))) bfd_nullvoidptr
2977 #define ieee_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
2978 #define ieee_close_and_cleanup bfd_generic_close_and_cleanup
2979 #define ieee_set_arch_mach bfd_default_set_arch_mach
2980 #define ieee_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
2981 #define ieee_bfd_relax_section bfd_generic_relax_section
2982 #define ieee_bfd_reloc_type_lookup \
2983 ((CONST struct reloc_howto_struct *(*) PARAMS ((bfd *, bfd_reloc_code_real_type))) bfd_nullvoidptr)
2984 #define ieee_bfd_make_debug_symbol \
2985 ((asymbol *(*) PARAMS ((bfd *, void *, unsigned long))) bfd_nullvoidptr)
2986 #define ieee_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
2987 #define ieee_bfd_link_add_symbols _bfd_generic_link_add_symbols
2988 #define ieee_bfd_final_link _bfd_generic_final_link
2989
2990 /*SUPPRESS 460 */
2991 bfd_target ieee_vec =
2992 {
2993 "ieee", /* name */
2994 bfd_target_ieee_flavour,
2995 true, /* target byte order */
2996 true, /* target headers byte order */
2997 (HAS_RELOC | EXEC_P | /* object flags */
2998 HAS_LINENO | HAS_DEBUG |
2999 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
3000 ( SEC_CODE|SEC_DATA|SEC_ROM|SEC_HAS_CONTENTS
3001 |SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
3002 0, /* leading underscore */
3003 ' ', /* ar_pad_char */
3004 16, /* ar_max_namelen */
3005 1, /* minimum alignment */
3006 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
3007 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
3008 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
3009 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
3010 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
3011 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
3012
3013 { _bfd_dummy_target,
3014 ieee_object_p, /* bfd_check_format */
3015 ieee_archive_p,
3016 _bfd_dummy_target,
3017 },
3018 {
3019 bfd_false,
3020 ieee_mkobject,
3021 _bfd_generic_mkarchive,
3022 bfd_false
3023 },
3024 {
3025 bfd_false,
3026 ieee_write_object_contents,
3027 _bfd_write_archive_contents,
3028 bfd_false,
3029 },
3030 JUMP_TABLE(ieee),
3031 (PTR) 0
3032 };
3033
GDB Binutils - Deliverables
This page took 0.125292 seconds and 5 git commands to generate.