PPC: e500mc: add missing IVORs to bitmap
[qemu.git] / hw / loader.c
1 /*
2 * QEMU Executable loader
3 *
4 * Copyright (c) 2006 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 *
24 * Gunzip functionality in this file is derived from u-boot:
25 *
26 * (C) Copyright 2008 Semihalf
27 *
28 * (C) Copyright 2000-2005
29 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
30 *
31 * This program is free software; you can redistribute it and/or
32 * modify it under the terms of the GNU General Public License as
33 * published by the Free Software Foundation; either version 2 of
34 * the License, or (at your option) any later version.
35 *
36 * This program is distributed in the hope that it will be useful,
37 * but WITHOUT ANY WARRANTY; without even the implied warranty of
38 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
39 * GNU General Public License for more details.
40 *
41 * You should have received a copy of the GNU General Public License along
42 * with this program; if not, see <http://www.gnu.org/licenses/>.
43 */
44
45 #include "hw.h"
46 #include "disas.h"
47 #include "monitor.h"
48 #include "sysemu.h"
49 #include "uboot_image.h"
50 #include "loader.h"
51 #include "fw_cfg.h"
52 #include "memory.h"
53 #include "exec-memory.h"
54
55 #include <zlib.h>
56
57 static int roms_loaded;
58
59 /* return the size or -1 if error */
60 int get_image_size(const char *filename)
61 {
62 int fd, size;
63 fd = open(filename, O_RDONLY | O_BINARY);
64 if (fd < 0)
65 return -1;
66 size = lseek(fd, 0, SEEK_END);
67 close(fd);
68 return size;
69 }
70
71 /* return the size or -1 if error */
72 /* deprecated, because caller does not specify buffer size! */
73 int load_image(const char *filename, uint8_t *addr)
74 {
75 int fd, size;
76 fd = open(filename, O_RDONLY | O_BINARY);
77 if (fd < 0)
78 return -1;
79 size = lseek(fd, 0, SEEK_END);
80 lseek(fd, 0, SEEK_SET);
81 if (read(fd, addr, size) != size) {
82 close(fd);
83 return -1;
84 }
85 close(fd);
86 return size;
87 }
88
89 /* read()-like version */
90 ssize_t read_targphys(const char *name,
91 int fd, target_phys_addr_t dst_addr, size_t nbytes)
92 {
93 uint8_t *buf;
94 ssize_t did;
95
96 buf = g_malloc(nbytes);
97 did = read(fd, buf, nbytes);
98 if (did > 0)
99 rom_add_blob_fixed("read", buf, did, dst_addr);
100 g_free(buf);
101 return did;
102 }
103
104 /* return the size or -1 if error */
105 int load_image_targphys(const char *filename,
106 target_phys_addr_t addr, int max_sz)
107 {
108 int size;
109
110 size = get_image_size(filename);
111 if (size > max_sz) {
112 return -1;
113 }
114 if (size > 0) {
115 rom_add_file_fixed(filename, addr, -1);
116 }
117 return size;
118 }
119
120 void pstrcpy_targphys(const char *name, target_phys_addr_t dest, int buf_size,
121 const char *source)
122 {
123 const char *nulp;
124 char *ptr;
125
126 if (buf_size <= 0) return;
127 nulp = memchr(source, 0, buf_size);
128 if (nulp) {
129 rom_add_blob_fixed(name, source, (nulp - source) + 1, dest);
130 } else {
131 rom_add_blob_fixed(name, source, buf_size, dest);
132 ptr = rom_ptr(dest + buf_size - 1);
133 *ptr = 0;
134 }
135 }
136
137 /* A.OUT loader */
138
139 struct exec
140 {
141 uint32_t a_info; /* Use macros N_MAGIC, etc for access */
142 uint32_t a_text; /* length of text, in bytes */
143 uint32_t a_data; /* length of data, in bytes */
144 uint32_t a_bss; /* length of uninitialized data area, in bytes */
145 uint32_t a_syms; /* length of symbol table data in file, in bytes */
146 uint32_t a_entry; /* start address */
147 uint32_t a_trsize; /* length of relocation info for text, in bytes */
148 uint32_t a_drsize; /* length of relocation info for data, in bytes */
149 };
150
151 static void bswap_ahdr(struct exec *e)
152 {
153 bswap32s(&e->a_info);
154 bswap32s(&e->a_text);
155 bswap32s(&e->a_data);
156 bswap32s(&e->a_bss);
157 bswap32s(&e->a_syms);
158 bswap32s(&e->a_entry);
159 bswap32s(&e->a_trsize);
160 bswap32s(&e->a_drsize);
161 }
162
163 #define N_MAGIC(exec) ((exec).a_info & 0xffff)
164 #define OMAGIC 0407
165 #define NMAGIC 0410
166 #define ZMAGIC 0413
167 #define QMAGIC 0314
168 #define _N_HDROFF(x) (1024 - sizeof (struct exec))
169 #define N_TXTOFF(x) \
170 (N_MAGIC(x) == ZMAGIC ? _N_HDROFF((x)) + sizeof (struct exec) : \
171 (N_MAGIC(x) == QMAGIC ? 0 : sizeof (struct exec)))
172 #define N_TXTADDR(x, target_page_size) (N_MAGIC(x) == QMAGIC ? target_page_size : 0)
173 #define _N_SEGMENT_ROUND(x, target_page_size) (((x) + target_page_size - 1) & ~(target_page_size - 1))
174
175 #define _N_TXTENDADDR(x, target_page_size) (N_TXTADDR(x, target_page_size)+(x).a_text)
176
177 #define N_DATADDR(x, target_page_size) \
178 (N_MAGIC(x)==OMAGIC? (_N_TXTENDADDR(x, target_page_size)) \
179 : (_N_SEGMENT_ROUND (_N_TXTENDADDR(x, target_page_size), target_page_size)))
180
181
182 int load_aout(const char *filename, target_phys_addr_t addr, int max_sz,
183 int bswap_needed, target_phys_addr_t target_page_size)
184 {
185 int fd;
186 ssize_t size, ret;
187 struct exec e;
188 uint32_t magic;
189
190 fd = open(filename, O_RDONLY | O_BINARY);
191 if (fd < 0)
192 return -1;
193
194 size = read(fd, &e, sizeof(e));
195 if (size < 0)
196 goto fail;
197
198 if (bswap_needed) {
199 bswap_ahdr(&e);
200 }
201
202 magic = N_MAGIC(e);
203 switch (magic) {
204 case ZMAGIC:
205 case QMAGIC:
206 case OMAGIC:
207 if (e.a_text + e.a_data > max_sz)
208 goto fail;
209 lseek(fd, N_TXTOFF(e), SEEK_SET);
210 size = read_targphys(filename, fd, addr, e.a_text + e.a_data);
211 if (size < 0)
212 goto fail;
213 break;
214 case NMAGIC:
215 if (N_DATADDR(e, target_page_size) + e.a_data > max_sz)
216 goto fail;
217 lseek(fd, N_TXTOFF(e), SEEK_SET);
218 size = read_targphys(filename, fd, addr, e.a_text);
219 if (size < 0)
220 goto fail;
221 ret = read_targphys(filename, fd, addr + N_DATADDR(e, target_page_size),
222 e.a_data);
223 if (ret < 0)
224 goto fail;
225 size += ret;
226 break;
227 default:
228 goto fail;
229 }
230 close(fd);
231 return size;
232 fail:
233 close(fd);
234 return -1;
235 }
236
237 /* ELF loader */
238
239 static void *load_at(int fd, int offset, int size)
240 {
241 void *ptr;
242 if (lseek(fd, offset, SEEK_SET) < 0)
243 return NULL;
244 ptr = g_malloc(size);
245 if (read(fd, ptr, size) != size) {
246 g_free(ptr);
247 return NULL;
248 }
249 return ptr;
250 }
251
252 #ifdef ELF_CLASS
253 #undef ELF_CLASS
254 #endif
255
256 #define ELF_CLASS ELFCLASS32
257 #include "elf.h"
258
259 #define SZ 32
260 #define elf_word uint32_t
261 #define elf_sword int32_t
262 #define bswapSZs bswap32s
263 #include "elf_ops.h"
264
265 #undef elfhdr
266 #undef elf_phdr
267 #undef elf_shdr
268 #undef elf_sym
269 #undef elf_note
270 #undef elf_word
271 #undef elf_sword
272 #undef bswapSZs
273 #undef SZ
274 #define elfhdr elf64_hdr
275 #define elf_phdr elf64_phdr
276 #define elf_note elf64_note
277 #define elf_shdr elf64_shdr
278 #define elf_sym elf64_sym
279 #define elf_word uint64_t
280 #define elf_sword int64_t
281 #define bswapSZs bswap64s
282 #define SZ 64
283 #include "elf_ops.h"
284
285 /* return < 0 if error, otherwise the number of bytes loaded in memory */
286 int load_elf(const char *filename, uint64_t (*translate_fn)(void *, uint64_t),
287 void *translate_opaque, uint64_t *pentry, uint64_t *lowaddr,
288 uint64_t *highaddr, int big_endian, int elf_machine, int clear_lsb)
289 {
290 int fd, data_order, target_data_order, must_swab, ret;
291 uint8_t e_ident[EI_NIDENT];
292
293 fd = open(filename, O_RDONLY | O_BINARY);
294 if (fd < 0) {
295 perror(filename);
296 return -1;
297 }
298 if (read(fd, e_ident, sizeof(e_ident)) != sizeof(e_ident))
299 goto fail;
300 if (e_ident[0] != ELFMAG0 ||
301 e_ident[1] != ELFMAG1 ||
302 e_ident[2] != ELFMAG2 ||
303 e_ident[3] != ELFMAG3)
304 goto fail;
305 #ifdef HOST_WORDS_BIGENDIAN
306 data_order = ELFDATA2MSB;
307 #else
308 data_order = ELFDATA2LSB;
309 #endif
310 must_swab = data_order != e_ident[EI_DATA];
311 if (big_endian) {
312 target_data_order = ELFDATA2MSB;
313 } else {
314 target_data_order = ELFDATA2LSB;
315 }
316
317 if (target_data_order != e_ident[EI_DATA]) {
318 goto fail;
319 }
320
321 lseek(fd, 0, SEEK_SET);
322 if (e_ident[EI_CLASS] == ELFCLASS64) {
323 ret = load_elf64(filename, fd, translate_fn, translate_opaque, must_swab,
324 pentry, lowaddr, highaddr, elf_machine, clear_lsb);
325 } else {
326 ret = load_elf32(filename, fd, translate_fn, translate_opaque, must_swab,
327 pentry, lowaddr, highaddr, elf_machine, clear_lsb);
328 }
329
330 close(fd);
331 return ret;
332
333 fail:
334 close(fd);
335 return -1;
336 }
337
338 static void bswap_uboot_header(uboot_image_header_t *hdr)
339 {
340 #ifndef HOST_WORDS_BIGENDIAN
341 bswap32s(&hdr->ih_magic);
342 bswap32s(&hdr->ih_hcrc);
343 bswap32s(&hdr->ih_time);
344 bswap32s(&hdr->ih_size);
345 bswap32s(&hdr->ih_load);
346 bswap32s(&hdr->ih_ep);
347 bswap32s(&hdr->ih_dcrc);
348 #endif
349 }
350
351
352 #define ZALLOC_ALIGNMENT 16
353
354 static void *zalloc(void *x, unsigned items, unsigned size)
355 {
356 void *p;
357
358 size *= items;
359 size = (size + ZALLOC_ALIGNMENT - 1) & ~(ZALLOC_ALIGNMENT - 1);
360
361 p = g_malloc(size);
362
363 return (p);
364 }
365
366 static void zfree(void *x, void *addr)
367 {
368 g_free(addr);
369 }
370
371
372 #define HEAD_CRC 2
373 #define EXTRA_FIELD 4
374 #define ORIG_NAME 8
375 #define COMMENT 0x10
376 #define RESERVED 0xe0
377
378 #define DEFLATED 8
379
380 /* This is the maximum in uboot, so if a uImage overflows this, it would
381 * overflow on real hardware too. */
382 #define UBOOT_MAX_GUNZIP_BYTES 0x800000
383
384 static ssize_t gunzip(void *dst, size_t dstlen, uint8_t *src,
385 size_t srclen)
386 {
387 z_stream s;
388 ssize_t dstbytes;
389 int r, i, flags;
390
391 /* skip header */
392 i = 10;
393 flags = src[3];
394 if (src[2] != DEFLATED || (flags & RESERVED) != 0) {
395 puts ("Error: Bad gzipped data\n");
396 return -1;
397 }
398 if ((flags & EXTRA_FIELD) != 0)
399 i = 12 + src[10] + (src[11] << 8);
400 if ((flags & ORIG_NAME) != 0)
401 while (src[i++] != 0)
402 ;
403 if ((flags & COMMENT) != 0)
404 while (src[i++] != 0)
405 ;
406 if ((flags & HEAD_CRC) != 0)
407 i += 2;
408 if (i >= srclen) {
409 puts ("Error: gunzip out of data in header\n");
410 return -1;
411 }
412
413 s.zalloc = zalloc;
414 s.zfree = zfree;
415
416 r = inflateInit2(&s, -MAX_WBITS);
417 if (r != Z_OK) {
418 printf ("Error: inflateInit2() returned %d\n", r);
419 return (-1);
420 }
421 s.next_in = src + i;
422 s.avail_in = srclen - i;
423 s.next_out = dst;
424 s.avail_out = dstlen;
425 r = inflate(&s, Z_FINISH);
426 if (r != Z_OK && r != Z_STREAM_END) {
427 printf ("Error: inflate() returned %d\n", r);
428 return -1;
429 }
430 dstbytes = s.next_out - (unsigned char *) dst;
431 inflateEnd(&s);
432
433 return dstbytes;
434 }
435
436 /* Load a U-Boot image. */
437 int load_uimage(const char *filename, target_phys_addr_t *ep,
438 target_phys_addr_t *loadaddr, int *is_linux)
439 {
440 int fd;
441 int size;
442 uboot_image_header_t h;
443 uboot_image_header_t *hdr = &h;
444 uint8_t *data = NULL;
445 int ret = -1;
446
447 fd = open(filename, O_RDONLY | O_BINARY);
448 if (fd < 0)
449 return -1;
450
451 size = read(fd, hdr, sizeof(uboot_image_header_t));
452 if (size < 0)
453 goto out;
454
455 bswap_uboot_header(hdr);
456
457 if (hdr->ih_magic != IH_MAGIC)
458 goto out;
459
460 /* TODO: Implement other image types. */
461 if (hdr->ih_type != IH_TYPE_KERNEL) {
462 fprintf(stderr, "Can only load u-boot image type \"kernel\"\n");
463 goto out;
464 }
465
466 switch (hdr->ih_comp) {
467 case IH_COMP_NONE:
468 case IH_COMP_GZIP:
469 break;
470 default:
471 fprintf(stderr,
472 "Unable to load u-boot images with compression type %d\n",
473 hdr->ih_comp);
474 goto out;
475 }
476
477 /* TODO: Check CPU type. */
478 if (is_linux) {
479 if (hdr->ih_os == IH_OS_LINUX)
480 *is_linux = 1;
481 else
482 *is_linux = 0;
483 }
484
485 *ep = hdr->ih_ep;
486 data = g_malloc(hdr->ih_size);
487
488 if (read(fd, data, hdr->ih_size) != hdr->ih_size) {
489 fprintf(stderr, "Error reading file\n");
490 goto out;
491 }
492
493 if (hdr->ih_comp == IH_COMP_GZIP) {
494 uint8_t *compressed_data;
495 size_t max_bytes;
496 ssize_t bytes;
497
498 compressed_data = data;
499 max_bytes = UBOOT_MAX_GUNZIP_BYTES;
500 data = g_malloc(max_bytes);
501
502 bytes = gunzip(data, max_bytes, compressed_data, hdr->ih_size);
503 g_free(compressed_data);
504 if (bytes < 0) {
505 fprintf(stderr, "Unable to decompress gzipped image!\n");
506 goto out;
507 }
508 hdr->ih_size = bytes;
509 }
510
511 rom_add_blob_fixed(filename, data, hdr->ih_size, hdr->ih_load);
512
513 if (loadaddr)
514 *loadaddr = hdr->ih_load;
515
516 ret = hdr->ih_size;
517
518 out:
519 if (data)
520 g_free(data);
521 close(fd);
522 return ret;
523 }
524
525 /*
526 * Functions for reboot-persistent memory regions.
527 * - used for vga bios and option roms.
528 * - also linux kernel (-kernel / -initrd).
529 */
530
531 typedef struct Rom Rom;
532
533 struct Rom {
534 char *name;
535 char *path;
536 size_t romsize;
537 uint8_t *data;
538 int isrom;
539 char *fw_dir;
540 char *fw_file;
541
542 target_phys_addr_t addr;
543 QTAILQ_ENTRY(Rom) next;
544 };
545
546 static FWCfgState *fw_cfg;
547 static QTAILQ_HEAD(, Rom) roms = QTAILQ_HEAD_INITIALIZER(roms);
548
549 static void rom_insert(Rom *rom)
550 {
551 Rom *item;
552
553 if (roms_loaded) {
554 hw_error ("ROM images must be loaded at startup\n");
555 }
556
557 /* list is ordered by load address */
558 QTAILQ_FOREACH(item, &roms, next) {
559 if (rom->addr >= item->addr)
560 continue;
561 QTAILQ_INSERT_BEFORE(item, rom, next);
562 return;
563 }
564 QTAILQ_INSERT_TAIL(&roms, rom, next);
565 }
566
567 int rom_add_file(const char *file, const char *fw_dir,
568 target_phys_addr_t addr, int32_t bootindex)
569 {
570 Rom *rom;
571 int rc, fd = -1;
572 char devpath[100];
573
574 rom = g_malloc0(sizeof(*rom));
575 rom->name = g_strdup(file);
576 rom->path = qemu_find_file(QEMU_FILE_TYPE_BIOS, rom->name);
577 if (rom->path == NULL) {
578 rom->path = g_strdup(file);
579 }
580
581 fd = open(rom->path, O_RDONLY | O_BINARY);
582 if (fd == -1) {
583 fprintf(stderr, "Could not open option rom '%s': %s\n",
584 rom->path, strerror(errno));
585 goto err;
586 }
587
588 if (fw_dir) {
589 rom->fw_dir = g_strdup(fw_dir);
590 rom->fw_file = g_strdup(file);
591 }
592 rom->addr = addr;
593 rom->romsize = lseek(fd, 0, SEEK_END);
594 rom->data = g_malloc0(rom->romsize);
595 lseek(fd, 0, SEEK_SET);
596 rc = read(fd, rom->data, rom->romsize);
597 if (rc != rom->romsize) {
598 fprintf(stderr, "rom: file %-20s: read error: rc=%d (expected %zd)\n",
599 rom->name, rc, rom->romsize);
600 goto err;
601 }
602 close(fd);
603 rom_insert(rom);
604 if (rom->fw_file && fw_cfg) {
605 const char *basename;
606 char fw_file_name[56];
607
608 basename = strrchr(rom->fw_file, '/');
609 if (basename) {
610 basename++;
611 } else {
612 basename = rom->fw_file;
613 }
614 snprintf(fw_file_name, sizeof(fw_file_name), "%s/%s", rom->fw_dir,
615 basename);
616 fw_cfg_add_file(fw_cfg, fw_file_name, rom->data, rom->romsize);
617 snprintf(devpath, sizeof(devpath), "/rom@%s", fw_file_name);
618 } else {
619 snprintf(devpath, sizeof(devpath), "/rom@" TARGET_FMT_plx, addr);
620 }
621
622 add_boot_device_path(bootindex, NULL, devpath);
623 return 0;
624
625 err:
626 if (fd != -1)
627 close(fd);
628 g_free(rom->data);
629 g_free(rom->path);
630 g_free(rom->name);
631 g_free(rom);
632 return -1;
633 }
634
635 int rom_add_blob(const char *name, const void *blob, size_t len,
636 target_phys_addr_t addr)
637 {
638 Rom *rom;
639
640 rom = g_malloc0(sizeof(*rom));
641 rom->name = g_strdup(name);
642 rom->addr = addr;
643 rom->romsize = len;
644 rom->data = g_malloc0(rom->romsize);
645 memcpy(rom->data, blob, len);
646 rom_insert(rom);
647 return 0;
648 }
649
650 int rom_add_vga(const char *file)
651 {
652 return rom_add_file(file, "vgaroms", 0, -1);
653 }
654
655 int rom_add_option(const char *file, int32_t bootindex)
656 {
657 return rom_add_file(file, "genroms", 0, bootindex);
658 }
659
660 static void rom_reset(void *unused)
661 {
662 Rom *rom;
663
664 QTAILQ_FOREACH(rom, &roms, next) {
665 if (rom->fw_file) {
666 continue;
667 }
668 if (rom->data == NULL) {
669 continue;
670 }
671 cpu_physical_memory_write_rom(rom->addr, rom->data, rom->romsize);
672 if (rom->isrom) {
673 /* rom needs to be written only once */
674 g_free(rom->data);
675 rom->data = NULL;
676 }
677 }
678 }
679
680 int rom_load_all(void)
681 {
682 target_phys_addr_t addr = 0;
683 MemoryRegionSection section;
684 Rom *rom;
685
686 QTAILQ_FOREACH(rom, &roms, next) {
687 if (rom->fw_file) {
688 continue;
689 }
690 if (addr > rom->addr) {
691 fprintf(stderr, "rom: requested regions overlap "
692 "(rom %s. free=0x" TARGET_FMT_plx
693 ", addr=0x" TARGET_FMT_plx ")\n",
694 rom->name, addr, rom->addr);
695 return -1;
696 }
697 addr = rom->addr;
698 addr += rom->romsize;
699 section = memory_region_find(get_system_memory(), rom->addr, 1);
700 rom->isrom = section.size && memory_region_is_rom(section.mr);
701 }
702 qemu_register_reset(rom_reset, NULL);
703 roms_loaded = 1;
704 return 0;
705 }
706
707 void rom_set_fw(void *f)
708 {
709 fw_cfg = f;
710 }
711
712 static Rom *find_rom(target_phys_addr_t addr)
713 {
714 Rom *rom;
715
716 QTAILQ_FOREACH(rom, &roms, next) {
717 if (rom->fw_file) {
718 continue;
719 }
720 if (rom->addr > addr) {
721 continue;
722 }
723 if (rom->addr + rom->romsize < addr) {
724 continue;
725 }
726 return rom;
727 }
728 return NULL;
729 }
730
731 /*
732 * Copies memory from registered ROMs to dest. Any memory that is contained in
733 * a ROM between addr and addr + size is copied. Note that this can involve
734 * multiple ROMs, which need not start at addr and need not end at addr + size.
735 */
736 int rom_copy(uint8_t *dest, target_phys_addr_t addr, size_t size)
737 {
738 target_phys_addr_t end = addr + size;
739 uint8_t *s, *d = dest;
740 size_t l = 0;
741 Rom *rom;
742
743 QTAILQ_FOREACH(rom, &roms, next) {
744 if (rom->fw_file) {
745 continue;
746 }
747 if (rom->addr + rom->romsize < addr) {
748 continue;
749 }
750 if (rom->addr > end) {
751 break;
752 }
753 if (!rom->data) {
754 continue;
755 }
756
757 d = dest + (rom->addr - addr);
758 s = rom->data;
759 l = rom->romsize;
760
761 if ((d + l) > (dest + size)) {
762 l = dest - d;
763 }
764
765 memcpy(d, s, l);
766 }
767
768 return (d + l) - dest;
769 }
770
771 void *rom_ptr(target_phys_addr_t addr)
772 {
773 Rom *rom;
774
775 rom = find_rom(addr);
776 if (!rom || !rom->data)
777 return NULL;
778 return rom->data + (addr - rom->addr);
779 }
780
781 void do_info_roms(Monitor *mon)
782 {
783 Rom *rom;
784
785 QTAILQ_FOREACH(rom, &roms, next) {
786 if (!rom->fw_file) {
787 monitor_printf(mon, "addr=" TARGET_FMT_plx
788 " size=0x%06zx mem=%s name=\"%s\"\n",
789 rom->addr, rom->romsize,
790 rom->isrom ? "rom" : "ram",
791 rom->name);
792 } else {
793 monitor_printf(mon, "fw=%s/%s"
794 " size=0x%06zx name=\"%s\"\n",
795 rom->fw_dir,
796 rom->fw_file,
797 rom->romsize,
798 rom->name);
799 }
800 }
801 }