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