File: | src/gnu/usr.bin/binutils/bfd/tekhex.c |
Warning: | line 712, column 17 Value stored to 's' during its initialization is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* BFD backend for Extended Tektronix Hex Format objects. |
2 | Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003 |
3 | Free Software Foundation, Inc. |
4 | Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>. |
5 | |
6 | This file is part of BFD, the Binary File Descriptor library. |
7 | |
8 | This program is free software; you can redistribute it and/or modify |
9 | it under the terms of the GNU General Public License as published by |
10 | the Free Software Foundation; either version 2 of the License, or |
11 | (at your option) any later version. |
12 | |
13 | This program is distributed in the hope that it will be useful, |
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
16 | GNU General Public License for more details. |
17 | |
18 | You should have received a copy of the GNU General Public License |
19 | along with this program; if not, write to the Free Software |
20 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
21 | |
22 | /* |
23 | SUBSECTION |
24 | Tektronix Hex Format handling |
25 | |
26 | DESCRIPTION |
27 | |
28 | Tek Hex records can hold symbols and data, but not |
29 | relocations. Their main application is communication with |
30 | devices like PROM programmers and ICE equipment. |
31 | |
32 | It seems that the sections are described as being really big, |
33 | the example I have says that the text section is 0..ffffffff. |
34 | BFD would barf with this, many apps would try to alloc 4GB to |
35 | read in the file. |
36 | |
37 | Tex Hex may contain many sections, but the data which comes in |
38 | has no tag saying which section it belongs to, so we create |
39 | one section for each block of data, called "blknnnn" which we |
40 | stick all the data into. |
41 | |
42 | TekHex may come out of order and there is no header, so an |
43 | initial scan is required to discover the minimum and maximum |
44 | addresses used to create the vma and size of the sections we |
45 | create. |
46 | We read in the data into pages of CHUNK_MASK+1 size and read |
47 | them out from that whenever we need to. |
48 | |
49 | Any number of sections may be created for output, we save them |
50 | up and output them when it's time to close the bfd. |
51 | |
52 | A TekHex record looks like: |
53 | EXAMPLE |
54 | %<block length><type><checksum><stuff><cr> |
55 | |
56 | DESCRIPTION |
57 | Where |
58 | o length |
59 | is the number of bytes in the record not including the % sign. |
60 | o type |
61 | is one of: |
62 | 3) symbol record |
63 | 6) data record |
64 | 8) termination record |
65 | |
66 | The data can come out of order, and may be discontigous. This is a |
67 | serial protocol, so big files are unlikely, so we keep a list of 8k chunks |
68 | */ |
69 | |
70 | #include "bfd.h" |
71 | #include "sysdep.h" |
72 | #include "libbfd.h" |
73 | #include "libiberty.h" |
74 | |
75 | typedef struct |
76 | { |
77 | bfd_vma low; |
78 | bfd_vma high; |
79 | } addr_range_type; |
80 | |
81 | typedef struct tekhex_symbol_struct |
82 | { |
83 | |
84 | asymbol symbol; |
85 | struct tekhex_symbol_struct *prev; |
86 | |
87 | } tekhex_symbol_type; |
88 | |
89 | static const char digs[] = "0123456789ABCDEF"; |
90 | |
91 | static char sum_block[256]; |
92 | |
93 | #define NOT_HEX20 20 |
94 | #define NIBBLE(x)((unsigned int) _hex_value[(unsigned char) (x)]) hex_value(x)((unsigned int) _hex_value[(unsigned char) (x)]) |
95 | #define HEX(buffer)((((unsigned int) _hex_value[(unsigned char) ((buffer)[0])])<< 4) + ((unsigned int) _hex_value[(unsigned char) ((buffer)[1]) ])) ((NIBBLE((buffer)[0])((unsigned int) _hex_value[(unsigned char) ((buffer)[0])])<<4) + NIBBLE((buffer)[1])((unsigned int) _hex_value[(unsigned char) ((buffer)[1])])) |
96 | #define TOHEX(d,x)(d)[1] = digs[(x) & 0xf]; (d)[0] = digs[((x)>>4)& 0xf]; \ |
97 | (d)[1] = digs[(x) & 0xf]; \ |
98 | (d)[0] = digs[((x)>>4)&0xf]; |
99 | #define ISHEX(x)(((unsigned int) _hex_value[(unsigned char) (x)]) != 99) hex_p(x)(((unsigned int) _hex_value[(unsigned char) (x)]) != 99) |
100 | |
101 | static void tekhex_init PARAMS ((void))(void); |
102 | static bfd_boolean getvalue PARAMS ((char **, bfd_vma *))(char **, bfd_vma *); |
103 | static void tekhex_print_symbol |
104 | PARAMS ((bfd *, PTR, asymbol *, bfd_print_symbol_type))(bfd *, void *, asymbol *, bfd_print_symbol_type); |
105 | static void tekhex_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *))(bfd *, asymbol *, symbol_info *); |
106 | static asymbol *tekhex_make_empty_symbol PARAMS ((bfd *))(bfd *); |
107 | static int tekhex_sizeof_headers PARAMS ((bfd *, bfd_boolean))(bfd *, bfd_boolean); |
108 | static bfd_boolean tekhex_write_object_contents PARAMS ((bfd *))(bfd *); |
109 | static void out PARAMS ((bfd *, int, char *, char *))(bfd *, int, char *, char *); |
110 | static void writesym PARAMS ((char **, const char *))(char **, const char *); |
111 | static void writevalue PARAMS ((char **, bfd_vma))(char **, bfd_vma); |
112 | static bfd_boolean tekhex_set_section_contents |
113 | PARAMS ((bfd*, sec_ptr, const PTR, file_ptr, bfd_size_type))(bfd*, sec_ptr, const void *, file_ptr, bfd_size_type); |
114 | static bfd_boolean tekhex_set_arch_mach |
115 | PARAMS ((bfd *, enum bfd_architecture, unsigned long))(bfd *, enum bfd_architecture, unsigned long); |
116 | static bfd_boolean tekhex_get_section_contents |
117 | PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type))(bfd *, asection *, void *, file_ptr, bfd_size_type); |
118 | static void move_section_contents |
119 | PARAMS ((bfd *, asection *, const PTR, file_ptr, bfd_size_type, bfd_boolean))(bfd *, asection *, const void *, file_ptr, bfd_size_type, bfd_boolean ); |
120 | static const bfd_target *tekhex_object_p PARAMS ((bfd *))(bfd *); |
121 | static bfd_boolean tekhex_mkobject PARAMS ((bfd *))(bfd *); |
122 | static long tekhex_get_symtab_upper_bound PARAMS ((bfd *))(bfd *); |
123 | static long tekhex_canonicalize_symtab PARAMS ((bfd *, asymbol **))(bfd *, asymbol **); |
124 | static bfd_boolean pass_over PARAMS ((bfd *, bfd_boolean (*) (bfd*, int, char *)))(bfd *, bfd_boolean (*) (bfd*, int, char *)); |
125 | static bfd_boolean first_phase PARAMS ((bfd *, int, char *))(bfd *, int, char *); |
126 | static void insert_byte PARAMS ((bfd *, int, bfd_vma))(bfd *, int, bfd_vma); |
127 | static struct data_struct *find_chunk PARAMS ((bfd *, bfd_vma))(bfd *, bfd_vma); |
128 | static bfd_boolean getsym PARAMS ((char *, char **, unsigned int *))(char *, char **, unsigned int *); |
129 | |
130 | /* |
131 | Here's an example |
132 | %3A6C6480004E56FFFC4E717063B0AEFFFC6D0652AEFFFC60F24E5E4E75 |
133 | %1B3709T_SEGMENT1108FFFFFFFF |
134 | %2B3AB9T_SEGMENT7Dgcc_compiled$1087hello$c10 |
135 | %373829T_SEGMENT80int$t1$r1$$214741080char$t2$r2$0$12710 |
136 | %373769T_SEGMENT80long$int$t3$r1$$1080unsigned$int$t4$10 |
137 | %373CA9T_SEGMENT80long$unsigned$in1080short$int$t6$r1$10 |
138 | %373049T_SEGMENT80long$long$int$t71080short$unsigned$i10 |
139 | %373A29T_SEGMENT80long$long$unsign1080signed$char$t10$10 |
140 | %373D69T_SEGMENT80unsigned$char$t11080float$t12$r1$4$010 |
141 | %373D19T_SEGMENT80double$t13$r1$8$1080long$double$t14$10 |
142 | %2734D9T_SEGMENT8Bvoid$t15$151035_main10 |
143 | %2F3CA9T_SEGMENT81$1081$1681$1E81$21487main$F110 |
144 | %2832F9T_SEGMENT83i$18FFFFFFFC81$1481$214 |
145 | %07 8 10 10 |
146 | |
147 | explanation: |
148 | %3A6C6480004E56FFFC4E717063B0AEFFFC6D0652AEFFFC60F24E5E4E75 |
149 | ^ ^^ ^ ^-data |
150 | | || +------ 4 char integer 0x8000 |
151 | | |+-------- checksum |
152 | | +--------- type 6 (data record) |
153 | +----------- length 3a chars |
154 | <---------------------- 3a (58 chars) -------------------> |
155 | |
156 | %1B3709T_SEGMENT1108FFFFFFFF |
157 | ^ ^^ ^- 8 character integer 0xffffffff |
158 | | |+- 1 character integer 0 |
159 | | +-- type 1 symbol (section definition) |
160 | +------------ 9 char symbol T_SEGMENT |
161 | |
162 | %2B3AB9T_SEGMENT7Dgcc_compiled$1087hello$c10 |
163 | %373829T_SEGMENT80int$t1$r1$$214741080char$t2$r2$0$12710 |
164 | %373769T_SEGMENT80long$int$t3$r1$$1080unsigned$int$t4$10 |
165 | %373CA9T_SEGMENT80long$unsigned$in1080short$int$t6$r1$10 |
166 | %373049T_SEGMENT80long$long$int$t71080short$unsigned$i10 |
167 | %373A29T_SEGMENT80long$long$unsign1080signed$char$t10$10 |
168 | %373D69T_SEGMENT80unsigned$char$t11080float$t12$r1$4$010 |
169 | %373D19T_SEGMENT80double$t13$r1$8$1080long$double$t14$10 |
170 | %2734D9T_SEGMENT8Bvoid$t15$151035_main10 |
171 | %2F3CA9T_SEGMENT81$1081$1681$1E81$21487main$F110 |
172 | %2832F9T_SEGMENT83i$18FFFFFFFC81$1481$214 |
173 | %0781010 |
174 | |
175 | Turns into |
176 | sac@thepub$ ./objdump -dx -m m68k f |
177 | |
178 | f: file format tekhex |
179 | -----x--- 9/55728 -134219416 Sep 29 15:13 1995 f |
180 | architecture: UNKNOWN!, flags 0x00000010: |
181 | HAS_SYMS |
182 | start address 0x00000000 |
183 | SECTION 0 [D00000000] : size 00020000 vma 00000000 align 2**0 |
184 | ALLOC, LOAD |
185 | SECTION 1 [D00008000] : size 00002001 vma 00008000 align 2**0 |
186 | |
187 | SECTION 2 [T_SEGMENT] : size ffffffff vma 00000000 align 2**0 |
188 | |
189 | SYMBOL TABLE: |
190 | 00000000 g T_SEGMENT gcc_compiled$ |
191 | 00000000 g T_SEGMENT hello$c |
192 | 00000000 g T_SEGMENT int$t1$r1$$21474 |
193 | 00000000 g T_SEGMENT char$t2$r2$0$127 |
194 | 00000000 g T_SEGMENT long$int$t3$r1$$ |
195 | 00000000 g T_SEGMENT unsigned$int$t4$ |
196 | 00000000 g T_SEGMENT long$unsigned$in |
197 | 00000000 g T_SEGMENT short$int$t6$r1$ |
198 | 00000000 g T_SEGMENT long$long$int$t7 |
199 | 00000000 g T_SEGMENT short$unsigned$i |
200 | 00000000 g T_SEGMENT long$long$unsign |
201 | 00000000 g T_SEGMENT signed$char$t10$ |
202 | 00000000 g T_SEGMENT unsigned$char$t1 |
203 | 00000000 g T_SEGMENT float$t12$r1$4$0 |
204 | 00000000 g T_SEGMENT double$t13$r1$8$ |
205 | 00000000 g T_SEGMENT long$double$t14$ |
206 | 00000000 g T_SEGMENT void$t15$15 |
207 | 00000000 g T_SEGMENT _main |
208 | 00000000 g T_SEGMENT $ |
209 | 00000000 g T_SEGMENT $ |
210 | 00000000 g T_SEGMENT $ |
211 | 00000010 g T_SEGMENT $ |
212 | 00000000 g T_SEGMENT main$F1 |
213 | fcffffff g T_SEGMENT i$1 |
214 | 00000000 g T_SEGMENT $ |
215 | 00000010 g T_SEGMENT $ |
216 | |
217 | RELOCATION RECORDS FOR [D00000000]: (none) |
218 | |
219 | RELOCATION RECORDS FOR [D00008000]: (none) |
220 | |
221 | RELOCATION RECORDS FOR [T_SEGMENT]: (none) |
222 | |
223 | Disassembly of section D00000000: |
224 | ... |
225 | 00008000 ($+)7ff0 linkw fp,#-4 |
226 | 00008004 ($+)7ff4 nop |
227 | 00008006 ($+)7ff6 movel #99,d0 |
228 | 00008008 ($+)7ff8 cmpl fp@(-4),d0 |
229 | 0000800c ($+)7ffc blts 00008014 ($+)8004 |
230 | 0000800e ($+)7ffe addql #1,fp@(-4) |
231 | 00008012 ($+)8002 bras 00008006 ($+)7ff6 |
232 | 00008014 ($+)8004 unlk fp |
233 | 00008016 ($+)8006 rts |
234 | ... |
235 | |
236 | */ |
237 | |
238 | static void |
239 | tekhex_init () |
240 | { |
241 | unsigned int i; |
242 | static bfd_boolean inited = FALSE0; |
243 | int val; |
244 | |
245 | if (! inited) |
246 | { |
247 | inited = TRUE1; |
248 | hex_init (); |
249 | val = 0; |
250 | for (i = 0; i < 10; i++) |
251 | { |
252 | sum_block[i + '0'] = val++; |
253 | } |
254 | for (i = 'A'; i <= 'Z'; i++) |
255 | { |
256 | sum_block[i] = val++; |
257 | } |
258 | sum_block['$'] = val++; |
259 | sum_block['%'] = val++; |
260 | sum_block['.'] = val++; |
261 | sum_block['_'] = val++; |
262 | for (i = 'a'; i <= 'z'; i++) |
263 | { |
264 | sum_block[i] = val++; |
265 | } |
266 | } |
267 | } |
268 | |
269 | /* The maximum number of bytes on a line is FF */ |
270 | #define MAXCHUNK0xff 0xff |
271 | /* The number of bytes we fit onto a line on output */ |
272 | #define CHUNK21 21 |
273 | |
274 | /* We cannot output our tekhexords as we see them, we have to glue them |
275 | together, this is done in this structure : */ |
276 | |
277 | struct tekhex_data_list_struct |
278 | { |
279 | unsigned char *data; |
280 | bfd_vma where; |
281 | bfd_size_type size; |
282 | struct tekhex_data_list_struct *next; |
283 | |
284 | }; |
285 | typedef struct tekhex_data_list_struct tekhex_data_list_type; |
286 | |
287 | #define CHUNK_MASK0x1fff 0x1fff |
288 | |
289 | struct data_struct |
290 | { |
291 | char chunk_data[CHUNK_MASK0x1fff + 1]; |
292 | char chunk_init[CHUNK_MASK0x1fff + 1]; |
293 | bfd_vma vma; |
294 | struct data_struct *next; |
295 | }; |
296 | |
297 | typedef struct tekhex_data_struct |
298 | { |
299 | tekhex_data_list_type *head; |
300 | unsigned int type; |
301 | struct tekhex_symbol_struct *symbols; |
302 | struct data_struct *data; |
303 | } tdata_type; |
304 | |
305 | #define enda(x)(x->vma + x->size) (x->vma + x->size) |
306 | |
307 | static bfd_boolean |
308 | getvalue (char **srcp, bfd_vma *valuep) |
309 | { |
310 | char *src = *srcp; |
311 | bfd_vma value = 0; |
312 | unsigned int len; |
313 | |
314 | if (!ISHEX (*src)(((unsigned int) _hex_value[(unsigned char) (*src)]) != 99)) |
315 | return FALSE0; |
316 | |
317 | len = hex_value(*src++)((unsigned int) _hex_value[(unsigned char) (*src++)]); |
318 | |
319 | if (len == 0) |
320 | len = 16; |
321 | while (len--) |
322 | { |
323 | if (!ISHEX (*src)(((unsigned int) _hex_value[(unsigned char) (*src)]) != 99)) |
324 | return FALSE0; |
325 | value = value << 4 | hex_value(*src++)((unsigned int) _hex_value[(unsigned char) (*src++)]); |
326 | } |
327 | *srcp = src; |
328 | *valuep = value; |
329 | return TRUE1; |
330 | } |
331 | |
332 | static bfd_boolean |
333 | getsym (char *dstp, char **srcp, unsigned int *lenp) |
334 | { |
335 | char *src = *srcp; |
336 | unsigned int i; |
337 | unsigned int len; |
338 | |
339 | if (!ISHEX (*src)(((unsigned int) _hex_value[(unsigned char) (*src)]) != 99)) |
340 | return FALSE0; |
341 | |
342 | len = hex_value(*src++)((unsigned int) _hex_value[(unsigned char) (*src++)]); |
343 | if (len == 0) |
344 | len = 16; |
345 | for (i = 0; i < len; i++) |
346 | dstp[i] = src[i]; |
347 | dstp[i] = 0; |
348 | *srcp = src + i; |
349 | *lenp = len; |
350 | return TRUE1; |
351 | } |
352 | |
353 | static struct data_struct * |
354 | find_chunk (abfd, vma) |
355 | bfd *abfd; |
356 | bfd_vma vma; |
357 | { |
358 | struct data_struct *d = abfd->tdata.tekhex_data->data; |
359 | |
360 | vma &= ~CHUNK_MASK0x1fff; |
361 | while (d && (d->vma) != vma) |
362 | { |
363 | d = d->next; |
364 | } |
365 | if (!d) |
366 | { |
367 | /* No chunk for this address, so make one up */ |
368 | d = ((struct data_struct *) |
369 | bfd_zalloc (abfd, (bfd_size_type) sizeof (struct data_struct))); |
370 | |
371 | if (!d) |
372 | return NULL((void*)0); |
373 | |
374 | d->next = abfd->tdata.tekhex_data->data; |
375 | d->vma = vma; |
376 | abfd->tdata.tekhex_data->data = d; |
377 | } |
378 | return d; |
379 | } |
380 | |
381 | static void |
382 | insert_byte (abfd, value, addr) |
383 | bfd *abfd; |
384 | int value; |
385 | bfd_vma addr; |
386 | { |
387 | /* Find the chunk that this byte needs and put it in */ |
388 | struct data_struct *d = find_chunk (abfd, addr); |
389 | |
390 | d->chunk_data[addr & CHUNK_MASK0x1fff] = value; |
391 | d->chunk_init[addr & CHUNK_MASK0x1fff] = 1; |
392 | } |
393 | |
394 | /* The first pass is to find the names of all the sections, and see |
395 | how big the data is */ |
396 | static bfd_boolean |
397 | first_phase (abfd, type, src) |
398 | bfd *abfd; |
399 | int type; |
400 | char *src; |
401 | { |
402 | asection *section = bfd_abs_section_ptr((asection *) &bfd_abs_section); |
403 | unsigned int len; |
404 | bfd_vma val; |
405 | char sym[17]; /* A symbol can only be 16chars long */ |
406 | |
407 | switch (type) |
408 | { |
409 | case '6': |
410 | /* Data record - read it and store it */ |
411 | { |
412 | bfd_vma addr; |
413 | |
414 | if (!getvalue (&src, &addr)) |
415 | return FALSE0; |
416 | |
417 | while (*src) |
418 | { |
419 | insert_byte (abfd, HEX (src)((((unsigned int) _hex_value[(unsigned char) ((src)[0])])<< 4) + ((unsigned int) _hex_value[(unsigned char) ((src)[1])])), addr); |
420 | src += 2; |
421 | addr++; |
422 | } |
423 | } |
424 | |
425 | return TRUE1; |
426 | case '3': |
427 | /* Symbol record, read the segment */ |
428 | if (!getsym (sym, &src, &len)) |
429 | return FALSE0; |
430 | section = bfd_get_section_by_name (abfd, sym); |
431 | if (section == (asection *) NULL((void*)0)) |
432 | { |
433 | char *n = bfd_alloc (abfd, (bfd_size_type) len + 1); |
434 | |
435 | if (!n) |
436 | return FALSE0; |
437 | memcpy (n, sym, len + 1); |
438 | section = bfd_make_section (abfd, n); |
439 | } |
440 | while (*src) |
441 | { |
442 | switch (*src) |
443 | { |
444 | case '1': /* section range */ |
445 | src++; |
446 | if (!getvalue (&src, §ion->vma)) |
447 | return FALSE0; |
448 | if (!getvalue (&src, &val)) |
449 | return FALSE0; |
450 | section->_raw_size = val - section->vma; |
451 | section->flags = SEC_HAS_CONTENTS0x200 | SEC_LOAD0x002 | SEC_ALLOC0x001; |
452 | break; |
453 | case '0': |
454 | case '2': |
455 | case '3': |
456 | case '4': |
457 | case '6': |
458 | case '7': |
459 | case '8': |
460 | /* Symbols, add to section */ |
461 | { |
462 | bfd_size_type amt = sizeof (tekhex_symbol_type); |
463 | tekhex_symbol_type *new = |
464 | (tekhex_symbol_type *) bfd_alloc (abfd, amt); |
465 | char stype = (*src); |
466 | |
467 | if (!new) |
468 | return FALSE0; |
469 | new->symbol.the_bfd = abfd; |
470 | src++; |
471 | abfd->symcount++; |
472 | abfd->flags |= HAS_SYMS0x10; |
473 | new->prev = abfd->tdata.tekhex_data->symbols; |
474 | abfd->tdata.tekhex_data->symbols = new; |
475 | if (!getsym (sym, &src, &len)) |
476 | return FALSE0; |
477 | new->symbol.name = bfd_alloc (abfd, (bfd_size_type) len + 1); |
478 | if (!new->symbol.name) |
479 | return FALSE0; |
480 | memcpy ((char *) (new->symbol.name), sym, len + 1); |
481 | new->symbol.section = section; |
482 | if (stype <= '4') |
483 | new->symbol.flags = (BSF_GLOBAL0x02 | BSF_EXPORT0x02); |
484 | else |
485 | new->symbol.flags = BSF_LOCAL0x01; |
486 | if (!getvalue (&src, &val)) |
487 | return FALSE0; |
488 | new->symbol.value = val - section->vma; |
489 | } |
490 | default: |
491 | return FALSE0; |
492 | } |
493 | } |
494 | } |
495 | |
496 | return TRUE1; |
497 | } |
498 | |
499 | /* Pass over a tekhex, calling one of the above functions on each |
500 | record. */ |
501 | |
502 | static bfd_boolean |
503 | pass_over (abfd, func) |
504 | bfd *abfd; |
505 | bfd_boolean (*func) PARAMS ((bfd *, int, char *))(bfd *, int, char *); |
506 | { |
507 | unsigned int chars_on_line; |
508 | bfd_boolean eof = FALSE0; |
509 | |
510 | /* To the front of the file */ |
511 | if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET0) != 0) |
512 | abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/tekhex.c", 512 , __PRETTY_FUNCTION__); |
513 | while (! eof) |
514 | { |
515 | char buffer[MAXCHUNK0xff]; |
516 | char *src = buffer; |
517 | char type; |
518 | |
519 | /* Find first '%' */ |
520 | eof = (bfd_boolean) (bfd_bread (src, (bfd_size_type) 1, abfd) != 1); |
521 | while (*src != '%' && !eof) |
522 | { |
523 | eof = (bfd_boolean) (bfd_bread (src, (bfd_size_type) 1, abfd) != 1); |
524 | } |
525 | if (eof) |
526 | break; |
527 | src++; |
528 | |
529 | /* Fetch the type and the length and the checksum */ |
530 | if (bfd_bread (src, (bfd_size_type) 5, abfd) != 5) |
531 | abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/tekhex.c", 531 , __PRETTY_FUNCTION__); /* FIXME */ |
532 | |
533 | type = src[2]; |
534 | |
535 | if (!ISHEX (src[0])(((unsigned int) _hex_value[(unsigned char) (src[0])]) != 99) || !ISHEX (src[1])(((unsigned int) _hex_value[(unsigned char) (src[1])]) != 99)) |
536 | break; |
537 | |
538 | chars_on_line = HEX (src)((((unsigned int) _hex_value[(unsigned char) ((src)[0])])<< 4) + ((unsigned int) _hex_value[(unsigned char) ((src)[1])])) - 5; /* Already read five char */ |
539 | |
540 | if (bfd_bread (src, (bfd_size_type) chars_on_line, abfd) != chars_on_line) |
541 | abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/tekhex.c", 541 , __PRETTY_FUNCTION__); /* FIXME */ |
542 | src[chars_on_line] = 0; /* put a null at the end */ |
543 | |
544 | if (!func (abfd, type, src)) |
545 | return FALSE0; |
546 | } |
547 | |
548 | return TRUE1; |
549 | } |
550 | |
551 | static long |
552 | tekhex_canonicalize_symtab (abfd, table) |
553 | bfd *abfd; |
554 | asymbol **table; |
555 | { |
556 | tekhex_symbol_type *p = abfd->tdata.tekhex_data->symbols; |
557 | unsigned int c = bfd_get_symcount (abfd)((abfd)->symcount); |
558 | |
559 | table[c] = 0; |
560 | while (p) |
561 | { |
562 | table[--c] = &(p->symbol); |
563 | p = p->prev; |
564 | } |
565 | |
566 | return bfd_get_symcount (abfd)((abfd)->symcount); |
567 | } |
568 | |
569 | static long |
570 | tekhex_get_symtab_upper_bound (abfd) |
571 | bfd *abfd; |
572 | { |
573 | return (abfd->symcount + 1) * (sizeof (struct tekhex_asymbol_struct *)); |
574 | |
575 | } |
576 | |
577 | static bfd_boolean |
578 | tekhex_mkobject (abfd) |
579 | bfd *abfd; |
580 | { |
581 | tdata_type *tdata; |
582 | |
583 | tdata = (tdata_type *) bfd_alloc (abfd, (bfd_size_type) sizeof (tdata_type)); |
584 | if (!tdata) |
585 | return FALSE0; |
586 | abfd->tdata.tekhex_data = tdata; |
587 | tdata->type = 1; |
588 | tdata->head = (tekhex_data_list_type *) NULL((void*)0); |
589 | tdata->symbols = (struct tekhex_symbol_struct *) NULL((void*)0); |
590 | tdata->data = (struct data_struct *) NULL((void*)0); |
591 | return TRUE1; |
592 | } |
593 | |
594 | /* |
595 | Return TRUE if the file looks like it's in TekHex format. Just look |
596 | for a percent sign and some hex digits */ |
597 | |
598 | static const bfd_target * |
599 | tekhex_object_p (abfd) |
600 | bfd *abfd; |
601 | { |
602 | char b[4]; |
603 | |
604 | tekhex_init (); |
605 | |
606 | if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET0) != 0 |
607 | || bfd_bread (b, (bfd_size_type) 4, abfd) != 4) |
608 | return NULL((void*)0); |
609 | |
610 | if (b[0] != '%' || !ISHEX (b[1])(((unsigned int) _hex_value[(unsigned char) (b[1])]) != 99) || !ISHEX (b[2])(((unsigned int) _hex_value[(unsigned char) (b[2])]) != 99) || !ISHEX (b[3])(((unsigned int) _hex_value[(unsigned char) (b[3])]) != 99)) |
611 | return (const bfd_target *) NULL((void*)0); |
612 | |
613 | tekhex_mkobject (abfd); |
614 | |
615 | if (!pass_over (abfd, first_phase)) |
616 | return NULL((void*)0); |
617 | |
618 | return abfd->xvec; |
619 | } |
620 | |
621 | static void |
622 | move_section_contents (abfd, section, locationp, offset, count, get) |
623 | bfd *abfd; |
624 | asection *section; |
625 | const PTRvoid * locationp; |
626 | file_ptr offset; |
627 | bfd_size_type count; |
628 | bfd_boolean get; |
629 | { |
630 | bfd_vma addr; |
631 | char *location = (char *) locationp; |
632 | bfd_vma prev_number = 1; /* Nothing can have this as a high bit*/ |
633 | struct data_struct *d = (struct data_struct *) NULL((void*)0); |
634 | |
635 | BFD_ASSERT (offset == 0){ if (!(offset == 0)) bfd_assert("/usr/src/gnu/usr.bin/binutils/bfd/tekhex.c" ,635); }; |
636 | for (addr = section->vma; count != 0; count--, addr++) |
637 | { |
638 | /* Get high bits of address. */ |
639 | bfd_vma chunk_number = addr & ~(bfd_vma) CHUNK_MASK0x1fff; |
640 | bfd_vma low_bits = addr & CHUNK_MASK0x1fff; |
641 | |
642 | if (chunk_number != prev_number) |
643 | { |
644 | /* Different chunk, so move pointer */ |
645 | d = find_chunk (abfd, chunk_number); |
646 | } |
647 | |
648 | if (get) |
649 | { |
650 | if (d->chunk_init[low_bits]) |
651 | { |
652 | *location = d->chunk_data[low_bits]; |
653 | } |
654 | else |
655 | { |
656 | *location = 0; |
657 | } |
658 | } |
659 | else |
660 | { |
661 | d->chunk_data[low_bits] = *location; |
662 | d->chunk_init[low_bits] = (*location != 0); |
663 | } |
664 | |
665 | location++; |
666 | |
667 | } |
668 | |
669 | } |
670 | |
671 | static bfd_boolean |
672 | tekhex_get_section_contents (abfd, section, locationp, offset, count) |
673 | bfd *abfd; |
674 | asection *section; |
675 | PTRvoid * locationp; |
676 | file_ptr offset; |
677 | bfd_size_type count; |
678 | { |
679 | if (section->flags & (SEC_LOAD0x002 | SEC_ALLOC0x001)) |
680 | { |
681 | move_section_contents (abfd, section, locationp, offset, count, TRUE1); |
682 | return TRUE1; |
683 | } |
684 | else |
685 | return FALSE0; |
686 | } |
687 | |
688 | static bfd_boolean |
689 | tekhex_set_arch_mach (abfd, arch, machine) |
690 | bfd *abfd; |
691 | enum bfd_architecture arch; |
692 | unsigned long machine; |
693 | { |
694 | return bfd_default_set_arch_mach (abfd, arch, machine); |
695 | } |
696 | |
697 | /* we have to save up all the Tekhexords for a splurge before output, |
698 | */ |
699 | |
700 | static bfd_boolean |
701 | tekhex_set_section_contents (abfd, section, locationp, offset, bytes_to_do) |
702 | bfd *abfd; |
703 | sec_ptr section; |
704 | const PTRvoid * locationp; |
705 | file_ptr offset; |
706 | bfd_size_type bytes_to_do; |
707 | { |
708 | |
709 | if (! abfd->output_has_begun) |
710 | { |
711 | /* The first time around, allocate enough sections to hold all the chunks */ |
712 | asection *s = abfd->sections; |
Value stored to 's' during its initialization is never read | |
713 | bfd_vma vma; |
714 | |
715 | for (s = abfd->sections; s; s = s->next) |
716 | { |
717 | if (s->flags & SEC_LOAD0x002) |
718 | { |
719 | for (vma = s->vma & ~(bfd_vma) CHUNK_MASK0x1fff; |
720 | vma < s->vma + s->_raw_size; |
721 | vma += CHUNK_MASK0x1fff) |
722 | find_chunk (abfd, vma); |
723 | } |
724 | } |
725 | |
726 | } |
727 | if (section->flags & (SEC_LOAD0x002 | SEC_ALLOC0x001)) |
728 | { |
729 | move_section_contents (abfd, section, locationp, offset, bytes_to_do, |
730 | FALSE0); |
731 | return TRUE1; |
732 | } |
733 | else |
734 | return FALSE0; |
735 | |
736 | } |
737 | |
738 | static void |
739 | writevalue (dst, value) |
740 | char **dst; |
741 | bfd_vma value; |
742 | { |
743 | char *p = *dst; |
744 | int len; |
745 | int shift; |
746 | |
747 | for (len = 8, shift = 28; shift; shift -= 4, len--) |
748 | { |
749 | if ((value >> shift) & 0xf) |
750 | { |
751 | *p++ = len + '0'; |
752 | while (len) |
753 | { |
754 | *p++ = digs[(value >> shift) & 0xf]; |
755 | shift -= 4; |
756 | len--; |
757 | } |
758 | *dst = p; |
759 | return; |
760 | |
761 | } |
762 | } |
763 | *p++ = '1'; |
764 | *p++ = '0'; |
765 | *dst = p; |
766 | } |
767 | |
768 | static void |
769 | writesym (dst, sym) |
770 | char **dst; |
771 | const char *sym; |
772 | { |
773 | char *p = *dst; |
774 | int len = (sym ? strlen (sym) : 0); |
775 | |
776 | if (len >= 16) |
777 | { |
778 | *p++ = '0'; |
779 | len = 16; |
780 | } |
781 | |
782 | else |
783 | { |
784 | if (len == 0) |
785 | { |
786 | *p++ = '1'; |
787 | sym = "$"; |
788 | len = 1; |
789 | } |
790 | else |
791 | { |
792 | *p++ = digs[len]; |
793 | } |
794 | } |
795 | |
796 | while (len--) |
797 | { |
798 | *p++ = *sym++; |
799 | } |
800 | *dst = p; |
801 | } |
802 | |
803 | static void |
804 | out (abfd, type, start, end) |
805 | bfd *abfd; |
806 | int type; |
807 | char *start; |
808 | char *end; |
809 | { |
810 | int sum = 0; |
811 | char *s; |
812 | char front[6]; |
813 | bfd_size_type wrlen; |
814 | |
815 | front[0] = '%'; |
816 | TOHEX (front + 1, end - start + 5)(front + 1)[1] = digs[(end - start + 5) & 0xf]; (front + 1 )[0] = digs[((end - start + 5)>>4)&0xf];; |
817 | front[3] = type; |
818 | |
819 | for (s = start; s < end; s++) |
820 | { |
821 | sum += sum_block[(unsigned char) *s]; |
822 | } |
823 | |
824 | sum += sum_block[(unsigned char) front[1]]; /* length */ |
825 | sum += sum_block[(unsigned char) front[2]]; |
826 | sum += sum_block[(unsigned char) front[3]]; /* type */ |
827 | TOHEX (front + 4, sum)(front + 4)[1] = digs[(sum) & 0xf]; (front + 4)[0] = digs [((sum)>>4)&0xf];; |
828 | if (bfd_bwrite (front, (bfd_size_type) 6, abfd) != 6) |
829 | abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/tekhex.c", 829 , __PRETTY_FUNCTION__); |
830 | end[0] = '\n'; |
831 | wrlen = end - start + 1; |
832 | if (bfd_bwrite (start, wrlen, abfd) != wrlen) |
833 | abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/tekhex.c", 833 , __PRETTY_FUNCTION__); |
834 | } |
835 | |
836 | static bfd_boolean |
837 | tekhex_write_object_contents (abfd) |
838 | bfd *abfd; |
839 | { |
840 | int bytes_written; |
841 | char buffer[100]; |
842 | asymbol **p; |
843 | asection *s; |
844 | struct data_struct *d; |
845 | |
846 | tekhex_init (); |
847 | |
848 | bytes_written = 0; |
849 | |
850 | /* And the raw data */ |
851 | for (d = abfd->tdata.tekhex_data->data; |
852 | d != (struct data_struct *) NULL((void*)0); |
853 | d = d->next) |
854 | { |
855 | int low; |
856 | |
857 | const int span = 32; |
858 | int addr; |
859 | |
860 | /* Write it in blocks of 32 bytes */ |
861 | |
862 | for (addr = 0; addr < CHUNK_MASK0x1fff + 1; addr += span) |
863 | { |
864 | int need = 0; |
865 | |
866 | /* Check to see if necessary */ |
867 | for (low = 0; !need && low < span; low++) |
868 | { |
869 | if (d->chunk_init[addr + low]) |
870 | need = 1; |
871 | } |
872 | if (need) |
873 | { |
874 | char *dst = buffer; |
875 | |
876 | writevalue (&dst, addr + d->vma); |
877 | for (low = 0; low < span; low++) |
878 | { |
879 | TOHEX (dst, d->chunk_data[addr + low])(dst)[1] = digs[(d->chunk_data[addr + low]) & 0xf]; (dst )[0] = digs[((d->chunk_data[addr + low])>>4)&0xf ];; |
880 | dst += 2; |
881 | } |
882 | out (abfd, '6', buffer, dst); |
883 | } |
884 | } |
885 | } |
886 | /* write all the section headers for the sections */ |
887 | for (s = abfd->sections; s != (asection *) NULL((void*)0); s = s->next) |
888 | { |
889 | char *dst = buffer; |
890 | |
891 | writesym (&dst, s->name); |
892 | *dst++ = '1'; |
893 | writevalue (&dst, s->vma); |
894 | writevalue (&dst, s->vma + s->_raw_size); |
895 | out (abfd, '3', buffer, dst); |
896 | } |
897 | |
898 | /* And the symbols */ |
899 | if (abfd->outsymbols) |
900 | { |
901 | for (p = abfd->outsymbols; *p; p++) |
902 | { |
903 | int section_code = bfd_decode_symclass (*p); |
904 | |
905 | if (section_code != '?') |
906 | { /* do not include debug symbols */ |
907 | asymbol *sym = *p; |
908 | char *dst = buffer; |
909 | |
910 | writesym (&dst, sym->section->name); |
911 | |
912 | switch (section_code) |
913 | { |
914 | case 'A': |
915 | *dst++ = '2'; |
916 | break; |
917 | case 'a': |
918 | *dst++ = '6'; |
919 | break; |
920 | case 'D': |
921 | case 'B': |
922 | case 'O': |
923 | *dst++ = '4'; |
924 | break; |
925 | case 'd': |
926 | case 'b': |
927 | case 'o': |
928 | *dst++ = '8'; |
929 | break; |
930 | case 'T': |
931 | *dst++ = '3'; |
932 | break; |
933 | case 't': |
934 | *dst++ = '7'; |
935 | break; |
936 | case 'C': |
937 | case 'U': |
938 | bfd_set_error (bfd_error_wrong_format); |
939 | return FALSE0; |
940 | } |
941 | |
942 | writesym (&dst, sym->name); |
943 | writevalue (&dst, sym->value + sym->section->vma); |
944 | out (abfd, '3', buffer, dst); |
945 | } |
946 | } |
947 | } |
948 | |
949 | /* And the terminator */ |
950 | if (bfd_bwrite ("%0781010\n", (bfd_size_type) 9, abfd) != 9) |
951 | abort ()_bfd_abort ("/usr/src/gnu/usr.bin/binutils/bfd/tekhex.c", 951 , __PRETTY_FUNCTION__); |
952 | return TRUE1; |
953 | } |
954 | |
955 | static int |
956 | tekhex_sizeof_headers (abfd, exec) |
957 | bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__)); |
958 | bfd_boolean exec ATTRIBUTE_UNUSED__attribute__ ((__unused__)); |
959 | |
960 | { |
961 | return 0; |
962 | } |
963 | |
964 | static asymbol * |
965 | tekhex_make_empty_symbol (abfd) |
966 | bfd *abfd; |
967 | { |
968 | bfd_size_type amt = sizeof (struct tekhex_symbol_struct); |
969 | tekhex_symbol_type *new = (tekhex_symbol_type *) bfd_zalloc (abfd, amt); |
970 | |
971 | if (!new) |
972 | return NULL((void*)0); |
973 | new->symbol.the_bfd = abfd; |
974 | new->prev = (struct tekhex_symbol_struct *) NULL((void*)0); |
975 | return &(new->symbol); |
976 | } |
977 | |
978 | static void |
979 | tekhex_get_symbol_info (ignore_abfd, symbol, ret) |
980 | bfd *ignore_abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__)); |
981 | asymbol *symbol; |
982 | symbol_info *ret; |
983 | { |
984 | bfd_symbol_info (symbol, ret); |
985 | } |
986 | |
987 | static void |
988 | tekhex_print_symbol (abfd, filep, symbol, how) |
989 | bfd *abfd; |
990 | PTRvoid * filep; |
991 | asymbol *symbol; |
992 | bfd_print_symbol_type how; |
993 | { |
994 | FILE *file = (FILE *) filep; |
995 | |
996 | switch (how) |
997 | { |
998 | case bfd_print_symbol_name: |
999 | fprintf (file, "%s", symbol->name); |
1000 | break; |
1001 | case bfd_print_symbol_more: |
1002 | break; |
1003 | |
1004 | case bfd_print_symbol_all: |
1005 | { |
1006 | const char *section_name = symbol->section->name; |
1007 | |
1008 | bfd_print_symbol_vandf (abfd, (PTRvoid *) file, symbol); |
1009 | |
1010 | fprintf (file, " %-5s %s", |
1011 | section_name, |
1012 | symbol->name); |
1013 | } |
1014 | } |
1015 | } |
1016 | |
1017 | #define tekhex_close_and_cleanupbfd_true _bfd_generic_close_and_cleanupbfd_true |
1018 | #define tekhex_bfd_free_cached_infobfd_true _bfd_generic_bfd_free_cached_infobfd_true |
1019 | #define tekhex_new_section_hook((bfd_boolean (*) (bfd *, asection *)) bfd_true) _bfd_generic_new_section_hook((bfd_boolean (*) (bfd *, asection *)) bfd_true) |
1020 | |
1021 | #define tekhex_bfd_is_local_label_namebfd_generic_is_local_label_name bfd_generic_is_local_label_name |
1022 | #define tekhex_get_lineno((alent *(*) (bfd *, asymbol *)) bfd_nullvoidptr) _bfd_nosymbols_get_lineno((alent *(*) (bfd *, asymbol *)) bfd_nullvoidptr) |
1023 | #define tekhex_find_nearest_line((bfd_boolean (*) (bfd *, asection *, asymbol **, bfd_vma, const char **, const char **, unsigned int *)) bfd_false) _bfd_nosymbols_find_nearest_line((bfd_boolean (*) (bfd *, asection *, asymbol **, bfd_vma, const char **, const char **, unsigned int *)) bfd_false) |
1024 | #define tekhex_bfd_make_debug_symbol((asymbol *(*) (bfd *, void *, unsigned long)) bfd_nullvoidptr ) _bfd_nosymbols_bfd_make_debug_symbol((asymbol *(*) (bfd *, void *, unsigned long)) bfd_nullvoidptr ) |
1025 | #define tekhex_read_minisymbols_bfd_generic_read_minisymbols _bfd_generic_read_minisymbols |
1026 | #define tekhex_minisymbol_to_symbol_bfd_generic_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol |
1027 | |
1028 | #define tekhex_bfd_get_relocated_section_contentsbfd_generic_get_relocated_section_contents \ |
1029 | bfd_generic_get_relocated_section_contents |
1030 | #define tekhex_bfd_relax_sectionbfd_generic_relax_section bfd_generic_relax_section |
1031 | #define tekhex_bfd_gc_sectionsbfd_generic_gc_sections bfd_generic_gc_sections |
1032 | #define tekhex_bfd_merge_sectionsbfd_generic_merge_sections bfd_generic_merge_sections |
1033 | #define tekhex_bfd_discard_groupbfd_generic_discard_group bfd_generic_discard_group |
1034 | #define tekhex_bfd_link_hash_table_create_bfd_generic_link_hash_table_create _bfd_generic_link_hash_table_create |
1035 | #define tekhex_bfd_link_hash_table_free_bfd_generic_link_hash_table_free _bfd_generic_link_hash_table_free |
1036 | #define tekhex_bfd_link_add_symbols_bfd_generic_link_add_symbols _bfd_generic_link_add_symbols |
1037 | #define tekhex_bfd_link_just_syms_bfd_generic_link_just_syms _bfd_generic_link_just_syms |
1038 | #define tekhex_bfd_final_link_bfd_generic_final_link _bfd_generic_final_link |
1039 | #define tekhex_bfd_link_split_section_bfd_generic_link_split_section _bfd_generic_link_split_section |
1040 | |
1041 | #define tekhex_get_section_contents_in_window_bfd_generic_get_section_contents_in_window \ |
1042 | _bfd_generic_get_section_contents_in_window |
1043 | |
1044 | const bfd_target tekhex_vec = |
1045 | { |
1046 | "tekhex", /* name */ |
1047 | bfd_target_tekhex_flavour, |
1048 | BFD_ENDIAN_UNKNOWN, /* target byte order */ |
1049 | BFD_ENDIAN_UNKNOWN, /* target headers byte order */ |
1050 | (EXEC_P0x02 | /* object flags */ |
1051 | HAS_SYMS0x10 | HAS_LINENO0x04 | HAS_DEBUG0x08 | HAS_RELOC0x01 | HAS_LOCALS0x20 | |
1052 | WP_TEXT0x80 | D_PAGED0x100), |
1053 | (SEC_CODE0x020 | SEC_DATA0x040 | SEC_ROM0x080 | SEC_HAS_CONTENTS0x200 |
1054 | | SEC_ALLOC0x001 | SEC_LOAD0x002 | SEC_RELOC0x004), /* section flags */ |
1055 | 0, /* leading underscore */ |
1056 | ' ', /* ar_pad_char */ |
1057 | 16, /* ar_max_namelen */ |
1058 | bfd_getb64, bfd_getb_signed_64, bfd_putb64, |
1059 | bfd_getb32, bfd_getb_signed_32, bfd_putb32, |
1060 | bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */ |
1061 | bfd_getb64, bfd_getb_signed_64, bfd_putb64, |
1062 | bfd_getb32, bfd_getb_signed_32, bfd_putb32, |
1063 | bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */ |
1064 | |
1065 | { |
1066 | _bfd_dummy_target, |
1067 | tekhex_object_p, /* bfd_check_format */ |
1068 | _bfd_dummy_target, |
1069 | _bfd_dummy_target, |
1070 | }, |
1071 | { |
1072 | bfd_false, |
1073 | tekhex_mkobject, |
1074 | _bfd_generic_mkarchive, |
1075 | bfd_false, |
1076 | }, |
1077 | { /* bfd_write_contents */ |
1078 | bfd_false, |
1079 | tekhex_write_object_contents, |
1080 | _bfd_write_archive_contents, |
1081 | bfd_false, |
1082 | }, |
1083 | |
1084 | BFD_JUMP_TABLE_GENERIC (tekhex)bfd_true, bfd_true, ((bfd_boolean (*) (bfd *, asection *)) bfd_true ), tekhex_get_section_contents, _bfd_generic_get_section_contents_in_window, |
1085 | BFD_JUMP_TABLE_COPY (_bfd_generic)((bfd_boolean (*) (bfd *, bfd *)) bfd_true), ((bfd_boolean (* ) (bfd *, bfd *)) bfd_true), ((bfd_boolean (*) (bfd *, asection *, bfd *, asection *)) bfd_true), ((bfd_boolean (*) (bfd *, asymbol *, bfd *, asymbol *)) bfd_true), ((bfd_boolean (*) (bfd *, flagword )) bfd_true), ((bfd_boolean (*) (bfd *, void *)) bfd_true), |
1086 | BFD_JUMP_TABLE_CORE (_bfd_nocore)_bfd_nocore_core_file_failing_command, _bfd_nocore_core_file_failing_signal , _bfd_nocore_core_file_matches_executable_p, |
1087 | BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive)bfd_false, bfd_false, ((bfd_boolean (*) (bfd *, char **, bfd_size_type *, const char **)) bfd_false), ((void (*) (bfd *, const char *, char *)) bfd_void), ((bfd_boolean (*) (bfd *, unsigned int , struct orl *, unsigned int, int)) bfd_false), bfd_nullvoidptr , ((bfd *(*) (bfd *, bfd *)) bfd_nullvoidptr), ((bfd *(*) (bfd *, symindex)) bfd_nullvoidptr), bfd_generic_stat_arch_elt, bfd_false, |
1088 | BFD_JUMP_TABLE_SYMBOLS (tekhex)tekhex_get_symtab_upper_bound, tekhex_canonicalize_symtab, tekhex_make_empty_symbol , tekhex_print_symbol, tekhex_get_symbol_info, bfd_generic_is_local_label_name , ((alent *(*) (bfd *, asymbol *)) bfd_nullvoidptr), ((bfd_boolean (*) (bfd *, asection *, asymbol **, bfd_vma, const char **, const char **, unsigned int *)) bfd_false), ((asymbol *(*) (bfd *, void *, unsigned long)) bfd_nullvoidptr), _bfd_generic_read_minisymbols , _bfd_generic_minisymbol_to_symbol, |
1089 | BFD_JUMP_TABLE_RELOCS (_bfd_norelocs)((long (*) (bfd *, asection *)) _bfd_n1), ((long (*) (bfd *, asection *, arelent **, asymbol **)) _bfd_n1), ((reloc_howto_type *(* ) (bfd *, bfd_reloc_code_real_type)) bfd_nullvoidptr), |
1090 | BFD_JUMP_TABLE_WRITE (tekhex)tekhex_set_arch_mach, tekhex_set_section_contents, |
1091 | BFD_JUMP_TABLE_LINK (tekhex)tekhex_sizeof_headers, bfd_generic_get_relocated_section_contents , bfd_generic_relax_section, _bfd_generic_link_hash_table_create , _bfd_generic_link_hash_table_free, _bfd_generic_link_add_symbols , _bfd_generic_link_just_syms, _bfd_generic_final_link, _bfd_generic_link_split_section , bfd_generic_gc_sections, bfd_generic_merge_sections, bfd_generic_discard_group, |
1092 | BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic)_bfd_n1, ((long (*) (bfd *, asymbol **)) _bfd_n1), _bfd_n1, ( (long (*) (bfd *, arelent **, asymbol **)) _bfd_n1), |
1093 | |
1094 | NULL((void*)0), |
1095 | |
1096 | (PTRvoid *) 0 |
1097 | }; |