File: | src/gnu/usr.bin/binutils/bfd/ihex.c |
Warning: | line 612, column 7 Value stored to 'addr' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* BFD back-end for Intel Hex objects. |
2 | Copyright 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003 |
3 | Free Software Foundation, Inc. |
4 | Written by Ian Lance Taylor of Cygnus Support <ian@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 | /* This is what Intel Hex files look like: |
23 | |
24 | 1. INTEL FORMATS |
25 | |
26 | A. Intel 1 |
27 | |
28 | 16-bit address-field format, for files 64k bytes in length or less. |
29 | |
30 | DATA RECORD |
31 | Byte 1 Header = colon(:) |
32 | 2..3 The number of data bytes in hex notation |
33 | 4..5 High byte of the record load address |
34 | 6..7 Low byte of the record load address |
35 | 8..9 Record type, must be "00" |
36 | 10..x Data bytes in hex notation: |
37 | x = (number of bytes - 1) * 2 + 11 |
38 | x+1..x+2 Checksum in hex notation |
39 | x+3..x+4 Carriage return, line feed |
40 | |
41 | END RECORD |
42 | Byte 1 Header = colon (:) |
43 | 2..3 The byte count, must be "00" |
44 | 4..7 Transfer-address (usually "0000") |
45 | the jump-to address, execution start address |
46 | 8..9 Record type, must be "01" |
47 | 10..11 Checksum, in hex notation |
48 | 12..13 Carriage return, line feed |
49 | |
50 | B. INTEL 2 |
51 | |
52 | MCS-86 format, using a 20-bit address for files larger than 64K bytes. |
53 | |
54 | DATA RECORD |
55 | Byte 1 Header = colon (:) |
56 | 2..3 The byte count of this record, hex notation |
57 | 4..5 High byte of the record load address |
58 | 6..7 Low byte of the record load address |
59 | 8..9 Record type, must be "00" |
60 | 10..x The data bytes in hex notation: |
61 | x = (number of data bytes - 1) * 2 + 11 |
62 | x+1..x+2 Checksum in hex notation |
63 | x+3..x+4 Carriage return, line feed |
64 | |
65 | EXTENDED ADDRESS RECORD |
66 | Byte 1 Header = colon(:) |
67 | 2..3 The byte count, must be "02" |
68 | 4..7 Load address, must be "0000" |
69 | 8..9 Record type, must be "02" |
70 | 10..11 High byte of the offset address |
71 | 12..13 Low byte of the offset address |
72 | 14..15 Checksum in hex notation |
73 | 16..17 Carriage return, line feed |
74 | |
75 | The checksums are the two's complement of the 8-bit sum |
76 | without carry of the byte count, offset address, and the |
77 | record type. |
78 | |
79 | START ADDRESS RECORD |
80 | Byte 1 Header = colon (:) |
81 | 2..3 The byte count, must be "04" |
82 | 4..7 Load address, must be "0000" |
83 | 8..9 Record type, must be "03" |
84 | 10..13 8086 CS value |
85 | 14..17 8086 IP value |
86 | 18..19 Checksum in hex notation |
87 | 20..21 Carriage return, line feed |
88 | |
89 | Another document reports these additional types: |
90 | |
91 | EXTENDED LINEAR ADDRESS RECORD |
92 | Byte 1 Header = colon (:) |
93 | 2..3 The byte count, must be "02" |
94 | 4..7 Load address, must be "0000" |
95 | 8..9 Record type, must be "04" |
96 | 10..13 Upper 16 bits of address of subsequent records |
97 | 14..15 Checksum in hex notation |
98 | 16..17 Carriage return, line feed |
99 | |
100 | START LINEAR ADDRESS RECORD |
101 | Byte 1 Header = colon (:) |
102 | 2..3 The byte count, must be "02" |
103 | 4..7 Load address, must be "0000" |
104 | 8..9 Record type, must be "05" |
105 | 10..13 Upper 16 bits of start address |
106 | 14..15 Checksum in hex notation |
107 | 16..17 Carriage return, line feed |
108 | |
109 | The MRI compiler uses this, which is a repeat of type 5: |
110 | |
111 | EXTENDED START RECORD |
112 | Byte 1 Header = colon (:) |
113 | 2..3 The byte count, must be "04" |
114 | 4..7 Load address, must be "0000" |
115 | 8..9 Record type, must be "05" |
116 | 10..13 Upper 16 bits of start address |
117 | 14..17 Lower 16 bits of start address |
118 | 18..19 Checksum in hex notation |
119 | 20..21 Carriage return, line feed |
120 | */ |
121 | |
122 | #include "bfd.h" |
123 | #include "sysdep.h" |
124 | #include "libbfd.h" |
125 | #include "libiberty.h" |
126 | #include "safe-ctype.h" |
127 | |
128 | static void ihex_init |
129 | PARAMS ((void))(void); |
130 | static bfd_boolean ihex_mkobject |
131 | PARAMS ((bfd *))(bfd *); |
132 | static INLINE__inline__ int ihex_get_byte |
133 | PARAMS ((bfd *, bfd_boolean *))(bfd *, bfd_boolean *); |
134 | static void ihex_bad_byte |
135 | PARAMS ((bfd *, unsigned int, int, bfd_boolean))(bfd *, unsigned int, int, bfd_boolean); |
136 | static bfd_boolean ihex_scan |
137 | PARAMS ((bfd *))(bfd *); |
138 | static const bfd_target *ihex_object_p |
139 | PARAMS ((bfd *))(bfd *); |
140 | static bfd_boolean ihex_read_section |
141 | PARAMS ((bfd *, asection *, bfd_byte *))(bfd *, asection *, bfd_byte *); |
142 | static bfd_boolean ihex_get_section_contents |
143 | PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type))(bfd *, asection *, void *, file_ptr, bfd_size_type); |
144 | static bfd_boolean ihex_set_section_contents |
145 | PARAMS ((bfd *, asection *, const PTR, file_ptr, bfd_size_type))(bfd *, asection *, const void *, file_ptr, bfd_size_type); |
146 | static bfd_boolean ihex_write_record |
147 | PARAMS ((bfd *, size_t, unsigned int, unsigned int, bfd_byte *))(bfd *, size_t, unsigned int, unsigned int, bfd_byte *); |
148 | static bfd_boolean ihex_write_object_contents |
149 | PARAMS ((bfd *))(bfd *); |
150 | static bfd_boolean ihex_set_arch_mach |
151 | PARAMS ((bfd *, enum bfd_architecture, unsigned long))(bfd *, enum bfd_architecture, unsigned long); |
152 | static int ihex_sizeof_headers |
153 | PARAMS ((bfd *, bfd_boolean))(bfd *, bfd_boolean); |
154 | |
155 | /* The number of bytes we put on one line during output. */ |
156 | |
157 | #define CHUNK16 16 |
158 | |
159 | /* Macros for converting between hex and binary. */ |
160 | |
161 | #define NIBBLE(x)(((unsigned int) _hex_value[(unsigned char) (x)])) (hex_value (x)((unsigned int) _hex_value[(unsigned char) (x)])) |
162 | #define HEX2(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])]))) |
163 | #define HEX4(buffer)(((((((unsigned int) _hex_value[(unsigned char) ((buffer)[0]) ])) << 4) + (((unsigned int) _hex_value[(unsigned char) ((buffer)[1])]))) << 8) + (((((unsigned int) _hex_value [(unsigned char) (((buffer) + 2)[0])])) << 4) + (((unsigned int) _hex_value[(unsigned char) (((buffer) + 2)[1])])))) ((HEX2 (buffer)(((((unsigned int) _hex_value[(unsigned char) ((buffer)[0])]) ) << 4) + (((unsigned int) _hex_value[(unsigned char) ( (buffer)[1])]))) << 8) + HEX2 ((buffer) + 2)(((((unsigned int) _hex_value[(unsigned char) (((buffer) + 2) [0])])) << 4) + (((unsigned int) _hex_value[(unsigned char ) (((buffer) + 2)[1])])))) |
164 | #define ISHEX(x)((((unsigned int) _hex_value[(unsigned char) (x)]) != 99)) (hex_p (x)(((unsigned int) _hex_value[(unsigned char) (x)]) != 99)) |
165 | |
166 | /* When we write out an ihex value, the values can not be output as |
167 | they are seen. Instead, we hold them in memory in this structure. */ |
168 | |
169 | struct ihex_data_list |
170 | { |
171 | struct ihex_data_list *next; |
172 | bfd_byte *data; |
173 | bfd_vma where; |
174 | bfd_size_type size; |
175 | }; |
176 | |
177 | /* The ihex tdata information. */ |
178 | |
179 | struct ihex_data_struct |
180 | { |
181 | struct ihex_data_list *head; |
182 | struct ihex_data_list *tail; |
183 | }; |
184 | |
185 | /* Initialize by filling in the hex conversion array. */ |
186 | |
187 | static void |
188 | ihex_init () |
189 | { |
190 | static bfd_boolean inited; |
191 | |
192 | if (! inited) |
193 | { |
194 | inited = TRUE1; |
195 | hex_init (); |
196 | } |
197 | } |
198 | |
199 | /* Create an ihex object. */ |
200 | |
201 | static bfd_boolean |
202 | ihex_mkobject (abfd) |
203 | bfd *abfd; |
204 | { |
205 | struct ihex_data_struct *tdata; |
206 | bfd_size_type amt = sizeof (struct ihex_data_struct); |
207 | |
208 | tdata = (struct ihex_data_struct *) bfd_alloc (abfd, amt); |
209 | if (tdata == NULL((void*)0)) |
210 | return FALSE0; |
211 | |
212 | abfd->tdata.ihex_data = tdata; |
213 | tdata->head = NULL((void*)0); |
214 | tdata->tail = NULL((void*)0); |
215 | return TRUE1; |
216 | } |
217 | |
218 | /* Read a byte from a BFD. Set *ERRORPTR if an error occurred. |
219 | Return EOF on error or end of file. */ |
220 | |
221 | static INLINE__inline__ int |
222 | ihex_get_byte (abfd, errorptr) |
223 | bfd *abfd; |
224 | bfd_boolean *errorptr; |
225 | { |
226 | bfd_byte c; |
227 | |
228 | if (bfd_bread (&c, (bfd_size_type) 1, abfd) != 1) |
229 | { |
230 | if (bfd_get_error () != bfd_error_file_truncated) |
231 | *errorptr = TRUE1; |
232 | return EOF(-1); |
233 | } |
234 | |
235 | return (int) (c & 0xff); |
236 | } |
237 | |
238 | /* Report a problem in an Intel Hex file. */ |
239 | |
240 | static void |
241 | ihex_bad_byte (abfd, lineno, c, error) |
242 | bfd *abfd; |
243 | unsigned int lineno; |
244 | int c; |
245 | bfd_boolean error; |
246 | { |
247 | if (c == EOF(-1)) |
248 | { |
249 | if (! error) |
250 | bfd_set_error (bfd_error_file_truncated); |
251 | } |
252 | else |
253 | { |
254 | char buf[10]; |
255 | |
256 | if (! ISPRINT (c)(_sch_istable[(c) & 0xff] & (unsigned short)(_sch_isprint ))) |
257 | sprintf (buf, "\\%03o", (unsigned int) c); |
258 | else |
259 | { |
260 | buf[0] = c; |
261 | buf[1] = '\0'; |
262 | } |
263 | (*_bfd_error_handler) |
264 | (_("%s:%d: unexpected character `%s' in Intel Hex file\n")("%s:%d: unexpected character `%s' in Intel Hex file\n"), |
265 | bfd_archive_filename (abfd), lineno, buf); |
266 | bfd_set_error (bfd_error_bad_value); |
267 | } |
268 | } |
269 | |
270 | /* Read an Intel hex file and turn it into sections. We create a new |
271 | section for each contiguous set of bytes. */ |
272 | |
273 | static bfd_boolean |
274 | ihex_scan (abfd) |
275 | bfd *abfd; |
276 | { |
277 | bfd_vma segbase; |
278 | bfd_vma extbase; |
279 | asection *sec; |
280 | unsigned int lineno; |
281 | bfd_boolean error; |
282 | bfd_byte *buf = NULL((void*)0); |
283 | size_t bufsize; |
284 | int c; |
285 | |
286 | if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET0) != 0) |
287 | goto error_return; |
288 | |
289 | abfd->start_address = 0; |
290 | |
291 | segbase = 0; |
292 | extbase = 0; |
293 | sec = NULL((void*)0); |
294 | lineno = 1; |
295 | error = FALSE0; |
296 | bufsize = 0; |
297 | |
298 | while ((c = ihex_get_byte (abfd, &error)) != EOF(-1)) |
299 | { |
300 | if (c == '\r') |
301 | continue; |
302 | else if (c == '\n') |
303 | { |
304 | ++lineno; |
305 | continue; |
306 | } |
307 | else if (c != ':') |
308 | { |
309 | ihex_bad_byte (abfd, lineno, c, error); |
310 | goto error_return; |
311 | } |
312 | else |
313 | { |
314 | file_ptr pos; |
315 | char hdr[8]; |
316 | unsigned int i; |
317 | unsigned int len; |
318 | bfd_vma addr; |
319 | unsigned int type; |
320 | unsigned int chars; |
321 | unsigned int chksum; |
322 | |
323 | /* This is a data record. */ |
324 | pos = bfd_tell (abfd) - 1; |
325 | |
326 | /* Read the header bytes. */ |
327 | if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8) |
328 | goto error_return; |
329 | |
330 | for (i = 0; i < 8; i++) |
331 | { |
332 | if (! ISHEX (hdr[i])((((unsigned int) _hex_value[(unsigned char) (hdr[i])]) != 99 ))) |
333 | { |
334 | ihex_bad_byte (abfd, lineno, hdr[i], error); |
335 | goto error_return; |
336 | } |
337 | } |
338 | |
339 | len = HEX2 (hdr)(((((unsigned int) _hex_value[(unsigned char) ((hdr)[0])])) << 4) + (((unsigned int) _hex_value[(unsigned char) ((hdr)[1])] ))); |
340 | addr = HEX4 (hdr + 2)(((((((unsigned int) _hex_value[(unsigned char) ((hdr + 2)[0] )])) << 4) + (((unsigned int) _hex_value[(unsigned char ) ((hdr + 2)[1])]))) << 8) + (((((unsigned int) _hex_value [(unsigned char) (((hdr + 2) + 2)[0])])) << 4) + (((unsigned int) _hex_value[(unsigned char) (((hdr + 2) + 2)[1])])))); |
341 | type = HEX2 (hdr + 6)(((((unsigned int) _hex_value[(unsigned char) ((hdr + 6)[0])] )) << 4) + (((unsigned int) _hex_value[(unsigned char) ( (hdr + 6)[1])]))); |
342 | |
343 | /* Read the data bytes. */ |
344 | chars = len * 2 + 2; |
345 | if (chars >= bufsize) |
346 | { |
347 | buf = (bfd_byte *) bfd_realloc (buf, (bfd_size_type) chars); |
348 | if (buf == NULL((void*)0)) |
349 | goto error_return; |
350 | bufsize = chars; |
351 | } |
352 | |
353 | if (bfd_bread (buf, (bfd_size_type) chars, abfd) != chars) |
354 | goto error_return; |
355 | |
356 | for (i = 0; i < chars; i++) |
357 | { |
358 | if (! ISHEX (buf[i])((((unsigned int) _hex_value[(unsigned char) (buf[i])]) != 99 ))) |
359 | { |
360 | ihex_bad_byte (abfd, lineno, hdr[i], error); |
361 | goto error_return; |
362 | } |
363 | } |
364 | |
365 | /* Check the checksum. */ |
366 | chksum = len + addr + (addr >> 8) + type; |
367 | for (i = 0; i < len; i++) |
368 | chksum += HEX2 (buf + 2 * i)(((((unsigned int) _hex_value[(unsigned char) ((buf + 2 * i)[ 0])])) << 4) + (((unsigned int) _hex_value[(unsigned char ) ((buf + 2 * i)[1])]))); |
369 | if (((- chksum) & 0xff) != (unsigned int) HEX2 (buf + 2 * i)(((((unsigned int) _hex_value[(unsigned char) ((buf + 2 * i)[ 0])])) << 4) + (((unsigned int) _hex_value[(unsigned char ) ((buf + 2 * i)[1])])))) |
370 | { |
371 | (*_bfd_error_handler) |
372 | (_("%s:%u: bad checksum in Intel Hex file (expected %u, found %u)")("%s:%u: bad checksum in Intel Hex file (expected %u, found %u)" ), |
373 | bfd_archive_filename (abfd), lineno, |
374 | (- chksum) & 0xff, (unsigned int) HEX2 (buf + 2 * i)(((((unsigned int) _hex_value[(unsigned char) ((buf + 2 * i)[ 0])])) << 4) + (((unsigned int) _hex_value[(unsigned char ) ((buf + 2 * i)[1])])))); |
375 | bfd_set_error (bfd_error_bad_value); |
376 | goto error_return; |
377 | } |
378 | |
379 | switch (type) |
380 | { |
381 | case 0: |
382 | /* This is a data record. */ |
383 | if (sec != NULL((void*)0) |
384 | && sec->vma + sec->_raw_size == extbase + segbase + addr) |
385 | { |
386 | /* This data goes at the end of the section we are |
387 | currently building. */ |
388 | sec->_raw_size += len; |
389 | } |
390 | else if (len > 0) |
391 | { |
392 | char secbuf[20]; |
393 | char *secname; |
394 | bfd_size_type amt; |
395 | |
396 | sprintf (secbuf, ".sec%d", bfd_count_sections (abfd)((abfd)->section_count) + 1); |
397 | amt = strlen (secbuf) + 1; |
398 | secname = (char *) bfd_alloc (abfd, amt); |
399 | if (secname == NULL((void*)0)) |
400 | goto error_return; |
401 | strcpy (secname, secbuf); |
402 | sec = bfd_make_section (abfd, secname); |
403 | if (sec == NULL((void*)0)) |
404 | goto error_return; |
405 | sec->flags = SEC_HAS_CONTENTS0x200 | SEC_LOAD0x002 | SEC_ALLOC0x001; |
406 | sec->vma = extbase + segbase + addr; |
407 | sec->lma = extbase + segbase + addr; |
408 | sec->_raw_size = len; |
409 | sec->filepos = pos; |
410 | } |
411 | break; |
412 | |
413 | case 1: |
414 | /* An end record. */ |
415 | if (abfd->start_address == 0) |
416 | abfd->start_address = addr; |
417 | if (buf != NULL((void*)0)) |
418 | free (buf); |
419 | return TRUE1; |
420 | |
421 | case 2: |
422 | /* An extended address record. */ |
423 | if (len != 2) |
424 | { |
425 | (*_bfd_error_handler) |
426 | (_("%s:%u: bad extended address record length in Intel Hex file")("%s:%u: bad extended address record length in Intel Hex file" ), |
427 | bfd_archive_filename (abfd), lineno); |
428 | bfd_set_error (bfd_error_bad_value); |
429 | goto error_return; |
430 | } |
431 | |
432 | segbase = HEX4 (buf)(((((((unsigned int) _hex_value[(unsigned char) ((buf)[0])])) << 4) + (((unsigned int) _hex_value[(unsigned char) (( buf)[1])]))) << 8) + (((((unsigned int) _hex_value[(unsigned char) (((buf) + 2)[0])])) << 4) + (((unsigned int) _hex_value [(unsigned char) (((buf) + 2)[1])])))) << 4; |
433 | |
434 | sec = NULL((void*)0); |
435 | |
436 | break; |
437 | |
438 | case 3: |
439 | /* An extended start address record. */ |
440 | if (len != 4) |
441 | { |
442 | (*_bfd_error_handler) |
443 | (_("%s:%u: bad extended start address length in Intel Hex file")("%s:%u: bad extended start address length in Intel Hex file" ), |
444 | bfd_archive_filename (abfd), lineno); |
445 | bfd_set_error (bfd_error_bad_value); |
446 | goto error_return; |
447 | } |
448 | |
449 | abfd->start_address += (HEX4 (buf)(((((((unsigned int) _hex_value[(unsigned char) ((buf)[0])])) << 4) + (((unsigned int) _hex_value[(unsigned char) (( buf)[1])]))) << 8) + (((((unsigned int) _hex_value[(unsigned char) (((buf) + 2)[0])])) << 4) + (((unsigned int) _hex_value [(unsigned char) (((buf) + 2)[1])])))) << 4) + HEX4 (buf + 4)(((((((unsigned int) _hex_value[(unsigned char) ((buf + 4)[0] )])) << 4) + (((unsigned int) _hex_value[(unsigned char ) ((buf + 4)[1])]))) << 8) + (((((unsigned int) _hex_value [(unsigned char) (((buf + 4) + 2)[0])])) << 4) + (((unsigned int) _hex_value[(unsigned char) (((buf + 4) + 2)[1])])))); |
450 | |
451 | sec = NULL((void*)0); |
452 | |
453 | break; |
454 | |
455 | case 4: |
456 | /* An extended linear address record. */ |
457 | if (len != 2) |
458 | { |
459 | (*_bfd_error_handler) |
460 | (_("%s:%u: bad extended linear address record length in Intel Hex file")("%s:%u: bad extended linear address record length in Intel Hex file" ), |
461 | bfd_archive_filename (abfd), lineno); |
462 | bfd_set_error (bfd_error_bad_value); |
463 | goto error_return; |
464 | } |
465 | |
466 | extbase = HEX4 (buf)(((((((unsigned int) _hex_value[(unsigned char) ((buf)[0])])) << 4) + (((unsigned int) _hex_value[(unsigned char) (( buf)[1])]))) << 8) + (((((unsigned int) _hex_value[(unsigned char) (((buf) + 2)[0])])) << 4) + (((unsigned int) _hex_value [(unsigned char) (((buf) + 2)[1])])))) << 16; |
467 | |
468 | sec = NULL((void*)0); |
469 | |
470 | break; |
471 | |
472 | case 5: |
473 | /* An extended linear start address record. */ |
474 | if (len != 2 && len != 4) |
475 | { |
476 | (*_bfd_error_handler) |
477 | (_("%s:%u: bad extended linear start address length in Intel Hex file")("%s:%u: bad extended linear start address length in Intel Hex file" ), |
478 | bfd_archive_filename (abfd), lineno); |
479 | bfd_set_error (bfd_error_bad_value); |
480 | goto error_return; |
481 | } |
482 | |
483 | if (len == 2) |
484 | abfd->start_address += HEX4 (buf)(((((((unsigned int) _hex_value[(unsigned char) ((buf)[0])])) << 4) + (((unsigned int) _hex_value[(unsigned char) (( buf)[1])]))) << 8) + (((((unsigned int) _hex_value[(unsigned char) (((buf) + 2)[0])])) << 4) + (((unsigned int) _hex_value [(unsigned char) (((buf) + 2)[1])])))) << 16; |
485 | else |
486 | abfd->start_address = (HEX4 (buf)(((((((unsigned int) _hex_value[(unsigned char) ((buf)[0])])) << 4) + (((unsigned int) _hex_value[(unsigned char) (( buf)[1])]))) << 8) + (((((unsigned int) _hex_value[(unsigned char) (((buf) + 2)[0])])) << 4) + (((unsigned int) _hex_value [(unsigned char) (((buf) + 2)[1])])))) << 16) + HEX4 (buf + 4)(((((((unsigned int) _hex_value[(unsigned char) ((buf + 4)[0] )])) << 4) + (((unsigned int) _hex_value[(unsigned char ) ((buf + 4)[1])]))) << 8) + (((((unsigned int) _hex_value [(unsigned char) (((buf + 4) + 2)[0])])) << 4) + (((unsigned int) _hex_value[(unsigned char) (((buf + 4) + 2)[1])])))); |
487 | |
488 | sec = NULL((void*)0); |
489 | |
490 | break; |
491 | |
492 | default: |
493 | (*_bfd_error_handler) |
494 | (_("%s:%u: unrecognized ihex type %u in Intel Hex file\n")("%s:%u: unrecognized ihex type %u in Intel Hex file\n"), |
495 | bfd_archive_filename (abfd), lineno, type); |
496 | bfd_set_error (bfd_error_bad_value); |
497 | goto error_return; |
498 | } |
499 | } |
500 | } |
501 | |
502 | if (error) |
503 | goto error_return; |
504 | |
505 | if (buf != NULL((void*)0)) |
506 | free (buf); |
507 | |
508 | return TRUE1; |
509 | |
510 | error_return: |
511 | if (buf != NULL((void*)0)) |
512 | free (buf); |
513 | return FALSE0; |
514 | } |
515 | |
516 | /* Try to recognize an Intel Hex file. */ |
517 | |
518 | static const bfd_target * |
519 | ihex_object_p (abfd) |
520 | bfd *abfd; |
521 | { |
522 | PTRvoid * tdata_save; |
523 | bfd_byte b[9]; |
524 | unsigned int i; |
525 | unsigned int type; |
526 | |
527 | ihex_init (); |
528 | |
529 | if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET0) != 0) |
530 | return NULL((void*)0); |
531 | if (bfd_bread (b, (bfd_size_type) 9, abfd) != 9) |
532 | { |
533 | if (bfd_get_error () == bfd_error_file_truncated) |
534 | bfd_set_error (bfd_error_wrong_format); |
535 | return NULL((void*)0); |
536 | } |
537 | |
538 | if (b[0] != ':') |
539 | { |
540 | bfd_set_error (bfd_error_wrong_format); |
541 | return NULL((void*)0); |
542 | } |
543 | |
544 | for (i = 1; i < 9; i++) |
545 | { |
546 | if (! ISHEX (b[i])((((unsigned int) _hex_value[(unsigned char) (b[i])]) != 99))) |
547 | { |
548 | bfd_set_error (bfd_error_wrong_format); |
549 | return NULL((void*)0); |
550 | } |
551 | } |
552 | |
553 | type = HEX2 (b + 7)(((((unsigned int) _hex_value[(unsigned char) ((b + 7)[0])])) << 4) + (((unsigned int) _hex_value[(unsigned char) (( b + 7)[1])]))); |
554 | if (type > 5) |
555 | { |
556 | bfd_set_error (bfd_error_wrong_format); |
557 | return NULL((void*)0); |
558 | } |
559 | |
560 | /* OK, it looks like it really is an Intel Hex file. */ |
561 | tdata_save = abfd->tdata.any; |
562 | if (! ihex_mkobject (abfd) || ! ihex_scan (abfd)) |
563 | { |
564 | if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL((void*)0)) |
565 | bfd_release (abfd, abfd->tdata.any); |
566 | abfd->tdata.any = tdata_save; |
567 | return NULL((void*)0); |
568 | } |
569 | |
570 | return abfd->xvec; |
571 | } |
572 | |
573 | /* Read the contents of a section in an Intel Hex file. */ |
574 | |
575 | static bfd_boolean |
576 | ihex_read_section (abfd, section, contents) |
577 | bfd *abfd; |
578 | asection *section; |
579 | bfd_byte *contents; |
580 | { |
581 | int c; |
582 | bfd_byte *p; |
583 | bfd_byte *buf = NULL((void*)0); |
584 | size_t bufsize; |
585 | bfd_boolean error; |
586 | |
587 | if (bfd_seek (abfd, section->filepos, SEEK_SET0) != 0) |
588 | goto error_return; |
589 | |
590 | p = contents; |
591 | bufsize = 0; |
592 | error = FALSE0; |
593 | while ((c = ihex_get_byte (abfd, &error)) != EOF(-1)) |
594 | { |
595 | char hdr[8]; |
596 | unsigned int len; |
597 | bfd_vma addr; |
598 | unsigned int type; |
599 | unsigned int i; |
600 | |
601 | if (c == '\r' || c == '\n') |
602 | continue; |
603 | |
604 | /* This is called after ihex_scan has succeeded, so we ought to |
605 | know the exact format. */ |
606 | BFD_ASSERT (c == ':'){ if (!(c == ':')) bfd_assert("/usr/src/gnu/usr.bin/binutils/bfd/ihex.c" ,606); }; |
607 | |
608 | if (bfd_bread (hdr, (bfd_size_type) 8, abfd) != 8) |
609 | goto error_return; |
610 | |
611 | len = HEX2 (hdr)(((((unsigned int) _hex_value[(unsigned char) ((hdr)[0])])) << 4) + (((unsigned int) _hex_value[(unsigned char) ((hdr)[1])] ))); |
612 | addr = HEX4 (hdr + 2)(((((((unsigned int) _hex_value[(unsigned char) ((hdr + 2)[0] )])) << 4) + (((unsigned int) _hex_value[(unsigned char ) ((hdr + 2)[1])]))) << 8) + (((((unsigned int) _hex_value [(unsigned char) (((hdr + 2) + 2)[0])])) << 4) + (((unsigned int) _hex_value[(unsigned char) (((hdr + 2) + 2)[1])])))); |
Value stored to 'addr' is never read | |
613 | type = HEX2 (hdr + 6)(((((unsigned int) _hex_value[(unsigned char) ((hdr + 6)[0])] )) << 4) + (((unsigned int) _hex_value[(unsigned char) ( (hdr + 6)[1])]))); |
614 | |
615 | /* We should only see type 0 records here. */ |
616 | if (type != 0) |
617 | { |
618 | (*_bfd_error_handler) |
619 | (_("%s: internal error in ihex_read_section")("%s: internal error in ihex_read_section"), |
620 | bfd_archive_filename (abfd)); |
621 | bfd_set_error (bfd_error_bad_value); |
622 | goto error_return; |
623 | } |
624 | |
625 | if (len * 2 > bufsize) |
626 | { |
627 | buf = (bfd_byte *) bfd_realloc (buf, (bfd_size_type) len * 2); |
628 | if (buf == NULL((void*)0)) |
629 | goto error_return; |
630 | bufsize = len * 2; |
631 | } |
632 | |
633 | if (bfd_bread (buf, (bfd_size_type) len * 2, abfd) != len * 2) |
634 | goto error_return; |
635 | |
636 | for (i = 0; i < len; i++) |
637 | *p++ = HEX2 (buf + 2 * i)(((((unsigned int) _hex_value[(unsigned char) ((buf + 2 * i)[ 0])])) << 4) + (((unsigned int) _hex_value[(unsigned char ) ((buf + 2 * i)[1])]))); |
638 | if ((bfd_size_type) (p - contents) >= section->_raw_size) |
639 | { |
640 | /* We've read everything in the section. */ |
641 | if (buf != NULL((void*)0)) |
642 | free (buf); |
643 | return TRUE1; |
644 | } |
645 | |
646 | /* Skip the checksum. */ |
647 | if (bfd_bread (buf, (bfd_size_type) 2, abfd) != 2) |
648 | goto error_return; |
649 | } |
650 | |
651 | if ((bfd_size_type) (p - contents) < section->_raw_size) |
652 | { |
653 | (*_bfd_error_handler) |
654 | (_("%s: bad section length in ihex_read_section")("%s: bad section length in ihex_read_section"), |
655 | bfd_archive_filename (abfd)); |
656 | bfd_set_error (bfd_error_bad_value); |
657 | goto error_return; |
658 | } |
659 | |
660 | if (buf != NULL((void*)0)) |
661 | free (buf); |
662 | |
663 | return TRUE1; |
664 | |
665 | error_return: |
666 | if (buf != NULL((void*)0)) |
667 | free (buf); |
668 | return FALSE0; |
669 | } |
670 | |
671 | /* Get the contents of a section in an Intel Hex file. */ |
672 | |
673 | static bfd_boolean |
674 | ihex_get_section_contents (abfd, section, location, offset, count) |
675 | bfd *abfd; |
676 | asection *section; |
677 | PTRvoid * location; |
678 | file_ptr offset; |
679 | bfd_size_type count; |
680 | { |
681 | if (section->used_by_bfd == NULL((void*)0)) |
682 | { |
683 | section->used_by_bfd = bfd_alloc (abfd, section->_raw_size); |
684 | if (section->used_by_bfd == NULL((void*)0)) |
685 | return FALSE0; |
686 | if (! ihex_read_section (abfd, section, section->used_by_bfd)) |
687 | return FALSE0; |
688 | } |
689 | |
690 | memcpy (location, (bfd_byte *) section->used_by_bfd + offset, |
691 | (size_t) count); |
692 | |
693 | return TRUE1; |
694 | } |
695 | |
696 | /* Set the contents of a section in an Intel Hex file. */ |
697 | |
698 | static bfd_boolean |
699 | ihex_set_section_contents (abfd, section, location, offset, count) |
700 | bfd *abfd; |
701 | asection *section; |
702 | const PTRvoid * location; |
703 | file_ptr offset; |
704 | bfd_size_type count; |
705 | { |
706 | struct ihex_data_list *n; |
707 | bfd_byte *data; |
708 | struct ihex_data_struct *tdata; |
709 | bfd_size_type amt; |
710 | |
711 | if (count == 0 |
712 | || (section->flags & SEC_ALLOC0x001) == 0 |
713 | || (section->flags & SEC_LOAD0x002) == 0) |
714 | return TRUE1; |
715 | |
716 | amt = sizeof (struct ihex_data_list); |
717 | n = (struct ihex_data_list *) bfd_alloc (abfd, amt); |
718 | if (n == NULL((void*)0)) |
719 | return FALSE0; |
720 | |
721 | data = (bfd_byte *) bfd_alloc (abfd, count); |
722 | if (data == NULL((void*)0)) |
723 | return FALSE0; |
724 | memcpy (data, location, (size_t) count); |
725 | |
726 | n->data = data; |
727 | n->where = section->lma + offset; |
728 | n->size = count; |
729 | |
730 | /* Sort the records by address. Optimize for the common case of |
731 | adding a record to the end of the list. */ |
732 | tdata = abfd->tdata.ihex_data; |
733 | if (tdata->tail != NULL((void*)0) |
734 | && n->where >= tdata->tail->where) |
735 | { |
736 | tdata->tail->next = n; |
737 | n->next = NULL((void*)0); |
738 | tdata->tail = n; |
739 | } |
740 | else |
741 | { |
742 | register struct ihex_data_list **pp; |
743 | |
744 | for (pp = &tdata->head; |
745 | *pp != NULL((void*)0) && (*pp)->where < n->where; |
746 | pp = &(*pp)->next) |
747 | ; |
748 | n->next = *pp; |
749 | *pp = n; |
750 | if (n->next == NULL((void*)0)) |
751 | tdata->tail = n; |
752 | } |
753 | |
754 | return TRUE1; |
755 | } |
756 | |
757 | /* Write a record out to an Intel Hex file. */ |
758 | |
759 | static bfd_boolean |
760 | ihex_write_record (abfd, count, addr, type, data) |
761 | bfd *abfd; |
762 | size_t count; |
763 | unsigned int addr; |
764 | unsigned int type; |
765 | bfd_byte *data; |
766 | { |
767 | static const char digs[] = "0123456789ABCDEF"; |
768 | char buf[9 + CHUNK16 * 2 + 4]; |
769 | char *p; |
770 | unsigned int chksum; |
771 | unsigned int i; |
772 | size_t total; |
773 | |
774 | #define TOHEX(buf, v)((buf)[0] = digs[((v) >> 4) & 0xf], (buf)[1] = digs [(v) & 0xf]) \ |
775 | ((buf)[0] = digs[((v) >> 4) & 0xf], (buf)[1] = digs[(v) & 0xf]) |
776 | |
777 | buf[0] = ':'; |
778 | TOHEX (buf + 1, count)((buf + 1)[0] = digs[((count) >> 4) & 0xf], (buf + 1 )[1] = digs[(count) & 0xf]); |
779 | TOHEX (buf + 3, (addr >> 8) & 0xff)((buf + 3)[0] = digs[(((addr >> 8) & 0xff) >> 4) & 0xf], (buf + 3)[1] = digs[((addr >> 8) & 0xff ) & 0xf]); |
780 | TOHEX (buf + 5, addr & 0xff)((buf + 5)[0] = digs[((addr & 0xff) >> 4) & 0xf ], (buf + 5)[1] = digs[(addr & 0xff) & 0xf]); |
781 | TOHEX (buf + 7, type)((buf + 7)[0] = digs[((type) >> 4) & 0xf], (buf + 7 )[1] = digs[(type) & 0xf]); |
782 | |
783 | chksum = count + addr + (addr >> 8) + type; |
784 | |
785 | for (i = 0, p = buf + 9; i < count; i++, p += 2, data++) |
786 | { |
787 | TOHEX (p, *data)((p)[0] = digs[((*data) >> 4) & 0xf], (p)[1] = digs [(*data) & 0xf]); |
788 | chksum += *data; |
789 | } |
790 | |
791 | TOHEX (p, (- chksum) & 0xff)((p)[0] = digs[(((- chksum) & 0xff) >> 4) & 0xf ], (p)[1] = digs[((- chksum) & 0xff) & 0xf]); |
792 | p[2] = '\r'; |
793 | p[3] = '\n'; |
794 | |
795 | total = 9 + count * 2 + 4; |
796 | if (bfd_bwrite (buf, (bfd_size_type) total, abfd) != total) |
797 | return FALSE0; |
798 | |
799 | return TRUE1; |
800 | } |
801 | |
802 | /* Write out an Intel Hex file. */ |
803 | |
804 | static bfd_boolean |
805 | ihex_write_object_contents (abfd) |
806 | bfd *abfd; |
807 | { |
808 | bfd_vma segbase; |
809 | bfd_vma extbase; |
810 | struct ihex_data_list *l; |
811 | |
812 | segbase = 0; |
813 | extbase = 0; |
814 | for (l = abfd->tdata.ihex_data->head; l != NULL((void*)0); l = l->next) |
815 | { |
816 | bfd_vma where; |
817 | bfd_byte *p; |
818 | bfd_size_type count; |
819 | |
820 | where = l->where; |
821 | p = l->data; |
822 | count = l->size; |
823 | while (count > 0) |
824 | { |
825 | size_t now; |
826 | unsigned int rec_addr; |
827 | |
828 | now = count; |
829 | if (count > CHUNK16) |
830 | now = CHUNK16; |
831 | |
832 | if (where > segbase + extbase + 0xffff) |
833 | { |
834 | bfd_byte addr[2]; |
835 | |
836 | /* We need a new base address. */ |
837 | if (where <= 0xfffff) |
838 | { |
839 | /* The addresses should be sorted. */ |
840 | BFD_ASSERT (extbase == 0){ if (!(extbase == 0)) bfd_assert("/usr/src/gnu/usr.bin/binutils/bfd/ihex.c" ,840); }; |
841 | |
842 | segbase = where & 0xf0000; |
843 | addr[0] = (bfd_byte)(segbase >> 12) & 0xff; |
844 | addr[1] = (bfd_byte)(segbase >> 4) & 0xff; |
845 | if (! ihex_write_record (abfd, 2, 0, 2, addr)) |
846 | return FALSE0; |
847 | } |
848 | else |
849 | { |
850 | /* The extended address record and the extended |
851 | linear address record are combined, at least by |
852 | some readers. We need an extended linear address |
853 | record here, so if we've already written out an |
854 | extended address record, zero it out to avoid |
855 | confusion. */ |
856 | if (segbase != 0) |
857 | { |
858 | addr[0] = 0; |
859 | addr[1] = 0; |
860 | if (! ihex_write_record (abfd, 2, 0, 2, addr)) |
861 | return FALSE0; |
862 | segbase = 0; |
863 | } |
864 | |
865 | extbase = where & 0xffff0000; |
866 | if (where > extbase + 0xffff) |
867 | { |
868 | char buf[20]; |
869 | |
870 | sprintf_vma (buf, where)sprintf (buf, "%016lx", where); |
871 | (*_bfd_error_handler) |
872 | (_("%s: address 0x%s out of range for Intel Hex file")("%s: address 0x%s out of range for Intel Hex file"), |
873 | bfd_get_filename (abfd)((char *) (abfd)->filename), buf); |
874 | bfd_set_error (bfd_error_bad_value); |
875 | return FALSE0; |
876 | } |
877 | addr[0] = (bfd_byte)(extbase >> 24) & 0xff; |
878 | addr[1] = (bfd_byte)(extbase >> 16) & 0xff; |
879 | if (! ihex_write_record (abfd, 2, 0, 4, addr)) |
880 | return FALSE0; |
881 | } |
882 | } |
883 | |
884 | rec_addr = where - (extbase + segbase); |
885 | |
886 | /* Output records shouldn't cross 64K boundaries. */ |
887 | if (rec_addr + now > 0xffff) |
888 | now = 0x10000 - rec_addr; |
889 | |
890 | if (! ihex_write_record (abfd, now, rec_addr, 0, p)) |
891 | return FALSE0; |
892 | |
893 | where += now; |
894 | p += now; |
895 | count -= now; |
896 | } |
897 | } |
898 | |
899 | if (abfd->start_address != 0) |
900 | { |
901 | bfd_vma start; |
902 | bfd_byte startbuf[4]; |
903 | |
904 | start = abfd->start_address; |
905 | |
906 | if (start <= 0xfffff) |
907 | { |
908 | startbuf[0] = (bfd_byte)((start & 0xf0000) >> 12) & 0xff; |
909 | startbuf[1] = 0; |
910 | startbuf[2] = (bfd_byte)(start >> 8) & 0xff; |
911 | startbuf[3] = (bfd_byte)start & 0xff; |
912 | if (! ihex_write_record (abfd, 4, 0, 3, startbuf)) |
913 | return FALSE0; |
914 | } |
915 | else |
916 | { |
917 | startbuf[0] = (bfd_byte)(start >> 24) & 0xff; |
918 | startbuf[1] = (bfd_byte)(start >> 16) & 0xff; |
919 | startbuf[2] = (bfd_byte)(start >> 8) & 0xff; |
920 | startbuf[3] = (bfd_byte)start & 0xff; |
921 | if (! ihex_write_record (abfd, 4, 0, 5, startbuf)) |
922 | return FALSE0; |
923 | } |
924 | } |
925 | |
926 | if (! ihex_write_record (abfd, 0, 0, 1, NULL((void*)0))) |
927 | return FALSE0; |
928 | |
929 | return TRUE1; |
930 | } |
931 | |
932 | /* Set the architecture for the output file. The architecture is |
933 | irrelevant, so we ignore errors about unknown architectures. */ |
934 | |
935 | static bfd_boolean |
936 | ihex_set_arch_mach (abfd, arch, mach) |
937 | bfd *abfd; |
938 | enum bfd_architecture arch; |
939 | unsigned long mach; |
940 | { |
941 | if (! bfd_default_set_arch_mach (abfd, arch, mach)) |
942 | { |
943 | if (arch != bfd_arch_unknown) |
944 | return FALSE0; |
945 | } |
946 | return TRUE1; |
947 | } |
948 | |
949 | /* Get the size of the headers, for the linker. */ |
950 | |
951 | static int |
952 | ihex_sizeof_headers (abfd, exec) |
953 | bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__)); |
954 | bfd_boolean exec ATTRIBUTE_UNUSED__attribute__ ((__unused__)); |
955 | { |
956 | return 0; |
957 | } |
958 | |
959 | /* Some random definitions for the target vector. */ |
960 | |
961 | #define ihex_close_and_cleanupbfd_true _bfd_generic_close_and_cleanupbfd_true |
962 | #define ihex_bfd_free_cached_infobfd_true _bfd_generic_bfd_free_cached_infobfd_true |
963 | #define ihex_new_section_hook((bfd_boolean (*) (bfd *, asection *)) bfd_true) _bfd_generic_new_section_hook((bfd_boolean (*) (bfd *, asection *)) bfd_true) |
964 | #define ihex_get_section_contents_in_window_bfd_generic_get_section_contents_in_window \ |
965 | _bfd_generic_get_section_contents_in_window |
966 | |
967 | #define ihex_get_symtab_upper_boundbfd_0l bfd_0l |
968 | #define ihex_canonicalize_symtab((long (*) (bfd *, asymbol **)) bfd_0l) \ |
969 | ((long (*) PARAMS ((bfd *, asymbol **))(bfd *, asymbol **)) bfd_0l) |
970 | #define ihex_make_empty_symbol_bfd_generic_make_empty_symbol _bfd_generic_make_empty_symbol |
971 | #define ihex_print_symbol((void (*) (bfd *, void *, asymbol *, bfd_print_symbol_type)) bfd_void) _bfd_nosymbols_print_symbol((void (*) (bfd *, void *, asymbol *, bfd_print_symbol_type)) bfd_void) |
972 | #define ihex_get_symbol_info((void (*) (bfd *, asymbol *, symbol_info *)) bfd_void) _bfd_nosymbols_get_symbol_info((void (*) (bfd *, asymbol *, symbol_info *)) bfd_void) |
973 | #define ihex_bfd_is_local_label_name((bfd_boolean (*) (bfd *, const char *)) bfd_false) _bfd_nosymbols_bfd_is_local_label_name((bfd_boolean (*) (bfd *, const char *)) bfd_false) |
974 | #define ihex_get_lineno((alent *(*) (bfd *, asymbol *)) bfd_nullvoidptr) _bfd_nosymbols_get_lineno((alent *(*) (bfd *, asymbol *)) bfd_nullvoidptr) |
975 | #define ihex_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) |
976 | #define ihex_bfd_make_debug_symbol((asymbol *(*) (bfd *, void *, unsigned long)) bfd_nullvoidptr ) _bfd_nosymbols_bfd_make_debug_symbol((asymbol *(*) (bfd *, void *, unsigned long)) bfd_nullvoidptr ) |
977 | #define ihex_read_minisymbols((long (*) (bfd *, bfd_boolean, void **, unsigned int *)) _bfd_n1 ) _bfd_nosymbols_read_minisymbols((long (*) (bfd *, bfd_boolean, void **, unsigned int *)) _bfd_n1 ) |
978 | #define ihex_minisymbol_to_symbol((asymbol *(*) (bfd *, bfd_boolean, const void *, asymbol *)) bfd_nullvoidptr) _bfd_nosymbols_minisymbol_to_symbol((asymbol *(*) (bfd *, bfd_boolean, const void *, asymbol *)) bfd_nullvoidptr) |
979 | |
980 | #define ihex_get_reloc_upper_bound((long (*) (bfd *, asection *)) bfd_0l) \ |
981 | ((long (*) PARAMS ((bfd *, asection *))(bfd *, asection *)) bfd_0l) |
982 | #define ihex_canonicalize_reloc((long (*) (bfd *, asection *, arelent **, asymbol **)) bfd_0l ) \ |
983 | ((long (*) PARAMS ((bfd *, asection *, arelent **, asymbol **))(bfd *, asection *, arelent **, asymbol **)) bfd_0l) |
984 | #define ihex_bfd_reloc_type_lookup((reloc_howto_type *(*) (bfd *, bfd_reloc_code_real_type)) bfd_nullvoidptr ) _bfd_norelocs_bfd_reloc_type_lookup((reloc_howto_type *(*) (bfd *, bfd_reloc_code_real_type)) bfd_nullvoidptr ) |
985 | |
986 | #define ihex_bfd_get_relocated_section_contentsbfd_generic_get_relocated_section_contents \ |
987 | bfd_generic_get_relocated_section_contents |
988 | #define ihex_bfd_relax_sectionbfd_generic_relax_section bfd_generic_relax_section |
989 | #define ihex_bfd_gc_sectionsbfd_generic_gc_sections bfd_generic_gc_sections |
990 | #define ihex_bfd_merge_sectionsbfd_generic_merge_sections bfd_generic_merge_sections |
991 | #define ihex_bfd_discard_groupbfd_generic_discard_group bfd_generic_discard_group |
992 | #define ihex_bfd_link_hash_table_create_bfd_generic_link_hash_table_create _bfd_generic_link_hash_table_create |
993 | #define ihex_bfd_link_hash_table_free_bfd_generic_link_hash_table_free _bfd_generic_link_hash_table_free |
994 | #define ihex_bfd_link_add_symbols_bfd_generic_link_add_symbols _bfd_generic_link_add_symbols |
995 | #define ihex_bfd_link_just_syms_bfd_generic_link_just_syms _bfd_generic_link_just_syms |
996 | #define ihex_bfd_final_link_bfd_generic_final_link _bfd_generic_final_link |
997 | #define ihex_bfd_link_split_section_bfd_generic_link_split_section _bfd_generic_link_split_section |
998 | |
999 | /* The Intel Hex target vector. */ |
1000 | |
1001 | const bfd_target ihex_vec = |
1002 | { |
1003 | "ihex", /* name */ |
1004 | bfd_target_ihex_flavour, |
1005 | BFD_ENDIAN_UNKNOWN, /* target byte order */ |
1006 | BFD_ENDIAN_UNKNOWN, /* target headers byte order */ |
1007 | 0, /* object flags */ |
1008 | (SEC_HAS_CONTENTS0x200 | SEC_ALLOC0x001 | SEC_LOAD0x002), /* section flags */ |
1009 | 0, /* leading underscore */ |
1010 | ' ', /* ar_pad_char */ |
1011 | 16, /* ar_max_namelen */ |
1012 | bfd_getb64, bfd_getb_signed_64, bfd_putb64, |
1013 | bfd_getb32, bfd_getb_signed_32, bfd_putb32, |
1014 | bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */ |
1015 | bfd_getb64, bfd_getb_signed_64, bfd_putb64, |
1016 | bfd_getb32, bfd_getb_signed_32, bfd_putb32, |
1017 | bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */ |
1018 | |
1019 | { |
1020 | _bfd_dummy_target, |
1021 | ihex_object_p, /* bfd_check_format */ |
1022 | _bfd_dummy_target, |
1023 | _bfd_dummy_target, |
1024 | }, |
1025 | { |
1026 | bfd_false, |
1027 | ihex_mkobject, |
1028 | _bfd_generic_mkarchive, |
1029 | bfd_false, |
1030 | }, |
1031 | { /* bfd_write_contents */ |
1032 | bfd_false, |
1033 | ihex_write_object_contents, |
1034 | _bfd_write_archive_contents, |
1035 | bfd_false, |
1036 | }, |
1037 | |
1038 | BFD_JUMP_TABLE_GENERIC (ihex)bfd_true, bfd_true, ((bfd_boolean (*) (bfd *, asection *)) bfd_true ), ihex_get_section_contents, _bfd_generic_get_section_contents_in_window, |
1039 | 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), |
1040 | 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, |
1041 | 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, |
1042 | BFD_JUMP_TABLE_SYMBOLS (ihex)bfd_0l, ((long (*) (bfd *, asymbol **)) bfd_0l), _bfd_generic_make_empty_symbol , ((void (*) (bfd *, void *, asymbol *, bfd_print_symbol_type )) bfd_void), ((void (*) (bfd *, asymbol *, symbol_info *)) bfd_void ), ((bfd_boolean (*) (bfd *, const char *)) bfd_false), ((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), ((long (*) (bfd *, bfd_boolean, void **, unsigned int *)) _bfd_n1), ((asymbol * (*) (bfd *, bfd_boolean, const void *, asymbol *)) bfd_nullvoidptr ), |
1043 | BFD_JUMP_TABLE_RELOCS (ihex)((long (*) (bfd *, asection *)) bfd_0l), ((long (*) (bfd *, asection *, arelent **, asymbol **)) bfd_0l), ((reloc_howto_type *(*) (bfd *, bfd_reloc_code_real_type)) bfd_nullvoidptr), |
1044 | BFD_JUMP_TABLE_WRITE (ihex)ihex_set_arch_mach, ihex_set_section_contents, |
1045 | BFD_JUMP_TABLE_LINK (ihex)ihex_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, |
1046 | BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic)_bfd_n1, ((long (*) (bfd *, asymbol **)) _bfd_n1), _bfd_n1, ( (long (*) (bfd *, arelent **, asymbol **)) _bfd_n1), |
1047 | |
1048 | NULL((void*)0), |
1049 | |
1050 | (PTRvoid *) 0 |
1051 | }; |