1 /* Utility to load a file into the simulator. 2 Copyright (C) 1997-2024 Free Software Foundation, Inc. 3 4 This program is free software; you can redistribute it and/or modify 5 it under the terms of the GNU General Public License as published by 6 the Free Software Foundation; either version 3 of the License, or 7 (at your option) any later version. 8 9 This program is distributed in the hope that it will be useful, 10 but WITHOUT ANY WARRANTY; without even the implied warranty of 11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 GNU General Public License for more details. 13 14 You should have received a copy of the GNU General Public License 15 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 16 17 /* This is a standalone loader, independent of the sim-basic.h machinery, 18 as it is used by simulators that don't use it [though that doesn't mean 19 to suggest that they shouldn't :-)]. */ 20 21 /* This must come before any other includes. */ 22 #include "defs.h" 23 24 #include <stdarg.h> 25 #include <stdio.h> /* for NULL */ 26 #include <stdlib.h> 27 #include <time.h> 28 29 #include "ansidecl.h" 30 #include "bfd.h" 31 32 #include "sim/callback.h" 33 #include "sim/sim.h" 34 #include "sim-utils.h" 35 36 static void eprintf (host_callback *, const char *, ...); 37 static void xprintf (host_callback *, const char *, ...); 38 static void report_transfer_performance 39 (host_callback *, unsigned long, time_t, time_t); 40 41 /* Load program PROG into the simulator using the function DO_WRITE. 42 If PROG_BFD is non-NULL, the file has already been opened. 43 If VERBOSE_P is non-zero statistics are printed of each loaded section 44 and the transfer rate (for consistency with gdb). 45 If LMA_P is non-zero the program sections are loaded at the LMA 46 rather than the VMA 47 If this fails an error message is printed and NULL is returned. 48 If it succeeds the bfd is returned. 49 NOTE: For historical reasons, older hardware simulators incorrectly 50 write the program sections at LMA interpreted as a virtual address. 51 This is still accommodated for backward compatibility reasons. */ 52 53 54 bfd * 55 sim_load_file (SIM_DESC sd, const char *myname, host_callback *callback, 56 const char *prog, bfd *prog_bfd, int verbose_p, int lma_p, 57 sim_write_fn do_write) 58 { 59 asection *s; 60 /* Record separately as we don't want to close PROG_BFD if it was passed. */ 61 bfd *result_bfd; 62 time_t start_time = 0; /* Start and end times of download */ 63 time_t end_time = 0; 64 unsigned long data_count = 0; /* Number of bytes transferred to memory */ 65 int found_loadable_section; 66 67 if (prog_bfd != NULL) 68 result_bfd = prog_bfd; 69 else 70 { 71 result_bfd = bfd_openr (prog, 0); 72 if (result_bfd == NULL) 73 { 74 eprintf (callback, "%s: can't open \"%s\": %s\n", 75 myname, prog, bfd_errmsg (bfd_get_error ())); 76 return NULL; 77 } 78 } 79 80 if (!bfd_check_format (result_bfd, bfd_object)) 81 { 82 eprintf (callback, "%s: \"%s\" is not an object file: %s\n", 83 myname, prog, bfd_errmsg (bfd_get_error ())); 84 /* Only close if we opened it. */ 85 if (prog_bfd == NULL) 86 bfd_close (result_bfd); 87 return NULL; 88 } 89 90 if (verbose_p) 91 start_time = time (NULL); 92 93 found_loadable_section = 0; 94 for (s = result_bfd->sections; s; s = s->next) 95 { 96 if (s->flags & SEC_LOAD) 97 { 98 bfd_size_type size; 99 100 size = bfd_section_size (s); 101 if (size > 0) 102 { 103 unsigned char *buffer; 104 bfd_vma lma; 105 106 buffer = malloc (size); 107 if (buffer == NULL) 108 { 109 eprintf (callback, 110 "%s: insufficient memory to load \"%s\"\n", 111 myname, prog); 112 /* Only close if we opened it. */ 113 if (prog_bfd == NULL) 114 bfd_close (result_bfd); 115 return NULL; 116 } 117 if (lma_p) 118 lma = bfd_section_lma (s); 119 else 120 lma = bfd_section_vma (s); 121 if (verbose_p) 122 { 123 xprintf (callback, 124 "Loading section %s, size 0x%" PRIx64 125 " %s %" PRIx64 "\n", 126 bfd_section_name (s), (uint64_t) size, 127 lma_p ? "lma" : "vma", (uint64_t) lma); 128 } 129 data_count += size; 130 bfd_get_section_contents (result_bfd, s, buffer, 0, size); 131 do_write (sd, lma, buffer, size); 132 found_loadable_section = 1; 133 free (buffer); 134 } 135 } 136 } 137 138 if (!found_loadable_section) 139 { 140 eprintf (callback, 141 "%s: no loadable sections \"%s\"\n", 142 myname, prog); 143 return NULL; 144 } 145 146 if (verbose_p) 147 { 148 end_time = time (NULL); 149 xprintf (callback, "Start address %" PRIx64 "\n", 150 (uint64_t) bfd_get_start_address (result_bfd)); 151 report_transfer_performance (callback, data_count, start_time, end_time); 152 } 153 154 bfd_cache_close (result_bfd); 155 156 return result_bfd; 157 } 158 159 static void 160 xprintf (host_callback *callback, const char *fmt, ...) 161 { 162 va_list ap; 163 164 va_start (ap, fmt); 165 166 (*callback->vprintf_filtered) (callback, fmt, ap); 167 168 va_end (ap); 169 } 170 171 static void 172 eprintf (host_callback *callback, const char *fmt, ...) 173 { 174 va_list ap; 175 176 va_start (ap, fmt); 177 178 (*callback->evprintf_filtered) (callback, fmt, ap); 179 180 va_end (ap); 181 } 182 183 /* Report how fast the transfer went. */ 184 185 static void 186 report_transfer_performance (host_callback *callback, unsigned long data_count, 187 time_t start_time, time_t end_time) 188 { 189 xprintf (callback, "Transfer rate: "); 190 if (end_time != start_time) 191 xprintf (callback, "%ld bits/sec", 192 (data_count * 8) / (end_time - start_time)); 193 else 194 xprintf (callback, "%ld bits in <1 sec", (data_count * 8)); 195 xprintf (callback, ".\n"); 196 } 197