![[BACK]](/icons/back.gif){kind=icon}
Return to ieee.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / external / gpl3 / binutils.old / dist / bfd|
Return to ieee.c CVS log | Up to [cvs.NetBSD.org] / src / external / gpl3 / binutils.old / dist / bfd |
1.1 christos 1: /* BFD back-end for ieee-695 objects.
2: Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3: 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011
4: Free Software Foundation, Inc.
5:
6: Written by Steve Chamberlain of Cygnus Support.
7:
8: This file is part of BFD, the Binary File Descriptor library.
9:
10: This program is free software; you can redistribute it and/or modify
11: it under the terms of the GNU General Public License as published by
12: the Free Software Foundation; either version 3 of the License, or
13: (at your option) any later version.
14:
15: This program is distributed in the hope that it will be useful,
16: but WITHOUT ANY WARRANTY; without even the implied warranty of
17: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18: GNU General Public License for more details.
19:
20: You should have received a copy of the GNU General Public License
21: along with this program; if not, write to the Free Software
22: Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23: MA 02110-1301, USA. */
24:
25:
26: #define KEEPMINUSPCININST 0
27:
28: /* IEEE 695 format is a stream of records, which we parse using a simple one-
29: token (which is one byte in this lexicon) lookahead recursive decent
30: parser. */
31:
32: #include "sysdep.h"
33: #include "bfd.h"
34: #include "libbfd.h"
35: #include "ieee.h"
36: #include "libieee.h"
37: #include "safe-ctype.h"
38:
39: struct output_buffer_struct
40: {
41: unsigned char *ptrp;
42: int buffer;
43: };
44:
45: static unsigned char *output_ptr_start;
46: static unsigned char *output_ptr;
47: static unsigned char *output_ptr_end;
48: static unsigned char *input_ptr_start;
49: static unsigned char *input_ptr;
50: static unsigned char *input_ptr_end;
51: static bfd *input_bfd;
52: static bfd *output_bfd;
53: static int output_buffer;
54:
55:
56: static void block (void);
57:
58: /* Functions for writing to ieee files in the strange way that the
59: standard requires. */
60:
61: static bfd_boolean
62: ieee_write_byte (bfd *abfd, int barg)
63: {
64: bfd_byte byte;
65:
66: byte = barg;
67: if (bfd_bwrite ((void *) &byte, (bfd_size_type) 1, abfd) != 1)
68: return FALSE;
69: return TRUE;
70: }
71:
72: static bfd_boolean
73: ieee_write_2bytes (bfd *abfd, int bytes)
74: {
75: bfd_byte buffer[2];
76:
77: buffer[0] = bytes >> 8;
78: buffer[1] = bytes & 0xff;
79: if (bfd_bwrite ((void *) buffer, (bfd_size_type) 2, abfd) != 2)
80: return FALSE;
81: return TRUE;
82: }
83:
84: static bfd_boolean
85: ieee_write_int (bfd *abfd, bfd_vma value)
86: {
87: if (value <= 127)
88: {
89: if (! ieee_write_byte (abfd, (bfd_byte) value))
90: return FALSE;
91: }
92: else
93: {
94: unsigned int length;
95:
96: /* How many significant bytes ? */
97: /* FIXME FOR LONGER INTS. */
98: if (value & 0xff000000)
99: length = 4;
100: else if (value & 0x00ff0000)
101: length = 3;
102: else if (value & 0x0000ff00)
103: length = 2;
104: else
105: length = 1;
106:
107: if (! ieee_write_byte (abfd,
108: (bfd_byte) ((int) ieee_number_repeat_start_enum
109: + length)))
110: return FALSE;
111: switch (length)
112: {
113: case 4:
114: if (! ieee_write_byte (abfd, (bfd_byte) (value >> 24)))
115: return FALSE;
116: /* Fall through. */
117: case 3:
118: if (! ieee_write_byte (abfd, (bfd_byte) (value >> 16)))
119: return FALSE;
120: /* Fall through. */
121: case 2:
122: if (! ieee_write_byte (abfd, (bfd_byte) (value >> 8)))
123: return FALSE;
124: /* Fall through. */
125: case 1:
126: if (! ieee_write_byte (abfd, (bfd_byte) (value)))
127: return FALSE;
128: }
129: }
130:
131: return TRUE;
132: }
133:
134: static bfd_boolean
135: ieee_write_id (bfd *abfd, const char *id)
136: {
137: size_t length = strlen (id);
138:
139: if (length <= 127)
140: {
141: if (! ieee_write_byte (abfd, (bfd_byte) length))
142: return FALSE;
143: }
144: else if (length < 255)
145: {
146: if (! ieee_write_byte (abfd, ieee_extension_length_1_enum)
147: || ! ieee_write_byte (abfd, (bfd_byte) length))
148: return FALSE;
149: }
150: else if (length < 65535)
151: {
152: if (! ieee_write_byte (abfd, ieee_extension_length_2_enum)
153: || ! ieee_write_2bytes (abfd, (int) length))
154: return FALSE;
155: }
156: else
157: {
158: (*_bfd_error_handler)
159: (_("%s: string too long (%d chars, max 65535)"),
160: bfd_get_filename (abfd), length);
161: bfd_set_error (bfd_error_invalid_operation);
162: return FALSE;
163: }
164:
165: if (bfd_bwrite ((void *) id, (bfd_size_type) length, abfd) != length)
166: return FALSE;
167: return TRUE;
168: }
169:
170: /* Functions for reading from ieee files in the strange way that the
171: standard requires. */
172:
173: #define this_byte(ieee) *((ieee)->input_p)
174: #define next_byte(ieee) ((ieee)->input_p++)
175: #define this_byte_and_next(ieee) (*((ieee)->input_p++))
176:
177: static unsigned short
178: read_2bytes (common_header_type *ieee)
179: {
180: unsigned char c1 = this_byte_and_next (ieee);
181: unsigned char c2 = this_byte_and_next (ieee);
182:
183: return (c1 << 8) | c2;
184: }
185:
186: static void
187: bfd_get_string (common_header_type *ieee, char *string, size_t length)
188: {
189: size_t i;
190:
191: for (i = 0; i < length; i++)
192: string[i] = this_byte_and_next (ieee);
193: }
194:
195: static char *
196: read_id (common_header_type *ieee)
197: {
198: size_t length;
199: char *string;
200:
201: length = this_byte_and_next (ieee);
202: if (length <= 0x7f)
203: /* Simple string of length 0 to 127. */
204: ;
205:
206: else if (length == 0xde)
207: /* Length is next byte, allowing 0..255. */
208: length = this_byte_and_next (ieee);
209:
210: else if (length == 0xdf)
211: {
212: /* Length is next two bytes, allowing 0..65535. */
213: length = this_byte_and_next (ieee);
214: length = (length * 256) + this_byte_and_next (ieee);
215: }
216:
217: /* Buy memory and read string. */
218: string = bfd_alloc (ieee->abfd, (bfd_size_type) length + 1);
219: if (!string)
220: return NULL;
221: bfd_get_string (ieee, string, length);
222: string[length] = 0;
223: return string;
224: }
225:
226: static bfd_boolean
227: ieee_write_expression (bfd *abfd,
228: bfd_vma value,
229: asymbol *symbol,
230: bfd_boolean pcrel,
231: unsigned int sindex)
232: {
233: unsigned int term_count = 0;
234:
235: if (value != 0)
236: {
237: if (! ieee_write_int (abfd, value))
238: return FALSE;
239: term_count++;
240: }
241:
242: /* Badly formatted binaries can have a missing symbol,
243: so test here to prevent a seg fault. */
244: if (symbol != NULL)
245: {
246: if (bfd_is_com_section (symbol->section)
247: || bfd_is_und_section (symbol->section))
248: {
249: /* Def of a common symbol. */
250: if (! ieee_write_byte (abfd, ieee_variable_X_enum)
251: || ! ieee_write_int (abfd, symbol->value))
252: return FALSE;
253: term_count ++;
254: }
255: else if (! bfd_is_abs_section (symbol->section))
256: {
257: /* Ref to defined symbol - */
258: if (symbol->flags & BSF_GLOBAL)
259: {
260: if (! ieee_write_byte (abfd, ieee_variable_I_enum)
261: || ! ieee_write_int (abfd, symbol->value))
262: return FALSE;
263: term_count++;
264: }
265: else if (symbol->flags & (BSF_LOCAL | BSF_SECTION_SYM))
266: {
267: /* This is a reference to a defined local symbol. We can
268: easily do a local as a section+offset. */
269: if (! ieee_write_byte (abfd, ieee_variable_R_enum)
270: || ! ieee_write_byte (abfd,
271: (bfd_byte) (symbol->section->index
272: + IEEE_SECTION_NUMBER_BASE)))
273: return FALSE;
274:
275: term_count++;
276: if (symbol->value != 0)
277: {
278: if (! ieee_write_int (abfd, symbol->value))
279: return FALSE;
280: term_count++;
281: }
282: }
283: else
284: {
285: (*_bfd_error_handler)
286: (_("%s: unrecognized symbol `%s' flags 0x%x"),
287: bfd_get_filename (abfd), bfd_asymbol_name (symbol),
288: symbol->flags);
289: bfd_set_error (bfd_error_invalid_operation);
290: return FALSE;
291: }
292: }
293: }
294:
295: if (pcrel)
296: {
297: /* Subtract the pc from here by asking for PC of this section. */
298: if (! ieee_write_byte (abfd, ieee_variable_P_enum)
299: || ! ieee_write_byte (abfd,
300: (bfd_byte) (sindex + IEEE_SECTION_NUMBER_BASE))
301: || ! ieee_write_byte (abfd, ieee_function_minus_enum))
302: return FALSE;
303: }
304:
305: /* Handle the degenerate case of a 0 address. */
306: if (term_count == 0)
307: if (! ieee_write_int (abfd, (bfd_vma) 0))
308: return FALSE;
309:
310: while (term_count > 1)
311: {
312: if (! ieee_write_byte (abfd, ieee_function_plus_enum))
313: return FALSE;
314: term_count--;
315: }
316:
317: return TRUE;
318: }
319:
320: /* Writes any integer into the buffer supplied and always takes 5 bytes. */
321:
322: static void
323: ieee_write_int5 (bfd_byte *buffer, bfd_vma value)
324: {
325: buffer[0] = (bfd_byte) ieee_number_repeat_4_enum;
326: buffer[1] = (value >> 24) & 0xff;
327: buffer[2] = (value >> 16) & 0xff;
328: buffer[3] = (value >> 8) & 0xff;
329: buffer[4] = (value >> 0) & 0xff;
330: }
331:
332: static bfd_boolean
333: ieee_write_int5_out (bfd *abfd, bfd_vma value)
334: {
335: bfd_byte b[5];
336:
337: ieee_write_int5 (b, value);
338: if (bfd_bwrite ((void *) b, (bfd_size_type) 5, abfd) != 5)
339: return FALSE;
340: return TRUE;
341: }
342:
343: static bfd_boolean
344: parse_int (common_header_type *ieee, bfd_vma *value_ptr)
345: {
346: int value = this_byte (ieee);
347: int result;
348:
349: if (value >= 0 && value <= 127)
350: {
351: *value_ptr = value;
352: next_byte (ieee);
353: return TRUE;
354: }
355: else if (value >= 0x80 && value <= 0x88)
356: {
357: unsigned int count = value & 0xf;
358:
359: result = 0;
360: next_byte (ieee);
361: while (count)
362: {
363: result = (result << 8) | this_byte_and_next (ieee);
364: count--;
365: }
366: *value_ptr = result;
367: return TRUE;
368: }
369: return FALSE;
370: }
371:
372: static int
373: parse_i (common_header_type *ieee, bfd_boolean *ok)
374: {
375: bfd_vma x = 0;
376: *ok = parse_int (ieee, &x);
377: return x;
378: }
379:
380: static bfd_vma
381: must_parse_int (common_header_type *ieee)
382: {
383: bfd_vma result = 0;
384: BFD_ASSERT (parse_int (ieee, &result));
385: return result;
386: }
387:
388: typedef struct
389: {
390: bfd_vma value;
391: asection *section;
392: ieee_symbol_index_type symbol;
393: } ieee_value_type;
394:
395:
396: #if KEEPMINUSPCININST
397:
398: #define SRC_MASK(arg) arg
399: #define PCREL_OFFSET FALSE
400:
401: #else
402:
403: #define SRC_MASK(arg) 0
404: #define PCREL_OFFSET TRUE
405:
406: #endif
407:
408: static reloc_howto_type abs32_howto =
409: HOWTO (1,
410: 0,
411: 2,
412: 32,
413: FALSE,
414: 0,
415: complain_overflow_bitfield,
416: 0,
417: "abs32",
418: TRUE,
419: 0xffffffff,
420: 0xffffffff,
421: FALSE);
422:
423: static reloc_howto_type abs16_howto =
424: HOWTO (1,
425: 0,
426: 1,
427: 16,
428: FALSE,
429: 0,
430: complain_overflow_bitfield,
431: 0,
432: "abs16",
433: TRUE,
434: 0x0000ffff,
435: 0x0000ffff,
436: FALSE);
437:
438: static reloc_howto_type abs8_howto =
439: HOWTO (1,
440: 0,
441: 0,
442: 8,
443: FALSE,
444: 0,
445: complain_overflow_bitfield,
446: 0,
447: "abs8",
448: TRUE,
449: 0x000000ff,
450: 0x000000ff,
451: FALSE);
452:
453: static reloc_howto_type rel32_howto =
454: HOWTO (1,
455: 0,
456: 2,
457: 32,
458: TRUE,
459: 0,
460: complain_overflow_signed,
461: 0,
462: "rel32",
463: TRUE,
464: SRC_MASK (0xffffffff),
465: 0xffffffff,
466: PCREL_OFFSET);
467:
468: static reloc_howto_type rel16_howto =
469: HOWTO (1,
470: 0,
471: 1,
472: 16,
473: TRUE,
474: 0,
475: complain_overflow_signed,
476: 0,
477: "rel16",
478: TRUE,
479: SRC_MASK (0x0000ffff),
480: 0x0000ffff,
481: PCREL_OFFSET);
482:
483: static reloc_howto_type rel8_howto =
484: HOWTO (1,
485: 0,
486: 0,
487: 8,
488: TRUE,
489: 0,
490: complain_overflow_signed,
491: 0,
492: "rel8",
493: TRUE,
494: SRC_MASK (0x000000ff),
495: 0x000000ff,
496: PCREL_OFFSET);
497:
498: static ieee_symbol_index_type NOSYMBOL = {0, 0};
499:
500: static void
501: parse_expression (ieee_data_type *ieee,
502: bfd_vma *value,
503: ieee_symbol_index_type *symbol,
504: bfd_boolean *pcrel,
505: unsigned int *extra,
506: asection **section)
507:
508: {
509: bfd_boolean loop = TRUE;
510: ieee_value_type stack[10];
511: ieee_value_type *sp = stack;
512: asection *dummy;
513:
514: #define POS sp[1]
515: #define TOS sp[0]
516: #define NOS sp[-1]
517: #define INC sp++;
518: #define DEC sp--;
519:
520: /* The stack pointer always points to the next unused location. */
521: #define PUSH(x,y,z) TOS.symbol = x; TOS.section = y; TOS.value = z; INC;
522: #define POP(x,y,z) DEC; x = TOS.symbol; y = TOS.section; z = TOS.value;
523:
524: while (loop && ieee->h.input_p < ieee->h.last_byte)
525: {
526: switch (this_byte (&(ieee->h)))
527: {
528: case ieee_variable_P_enum:
529: /* P variable, current program counter for section n. */
530: {
531: int section_n;
532:
533: next_byte (&(ieee->h));
534: *pcrel = TRUE;
535: section_n = must_parse_int (&(ieee->h));
536: (void) section_n;
537: PUSH (NOSYMBOL, bfd_abs_section_ptr, 0);
538: break;
539: }
540: case ieee_variable_L_enum:
541: /* L variable address of section N. */
542: next_byte (&(ieee->h));
543: PUSH (NOSYMBOL, ieee->section_table[must_parse_int (&(ieee->h))], 0);
544: break;
545: case ieee_variable_R_enum:
546: /* R variable, logical address of section module. */
547: /* FIXME, this should be different to L. */
548: next_byte (&(ieee->h));
549: PUSH (NOSYMBOL, ieee->section_table[must_parse_int (&(ieee->h))], 0);
550: break;
551: case ieee_variable_S_enum:
552: /* S variable, size in MAUS of section module. */
553: next_byte (&(ieee->h));
554: PUSH (NOSYMBOL,
555: 0,
556: ieee->section_table[must_parse_int (&(ieee->h))]->size);
557: break;
558: case ieee_variable_I_enum:
559: /* Push the address of variable n. */
560: {
561: ieee_symbol_index_type sy;
562:
563: next_byte (&(ieee->h));
564: sy.index = (int) must_parse_int (&(ieee->h));
565: sy.letter = 'I';
566:
567: PUSH (sy, bfd_abs_section_ptr, 0);
568: }
569: break;
570: case ieee_variable_X_enum:
571: /* Push the address of external variable n. */
572: {
573: ieee_symbol_index_type sy;
574:
575: next_byte (&(ieee->h));
576: sy.index = (int) (must_parse_int (&(ieee->h)));
577: sy.letter = 'X';
578:
579: PUSH (sy, bfd_und_section_ptr, 0);
580: }
581: break;
582: case ieee_function_minus_enum:
583: {
584: bfd_vma value1, value2;
585: asection *section1, *section_dummy;
586: ieee_symbol_index_type sy;
587:
588: next_byte (&(ieee->h));
589:
590: POP (sy, section1, value1);
591: POP (sy, section_dummy, value2);
592: PUSH (sy, section1 ? section1 : section_dummy, value2 - value1);
593: }
594: break;
595: case ieee_function_plus_enum:
596: {
597: bfd_vma value1, value2;
598: asection *section1;
599: asection *section2;
600: ieee_symbol_index_type sy1;
601: ieee_symbol_index_type sy2;
602:
603: next_byte (&(ieee->h));
604:
605: POP (sy1, section1, value1);
606: POP (sy2, section2, value2);
607: PUSH (sy1.letter ? sy1 : sy2,
608: bfd_is_abs_section (section1) ? section2 : section1,
609: value1 + value2);
610: }
611: break;
612: default:
613: {
614: bfd_vma va;
615:
616: BFD_ASSERT (this_byte (&(ieee->h)) < (int) ieee_variable_A_enum
617: || this_byte (&(ieee->h)) > (int) ieee_variable_Z_enum);
618: if (parse_int (&(ieee->h), &va))
619: {
620: PUSH (NOSYMBOL, bfd_abs_section_ptr, va);
621: }
622: else
623: /* Thats all that we can understand. */
624: loop = FALSE;
625: }
626: }
627: }
628:
629: /* As far as I can see there is a bug in the Microtec IEEE output
630: which I'm using to scan, whereby the comma operator is omitted
631: sometimes in an expression, giving expressions with too many
632: terms. We can tell if that's the case by ensuring that
633: sp == stack here. If not, then we've pushed something too far,
634: so we keep adding. */
635: while (sp != stack + 1)
636: {
637: asection *section1;
638: ieee_symbol_index_type sy1;
639:
640: POP (sy1, section1, *extra);
641: (void) section1;
642: (void) sy1;
643: }
644:
645: POP (*symbol, dummy, *value);
646: if (section)
647: *section = dummy;
648: }
649:
650:
651: #define ieee_seek(ieee, offset) \
652: do \
653: { \
654: ieee->h.input_p = ieee->h.first_byte + offset; \
655: ieee->h.last_byte = (ieee->h.first_byte \
656: + ieee_part_after (ieee, offset)); \
657: } \
658: while (0)
659:
660: #define ieee_pos(ieee) \
661: (ieee->h.input_p - ieee->h.first_byte)
662:
663: /* Find the first part of the ieee file after HERE. */
664:
665: static file_ptr
666: ieee_part_after (ieee_data_type *ieee, file_ptr here)
667: {
668: int part;
669: file_ptr after = ieee->w.r.me_record;
670:
671: /* File parts can come in any order, except that module end is
672: guaranteed to be last (and the header first). */
673: for (part = 0; part < N_W_VARIABLES; part++)
674: if (ieee->w.offset[part] > here && after > ieee->w.offset[part])
675: after = ieee->w.offset[part];
676:
677: return after;
678: }
679:
680: static unsigned int last_index;
681: static char last_type; /* Is the index for an X or a D. */
682:
683: static ieee_symbol_type *
684: get_symbol (bfd *abfd ATTRIBUTE_UNUSED,
685: ieee_data_type *ieee,
686: ieee_symbol_type *last_symbol,
687: unsigned int *symbol_count,
688: ieee_symbol_type ***pptr,
689: unsigned int *max_index,
690: int this_type)
691: {
692: /* Need a new symbol. */
693: unsigned int new_index = must_parse_int (&(ieee->h));
694:
695: if (new_index != last_index || this_type != last_type)
696: {
697: ieee_symbol_type *new_symbol;
698: bfd_size_type amt = sizeof (ieee_symbol_type);
699:
700: new_symbol = bfd_alloc (ieee->h.abfd, amt);
701: if (!new_symbol)
702: return NULL;
703:
704: new_symbol->index = new_index;
705: last_index = new_index;
706: (*symbol_count)++;
707: **pptr = new_symbol;
708: *pptr = &new_symbol->next;
709: if (new_index > *max_index)
710: *max_index = new_index;
711:
712: last_type = this_type;
713: new_symbol->symbol.section = bfd_abs_section_ptr;
714: return new_symbol;
715: }
716: return last_symbol;
717: }
718:
719: static bfd_boolean
720: ieee_slurp_external_symbols (bfd *abfd)
721: {
722: ieee_data_type *ieee = IEEE_DATA (abfd);
723: file_ptr offset = ieee->w.r.external_part;
724:
725: ieee_symbol_type **prev_symbols_ptr = &ieee->external_symbols;
726: ieee_symbol_type **prev_reference_ptr = &ieee->external_reference;
727: ieee_symbol_type *symbol = NULL;
728: unsigned int symbol_count = 0;
729: bfd_boolean loop = TRUE;
730:
731: last_index = 0xffffff;
732: ieee->symbol_table_full = TRUE;
733:
734: ieee_seek (ieee, offset);
735:
736: while (loop)
737: {
738: switch (this_byte (&(ieee->h)))
739: {
740: case ieee_nn_record:
741: next_byte (&(ieee->h));
742:
743: symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
744: & prev_symbols_ptr,
745: & ieee->external_symbol_max_index, 'I');
746: if (symbol == NULL)
747: return FALSE;
748:
749: symbol->symbol.the_bfd = abfd;
750: symbol->symbol.name = read_id (&(ieee->h));
751: symbol->symbol.udata.p = NULL;
752: symbol->symbol.flags = BSF_NO_FLAGS;
753: break;
754: case ieee_external_symbol_enum:
755: next_byte (&(ieee->h));
756:
757: symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
758: &prev_symbols_ptr,
759: &ieee->external_symbol_max_index, 'D');
760: if (symbol == NULL)
761: return FALSE;
762:
763: BFD_ASSERT (symbol->index >= ieee->external_symbol_min_index);
764:
765: symbol->symbol.the_bfd = abfd;
766: symbol->symbol.name = read_id (&(ieee->h));
767: symbol->symbol.udata.p = NULL;
768: symbol->symbol.flags = BSF_NO_FLAGS;
769: break;
770: case ieee_attribute_record_enum >> 8:
771: {
772: unsigned int symbol_name_index;
773: unsigned int symbol_type_index;
774: unsigned int symbol_attribute_def;
775: bfd_vma value = 0;
776:
777: switch (read_2bytes (&ieee->h))
778: {
779: case ieee_attribute_record_enum:
780: symbol_name_index = must_parse_int (&(ieee->h));
781: symbol_type_index = must_parse_int (&(ieee->h));
782: (void) symbol_type_index;
783: symbol_attribute_def = must_parse_int (&(ieee->h));
784: switch (symbol_attribute_def)
785: {
786: case 8:
787: case 19:
788: parse_int (&ieee->h, &value);
789: break;
790: default:
791: (*_bfd_error_handler)
792: (_("%B: unimplemented ATI record %u for symbol %u"),
793: abfd, symbol_attribute_def, symbol_name_index);
794: bfd_set_error (bfd_error_bad_value);
795: return FALSE;
796: break;
797: }
798: break;
799: case ieee_external_reference_info_record_enum:
800: /* Skip over ATX record. */
801: parse_int (&(ieee->h), &value);
802: parse_int (&(ieee->h), &value);
803: parse_int (&(ieee->h), &value);
804: parse_int (&(ieee->h), &value);
805: break;
806: case ieee_atn_record_enum:
807: /* We may get call optimization information here,
808: which we just ignore. The format is
809: {$F1}${CE}{index}{$00}{$3F}{$3F}{#_of_ASNs}. */
810: parse_int (&ieee->h, &value);
811: parse_int (&ieee->h, &value);
812: parse_int (&ieee->h, &value);
813: if (value != 0x3f)
814: {
815: (*_bfd_error_handler)
816: (_("%B: unexpected ATN type %d in external part"),
817: abfd, (int) value);
818: bfd_set_error (bfd_error_bad_value);
819: return FALSE;
820: }
821: parse_int (&ieee->h, &value);
822: parse_int (&ieee->h, &value);
823: while (value > 0)
824: {
825: bfd_vma val1;
826:
827: --value;
828:
829: switch (read_2bytes (&ieee->h))
830: {
831: case ieee_asn_record_enum:
832: parse_int (&ieee->h, &val1);
833: parse_int (&ieee->h, &val1);
834: break;
835:
836: default:
837: (*_bfd_error_handler)
838: (_("%B: unexpected type after ATN"), abfd);
839: bfd_set_error (bfd_error_bad_value);
840: return FALSE;
841: }
842: }
843: }
844: }
845: break;
846: case ieee_value_record_enum >> 8:
847: {
848: unsigned int symbol_name_index;
849: ieee_symbol_index_type symbol_ignore;
850: bfd_boolean pcrel_ignore;
851: unsigned int extra;
852:
853: next_byte (&(ieee->h));
854: next_byte (&(ieee->h));
855:
856: symbol_name_index = must_parse_int (&(ieee->h));
857: (void) symbol_name_index;
858: parse_expression (ieee,
859: &symbol->symbol.value,
860: &symbol_ignore,
861: &pcrel_ignore,
862: &extra,
863: &symbol->symbol.section);
864:
865: /* Fully linked IEEE-695 files tend to give every symbol
866: an absolute value. Try to convert that back into a
867: section relative value. FIXME: This won't always to
868: the right thing. */
869: if (bfd_is_abs_section (symbol->symbol.section)
870: && (abfd->flags & HAS_RELOC) == 0)
871: {
872: bfd_vma val;
873: asection *s;
874:
875: val = symbol->symbol.value;
876: for (s = abfd->sections; s != NULL; s = s->next)
877: {
878: if (val >= s->vma && val < s->vma + s->size)
879: {
880: symbol->symbol.section = s;
881: symbol->symbol.value -= s->vma;
882: break;
883: }
884: }
885: }
886:
887: symbol->symbol.flags = BSF_GLOBAL | BSF_EXPORT;
888:
889: }
890: break;
891: case ieee_weak_external_reference_enum:
892: {
893: bfd_vma size;
894: bfd_vma value;
895:
896: next_byte (&(ieee->h));
897: /* Throw away the external reference index. */
898: (void) must_parse_int (&(ieee->h));
899: /* Fetch the default size if not resolved. */
900: size = must_parse_int (&(ieee->h));
901: /* Fetch the default value if available. */
902: if (! parse_int (&(ieee->h), &value))
903: value = 0;
904: /* This turns into a common. */
905: symbol->symbol.section = bfd_com_section_ptr;
906: symbol->symbol.value = size;
907: }
908: break;
909:
910: case ieee_external_reference_enum:
911: next_byte (&(ieee->h));
912:
913: symbol = get_symbol (abfd, ieee, symbol, &symbol_count,
914: &prev_reference_ptr,
915: &ieee->external_reference_max_index, 'X');
916: if (symbol == NULL)
917: return FALSE;
918:
919: symbol->symbol.the_bfd = abfd;
920: symbol->symbol.name = read_id (&(ieee->h));
921: symbol->symbol.udata.p = NULL;
922: symbol->symbol.section = bfd_und_section_ptr;
923: symbol->symbol.value = (bfd_vma) 0;
924: symbol->symbol.flags = 0;
925:
926: BFD_ASSERT (symbol->index >= ieee->external_reference_min_index);
927: break;
928:
929: default:
930: loop = FALSE;
931: }
932: }
933:
934: if (ieee->external_symbol_max_index != 0)
935: {
936: ieee->external_symbol_count =
937: ieee->external_symbol_max_index -
938: ieee->external_symbol_min_index + 1;
939: }
940: else
941: ieee->external_symbol_count = 0;
942:
943: if (ieee->external_reference_max_index != 0)
944: {
945: ieee->external_reference_count =
946: ieee->external_reference_max_index -
947: ieee->external_reference_min_index + 1;
948: }
949: else
950: ieee->external_reference_count = 0;
951:
952: abfd->symcount =
953: ieee->external_reference_count + ieee->external_symbol_count;
954:
955: if (symbol_count != abfd->symcount)
956: /* There are gaps in the table -- */
957: ieee->symbol_table_full = FALSE;
958:
959: *prev_symbols_ptr = NULL;
960: *prev_reference_ptr = NULL;
961:
962: return TRUE;
963: }
964:
965: static bfd_boolean
966: ieee_slurp_symbol_table (bfd *abfd)
967: {
968: if (! IEEE_DATA (abfd)->read_symbols)
969: {
970: if (! ieee_slurp_external_symbols (abfd))
971: return FALSE;
972: IEEE_DATA (abfd)->read_symbols = TRUE;
973: }
974: return TRUE;
975: }
976:
977: static long
978: ieee_get_symtab_upper_bound (bfd *abfd)
979: {
980: if (! ieee_slurp_symbol_table (abfd))
981: return -1;
982:
983: return (abfd->symcount != 0) ?
984: (abfd->symcount + 1) * (sizeof (ieee_symbol_type *)) : 0;
985: }
986:
987: /* Move from our internal lists to the canon table, and insert in
988: symbol index order. */
989:
990: extern const bfd_target ieee_vec;
991:
992: static long
993: ieee_canonicalize_symtab (bfd *abfd, asymbol **location)
994: {
995: ieee_symbol_type *symp;
996: static bfd dummy_bfd;
997: static asymbol empty_symbol =
998: {
999: &dummy_bfd,
1000: " ieee empty",
1001: (symvalue) 0,
1002: BSF_DEBUGGING,
1003: bfd_abs_section_ptr
1004: #ifdef __STDC__
1005: /* K&R compilers can't initialise unions. */
1006: , { 0 }
1007: #endif
1008: };
1009:
1010: if (abfd->symcount)
1011: {
1012: ieee_data_type *ieee = IEEE_DATA (abfd);
1013:
1014: dummy_bfd.xvec = &ieee_vec;
1015: if (! ieee_slurp_symbol_table (abfd))
1016: return -1;
1017:
1018: if (! ieee->symbol_table_full)
1019: {
1020: /* Arrgh - there are gaps in the table, run through and fill them
1021: up with pointers to a null place. */
1022: unsigned int i;
1023:
1024: for (i = 0; i < abfd->symcount; i++)
1025: location[i] = &empty_symbol;
1026: }
1027:
1028: ieee->external_symbol_base_offset = -ieee->external_symbol_min_index;
1029: for (symp = IEEE_DATA (abfd)->external_symbols;
1030: symp != (ieee_symbol_type *) NULL;
1031: symp = symp->next)
1032: /* Place into table at correct index locations. */
1033: location[symp->index + ieee->external_symbol_base_offset] = &symp->symbol;
1034:
1035: /* The external refs are indexed in a bit. */
1036: ieee->external_reference_base_offset =
1037: -ieee->external_reference_min_index + ieee->external_symbol_count;
1038:
1039: for (symp = IEEE_DATA (abfd)->external_reference;
1040: symp != (ieee_symbol_type *) NULL;
1041: symp = symp->next)
1042: location[symp->index + ieee->external_reference_base_offset] =
1043: &symp->symbol;
1044: }
1045:
1046: if (abfd->symcount)
1047: location[abfd->symcount] = (asymbol *) NULL;
1048:
1049: return abfd->symcount;
1050: }
1051:
1052: static asection *
1053: get_section_entry (bfd *abfd, ieee_data_type *ieee, unsigned int sindex)
1054: {
1055: if (sindex >= ieee->section_table_size)
1056: {
1057: unsigned int c, i;
1058: asection **n;
1059: bfd_size_type amt;
1060:
1061: c = ieee->section_table_size;
1062: if (c == 0)
1063: c = 20;
1064: while (c <= sindex)
1065: c *= 2;
1066:
1067: amt = c;
1068: amt *= sizeof (asection *);
1069: n = bfd_realloc (ieee->section_table, amt);
1070: if (n == NULL)
1071: return NULL;
1072:
1073: for (i = ieee->section_table_size; i < c; i++)
1074: n[i] = NULL;
1075:
1076: ieee->section_table = n;
1077: ieee->section_table_size = c;
1078: }
1079:
1080: if (ieee->section_table[sindex] == (asection *) NULL)
1081: {
1082: char *tmp = bfd_alloc (abfd, (bfd_size_type) 11);
1083: asection *section;
1084:
1085: if (!tmp)
1086: return NULL;
1087: sprintf (tmp, " fsec%4d", sindex);
1088: section = bfd_make_section (abfd, tmp);
1089: ieee->section_table[sindex] = section;
1090: section->target_index = sindex;
1091: ieee->section_table[sindex] = section;
1092: }
1093: return ieee->section_table[sindex];
1094: }
1095:
1096: static void
1097: ieee_slurp_sections (bfd *abfd)
1098: {
1099: ieee_data_type *ieee = IEEE_DATA (abfd);
1100: file_ptr offset = ieee->w.r.section_part;
1101: char *name;
1102:
1103: if (offset != 0)
1104: {
1105: bfd_byte section_type[3];
1106:
1107: ieee_seek (ieee, offset);
1108: while (TRUE)
1109: {
1110: switch (this_byte (&(ieee->h)))
1111: {
1112: case ieee_section_type_enum:
1113: {
1114: asection *section;
1115: unsigned int section_index;
1116:
1117: next_byte (&(ieee->h));
1118: section_index = must_parse_int (&(ieee->h));
1119:
1120: section = get_section_entry (abfd, ieee, section_index);
1121:
1122: section_type[0] = this_byte_and_next (&(ieee->h));
1123:
1124: /* Set minimal section attributes. Attributes are
1125: extended later, based on section contents. */
1126: switch (section_type[0])
1127: {
1128: case 0xC1:
1129: /* Normal attributes for absolute sections. */
1130: section_type[1] = this_byte (&(ieee->h));
1131: section->flags = SEC_ALLOC;
1132: switch (section_type[1])
1133: {
1134: /* AS Absolute section attributes. */
1135: case 0xD3:
1136: next_byte (&(ieee->h));
1137: section_type[2] = this_byte (&(ieee->h));
1138: switch (section_type[2])
1139: {
1140: case 0xD0:
1141: /* Normal code. */
1142: next_byte (&(ieee->h));
1143: section->flags |= SEC_CODE;
1144: break;
1145: case 0xC4:
1146: /* Normal data. */
1147: next_byte (&(ieee->h));
1148: section->flags |= SEC_DATA;
1149: break;
1150: case 0xD2:
1151: next_byte (&(ieee->h));
1152: /* Normal rom data. */
1153: section->flags |= SEC_ROM | SEC_DATA;
1154: break;
1155: default:
1156: break;
1157: }
1158: }
1159: break;
1160:
1161: /* Named relocatable sections (type C). */
1162: case 0xC3:
1163: section_type[1] = this_byte (&(ieee->h));
1164: section->flags = SEC_ALLOC;
1165: switch (section_type[1])
1166: {
1167: case 0xD0: /* Normal code (CP). */
1168: next_byte (&(ieee->h));
1169: section->flags |= SEC_CODE;
1170: break;
1171: case 0xC4: /* Normal data (CD). */
1172: next_byte (&(ieee->h));
1173: section->flags |= SEC_DATA;
1174: break;
1175: case 0xD2: /* Normal rom data (CR). */
1176: next_byte (&(ieee->h));
1177: section->flags |= SEC_ROM | SEC_DATA;
1178: break;
1179: default:
1180: break;
1181: }
1182: }
1183:
1184: /* Read section name, use it if non empty. */
1185: name = read_id (&ieee->h);
1186: if (name[0])
1187: section->name = name;
1188:
1189: /* Skip these fields, which we don't care about. */
1190: {
1191: bfd_vma parent, brother, context;
1192:
1193: parse_int (&(ieee->h), &parent);
1194: parse_int (&(ieee->h), &brother);
1195: parse_int (&(ieee->h), &context);
1196: }
1197: }
1198: break;
1199: case ieee_section_alignment_enum:
1200: {
1201: unsigned int section_index;
1202: bfd_vma value;
1203: asection *section;
1204:
1205: next_byte (&(ieee->h));
1206: section_index = must_parse_int (&ieee->h);
1207: section = get_section_entry (abfd, ieee, section_index);
1208: if (section_index > ieee->section_count)
1209: ieee->section_count = section_index;
1210:
1211: section->alignment_power =
1212: bfd_log2 (must_parse_int (&ieee->h));
1213: (void) parse_int (&(ieee->h), &value);
1214: }
1215: break;
1216: case ieee_e2_first_byte_enum:
1217: {
1218: asection *section;
1219: ieee_record_enum_type t;
1220:
1221: t = (ieee_record_enum_type) (read_2bytes (&(ieee->h)));
1222: switch (t)
1223: {
1224: case ieee_section_size_enum:
1225: section = ieee->section_table[must_parse_int (&(ieee->h))];
1226: section->size = must_parse_int (&(ieee->h));
1227: break;
1228: case ieee_physical_region_size_enum:
1229: section = ieee->section_table[must_parse_int (&(ieee->h))];
1230: section->size = must_parse_int (&(ieee->h));
1231: break;
1232: case ieee_region_base_address_enum:
1233: section = ieee->section_table[must_parse_int (&(ieee->h))];
1234: section->vma = must_parse_int (&(ieee->h));
1235: section->lma = section->vma;
1236: break;
1237: case ieee_mau_size_enum:
1238: must_parse_int (&(ieee->h));
1239: must_parse_int (&(ieee->h));
1240: break;
1241: case ieee_m_value_enum:
1242: must_parse_int (&(ieee->h));
1243: must_parse_int (&(ieee->h));
1244: break;
1245: case ieee_section_base_address_enum:
1246: section = ieee->section_table[must_parse_int (&(ieee->h))];
1247: section->vma = must_parse_int (&(ieee->h));
1248: section->lma = section->vma;
1249: break;
1250: case ieee_section_offset_enum:
1251: (void) must_parse_int (&(ieee->h));
1252: (void) must_parse_int (&(ieee->h));
1253: break;
1254: default:
1255: return;
1256: }
1257: }
1258: break;
1259: default:
1260: return;
1261: }
1262: }
1263: }
1264: }
1265:
1266: /* Make a section for the debugging information, if any. We don't try
1267: to interpret the debugging information; we just point the section
1268: at the area in the file so that program which understand can dig it
1269: out. */
1270:
1271: static bfd_boolean
1272: ieee_slurp_debug (bfd *abfd)
1273: {
1274: ieee_data_type *ieee = IEEE_DATA (abfd);
1275: asection *sec;
1276: file_ptr debug_end;
1277: flagword flags;
1278:
1279: if (ieee->w.r.debug_information_part == 0)
1280: return TRUE;
1281:
1282: flags = SEC_DEBUGGING | SEC_HAS_CONTENTS;
1283: sec = bfd_make_section_with_flags (abfd, ".debug", flags);
1284: if (sec == NULL)
1285: return FALSE;
1286: sec->filepos = ieee->w.r.debug_information_part;
1287:
1288: debug_end = ieee_part_after (ieee, ieee->w.r.debug_information_part);
1289: sec->size = debug_end - ieee->w.r.debug_information_part;
1290:
1291: return TRUE;
1292: }
1293:
1294: /* Archive stuff. */
1295:
1296: static const bfd_target *
1297: ieee_archive_p (bfd *abfd)
1298: {
1299: char *library;
1300: unsigned int i;
1301: unsigned char buffer[512];
1302: file_ptr buffer_offset = 0;
1303: ieee_ar_data_type *save = abfd->tdata.ieee_ar_data;
1304: ieee_ar_data_type *ieee;
1305: bfd_size_type alc_elts;
1306: ieee_ar_obstack_type *elts = NULL;
1307: bfd_size_type amt = sizeof (ieee_ar_data_type);
1308:
1309: abfd->tdata.ieee_ar_data = bfd_alloc (abfd, amt);
1310: if (!abfd->tdata.ieee_ar_data)
1311: goto error_ret_restore;
1312: ieee = IEEE_AR_DATA (abfd);
1313:
1314: /* Ignore the return value here. It doesn't matter if we don't read
1315: the entire buffer. We might have a very small ieee file. */
1316: bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd);
1317:
1318: ieee->h.first_byte = buffer;
1319: ieee->h.input_p = buffer;
1320:
1321: ieee->h.abfd = abfd;
1322:
1323: if (this_byte (&(ieee->h)) != Module_Beginning)
1324: goto got_wrong_format_error;
1325:
1326: next_byte (&(ieee->h));
1327: library = read_id (&(ieee->h));
1328: if (strcmp (library, "LIBRARY") != 0)
1329: goto got_wrong_format_error;
1330:
1331: /* Throw away the filename. */
1332: read_id (&(ieee->h));
1333:
1334: ieee->element_count = 0;
1335: ieee->element_index = 0;
1336:
1337: next_byte (&(ieee->h)); /* Drop the ad part. */
1338: must_parse_int (&(ieee->h)); /* And the two dummy numbers. */
1339: must_parse_int (&(ieee->h));
1340:
1341: alc_elts = 10;
1342: elts = bfd_malloc (alc_elts * sizeof *elts);
1343: if (elts == NULL)
1344: goto error_return;
1345:
1346: /* Read the index of the BB table. */
1347: while (1)
1348: {
1349: int rec;
1350: ieee_ar_obstack_type *t;
1351:
1352: rec = read_2bytes (&(ieee->h));
1353: if (rec != (int) ieee_assign_value_to_variable_enum)
1354: break;
1355:
1356: if (ieee->element_count >= alc_elts)
1357: {
1358: ieee_ar_obstack_type *n;
1359:
1360: alc_elts *= 2;
1361: n = bfd_realloc (elts, alc_elts * sizeof (* elts));
1362: if (n == NULL)
1363: goto error_return;
1364: elts = n;
1365: }
1366:
1367: t = &elts[ieee->element_count];
1368: ieee->element_count++;
1369:
1370: must_parse_int (&(ieee->h));
1371: t->file_offset = must_parse_int (&(ieee->h));
1372: t->abfd = (bfd *) NULL;
1373:
1374: /* Make sure that we don't go over the end of the buffer. */
1375: if ((size_t) ieee_pos (IEEE_DATA (abfd)) > sizeof (buffer) / 2)
1376: {
1377: /* Past half way, reseek and reprime. */
1378: buffer_offset += ieee_pos (IEEE_DATA (abfd));
1379: if (bfd_seek (abfd, buffer_offset, SEEK_SET) != 0)
1380: goto error_return;
1381:
1382: /* Again ignore return value of bfd_bread. */
1383: bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd);
1384: ieee->h.first_byte = buffer;
1385: ieee->h.input_p = buffer;
1386: }
1387: }
1388:
1389: amt = ieee->element_count;
1390: amt *= sizeof *ieee->elements;
1391: ieee->elements = bfd_alloc (abfd, amt);
1392: if (ieee->elements == NULL)
1393: goto error_return;
1394:
1395: memcpy (ieee->elements, elts, (size_t) amt);
1396: free (elts);
1397: elts = NULL;
1398:
1399: /* Now scan the area again, and replace BB offsets with file offsets. */
1400: for (i = 2; i < ieee->element_count; i++)
1401: {
1402: if (bfd_seek (abfd, ieee->elements[i].file_offset, SEEK_SET) != 0)
1403: goto error_return;
1404:
1405: /* Again ignore return value of bfd_bread. */
1406: bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd);
1407: ieee->h.first_byte = buffer;
1408: ieee->h.input_p = buffer;
1409:
1410: next_byte (&(ieee->h)); /* Drop F8. */
1411: next_byte (&(ieee->h)); /* Drop 14. */
1412: must_parse_int (&(ieee->h)); /* Drop size of block. */
1413:
1414: if (must_parse_int (&(ieee->h)) != 0)
1415: /* This object has been deleted. */
1416: ieee->elements[i].file_offset = 0;
1417: else
1418: ieee->elements[i].file_offset = must_parse_int (&(ieee->h));
1419: }
1420:
1421: /* abfd->has_armap = ;*/
1422:
1423: return abfd->xvec;
1424:
1425: got_wrong_format_error:
1426: bfd_set_error (bfd_error_wrong_format);
1427: error_return:
1428: if (elts != NULL)
1429: free (elts);
1430: bfd_release (abfd, ieee);
1431: error_ret_restore:
1432: abfd->tdata.ieee_ar_data = save;
1433:
1434: return NULL;
1435: }
1436:
1437: static bfd_boolean
1438: ieee_mkobject (bfd *abfd)
1439: {
1440: bfd_size_type amt;
1441:
1442: output_ptr_start = NULL;
1443: output_ptr = NULL;
1444: output_ptr_end = NULL;
1445: input_ptr_start = NULL;
1446: input_ptr = NULL;
1447: input_ptr_end = NULL;
1448: input_bfd = NULL;
1449: output_bfd = NULL;
1450: output_buffer = 0;
1451: amt = sizeof (ieee_data_type);
1452: abfd->tdata.ieee_data = bfd_zalloc (abfd, amt);
1453: return abfd->tdata.ieee_data != NULL;
1454: }
1455:
1456: static bfd_boolean
1457: do_one (ieee_data_type *ieee,
1458: ieee_per_section_type *current_map,
1459: unsigned char *location_ptr,
1460: asection *s,
1461: int iterations)
1462: {
1463: switch (this_byte (&(ieee->h)))
1464: {
1465: case ieee_load_constant_bytes_enum:
1466: {
1467: unsigned int number_of_maus;
1468: unsigned int i;
1469:
1470: next_byte (&(ieee->h));
1471: number_of_maus = must_parse_int (&(ieee->h));
1472:
1473: for (i = 0; i < number_of_maus; i++)
1474: {
1475: location_ptr[current_map->pc++] = this_byte (&(ieee->h));
1476: next_byte (&(ieee->h));
1477: }
1478: }
1479: break;
1480:
1481: case ieee_load_with_relocation_enum:
1482: {
1483: bfd_boolean loop = TRUE;
1484:
1485: next_byte (&(ieee->h));
1486: while (loop)
1487: {
1488: switch (this_byte (&(ieee->h)))
1489: {
1490: case ieee_variable_R_enum:
1491:
1492: case ieee_function_signed_open_b_enum:
1493: case ieee_function_unsigned_open_b_enum:
1494: case ieee_function_either_open_b_enum:
1495: {
1496: unsigned int extra = 4;
1497: bfd_boolean pcrel = FALSE;
1498: asection *section;
1499: ieee_reloc_type *r;
1500:
1501: r = bfd_alloc (ieee->h.abfd, sizeof (* r));
1502: if (!r)
1503: return FALSE;
1504:
1505: *(current_map->reloc_tail_ptr) = r;
1506: current_map->reloc_tail_ptr = &r->next;
1507: r->next = (ieee_reloc_type *) NULL;
1508: next_byte (&(ieee->h));
1509: /* abort();*/
1510: r->relent.sym_ptr_ptr = 0;
1511: parse_expression (ieee,
1512: &r->relent.addend,
1513: &r->symbol,
1514: &pcrel, &extra, §ion);
1515: r->relent.address = current_map->pc;
1516: s->flags |= SEC_RELOC;
1517: s->owner->flags |= HAS_RELOC;
1518: s->reloc_count++;
1519: if (r->relent.sym_ptr_ptr == NULL && section != NULL)
1520: r->relent.sym_ptr_ptr = section->symbol_ptr_ptr;
1521:
1522: if (this_byte (&(ieee->h)) == (int) ieee_comma)
1523: {
1524: next_byte (&(ieee->h));
1525: /* Fetch number of bytes to pad. */
1526: extra = must_parse_int (&(ieee->h));
1527: };
1528:
1529: switch (this_byte (&(ieee->h)))
1530: {
1531: case ieee_function_signed_close_b_enum:
1532: next_byte (&(ieee->h));
1533: break;
1534: case ieee_function_unsigned_close_b_enum:
1535: next_byte (&(ieee->h));
1536: break;
1537: case ieee_function_either_close_b_enum:
1538: next_byte (&(ieee->h));
1539: break;
1540: default:
1541: break;
1542: }
1543: /* Build a relocation entry for this type. */
1544: /* If pc rel then stick -ve pc into instruction
1545: and take out of reloc ..
1546:
1547: I've changed this. It's all too complicated. I
1548: keep 0 in the instruction now. */
1549:
1550: switch (extra)
1551: {
1552: case 0:
1553: case 4:
1554:
1555: if (pcrel)
1556: {
1557: #if KEEPMINUSPCININST
1558: bfd_put_32 (ieee->h.abfd, -current_map->pc,
1559: location_ptr + current_map->pc);
1560: r->relent.howto = &rel32_howto;
1561: r->relent.addend -= current_map->pc;
1562: #else
1563: bfd_put_32 (ieee->h.abfd, (bfd_vma) 0, location_ptr +
1564: current_map->pc);
1565: r->relent.howto = &rel32_howto;
1566: #endif
1567: }
1568: else
1569: {
1570: bfd_put_32 (ieee->h.abfd, (bfd_vma) 0,
1571: location_ptr + current_map->pc);
1572: r->relent.howto = &abs32_howto;
1573: }
1574: current_map->pc += 4;
1575: break;
1576: case 2:
1577: if (pcrel)
1578: {
1579: #if KEEPMINUSPCININST
1580: bfd_put_16 (ieee->h.abfd, (bfd_vma) -current_map->pc,
1581: location_ptr + current_map->pc);
1582: r->relent.addend -= current_map->pc;
1583: r->relent.howto = &rel16_howto;
1584: #else
1585:
1586: bfd_put_16 (ieee->h.abfd, (bfd_vma) 0,
1587: location_ptr + current_map->pc);
1588: r->relent.howto = &rel16_howto;
1589: #endif
1590: }
1591:
1592: else
1593: {
1594: bfd_put_16 (ieee->h.abfd, (bfd_vma) 0,
1595: location_ptr + current_map->pc);
1596: r->relent.howto = &abs16_howto;
1597: }
1598: current_map->pc += 2;
1599: break;
1600: case 1:
1601: if (pcrel)
1602: {
1603: #if KEEPMINUSPCININST
1604: bfd_put_8 (ieee->h.abfd, (int) (-current_map->pc), location_ptr + current_map->pc);
1605: r->relent.addend -= current_map->pc;
1606: r->relent.howto = &rel8_howto;
1607: #else
1608: bfd_put_8 (ieee->h.abfd, 0, location_ptr + current_map->pc);
1609: r->relent.howto = &rel8_howto;
1610: #endif
1611: }
1612: else
1613: {
1614: bfd_put_8 (ieee->h.abfd, 0, location_ptr + current_map->pc);
1615: r->relent.howto = &abs8_howto;
1616: }
1617: current_map->pc += 1;
1618: break;
1619:
1620: default:
1621: BFD_FAIL ();
1622: return FALSE;
1623: }
1624: }
1625: break;
1626: default:
1627: {
1628: bfd_vma this_size;
1629:
1630: if (parse_int (&(ieee->h), &this_size))
1631: {
1632: unsigned int i;
1633:
1634: for (i = 0; i < this_size; i++)
1635: {
1636: location_ptr[current_map->pc++] = this_byte (&(ieee->h));
1637: next_byte (&(ieee->h));
1638: }
1639: }
1640: else
1641: loop = FALSE;
1642: }
1643: }
1644:
1645: /* Prevent more than the first load-item of an LR record
1646: from being repeated (MRI convention). */
1647: if (iterations != 1)
1648: loop = FALSE;
1649: }
1650: }
1651: }
1652: return TRUE;
1653: }
1654:
1655: /* Read in all the section data and relocation stuff too. */
1656:
1657: static bfd_boolean
1658: ieee_slurp_section_data (bfd *abfd)
1659: {
1660: bfd_byte *location_ptr = (bfd_byte *) NULL;
1661: ieee_data_type *ieee = IEEE_DATA (abfd);
1662: unsigned int section_number;
1663: ieee_per_section_type *current_map = NULL;
1664: asection *s;
1665:
1666: /* Seek to the start of the data area. */
1667: if (ieee->read_data)
1668: return TRUE;
1669: ieee->read_data = TRUE;
1670: ieee_seek (ieee, ieee->w.r.data_part);
1671:
1672: /* Allocate enough space for all the section contents. */
1673: for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1674: {
1675: ieee_per_section_type *per = ieee_per_section (s);
1676: arelent **relpp;
1677:
1678: if ((s->flags & SEC_DEBUGGING) != 0)
1679: continue;
1680: per->data = bfd_alloc (ieee->h.abfd, s->size);
1681: if (!per->data)
1682: return FALSE;
1683: relpp = &s->relocation;
1684: per->reloc_tail_ptr = (ieee_reloc_type **) relpp;
1685: }
1686:
1687: while (TRUE)
1688: {
1689: switch (this_byte (&(ieee->h)))
1690: {
1691: /* IF we see anything strange then quit. */
1692: default:
1693: return TRUE;
1694:
1695: case ieee_set_current_section_enum:
1696: next_byte (&(ieee->h));
1697: section_number = must_parse_int (&(ieee->h));
1698: s = ieee->section_table[section_number];
1699: s->flags |= SEC_LOAD | SEC_HAS_CONTENTS;
1700: current_map = ieee_per_section (s);
1701: location_ptr = current_map->data - s->vma;
1702: /* The document I have says that Microtec's compilers reset
1703: this after a sec section, even though the standard says not
1704: to, SO... */
1705: current_map->pc = s->vma;
1706: break;
1707:
1708: case ieee_e2_first_byte_enum:
1709: next_byte (&(ieee->h));
1710: switch (this_byte (&(ieee->h)))
1711: {
1712: case ieee_set_current_pc_enum & 0xff:
1713: {
1714: bfd_vma value;
1715: ieee_symbol_index_type symbol;
1716: unsigned int extra;
1717: bfd_boolean pcrel;
1718:
1719: next_byte (&(ieee->h));
1720: must_parse_int (&(ieee->h)); /* Throw away section #. */
1721: parse_expression (ieee, &value,
1722: &symbol,
1723: &pcrel, &extra,
1724: 0);
1725: current_map->pc = value;
1726: BFD_ASSERT ((unsigned) (value - s->vma) <= s->size);
1727: }
1728: break;
1729:
1730: case ieee_value_starting_address_enum & 0xff:
1731: next_byte (&(ieee->h));
1732: if (this_byte (&(ieee->h)) == ieee_function_either_open_b_enum)
1733: next_byte (&(ieee->h));
1734: abfd->start_address = must_parse_int (&(ieee->h));
1735: /* We've got to the end of the data now - */
1736: return TRUE;
1737: default:
1738: BFD_FAIL ();
1739: return FALSE;
1740: }
1741: break;
1742: case ieee_repeat_data_enum:
1743: {
1744: /* Repeat the following LD or LR n times - we do this by
1745: remembering the stream pointer before running it and
1746: resetting it and running it n times. We special case
1747: the repetition of a repeat_data/load_constant. */
1748: unsigned int iterations;
1749: unsigned char *start;
1750:
1751: next_byte (&(ieee->h));
1752: iterations = must_parse_int (&(ieee->h));
1753: start = ieee->h.input_p;
1754: if (start[0] == (int) ieee_load_constant_bytes_enum
1755: && start[1] == 1)
1756: {
1757: while (iterations != 0)
1758: {
1759: location_ptr[current_map->pc++] = start[2];
1760: iterations--;
1761: }
1762: next_byte (&(ieee->h));
1763: next_byte (&(ieee->h));
1764: next_byte (&(ieee->h));
1765: }
1766: else
1767: {
1768: while (iterations != 0)
1769: {
1770: ieee->h.input_p = start;
1771: if (!do_one (ieee, current_map, location_ptr, s,
1772: (int) iterations))
1773: return FALSE;
1774: iterations--;
1775: }
1776: }
1777: }
1778: break;
1779: case ieee_load_constant_bytes_enum:
1780: case ieee_load_with_relocation_enum:
1781: if (!do_one (ieee, current_map, location_ptr, s, 1))
1782: return FALSE;
1783: }
1784: }
1785: }
1786:
1787: static const bfd_target *
1788: ieee_object_p (bfd *abfd)
1789: {
1790: char *processor;
1791: unsigned int part;
1792: ieee_data_type *ieee;
1793: unsigned char buffer[300];
1794: ieee_data_type *save = IEEE_DATA (abfd);
1795: bfd_size_type amt;
1796:
1797: abfd->tdata.ieee_data = 0;
1798: ieee_mkobject (abfd);
1799:
1800: ieee = IEEE_DATA (abfd);
1801: if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
1802: goto fail;
1803: /* Read the first few bytes in to see if it makes sense. Ignore
1804: bfd_bread return value; The file might be very small. */
1805: bfd_bread ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd);
1806:
1807: ieee->h.input_p = buffer;
1808: if (this_byte_and_next (&(ieee->h)) != Module_Beginning)
1809: goto got_wrong_format;
1810:
1811: ieee->read_symbols = FALSE;
1812: ieee->read_data = FALSE;
1813: ieee->section_count = 0;
1814: ieee->external_symbol_max_index = 0;
1815: ieee->external_symbol_min_index = IEEE_PUBLIC_BASE;
1816: ieee->external_reference_min_index = IEEE_REFERENCE_BASE;
1817: ieee->external_reference_max_index = 0;
1818: ieee->h.abfd = abfd;
1819: ieee->section_table = NULL;
1820: ieee->section_table_size = 0;
1821:
1822: processor = ieee->mb.processor = read_id (&(ieee->h));
1823: if (strcmp (processor, "LIBRARY") == 0)
1824: goto got_wrong_format;
1825: ieee->mb.module_name = read_id (&(ieee->h));
1826: if (abfd->filename == (const char *) NULL)
1827: abfd->filename = ieee->mb.module_name;
1828:
1829: /* Determine the architecture and machine type of the object file. */
1830: {
1831: const bfd_arch_info_type *arch;
1832: char family[10];
1833:
1834: /* IEEE does not specify the format of the processor identification
1835: string, so the compiler is free to put in it whatever it wants.
1836: We try here to recognize different processors belonging to the
1837: m68k family. Code for other processors can be added here. */
1838: if ((processor[0] == '6') && (processor[1] == '8'))
1839: {
1840: if (processor[2] == '3') /* 683xx integrated processors. */
1841: {
1842: switch (processor[3])
1843: {
1844: case '0': /* 68302, 68306, 68307 */
1845: case '2': /* 68322, 68328 */
1846: case '5': /* 68356 */
1847: strcpy (family, "68000"); /* MC68000-based controllers. */
1848: break;
1849:
1850: case '3': /* 68330, 68331, 68332, 68333,
1851: 68334, 68335, 68336, 68338 */
1852: case '6': /* 68360 */
1853: case '7': /* 68376 */
1854: strcpy (family, "68332"); /* CPU32 and CPU32+ */
1855: break;
1856:
1857: case '4':
1858: if (processor[4] == '9') /* 68349 */
1859: strcpy (family, "68030"); /* CPU030 */
1860: else /* 68340, 68341 */
1861: strcpy (family, "68332"); /* CPU32 and CPU32+ */
1862: break;
1863:
1864: default: /* Does not exist yet. */
1865: strcpy (family, "68332"); /* Guess it will be CPU32 */
1866: }
1867: }
1868: else if (TOUPPER (processor[3]) == 'F') /* 68F333 */
1869: strcpy (family, "68332"); /* CPU32 */
1870: else if ((TOUPPER (processor[3]) == 'C') /* Embedded controllers. */
1871: && ((TOUPPER (processor[2]) == 'E')
1872: || (TOUPPER (processor[2]) == 'H')
1873: || (TOUPPER (processor[2]) == 'L')))
1874: {
1875: strcpy (family, "68");
1876: strncat (family, processor + 4, 7);
1877: family[9] = '\0';
1878: }
1879: else /* "Regular" processors. */
1880: {
1881: strncpy (family, processor, 9);
1882: family[9] = '\0';
1883: }
1884: }
1885: else if ((CONST_STRNEQ (processor, "cpu32")) /* CPU32 and CPU32+ */
1886: || (CONST_STRNEQ (processor, "CPU32")))
1887: strcpy (family, "68332");
1888: else
1889: {
1890: strncpy (family, processor, 9);
1891: family[9] = '\0';
1892: }
1893:
1894: arch = bfd_scan_arch (family);
1895: if (arch == 0)
1896: goto got_wrong_format;
1897: abfd->arch_info = arch;
1898: }
1899:
1900: if (this_byte (&(ieee->h)) != (int) ieee_address_descriptor_enum)
1901: goto fail;
1902:
1903: next_byte (&(ieee->h));
1904:
1905: if (! parse_int (&(ieee->h), &ieee->ad.number_of_bits_mau))
1906: goto fail;
1907:
1908: if (! parse_int (&(ieee->h), &ieee->ad.number_of_maus_in_address))
1909: goto fail;
1910:
1911: /* If there is a byte order info, take it. */
1912: if (this_byte (&(ieee->h)) == (int) ieee_variable_L_enum
1913: || this_byte (&(ieee->h)) == (int) ieee_variable_M_enum)
1914: next_byte (&(ieee->h));
1915:
1916: for (part = 0; part < N_W_VARIABLES; part++)
1917: {
1918: bfd_boolean ok;
1919:
1920: if (read_2bytes (&(ieee->h)) != (int) ieee_assign_value_to_variable_enum)
1921: goto fail;
1922:
1923: if (this_byte_and_next (&(ieee->h)) != part)
1924: goto fail;
1925:
1926: ieee->w.offset[part] = parse_i (&(ieee->h), &ok);
1927: if (! ok)
1928: goto fail;
1929: }
1930:
1931: if (ieee->w.r.external_part != 0)
1932: abfd->flags = HAS_SYMS;
1933:
1934: /* By now we know that this is a real IEEE file, we're going to read
1935: the whole thing into memory so that we can run up and down it
1936: quickly. We can work out how big the file is from the trailer
1937: record. */
1938:
1939: amt = ieee->w.r.me_record + 1;
1940: IEEE_DATA (abfd)->h.first_byte = bfd_alloc (ieee->h.abfd, amt);
1941: if (!IEEE_DATA (abfd)->h.first_byte)
1942: goto fail;
1943: if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
1944: goto fail;
1945: /* FIXME: Check return value. I'm not sure whether it needs to read
1946: the entire buffer or not. */
1947: bfd_bread ((void *) (IEEE_DATA (abfd)->h.first_byte),
1948: (bfd_size_type) ieee->w.r.me_record + 1, abfd);
1949:
1950: ieee_slurp_sections (abfd);
1951:
1952: if (! ieee_slurp_debug (abfd))
1953: goto fail;
1954:
1955: /* Parse section data to activate file and section flags implied by
1956: section contents. */
1957: if (! ieee_slurp_section_data (abfd))
1958: goto fail;
1959:
1960: return abfd->xvec;
1961: got_wrong_format:
1962: bfd_set_error (bfd_error_wrong_format);
1963: fail:
1964: bfd_release (abfd, ieee);
1965: abfd->tdata.ieee_data = save;
1966: return (const bfd_target *) NULL;
1967: }
1968:
1969: static void
1970: ieee_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED,
1971: asymbol *symbol,
1972: symbol_info *ret)
1973: {
1974: bfd_symbol_info (symbol, ret);
1975: if (symbol->name[0] == ' ')
1976: ret->name = "* empty table entry ";
1977: if (!symbol->section)
1978: ret->type = (symbol->flags & BSF_LOCAL) ? 'a' : 'A';
1979: }
1980:
1981: static void
1982: ieee_print_symbol (bfd *abfd,
1983: void * afile,
1984: asymbol *symbol,
1985: bfd_print_symbol_type how)
1986: {
1987: FILE *file = (FILE *) afile;
1988:
1989: switch (how)
1990: {
1991: case bfd_print_symbol_name:
1992: fprintf (file, "%s", symbol->name);
1993: break;
1994: case bfd_print_symbol_more:
1995: BFD_FAIL ();
1996: break;
1997: case bfd_print_symbol_all:
1998: {
1999: const char *section_name =
2000: (symbol->section == (asection *) NULL
2001: ? "*abs"
2002: : symbol->section->name);
2003:
2004: if (symbol->name[0] == ' ')
2005: fprintf (file, "* empty table entry ");
2006: else
2007: {
2008: bfd_print_symbol_vandf (abfd, (void *) file, symbol);
2009:
2010: fprintf (file, " %-5s %04x %02x %s",
2011: section_name,
2012: (unsigned) ieee_symbol (symbol)->index,
2013: (unsigned) 0,
2014: symbol->name);
2015: }
2016: }
2017: break;
2018: }
2019: }
2020:
2021: static bfd_boolean
2022: ieee_new_section_hook (bfd *abfd, asection *newsect)
2023: {
2024: if (!newsect->used_by_bfd)
2025: {
2026: newsect->used_by_bfd = bfd_alloc (abfd, sizeof (ieee_per_section_type));
2027: if (!newsect->used_by_bfd)
2028: return FALSE;
2029: }
2030: ieee_per_section (newsect)->data = NULL;
2031: ieee_per_section (newsect)->section = newsect;
2032: return _bfd_generic_new_section_hook (abfd, newsect);
2033: }
2034:
2035: static long
2036: ieee_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
2037: {
2038: if ((asect->flags & SEC_DEBUGGING) != 0)
2039: return 0;
2040: if (! ieee_slurp_section_data (abfd))
2041: return -1;
2042: return (asect->reloc_count + 1) * sizeof (arelent *);
2043: }
2044:
2045: static bfd_boolean
2046: ieee_get_section_contents (bfd *abfd,
2047: sec_ptr section,
2048: void * location,
2049: file_ptr offset,
2050: bfd_size_type count)
2051: {
2052: ieee_per_section_type *p = ieee_per_section (section);
2053: if ((section->flags & SEC_DEBUGGING) != 0)
2054: return _bfd_generic_get_section_contents (abfd, section, location,
2055: offset, count);
2056: ieee_slurp_section_data (abfd);
2057: (void) memcpy ((void *) location, (void *) (p->data + offset), (unsigned) count);
2058: return TRUE;
2059: }
2060:
2061: static long
2062: ieee_canonicalize_reloc (bfd *abfd,
2063: sec_ptr section,
2064: arelent **relptr,
2065: asymbol **symbols)
2066: {
2067: ieee_reloc_type *src = (ieee_reloc_type *) (section->relocation);
2068: ieee_data_type *ieee = IEEE_DATA (abfd);
2069:
2070: if ((section->flags & SEC_DEBUGGING) != 0)
2071: return 0;
2072:
2073: while (src != (ieee_reloc_type *) NULL)
2074: {
2075: /* Work out which symbol to attach it this reloc to. */
2076: switch (src->symbol.letter)
2077: {
2078: case 'I':
2079: src->relent.sym_ptr_ptr =
2080: symbols + src->symbol.index + ieee->external_symbol_base_offset;
2081: break;
2082: case 'X':
2083: src->relent.sym_ptr_ptr =
2084: symbols + src->symbol.index + ieee->external_reference_base_offset;
2085: break;
2086: case 0:
2087: if (src->relent.sym_ptr_ptr != NULL)
2088: src->relent.sym_ptr_ptr =
2089: src->relent.sym_ptr_ptr[0]->section->symbol_ptr_ptr;
2090: break;
2091: default:
2092:
2093: BFD_FAIL ();
2094: }
2095: *relptr++ = &src->relent;
2096: src = src->next;
2097: }
2098: *relptr = NULL;
2099: return section->reloc_count;
2100: }
2101:
2102: static int
2103: comp (const void * ap, const void * bp)
2104: {
2105: arelent *a = *((arelent **) ap);
2106: arelent *b = *((arelent **) bp);
2107: return a->address - b->address;
2108: }
2109:
2110: /* Write the section headers. */
2111:
2112: static bfd_boolean
2113: ieee_write_section_part (bfd *abfd)
2114: {
2115: ieee_data_type *ieee = IEEE_DATA (abfd);
2116: asection *s;
2117:
2118: ieee->w.r.section_part = bfd_tell (abfd);
2119: for (s = abfd->sections; s != (asection *) NULL; s = s->next)
2120: {
2121: if (! bfd_is_abs_section (s)
2122: && (s->flags & SEC_DEBUGGING) == 0)
2123: {
2124: if (! ieee_write_byte (abfd, ieee_section_type_enum)
2125: || ! ieee_write_byte (abfd,
2126: (bfd_byte) (s->index
2127: + IEEE_SECTION_NUMBER_BASE)))
2128: return FALSE;
2129:
2130: if (abfd->flags & EXEC_P)
2131: {
2132: /* This image is executable, so output absolute sections. */
2133: if (! ieee_write_byte (abfd, ieee_variable_A_enum)
2134: || ! ieee_write_byte (abfd, ieee_variable_S_enum))
2135: return FALSE;
2136: }
2137: else
2138: {
2139: if (! ieee_write_byte (abfd, ieee_variable_C_enum))
2140: return FALSE;
2141: }
2142:
2143: switch (s->flags & (SEC_CODE | SEC_DATA | SEC_ROM))
2144: {
2145: case SEC_CODE | SEC_LOAD:
2146: case SEC_CODE:
2147: if (! ieee_write_byte (abfd, ieee_variable_P_enum))
2148: return FALSE;
2149: break;
2150: case SEC_DATA:
2151: default:
2152: if (! ieee_write_byte (abfd, ieee_variable_D_enum))
2153: return FALSE;
2154: break;
2155: case SEC_ROM:
2156: case SEC_ROM | SEC_DATA:
2157: case SEC_ROM | SEC_LOAD:
2158: case SEC_ROM | SEC_DATA | SEC_LOAD:
2159: if (! ieee_write_byte (abfd, ieee_variable_R_enum))
2160: return FALSE;
2161: }
2162:
2163:
2164: if (! ieee_write_id (abfd, s->name))
2165: return FALSE;
2166: /* Alignment. */
2167: if (! ieee_write_byte (abfd, ieee_section_alignment_enum)
2168: || ! ieee_write_byte (abfd,
2169: (bfd_byte) (s->index
2170: + IEEE_SECTION_NUMBER_BASE))
2171: || ! ieee_write_int (abfd, (bfd_vma) 1 << s->alignment_power))
2172: return FALSE;
2173:
2174: /* Size. */
2175: if (! ieee_write_2bytes (abfd, ieee_section_size_enum)
2176: || ! ieee_write_byte (abfd,
2177: (bfd_byte) (s->index
2178: + IEEE_SECTION_NUMBER_BASE))
2179: || ! ieee_write_int (abfd, s->size))
2180: return FALSE;
2181: if (abfd->flags & EXEC_P)
2182: {
2183: /* Relocateable sections don't have asl records. */
2184: /* Vma. */
2185: if (! ieee_write_2bytes (abfd, ieee_section_base_address_enum)
2186: || ! ieee_write_byte (abfd,
2187: ((bfd_byte)
2188: (s->index
2189: + IEEE_SECTION_NUMBER_BASE)))
2190: || ! ieee_write_int (abfd, s->lma))
2191: return FALSE;
2192: }
2193: }
2194: }
2195:
2196: return TRUE;
2197: }
2198:
2199: static bfd_boolean
2200: do_with_relocs (bfd *abfd, asection *s)
2201: {
2202: unsigned int number_of_maus_in_address =
2203: bfd_arch_bits_per_address (abfd) / bfd_arch_bits_per_byte (abfd);
2204: unsigned int relocs_to_go = s->reloc_count;
2205: bfd_byte *stream = ieee_per_section (s)->data;
2206: arelent **p = s->orelocation;
2207: bfd_size_type current_byte_index = 0;
2208:
2209: qsort (s->orelocation,
2210: relocs_to_go,
2211: sizeof (arelent **),
2212: comp);
2213:
2214: /* Output the section preheader. */
2215: if (! ieee_write_byte (abfd, ieee_set_current_section_enum)
2216: || ! ieee_write_byte (abfd,
2217: (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE))
2218: || ! ieee_write_2bytes (abfd, ieee_set_current_pc_enum)
2219: || ! ieee_write_byte (abfd,
2220: (bfd_byte) (s->index + IEEE_SECTION_NUMBER_BASE)))
2221: return FALSE;
2222:
2223: if ((abfd->flags & EXEC_P) != 0 && relocs_to_go == 0)
2224: {
2225: if (! ieee_write_int (abfd, s->lma))
2226: return FALSE;
2227: }
2228: else
2229: {
2230: if (! ieee_write_expression (abfd, (bfd_vma) 0, s->symbol, 0, 0))
2231: return FALSE;
2232: }
2233:
2234: if (relocs_to_go == 0)
2235: {
2236: /* If there aren't any relocations then output the load constant
2237: byte opcode rather than the load with relocation opcode. */
2238: while (current_byte_index < s->size)
2239: {
2240: bfd_size_type run;
2241: unsigned int MAXRUN = 127;
2242:
2243: run = MAXRUN;
2244: if (run > s->size - current_byte_index)
2245: run = s->size - current_byte_index;
2246:
2247: if (run != 0)
2248: {
2249: if (! ieee_write_byte (abfd, ieee_load_constant_bytes_enum))
2250: return FALSE;
2251: /* Output a stream of bytes. */
2252: if (! ieee_write_int (abfd, run))
2253: return FALSE;
2254: if (bfd_bwrite ((void *) (stream + current_byte_index), run, abfd)
2255: != run)
2256: return FALSE;
2257: current_byte_index += run;
2258: }
2259: }
2260: }
2261: else
2262: {
2263: if (! ieee_write_byte (abfd, ieee_load_with_relocation_enum))
2264: return FALSE;
2265:
2266: /* Output the data stream as the longest sequence of bytes
2267: possible, allowing for the a reasonable packet size and
2268: relocation stuffs. */
2269: if (stream == NULL)
2270: {
2271: /* Outputting a section without data, fill it up. */
2272: stream = bfd_zalloc (abfd, s->size);
2273: if (!stream)
2274: return FALSE;
2275: }
2276: while (current_byte_index < s->size)
2277: {
2278: bfd_size_type run;
2279: unsigned int MAXRUN = 127;
2280:
2281: if (relocs_to_go)
2282: {
2283: run = (*p)->address - current_byte_index;
2284: if (run > MAXRUN)
2285: run = MAXRUN;
2286: }
2287: else
2288: run = MAXRUN;
2289:
2290: if (run > s->size - current_byte_index)
2291: run = s->size - current_byte_index;
2292:
2293: if (run != 0)
2294: {
2295: /* Output a stream of bytes. */
2296: if (! ieee_write_int (abfd, run))
2297: return FALSE;
2298: if (bfd_bwrite ((void *) (stream + current_byte_index), run, abfd)
2299: != run)
2300: return FALSE;
2301: current_byte_index += run;
2302: }
2303:
2304: /* Output any relocations here. */
2305: if (relocs_to_go && (*p) && (*p)->address == current_byte_index)
2306: {
2307: while (relocs_to_go
2308: && (*p) && (*p)->address == current_byte_index)
2309: {
2310: arelent *r = *p;
2311: bfd_signed_vma ov;
2312: switch (r->howto->size)
2313: {
2314: case 2:
2315: ov = bfd_get_signed_32 (abfd,
2316: stream + current_byte_index);
2317: current_byte_index += 4;
2318: break;
2319: case 1:
2320: ov = bfd_get_signed_16 (abfd,
2321: stream + current_byte_index);
2322: current_byte_index += 2;
2323: break;
2324: case 0:
2325: ov = bfd_get_signed_8 (abfd,
2326: stream + current_byte_index);
2327: current_byte_index++;
2328: break;
2329: default:
2330: ov = 0;
2331: BFD_FAIL ();
2332: return FALSE;
2333: }
2334:
2335: ov &= r->howto->src_mask;
2336:
2337: if (r->howto->pc_relative
2338: && ! r->howto->pcrel_offset)
2339: ov += r->address;
2340:
2341: if (! ieee_write_byte (abfd,
2342: ieee_function_either_open_b_enum))
2343: return FALSE;
2344:
2345: if (r->sym_ptr_ptr != (asymbol **) NULL)
2346: {
2347: if (! ieee_write_expression (abfd, r->addend + ov,
2348: *(r->sym_ptr_ptr),
2349: r->howto->pc_relative,
2350: (unsigned) s->index))
2351: return FALSE;
2352: }
2353: else
2354: {
2355: if (! ieee_write_expression (abfd, r->addend + ov,
2356: (asymbol *) NULL,
2357: r->howto->pc_relative,
2358: (unsigned) s->index))
2359: return FALSE;
2360: }
2361:
2362: if (number_of_maus_in_address
2363: != bfd_get_reloc_size (r->howto))
2364: {
2365: bfd_vma rsize = bfd_get_reloc_size (r->howto);
2366: if (! ieee_write_int (abfd, rsize))
2367: return FALSE;
2368: }
2369: if (! ieee_write_byte (abfd,
2370: ieee_function_either_close_b_enum))
2371: return FALSE;
2372:
2373: relocs_to_go--;
2374: p++;
2375: }
2376:
2377: }
2378: }
2379: }
2380:
2381: return TRUE;
2382: }
2383:
2384: /* If there are no relocations in the output section then we can be
2385: clever about how we write. We block items up into a max of 127
2386: bytes. */
2387:
2388: static bfd_boolean
2389: do_as_repeat (bfd *abfd, asection *s)
2390: {
2391: if (s->size)
2392: {
2393: if (! ieee_write_byte (abfd, ieee_set_current_section_enum)
2394: || ! ieee_write_byte (abfd,
2395: (bfd_byte) (s->index
2396: + IEEE_SECTION_NUMBER_BASE))
2397: || ! ieee_write_byte (abfd, ieee_set_current_pc_enum >> 8)
2398: || ! ieee_write_byte (abfd, ieee_set_current_pc_enum & 0xff)
2399: || ! ieee_write_byte (abfd,
2400: (bfd_byte) (s->index
2401: + IEEE_SECTION_NUMBER_BASE)))
2402: return FALSE;
2403:
2404: if ((abfd->flags & EXEC_P) != 0)
2405: {
2406: if (! ieee_write_int (abfd, s->lma))
2407: return FALSE;
2408: }
2409: else
2410: {
2411: if (! ieee_write_expression (abfd, (bfd_vma) 0, s->symbol, 0, 0))
2412: return FALSE;
2413: }
2414:
2415: if (! ieee_write_byte (abfd, ieee_repeat_data_enum)
2416: || ! ieee_write_int (abfd, s->size)
2417: || ! ieee_write_byte (abfd, ieee_load_constant_bytes_enum)
2418: || ! ieee_write_byte (abfd, 1)
2419: || ! ieee_write_byte (abfd, 0))
2420: return FALSE;
2421: }
2422:
2423: return TRUE;
2424: }
2425:
2426: static bfd_boolean
2427: do_without_relocs (bfd *abfd, asection *s)
2428: {
2429: bfd_byte *stream = ieee_per_section (s)->data;
2430:
2431: if (stream == 0 || ((s->flags & SEC_LOAD) == 0))
2432: {
2433: if (! do_as_repeat (abfd, s))
2434: return FALSE;
2435: }
2436: else
2437: {
2438: unsigned int i;
2439:
2440: for (i = 0; i < s->size; i++)
2441: {
2442: if (stream[i] != 0)
2443: {
2444: if (! do_with_relocs (abfd, s))
2445: return FALSE;
2446: return TRUE;
2447: }
2448: }
2449: if (! do_as_repeat (abfd, s))
2450: return FALSE;
2451: }
2452:
2453: return TRUE;
2454: }
2455:
2456: static void
2457: fill (void)
2458: {
2459: bfd_size_type amt = input_ptr_end - input_ptr_start;
2460: /* FIXME: Check return value. I'm not sure whether it needs to read
2461: the entire buffer or not. */
2462: bfd_bread ((void *) input_ptr_start, amt, input_bfd);
2463: input_ptr = input_ptr_start;
2464: }
2465:
2466: static void
2467: flush (void)
2468: {
2469: bfd_size_type amt = output_ptr - output_ptr_start;
2470:
2471: if (bfd_bwrite ((void *) (output_ptr_start), amt, output_bfd) != amt)
2472: abort ();
2473: output_ptr = output_ptr_start;
2474: output_buffer++;
2475: }
2476:
2477: #define THIS() ( *input_ptr )
2478: #define NEXT() { input_ptr++; if (input_ptr == input_ptr_end) fill (); }
2479: #define OUT(x) { *output_ptr++ = (x); if (output_ptr == output_ptr_end) flush (); }
2480:
2481: static void
2482: write_int (int value)
2483: {
2484: if (value >= 0 && value <= 127)
2485: {
2486: OUT (value);
2487: }
2488: else
2489: {
2490: unsigned int length;
2491:
2492: /* How many significant bytes ? */
2493: /* FIXME FOR LONGER INTS. */
2494: if (value & 0xff000000)
2495: length = 4;
2496: else if (value & 0x00ff0000)
2497: length = 3;
2498: else if (value & 0x0000ff00)
2499: length = 2;
2500: else
2501: length = 1;
2502:
2503: OUT ((int) ieee_number_repeat_start_enum + length);
2504: switch (length)
2505: {
2506: case 4:
2507: OUT (value >> 24);
2508: case 3:
2509: OUT (value >> 16);
2510: case 2:
2511: OUT (value >> 8);
2512: case 1:
2513: OUT (value);
2514: }
2515: }
2516: }
2517:
2518: static void
2519: copy_id (void)
2520: {
2521: int length = THIS ();
2522: char ch;
2523:
2524: OUT (length);
2525: NEXT ();
2526: while (length--)
2527: {
2528: ch = THIS ();
2529: OUT (ch);
2530: NEXT ();
2531: }
2532: }
2533:
2534: #define VAR(x) ((x | 0x80))
2535: static void
2536: copy_expression (void)
2537: {
2538: int stack[10];
2539: int *tos = stack;
2540: int value;
2541:
2542: while (1)
2543: {
2544: switch (THIS ())
2545: {
2546: case 0x84:
2547: NEXT ();
2548: value = THIS ();
2549: NEXT ();
2550: value = (value << 8) | THIS ();
2551: NEXT ();
2552: value = (value << 8) | THIS ();
2553: NEXT ();
2554: value = (value << 8) | THIS ();
2555: NEXT ();
2556: *tos++ = value;
2557: break;
2558: case 0x83:
2559: NEXT ();
2560: value = THIS ();
2561: NEXT ();
2562: value = (value << 8) | THIS ();
2563: NEXT ();
2564: value = (value << 8) | THIS ();
2565: NEXT ();
2566: *tos++ = value;
2567: break;
2568: case 0x82:
2569: NEXT ();
2570: value = THIS ();
2571: NEXT ();
2572: value = (value << 8) | THIS ();
2573: NEXT ();
2574: *tos++ = value;
2575: break;
2576: case 0x81:
2577: NEXT ();
2578: value = THIS ();
2579: NEXT ();
2580: *tos++ = value;
2581: break;
2582: case 0x80:
2583: NEXT ();
2584: *tos++ = 0;
2585: break;
2586: default:
2587: if (THIS () > 0x84)
2588: {
2589: /* Not a number, just bug out with the answer. */
2590: write_int (*(--tos));
2591: return;
2592: }
2593: *tos++ = THIS ();
2594: NEXT ();
2595: break;
2596: case 0xa5:
2597: /* PLUS anything. */
2598: value = *(--tos);
2599: value += *(--tos);
2600: *tos++ = value;
2601: NEXT ();
2602: break;
2603: case VAR ('R'):
2604: {
2605: int section_number;
2606: ieee_data_type *ieee;
2607: asection *s;
2608:
2609: NEXT ();
2610: section_number = THIS ();
2611:
2612: NEXT ();
2613: ieee = IEEE_DATA (input_bfd);
2614: s = ieee->section_table[section_number];
2615: value = 0;
2616: if (s->output_section)
2617: value = s->output_section->lma;
2618: value += s->output_offset;
2619: *tos++ = value;
2620: }
2621: break;
2622: case 0x90:
2623: {
2624: NEXT ();
2625: write_int (*(--tos));
2626: OUT (0x90);
2627: return;
2628: }
2629: }
2630: }
2631: }
2632:
2633: /* Drop the int in the buffer, and copy a null into the gap, which we
2634: will overwrite later. */
2635:
2636: static void
2637: fill_int (struct output_buffer_struct *buf)
2638: {
2639: if (buf->buffer == output_buffer)
2640: {
2641: /* Still a chance to output the size. */
2642: int value = output_ptr - buf->ptrp + 3;
2643: buf->ptrp[0] = value >> 24;
2644: buf->ptrp[1] = value >> 16;
2645: buf->ptrp[2] = value >> 8;
2646: buf->ptrp[3] = value >> 0;
2647: }
2648: }
2649:
2650: static void
2651: drop_int (struct output_buffer_struct *buf)
2652: {
2653: int type = THIS ();
2654: int ch;
2655:
2656: if (type <= 0x84)
2657: {
2658: NEXT ();
2659: switch (type)
2660: {
2661: case 0x84:
2662: ch = THIS ();
2663: NEXT ();
2664: case 0x83:
2665: ch = THIS ();
2666: NEXT ();
2667: case 0x82:
2668: ch = THIS ();
2669: NEXT ();
2670: case 0x81:
2671: ch = THIS ();
2672: NEXT ();
2673: case 0x80:
2674: break;
2675: }
2676: }
2677: (void) ch;
2678: OUT (0x84);
2679: buf->ptrp = output_ptr;
2680: buf->buffer = output_buffer;
2681: OUT (0);
2682: OUT (0);
2683: OUT (0);
2684: OUT (0);
2685: }
2686:
2687: static void
2688: copy_int (void)
2689: {
2690: int type = THIS ();
2691: int ch;
2692: if (type <= 0x84)
2693: {
2694: OUT (type);
2695: NEXT ();
2696: switch (type)
2697: {
2698: case 0x84:
2699: ch = THIS ();
2700: NEXT ();
2701: OUT (ch);
2702: case 0x83:
2703: ch = THIS ();
2704: NEXT ();
2705: OUT (ch);
2706: case 0x82:
2707: ch = THIS ();
2708: NEXT ();
2709: OUT (ch);
2710: case 0x81:
2711: ch = THIS ();
2712: NEXT ();
2713: OUT (ch);
2714: case 0x80:
2715: break;
2716: }
2717: }
2718: }
2719:
2720: #define ID copy_id ()
2721: #define INT copy_int ()
2722: #define EXP copy_expression ()
2723: #define INTn(q) copy_int ()
2724: #define EXPn(q) copy_expression ()
2725:
2726: static void
2727: copy_till_end (void)
2728: {
2729: int ch = THIS ();
2730:
2731: while (1)
2732: {
2733: while (ch <= 0x80)
2734: {
2735: OUT (ch);
2736: NEXT ();
2737: ch = THIS ();
2738: }
2739: switch (ch)
2740: {
2741: case 0x84:
2742: OUT (THIS ());
2743: NEXT ();
2744: case 0x83:
2745: OUT (THIS ());
2746: NEXT ();
2747: case 0x82:
2748: OUT (THIS ());
2749: NEXT ();
2750: case 0x81:
2751: OUT (THIS ());
2752: NEXT ();
2753: OUT (THIS ());
2754: NEXT ();
2755:
2756: ch = THIS ();
2757: break;
2758: default:
2759: return;
2760: }
2761: }
2762:
2763: }
2764:
2765: static void
2766: f1_record (void)
2767: {
2768: int ch;
2769:
2770: /* ATN record. */
2771: NEXT ();
2772: ch = THIS ();
2773: switch (ch)
2774: {
2775: default:
2776: OUT (0xf1);
2777: OUT (ch);
2778: break;
2779: case 0xc9:
2780: NEXT ();
2781: OUT (0xf1);
2782: OUT (0xc9);
2783: INT;
2784: INT;
2785: ch = THIS ();
2786: switch (ch)
2787: {
2788: case 0x16:
2789: NEXT ();
2790: break;
2791: case 0x01:
2792: NEXT ();
2793: break;
2794: case 0x00:
2795: NEXT ();
2796: INT;
2797: break;
2798: case 0x03:
2799: NEXT ();
2800: INT;
2801: break;
2802: case 0x13:
2803: EXPn (instruction address);
2804: break;
2805: default:
2806: break;
2807: }
2808: break;
2809: case 0xd8:
2810: /* EXternal ref. */
2811: NEXT ();
2812: OUT (0xf1);
2813: OUT (0xd8);
2814: EXP;
2815: EXP;
2816: EXP;
2817: EXP;
2818: break;
2819: case 0xce:
2820: NEXT ();
2821: OUT (0xf1);
2822: OUT (0xce);
2823: INT;
2824: INT;
2825: ch = THIS ();
2826: INT;
2827: switch (ch)
2828: {
2829: case 0x01:
2830: INT;
2831: INT;
2832: break;
2833: case 0x02:
2834: INT;
2835: break;
2836: case 0x04:
2837: EXPn (external function);
2838: break;
2839: case 0x05:
2840: break;
2841: case 0x07:
2842: INTn (line number);
2843: INT;
2844: case 0x08:
2845: break;
2846: case 0x0a:
2847: INTn (locked register);
2848: INT;
2849: break;
2850: case 0x3f:
2851: copy_till_end ();
2852: break;
2853: case 0x3e:
2854: copy_till_end ();
2855: break;
2856: case 0x40:
2857: copy_till_end ();
2858: break;
2859: case 0x41:
2860: ID;
2861: break;
2862: }
2863: }
2864: }
2865:
2866: static void
2867: f0_record (void)
2868: {
2869: /* Attribute record. */
2870: NEXT ();
2871: OUT (0xf0);
2872: INTn (Symbol name);
2873: ID;
2874: }
2875:
2876: static void
2877: f2_record (void)
2878: {
2879: NEXT ();
2880: OUT (0xf2);
2881: INT;
2882: NEXT ();
2883: OUT (0xce);
2884: INT;
2885: copy_till_end ();
2886: }
2887:
2888: static void
2889: f8_record (void)
2890: {
2891: int ch;
2892: NEXT ();
2893: ch = THIS ();
2894: switch (ch)
2895: {
2896: case 0x01:
2897: case 0x02:
2898: case 0x03:
2899: /* Unique typedefs for module. */
2900: /* GLobal typedefs. */
2901: /* High level module scope beginning. */
2902: {
2903: struct output_buffer_struct ob;
2904:
2905: NEXT ();
2906: OUT (0xf8);
2907: OUT (ch);
2908: drop_int (&ob);
2909: ID;
2910:
2911: block ();
2912:
2913: NEXT ();
2914: fill_int (&ob);
2915: OUT (0xf9);
2916: }
2917: break;
2918: case 0x04:
2919: /* Global function. */
2920: {
2921: struct output_buffer_struct ob;
2922:
2923: NEXT ();
2924: OUT (0xf8);
2925: OUT (0x04);
2926: drop_int (&ob);
2927: ID;
2928: INTn (stack size);
2929: INTn (ret val);
2930: EXPn (offset);
2931:
2932: block ();
2933:
2934: NEXT ();
2935: OUT (0xf9);
2936: EXPn (size of block);
2937: fill_int (&ob);
2938: }
2939: break;
2940:
2941: case 0x05:
2942: /* File name for source line numbers. */
2943: {
2944: struct output_buffer_struct ob;
2945:
2946: NEXT ();
2947: OUT (0xf8);
2948: OUT (0x05);
2949: drop_int (&ob);
2950: ID;
2951: INTn (year);
2952: INTn (month);
2953: INTn (day);
2954: INTn (hour);
2955: INTn (monute);
2956: INTn (second);
2957: block ();
2958: NEXT ();
2959: OUT (0xf9);
2960: fill_int (&ob);
2961: }
2962: break;
2963:
2964: case 0x06:
2965: /* Local function. */
2966: {
2967: struct output_buffer_struct ob;
2968:
2969: NEXT ();
2970: OUT (0xf8);
2971: OUT (0x06);
2972: drop_int (&ob);
2973: ID;
2974: INTn (stack size);
2975: INTn (type return);
2976: EXPn (offset);
2977: block ();
2978: NEXT ();
2979: OUT (0xf9);
2980: EXPn (size);
2981: fill_int (&ob);
2982: }
2983: break;
2984:
2985: case 0x0a:
2986: /* Assembler module scope beginning - */
2987: {
2988: struct output_buffer_struct ob;
2989:
2990: NEXT ();
2991: OUT (0xf8);
2992: OUT (0x0a);
2993: drop_int (&ob);
2994: ID;
2995: ID;
2996: INT;
2997: ID;
2998: INT;
2999: INT;
3000: INT;
3001: INT;
3002: INT;
3003: INT;
3004:
3005: block ();
3006:
3007: NEXT ();
3008: OUT (0xf9);
3009: fill_int (&ob);
3010: }
3011: break;
3012: case 0x0b:
3013: {
3014: struct output_buffer_struct ob;
3015:
3016: NEXT ();
3017: OUT (0xf8);
3018: OUT (0x0b);
3019: drop_int (&ob);
3020: ID;
3021: INT;
3022: INTn (section index);
3023: EXPn (offset);
3024: INTn (stuff);
3025:
3026: block ();
3027:
3028: OUT (0xf9);
3029: NEXT ();
3030: EXPn (Size in Maus);
3031: fill_int (&ob);
3032: }
3033: break;
3034: }
3035: }
3036:
3037: static void
3038: e2_record (void)
3039: {
3040: OUT (0xe2);
3041: NEXT ();
3042: OUT (0xce);
3043: NEXT ();
3044: INT;
3045: EXP;
3046: }
3047:
3048: static void
3049: block (void)
3050: {
3051: int ch;
3052:
3053: while (1)
3054: {
3055: ch = THIS ();
3056: switch (ch)
3057: {
3058: case 0xe1:
3059: case 0xe5:
3060: return;
3061: case 0xf9:
3062: return;
3063: case 0xf0:
3064: f0_record ();
3065: break;
3066: case 0xf1:
3067: f1_record ();
3068: break;
3069: case 0xf2:
3070: f2_record ();
3071: break;
3072: case 0xf8:
3073: f8_record ();
3074: break;
3075: case 0xe2:
3076: e2_record ();
3077: break;
3078:
3079: }
3080: }
3081: }
3082:
3083: /* Moves all the debug information from the source bfd to the output
3084: bfd, and relocates any expressions it finds. */
3085:
3086: static void
3087: relocate_debug (bfd *output ATTRIBUTE_UNUSED,
3088: bfd *input)
3089: {
3090: #define IBS 400
3091: #define OBS 400
3092: unsigned char input_buffer[IBS];
3093:
3094: input_ptr_start = input_ptr = input_buffer;
3095: input_ptr_end = input_buffer + IBS;
3096: input_bfd = input;
3097: /* FIXME: Check return value. I'm not sure whether it needs to read
3098: the entire buffer or not. */
3099: bfd_bread ((void *) input_ptr_start, (bfd_size_type) IBS, input);
3100: block ();
3101: }
3102:
3103: /* Gather together all the debug information from each input BFD into
3104: one place, relocating it and emitting it as we go. */
3105:
3106: static bfd_boolean
3107: ieee_write_debug_part (bfd *abfd)
3108: {
3109: ieee_data_type *ieee = IEEE_DATA (abfd);
3110: bfd_chain_type *chain = ieee->chain_root;
3111: unsigned char obuff[OBS];
3112: bfd_boolean some_debug = FALSE;
3113: file_ptr here = bfd_tell (abfd);
3114:
3115: output_ptr_start = output_ptr = obuff;
3116: output_ptr_end = obuff + OBS;
3117: output_ptr = obuff;
3118: output_bfd = abfd;
3119:
3120: if (chain == (bfd_chain_type *) NULL)
3121: {
3122: asection *s;
3123:
3124: for (s = abfd->sections; s != NULL; s = s->next)
3125: if ((s->flags & SEC_DEBUGGING) != 0)
3126: break;
3127: if (s == NULL)
3128: {
3129: ieee->w.r.debug_information_part = 0;
3130: return TRUE;
3131: }
3132:
3133: ieee->w.r.debug_information_part = here;
3134: if (bfd_bwrite (s->contents, s->size, abfd) != s->size)
3135: return FALSE;
3136: }
3137: else
3138: {
3139: while (chain != (bfd_chain_type *) NULL)
3140: {
3141: bfd *entry = chain->this;
3142: ieee_data_type *entry_ieee = IEEE_DATA (entry);
3143:
3144: if (entry_ieee->w.r.debug_information_part)
3145: {
3146: if (bfd_seek (entry, entry_ieee->w.r.debug_information_part,
3147: SEEK_SET) != 0)
3148: return FALSE;
3149: relocate_debug (abfd, entry);
3150: }
3151:
3152: chain = chain->next;
3153: }
3154:
3155: if (some_debug)
3156: ieee->w.r.debug_information_part = here;
3157: else
3158: ieee->w.r.debug_information_part = 0;
3159:
3160: flush ();
3161: }
3162:
3163: return TRUE;
3164: }
3165:
3166: /* Write the data in an ieee way. */
3167:
3168: static bfd_boolean
3169: ieee_write_data_part (bfd *abfd)
3170: {
3171: asection *s;
3172:
3173: ieee_data_type *ieee = IEEE_DATA (abfd);
3174: ieee->w.r.data_part = bfd_tell (abfd);
3175:
3176: for (s = abfd->sections; s != (asection *) NULL; s = s->next)
3177: {
3178: /* Skip sections that have no loadable contents (.bss,
3179: debugging, etc.) */
3180: if ((s->flags & SEC_LOAD) == 0)
3181: continue;
3182:
3183: /* Sort the reloc records so we can insert them in the correct
3184: places. */
3185: if (s->reloc_count != 0)
3186: {
3187: if (! do_with_relocs (abfd, s))
3188: return FALSE;
3189: }
3190: else
3191: {
3192: if (! do_without_relocs (abfd, s))
3193: return FALSE;
3194: }
3195: }
3196:
3197: return TRUE;
3198: }
3199:
3200: static bfd_boolean
3201: init_for_output (bfd *abfd)
3202: {
3203: asection *s;
3204:
3205: for (s = abfd->sections; s != (asection *) NULL; s = s->next)
3206: {
3207: if ((s->flags & SEC_DEBUGGING) != 0)
3208: continue;
3209: if (s->size != 0)
3210: {
3211: bfd_size_type size = s->size;
3212: ieee_per_section (s)->data = bfd_alloc (abfd, size);
3213: if (!ieee_per_section (s)->data)
3214: return FALSE;
3215: }
3216: }
3217: return TRUE;
3218: }
3219:
3220: /* Exec and core file sections. */
3221:
3222: /* Set section contents is complicated with IEEE since the format is
3223: not a byte image, but a record stream. */
3224:
3225: static bfd_boolean
3226: ieee_set_section_contents (bfd *abfd,
3227: sec_ptr section,
3228: const void * location,
3229: file_ptr offset,
3230: bfd_size_type count)
3231: {
3232: if ((section->flags & SEC_DEBUGGING) != 0)
3233: {
3234: if (section->contents == NULL)
3235: {
3236: bfd_size_type size = section->size;
3237: section->contents = bfd_alloc (abfd, size);
3238: if (section->contents == NULL)
3239: return FALSE;
3240: }
3241: /* bfd_set_section_contents has already checked that everything
3242: is within range. */
3243: memcpy (section->contents + offset, location, (size_t) count);
3244: return TRUE;
3245: }
3246:
3247: if (ieee_per_section (section)->data == (bfd_byte *) NULL)
3248: {
3249: if (!init_for_output (abfd))
3250: return FALSE;
3251: }
3252: memcpy ((void *) (ieee_per_section (section)->data + offset),
3253: (void *) location,
3254: (unsigned int) count);
3255: return TRUE;
3256: }
3257:
3258: /* Write the external symbols of a file. IEEE considers two sorts of
3259: external symbols, public, and referenced. It uses to internal
3260: forms to index them as well. When we write them out we turn their
3261: symbol values into indexes from the right base. */
3262:
3263: static bfd_boolean
3264: ieee_write_external_part (bfd *abfd)
3265: {
3266: asymbol **q;
3267: ieee_data_type *ieee = IEEE_DATA (abfd);
3268: unsigned int reference_index = IEEE_REFERENCE_BASE;
3269: unsigned int public_index = IEEE_PUBLIC_BASE + 2;
3270: file_ptr here = bfd_tell (abfd);
3271: bfd_boolean hadone = FALSE;
3272:
3273: if (abfd->outsymbols != (asymbol **) NULL)
3274: {
3275:
3276: for (q = abfd->outsymbols; *q != (asymbol *) NULL; q++)
3277: {
3278: asymbol *p = *q;
3279:
3280: if (bfd_is_und_section (p->section))
3281: {
3282: /* This must be a symbol reference. */
3283: if (! ieee_write_byte (abfd, ieee_external_reference_enum)
3284: || ! ieee_write_int (abfd, (bfd_vma) reference_index)
3285: || ! ieee_write_id (abfd, p->name))
3286: return FALSE;
3287: p->value = reference_index;
3288: reference_index++;
3289: hadone = TRUE;
3290: }
3291: else if (bfd_is_com_section (p->section))
3292: {
3293: /* This is a weak reference. */
3294: if (! ieee_write_byte (abfd, ieee_external_reference_enum)
3295: || ! ieee_write_int (abfd, (bfd_vma) reference_index)
3296: || ! ieee_write_id (abfd, p->name)
3297: || ! ieee_write_byte (abfd,
3298: ieee_weak_external_reference_enum)
3299: || ! ieee_write_int (abfd, (bfd_vma) reference_index)
3300: || ! ieee_write_int (abfd, p->value))
3301: return FALSE;
3302: p->value = reference_index;
3303: reference_index++;
3304: hadone = TRUE;
3305: }
3306: else if (p->flags & BSF_GLOBAL)
3307: {
3308: /* This must be a symbol definition. */
3309: if (! ieee_write_byte (abfd, ieee_external_symbol_enum)
3310: || ! ieee_write_int (abfd, (bfd_vma) public_index)
3311: || ! ieee_write_id (abfd, p->name)
3312: || ! ieee_write_2bytes (abfd, ieee_attribute_record_enum)
3313: || ! ieee_write_int (abfd, (bfd_vma) public_index)
3314: || ! ieee_write_byte (abfd, 15) /* Instruction address. */
3315: || ! ieee_write_byte (abfd, 19) /* Static symbol. */
3316: || ! ieee_write_byte (abfd, 1)) /* One of them. */
3317: return FALSE;
3318:
3319: /* Write out the value. */
3320: if (! ieee_write_2bytes (abfd, ieee_value_record_enum)
3321: || ! ieee_write_int (abfd, (bfd_vma) public_index))
3322: return FALSE;
3323: if (! bfd_is_abs_section (p->section))
3324: {
3325: if (abfd->flags & EXEC_P)
3326: {
3327: /* If fully linked, then output all symbols
3328: relocated. */
3329: if (! (ieee_write_int
3330: (abfd,
3331: (p->value
3332: + p->section->output_offset
3333: + p->section->output_section->vma))))
3334: return FALSE;
3335: }
3336: else
3337: {
3338: if (! (ieee_write_expression
3339: (abfd,
3340: p->value + p->section->output_offset,
3341: p->section->output_section->symbol,
3342: FALSE, 0)))
3343: return FALSE;
3344: }
3345: }
3346: else
3347: {
3348: if (! ieee_write_expression (abfd,
3349: p->value,
3350: bfd_abs_section_ptr->symbol,
3351: FALSE, 0))
3352: return FALSE;
3353: }
3354: p->value = public_index;
3355: public_index++;
3356: hadone = TRUE;
3357: }
3358: else
3359: {
3360: /* This can happen - when there are gaps in the symbols read
3361: from an input ieee file. */
3362: }
3363: }
3364: }
3365: if (hadone)
3366: ieee->w.r.external_part = here;
3367:
3368: return TRUE;
3369: }
3370:
3371:
3372: static const unsigned char exten[] =
3373: {
3374: 0xf0, 0x20, 0x00,
3375: 0xf1, 0xce, 0x20, 0x00, 37, 3, 3, /* Set version 3 rev 3. */
3376: 0xf1, 0xce, 0x20, 0x00, 39, 2, /* Keep symbol in original case. */
3377: 0xf1, 0xce, 0x20, 0x00, 38 /* Set object type relocatable to x. */
3378: };
3379:
3380: static const unsigned char envi[] =
3381: {
3382: 0xf0, 0x21, 0x00,
3383:
3384: /* 0xf1, 0xce, 0x21, 00, 50, 0x82, 0x07, 0xc7, 0x09, 0x11, 0x11,
3385: 0x19, 0x2c,
3386: */
3387: 0xf1, 0xce, 0x21, 00, 52, 0x00, /* exec ok. */
3388:
3389: 0xf1, 0xce, 0x21, 0, 53, 0x03,/* host unix. */
3390: /* 0xf1, 0xce, 0x21, 0, 54, 2,1,1 tool & version # */
3391: };
3392:
3393: static bfd_boolean
3394: ieee_write_me_part (bfd *abfd)
3395: {
3396: ieee_data_type *ieee = IEEE_DATA (abfd);
3397: ieee->w.r.trailer_part = bfd_tell (abfd);
3398: if (abfd->start_address)
3399: {
3400: if (! ieee_write_2bytes (abfd, ieee_value_starting_address_enum)
3401: || ! ieee_write_byte (abfd, ieee_function_either_open_b_enum)
3402: || ! ieee_write_int (abfd, abfd->start_address)
3403: || ! ieee_write_byte (abfd, ieee_function_either_close_b_enum))
3404: return FALSE;
3405: }
3406: ieee->w.r.me_record = bfd_tell (abfd);
3407: if (! ieee_write_byte (abfd, ieee_module_end_enum))
3408: return FALSE;
3409: return TRUE;
3410: }
3411:
3412: /* Write out the IEEE processor ID. */
3413:
3414: static bfd_boolean
3415: ieee_write_processor (bfd *abfd)
3416: {
3417: const bfd_arch_info_type *arch;
3418:
3419: arch = bfd_get_arch_info (abfd);
3420: switch (arch->arch)
3421: {
3422: default:
3423: if (! ieee_write_id (abfd, bfd_printable_name (abfd)))
3424: return FALSE;
3425: break;
3426:
3427: case bfd_arch_h8300:
3428: if (! ieee_write_id (abfd, "H8/300"))
3429: return FALSE;
3430: break;
3431:
3432: case bfd_arch_h8500:
3433: if (! ieee_write_id (abfd, "H8/500"))
3434: return FALSE;
3435: break;
3436:
3437: case bfd_arch_i960:
3438: switch (arch->mach)
3439: {
3440: default:
3441: case bfd_mach_i960_core:
3442: case bfd_mach_i960_ka_sa:
3443: if (! ieee_write_id (abfd, "80960KA"))
3444: return FALSE;
3445: break;
3446:
3447: case bfd_mach_i960_kb_sb:
3448: if (! ieee_write_id (abfd, "80960KB"))
3449: return FALSE;
3450: break;
3451:
3452: case bfd_mach_i960_ca:
3453: if (! ieee_write_id (abfd, "80960CA"))
3454: return FALSE;
3455: break;
3456:
3457: case bfd_mach_i960_mc:
3458: case bfd_mach_i960_xa:
3459: if (! ieee_write_id (abfd, "80960MC"))
3460: return FALSE;
3461: break;
3462: }
3463: break;
3464:
3465: case bfd_arch_m68k:
3466: {
3467: const char *id;
3468:
3469: switch (arch->mach)
3470: {
3471: default: id = "68020"; break;
3472: case bfd_mach_m68000: id = "68000"; break;
3473: case bfd_mach_m68008: id = "68008"; break;
3474: case bfd_mach_m68010: id = "68010"; break;
3475: case bfd_mach_m68020: id = "68020"; break;
3476: case bfd_mach_m68030: id = "68030"; break;
3477: case bfd_mach_m68040: id = "68040"; break;
3478: case bfd_mach_m68060: id = "68060"; break;
3479: case bfd_mach_cpu32: id = "cpu32"; break;
3480: case bfd_mach_mcf_isa_a_nodiv: id = "isa-a:nodiv"; break;
3481: case bfd_mach_mcf_isa_a: id = "isa-a"; break;
3482: case bfd_mach_mcf_isa_a_mac: id = "isa-a:mac"; break;
3483: case bfd_mach_mcf_isa_a_emac: id = "isa-a:emac"; break;
3484: case bfd_mach_mcf_isa_aplus: id = "isa-aplus"; break;
3485: case bfd_mach_mcf_isa_aplus_mac: id = "isa-aplus:mac"; break;
3486: case bfd_mach_mcf_isa_aplus_emac: id = "isa-aplus:mac"; break;
3487: case bfd_mach_mcf_isa_b_nousp: id = "isa-b:nousp"; break;
3488: case bfd_mach_mcf_isa_b_nousp_mac: id = "isa-b:nousp:mac"; break;
3489: case bfd_mach_mcf_isa_b_nousp_emac: id = "isa-b:nousp:emac"; break;
3490: case bfd_mach_mcf_isa_b: id = "isa-b"; break;
3491: case bfd_mach_mcf_isa_b_mac: id = "isa-b:mac"; break;
3492: case bfd_mach_mcf_isa_b_emac: id = "isa-b:emac"; break;
3493: case bfd_mach_mcf_isa_b_float: id = "isa-b:float"; break;
3494: case bfd_mach_mcf_isa_b_float_mac: id = "isa-b:float:mac"; break;
3495: case bfd_mach_mcf_isa_b_float_emac: id = "isa-b:float:emac"; break;
3496: case bfd_mach_mcf_isa_c: id = "isa-c"; break;
3497: case bfd_mach_mcf_isa_c_mac: id = "isa-c:mac"; break;
3498: case bfd_mach_mcf_isa_c_emac: id = "isa-c:emac"; break;
3499: case bfd_mach_mcf_isa_c_nodiv: id = "isa-c:nodiv"; break;
3500: case bfd_mach_mcf_isa_c_nodiv_mac: id = "isa-c:nodiv:mac"; break;
3501: case bfd_mach_mcf_isa_c_nodiv_emac: id = "isa-c:nodiv:emac"; break;
3502: }
3503:
3504: if (! ieee_write_id (abfd, id))
3505: return FALSE;
3506: }
3507: break;
3508: }
3509:
3510: return TRUE;
3511: }
3512:
3513: static bfd_boolean
3514: ieee_write_object_contents (bfd *abfd)
3515: {
3516: ieee_data_type *ieee = IEEE_DATA (abfd);
3517: unsigned int i;
3518: file_ptr old;
3519:
3520: /* Fast forward over the header area. */
3521: if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
3522: return FALSE;
3523:
3524: if (! ieee_write_byte (abfd, ieee_module_beginning_enum)
3525: || ! ieee_write_processor (abfd)
3526: || ! ieee_write_id (abfd, abfd->filename))
3527: return FALSE;
3528:
3529: /* Fast forward over the variable bits. */
3530: if (! ieee_write_byte (abfd, ieee_address_descriptor_enum))
3531: return FALSE;
3532:
3533: /* Bits per MAU. */
3534: if (! ieee_write_byte (abfd, (bfd_byte) (bfd_arch_bits_per_byte (abfd))))
3535: return FALSE;
3536: /* MAU's per address. */
3537: if (! ieee_write_byte (abfd,
3538: (bfd_byte) (bfd_arch_bits_per_address (abfd)
3539: / bfd_arch_bits_per_byte (abfd))))
3540: return FALSE;
3541:
3542: old = bfd_tell (abfd);
3543: if (bfd_seek (abfd, (file_ptr) (8 * N_W_VARIABLES), SEEK_CUR) != 0)
3544: return FALSE;
3545:
3546: ieee->w.r.extension_record = bfd_tell (abfd);
3547: if (bfd_bwrite ((char *) exten, (bfd_size_type) sizeof (exten), abfd)
3548: != sizeof (exten))
3549: return FALSE;
3550: if (abfd->flags & EXEC_P)
3551: {
3552: if (! ieee_write_byte (abfd, 0x1)) /* Absolute. */
3553: return FALSE;
3554: }
3555: else
3556: {
3557: if (! ieee_write_byte (abfd, 0x2)) /* Relocateable. */
3558: return FALSE;
3559: }
3560:
3561: ieee->w.r.environmental_record = bfd_tell (abfd);
3562: if (bfd_bwrite ((char *) envi, (bfd_size_type) sizeof (envi), abfd)
3563: != sizeof (envi))
3564: return FALSE;
3565:
3566: /* The HP emulator database requires a timestamp in the file. */
3567: {
3568: time_t now;
3569: const struct tm *t;
3570:
3571: time (&now);
3572: t = (struct tm *) localtime (&now);
3573: if (! ieee_write_2bytes (abfd, (int) ieee_atn_record_enum)
3574: || ! ieee_write_byte (abfd, 0x21)
3575: || ! ieee_write_byte (abfd, 0)
3576: || ! ieee_write_byte (abfd, 50)
3577: || ! ieee_write_int (abfd, (bfd_vma) (t->tm_year + 1900))
3578: || ! ieee_write_int (abfd, (bfd_vma) (t->tm_mon + 1))
3579: || ! ieee_write_int (abfd, (bfd_vma) t->tm_mday)
3580: || ! ieee_write_int (abfd, (bfd_vma) t->tm_hour)
3581: || ! ieee_write_int (abfd, (bfd_vma) t->tm_min)
3582: || ! ieee_write_int (abfd, (bfd_vma) t->tm_sec))
3583: return FALSE;
3584: }
3585:
3586: output_bfd = abfd;
3587:
3588: flush ();
3589:
3590: if (! ieee_write_section_part (abfd))
3591: return FALSE;
3592: /* First write the symbols. This changes their values into table
3593: indeces so we cant use it after this point. */
3594: if (! ieee_write_external_part (abfd))
3595: return FALSE;
3596:
3597: /* Write any debugs we have been told about. */
3598: if (! ieee_write_debug_part (abfd))
3599: return FALSE;
3600:
3601: /* Can only write the data once the symbols have been written, since
3602: the data contains relocation information which points to the
3603: symbols. */
3604: if (! ieee_write_data_part (abfd))
3605: return FALSE;
3606:
3607: /* At the end we put the end! */
3608: if (! ieee_write_me_part (abfd))
3609: return FALSE;
3610:
3611: /* Generate the header. */
3612: if (bfd_seek (abfd, old, SEEK_SET) != 0)
3613: return FALSE;
3614:
3615: for (i = 0; i < N_W_VARIABLES; i++)
3616: {
3617: if (! ieee_write_2bytes (abfd, ieee_assign_value_to_variable_enum)
3618: || ! ieee_write_byte (abfd, (bfd_byte) i)
3619: || ! ieee_write_int5_out (abfd, (bfd_vma) ieee->w.offset[i]))
3620: return FALSE;
3621: }
3622:
3623: return TRUE;
3624: }
3625:
3626: /* Native-level interface to symbols. */
3627:
3628: /* We read the symbols into a buffer, which is discarded when this
3629: function exits. We read the strings into a buffer large enough to
3630: hold them all plus all the cached symbol entries. */
3631:
3632: static asymbol *
3633: ieee_make_empty_symbol (bfd *abfd)
3634: {
3635: bfd_size_type amt = sizeof (ieee_symbol_type);
3636: ieee_symbol_type *new_symbol = (ieee_symbol_type *) bfd_zalloc (abfd, amt);
3637:
3638: if (!new_symbol)
3639: return NULL;
3640: new_symbol->symbol.the_bfd = abfd;
3641: return &new_symbol->symbol;
3642: }
3643:
3644: static bfd *
3645: ieee_openr_next_archived_file (bfd *arch, bfd *prev)
3646: {
3647: ieee_ar_data_type *ar = IEEE_AR_DATA (arch);
3648:
3649: /* Take the next one from the arch state, or reset. */
3650: if (prev == (bfd *) NULL)
3651: /* Reset the index - the first two entries are bogus. */
3652: ar->element_index = 2;
3653:
3654: while (TRUE)
3655: {
3656: ieee_ar_obstack_type *p = ar->elements + ar->element_index;
3657:
3658: ar->element_index++;
3659: if (ar->element_index <= ar->element_count)
3660: {
3661: if (p->file_offset != (file_ptr) 0)
3662: {
3663: if (p->abfd == (bfd *) NULL)
3664: {
3665: p->abfd = _bfd_create_empty_archive_element_shell (arch);
3666: p->abfd->origin = p->file_offset;
3667: }
3668: return p->abfd;
3669: }
3670: }
3671: else
3672: {
3673: bfd_set_error (bfd_error_no_more_archived_files);
3674: return NULL;
3675: }
3676: }
3677: }
3678:
3679: static bfd_boolean
3680: ieee_find_nearest_line (bfd *abfd ATTRIBUTE_UNUSED,
3681: asection *section ATTRIBUTE_UNUSED,
3682: asymbol **symbols ATTRIBUTE_UNUSED,
3683: bfd_vma offset ATTRIBUTE_UNUSED,
3684: const char **filename_ptr ATTRIBUTE_UNUSED,
3685: const char **functionname_ptr ATTRIBUTE_UNUSED,
3686: unsigned int *line_ptr ATTRIBUTE_UNUSED)
3687: {
3688: return FALSE;
3689: }
3690:
3691: static bfd_boolean
3692: ieee_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
3693: const char **filename_ptr ATTRIBUTE_UNUSED,
3694: const char **functionname_ptr ATTRIBUTE_UNUSED,
3695: unsigned int *line_ptr ATTRIBUTE_UNUSED)
3696: {
3697: return FALSE;
3698: }
3699:
3700: static int
3701: ieee_generic_stat_arch_elt (bfd *abfd, struct stat *buf)
3702: {
3703: ieee_ar_data_type *ar = (ieee_ar_data_type *) NULL;
3704: ieee_data_type *ieee;
3705:
3706: if (abfd->my_archive != NULL)
3707: ar = abfd->my_archive->tdata.ieee_ar_data;
3708: if (ar == (ieee_ar_data_type *) NULL)
3709: {
3710: bfd_set_error (bfd_error_invalid_operation);
3711: return -1;
3712: }
3713:
3714: if (IEEE_DATA (abfd) == NULL)
3715: {
3716: if (ieee_object_p (abfd) == NULL)
3717: {
3718: bfd_set_error (bfd_error_wrong_format);
3719: return -1;
3720: }
3721: }
3722:
3723: ieee = IEEE_DATA (abfd);
3724:
3725: buf->st_size = ieee->w.r.me_record + 1;
3726: buf->st_mode = 0644;
3727: return 0;
3728: }
3729:
3730: static int
3731: ieee_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
3732: struct bfd_link_info *info ATTRIBUTE_UNUSED)
3733: {
3734: return 0;
3735: }
3736:
3737: #define ieee_close_and_cleanup _bfd_generic_close_and_cleanup
3738: #define ieee_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
3739:
3740: #define ieee_slurp_armap bfd_true
3741: #define ieee_slurp_extended_name_table bfd_true
3742: #define ieee_construct_extended_name_table \
3743: ((bfd_boolean (*) \
3744: (bfd *, char **, bfd_size_type *, const char **)) \
3745: bfd_true)
3746: #define ieee_truncate_arname bfd_dont_truncate_arname
3747: #define ieee_write_armap \
3748: ((bfd_boolean (*) \
3749: (bfd *, unsigned int, struct orl *, unsigned int, int)) \
3750: bfd_true)
3751: #define ieee_read_ar_hdr bfd_nullvoidptr
3752: #define ieee_write_ar_hdr ((bfd_boolean (*) (bfd *, bfd *)) bfd_false)
3753: #define ieee_update_armap_timestamp bfd_true
3754: #define ieee_get_elt_at_index _bfd_generic_get_elt_at_index
3755:
3756: #define ieee_bfd_is_target_special_symbol \
3757: ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
3758: #define ieee_bfd_is_local_label_name bfd_generic_is_local_label_name
3759: #define ieee_get_lineno _bfd_nosymbols_get_lineno
3760: #define ieee_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
3761: #define ieee_read_minisymbols _bfd_generic_read_minisymbols
3762: #define ieee_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
3763:
3764: #define ieee_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
3765: #define ieee_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
3766:
3767: #define ieee_set_arch_mach _bfd_generic_set_arch_mach
3768:
3769: #define ieee_get_section_contents_in_window \
3770: _bfd_generic_get_section_contents_in_window
3771: #define ieee_bfd_get_relocated_section_contents \
3772: bfd_generic_get_relocated_section_contents
3773: #define ieee_bfd_relax_section bfd_generic_relax_section
3774: #define ieee_bfd_gc_sections bfd_generic_gc_sections
3775: #define ieee_bfd_lookup_section_flags bfd_generic_lookup_section_flags
3776: #define ieee_bfd_merge_sections bfd_generic_merge_sections
3777: #define ieee_bfd_is_group_section bfd_generic_is_group_section
3778: #define ieee_bfd_discard_group bfd_generic_discard_group
3779: #define ieee_section_already_linked \
3780: _bfd_generic_section_already_linked
3781: #define ieee_bfd_define_common_symbol bfd_generic_define_common_symbol
3782: #define ieee_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
3783: #define ieee_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
3784: #define ieee_bfd_link_add_symbols _bfd_generic_link_add_symbols
3785: #define ieee_bfd_link_just_syms _bfd_generic_link_just_syms
3786: #define ieee_bfd_copy_link_hash_symbol_type \
3787: _bfd_generic_copy_link_hash_symbol_type
3788: #define ieee_bfd_final_link _bfd_generic_final_link
3789: #define ieee_bfd_link_split_section _bfd_generic_link_split_section
3790:
3791: const bfd_target ieee_vec =
3792: {
3793: "ieee", /* Name. */
3794: bfd_target_ieee_flavour,
3795: BFD_ENDIAN_UNKNOWN, /* Target byte order. */
3796: BFD_ENDIAN_UNKNOWN, /* Target headers byte order. */
3797: (HAS_RELOC | EXEC_P | /* Object flags. */
3798: HAS_LINENO | HAS_DEBUG |
3799: HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
3800: (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
3801: | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */
3802: '_', /* Leading underscore. */
3803: ' ', /* AR_pad_char. */
3804: 16, /* AR_max_namelen. */
3805: 0, /* match priority. */
3806: bfd_getb64, bfd_getb_signed_64, bfd_putb64,
3807: bfd_getb32, bfd_getb_signed_32, bfd_putb32,
3808: bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */
3809: bfd_getb64, bfd_getb_signed_64, bfd_putb64,
3810: bfd_getb32, bfd_getb_signed_32, bfd_putb32,
3811: bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers. */
3812:
3813: {_bfd_dummy_target,
3814: ieee_object_p, /* bfd_check_format. */
3815: ieee_archive_p,
3816: _bfd_dummy_target,
3817: },
3818: {
3819: bfd_false,
3820: ieee_mkobject,
3821: _bfd_generic_mkarchive,
3822: bfd_false
3823: },
3824: {
3825: bfd_false,
3826: ieee_write_object_contents,
3827: _bfd_write_archive_contents,
3828: bfd_false,
3829: },
3830:
3831: /* ieee_close_and_cleanup, ieee_bfd_free_cached_info, ieee_new_section_hook,
3832: ieee_get_section_contents, ieee_get_section_contents_in_window. */
3833: BFD_JUMP_TABLE_GENERIC (ieee),
3834:
3835: BFD_JUMP_TABLE_COPY (_bfd_generic),
3836: BFD_JUMP_TABLE_CORE (_bfd_nocore),
3837:
3838: /* ieee_slurp_armap, ieee_slurp_extended_name_table,
3839: ieee_construct_extended_name_table, ieee_truncate_arname,
3840: ieee_write_armap, ieee_read_ar_hdr, ieee_openr_next_archived_file,
3841: ieee_get_elt_at_index, ieee_generic_stat_arch_elt,
3842: ieee_update_armap_timestamp. */
3843: BFD_JUMP_TABLE_ARCHIVE (ieee),
3844:
3845: /* ieee_get_symtab_upper_bound, ieee_canonicalize_symtab,
3846: ieee_make_empty_symbol, ieee_print_symbol, ieee_get_symbol_info,
3847: ieee_bfd_is_local_label_name, ieee_get_lineno,
3848: ieee_find_nearest_line, ieee_bfd_make_debug_symbol,
3849: ieee_read_minisymbols, ieee_minisymbol_to_symbol. */
3850: BFD_JUMP_TABLE_SYMBOLS (ieee),
3851:
3852: /* ieee_get_reloc_upper_bound, ieee_canonicalize_reloc,
3853: ieee_bfd_reloc_type_lookup. */
3854: BFD_JUMP_TABLE_RELOCS (ieee),
3855:
3856: /* ieee_set_arch_mach, ieee_set_section_contents. */
3857: BFD_JUMP_TABLE_WRITE (ieee),
3858:
3859: /* ieee_sizeof_headers, ieee_bfd_get_relocated_section_contents,
3860: ieee_bfd_relax_section, ieee_bfd_link_hash_table_create,
3861: _bfd_generic_link_hash_table_free,
3862: ieee_bfd_link_add_symbols, ieee_bfd_final_link,
3863: ieee_bfd_link_split_section, ieee_bfd_gc_sections,
3864: ieee_bfd_merge_sections. */
3865: BFD_JUMP_TABLE_LINK (ieee),
3866:
3867: BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
3868:
3869: NULL,
3870:
3871: NULL
3872: };