1 /***************************************************************************
2 * Copyright (C) 2007 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
11 * Copyright (C) 2009 by Franck Hereson *
12 * franck.hereson@secad.fr *
14 * Copyright (C) 2018 by Advantest *
15 * florian.meister@advantest.com *
17 * This program is free software; you can redistribute it and/or modify *
18 * it under the terms of the GNU General Public License as published by *
19 * the Free Software Foundation; either version 2 of the License, or *
20 * (at your option) any later version. *
22 * This program is distributed in the hope that it will be useful, *
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
25 * GNU General Public License for more details. *
27 * You should have received a copy of the GNU General Public License *
28 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
29 ***************************************************************************/
37 #include <helper/log.h>
39 /* convert ELF header field to host endianness */
40 #define field16(elf, field) \
41 ((elf->endianness == ELFDATA2LSB) ? \
42 le_to_h_u16((uint8_t *)&field) : be_to_h_u16((uint8_t *)&field))
44 #define field32(elf, field) \
45 ((elf->endianness == ELFDATA2LSB) ? \
46 le_to_h_u32((uint8_t *)&field) : be_to_h_u32((uint8_t *)&field))
48 #define field64(elf, field) \
49 ((elf->endianness == ELFDATA2LSB) ? \
50 le_to_h_u64((uint8_t *)&field) : be_to_h_u64((uint8_t *)&field))
52 static int autodetect_image_type(struct image
*image
, const char *url
)
55 struct fileio
*fileio
;
59 /* read the first 9 bytes of image */
60 retval
= fileio_open(&fileio
, url
, FILEIO_READ
, FILEIO_BINARY
);
61 if (retval
!= ERROR_OK
)
63 retval
= fileio_read(fileio
, 9, buffer
, &read_bytes
);
65 if (retval
== ERROR_OK
) {
67 retval
= ERROR_FILEIO_OPERATION_FAILED
;
71 if (retval
!= ERROR_OK
)
74 /* check header against known signatures */
75 if (strncmp((char *)buffer
, ELFMAG
, SELFMAG
) == 0) {
76 LOG_DEBUG("ELF image detected.");
77 image
->type
= IMAGE_ELF
;
78 } else if ((buffer
[0] == ':') /* record start byte */
79 && (isxdigit(buffer
[1]))
80 && (isxdigit(buffer
[2]))
81 && (isxdigit(buffer
[3]))
82 && (isxdigit(buffer
[4]))
83 && (isxdigit(buffer
[5]))
84 && (isxdigit(buffer
[6]))
85 && (buffer
[7] == '0') /* record type : 00 -> 05 */
86 && (buffer
[8] >= '0') && (buffer
[8] < '6')) {
87 LOG_DEBUG("IHEX image detected.");
88 image
->type
= IMAGE_IHEX
;
89 } else if ((buffer
[0] == 'S') /* record start byte */
90 && (isxdigit(buffer
[1]))
91 && (isxdigit(buffer
[2]))
92 && (isxdigit(buffer
[3]))
93 && (buffer
[1] >= '0') && (buffer
[1] < '9')) {
94 LOG_DEBUG("S19 image detected.");
95 image
->type
= IMAGE_SRECORD
;
97 image
->type
= IMAGE_BINARY
;
102 static int identify_image_type(struct image
*image
, const char *type_string
, const char *url
)
105 if (!strcmp(type_string
, "bin"))
106 image
->type
= IMAGE_BINARY
;
107 else if (!strcmp(type_string
, "ihex"))
108 image
->type
= IMAGE_IHEX
;
109 else if (!strcmp(type_string
, "elf"))
110 image
->type
= IMAGE_ELF
;
111 else if (!strcmp(type_string
, "mem"))
112 image
->type
= IMAGE_MEMORY
;
113 else if (!strcmp(type_string
, "s19"))
114 image
->type
= IMAGE_SRECORD
;
115 else if (!strcmp(type_string
, "build"))
116 image
->type
= IMAGE_BUILDER
;
118 return ERROR_IMAGE_TYPE_UNKNOWN
;
120 return autodetect_image_type(image
, url
);
125 static int image_ihex_buffer_complete_inner(struct image
*image
,
127 struct imagesection
*section
)
129 struct image_ihex
*ihex
= image
->type_private
;
130 struct fileio
*fileio
= ihex
->fileio
;
131 uint32_t full_address
;
132 uint32_t cooked_bytes
;
133 bool end_rec
= false;
135 /* we can't determine the number of sections that we'll have to create ahead of time,
136 * so we locally hold them until parsing is finished */
140 retval
= fileio_size(fileio
, &filesize
);
141 if (retval
!= ERROR_OK
)
144 ihex
->buffer
= malloc(filesize
>> 1);
146 image
->num_sections
= 0;
148 while (!fileio_feof(fileio
)) {
150 section
[image
->num_sections
].private = &ihex
->buffer
[cooked_bytes
];
151 section
[image
->num_sections
].base_address
= 0x0;
152 section
[image
->num_sections
].size
= 0x0;
153 section
[image
->num_sections
].flags
= 0;
155 while (fileio_fgets(fileio
, 1023, lpsz_line
) == ERROR_OK
) {
158 uint32_t record_type
;
160 uint8_t cal_checksum
= 0;
161 size_t bytes_read
= 0;
163 /* skip comments and blank lines */
164 if ((lpsz_line
[0] == '#') || (strlen(lpsz_line
+ strspn(lpsz_line
, "\n\t\r ")) == 0))
167 if (sscanf(&lpsz_line
[bytes_read
], ":%2" SCNx32
"%4" SCNx32
"%2" SCNx32
, &count
,
168 &address
, &record_type
) != 3)
169 return ERROR_IMAGE_FORMAT_ERROR
;
172 cal_checksum
+= (uint8_t)count
;
173 cal_checksum
+= (uint8_t)(address
>> 8);
174 cal_checksum
+= (uint8_t)address
;
175 cal_checksum
+= (uint8_t)record_type
;
177 if (record_type
== 0) { /* Data Record */
178 if ((full_address
& 0xffff) != address
) {
179 /* we encountered a nonconsecutive location, create a new section,
180 * unless the current section has zero size, in which case this specifies
181 * the current section's base address
183 if (section
[image
->num_sections
].size
!= 0) {
184 image
->num_sections
++;
185 if (image
->num_sections
>= IMAGE_MAX_SECTIONS
) {
186 /* too many sections */
187 LOG_ERROR("Too many sections found in IHEX file");
188 return ERROR_IMAGE_FORMAT_ERROR
;
190 section
[image
->num_sections
].size
= 0x0;
191 section
[image
->num_sections
].flags
= 0;
192 section
[image
->num_sections
].private =
193 &ihex
->buffer
[cooked_bytes
];
195 section
[image
->num_sections
].base_address
=
196 (full_address
& 0xffff0000) | address
;
197 full_address
= (full_address
& 0xffff0000) | address
;
200 while (count
-- > 0) {
202 sscanf(&lpsz_line
[bytes_read
], "%2x", &value
);
203 ihex
->buffer
[cooked_bytes
] = (uint8_t)value
;
204 cal_checksum
+= (uint8_t)ihex
->buffer
[cooked_bytes
];
207 section
[image
->num_sections
].size
+= 1;
210 } else if (record_type
== 1) { /* End of File Record */
211 /* finish the current section */
212 image
->num_sections
++;
214 /* copy section information */
215 image
->sections
= malloc(sizeof(struct imagesection
) * image
->num_sections
);
216 for (unsigned int i
= 0; i
< image
->num_sections
; i
++) {
217 image
->sections
[i
].private = section
[i
].private;
218 image
->sections
[i
].base_address
= section
[i
].base_address
;
219 image
->sections
[i
].size
= section
[i
].size
;
220 image
->sections
[i
].flags
= section
[i
].flags
;
225 } else if (record_type
== 2) { /* Linear Address Record */
226 uint16_t upper_address
;
228 sscanf(&lpsz_line
[bytes_read
], "%4hx", &upper_address
);
229 cal_checksum
+= (uint8_t)(upper_address
>> 8);
230 cal_checksum
+= (uint8_t)upper_address
;
233 if ((full_address
>> 4) != upper_address
) {
234 /* we encountered a nonconsecutive location, create a new section,
235 * unless the current section has zero size, in which case this specifies
236 * the current section's base address
238 if (section
[image
->num_sections
].size
!= 0) {
239 image
->num_sections
++;
240 if (image
->num_sections
>= IMAGE_MAX_SECTIONS
) {
241 /* too many sections */
242 LOG_ERROR("Too many sections found in IHEX file");
243 return ERROR_IMAGE_FORMAT_ERROR
;
245 section
[image
->num_sections
].size
= 0x0;
246 section
[image
->num_sections
].flags
= 0;
247 section
[image
->num_sections
].private =
248 &ihex
->buffer
[cooked_bytes
];
250 section
[image
->num_sections
].base_address
=
251 (full_address
& 0xffff) | (upper_address
<< 4);
252 full_address
= (full_address
& 0xffff) | (upper_address
<< 4);
254 } else if (record_type
== 3) { /* Start Segment Address Record */
257 /* "Start Segment Address Record" will not be supported
258 * but we must consume it, and do not create an error. */
259 while (count
-- > 0) {
260 sscanf(&lpsz_line
[bytes_read
], "%2" SCNx32
, &dummy
);
261 cal_checksum
+= (uint8_t)dummy
;
264 } else if (record_type
== 4) { /* Extended Linear Address Record */
265 uint16_t upper_address
;
267 sscanf(&lpsz_line
[bytes_read
], "%4hx", &upper_address
);
268 cal_checksum
+= (uint8_t)(upper_address
>> 8);
269 cal_checksum
+= (uint8_t)upper_address
;
272 if ((full_address
>> 16) != upper_address
) {
273 /* we encountered a nonconsecutive location, create a new section,
274 * unless the current section has zero size, in which case this specifies
275 * the current section's base address
277 if (section
[image
->num_sections
].size
!= 0) {
278 image
->num_sections
++;
279 if (image
->num_sections
>= IMAGE_MAX_SECTIONS
) {
280 /* too many sections */
281 LOG_ERROR("Too many sections found in IHEX file");
282 return ERROR_IMAGE_FORMAT_ERROR
;
284 section
[image
->num_sections
].size
= 0x0;
285 section
[image
->num_sections
].flags
= 0;
286 section
[image
->num_sections
].private =
287 &ihex
->buffer
[cooked_bytes
];
289 section
[image
->num_sections
].base_address
=
290 (full_address
& 0xffff) | (upper_address
<< 16);
291 full_address
= (full_address
& 0xffff) | (upper_address
<< 16);
293 } else if (record_type
== 5) { /* Start Linear Address Record */
294 uint32_t start_address
;
296 sscanf(&lpsz_line
[bytes_read
], "%8" SCNx32
, &start_address
);
297 cal_checksum
+= (uint8_t)(start_address
>> 24);
298 cal_checksum
+= (uint8_t)(start_address
>> 16);
299 cal_checksum
+= (uint8_t)(start_address
>> 8);
300 cal_checksum
+= (uint8_t)start_address
;
303 image
->start_address_set
= true;
304 image
->start_address
= be_to_h_u32((uint8_t *)&start_address
);
306 LOG_ERROR("unhandled IHEX record type: %i", (int)record_type
);
307 return ERROR_IMAGE_FORMAT_ERROR
;
310 sscanf(&lpsz_line
[bytes_read
], "%2" SCNx32
, &checksum
);
312 if ((uint8_t)checksum
!= (uint8_t)(~cal_checksum
+ 1)) {
313 /* checksum failed */
314 LOG_ERROR("incorrect record checksum found in IHEX file");
315 return ERROR_IMAGE_CHECKSUM
;
320 LOG_WARNING("continuing after end-of-file record: %.40s", lpsz_line
);
328 LOG_ERROR("premature end of IHEX file, no matching end-of-file record found");
329 return ERROR_IMAGE_FORMAT_ERROR
;
334 * Allocate memory dynamically instead of on the stack. This
335 * is important w/embedded hosts.
337 static int image_ihex_buffer_complete(struct image
*image
)
339 char *lpsz_line
= malloc(1023);
341 LOG_ERROR("Out of memory");
344 struct imagesection
*section
= malloc(sizeof(struct imagesection
) * IMAGE_MAX_SECTIONS
);
347 LOG_ERROR("Out of memory");
352 retval
= image_ihex_buffer_complete_inner(image
, lpsz_line
, section
);
360 static int image_elf32_read_headers(struct image
*image
)
362 struct image_elf
*elf
= image
->type_private
;
367 bool load_to_vaddr
= false;
369 retval
= fileio_seek(elf
->fileio
, 0);
370 if (retval
!= ERROR_OK
) {
371 LOG_ERROR("cannot seek to ELF file header, read failed");
375 elf
->header32
= malloc(sizeof(Elf32_Ehdr
));
377 if (!elf
->header32
) {
378 LOG_ERROR("insufficient memory to perform operation");
379 return ERROR_FILEIO_OPERATION_FAILED
;
382 retval
= fileio_read(elf
->fileio
, sizeof(Elf32_Ehdr
), (uint8_t *)elf
->header32
, &read_bytes
);
383 if (retval
!= ERROR_OK
) {
384 LOG_ERROR("cannot read ELF file header, read failed");
385 return ERROR_FILEIO_OPERATION_FAILED
;
387 if (read_bytes
!= sizeof(Elf32_Ehdr
)) {
388 LOG_ERROR("cannot read ELF file header, only partially read");
389 return ERROR_FILEIO_OPERATION_FAILED
;
392 elf
->segment_count
= field16(elf
, elf
->header32
->e_phnum
);
393 if (elf
->segment_count
== 0) {
394 LOG_ERROR("invalid ELF file, no program headers");
395 return ERROR_IMAGE_FORMAT_ERROR
;
398 retval
= fileio_seek(elf
->fileio
, field32(elf
, elf
->header32
->e_phoff
));
399 if (retval
!= ERROR_OK
) {
400 LOG_ERROR("cannot seek to ELF program header table, read failed");
404 elf
->segments32
= malloc(elf
->segment_count
*sizeof(Elf32_Phdr
));
405 if (!elf
->segments32
) {
406 LOG_ERROR("insufficient memory to perform operation");
407 return ERROR_FILEIO_OPERATION_FAILED
;
410 retval
= fileio_read(elf
->fileio
, elf
->segment_count
*sizeof(Elf32_Phdr
),
411 (uint8_t *)elf
->segments32
, &read_bytes
);
412 if (retval
!= ERROR_OK
) {
413 LOG_ERROR("cannot read ELF segment headers, read failed");
416 if (read_bytes
!= elf
->segment_count
*sizeof(Elf32_Phdr
)) {
417 LOG_ERROR("cannot read ELF segment headers, only partially read");
418 return ERROR_FILEIO_OPERATION_FAILED
;
421 /* count useful segments (loadable), ignore BSS section */
422 image
->num_sections
= 0;
423 for (i
= 0; i
< elf
->segment_count
; i
++)
425 elf
->segments32
[i
].p_type
) == PT_LOAD
) &&
426 (field32(elf
, elf
->segments32
[i
].p_filesz
) != 0))
427 image
->num_sections
++;
429 if (image
->num_sections
== 0) {
430 LOG_ERROR("invalid ELF file, no loadable segments");
431 return ERROR_IMAGE_FORMAT_ERROR
;
435 * some ELF linkers produce binaries with *all* the program header
436 * p_paddr fields zero (there can be however one loadable segment
437 * that has valid physical address 0x0).
438 * If we have such a binary with more than
439 * one PT_LOAD header, then use p_vaddr instead of p_paddr
440 * (ARM ELF standard demands p_paddr = 0 anyway, and BFD
441 * library uses this approach to workaround zero-initialized p_paddrs
442 * when obtaining lma - look at elf.c of BDF)
444 for (nload
= 0, i
= 0; i
< elf
->segment_count
; i
++)
445 if (elf
->segments32
[i
].p_paddr
!= 0)
447 else if ((field32(elf
,
448 elf
->segments32
[i
].p_type
) == PT_LOAD
) &&
449 (field32(elf
, elf
->segments32
[i
].p_memsz
) != 0))
452 if (i
>= elf
->segment_count
&& nload
> 1)
453 load_to_vaddr
= true;
455 /* alloc and fill sections array with loadable segments */
456 image
->sections
= malloc(image
->num_sections
* sizeof(struct imagesection
));
457 if (!image
->sections
) {
458 LOG_ERROR("insufficient memory to perform operation");
459 return ERROR_FILEIO_OPERATION_FAILED
;
462 for (i
= 0, j
= 0; i
< elf
->segment_count
; i
++) {
464 elf
->segments32
[i
].p_type
) == PT_LOAD
) &&
465 (field32(elf
, elf
->segments32
[i
].p_filesz
) != 0)) {
466 image
->sections
[j
].size
= field32(elf
, elf
->segments32
[i
].p_filesz
);
468 image
->sections
[j
].base_address
= field32(elf
,
469 elf
->segments32
[i
].p_vaddr
);
471 image
->sections
[j
].base_address
= field32(elf
,
472 elf
->segments32
[i
].p_paddr
);
473 image
->sections
[j
].private = &elf
->segments32
[i
];
474 image
->sections
[j
].flags
= field32(elf
, elf
->segments32
[i
].p_flags
);
479 image
->start_address_set
= true;
480 image
->start_address
= field32(elf
, elf
->header32
->e_entry
);
485 static int image_elf64_read_headers(struct image
*image
)
487 struct image_elf
*elf
= image
->type_private
;
492 bool load_to_vaddr
= false;
494 retval
= fileio_seek(elf
->fileio
, 0);
495 if (retval
!= ERROR_OK
) {
496 LOG_ERROR("cannot seek to ELF file header, read failed");
500 elf
->header64
= malloc(sizeof(Elf64_Ehdr
));
502 if (!elf
->header64
) {
503 LOG_ERROR("insufficient memory to perform operation");
504 return ERROR_FILEIO_OPERATION_FAILED
;
507 retval
= fileio_read(elf
->fileio
, sizeof(Elf64_Ehdr
), (uint8_t *)elf
->header64
, &read_bytes
);
508 if (retval
!= ERROR_OK
) {
509 LOG_ERROR("cannot read ELF file header, read failed");
510 return ERROR_FILEIO_OPERATION_FAILED
;
512 if (read_bytes
!= sizeof(Elf64_Ehdr
)) {
513 LOG_ERROR("cannot read ELF file header, only partially read");
514 return ERROR_FILEIO_OPERATION_FAILED
;
517 elf
->segment_count
= field16(elf
, elf
->header64
->e_phnum
);
518 if (elf
->segment_count
== 0) {
519 LOG_ERROR("invalid ELF file, no program headers");
520 return ERROR_IMAGE_FORMAT_ERROR
;
523 retval
= fileio_seek(elf
->fileio
, field64(elf
, elf
->header64
->e_phoff
));
524 if (retval
!= ERROR_OK
) {
525 LOG_ERROR("cannot seek to ELF program header table, read failed");
529 elf
->segments64
= malloc(elf
->segment_count
*sizeof(Elf64_Phdr
));
530 if (!elf
->segments64
) {
531 LOG_ERROR("insufficient memory to perform operation");
532 return ERROR_FILEIO_OPERATION_FAILED
;
535 retval
= fileio_read(elf
->fileio
, elf
->segment_count
*sizeof(Elf64_Phdr
),
536 (uint8_t *)elf
->segments64
, &read_bytes
);
537 if (retval
!= ERROR_OK
) {
538 LOG_ERROR("cannot read ELF segment headers, read failed");
541 if (read_bytes
!= elf
->segment_count
*sizeof(Elf64_Phdr
)) {
542 LOG_ERROR("cannot read ELF segment headers, only partially read");
543 return ERROR_FILEIO_OPERATION_FAILED
;
546 /* count useful segments (loadable), ignore BSS section */
547 image
->num_sections
= 0;
548 for (i
= 0; i
< elf
->segment_count
; i
++)
550 elf
->segments64
[i
].p_type
) == PT_LOAD
) &&
551 (field64(elf
, elf
->segments64
[i
].p_filesz
) != 0))
552 image
->num_sections
++;
554 if (image
->num_sections
== 0) {
555 LOG_ERROR("invalid ELF file, no loadable segments");
556 return ERROR_IMAGE_FORMAT_ERROR
;
560 * some ELF linkers produce binaries with *all* the program header
561 * p_paddr fields zero (there can be however one loadable segment
562 * that has valid physical address 0x0).
563 * If we have such a binary with more than
564 * one PT_LOAD header, then use p_vaddr instead of p_paddr
565 * (ARM ELF standard demands p_paddr = 0 anyway, and BFD
566 * library uses this approach to workaround zero-initialized p_paddrs
567 * when obtaining lma - look at elf.c of BDF)
569 for (nload
= 0, i
= 0; i
< elf
->segment_count
; i
++)
570 if (elf
->segments64
[i
].p_paddr
!= 0)
572 else if ((field32(elf
,
573 elf
->segments64
[i
].p_type
) == PT_LOAD
) &&
574 (field64(elf
, elf
->segments64
[i
].p_memsz
) != 0))
577 if (i
>= elf
->segment_count
&& nload
> 1)
578 load_to_vaddr
= true;
580 /* alloc and fill sections array with loadable segments */
581 image
->sections
= malloc(image
->num_sections
* sizeof(struct imagesection
));
582 if (!image
->sections
) {
583 LOG_ERROR("insufficient memory to perform operation");
584 return ERROR_FILEIO_OPERATION_FAILED
;
587 for (i
= 0, j
= 0; i
< elf
->segment_count
; i
++) {
589 elf
->segments64
[i
].p_type
) == PT_LOAD
) &&
590 (field64(elf
, elf
->segments64
[i
].p_filesz
) != 0)) {
591 image
->sections
[j
].size
= field64(elf
, elf
->segments64
[i
].p_filesz
);
593 image
->sections
[j
].base_address
= field64(elf
,
594 elf
->segments64
[i
].p_vaddr
);
596 image
->sections
[j
].base_address
= field64(elf
,
597 elf
->segments64
[i
].p_paddr
);
598 image
->sections
[j
].private = &elf
->segments64
[i
];
599 image
->sections
[j
].flags
= field32(elf
, elf
->segments64
[i
].p_flags
);
604 image
->start_address_set
= true;
605 image
->start_address
= field64(elf
, elf
->header64
->e_entry
);
610 static int image_elf_read_headers(struct image
*image
)
612 struct image_elf
*elf
= image
->type_private
;
614 unsigned char e_ident
[EI_NIDENT
];
617 retval
= fileio_read(elf
->fileio
, EI_NIDENT
, e_ident
, &read_bytes
);
618 if (retval
!= ERROR_OK
) {
619 LOG_ERROR("cannot read ELF file header, read failed");
620 return ERROR_FILEIO_OPERATION_FAILED
;
622 if (read_bytes
!= EI_NIDENT
) {
623 LOG_ERROR("cannot read ELF file header, only partially read");
624 return ERROR_FILEIO_OPERATION_FAILED
;
627 if (strncmp((char *)e_ident
, ELFMAG
, SELFMAG
) != 0) {
628 LOG_ERROR("invalid ELF file, bad magic number");
629 return ERROR_IMAGE_FORMAT_ERROR
;
632 elf
->endianness
= e_ident
[EI_DATA
];
633 if ((elf
->endianness
!= ELFDATA2LSB
)
634 && (elf
->endianness
!= ELFDATA2MSB
)) {
635 LOG_ERROR("invalid ELF file, unknown endianness setting");
636 return ERROR_IMAGE_FORMAT_ERROR
;
639 switch (e_ident
[EI_CLASS
]) {
641 LOG_DEBUG("ELF32 image detected.");
642 elf
->is_64_bit
= false;
643 return image_elf32_read_headers(image
);
646 LOG_DEBUG("ELF64 image detected.");
647 elf
->is_64_bit
= true;
648 return image_elf64_read_headers(image
);
651 LOG_ERROR("invalid ELF file, only 32/64 bit ELF files are supported");
652 return ERROR_IMAGE_FORMAT_ERROR
;
656 static int image_elf32_read_section(struct image
*image
,
658 target_addr_t offset
,
663 struct image_elf
*elf
= image
->type_private
;
664 Elf32_Phdr
*segment
= (Elf32_Phdr
*)image
->sections
[section
].private;
665 size_t read_size
, really_read
;
670 LOG_DEBUG("load segment %d at 0x%" TARGET_PRIxADDR
" (sz = 0x%" PRIx32
")", section
, offset
, size
);
672 /* read initialized data in current segment if any */
673 if (offset
< field32(elf
, segment
->p_filesz
)) {
674 /* maximal size present in file for the current segment */
675 read_size
= MIN(size
, field32(elf
, segment
->p_filesz
) - offset
);
676 LOG_DEBUG("read elf: size = 0x%zx at 0x%" TARGET_PRIxADDR
"", read_size
,
677 field32(elf
, segment
->p_offset
) + offset
);
678 /* read initialized area of the segment */
679 retval
= fileio_seek(elf
->fileio
, field32(elf
, segment
->p_offset
) + offset
);
680 if (retval
!= ERROR_OK
) {
681 LOG_ERROR("cannot find ELF segment content, seek failed");
684 retval
= fileio_read(elf
->fileio
, read_size
, buffer
, &really_read
);
685 if (retval
!= ERROR_OK
) {
686 LOG_ERROR("cannot read ELF segment content, read failed");
690 *size_read
+= read_size
;
691 /* need more data ? */
699 static int image_elf64_read_section(struct image
*image
,
701 target_addr_t offset
,
706 struct image_elf
*elf
= image
->type_private
;
707 Elf64_Phdr
*segment
= (Elf64_Phdr
*)image
->sections
[section
].private;
708 size_t read_size
, really_read
;
713 LOG_DEBUG("load segment %d at 0x%" TARGET_PRIxADDR
" (sz = 0x%" PRIx32
")", section
, offset
, size
);
715 /* read initialized data in current segment if any */
716 if (offset
< field64(elf
, segment
->p_filesz
)) {
717 /* maximal size present in file for the current segment */
718 read_size
= MIN(size
, field64(elf
, segment
->p_filesz
) - offset
);
719 LOG_DEBUG("read elf: size = 0x%zx at 0x%" TARGET_PRIxADDR
"", read_size
,
720 field64(elf
, segment
->p_offset
) + offset
);
721 /* read initialized area of the segment */
722 retval
= fileio_seek(elf
->fileio
, field64(elf
, segment
->p_offset
) + offset
);
723 if (retval
!= ERROR_OK
) {
724 LOG_ERROR("cannot find ELF segment content, seek failed");
727 retval
= fileio_read(elf
->fileio
, read_size
, buffer
, &really_read
);
728 if (retval
!= ERROR_OK
) {
729 LOG_ERROR("cannot read ELF segment content, read failed");
733 *size_read
+= read_size
;
734 /* need more data ? */
742 static int image_elf_read_section(struct image
*image
,
744 target_addr_t offset
,
749 struct image_elf
*elf
= image
->type_private
;
752 return image_elf64_read_section(image
, section
, offset
, size
, buffer
, size_read
);
754 return image_elf32_read_section(image
, section
, offset
, size
, buffer
, size_read
);
757 static int image_mot_buffer_complete_inner(struct image
*image
,
759 struct imagesection
*section
)
761 struct image_mot
*mot
= image
->type_private
;
762 struct fileio
*fileio
= mot
->fileio
;
763 uint32_t full_address
;
764 uint32_t cooked_bytes
;
765 bool end_rec
= false;
767 /* we can't determine the number of sections that we'll have to create ahead of time,
768 * so we locally hold them until parsing is finished */
772 retval
= fileio_size(fileio
, &filesize
);
773 if (retval
!= ERROR_OK
)
776 mot
->buffer
= malloc(filesize
>> 1);
778 image
->num_sections
= 0;
780 while (!fileio_feof(fileio
)) {
782 section
[image
->num_sections
].private = &mot
->buffer
[cooked_bytes
];
783 section
[image
->num_sections
].base_address
= 0x0;
784 section
[image
->num_sections
].size
= 0x0;
785 section
[image
->num_sections
].flags
= 0;
787 while (fileio_fgets(fileio
, 1023, lpsz_line
) == ERROR_OK
) {
790 uint32_t record_type
;
792 uint8_t cal_checksum
= 0;
793 uint32_t bytes_read
= 0;
795 /* skip comments and blank lines */
796 if ((lpsz_line
[0] == '#') || (strlen(lpsz_line
+ strspn(lpsz_line
, "\n\t\r ")) == 0))
799 /* get record type and record length */
800 if (sscanf(&lpsz_line
[bytes_read
], "S%1" SCNx32
"%2" SCNx32
, &record_type
,
802 return ERROR_IMAGE_FORMAT_ERROR
;
805 cal_checksum
+= (uint8_t)count
;
807 /* skip checksum byte */
810 if (record_type
== 0) {
811 /* S0 - starting record (optional) */
814 while (count
-- > 0) {
815 sscanf(&lpsz_line
[bytes_read
], "%2x", &value
);
816 cal_checksum
+= (uint8_t)value
;
819 } else if (record_type
>= 1 && record_type
<= 3) {
820 switch (record_type
) {
822 /* S1 - 16 bit address data record */
823 sscanf(&lpsz_line
[bytes_read
], "%4" SCNx32
, &address
);
824 cal_checksum
+= (uint8_t)(address
>> 8);
825 cal_checksum
+= (uint8_t)address
;
831 /* S2 - 24 bit address data record */
832 sscanf(&lpsz_line
[bytes_read
], "%6" SCNx32
, &address
);
833 cal_checksum
+= (uint8_t)(address
>> 16);
834 cal_checksum
+= (uint8_t)(address
>> 8);
835 cal_checksum
+= (uint8_t)address
;
841 /* S3 - 32 bit address data record */
842 sscanf(&lpsz_line
[bytes_read
], "%8" SCNx32
, &address
);
843 cal_checksum
+= (uint8_t)(address
>> 24);
844 cal_checksum
+= (uint8_t)(address
>> 16);
845 cal_checksum
+= (uint8_t)(address
>> 8);
846 cal_checksum
+= (uint8_t)address
;
853 if (full_address
!= address
) {
854 /* we encountered a nonconsecutive location, create a new section,
855 * unless the current section has zero size, in which case this specifies
856 * the current section's base address
858 if (section
[image
->num_sections
].size
!= 0) {
859 image
->num_sections
++;
860 section
[image
->num_sections
].size
= 0x0;
861 section
[image
->num_sections
].flags
= 0;
862 section
[image
->num_sections
].private =
863 &mot
->buffer
[cooked_bytes
];
865 section
[image
->num_sections
].base_address
= address
;
866 full_address
= address
;
869 while (count
-- > 0) {
871 sscanf(&lpsz_line
[bytes_read
], "%2x", &value
);
872 mot
->buffer
[cooked_bytes
] = (uint8_t)value
;
873 cal_checksum
+= (uint8_t)mot
->buffer
[cooked_bytes
];
876 section
[image
->num_sections
].size
+= 1;
879 } else if (record_type
== 5 || record_type
== 6) {
880 /* S5 and S6 are the data count records, we ignore them */
883 while (count
-- > 0) {
884 sscanf(&lpsz_line
[bytes_read
], "%2" SCNx32
, &dummy
);
885 cal_checksum
+= (uint8_t)dummy
;
888 } else if (record_type
>= 7 && record_type
<= 9) {
889 /* S7, S8, S9 - ending records for 32, 24 and 16bit */
890 image
->num_sections
++;
892 /* copy section information */
893 image
->sections
= malloc(sizeof(struct imagesection
) * image
->num_sections
);
894 for (unsigned int i
= 0; i
< image
->num_sections
; i
++) {
895 image
->sections
[i
].private = section
[i
].private;
896 image
->sections
[i
].base_address
= section
[i
].base_address
;
897 image
->sections
[i
].size
= section
[i
].size
;
898 image
->sections
[i
].flags
= section
[i
].flags
;
904 LOG_ERROR("unhandled S19 record type: %i", (int)(record_type
));
905 return ERROR_IMAGE_FORMAT_ERROR
;
908 /* account for checksum, will always be 0xFF */
909 sscanf(&lpsz_line
[bytes_read
], "%2" SCNx32
, &checksum
);
910 cal_checksum
+= (uint8_t)checksum
;
912 if (cal_checksum
!= 0xFF) {
913 /* checksum failed */
914 LOG_ERROR("incorrect record checksum found in S19 file");
915 return ERROR_IMAGE_CHECKSUM
;
920 LOG_WARNING("continuing after end-of-file record: %.40s", lpsz_line
);
928 LOG_ERROR("premature end of S19 file, no matching end-of-file record found");
929 return ERROR_IMAGE_FORMAT_ERROR
;
934 * Allocate memory dynamically instead of on the stack. This
935 * is important w/embedded hosts.
937 static int image_mot_buffer_complete(struct image
*image
)
939 char *lpsz_line
= malloc(1023);
941 LOG_ERROR("Out of memory");
944 struct imagesection
*section
= malloc(sizeof(struct imagesection
) * IMAGE_MAX_SECTIONS
);
947 LOG_ERROR("Out of memory");
952 retval
= image_mot_buffer_complete_inner(image
, lpsz_line
, section
);
960 int image_open(struct image
*image
, const char *url
, const char *type_string
)
962 int retval
= ERROR_OK
;
964 retval
= identify_image_type(image
, type_string
, url
);
965 if (retval
!= ERROR_OK
)
968 if (image
->type
== IMAGE_BINARY
) {
969 struct image_binary
*image_binary
;
971 image_binary
= image
->type_private
= malloc(sizeof(struct image_binary
));
973 retval
= fileio_open(&image_binary
->fileio
, url
, FILEIO_READ
, FILEIO_BINARY
);
974 if (retval
!= ERROR_OK
)
977 retval
= fileio_size(image_binary
->fileio
, &filesize
);
978 if (retval
!= ERROR_OK
) {
979 fileio_close(image_binary
->fileio
);
983 image
->num_sections
= 1;
984 image
->sections
= malloc(sizeof(struct imagesection
));
985 image
->sections
[0].base_address
= 0x0;
986 image
->sections
[0].size
= filesize
;
987 image
->sections
[0].flags
= 0;
988 } else if (image
->type
== IMAGE_IHEX
) {
989 struct image_ihex
*image_ihex
;
991 image_ihex
= image
->type_private
= malloc(sizeof(struct image_ihex
));
993 retval
= fileio_open(&image_ihex
->fileio
, url
, FILEIO_READ
, FILEIO_TEXT
);
994 if (retval
!= ERROR_OK
)
997 retval
= image_ihex_buffer_complete(image
);
998 if (retval
!= ERROR_OK
) {
1000 "failed buffering IHEX image, check server output for additional information");
1001 fileio_close(image_ihex
->fileio
);
1004 } else if (image
->type
== IMAGE_ELF
) {
1005 struct image_elf
*image_elf
;
1007 image_elf
= image
->type_private
= malloc(sizeof(struct image_elf
));
1009 retval
= fileio_open(&image_elf
->fileio
, url
, FILEIO_READ
, FILEIO_BINARY
);
1010 if (retval
!= ERROR_OK
)
1013 retval
= image_elf_read_headers(image
);
1014 if (retval
!= ERROR_OK
) {
1015 fileio_close(image_elf
->fileio
);
1018 } else if (image
->type
== IMAGE_MEMORY
) {
1019 struct target
*target
= get_target(url
);
1022 LOG_ERROR("target '%s' not defined", url
);
1026 struct image_memory
*image_memory
;
1028 image
->num_sections
= 1;
1029 image
->sections
= malloc(sizeof(struct imagesection
));
1030 image
->sections
[0].base_address
= 0x0;
1031 image
->sections
[0].size
= 0xffffffff;
1032 image
->sections
[0].flags
= 0;
1034 image_memory
= image
->type_private
= malloc(sizeof(struct image_memory
));
1036 image_memory
->target
= target
;
1037 image_memory
->cache
= NULL
;
1038 image_memory
->cache_address
= 0x0;
1039 } else if (image
->type
== IMAGE_SRECORD
) {
1040 struct image_mot
*image_mot
;
1042 image_mot
= image
->type_private
= malloc(sizeof(struct image_mot
));
1044 retval
= fileio_open(&image_mot
->fileio
, url
, FILEIO_READ
, FILEIO_TEXT
);
1045 if (retval
!= ERROR_OK
)
1048 retval
= image_mot_buffer_complete(image
);
1049 if (retval
!= ERROR_OK
) {
1051 "failed buffering S19 image, check server output for additional information");
1052 fileio_close(image_mot
->fileio
);
1055 } else if (image
->type
== IMAGE_BUILDER
) {
1056 image
->num_sections
= 0;
1057 image
->base_address_set
= false;
1058 image
->sections
= NULL
;
1059 image
->type_private
= NULL
;
1062 if (image
->base_address_set
) {
1064 for (unsigned int section
= 0; section
< image
->num_sections
; section
++)
1065 image
->sections
[section
].base_address
+= image
->base_address
;
1066 /* we're done relocating. The two statements below are mainly
1067 * for documentation purposes: stop anyone from empirically
1068 * thinking they should use these values henceforth. */
1069 image
->base_address
= 0;
1070 image
->base_address_set
= false;
1076 int image_read_section(struct image
*image
,
1078 target_addr_t offset
,
1085 /* don't read past the end of a section */
1086 if (offset
+ size
> image
->sections
[section
].size
) {
1088 "read past end of section: 0x%8.8" TARGET_PRIxADDR
" + 0x%8.8" PRIx32
" > 0x%8.8" PRIx32
"",
1091 image
->sections
[section
].size
);
1092 return ERROR_COMMAND_SYNTAX_ERROR
;
1095 if (image
->type
== IMAGE_BINARY
) {
1096 struct image_binary
*image_binary
= image
->type_private
;
1098 /* only one section in a plain binary */
1100 return ERROR_COMMAND_SYNTAX_ERROR
;
1102 /* seek to offset */
1103 retval
= fileio_seek(image_binary
->fileio
, offset
);
1104 if (retval
!= ERROR_OK
)
1107 /* return requested bytes */
1108 retval
= fileio_read(image_binary
->fileio
, size
, buffer
, size_read
);
1109 if (retval
!= ERROR_OK
)
1111 } else if (image
->type
== IMAGE_IHEX
) {
1112 memcpy(buffer
, (uint8_t *)image
->sections
[section
].private + offset
, size
);
1116 } else if (image
->type
== IMAGE_ELF
) {
1117 return image_elf_read_section(image
, section
, offset
, size
, buffer
, size_read
);
1118 } else if (image
->type
== IMAGE_MEMORY
) {
1119 struct image_memory
*image_memory
= image
->type_private
;
1120 uint32_t address
= image
->sections
[section
].base_address
+ offset
;
1124 while ((size
- *size_read
) > 0) {
1125 uint32_t size_in_cache
;
1127 if (!image_memory
->cache
1128 || (address
< image_memory
->cache_address
)
1130 (image_memory
->cache_address
+ IMAGE_MEMORY_CACHE_SIZE
))) {
1131 if (!image_memory
->cache
)
1132 image_memory
->cache
= malloc(IMAGE_MEMORY_CACHE_SIZE
);
1134 if (target_read_buffer(image_memory
->target
, address
&
1135 ~(IMAGE_MEMORY_CACHE_SIZE
- 1),
1136 IMAGE_MEMORY_CACHE_SIZE
, image_memory
->cache
) != ERROR_OK
) {
1137 free(image_memory
->cache
);
1138 image_memory
->cache
= NULL
;
1139 return ERROR_IMAGE_TEMPORARILY_UNAVAILABLE
;
1141 image_memory
->cache_address
= address
&
1142 ~(IMAGE_MEMORY_CACHE_SIZE
- 1);
1146 (image_memory
->cache_address
+ IMAGE_MEMORY_CACHE_SIZE
) - address
;
1148 memcpy(buffer
+ *size_read
,
1149 image_memory
->cache
+ (address
- image_memory
->cache_address
),
1150 (size_in_cache
> size
) ? size
: size_in_cache
1153 *size_read
+= (size_in_cache
> size
) ? size
: size_in_cache
;
1154 address
+= (size_in_cache
> size
) ? size
: size_in_cache
;
1156 } else if (image
->type
== IMAGE_SRECORD
) {
1157 memcpy(buffer
, (uint8_t *)image
->sections
[section
].private + offset
, size
);
1161 } else if (image
->type
== IMAGE_BUILDER
) {
1162 memcpy(buffer
, (uint8_t *)image
->sections
[section
].private + offset
, size
);
1171 int image_add_section(struct image
*image
, target_addr_t base
, uint32_t size
, int flags
, uint8_t const *data
)
1173 struct imagesection
*section
;
1175 /* only image builder supports adding sections */
1176 if (image
->type
!= IMAGE_BUILDER
)
1177 return ERROR_COMMAND_SYNTAX_ERROR
;
1179 /* see if there's a previous section */
1180 if (image
->num_sections
) {
1181 section
= &image
->sections
[image
->num_sections
- 1];
1183 /* see if it's enough to extend the last section,
1184 * adding data to previous sections or merging is not supported */
1185 if (((section
->base_address
+ section
->size
) == base
) &&
1186 (section
->flags
== flags
)) {
1187 section
->private = realloc(section
->private, section
->size
+ size
);
1188 memcpy((uint8_t *)section
->private + section
->size
, data
, size
);
1189 section
->size
+= size
;
1194 /* allocate new section */
1195 image
->num_sections
++;
1197 realloc(image
->sections
, sizeof(struct imagesection
) * image
->num_sections
);
1198 section
= &image
->sections
[image
->num_sections
- 1];
1199 section
->base_address
= base
;
1200 section
->size
= size
;
1201 section
->flags
= flags
;
1202 section
->private = malloc(sizeof(uint8_t) * size
);
1203 memcpy((uint8_t *)section
->private, data
, size
);
1208 void image_close(struct image
*image
)
1210 if (image
->type
== IMAGE_BINARY
) {
1211 struct image_binary
*image_binary
= image
->type_private
;
1213 fileio_close(image_binary
->fileio
);
1214 } else if (image
->type
== IMAGE_IHEX
) {
1215 struct image_ihex
*image_ihex
= image
->type_private
;
1217 fileio_close(image_ihex
->fileio
);
1219 free(image_ihex
->buffer
);
1220 image_ihex
->buffer
= NULL
;
1221 } else if (image
->type
== IMAGE_ELF
) {
1222 struct image_elf
*image_elf
= image
->type_private
;
1224 fileio_close(image_elf
->fileio
);
1226 if (image_elf
->is_64_bit
) {
1227 free(image_elf
->header64
);
1228 image_elf
->header64
= NULL
;
1230 free(image_elf
->segments64
);
1231 image_elf
->segments64
= NULL
;
1233 free(image_elf
->header32
);
1234 image_elf
->header32
= NULL
;
1236 free(image_elf
->segments32
);
1237 image_elf
->segments32
= NULL
;
1239 } else if (image
->type
== IMAGE_MEMORY
) {
1240 struct image_memory
*image_memory
= image
->type_private
;
1242 free(image_memory
->cache
);
1243 image_memory
->cache
= NULL
;
1244 } else if (image
->type
== IMAGE_SRECORD
) {
1245 struct image_mot
*image_mot
= image
->type_private
;
1247 fileio_close(image_mot
->fileio
);
1249 free(image_mot
->buffer
);
1250 image_mot
->buffer
= NULL
;
1251 } else if (image
->type
== IMAGE_BUILDER
) {
1252 for (unsigned int i
= 0; i
< image
->num_sections
; i
++) {
1253 free(image
->sections
[i
].private);
1254 image
->sections
[i
].private = NULL
;
1258 free(image
->type_private
);
1259 image
->type_private
= NULL
;
1261 free(image
->sections
);
1262 image
->sections
= NULL
;
1265 int image_calculate_checksum(const uint8_t *buffer
, uint32_t nbytes
, uint32_t *checksum
)
1267 uint32_t crc
= 0xffffffff;
1268 LOG_DEBUG("Calculating checksum");
1270 static uint32_t crc32_table
[256];
1272 static bool first_init
;
1274 /* Initialize the CRC table and the decoding table. */
1275 unsigned int i
, j
, c
;
1276 for (i
= 0; i
< 256; i
++) {
1278 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
1279 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
1286 while (nbytes
> 0) {
1293 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buffer
++) & 255];
1298 LOG_DEBUG("Calculating checksum done; checksum=0x%" PRIx32
, crc
);
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)