projects / deliverable / binutils-gdb.git / blob
? search:


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