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