int sim_write (SIM_DESC sd, SIM_ADDR mem, const unsigned char *buf, int length) { check_desc (sd); mem_put_blk ((int) mem, buf, length); return length; }
int sim_write (SIM_DESC sd, SIM_ADDR mem, const unsigned char *buf, int length) { check_desc (sd); if (mem >= MEM_SIZE) return 0; else if (mem + length > MEM_SIZE) length = MEM_SIZE - mem; mem_put_blk (mem, buf, length); return length; }
void rx_load (bfd *prog) { unsigned long highest_addr_loaded = 0; Elf_Internal_Phdr * phdrs; long sizeof_phdrs; int num_headers; int i; rx_big_endian = bfd_big_endian (prog); /* Note we load by ELF program header not by BFD sections. This is because BFD sections get their information from the ELF section structure, which only includes a VMA value and not an LMA value. */ sizeof_phdrs = bfd_get_elf_phdr_upper_bound (prog); if (sizeof_phdrs == 0) { fprintf (stderr, "Failed to get size of program headers\n"); return; } phdrs = malloc (sizeof_phdrs); if (phdrs == NULL) { fprintf (stderr, "Failed allocate memory to hold program headers\n"); return; } num_headers = bfd_get_elf_phdrs (prog, phdrs); if (num_headers < 1) { fprintf (stderr, "Failed to read program headers\n"); return; } for (i = 0; i < num_headers; i++) { Elf_Internal_Phdr * p = phdrs + i; char *buf; bfd_vma size; bfd_vma base; file_ptr offset; size = p->p_filesz; if (size <= 0) continue; base = p->p_paddr; if (verbose > 1) fprintf (stderr, "[load segment: lma=%08x vma=%08x size=%08x]\n", (int) base, (int) p->p_vaddr, (int) size); buf = malloc (size); if (buf == NULL) { fprintf (stderr, "Failed to allocate buffer to hold program segment\n"); continue; } offset = p->p_offset; if (prog->iovec->bseek (prog, offset, SEEK_SET) != 0) { fprintf (stderr, "Failed to seek to offset %lx\n", (long) offset); continue; } if (prog->iovec->bread (prog, buf, size) != size) { fprintf (stderr, "Failed to read %lx bytes\n", size); continue; } mem_put_blk (base, buf, size); free (buf); if (highest_addr_loaded < base + size - 1 && size >= 4) highest_addr_loaded = base + size - 1; } free (phdrs); regs.r_pc = prog->start_address; if (strcmp (bfd_get_target (prog), "srec") == 0 || regs.r_pc == 0) { regs.r_pc = mem_get_si (0xfffffffc); heaptop = heapbottom = 0; } if (verbose > 1) fprintf (stderr, "[start pc=%08x %s]\n", (unsigned int) regs.r_pc, rx_big_endian ? "BE" : "LE"); }
void rl78_load (bfd *prog, host_callback *callbacks, const char * const simname) { Elf_Internal_Phdr * phdrs; long sizeof_phdrs; int num_headers; int i; int max_rom = 0; init_cpu (); /* Note we load by ELF program header not by BFD sections. This is because BFD sections get their information from the ELF section structure, which only includes a VMA value and not an LMA value. */ sizeof_phdrs = bfd_get_elf_phdr_upper_bound (prog); if (sizeof_phdrs == 0) { fprintf (stderr, "%s: Failed to get size of program headers\n", simname); return; } phdrs = xmalloc (sizeof_phdrs); num_headers = bfd_get_elf_phdrs (prog, phdrs); if (num_headers < 1) { fprintf (stderr, "%s: Failed to read program headers\n", simname); return; } for (i = 0; i < num_headers; i++) { Elf_Internal_Phdr * p = phdrs + i; char *buf; bfd_vma size; bfd_vma base; file_ptr offset; size = p->p_filesz; if (size <= 0) continue; base = p->p_paddr; if (verbose > 1) fprintf (stderr, "[load segment: lma=%08x vma=%08x size=%08x]\n", (int) base, (int) p->p_vaddr, (int) size); if (callbacks) xprintf (callbacks, "Loading section %s, size %#lx lma %08lx vma %08lx\n", find_section_name_by_offset (prog, p->p_offset), size, base, p->p_vaddr); buf = xmalloc (size); offset = p->p_offset; if (prog->iovec->bseek (prog, offset, SEEK_SET) != 0) { fprintf (stderr, "%s, Failed to seek to offset %lx\n", simname, (long) offset); continue; } if (prog->iovec->bread (prog, buf, size) != size) { fprintf (stderr, "%s: Failed to read %lx bytes\n", simname, size); continue; } if (base > 0xeffff || base + size > 0xeffff) { fprintf (stderr, "%s, Can't load image to RAM/SFR space: 0x%lx - 0x%lx\n", simname, base, base+size); continue; } if (max_rom < base + size) max_rom = base + size; mem_put_blk (base, buf, size); free (buf); } free (phdrs); mem_rom_size (max_rom); pc = prog->start_address; if (strcmp (bfd_get_target (prog), "srec") == 0 || pc == 0) { pc = mem_get_hi (0); } if (verbose > 1) fprintf (stderr, "[start pc=%08x]\n", (unsigned int) pc); }
void m32c_load (bfd * prog) { asection *s; unsigned long mach = bfd_get_mach (prog); unsigned long highest_addr_loaded = 0; if (mach == 0 && default_machine != 0) mach = default_machine; m32c_set_mach (mach); for (s = prog->sections; s; s = s->next) { #if 0 /* This was a good idea until we started storing the RAM data in ROM, at which point everything was all messed up. The code remains as a reminder. */ if ((s->flags & SEC_ALLOC) && !(s->flags & SEC_READONLY)) { if (strcmp (bfd_get_section_name (prog, s), ".stack")) { int secend = bfd_get_section_size (s) + bfd_section_lma (prog, s); if (heaptop < secend && bfd_section_lma (prog, s) < 0x10000) { heaptop = heapbottom = secend; } } } #endif if (s->flags & SEC_LOAD) { char *buf; bfd_size_type size; size = bfd_get_section_size (s); if (size <= 0) continue; bfd_vma base = bfd_section_lma (prog, s); if (verbose) fprintf (stderr, "[load a=%08x s=%08x %s]\n", (int) base, (int) size, bfd_get_section_name (prog, s)); buf = (char *) malloc (size); bfd_get_section_contents (prog, s, buf, 0, size); mem_put_blk (base, buf, size); free (buf); if (highest_addr_loaded < base + size - 1 && size >= 4) highest_addr_loaded = base + size - 1; } } if (strcmp (bfd_get_target (prog), "srec") == 0) { heaptop = heapbottom = 0; switch (mach) { case bfd_mach_m16c: if (highest_addr_loaded > 0x10000) regs.r_pc = mem_get_si (0x000ffffc) & membus_mask; else regs.r_pc = mem_get_si (0x000fffc) & membus_mask; break; case bfd_mach_m32c: regs.r_pc = mem_get_si (0x00fffffc) & membus_mask; break; } } else regs.r_pc = prog->start_address; if (verbose) fprintf (stderr, "[start pc=%08x]\n", (unsigned int) regs.r_pc); }