Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- fixed relocation problems with image loading. Relocation is handled
[openocd.git] / src / target / image.c
1 /***************************************************************************
2 * Copyright (C) 2007 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #include <stdlib.h>
25 #include <string.h>
26 #ifdef HAVE_ELF_H
27 #include <elf.h>
28 #endif
29
30 #include "image.h"
31
32 #include "types.h"
33 #include "replacements.h"
34 #include "log.h"
35
36 #include "fileio.h"
37 #include "target.h"
38
39 /* convert ELF header field to host endianness */
40 #define field16(elf,field)\
41 ((elf->endianness==ELFDATA2LSB)? \
42 le_to_h_u16((u8*)&field):be_to_h_u16((u8*)&field))
43
44 #define field32(elf,field)\
45 ((elf->endianness==ELFDATA2LSB)? \
46 le_to_h_u32((u8*)&field):be_to_h_u32((u8*)&field))
47
48 static int autodetect_image_type(image_t *image, char *url)
49 {
50 int retval;
51 fileio_t fileio;
52 u32 read_bytes;
53 u8 buffer[9];
54
55 /* read the first 4 bytes of image */
56 if ((retval = fileio_open(&fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK)
57 {
58 snprintf(image->error_str, IMAGE_MAX_ERROR_STRING, "cannot open image: %s", fileio.error_str);
59 ERROR(image->error_str);
60 return retval;
61 }
62 if ((retval = fileio_read(&fileio, 9, buffer, &read_bytes)) != ERROR_OK)
63 {
64 snprintf(image->error_str, IMAGE_MAX_ERROR_STRING, "cannot read image header: %s", fileio.error_str);
65 ERROR(image->error_str);
66 return ERROR_FILEIO_OPERATION_FAILED;
67 }
68 if (read_bytes != 9)
69 {
70 snprintf(image->error_str, IMAGE_MAX_ERROR_STRING, "cannot read image, only partially read");
71 ERROR(image->error_str);
72 return ERROR_FILEIO_OPERATION_FAILED;
73 }
74 fileio_close(&fileio);
75
76 /* check header against known signatures */
77 if (strncmp((char*)buffer,ELFMAG,SELFMAG)==0)
78 {
79 DEBUG("ELF image detected.");
80 image->type = IMAGE_ELF;
81 }
82 else if ((buffer[0]==':') /* record start byte */
83 &&(isxdigit(buffer[1]))
84 &&(isxdigit(buffer[2]))
85 &&(isxdigit(buffer[3]))
86 &&(isxdigit(buffer[4]))
87 &&(isxdigit(buffer[5]))
88 &&(isxdigit(buffer[6]))
89 &&(buffer[7]=='0') /* record type : 00 -> 05 */
90 &&(buffer[8]>='0')&&(buffer[8]<'6'))
91 {
92 DEBUG("IHEX image detected.");
93 image->type = IMAGE_IHEX;
94 }
95 else if ((buffer[0] == 'S') /* record start byte */
96 &&(isxdigit(buffer[1]))
97 &&(isxdigit(buffer[2]))
98 &&(isxdigit(buffer[3]))
99 &&(buffer[1] >= '0') && (buffer[1] < '9'))
100 {
101 DEBUG("S19 image detected.");
102 image->type = IMAGE_SRECORD;
103 }
104 else
105 {
106 image->type = IMAGE_BINARY;
107 }
108
109 return ERROR_OK;
110 }
111
112 int identify_image_type(image_t *image, char *type_string, char *url)
113 {
114 if (type_string)
115 {
116 if (!strcmp(type_string, "bin"))
117 {
118 image->type = IMAGE_BINARY;
119 }
120 else if (!strcmp(type_string, "ihex"))
121 {
122 image->type = IMAGE_IHEX;
123 }
124 else if (!strcmp(type_string, "elf"))
125 {
126 image->type = IMAGE_ELF;
127 }
128 else if (!strcmp(type_string, "mem"))
129 {
130 image->type = IMAGE_MEMORY;
131 }
132 else if (!strcmp(type_string, "s19"))
133 {
134 image->type = IMAGE_SRECORD;
135 }
136 else if (!strcmp(type_string, "build"))
137 {
138 image->type = IMAGE_BUILDER;
139 }
140 else
141 {
142 return ERROR_IMAGE_TYPE_UNKNOWN;
143 }
144 }
145 else
146 {
147 return autodetect_image_type(image, url);
148 }
149
150 return ERROR_OK;
151 }
152
153 int image_ihex_buffer_complete(image_t *image)
154 {
155 image_ihex_t *ihex = image->type_private;
156 fileio_t *fileio = &ihex->fileio;
157 u32 full_address = 0x0;
158 u32 cooked_bytes;
159 int i;
160 char lpszLine[1023];
161
162 /* we can't determine the number of sections that we'll have to create ahead of time,
163 * so we locally hold them until parsing is finished */
164 image_section_t section[IMAGE_MAX_SECTIONS];
165
166 ihex->buffer = malloc(fileio->size >> 1);
167 cooked_bytes = 0x0;
168 image->num_sections = 0;
169 section[image->num_sections].private = &ihex->buffer[cooked_bytes];
170 section[image->num_sections].base_address = 0x0;
171 section[image->num_sections].size = 0x0;
172 section[image->num_sections].flags = 0;
173
174 while (fileio_fgets(fileio, 1023, lpszLine) == ERROR_OK)
175 {
176 u32 count;
177 u32 address;
178 u32 record_type;
179 u32 checksum;
180 u8 cal_checksum = 0;
181 u32 bytes_read = 0;
182
183 if (sscanf(&lpszLine[bytes_read], ":%2x%4x%2x", &count, &address, &record_type) != 3)
184 {
185 return ERROR_IMAGE_FORMAT_ERROR;
186 }
187 bytes_read += 9;
188
189 cal_checksum += (u8)count;
190 cal_checksum += (u8)(address >> 8);
191 cal_checksum += (u8)address;
192 cal_checksum += (u8)record_type;
193
194 if (record_type == 0) /* Data Record */
195 {
196 if ((full_address & 0xffff) != address)
197 {
198 /* we encountered a nonconsecutive location, create a new section,
199 * unless the current section has zero size, in which case this specifies
200 * the current section's base address
201 */
202 if (section[image->num_sections].size != 0)
203 {
204 image->num_sections++;
205 section[image->num_sections].size = 0x0;
206 section[image->num_sections].flags = 0;
207 section[image->num_sections].private = &ihex->buffer[cooked_bytes];
208 }
209 section[image->num_sections].base_address =
210 (full_address & 0xffff0000) | address;
211 full_address = (full_address & 0xffff0000) | address;
212 }
213
214 while (count-- > 0)
215 {
216 sscanf(&lpszLine[bytes_read], "%2x", (u32*)&ihex->buffer[cooked_bytes]);
217 cal_checksum += (u8)ihex->buffer[cooked_bytes];
218 bytes_read += 2;
219 cooked_bytes += 1;
220 section[image->num_sections].size += 1;
221 full_address++;
222 }
223 }
224 else if (record_type == 1) /* End of File Record */
225 {
226 /* finish the current section */
227 image->num_sections++;
228
229 /* copy section information */
230 image->sections = malloc(sizeof(image_section_t) * image->num_sections);
231 for (i = 0; i < image->num_sections; i++)
232 {
233 image->sections[i].private = section[i].private;
234 image->sections[i].base_address = section[i].base_address;
235 image->sections[i].size = section[i].size;
236 image->sections[i].flags = section[i].flags;
237 }
238
239 return ERROR_OK;
240 }
241 else if (record_type == 2) /* Linear Address Record */
242 {
243 u16 upper_address;
244
245 sscanf(&lpszLine[bytes_read], "%4hx", &upper_address);
246 cal_checksum += (u8)(upper_address >> 8);
247 cal_checksum += (u8)upper_address;
248 bytes_read += 4;
249
250 if ((full_address >> 4) != upper_address)
251 {
252 /* we encountered a nonconsecutive location, create a new section,
253 * unless the current section has zero size, in which case this specifies
254 * the current section's base address
255 */
256 if (section[image->num_sections].size != 0)
257 {
258 image->num_sections++;
259 section[image->num_sections].size = 0x0;
260 section[image->num_sections].flags = 0;
261 section[image->num_sections].private = &ihex->buffer[cooked_bytes];
262 }
263 section[image->num_sections].base_address =
264 (full_address & 0xffff) | (upper_address << 4);
265 full_address = (full_address & 0xffff) | (upper_address << 4);
266 }
267 }
268 else if (record_type == 4) /* Extended Linear Address Record */
269 {
270 u16 upper_address;
271
272 sscanf(&lpszLine[bytes_read], "%4hx", &upper_address);
273 cal_checksum += (u8)(upper_address >> 8);
274 cal_checksum += (u8)upper_address;
275 bytes_read += 4;
276
277 if ((full_address >> 16) != upper_address)
278 {
279 /* we encountered a nonconsecutive location, create a new section,
280 * unless the current section has zero size, in which case this specifies
281 * the current section's base address
282 */
283 if (section[image->num_sections].size != 0)
284 {
285 image->num_sections++;
286 section[image->num_sections].size = 0x0;
287 section[image->num_sections].flags = 0;
288 section[image->num_sections].private = &ihex->buffer[cooked_bytes];
289 }
290 section[image->num_sections].base_address =
291 (full_address & 0xffff) | (upper_address << 16);
292 full_address = (full_address & 0xffff) | (upper_address << 16);
293 }
294 }
295 else if (record_type == 5) /* Start Linear Address Record */
296 {
297 u32 start_address;
298
299 sscanf(&lpszLine[bytes_read], "%8x", &start_address);
300 cal_checksum += (u8)(start_address >> 24);
301 cal_checksum += (u8)(start_address >> 16);
302 cal_checksum += (u8)(start_address >> 8);
303 cal_checksum += (u8)start_address;
304 bytes_read += 8;
305
306 image->start_address_set = 1;
307 image->start_address = be_to_h_u32((u8*)&start_address);
308 }
309 else
310 {
311 ERROR("unhandled IHEX record type: %i", record_type);
312 return ERROR_IMAGE_FORMAT_ERROR;
313 }
314
315 sscanf(&lpszLine[bytes_read], "%2x", &checksum);
316 bytes_read += 2;
317
318 if ((u8)checksum != (u8)(~cal_checksum + 1))
319 {
320 /* checksum failed */
321 ERROR("incorrect record checksum found in IHEX file");
322 return ERROR_IMAGE_CHECKSUM;
323 }
324 }
325
326 ERROR("premature end of IHEX file, no end-of-file record found");
327 return ERROR_IMAGE_FORMAT_ERROR;
328 }
329
330 int image_elf_read_headers(image_t *image)
331 {
332 image_elf_t *elf = image->type_private;
333 u32 read_bytes;
334 u32 i,j;
335 int retval;
336
337 elf->header = malloc(sizeof(Elf32_Ehdr));
338
339 if ((retval = fileio_read(&elf->fileio, sizeof(Elf32_Ehdr), (u8*)elf->header, &read_bytes)) != ERROR_OK)
340 {
341 ERROR("cannot read ELF file header, read failed");
342 return ERROR_FILEIO_OPERATION_FAILED;
343 }
344 if (read_bytes != sizeof(Elf32_Ehdr))
345 {
346 ERROR("cannot read ELF file header, only partially read");
347 return ERROR_FILEIO_OPERATION_FAILED;
348 }
349
350 if (strncmp((char*)elf->header->e_ident,ELFMAG,SELFMAG)!=0)
351 {
352 ERROR("invalid ELF file, bad magic number");
353 return ERROR_IMAGE_FORMAT_ERROR;
354 }
355 if (elf->header->e_ident[EI_CLASS]!=ELFCLASS32)
356 {
357 ERROR("invalid ELF file, only 32bits files are supported");
358 return ERROR_IMAGE_FORMAT_ERROR;
359 }
360
361
362 elf->endianness = elf->header->e_ident[EI_DATA];
363 if ((elf->endianness!=ELFDATA2LSB)
364 &&(elf->endianness!=ELFDATA2MSB))
365 {
366 ERROR("invalid ELF file, unknown endianess setting");
367 return ERROR_IMAGE_FORMAT_ERROR;
368 }
369
370 elf->segment_count = field16(elf,elf->header->e_phnum);
371 if (elf->segment_count==0)
372 {
373 ERROR("invalid ELF file, no program headers");
374 return ERROR_IMAGE_FORMAT_ERROR;
375 }
376
377 elf->segments = malloc(elf->segment_count*sizeof(Elf32_Phdr));
378
379 if ((retval = fileio_read(&elf->fileio, elf->segment_count*sizeof(Elf32_Phdr), (u8*)elf->segments, &read_bytes)) != ERROR_OK)
380 {
381 ERROR("cannot read ELF segment headers, read failed");
382 return retval;
383 }
384 if (read_bytes != elf->segment_count*sizeof(Elf32_Phdr))
385 {
386 ERROR("cannot read ELF segment headers, only partially read");
387 return ERROR_FILEIO_OPERATION_FAILED;
388 }
389
390 /* count useful segments (loadable), ignore BSS section */
391 image->num_sections = 0;
392 for (i=0;i<elf->segment_count;i++)
393 if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0))
394 image->num_sections++;
395 /* alloc and fill sections array with loadable segments */
396 image->sections = malloc(image->num_sections * sizeof(image_section_t));
397 for (i=0,j=0;i<elf->segment_count;i++)
398 {
399 if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0))
400 {
401 image->sections[j].size = field32(elf,elf->segments[i].p_memsz);
402 image->sections[j].base_address = field32(elf,elf->segments[i].p_paddr);
403 image->sections[j].private = &elf->segments[i];
404 image->sections[j].flags = field32(elf,elf->segments[i].p_flags);
405 j++;
406 }
407 }
408
409 image->start_address_set = 1;
410 image->start_address = field32(elf,elf->header->e_entry);
411
412 return ERROR_OK;
413 }
414
415 int image_elf_read_section(image_t *image, int section, u32 offset, u32 size, u8 *buffer, u32 *size_read)
416 {
417 image_elf_t *elf = image->type_private;
418 Elf32_Phdr *segment = (Elf32_Phdr *)image->sections[section].private;
419 u32 read_size,really_read;
420 int retval;
421
422 *size_read = 0;
423
424 DEBUG("load segment %d at 0x%x (sz=0x%x)",section,offset,size);
425
426 /* read initialized data in current segment if any */
427 if (offset<field32(elf,segment->p_filesz))
428 {
429 /* maximal size present in file for the current segment */
430 read_size = MIN(size, field32(elf,segment->p_filesz)-offset);
431 DEBUG("read elf: size = 0x%x at 0x%x",read_size,
432 field32(elf,segment->p_offset)+offset);
433 /* read initialized area of the segment */
434 if ((retval = fileio_seek(&elf->fileio, field32(elf,segment->p_offset)+offset)) != ERROR_OK)
435 {
436 ERROR("cannot find ELF segment content, seek failed");
437 return retval;
438 }
439 if ((retval = fileio_read(&elf->fileio, read_size, buffer, &really_read)) != ERROR_OK)
440 {
441 ERROR("cannot read ELF segment content, read failed");
442 return retval;
443 }
444 buffer += read_size;
445 size -= read_size;
446 offset += read_size;
447 *size_read += read_size;
448 /* need more data ? */
449 if (!size)
450 return ERROR_OK;
451 }
452 /* if there is remaining zeroed area in current segment */
453 if (offset<field32(elf,segment->p_memsz))
454 {
455 /* fill zeroed part (BSS) of the segment */
456 read_size = MIN(size, field32(elf,segment->p_memsz)-offset);
457 DEBUG("zero fill: size = 0x%x",read_size);
458 memset(buffer,0,read_size);
459 *size_read += read_size;
460 }
461
462 return ERROR_OK;
463 }
464
465 int image_mot_buffer_complete(image_t *image)
466 {
467 image_mot_t *mot = image->type_private;
468 fileio_t *fileio = &mot->fileio;
469 u32 full_address = 0x0;
470 u32 cooked_bytes;
471 int i;
472 char lpszLine[1023];
473
474 /* we can't determine the number of sections that we'll have to create ahead of time,
475 * so we locally hold them until parsing is finished */
476 image_section_t section[IMAGE_MAX_SECTIONS];
477
478 mot->buffer = malloc(fileio->size >> 1);
479 cooked_bytes = 0x0;
480 image->num_sections = 0;
481 section[image->num_sections].private = &mot->buffer[cooked_bytes];
482 section[image->num_sections].base_address = 0x0;
483 section[image->num_sections].size = 0x0;
484 section[image->num_sections].flags = 0;
485
486 while (fileio_fgets(fileio, 1023, lpszLine) == ERROR_OK)
487 {
488 u32 count;
489 u32 address;
490 u32 record_type;
491 u32 checksum;
492 u8 cal_checksum = 0;
493 u32 bytes_read = 0;
494
495 /* get record type and record length */
496 if (sscanf(&lpszLine[bytes_read], "S%1x%2x", &record_type, &count) != 2)
497 {
498 return ERROR_IMAGE_FORMAT_ERROR;
499 }
500
501 bytes_read += 4;
502 cal_checksum += (u8)count;
503
504 /* skip checksum byte */
505 count -=1;
506
507 if (record_type == 0)
508 {
509 /* S0 - starting record (optional) */
510 int iValue;
511
512 while (count-- > 0) {
513 sscanf(&lpszLine[bytes_read], "%2x", &iValue);
514 cal_checksum += (u8)iValue;
515 bytes_read += 2;
516 }
517 }
518 else if (record_type >= 1 && record_type <= 3)
519 {
520 switch( record_type )
521 {
522 case 1:
523 /* S1 - 16 bit address data record */
524 sscanf(&lpszLine[bytes_read], "%4x", &address);
525 cal_checksum += (u8)(address >> 8);
526 cal_checksum += (u8)address;
527 bytes_read += 4;
528 count -=2;
529 break;
530
531 case 2:
532 /* S2 - 24 bit address data record */
533 sscanf(&lpszLine[bytes_read], "%6x", &address);
534 cal_checksum += (u8)(address >> 16);
535 cal_checksum += (u8)(address >> 8);
536 cal_checksum += (u8)address;
537 bytes_read += 6;
538 count -=3;
539 break;
540
541 case 3:
542 /* S3 - 32 bit address data record */
543 sscanf(&lpszLine[bytes_read], "%8x", &address);
544 cal_checksum += (u8)(address >> 24);
545 cal_checksum += (u8)(address >> 16);
546 cal_checksum += (u8)(address >> 8);
547 cal_checksum += (u8)address;
548 bytes_read += 8;
549 count -=4;
550 break;
551
552 }
553
554 if (full_address != address)
555 {
556 /* we encountered a nonconsecutive location, create a new section,
557 * unless the current section has zero size, in which case this specifies
558 * the current section's base address
559 */
560 if (section[image->num_sections].size != 0)
561 {
562 image->num_sections++;
563 section[image->num_sections].size = 0x0;
564 section[image->num_sections].flags = 0;
565 section[image->num_sections].private = &mot->buffer[cooked_bytes];
566 }
567 section[image->num_sections].base_address = address;
568 full_address = address;
569 }
570
571 while (count-- > 0)
572 {
573 sscanf(&lpszLine[bytes_read], "%2x", (u32*)&mot->buffer[cooked_bytes]);
574 cal_checksum += (u8)mot->buffer[cooked_bytes];
575 bytes_read += 2;
576 cooked_bytes += 1;
577 section[image->num_sections].size += 1;
578 full_address++;
579 }
580 }
581 else if (record_type >= 7 && record_type <= 9)
582 {
583 /* S7, S8, S9 - ending records for 32, 24 and 16bit */
584 image->num_sections++;
585
586 /* copy section information */
587 image->sections = malloc(sizeof(image_section_t) * image->num_sections);
588 for (i = 0; i < image->num_sections; i++)
589 {
590 image->sections[i].private = section[i].private;
591 image->sections[i].base_address = section[i].base_address;
592 image->sections[i].size = section[i].size;
593 image->sections[i].flags = section[i].flags;
594 }
595
596 return ERROR_OK;
597 }
598 else
599 {
600 ERROR("unhandled S19 record type: %i", record_type);
601 return ERROR_IMAGE_FORMAT_ERROR;
602 }
603
604 /* account for checksum, will always be 0xFF */
605 sscanf(&lpszLine[bytes_read], "%2x", &checksum);
606 cal_checksum += (u8)checksum;
607 bytes_read += 2;
608
609 if( cal_checksum != 0xFF )
610 {
611 /* checksum failed */
612 ERROR("incorrect record checksum found in S19 file");
613 return ERROR_IMAGE_CHECKSUM;
614 }
615 }
616
617 ERROR("premature end of S19 file, no end-of-file record found");
618 return ERROR_IMAGE_FORMAT_ERROR;
619 }
620
621 int image_open(image_t *image, char *url, char *type_string)
622 {
623 int retval = ERROR_OK;
624
625 if ((retval = identify_image_type(image, type_string, url)) != ERROR_OK)
626 {
627 return retval;
628 }
629
630 if (image->type == IMAGE_BINARY)
631 {
632 image_binary_t *image_binary;
633
634 image_binary = image->type_private = malloc(sizeof(image_binary_t));
635
636 if ((retval = fileio_open(&image_binary->fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK)
637 {
638 strncpy(image->error_str, image_binary->fileio.error_str, IMAGE_MAX_ERROR_STRING);
639 ERROR(image->error_str);
640 return retval;
641 }
642
643 image->num_sections = 1;
644 image->sections = malloc(sizeof(image_section_t));
645 image->sections[0].base_address = 0x0;
646 image->sections[0].size = image_binary->fileio.size;
647 image->sections[0].flags = 0;
648 }
649 else if (image->type == IMAGE_IHEX)
650 {
651 image_ihex_t *image_ihex;
652
653 image_ihex = image->type_private = malloc(sizeof(image_ihex_t));
654
655 if ((retval = fileio_open(&image_ihex->fileio, url, FILEIO_READ, FILEIO_TEXT)) != ERROR_OK)
656 {
657 strncpy(image->error_str, image_ihex->fileio.error_str, IMAGE_MAX_ERROR_STRING);
658 ERROR(image->error_str);
659 return retval;
660 }
661
662 if ((retval = image_ihex_buffer_complete(image)) != ERROR_OK)
663 {
664 snprintf(image->error_str, IMAGE_MAX_ERROR_STRING,
665 "failed buffering IHEX image, check daemon output for additional information");
666 ERROR(image->error_str);
667 fileio_close(&image_ihex->fileio);
668 return retval;
669 }
670 }
671 else if (image->type == IMAGE_ELF)
672 {
673 image_elf_t *image_elf;
674
675 image_elf = image->type_private = malloc(sizeof(image_elf_t));
676
677 if ((retval = fileio_open(&image_elf->fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK)
678 {
679 strncpy(image->error_str, image_elf->fileio.error_str, IMAGE_MAX_ERROR_STRING);
680 ERROR(image->error_str);
681 return retval;
682 }
683
684 if ((retval = image_elf_read_headers(image)) != ERROR_OK)
685 {
686 snprintf(image->error_str, IMAGE_MAX_ERROR_STRING,
687 "failed to read ELF headers, check daemon output for additional information");
688 ERROR(image->error_str);
689 fileio_close(&image_elf->fileio);
690 return retval;
691 }
692 }
693 else if (image->type == IMAGE_MEMORY)
694 {
695 image_memory_t *image_memory;
696
697 image->num_sections = 1;
698 image->sections = malloc(sizeof(image_section_t));
699 image->sections[0].base_address = 0x0;
700 image->sections[0].size = 0xffffffff;
701 image->sections[0].flags = 0;
702
703 image_memory = image->type_private = malloc(sizeof(image_memory_t));
704
705 image_memory->target = get_target_by_num(strtoul(url, NULL, 0));;
706 image_memory->cache = NULL;
707 image_memory->cache_address = 0x0;
708 }
709 else if (image->type == IMAGE_SRECORD)
710 {
711 image_mot_t *image_mot;
712
713 image_mot = image->type_private = malloc(sizeof(image_mot_t));
714
715 if ((retval = fileio_open(&image_mot->fileio, url, FILEIO_READ, FILEIO_TEXT)) != ERROR_OK)
716 {
717 strncpy(image->error_str, image_mot->fileio.error_str, IMAGE_MAX_ERROR_STRING);
718 ERROR(image->error_str);
719 return retval;
720 }
721
722 if ((retval = image_mot_buffer_complete(image)) != ERROR_OK)
723 {
724 snprintf(image->error_str, IMAGE_MAX_ERROR_STRING,
725 "failed buffering S19 image, check daemon output for additional information");
726 ERROR(image->error_str);
727 fileio_close(&image_mot->fileio);
728 return retval;
729 }
730 }
731 else if (image->type == IMAGE_BUILDER)
732 {
733 image->num_sections = 0;
734 image->sections = NULL;
735 image->type_private = NULL;
736 }
737
738 if (image->base_address_set)
739 {
740 // relocate
741 int section;
742 for (section=0; section < image->num_sections; section++)
743 {
744 image->sections[section].base_address+=image->base_address;
745 }
746 // we're done relocating. The two statements below are mainly
747 // for documenation purposes: stop anyone from empirically
748 // thinking they should use these values henceforth.
749 image->base_address=0;
750 image->base_address_set=0;
751 }
752
753 return retval;
754 };
755
756 int image_read_section(image_t *image, int section, u32 offset, u32 size, u8 *buffer, u32 *size_read)
757 {
758 int retval;
759
760 /* don't read past the end of a section */
761 if (offset + size > image->sections[section].size)
762 {
763 DEBUG("read past end of section: 0x%8.8x + 0x%8.8x > 0x%8.8x",
764 offset, size, image->sections[section].size);
765 return ERROR_INVALID_ARGUMENTS;
766 }
767
768 if (image->type == IMAGE_BINARY)
769 {
770 image_binary_t *image_binary = image->type_private;
771
772 /* only one section in a plain binary */
773 if (section != 0)
774 return ERROR_INVALID_ARGUMENTS;
775
776 /* seek to offset */
777 if ((retval = fileio_seek(&image_binary->fileio, offset)) != ERROR_OK)
778 {
779 strncpy(image->error_str, image_binary->fileio.error_str, IMAGE_MAX_ERROR_STRING);
780 return retval;
781 }
782
783 /* return requested bytes */
784 if ((retval = fileio_read(&image_binary->fileio, size, buffer, size_read)) != ERROR_OK)
785 {
786 strncpy(image->error_str, image_binary->fileio.error_str, IMAGE_MAX_ERROR_STRING);
787 return retval;
788 }
789 }
790 else if (image->type == IMAGE_IHEX)
791 {
792 memcpy(buffer, (u8*)image->sections[section].private + offset, size);
793 *size_read = size;
794 image->error_str[0] = '\0';
795
796 return ERROR_OK;
797 }
798 else if (image->type == IMAGE_ELF)
799 {
800 return image_elf_read_section(image, section, offset, size, buffer, size_read);
801 }
802 else if (image->type == IMAGE_MEMORY)
803 {
804 image_memory_t *image_memory = image->type_private;
805 u32 address = image->sections[section].base_address + offset;
806
807 *size_read = 0;
808
809 while ((size - *size_read) > 0)
810 {
811 u32 size_in_cache;
812
813 if (!image_memory->cache
814 || (address < image_memory->cache_address)
815 || (address >= (image_memory->cache_address + IMAGE_MEMORY_CACHE_SIZE)))
816 {
817 if (!image_memory->cache)
818 image_memory->cache = malloc(IMAGE_MEMORY_CACHE_SIZE);
819
820 if (target_read_buffer(image_memory->target, address & ~(IMAGE_MEMORY_CACHE_SIZE - 1),
821 IMAGE_MEMORY_CACHE_SIZE, image_memory->cache) != ERROR_OK)
822 {
823 free(image_memory->cache);
824 return ERROR_IMAGE_TEMPORARILY_UNAVAILABLE;
825 }
826 image_memory->cache_address = address & ~(IMAGE_MEMORY_CACHE_SIZE - 1);
827 }
828
829 size_in_cache = (image_memory->cache_address + IMAGE_MEMORY_CACHE_SIZE) - address;
830
831 memcpy(buffer + *size_read,
832 image_memory->cache + (address - image_memory->cache_address),
833 (size_in_cache > size) ? size : size_in_cache
834 );
835
836 *size_read += (size_in_cache > size) ? size : size_in_cache;
837 address += (size_in_cache > size) ? size : size_in_cache;
838 }
839 }
840 else if (image->type == IMAGE_SRECORD)
841 {
842 memcpy(buffer, (u8*)image->sections[section].private + offset, size);
843 *size_read = size;
844 image->error_str[0] = '\0';
845
846 return ERROR_OK;
847 }
848 else if (image->type == IMAGE_BUILDER)
849 {
850 memcpy(buffer, (u8*)image->sections[section].private + offset, size);
851 *size_read = size;
852 image->error_str[0] = '\0';
853
854 return ERROR_OK;
855 }
856
857 return ERROR_OK;
858 }
859
860 int image_add_section(image_t *image, u32 base, u32 size, int flags, u8 *data)
861 {
862 image_section_t *section;
863
864 /* only image builder supports adding sections */
865 if (image->type != IMAGE_BUILDER)
866 return ERROR_INVALID_ARGUMENTS;
867
868 /* see if there's a previous section */
869 if (image->num_sections)
870 {
871 section = &image->sections[image->num_sections - 1];
872
873 /* see if it's enough to extend the last section,
874 * adding data to previous sections or merging is not supported */
875 if (((section->base_address + section->size) == base) && (section->flags == flags))
876 {
877 section->private = realloc(section->private, section->size + size);
878 memcpy((u8*)section->private + section->size, data, size);
879 section->size += size;
880 return ERROR_OK;
881 }
882 }
883
884 /* allocate new section */
885 image->num_sections++;
886 image->sections = realloc(image->sections, sizeof(image_section_t) * image->num_sections);
887 section = &image->sections[image->num_sections - 1];
888 section->base_address = base;
889 section->size = size;
890 section->flags = flags;
891 section->private = malloc(sizeof(u8) * size);
892 memcpy((u8*)section->private, data, size);
893
894 return ERROR_OK;
895 }
896
897 int image_close(image_t *image)
898 {
899 if (image->type == IMAGE_BINARY)
900 {
901 image_binary_t *image_binary = image->type_private;
902
903 fileio_close(&image_binary->fileio);
904 }
905 else if (image->type == IMAGE_IHEX)
906 {
907 image_ihex_t *image_ihex = image->type_private;
908
909 fileio_close(&image_ihex->fileio);
910
911 if (image_ihex->buffer)
912 free(image_ihex->buffer);
913 }
914 else if (image->type == IMAGE_ELF)
915 {
916 image_elf_t *image_elf = image->type_private;
917
918 fileio_close(&image_elf->fileio);
919
920 if (image_elf->header)
921 free(image_elf->header);
922
923 if (image_elf->segments)
924 free(image_elf->segments);
925 }
926 else if (image->type == IMAGE_MEMORY)
927 {
928 image_memory_t *image_memory = image->type_private;
929
930 if (image_memory->cache)
931 free(image_memory->cache);
932 }
933 else if (image->type == IMAGE_SRECORD)
934 {
935 image_mot_t *image_mot = image->type_private;
936
937 fileio_close(&image_mot->fileio);
938
939 if (image_mot->buffer)
940 free(image_mot->buffer);
941 }
942 else if (image->type == IMAGE_BUILDER)
943 {
944 int i;
945
946 for (i = 0; i < image->num_sections; i++)
947 {
948 free(image->sections[i].private);
949 }
950 }
951
952 if (image->type_private)
953 free(image->type_private);
954
955 if (image->sections)
956 free(image->sections);
957
958 return ERROR_OK;
959 }
960
961 static u32 crc32_table[256] = {0, 0};
962
963 int image_calculate_checksum(u8* buffer, u32 nbytes, u32* checksum)
964 {
965 u32 crc = 0xffffffff;
966
967 if (!crc32_table[1])
968 {
969 /* Initialize the CRC table and the decoding table. */
970 int i, j;
971 unsigned int c;
972 for (i = 0; i < 256; i++)
973 {
974 /* as per gdb */
975 for (c = i << 24, j = 8; j > 0; --j)
976 c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
977 crc32_table[i] = c;
978 }
979 }
980
981 while (nbytes--)
982 {
983 /* as per gdb */
984 crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buffer++) & 255];
985 }
986
987 *checksum = crc;
988 return ERROR_OK;
989 }
990
Open On-Chip Debugger

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)