Commit | Line | Data |
---|---|---|
87f86b4e DHW |
1 | /* |
2 | ||
3 | bfd backend for ieee objects. | |
4 | ||
87f86b4e | 5 | |
87f86b4e | 6 | |
301dfc71 SC |
7 | IEEE 695 format is a stream of records, which we parse using a simple one |
8 | token (which is one byte in this lexicon) lookahead recursive decent | |
9 | parser. | |
87f86b4e DHW |
10 | |
11 | ||
12 | */ | |
13 | ||
14 | ||
15 | #include "sysdep.h" | |
16 | #include "bfd.h" | |
17 | #include "libbfd.h" | |
18 | #include "obstack.h" | |
19 | #include "ieee.h" | |
20 | #include "libieee.h" | |
21 | ||
22 | ||
23 | #define obstack_chunk_alloc malloc | |
24 | #define obstack_chunk_free free | |
301dfc71 SC |
25 | #define ieee_malloc(abfd,size) \ |
26 | obstack_alloc(&( ieee_data(abfd)->ieee_obstack), (size)) | |
87f86b4e DHW |
27 | |
28 | typedef void generic_symbol_type; | |
301dfc71 | 29 | |
87f86b4e DHW |
30 | |
31 | /*************************************************************************** | |
32 | Functions for writing to ieee files in the strange way that the | |
33 | standard requires: | |
34 | */ | |
35 | ||
36 | ||
37 | static void | |
301dfc71 SC |
38 | DEFUN(ieee_write_byte,(abfd, byte), |
39 | bfd *abfd AND | |
40 | bfd_byte byte) | |
87f86b4e DHW |
41 | { |
42 | bfd_write(&byte, 1, 1, abfd); | |
43 | } | |
44 | ||
45 | ||
46 | static void | |
301dfc71 SC |
47 | DEFUN(ieee_write_2bytes,(abfd, bytes), |
48 | bfd *abfd AND | |
49 | int bytes) | |
87f86b4e DHW |
50 | { |
51 | bfd_byte buffer[2]; | |
52 | buffer[0] = bytes >> 8; | |
53 | buffer[1] = bytes & 0xff; | |
54 | ||
55 | bfd_write(buffer, 1, 2, abfd); | |
56 | } | |
57 | ||
58 | static void | |
301dfc71 SC |
59 | DEFUN(ieee_write_int,(abfd, value), |
60 | bfd *abfd AND | |
61 | bfd_vma value) | |
87f86b4e DHW |
62 | { |
63 | if (value >= 0 && value <= 127) { | |
64 | ieee_write_byte(abfd, value); | |
65 | } | |
66 | else { | |
67 | unsigned int length; | |
68 | /* How many significant bytes ? */ | |
69 | /* FIXME FOR LONGER INTS */ | |
70 | if (value & 0xff000000) { | |
71 | length = 4; | |
72 | } | |
73 | else if (value & 0x00ff0000) { | |
74 | length = 3; | |
75 | } | |
76 | else if (value & 0x0000ff00) { | |
77 | length = 2; | |
78 | } | |
79 | else length = 1; | |
80 | ||
81 | ieee_write_byte(abfd, ieee_number_repeat_start_enum + length); | |
82 | switch (length) { | |
83 | case 4: | |
84 | ieee_write_byte(abfd, value >> 24); | |
85 | case 3: | |
86 | ieee_write_byte(abfd, value >> 16); | |
87 | case 2: | |
88 | ieee_write_byte(abfd, value >> 8); | |
89 | case 1: | |
90 | ieee_write_byte(abfd, value); | |
91 | } | |
92 | } | |
93 | } | |
94 | ||
95 | static void | |
301dfc71 SC |
96 | DEFUN(ieee_write_id,(abfd, id), |
97 | bfd *abfd AND | |
98 | CONST char *id) | |
87f86b4e DHW |
99 | { |
100 | size_t length = strlen(id); | |
101 | if (length >= 0 && length <= 127) { | |
102 | ieee_write_byte(abfd, length); | |
103 | } | |
104 | else if (length < 255) { | |
105 | ieee_write_byte(abfd, ieee_extension_length_1_enum); | |
106 | ieee_write_byte(abfd, length); | |
107 | } | |
108 | else if (length < 65535) { | |
109 | ieee_write_byte(abfd, ieee_extension_length_2_enum); | |
110 | ieee_write_byte(abfd, length >> 8); | |
111 | ieee_write_byte(abfd, length & 0xff); | |
112 | } | |
113 | else { | |
114 | BFD_FAIL(); | |
115 | } | |
116 | bfd_write((bfd_byte *)id, 1, length, abfd); | |
117 | } | |
118 | /*************************************************************************** | |
119 | Functions for reading from ieee files in the strange way that the | |
120 | standard requires: | |
121 | */ | |
87f86b4e | 122 | |
301dfc71 SC |
123 | #define this_byte(abfd) *(ptr(abfd)) |
124 | #define next_byte(abfd) (ptr(abfd)++) | |
125 | #define this_byte_and_next(abfd) *(ptr(abfd)++) | |
87f86b4e DHW |
126 | |
127 | ||
301dfc71 SC |
128 | static unsigned short |
129 | DEFUN(read_2bytes,(abfd), | |
130 | bfd *abfd) | |
87f86b4e DHW |
131 | { |
132 | unsigned char c1 = this_byte_and_next(abfd); | |
133 | unsigned char c2 = this_byte_and_next(abfd); | |
134 | return (c1<<8 ) | c2; | |
135 | ||
136 | } | |
137 | ||
138 | static void | |
301dfc71 SC |
139 | DEFUN(bfd_get_string,(abfd, string, length), |
140 | bfd *abfd AND | |
141 | char *string AND | |
142 | size_t length) | |
87f86b4e DHW |
143 | { |
144 | size_t i; | |
145 | for (i= 0; i < length; i++) { | |
146 | string[i] = this_byte_and_next(abfd); | |
147 | } | |
148 | } | |
149 | ||
301dfc71 SC |
150 | static char * |
151 | DEFUN(read_id,(abfd), | |
152 | bfd *abfd) | |
87f86b4e DHW |
153 | { |
154 | size_t length; | |
155 | char *string; | |
156 | length = this_byte_and_next(abfd); | |
157 | if (length >= 0x00 && length <= 0x7f) { | |
158 | /* Simple string of length 0 to 127 */ | |
159 | } | |
160 | else if (length == 0xde) { | |
161 | /* Length is next byte, allowing 0..255 */ | |
162 | length = this_byte_and_next(abfd); | |
163 | } | |
164 | else if (length == 0xdf) { | |
165 | /* Length is next two bytes, allowing 0..65535 */ | |
166 | length = this_byte_and_next(abfd) ; | |
167 | length = (length * 256) + this_byte_and_next(abfd); | |
168 | } | |
169 | /* Buy memory and read string */ | |
301dfc71 | 170 | string = ieee_malloc(abfd, length+1); |
87f86b4e DHW |
171 | bfd_get_string(abfd, string, length); |
172 | string[length] = 0; | |
173 | return string; | |
174 | } | |
175 | ||
176 | static void | |
301dfc71 SC |
177 | DEFUN(ieee_write_expression,(abfd, value, section, symbol), |
178 | bfd*abfd AND | |
179 | bfd_vma value AND | |
180 | asection *section AND | |
181 | asymbol *symbol) | |
87f86b4e DHW |
182 | { |
183 | unsigned int plus_count = 0; | |
184 | ieee_write_int(abfd, value); | |
185 | if (section != (asection *)NULL) { | |
186 | plus_count++; | |
187 | ieee_write_byte(abfd, ieee_variable_L_enum); | |
188 | ieee_write_byte(abfd, section->index +IEEE_SECTION_NUMBER_BASE); | |
189 | } | |
190 | ||
191 | if (symbol != (asymbol *)NULL) { | |
192 | plus_count++; | |
193 | if ((symbol->flags & BSF_UNDEFINED ) || | |
194 | (symbol->flags & BSF_FORT_COMM)) { | |
195 | ieee_write_byte(abfd, ieee_variable_X_enum); | |
196 | ieee_write_int(abfd, symbol->value); | |
197 | } | |
198 | else if (symbol->flags & BSF_GLOBAL) { | |
199 | ieee_write_byte(abfd, ieee_variable_I_enum); | |
200 | ieee_write_int(abfd, symbol->value); | |
201 | } | |
301dfc71 SC |
202 | else if (symbol->flags & BSF_LOCAL) { |
203 | /* This is a reference to a defined local symbol, | |
204 | We can easily do a local as a section+offset */ | |
205 | if (symbol->section != (asection *)NULL) { | |
206 | /* If this symbol is not absolute, add the base of it */ | |
207 | ieee_write_byte(abfd, ieee_variable_L_enum); | |
208 | ieee_write_byte(abfd, symbol->section->index + | |
209 | IEEE_SECTION_NUMBER_BASE); | |
210 | plus_count++; | |
211 | } | |
212 | ||
213 | ieee_write_int(abfd, symbol->value); | |
214 | } | |
87f86b4e | 215 | else { |
301dfc71 | 216 | |
87f86b4e DHW |
217 | BFD_FAIL(); |
218 | } | |
219 | } | |
220 | ||
221 | while (plus_count != 0) { | |
222 | ieee_write_byte(abfd, ieee_function_plus_enum); | |
223 | plus_count--; | |
224 | } | |
225 | ||
226 | } | |
227 | ||
228 | ||
229 | ||
230 | ||
231 | ||
232 | ||
233 | ||
234 | ||
235 | ||
236 | /*****************************************************************************/ | |
237 | ||
238 | /* | |
239 | writes any integer into the buffer supplied and always takes 5 bytes | |
240 | */ | |
241 | static void | |
301dfc71 SC |
242 | DEFUN(ieee_write_int5,(buffer, value), |
243 | bfd_byte*buffer AND | |
244 | bfd_vma value ) | |
87f86b4e DHW |
245 | { |
246 | buffer[0] = ieee_number_repeat_4_enum; | |
247 | buffer[1] = (value >> 24 ) & 0xff; | |
248 | buffer[2] = (value >> 16 ) & 0xff; | |
249 | buffer[3] = (value >> 8 ) & 0xff; | |
301dfc71 SC |
250 | buffer[4] = (value >> 0 ) & 0xff; |
251 | } | |
252 | static void | |
253 | DEFUN(ieee_write_int5_out, (abfd, value), | |
254 | bfd *abfd AND | |
255 | bfd_vma value) | |
256 | { | |
257 | char b[5]; | |
258 | ieee_write_int5(b, value); | |
259 | bfd_write(b,1,5,abfd); | |
87f86b4e | 260 | } |
87f86b4e DHW |
261 | |
262 | ||
263 | static boolean | |
301dfc71 SC |
264 | DEFUN(parse_int,(abfd, value_ptr), |
265 | bfd *abfd AND | |
266 | bfd_vma *value_ptr) | |
87f86b4e DHW |
267 | { |
268 | int value = this_byte(abfd); | |
269 | int result; | |
270 | if (value >= 0 && value <= 127) { | |
271 | *value_ptr = value; | |
272 | next_byte(abfd); | |
273 | return true; | |
274 | } | |
275 | else if (value >= 0x80 && value <= 0x88) { | |
276 | unsigned int count = value & 0xf; | |
277 | result = 0; | |
278 | next_byte(abfd); | |
279 | while (count) { | |
280 | result =(result << 8) | this_byte_and_next(abfd); | |
281 | count--; | |
282 | } | |
283 | *value_ptr = result; | |
284 | return true; | |
285 | } | |
286 | return false; | |
287 | } | |
301dfc71 SC |
288 | static int |
289 | DEFUN(parse_i,(abfd, ok), | |
290 | bfd *abfd AND | |
291 | boolean *ok) | |
87f86b4e DHW |
292 | { |
293 | bfd_vma x; | |
294 | *ok = parse_int(abfd, &x); | |
295 | return x; | |
296 | } | |
297 | ||
301dfc71 SC |
298 | static bfd_vma |
299 | DEFUN(must_parse_int,(abfd), | |
300 | bfd *abfd) | |
87f86b4e DHW |
301 | { |
302 | bfd_vma result; | |
303 | BFD_ASSERT(parse_int(abfd, &result) == true); | |
304 | return result; | |
305 | } | |
306 | ||
307 | typedef struct | |
308 | { | |
309 | bfd_vma value; | |
310 | asection *section; | |
311 | ieee_symbol_index_type symbol; | |
312 | } ieee_value_type; | |
313 | ||
314 | ||
315 | static | |
316 | reloc_howto_type abs32_howto | |
4cddd1c9 | 317 | = HOWTO(1,0,2,32,0,0,0,true,0,"abs32",false,0xffffffff, 0xffffffff,false); |
87f86b4e DHW |
318 | static |
319 | reloc_howto_type abs16_howto | |
4cddd1c9 | 320 | = HOWTO(1,0,1,16,0,0,0,true,0,"abs16",false,0x0000ffff, 0x0000ffff,false); |
87f86b4e DHW |
321 | |
322 | static ieee_symbol_index_type NOSYMBOL = { 0, 0}; | |
323 | ||
324 | ||
301dfc71 SC |
325 | static void |
326 | DEFUN(parse_expression,(abfd, value, section, symbol, pcrel, extra), | |
327 | bfd *abfd AND | |
328 | bfd_vma *value AND | |
329 | asection **section AND | |
330 | ieee_symbol_index_type *symbol AND | |
331 | boolean *pcrel AND | |
332 | unsigned int *extra) | |
87f86b4e DHW |
333 | { |
334 | #define POS sp[1] | |
335 | #define TOS sp[0] | |
336 | #define NOS sp[-1] | |
337 | #define INC sp++; | |
338 | #define DEC sp--; | |
339 | ||
340 | boolean loop = true; | |
341 | ieee_value_type stack[10]; | |
342 | ||
343 | /* The stack pointer always points to the next unused location */ | |
344 | #define PUSH(x,y,z) TOS.symbol=x;TOS.section=y;TOS.value=z;INC; | |
345 | #define POP(x,y,z) DEC;x=TOS.symbol;y=TOS.section;z=TOS.value; | |
346 | ieee_value_type *sp = stack; | |
347 | ||
348 | while (loop) { | |
349 | switch (this_byte(abfd)) | |
350 | { | |
351 | case ieee_variable_P_enum: | |
352 | /* P variable, current program counter for section n */ | |
353 | { | |
354 | int section_n ; | |
355 | next_byte(abfd); | |
356 | section_n = must_parse_int(abfd); | |
357 | PUSH(NOSYMBOL, 0, | |
358 | TOS.value = ieee_data(abfd)->section_table[section_n]->vma + | |
359 | ieee_per_section(ieee_data(abfd)->section_table[section_n])->pc); | |
360 | break; | |
361 | } | |
362 | case ieee_variable_L_enum: | |
363 | /* L variable address of section N */ | |
364 | next_byte(abfd); | |
365 | PUSH(NOSYMBOL,ieee_data(abfd)->section_table[must_parse_int(abfd)],0); | |
366 | break; | |
367 | case ieee_variable_R_enum: | |
368 | /* R variable, logical address of section module */ | |
369 | /* FIXME, this should be different to L */ | |
370 | next_byte(abfd); | |
371 | PUSH(NOSYMBOL,ieee_data(abfd)->section_table[must_parse_int(abfd)],0); | |
372 | break; | |
373 | case ieee_variable_S_enum: | |
374 | /* S variable, size in MAUS of section module */ | |
375 | next_byte(abfd); | |
376 | PUSH(NOSYMBOL, | |
377 | 0, | |
378 | ieee_data(abfd)->section_table[must_parse_int(abfd)]->size); | |
379 | break; | |
380 | ||
381 | case ieee_variable_X_enum: | |
382 | /* Push the address of external variable n */ | |
383 | { | |
384 | ieee_symbol_index_type sy; | |
385 | next_byte(abfd); | |
386 | sy.index = (int)(must_parse_int(abfd)) ; | |
387 | sy.letter = 'X'; | |
388 | ||
389 | PUSH(sy, 0, 0); | |
390 | } | |
391 | break; | |
392 | case ieee_function_minus_enum: | |
393 | { | |
394 | bfd_vma value1, value2; | |
395 | asection *section; | |
396 | ieee_symbol_index_type sy; | |
397 | next_byte(abfd); | |
398 | ||
399 | POP(sy, section, value1); | |
400 | POP(sy, section, value2); | |
401 | PUSH(NOSYMBOL, 0, value1-value2); | |
402 | } | |
403 | break; | |
404 | case ieee_function_plus_enum: | |
405 | { | |
406 | bfd_vma value1, value2; | |
407 | asection *section1; | |
408 | asection *section2; | |
301dfc71 SC |
409 | ieee_symbol_index_type sy1; |
410 | ieee_symbol_index_type sy2; | |
87f86b4e DHW |
411 | next_byte(abfd); |
412 | ||
301dfc71 SC |
413 | POP(sy1, section1, value1); |
414 | POP(sy2, section2, value2); | |
415 | PUSH(sy1.letter ? sy1 : sy2, section1 ? section1: section2, value1+value2); | |
87f86b4e DHW |
416 | } |
417 | break; | |
418 | default: | |
419 | { | |
420 | bfd_vma va; | |
421 | BFD_ASSERT(this_byte(abfd) < ieee_variable_A_enum | |
422 | || this_byte(abfd) > ieee_variable_Z_enum); | |
423 | if (parse_int(abfd, &va)) | |
424 | { | |
425 | PUSH(NOSYMBOL,0, va); | |
426 | } | |
427 | else { | |
428 | /* | |
429 | Thats all that we can understand. As far as I can see | |
430 | there is a bug in the Microtec IEEE output which I'm | |
431 | using to scan, whereby the comma operator is ommited | |
432 | sometimes in an expression, giving expressions with too | |
433 | many terms. We can tell if that's the case by ensuring | |
434 | that sp == stack here. If not, then we've pushed | |
435 | something too far. - | |
436 | */ | |
437 | ||
438 | POP(*symbol, *section, *value); | |
439 | if (sp != stack) { | |
440 | BFD_ASSERT(*section == 0); | |
441 | *extra = *value; | |
442 | /* Get what should be returned */ | |
443 | POP(*symbol, *section, *value); | |
444 | } | |
445 | else { | |
446 | *extra = 0; | |
447 | } | |
448 | loop = false; | |
449 | } | |
450 | } | |
451 | ||
452 | } | |
453 | } | |
454 | } | |
455 | ||
301dfc71 SC |
456 | |
457 | ||
458 | #define ieee_seek(abfd, offset) \ | |
459 | ieee_data(abfd)->input_p = ieee_data(abfd)->first_byte + offset | |
87f86b4e DHW |
460 | |
461 | static void | |
301dfc71 SC |
462 | DEFUN(ieee_slurp_external_symbols,(abfd), |
463 | bfd *abfd) | |
87f86b4e DHW |
464 | { |
465 | ieee_data_type *ieee = ieee_data(abfd); | |
466 | file_ptr offset = ieee->w.r.external_part; | |
467 | ||
468 | ieee_symbol_type **prev_symbols_ptr = &ieee->external_symbols; | |
469 | ieee_symbol_type **prev_reference_ptr = &ieee->external_reference; | |
470 | ieee_symbol_type *symbol; | |
471 | unsigned int symbol_count = 0; | |
472 | boolean loop = true; | |
473 | ||
474 | ieee->symbol_table_full = true; | |
475 | ||
301dfc71 | 476 | ieee_seek(abfd, offset ); |
87f86b4e DHW |
477 | |
478 | while (loop) { | |
479 | switch (this_byte(abfd)) { | |
480 | case ieee_external_symbol_enum: | |
481 | next_byte(abfd); | |
301dfc71 | 482 | symbol = (ieee_symbol_type *)ieee_malloc(abfd, sizeof(ieee_symbol_type)); |
87f86b4e DHW |
483 | |
484 | *prev_symbols_ptr = symbol; | |
485 | prev_symbols_ptr= &symbol->next; | |
486 | symbol->index = must_parse_int(abfd); | |
487 | if (symbol->index > ieee->external_symbol_max_index) { | |
488 | ieee->external_symbol_max_index = symbol->index; | |
489 | } | |
490 | BFD_ASSERT (symbol->index >= ieee->external_symbol_min_index); | |
491 | symbol_count++; | |
492 | symbol->symbol.the_bfd = abfd; | |
493 | symbol->symbol.name = read_id(abfd); | |
494 | symbol->symbol.udata = (void *)NULL; | |
495 | symbol->symbol.flags = BSF_NO_FLAGS; | |
496 | break; | |
497 | case ieee_attribute_record_enum >> 8: | |
498 | { | |
499 | unsigned int symbol_name_index; | |
500 | unsigned int symbol_type_index; | |
501 | unsigned int symbol_attribute_def; | |
502 | bfd_vma value; | |
503 | next_byte(abfd); /* Skip prefix */ | |
504 | next_byte(abfd); | |
505 | symbol_name_index = must_parse_int(abfd); | |
506 | symbol_type_index = must_parse_int(abfd); | |
507 | symbol_attribute_def = must_parse_int(abfd); | |
508 | ||
509 | parse_int(abfd,&value); | |
510 | ||
511 | } | |
512 | break; | |
513 | case ieee_value_record_enum >> 8: | |
514 | { | |
515 | unsigned int symbol_name_index; | |
516 | ieee_symbol_index_type symbol_ignore; | |
301dfc71 | 517 | boolean pcrel_ignore; |
87f86b4e DHW |
518 | unsigned int extra_ignore; |
519 | next_byte(abfd); | |
520 | next_byte(abfd); | |
521 | ||
522 | symbol_name_index = must_parse_int(abfd); | |
301dfc71 | 523 | parse_expression(abfd, |
87f86b4e DHW |
524 | &symbol->symbol.value, |
525 | &symbol->symbol.section, | |
526 | &symbol_ignore, | |
527 | &pcrel_ignore, | |
528 | &extra_ignore); | |
529 | if (symbol->symbol.section != (asection *)NULL) { | |
530 | symbol->symbol.flags = BSF_GLOBAL | BSF_EXPORT; | |
531 | } | |
532 | else { | |
533 | symbol->symbol.flags = BSF_GLOBAL | BSF_EXPORT | BSF_ABSOLUTE; | |
534 | } | |
535 | } | |
536 | break; | |
537 | case ieee_weak_external_reference_enum: | |
538 | { bfd_vma size; | |
539 | bfd_vma value ; | |
540 | next_byte(abfd); | |
541 | /* Throw away the external reference index */ | |
542 | (void)must_parse_int(abfd); | |
543 | /* Fetch the default size if not resolved */ | |
544 | size = must_parse_int(abfd); | |
545 | /* Fetch the defautlt value if available */ | |
546 | if ( parse_int(abfd, &value) == false) { | |
547 | value = 0; | |
548 | } | |
549 | /* This turns into a common */ | |
550 | symbol->symbol.flags = BSF_FORT_COMM; | |
551 | symbol->symbol.value = size; | |
552 | } | |
553 | break; | |
554 | ||
555 | case ieee_external_reference_enum: | |
556 | next_byte(abfd); | |
301dfc71 | 557 | symbol = (ieee_symbol_type *)ieee_malloc(abfd, sizeof(ieee_symbol_type)); |
87f86b4e DHW |
558 | symbol_count++; |
559 | *prev_reference_ptr = symbol; | |
560 | prev_reference_ptr = &symbol->next; | |
561 | symbol->index = must_parse_int(abfd); | |
562 | symbol->symbol.the_bfd = abfd; | |
563 | symbol->symbol.name = read_id(abfd); | |
564 | symbol->symbol.udata = (void *)NULL; | |
565 | symbol->symbol.section = (asection *)NULL; | |
566 | symbol->symbol.value = (bfd_vma)0; | |
567 | symbol->symbol.flags = BSF_UNDEFINED; | |
568 | if (symbol->index > ieee->external_reference_max_index) { | |
569 | ieee->external_reference_max_index = symbol->index; | |
570 | } | |
571 | BFD_ASSERT (symbol->index >= ieee->external_reference_min_index); | |
572 | break; | |
573 | ||
574 | default: | |
575 | loop = false; | |
576 | } | |
577 | } | |
578 | ||
579 | if (ieee->external_symbol_max_index != 0) { | |
580 | ieee->external_symbol_count = | |
581 | ieee->external_symbol_max_index - | |
582 | ieee->external_symbol_min_index + 1 ; | |
583 | } | |
584 | else { | |
585 | ieee->external_symbol_count = 0; | |
586 | } | |
587 | ||
588 | ||
589 | if(ieee->external_reference_max_index != 0) { | |
590 | ieee->external_reference_count = | |
591 | ieee->external_reference_max_index - | |
592 | ieee->external_reference_min_index + 1; | |
593 | } | |
594 | else { | |
595 | ieee->external_reference_count = 0; | |
596 | } | |
597 | ||
598 | abfd->symcount = | |
599 | ieee->external_reference_count + ieee->external_symbol_count; | |
600 | ||
601 | if (symbol_count != abfd->symcount) { | |
602 | /* There are gaps in the table -- */ | |
603 | ieee->symbol_table_full = false; | |
604 | } | |
605 | *prev_symbols_ptr = (ieee_symbol_type *)NULL; | |
606 | *prev_reference_ptr = (ieee_symbol_type *)NULL; | |
607 | } | |
608 | ||
609 | static void | |
301dfc71 SC |
610 | DEFUN(ieee_slurp_symbol_table,(abfd), |
611 | bfd *abfd) | |
87f86b4e DHW |
612 | { |
613 | if (ieee_data(abfd)->read_symbols == false) { | |
614 | ieee_slurp_external_symbols(abfd); | |
615 | ieee_data(abfd)->read_symbols= true; | |
616 | } | |
617 | } | |
618 | ||
619 | size_t | |
301dfc71 SC |
620 | DEFUN(ieee_get_symtab_upper_bound,(abfd), |
621 | bfd *abfd) | |
87f86b4e DHW |
622 | { |
623 | ieee_slurp_symbol_table (abfd); | |
624 | ||
625 | return (abfd->symcount != 0) ? | |
626 | (abfd->symcount+1) * (sizeof (ieee_symbol_type *)) : 0; | |
627 | } | |
628 | ||
629 | /* | |
630 | Move from our internal lists to the canon table, and insert in | |
631 | symbol index order | |
632 | */ | |
633 | ||
634 | extern bfd_target ieee_vec; | |
301dfc71 | 635 | |
87f86b4e | 636 | unsigned int |
301dfc71 SC |
637 | DEFUN(ieee_get_symtab,(abfd, location), |
638 | bfd *abfd AND | |
639 | asymbol **location) | |
87f86b4e DHW |
640 | { |
641 | ieee_symbol_type *symp; | |
642 | static bfd dummy_bfd; | |
643 | static asymbol empty_symbol = | |
644 | { &dummy_bfd," ieee empty",(symvalue)0,BSF_DEBUGGING | BSF_FAKE}; | |
645 | ||
646 | ieee_data_type *ieee = ieee_data(abfd); | |
647 | dummy_bfd.xvec= &ieee_vec; | |
648 | ieee_slurp_symbol_table(abfd); | |
649 | ||
650 | if (ieee->symbol_table_full == false) { | |
651 | /* Arrgh - there are gaps in the table, run through and fill them */ | |
652 | /* up with pointers to a null place */ | |
653 | unsigned int i; | |
654 | for (i= 0; i < abfd->symcount; i++) { | |
655 | location[i] = &empty_symbol; | |
656 | } | |
657 | } | |
658 | ||
659 | ||
660 | ieee->external_symbol_base_offset= - ieee->external_symbol_min_index; | |
661 | for (symp = ieee_data(abfd)->external_symbols; | |
662 | symp != (ieee_symbol_type *)NULL; | |
663 | symp = symp->next) { | |
664 | /* Place into table at correct index locations */ | |
665 | location[symp->index + ieee->external_symbol_base_offset] = &symp->symbol; | |
666 | ||
667 | } | |
668 | ||
669 | /* The external refs are indexed in a bit */ | |
670 | ieee->external_reference_base_offset = | |
671 | - ieee->external_reference_min_index +ieee->external_symbol_count ; | |
672 | ||
673 | for (symp = ieee_data(abfd)->external_reference; | |
674 | symp != (ieee_symbol_type *)NULL; | |
675 | symp = symp->next) { | |
676 | location[symp->index + ieee->external_reference_base_offset] = | |
677 | &symp->symbol; | |
678 | ||
679 | } | |
680 | ||
681 | ||
682 | ||
683 | location[abfd->symcount] = (asymbol *)NULL; | |
684 | ||
685 | return abfd->symcount; | |
686 | } | |
687 | ||
688 | ||
689 | static void | |
301dfc71 SC |
690 | DEFUN(ieee_slurp_sections,(abfd), |
691 | bfd *abfd) | |
87f86b4e DHW |
692 | { |
693 | ieee_data_type *ieee = ieee_data(abfd); | |
694 | file_ptr offset = ieee->w.r.section_part; | |
695 | ||
696 | asection *section = (asection *)NULL; | |
697 | ||
698 | if (offset != 0) { | |
699 | bfd_byte section_type[3]; | |
301dfc71 | 700 | ieee_seek(abfd, offset); |
87f86b4e DHW |
701 | while (true) { |
702 | switch (this_byte(abfd)) { | |
703 | case ieee_section_type_enum: | |
704 | { | |
705 | unsigned int section_index ; | |
706 | next_byte(abfd); | |
707 | section_index = must_parse_int(abfd); | |
708 | /* Fixme to be nice about a silly number of sections */ | |
709 | BFD_ASSERT(section_index < NSECTIONS); | |
710 | ||
711 | section = bfd_make_section(abfd, " tempname"); | |
712 | ieee->section_table[section_index] = section; | |
713 | section->flags = SEC_NO_FLAGS; | |
714 | section->target_index = section_index; | |
715 | section_type[0] = this_byte_and_next(abfd); | |
716 | switch (section_type[0]) { | |
717 | case 0xC3: | |
718 | section_type[1] = this_byte(abfd); | |
719 | section->flags = SEC_LOAD; | |
720 | switch (section_type[1]) { | |
721 | case 0xD0: | |
722 | /* Normal code */ | |
723 | next_byte(abfd); | |
724 | section->flags |= SEC_LOAD | SEC_CODE; | |
725 | break; | |
726 | case 0xC4: | |
727 | next_byte(abfd); | |
728 | section->flags |= SEC_LOAD | SEC_DATA; | |
729 | /* Normal data */ | |
730 | break; | |
731 | case 0xD2: | |
732 | next_byte(abfd); | |
733 | /* Normal rom data */ | |
734 | section->flags |= SEC_LOAD | SEC_ROM | SEC_DATA; | |
735 | break; | |
736 | default: | |
737 | break; | |
738 | } | |
739 | } | |
740 | section->name = read_id(abfd); | |
741 | { bfd_vma parent, brother, context; | |
742 | parse_int(abfd, &parent); | |
743 | parse_int(abfd, &brother); | |
744 | parse_int(abfd, &context); | |
745 | } | |
746 | ||
747 | ||
748 | } | |
749 | break; | |
750 | case ieee_section_alignment_enum: | |
751 | { | |
752 | unsigned int section_index; | |
753 | bfd_vma value; | |
754 | next_byte(abfd); | |
755 | section_index = must_parse_int(abfd); | |
756 | if (section_index > ieee->section_count) { | |
757 | ieee->section_count = section_index; | |
758 | } | |
759 | ieee->section_table[section_index]->alignment_power = | |
760 | bfd_log2(must_parse_int(abfd)); | |
761 | (void)parse_int(abfd, & value); | |
762 | } | |
763 | break; | |
764 | case ieee_e2_first_byte_enum: | |
765 | { | |
766 | ieee_record_enum_type t = read_2bytes(abfd); | |
767 | switch (t) { | |
768 | case ieee_section_size_enum: | |
769 | section = ieee->section_table[must_parse_int(abfd)]; | |
770 | section->size = must_parse_int(abfd); | |
771 | break; | |
772 | case ieee_physical_region_size_enum: | |
773 | section = ieee->section_table[must_parse_int(abfd)]; | |
774 | section->size = must_parse_int(abfd); | |
775 | break; | |
776 | case ieee_region_base_address_enum: | |
777 | section = ieee->section_table[must_parse_int(abfd)]; | |
778 | section->vma = must_parse_int(abfd); | |
779 | break; | |
780 | case ieee_mau_size_enum: | |
781 | must_parse_int(abfd); | |
782 | must_parse_int(abfd); | |
783 | break; | |
784 | case ieee_m_value_enum: | |
785 | must_parse_int(abfd); | |
786 | must_parse_int(abfd); | |
787 | break; | |
788 | case ieee_section_base_address_enum: | |
789 | section = ieee->section_table[must_parse_int(abfd)]; | |
790 | section->vma = must_parse_int(abfd); | |
791 | break; | |
792 | case ieee_section_offset_enum: | |
793 | (void) must_parse_int(abfd); | |
794 | (void) must_parse_int(abfd); | |
795 | break; | |
796 | default: | |
797 | return; | |
798 | } | |
799 | } | |
800 | break; | |
801 | default: | |
802 | return; | |
803 | } | |
804 | } | |
805 | } | |
806 | } | |
807 | ||
808 | /*********************************************************************** | |
809 | * archive stuff | |
810 | */ | |
811 | bfd_target * | |
301dfc71 SC |
812 | DEFUN(ieee_archive_p,(abfd), |
813 | bfd *abfd) | |
87f86b4e DHW |
814 | { |
815 | char *library; | |
816 | boolean loop; | |
817 | ieee_ar_data_type *ar; | |
818 | unsigned int i; | |
d6a554ae | 819 | return 0; /* FIXME */ |
301dfc71 | 820 | ieee_seek(abfd, (file_ptr) 0); |
87f86b4e DHW |
821 | if (this_byte(abfd) != Module_Beginning) return (bfd_target*)NULL; |
822 | next_byte(abfd); | |
823 | library= read_id(abfd); | |
824 | if (strcmp(library , "LIBRARY") != 0) { | |
825 | free(library); | |
826 | return (bfd_target *)NULL; | |
827 | } | |
828 | /* Throw away the filename */ | |
829 | free( read_id(abfd)); | |
830 | /* This must be an IEEE archive, so we'll buy some space to do | |
831 | things */ | |
832 | ar = (ieee_ar_data_type *) malloc(sizeof(ieee_ar_data_type)); | |
833 | ieee_ar_data(abfd) = ar; | |
834 | ar->element_count = 0; | |
835 | ar->element_index = 0; | |
836 | obstack_init(&ar->element_obstack); | |
837 | ||
838 | next_byte(abfd); /* Drop the ad part */ | |
839 | must_parse_int(abfd); /* And the two dummy numbers */ | |
840 | must_parse_int(abfd); | |
841 | ||
842 | loop = true; | |
843 | /* Read the index of the BB table */ | |
844 | while (loop) { | |
845 | ieee_ar_obstack_type t; | |
846 | int rec =read_2bytes(abfd); | |
847 | if (rec ==ieee_assign_value_to_variable_enum) { | |
848 | int record_number = must_parse_int(abfd); | |
849 | t.file_offset = must_parse_int(abfd); | |
850 | t.abfd = (bfd *)NULL; | |
851 | ar->element_count++; | |
301dfc71 | 852 | obstack_grow(&ar->element_obstack, (PTR)&t, sizeof(t)); |
87f86b4e DHW |
853 | } |
854 | else loop = false; | |
855 | } | |
856 | ar->elements = (ieee_ar_obstack_type *)obstack_base(&ar->element_obstack); | |
857 | ||
858 | /* Now scan the area again, and replace BB offsets with file */ | |
859 | /* offsets */ | |
860 | ||
861 | ||
862 | for (i = 2; i < ar->element_count; i++) { | |
301dfc71 | 863 | ieee_seek(abfd, ar->elements[i].file_offset); |
87f86b4e DHW |
864 | next_byte(abfd); /* Drop F8 */ |
865 | next_byte(abfd); /* Drop 14 */ | |
866 | must_parse_int(abfd); /* Drop size of block */ | |
867 | if (must_parse_int(abfd) != 0) { | |
868 | /* This object has been deleted */ | |
869 | ar->elements[i].file_offset = 0; | |
870 | } | |
871 | else { | |
872 | ar->elements[i].file_offset = must_parse_int(abfd); | |
873 | } | |
874 | } | |
875 | ||
876 | obstack_finish(&ar->element_obstack); | |
877 | return abfd->xvec; | |
878 | } | |
879 | ||
301dfc71 SC |
880 | static boolean |
881 | DEFUN(ieee_mkobject,(abfd), | |
882 | bfd *abfd) | |
883 | { | |
884 | struct obstack tmp_obstack; | |
885 | ieee_data_type *ieee; | |
886 | obstack_init(&tmp_obstack); | |
887 | BFD_ASSERT(ieee_data(abfd) == 0); | |
888 | ieee_data(abfd) = | |
889 | (ieee_data_type*)obstack_alloc(&tmp_obstack,sizeof(ieee_data_type)); | |
890 | ieee = ieee_data(abfd); | |
891 | ieee->ieee_obstack = tmp_obstack; | |
892 | return true; | |
893 | } | |
894 | ||
87f86b4e | 895 | bfd_target * |
301dfc71 SC |
896 | DEFUN(ieee_object_p,(abfd), |
897 | bfd *abfd) | |
87f86b4e DHW |
898 | { |
899 | char *processor; | |
900 | unsigned int part; | |
301dfc71 SC |
901 | ieee_data_type *ieee; |
902 | char buffer[300]; | |
d6a554ae | 903 | |
301dfc71 SC |
904 | ieee_data(abfd) = 0; |
905 | ieee_mkobject(abfd); | |
906 | ieee = ieee_data(abfd); | |
907 | ||
908 | /* Read the first few bytes in to see if it makes sense */ | |
909 | bfd_read(buffer, 1, sizeof(buffer), abfd); | |
910 | ||
911 | ptr(abfd)= buffer; | |
912 | if (*(ptr(abfd)++) != Module_Beginning) goto fail; | |
301dfc71 SC |
913 | |
914 | ieee->read_symbols= false; | |
915 | ieee->read_data= false; | |
916 | ieee->section_count = 0; | |
917 | ieee->external_symbol_max_index = 0; | |
918 | ieee->external_symbol_min_index = IEEE_PUBLIC_BASE; | |
919 | ieee->external_reference_min_index =IEEE_REFERENCE_BASE; | |
920 | ieee->external_reference_max_index = 0; | |
921 | memset((PTR)ieee->section_table, 0, sizeof(ieee->section_table)); | |
922 | ||
923 | processor = ieee->mb.processor = read_id(abfd); | |
924 | if (strcmp(processor,"LIBRARY") == 0) goto fail; | |
925 | ieee->mb.module_name = read_id(abfd); | |
87f86b4e | 926 | if (abfd->filename == (char *)NULL) { |
301dfc71 | 927 | abfd->filename = ieee->mb.module_name; |
87f86b4e DHW |
928 | } |
929 | /* Determine the architecture and machine type of the object file. */ | |
930 | bfd_scan_arch_mach(processor, &abfd->obj_arch, &abfd->obj_machine); | |
931 | ||
932 | if (this_byte(abfd) != ieee_address_descriptor_enum) { | |
301dfc71 | 933 | goto fail; |
87f86b4e DHW |
934 | } |
935 | next_byte(abfd); | |
936 | ||
301dfc71 SC |
937 | if (parse_int(abfd, &ieee->ad.number_of_bits_mau) == false) { |
938 | goto fail; | |
87f86b4e | 939 | } |
301dfc71 SC |
940 | if(parse_int(abfd, &ieee->ad.number_of_maus_in_address) == false) { |
941 | goto fail; | |
87f86b4e DHW |
942 | } |
943 | ||
944 | /* If there is a byte order info, take it */ | |
945 | if (this_byte(abfd) == ieee_variable_L_enum || | |
946 | this_byte(abfd) == ieee_variable_M_enum) | |
947 | next_byte(abfd); | |
948 | ||
949 | ||
950 | for (part = 0; part < N_W_VARIABLES; part++) { | |
951 | boolean ok; | |
952 | if (read_2bytes(abfd) != ieee_assign_value_to_variable_enum) { | |
301dfc71 | 953 | goto fail; |
87f86b4e DHW |
954 | } |
955 | if (this_byte_and_next(abfd) != part) { | |
301dfc71 | 956 | goto fail; |
87f86b4e DHW |
957 | } |
958 | ||
301dfc71 | 959 | ieee->w.offset[part] = parse_i(abfd, &ok); |
87f86b4e | 960 | if (ok==false) { |
301dfc71 | 961 | goto fail; |
87f86b4e DHW |
962 | } |
963 | ||
964 | } | |
965 | abfd->flags = HAS_SYMS; | |
966 | ||
301dfc71 SC |
967 | /* By now we know that this is a real IEEE file, we're going to read |
968 | the whole thing into memory so that we can run up and down it | |
969 | quickly. We can work out how big the file is from the trailer | |
970 | record */ | |
971 | ||
972 | ieee_data(abfd)->first_byte = ieee_malloc(abfd, ieee->w.r.me_record | |
973 | + 50); | |
974 | bfd_seek(abfd, 0, 0); | |
975 | bfd_read(ieee_data(abfd)->first_byte, 1, ieee->w.r.me_record+50, abfd); | |
976 | ||
87f86b4e DHW |
977 | ieee_slurp_sections(abfd); |
978 | return abfd->xvec; | |
301dfc71 SC |
979 | fail: |
980 | obstack_finish(&ieee->ieee_obstack); | |
981 | return (bfd_target *)NULL; | |
87f86b4e DHW |
982 | } |
983 | ||
984 | ||
985 | void | |
301dfc71 SC |
986 | DEFUN(ieee_print_symbol,(ignore_abfd, file, symbol, how), |
987 | bfd *ignore_abfd AND | |
988 | FILE *file AND | |
989 | asymbol *symbol AND | |
990 | bfd_print_symbol_enum_type how) | |
87f86b4e | 991 | { |
87f86b4e DHW |
992 | switch (how) { |
993 | case bfd_print_symbol_name_enum: | |
994 | fprintf(file,"%s", symbol->name); | |
995 | break; | |
996 | case bfd_print_symbol_type_enum: | |
997 | #if 0 | |
998 | fprintf(file,"%4x %2x",aout_symbol(symbol)->desc & 0xffff, | |
999 | aout_symbol(symbol)->other & 0xff); | |
1000 | #endif | |
1001 | BFD_FAIL(); | |
1002 | break; | |
1003 | case bfd_print_symbol_all_enum: | |
301dfc71 SC |
1004 | { |
1005 | CONST char *section_name = symbol->section == (asection *)NULL ? | |
1006 | "*abs" : symbol->section->name; | |
1007 | ||
1008 | bfd_print_symbol_vandf((void *)file,symbol); | |
1009 | ||
1010 | fprintf(file," %-5s %04x %02x %s", | |
1011 | section_name, | |
1012 | (unsigned) ieee_symbol(symbol)->index, | |
1013 | (unsigned) 0, /* | |
1014 | aout_symbol(symbol)->desc & 0xffff, | |
1015 | aout_symbol(symbol)->other & 0xff,*/ | |
1016 | symbol->name); | |
1017 | } | |
87f86b4e DHW |
1018 | break; |
1019 | } | |
1020 | } | |
1021 | ||
1022 | ||
1023 | ||
1024 | /* Read in all the section data and relocation stuff too */ | |
301dfc71 SC |
1025 | static boolean |
1026 | DEFUN(ieee_slurp_section_data,(abfd), | |
1027 | bfd *abfd) | |
87f86b4e DHW |
1028 | { |
1029 | bfd_byte *location_ptr ; | |
1030 | ieee_data_type *ieee = ieee_data(abfd); | |
1031 | unsigned int section_number ; | |
1032 | ||
1033 | ieee_per_section_type *current_map; | |
1034 | asection *s; | |
1035 | /* Seek to the start of the data area */ | |
1036 | if (ieee->read_data== true) return true; | |
1037 | ieee->read_data = true; | |
301dfc71 | 1038 | ieee_seek(abfd, ieee->w.r.data_part); |
87f86b4e DHW |
1039 | |
1040 | /* Allocate enough space for all the section contents */ | |
1041 | ||
1042 | ||
1043 | for (s = abfd->sections; s != (asection *)NULL; s = s->next) { | |
a6dab071 | 1044 | ieee_per_section_type *per = (ieee_per_section_type *) s->used_by_bfd; |
301dfc71 | 1045 | per->data = (bfd_byte *) ieee_malloc(abfd, s->size); |
87f86b4e | 1046 | /*SUPPRESS 68*/ |
87f86b4e DHW |
1047 | per->reloc_tail_ptr = |
1048 | (ieee_reloc_type **)&(s->relocation); | |
1049 | } | |
1050 | ||
1051 | ||
1052 | ||
1053 | while (true) { | |
1054 | switch (this_byte(abfd)) | |
1055 | { | |
1056 | /* IF we see anything strange then quit */ | |
1057 | default: | |
1058 | return true; | |
1059 | ||
1060 | case ieee_set_current_section_enum: | |
1061 | next_byte(abfd); | |
1062 | section_number = must_parse_int(abfd); | |
1063 | s = ieee->section_table[section_number]; | |
a6dab071 | 1064 | current_map = (ieee_per_section_type *) s->used_by_bfd; |
87f86b4e DHW |
1065 | location_ptr = current_map->data - s->vma; |
1066 | /* The document I have says that Microtec's compilers reset */ | |
1067 | /* this after a sec section, even though the standard says not */ | |
1068 | /* to. SO .. */ | |
1069 | current_map->pc =s->vma; | |
1070 | break; | |
1071 | ||
1072 | case ieee_load_constant_bytes_enum: | |
1073 | { | |
1074 | unsigned int number_of_maus; | |
1075 | unsigned int i; | |
1076 | next_byte(abfd); | |
1077 | number_of_maus = must_parse_int(abfd); | |
1078 | ||
1079 | for (i = 0; i < number_of_maus; i++) { | |
1080 | location_ptr[current_map->pc++]= this_byte(abfd); | |
1081 | next_byte(abfd); | |
1082 | } | |
1083 | } | |
1084 | break; | |
1085 | ||
1086 | case ieee_e2_first_byte_enum: | |
1087 | next_byte(abfd); | |
1088 | switch (this_byte(abfd)) | |
1089 | { | |
1090 | case ieee_set_current_pc_enum & 0xff: | |
1091 | { | |
1092 | bfd_vma value; | |
1093 | asection *dsection; | |
1094 | ieee_symbol_index_type symbol; | |
1095 | unsigned int extra; | |
1096 | boolean pcrel; | |
1097 | next_byte(abfd); | |
1098 | must_parse_int(abfd); /* Thow away section #*/ | |
301dfc71 | 1099 | parse_expression(abfd, &value, &dsection, &symbol, &pcrel, &extra); |
87f86b4e | 1100 | current_map->pc = value; |
301dfc71 | 1101 | BFD_ASSERT((unsigned)(value - s->vma) <= s->size); |
87f86b4e DHW |
1102 | } |
1103 | break; | |
1104 | ||
1105 | case ieee_value_starting_address_enum & 0xff: | |
1106 | /* We've got to the end of the data now - */ | |
1107 | return true; | |
1108 | break; | |
1109 | default: | |
1110 | BFD_FAIL(); | |
1111 | return true; | |
1112 | } | |
1113 | break; | |
1114 | case ieee_load_with_relocation_enum: | |
1115 | { | |
1116 | boolean loop = true; | |
1117 | next_byte(abfd); | |
1118 | while (loop) | |
1119 | { | |
1120 | switch (this_byte(abfd)) | |
1121 | { | |
1122 | case ieee_variable_R_enum: | |
1123 | ||
1124 | case ieee_function_signed_open_b_enum: | |
1125 | case ieee_function_unsigned_open_b_enum: | |
1126 | case ieee_function_either_open_b_enum: | |
1127 | { | |
1128 | unsigned int extra; | |
1129 | boolean pcrel; | |
1130 | ||
1131 | ieee_reloc_type *r = | |
301dfc71 | 1132 | (ieee_reloc_type *) ieee_malloc(abfd, |
87f86b4e DHW |
1133 | sizeof(ieee_reloc_type)); |
1134 | ||
1135 | *(current_map->reloc_tail_ptr) = r; | |
1136 | current_map->reloc_tail_ptr= &r->next; | |
1137 | r->next = (ieee_reloc_type *)NULL; | |
1138 | next_byte(abfd); | |
301dfc71 | 1139 | parse_expression(abfd, |
87f86b4e DHW |
1140 | &r->relent.addend, |
1141 | &r->relent.section, | |
1142 | &r->symbol, | |
1143 | &pcrel, | |
1144 | &extra); | |
1145 | r->relent.address = current_map->pc; | |
1146 | s->reloc_count++; | |
1147 | switch (this_byte(abfd)) { | |
1148 | case ieee_function_signed_close_b_enum: | |
1149 | next_byte(abfd); | |
1150 | break; | |
1151 | case ieee_function_unsigned_close_b_enum: | |
1152 | next_byte(abfd); | |
1153 | break; | |
1154 | case ieee_function_either_close_b_enum: | |
1155 | next_byte(abfd); | |
1156 | break; | |
1157 | default: | |
1158 | break; | |
1159 | } | |
1160 | /* Build a relocation entry for this type */ | |
1161 | if (this_byte(abfd) == ieee_comma) { | |
1162 | ||
1163 | next_byte(abfd); | |
1164 | /* Fetch number of bytes to pad */ | |
1165 | extra = must_parse_int(abfd); | |
1166 | BFD_FAIL(); | |
1167 | } | |
1168 | switch (extra) { | |
1169 | case 0: | |
1170 | case 4: | |
1171 | location_ptr[current_map->pc++] = 0; | |
1172 | location_ptr[current_map->pc++] = 0; | |
1173 | location_ptr[current_map->pc++] = 0; | |
1174 | location_ptr[current_map->pc++] = 0; | |
1175 | r->relent.howto = &abs32_howto; | |
1176 | break; | |
1177 | case 2: | |
1178 | location_ptr[current_map->pc++] = 0; | |
1179 | location_ptr[current_map->pc++] = 0; | |
1180 | r->relent.howto = &abs16_howto; | |
1181 | break; | |
1182 | ||
1183 | default: | |
1184 | BFD_FAIL(); | |
1185 | break; | |
1186 | } | |
1187 | } | |
1188 | break; | |
1189 | default: | |
1190 | { | |
1191 | bfd_vma this_size ; | |
1192 | if (parse_int(abfd, &this_size) == true) { | |
1193 | unsigned int i; | |
1194 | for (i = 0; i < this_size; i++) { | |
1195 | location_ptr[current_map->pc ++] = this_byte(abfd); | |
1196 | next_byte(abfd); | |
1197 | } | |
1198 | } | |
1199 | else { | |
1200 | loop = false; | |
1201 | } | |
1202 | } | |
1203 | } | |
1204 | } | |
1205 | } | |
1206 | } | |
1207 | } | |
1208 | } | |
1209 | ||
1210 | ||
1211 | ||
1212 | boolean | |
301dfc71 SC |
1213 | DEFUN(ieee_new_section_hook,(abfd, newsect), |
1214 | bfd *abfd AND | |
1215 | asection *newsect) | |
87f86b4e | 1216 | { |
a6dab071 | 1217 | newsect->used_by_bfd = (PTR) |
301dfc71 | 1218 | ieee_malloc(abfd, sizeof(ieee_per_section_type)); |
87f86b4e DHW |
1219 | ieee_per_section( newsect)->data = (bfd_byte *)NULL; |
1220 | ieee_per_section(newsect)->section = newsect; | |
1221 | return true; | |
1222 | } | |
1223 | ||
1224 | ||
1225 | unsigned int | |
301dfc71 SC |
1226 | DEFUN(ieee_get_reloc_upper_bound,(abfd, asect), |
1227 | bfd *abfd AND | |
1228 | sec_ptr asect) | |
87f86b4e DHW |
1229 | { |
1230 | ieee_slurp_section_data(abfd); | |
1231 | return (asect->reloc_count+1) * sizeof(arelent *); | |
1232 | } | |
1233 | ||
1234 | static boolean | |
301dfc71 SC |
1235 | DEFUN(ieee_get_section_contents,(abfd, section, location, offset, count), |
1236 | bfd *abfd AND | |
1237 | sec_ptr section AND | |
1238 | void *location AND | |
1239 | file_ptr offset AND | |
1240 | unsigned int count) | |
87f86b4e | 1241 | { |
a6dab071 | 1242 | ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd; |
87f86b4e DHW |
1243 | ieee_slurp_section_data(abfd); |
1244 | (void) memcpy(location, p->data + offset, count); | |
1245 | return true; | |
1246 | } | |
1247 | ||
1248 | ||
1249 | unsigned int | |
301dfc71 SC |
1250 | DEFUN(ieee_canonicalize_reloc,(abfd, section, relptr, symbols), |
1251 | bfd *abfd AND | |
1252 | sec_ptr section AND | |
1253 | arelent **relptr AND | |
1254 | asymbol **symbols) | |
87f86b4e | 1255 | { |
a6dab071 | 1256 | ieee_per_section_type *p = (ieee_per_section_type *) section->used_by_bfd; |
87f86b4e DHW |
1257 | ieee_reloc_type *src = (ieee_reloc_type *)(section->relocation); |
1258 | ieee_data_type *ieee = ieee_data(abfd); | |
1259 | ||
1260 | while (src != (ieee_reloc_type *)NULL) { | |
1261 | /* Work out which symbol to attatch it this reloc to */ | |
1262 | switch (src->symbol.letter) { | |
1263 | case 'X': | |
1264 | src->relent.sym_ptr_ptr = | |
1265 | symbols + src->symbol.index + ieee->external_reference_base_offset; | |
1266 | break; | |
1267 | case 0: | |
1268 | src->relent.sym_ptr_ptr = (asymbol **)NULL; | |
1269 | break; | |
1270 | default: | |
1271 | ||
1272 | BFD_FAIL(); | |
1273 | } | |
1274 | *relptr++ = &src->relent; | |
1275 | src = src->next; | |
1276 | } | |
1277 | *relptr = (arelent *)NULL; | |
1278 | return section->reloc_count; | |
1279 | } | |
1280 | ||
1281 | boolean | |
301dfc71 SC |
1282 | DEFUN(ieee_set_arch_mach,(abfd, arch, machine), |
1283 | bfd *abfd AND | |
1284 | enum bfd_architecture arch AND | |
1285 | unsigned long machine) | |
87f86b4e DHW |
1286 | { |
1287 | abfd->obj_arch = arch; | |
1288 | abfd->obj_machine = machine; | |
1289 | return true; | |
1290 | } | |
1291 | ||
87f86b4e | 1292 | |
301dfc71 SC |
1293 | static int |
1294 | DEFUN(comp,(ap, bp), | |
39a2ce33 SC |
1295 | CONST PTR ap AND |
1296 | CONST PTR bp) | |
87f86b4e | 1297 | { |
9872a49c SC |
1298 | arelent *a = *((arelent **)ap); |
1299 | arelent *b = *((arelent **)bp); | |
87f86b4e DHW |
1300 | return a->address - b->address; |
1301 | } | |
9872a49c | 1302 | |
87f86b4e DHW |
1303 | /* |
1304 | Write the section headers | |
1305 | */ | |
1306 | ||
1307 | static void | |
301dfc71 SC |
1308 | DEFUN(ieee_write_section_part,(abfd), |
1309 | bfd *abfd) | |
87f86b4e DHW |
1310 | { |
1311 | ieee_data_type *ieee = ieee_data(abfd); | |
1312 | asection *s; | |
1313 | ieee->w.r.section_part = bfd_tell(abfd); | |
1314 | for (s = abfd->sections; s != (asection *)NULL; s=s->next) { | |
1315 | ieee_write_byte(abfd, ieee_section_type_enum); | |
1316 | ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE); | |
1317 | ||
1318 | switch (s->flags & (SEC_LOAD | SEC_CODE | SEC_DATA | SEC_ROM)) { | |
1319 | case SEC_LOAD | SEC_CODE: | |
1320 | /* Normal named section, code */ | |
1321 | ieee_write_byte(abfd, ieee_variable_C_enum); | |
1322 | ieee_write_byte(abfd, ieee_variable_P_enum); | |
1323 | break; | |
1324 | case SEC_LOAD | SEC_DATA: | |
1325 | /* Normal named section, data */ | |
1326 | ieee_write_byte(abfd, ieee_variable_C_enum); | |
1327 | ieee_write_byte(abfd, ieee_variable_D_enum); | |
1328 | break; | |
1329 | case SEC_LOAD | SEC_DATA | SEC_ROM: | |
1330 | /* Normal named section, data rom */ | |
1331 | ieee_write_byte(abfd, ieee_variable_C_enum); | |
1332 | ieee_write_byte(abfd, ieee_variable_R_enum); | |
1333 | break; | |
1334 | default: | |
1335 | ieee_write_byte(abfd, ieee_variable_C_enum); | |
1336 | break; | |
1337 | } | |
1338 | ||
1339 | ieee_write_id(abfd, s->name); | |
1340 | ieee_write_int(abfd, 0); /* Parent */ | |
1341 | ieee_write_int(abfd, 0); /* Brother */ | |
1342 | ieee_write_int(abfd, 0); /* Context */ | |
1343 | ||
1344 | /* Alignment */ | |
1345 | ieee_write_byte(abfd, ieee_section_alignment_enum); | |
1346 | ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE); | |
1347 | ieee_write_int(abfd, 1 << s->alignment_power); | |
1348 | ||
1349 | /* Size */ | |
1350 | ieee_write_2bytes(abfd, ieee_section_size_enum); | |
1351 | ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE); | |
1352 | ieee_write_int(abfd, s->size); | |
1353 | ||
1354 | /* Vma */ | |
1355 | ieee_write_2bytes(abfd, ieee_region_base_address_enum); | |
1356 | ieee_write_byte(abfd, s->index + IEEE_SECTION_NUMBER_BASE); | |
1357 | ieee_write_int(abfd, s->vma); | |
1358 | ||
1359 | } | |
1360 | } | |
1361 | ||
1362 | ||
1363 | ||
1364 | /* write the data in an ieee way */ | |
1365 | static void | |
301dfc71 SC |
1366 | DEFUN(ieee_write_data_part,(abfd), |
1367 | bfd *abfd) | |
87f86b4e DHW |
1368 | { |
1369 | asection *s; | |
1370 | ieee_data_type *ieee = ieee_data(abfd); | |
1371 | ieee->w.r.data_part = bfd_tell(abfd); | |
1372 | for (s = abfd->sections; s != (asection *)NULL; s = s->next) | |
301dfc71 SC |
1373 | { |
1374 | bfd_byte header[11]; | |
1375 | bfd_byte *stream = ieee_per_section(s)->data; | |
1376 | arelent **p = s->orelocation; | |
1377 | unsigned int relocs_to_go = s->reloc_count; | |
1378 | size_t current_byte_index = 0; | |
1379 | ||
1380 | ||
1381 | /* Sort the reloc records so we can insert them in the correct | |
1382 | places */ | |
1383 | if (s->reloc_count != 0) { | |
1384 | qsort(s->orelocation, | |
1385 | s->reloc_count, | |
1386 | sizeof(arelent **), | |
1387 | comp); | |
1388 | } | |
87f86b4e DHW |
1389 | |
1390 | ||
301dfc71 SC |
1391 | /* Output the section preheader */ |
1392 | header[0] =ieee_set_current_section_enum; | |
1393 | header[1] = s->index + IEEE_SECTION_NUMBER_BASE; | |
87f86b4e | 1394 | |
301dfc71 SC |
1395 | header[2] = ieee_set_current_pc_enum >> 8; |
1396 | header[3]= ieee_set_current_pc_enum & 0xff; | |
1397 | header[4] = s->index + IEEE_SECTION_NUMBER_BASE; | |
1398 | ieee_write_int5(header+5, s->vma ); | |
1399 | header[10] = ieee_load_with_relocation_enum; | |
1400 | bfd_write(header, 1, sizeof(header), abfd); | |
87f86b4e | 1401 | |
301dfc71 SC |
1402 | /* Output the data stream as the longest sequence of bytes |
1403 | possible, allowing for the a reasonable packet size and | |
1404 | relocation stuffs */ | |
87f86b4e | 1405 | |
301dfc71 SC |
1406 | if (stream == (void *)NULL) { |
1407 | /* Outputting a section without data, fill it up */ | |
1408 | stream = ieee_malloc(abfd, s->size); | |
1409 | memset(stream, 0, s->size); | |
87f86b4e | 1410 | } |
301dfc71 SC |
1411 | while (current_byte_index < s->size) { |
1412 | size_t run; | |
1413 | unsigned int MAXRUN = 32; | |
1414 | if (p && *p) { | |
1415 | run = (*p)->address - current_byte_index; | |
1416 | } | |
1417 | else { | |
1418 | run = MAXRUN; | |
1419 | } | |
1420 | if (run > s->size - current_byte_index) { | |
1421 | run = s->size - current_byte_index; | |
1422 | } | |
1423 | ||
1424 | if (run != 0) { | |
1425 | /* Output a stream of bytes */ | |
1426 | ieee_write_int(abfd, run); | |
1427 | bfd_write(stream + current_byte_index, | |
1428 | 1, | |
1429 | run, | |
1430 | abfd); | |
1431 | current_byte_index += run; | |
1432 | } | |
1433 | /* Output any relocations here */ | |
1434 | if (relocs_to_go && (*p) && (*p)->address == current_byte_index) { | |
1435 | while (relocs_to_go && (*p) && (*p)->address == current_byte_index) { | |
1436 | ||
1437 | arelent *r = *p; | |
1438 | ieee_write_byte(abfd, ieee_function_either_open_b_enum); | |
1439 | if (r->sym_ptr_ptr != (asymbol **)NULL) { | |
1440 | ieee_write_expression(abfd, r->addend, | |
1441 | r->section, | |
1442 | *(r->sym_ptr_ptr)); | |
1443 | } | |
1444 | else { | |
1445 | ieee_write_expression(abfd, r->addend, | |
1446 | r->section, | |
1447 | (asymbol *)NULL); | |
1448 | } | |
1449 | ieee_write_byte(abfd, | |
1450 | ieee_function_either_close_b_enum); | |
1451 | relocs_to_go --; | |
1452 | p++; | |
87f86b4e | 1453 | } |
301dfc71 SC |
1454 | /* FIXME !! Are all relocations 4 bytes ? */ |
1455 | current_byte_index += 4; | |
87f86b4e | 1456 | } |
87f86b4e DHW |
1457 | } |
1458 | } | |
87f86b4e | 1459 | |
301dfc71 | 1460 | } |
87f86b4e DHW |
1461 | |
1462 | ||
1463 | ||
1464 | static void | |
301dfc71 SC |
1465 | DEFUN(init_for_output,(abfd), |
1466 | bfd *abfd) | |
87f86b4e DHW |
1467 | { |
1468 | asection *s; | |
1469 | for (s = abfd->sections; s != (asection *)NULL; s = s->next) { | |
1470 | if (s->size != 0) { | |
301dfc71 | 1471 | ieee_per_section(s)->data = (bfd_byte *)(ieee_malloc(abfd, s->size)); |
87f86b4e DHW |
1472 | } |
1473 | } | |
1474 | } | |
1475 | ||
1476 | /** exec and core file sections */ | |
1477 | ||
1478 | /* set section contents is complicated with IEEE since the format is | |
1479 | * not a byte image, but a record stream. | |
1480 | */ | |
1481 | boolean | |
301dfc71 SC |
1482 | DEFUN(ieee_set_section_contents,(abfd, section, location, offset, count), |
1483 | bfd *abfd AND | |
1484 | sec_ptr section AND | |
1485 | unsigned char *location AND | |
1486 | file_ptr offset AND | |
1487 | int count) | |
87f86b4e DHW |
1488 | { |
1489 | if (ieee_per_section(section)->data == (bfd_byte *)NULL) { | |
1490 | init_for_output(abfd); | |
1491 | } | |
1492 | (void) memcpy(ieee_per_section(section)->data + offset, location, count); | |
1493 | return true; | |
1494 | } | |
1495 | ||
1496 | /* | |
1497 | write the external symbols of a file, IEEE considers two sorts of | |
1498 | external symbols, public, and referenced. It uses to internal forms | |
1499 | to index them as well. When we write them out we turn their symbol | |
1500 | values into indexes from the right base. | |
1501 | */ | |
1502 | static void | |
301dfc71 SC |
1503 | DEFUN(ieee_write_external_part,(abfd), |
1504 | bfd *abfd) | |
87f86b4e DHW |
1505 | { |
1506 | asymbol **q; | |
1507 | ieee_data_type *ieee = ieee_data(abfd); | |
1508 | ||
1509 | unsigned int reference_index = IEEE_REFERENCE_BASE; | |
1510 | unsigned int public_index = IEEE_PUBLIC_BASE; | |
1511 | ieee->w.r.external_part = bfd_tell(abfd); | |
1512 | if (abfd->outsymbols != (asymbol **)NULL) { | |
1513 | for (q = abfd->outsymbols; *q != (asymbol *)NULL; q++) { | |
1514 | asymbol *p = *q; | |
1515 | if (p->flags & BSF_UNDEFINED) { | |
1516 | /* This must be a symbol reference .. */ | |
1517 | ieee_write_byte(abfd, ieee_external_reference_enum); | |
1518 | ieee_write_int(abfd, reference_index); | |
1519 | ieee_write_id(abfd, p->name); | |
1520 | p->value = reference_index; | |
1521 | reference_index++; | |
1522 | } | |
1523 | else if(p->flags & BSF_FORT_COMM) { | |
1524 | /* This is a weak reference */ | |
1525 | ieee_write_byte(abfd, ieee_external_reference_enum); | |
1526 | ieee_write_int(abfd, reference_index); | |
1527 | ieee_write_id(abfd, p->name); | |
1528 | ieee_write_byte(abfd, ieee_weak_external_reference_enum); | |
1529 | ieee_write_int(abfd, reference_index); | |
1530 | ieee_write_int(abfd, p->value); | |
1531 | ieee_write_int(abfd, BFD_FORT_COMM_DEFAULT_VALUE); | |
1532 | p->value = reference_index; | |
1533 | reference_index++; | |
1534 | } | |
1535 | else if(p->flags & BSF_GLOBAL) { | |
1536 | /* This must be a symbol definition */ | |
1537 | ||
1538 | ieee_write_byte(abfd, ieee_external_symbol_enum); | |
1539 | ieee_write_int(abfd, public_index ); | |
1540 | ieee_write_id(abfd, p->name); | |
1541 | ||
1542 | /* Write out the value */ | |
1543 | ieee_write_2bytes(abfd, ieee_value_record_enum); | |
1544 | ieee_write_int(abfd, public_index); | |
1545 | if (p->section != (asection *)NULL) | |
1546 | { | |
1547 | ieee_write_expression(abfd, | |
1548 | p->value + p->section->output_offset, | |
1549 | p->section->output_section, | |
1550 | (asymbol *)NULL); | |
1551 | } | |
1552 | else | |
1553 | { | |
1554 | ieee_write_expression(abfd, | |
1555 | p->value, | |
1556 | (asection *)NULL, | |
1557 | (asymbol *)NULL); | |
1558 | } | |
1559 | p->value = public_index; | |
1560 | public_index++; | |
1561 | } | |
1562 | else { | |
1563 | /* This can happen - when there are gaps in the symbols read */ | |
1564 | /* from an input ieee file */ | |
1565 | } | |
1566 | } | |
1567 | } | |
1568 | ||
1569 | } | |
1570 | ||
1571 | static | |
301dfc71 SC |
1572 | void |
1573 | DEFUN(ieee_write_me_part,(abfd), | |
1574 | bfd *abfd) | |
87f86b4e DHW |
1575 | { |
1576 | ieee_data_type *ieee= ieee_data(abfd); | |
1577 | ieee->w.r.me_record = bfd_tell(abfd); | |
1578 | ||
1579 | ieee_write_2bytes(abfd, ieee_value_starting_address_enum); | |
1580 | ieee_write_int(abfd, abfd->start_address); | |
1581 | ieee_write_byte(abfd, ieee_module_end_enum); | |
1582 | ||
1583 | } | |
1584 | boolean | |
301dfc71 SC |
1585 | DEFUN(ieee_write_object_contents,(abfd), |
1586 | bfd *abfd) | |
87f86b4e DHW |
1587 | { |
1588 | ieee_data_type *ieee = ieee_data(abfd); | |
1589 | unsigned int i; | |
301dfc71 SC |
1590 | file_ptr old; |
1591 | /* Fast forward over the header area */ | |
1592 | bfd_seek(abfd, 0, 0); | |
1593 | ieee_write_byte(abfd, ieee_module_beginning_enum); | |
1594 | ||
1595 | ieee_write_id(abfd, bfd_printable_arch_mach(abfd->obj_arch, | |
1596 | abfd->obj_machine)); | |
1597 | ieee_write_id(abfd, abfd->filename); | |
1598 | ieee_write_byte(abfd, ieee_address_descriptor_enum); | |
1599 | ieee_write_byte(abfd, 8); /* Bits per MAU */ | |
1600 | ieee_write_byte(abfd, 4); /* MAU's per address */ | |
1601 | ||
1602 | /* Fast forward over the variable bits */ | |
1603 | old = bfd_tell(abfd); | |
1604 | bfd_seek(abfd, 8 * N_W_VARIABLES, 1); | |
87f86b4e | 1605 | |
87f86b4e | 1606 | /* |
301dfc71 SC |
1607 | First write the symbols, this changes their values into table |
1608 | indeces so we cant use it after this point | |
1609 | */ | |
87f86b4e DHW |
1610 | ieee_write_external_part(abfd); |
1611 | ieee_write_byte(abfd, ieee_record_seperator_enum); | |
1612 | ||
1613 | ieee_write_section_part(abfd); | |
1614 | ieee_write_byte(abfd, ieee_record_seperator_enum); | |
1615 | /* | |
301dfc71 SC |
1616 | Can only write the data once the symbols have been written since |
1617 | the data contains relocation information which points to the | |
1618 | symbols | |
1619 | */ | |
87f86b4e DHW |
1620 | ieee_write_data_part(abfd); |
1621 | ieee_write_byte(abfd, ieee_record_seperator_enum); | |
1622 | ||
1623 | /* | |
301dfc71 SC |
1624 | At the end we put the end ! |
1625 | */ | |
87f86b4e | 1626 | ieee_write_me_part(abfd); |
87f86b4e | 1627 | |
87f86b4e | 1628 | |
301dfc71 SC |
1629 | /* Generate the header */ |
1630 | bfd_seek(abfd, old, false); | |
87f86b4e DHW |
1631 | |
1632 | for (i= 0; i < N_W_VARIABLES; i++) { | |
1633 | ieee_write_2bytes(abfd,ieee_assign_value_to_variable_enum); | |
1634 | ieee_write_byte(abfd, i); | |
301dfc71 | 1635 | ieee_write_int5_out(abfd, ieee->w.offset[i]); |
87f86b4e DHW |
1636 | } |
1637 | return true; | |
1638 | } | |
1639 | ||
1640 | ||
1641 | ||
1642 | \f | |
1643 | /* Native-level interface to symbols. */ | |
1644 | ||
1645 | /* We read the symbols into a buffer, which is discarded when this | |
1646 | function exits. We read the strings into a buffer large enough to | |
1647 | hold them all plus all the cached symbol entries. */ | |
1648 | ||
1649 | asymbol * | |
301dfc71 SC |
1650 | DEFUN(ieee_make_empty_symbol,(abfd), |
1651 | bfd *abfd) | |
87f86b4e DHW |
1652 | { |
1653 | ||
1654 | ieee_symbol_type *new = | |
1655 | (ieee_symbol_type *)zalloc (sizeof (ieee_symbol_type)); | |
1656 | new->symbol.the_bfd = abfd; | |
1657 | return &new->symbol; | |
1658 | ||
1659 | } | |
1660 | ||
1661 | void | |
301dfc71 SC |
1662 | DEFUN(ieee_reclaim_symbol_table, (abfd), |
1663 | bfd *abfd) | |
87f86b4e DHW |
1664 | { |
1665 | #if 0 | |
1666 | asection *section; | |
1667 | ||
1668 | if (!bfd_get_symcount (abfd)) return; | |
1669 | ||
1670 | for (section = abfd->sections; section != NULL; section = section->next) | |
1671 | if (section->relocation) { | |
1672 | free ((void *)section->relocation); | |
1673 | section->relocation = NULL; | |
1674 | section->reloc_count = 0; | |
1675 | } | |
1676 | ||
1677 | bfd_get_symcount (abfd) = 0; | |
1678 | free ((void *)obj_aout_symbols (abfd)); | |
1679 | obj_aout_symbols (abfd) = (aout_symbol_type *)NULL; | |
1680 | #endif | |
1681 | } | |
1682 | \f | |
1683 | ||
1684 | ||
1685 | \f | |
1686 | /* Obsolete procedural interface; better to look at the cache directly */ | |
1687 | ||
1688 | /* User should have checked the file flags; perhaps we should return | |
1689 | BFD_NO_MORE_SYMBOLS if there are none? */ | |
1690 | ||
1691 | int | |
301dfc71 SC |
1692 | DEFUN(ieee_get_symcount_upper_bound,(abfd), |
1693 | bfd *abfd) | |
87f86b4e DHW |
1694 | { |
1695 | #if 0 | |
1696 | /* In case we're doing an output file or something...? */ | |
1697 | if (bfd_get_symcount (abfd)) return bfd_get_symcount (abfd); | |
1698 | ||
1699 | return (exec_hdr (abfd)->a_syms) / (sizeof (struct nlist)); | |
1700 | #endif | |
1701 | return 0; | |
1702 | } | |
1703 | ||
1704 | symindex | |
301dfc71 SC |
1705 | DEFUN(ieee_get_first_symbol,(ignore_abfd), |
1706 | bfd * ignore_abfd) | |
87f86b4e DHW |
1707 | { |
1708 | return 0; | |
1709 | } | |
1710 | ||
1711 | symindex | |
301dfc71 SC |
1712 | DEFUN(ieee_get_next_symbol,(abfd, oidx), |
1713 | bfd *abfd AND | |
1714 | symindex oidx) | |
87f86b4e DHW |
1715 | { |
1716 | #if 0 | |
1717 | if (oidx == BFD_NO_MORE_SYMBOLS) return BFD_NO_MORE_SYMBOLS; | |
1718 | return ++oidx >= bfd_get_symcount (abfd) ? BFD_NO_MORE_SYMBOLS : | |
1719 | oidx; | |
1720 | #endif | |
1721 | return 0; | |
1722 | } | |
1723 | ||
1724 | char * | |
1725 | ieee_symbol_name (abfd, idx) | |
1726 | bfd *abfd; | |
1727 | symindex idx; | |
1728 | { | |
1729 | #if 0 | |
1730 | return (obj_aout_symbols (abfd) + idx)->symbol.name; | |
1731 | #endif | |
1732 | return 0; | |
1733 | } | |
1734 | ||
1735 | long | |
1736 | ieee_symbol_value (abfd, idx) | |
1737 | bfd *abfd; | |
1738 | symindex idx; | |
1739 | { | |
1740 | #if 0 | |
1741 | return (obj_aout_symbols (abfd) + idx)->symbol.value; | |
1742 | #endif | |
1743 | return 0; | |
1744 | } | |
1745 | ||
1746 | symclass | |
1747 | ieee_classify_symbol (abfd, idx) | |
1748 | bfd *abfd; | |
1749 | symindex idx; | |
1750 | { | |
1751 | #if 0 | |
1752 | aout_symbol_type *sym = obj_aout_symbols (abfd) + idx; | |
1753 | ||
1754 | if ((sym->symbol.flags & BSF_FORT_COMM) != 0) return bfd_symclass_fcommon; | |
1755 | if ((sym->symbol.flags & BSF_GLOBAL) != 0) return bfd_symclass_global; | |
1756 | if ((sym->symbol.flags & BSF_DEBUGGING) != 0) return bfd_symclass_debugger; | |
1757 | if ((sym->symbol.flags & BSF_UNDEFINED) != 0) return bfd_symclass_undefined; | |
1758 | #endif | |
1759 | return bfd_symclass_unknown; | |
1760 | } | |
1761 | ||
1762 | boolean | |
1763 | ieee_symbol_hasclass (abfd, idx, class) | |
1764 | bfd *abfd; | |
1765 | symindex idx; | |
1766 | symclass class; | |
1767 | { | |
1768 | #if 0 | |
1769 | aout_symbol_type *sym = obj_aout_symbols (abfd) + idx; | |
1770 | switch (class) { | |
1771 | case bfd_symclass_fcommon: | |
1772 | return (sym->symbol.flags & BSF_FORT_COMM) ? true :false; | |
1773 | case bfd_symclass_global: | |
1774 | return (sym->symbol.flags & BSF_GLOBAL) ? true:false; | |
1775 | case bfd_symclass_debugger: | |
1776 | return (sym->symbol.flags & BSF_DEBUGGING) ? true:false;; | |
1777 | case bfd_symclass_undefined: | |
1778 | return (sym->symbol.flags & BSF_UNDEFINED) ? true:false;; | |
1779 | default: return false; | |
1780 | } | |
1781 | #endif | |
1782 | return 0; | |
1783 | } | |
1784 | ||
1785 | ||
1786 | void | |
1787 | ieee_reclaim_reloc (ignore_abfd, section) | |
1788 | bfd *ignore_abfd; | |
1789 | sec_ptr section; | |
1790 | { | |
1791 | #if 0 | |
1792 | if (section->relocation) { | |
1793 | free (section->relocation); | |
1794 | section->relocation = NULL; | |
1795 | section->reloc_count = 0; | |
1796 | } | |
1797 | #endif | |
1798 | } | |
1799 | ||
1800 | boolean | |
1801 | ieee_close_and_cleanup (abfd) | |
1802 | bfd *abfd; | |
1803 | { | |
1804 | if (bfd_read_p (abfd) == false) | |
1805 | switch (abfd->format) { | |
1806 | case bfd_archive: | |
1807 | if (!_bfd_write_archive_contents (abfd)) { | |
1808 | return false; | |
1809 | } | |
1810 | break; | |
1811 | case bfd_object: | |
1812 | if (!ieee_write_object_contents (abfd)) { | |
1813 | return false; | |
1814 | } | |
1815 | break; | |
1816 | default: | |
1817 | bfd_error = invalid_operation; | |
1818 | return false; | |
1819 | } | |
1820 | ||
1821 | ||
1822 | if (ieee_data(abfd) != (ieee_data_type *)NULL) { | |
1823 | /* FIXME MORE LEAKS */ | |
1824 | ||
1825 | } | |
1826 | ||
1827 | return true; | |
1828 | } | |
1829 | ||
1830 | static bfd * | |
1831 | ieee_openr_next_archived_file(arch, prev) | |
1832 | bfd *arch; | |
1833 | bfd *prev; | |
1834 | { | |
1835 | ieee_ar_data_type *ar = ieee_ar_data(arch); | |
1836 | /* take the next one from the arch state, or reset */ | |
1837 | if (prev == (bfd *)NULL) { | |
1838 | /* Reset the index - the first two entries are bogus*/ | |
1839 | ar->element_index = 2; | |
1840 | } | |
1841 | while (true) { | |
1842 | ieee_ar_obstack_type *p = ar->elements + ar->element_index; | |
1843 | ar->element_index++; | |
1844 | if (ar->element_index <= ar->element_count) { | |
1845 | if (p->file_offset != (file_ptr)0) { | |
1846 | if (p->abfd == (bfd *)NULL) { | |
1847 | p->abfd = _bfd_create_empty_archive_element_shell(arch); | |
1848 | p->abfd->origin = p->file_offset; | |
1849 | } | |
1850 | return p->abfd; | |
1851 | } | |
1852 | } | |
1853 | else { | |
1854 | return (bfd *)NULL; | |
1855 | } | |
1856 | ||
1857 | } | |
1858 | } | |
1859 | ||
1860 | static boolean | |
1861 | ieee_find_nearest_line(abfd, | |
1862 | section, | |
1863 | symbols, | |
1864 | offset, | |
1865 | filename_ptr, | |
1866 | functionname_ptr, | |
1867 | line_ptr) | |
1868 | bfd *abfd; | |
1869 | asection *section; | |
1870 | asymbol **symbols; | |
1871 | bfd_vma offset; | |
1872 | char **filename_ptr; | |
1873 | char **functionname_ptr; | |
1874 | unsigned int *line_ptr; | |
1875 | { | |
1876 | return false; | |
1877 | ||
1878 | } | |
301dfc71 SC |
1879 | |
1880 | ||
1881 | static int | |
9872a49c | 1882 | ieee_generic_stat_arch_elt(abfd, buf) |
301dfc71 SC |
1883 | bfd *abfd; |
1884 | struct stat *buf; | |
1885 | { | |
1886 | ieee_ar_data_type *ar = ieee_ar_data(abfd); | |
1887 | if (ar == (ieee_ar_data_type *)NULL) { | |
1888 | bfd_error = invalid_operation; | |
1889 | return -1; | |
1890 | } | |
1891 | else { | |
1892 | buf->st_size = 0x1; | |
1893 | buf->st_mode = 0666; | |
1894 | return 0; | |
1895 | } | |
1896 | } | |
39a2ce33 SC |
1897 | static int |
1898 | DEFUN(ieee_sizeof_headers,(abfd), | |
1899 | bfd *abfd) | |
1900 | { | |
1901 | return 0; | |
1902 | } | |
1903 | ||
9872a49c SC |
1904 | #define ieee_core_file_failing_command bfd_false |
1905 | #define ieee_core_file_failing_signal bfd_false | |
1906 | #define ieee_core_file_matches_executable_p bfd_false | |
1907 | #define ieee_slurp_armap bfd_true | |
1908 | #define ieee_slurp_extended_name_table bfd_true | |
1909 | #define ieee_truncate_arname bfd_false | |
1910 | #define ieee_write_armap bfd_false | |
1911 | #define ieee_get_lineno bfd_false | |
1912 | ||
301dfc71 | 1913 | |
87f86b4e DHW |
1914 | /*SUPPRESS 460 */ |
1915 | bfd_target ieee_vec = | |
1916 | { | |
1917 | "ieee", /* name */ | |
1918 | bfd_target_ieee_flavour_enum, | |
1919 | true, /* target byte order */ | |
1920 | true, /* target headers byte order */ | |
1921 | (HAS_RELOC | EXEC_P | /* object flags */ | |
1922 | HAS_LINENO | HAS_DEBUG | | |
1923 | HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED), | |
f61d204a | 1924 | (SEC_CODE|SEC_DATA|SEC_ROM|SEC_HAS_CONTENTS |
87f86b4e | 1925 | |SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ |
87f86b4e DHW |
1926 | ' ', /* ar_pad_char */ |
1927 | 16, /* ar_max_namelen */ | |
87f86b4e DHW |
1928 | |
1929 | _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* data */ | |
1930 | _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* hdrs */ | |
1931 | ||
1932 | {_bfd_dummy_target, | |
1933 | ieee_object_p, /* bfd_check_format */ | |
1934 | ieee_archive_p, | |
1935 | bfd_false | |
1936 | }, | |
1937 | { | |
1938 | bfd_false, | |
1939 | ieee_mkobject, | |
1940 | _bfd_generic_mkarchive, | |
1941 | bfd_false | |
1942 | }, | |
9872a49c | 1943 | JUMP_TABLE(ieee) |
87f86b4e | 1944 | }; |