1 /* Utility to load a file into the simulator. 2 Copyright (C) 1997, 1998, 2001, 2002, 2004, 2007, 2008, 2009, 2010, 2011 3 Free Software Foundation, Inc. 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 3 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, see <http://www.gnu.org/licenses/>. */ 17 18 /* This is a standalone loader, independent of the sim-basic.h machinery, 19 as it is used by simulators that don't use it [though that doesn't mean 20 to suggest that they shouldn't :-)]. */ 21 22 #ifdef HAVE_CONFIG_H 23 #include "cconfig.h" 24 #endif 25 #include "ansidecl.h" 26 #include <stdio.h> /* for NULL */ 27 #include <stdarg.h> 28 #ifdef HAVE_STDLIB_H 29 #include <stdlib.h> 30 #endif 31 #include <time.h> 32 33 #include "sim-basics.h" 34 #include "bfd.h" 35 #include "sim-utils.h" 36 37 #include "gdb/callback.h" 38 #include "gdb/remote-sim.h" 39 40 static void eprintf PARAMS ((host_callback *, const char *, ...)); 41 static void xprintf PARAMS ((host_callback *, const char *, ...)); 42 static void report_transfer_performance 43 PARAMS ((host_callback *, unsigned long, time_t, time_t)); 44 static void xprintf_bfd_vma PARAMS ((host_callback *, bfd_vma)); 45 46 /* Load program PROG into the simulator using the function DO_LOAD. 47 If PROG_BFD is non-NULL, the file has already been opened. 48 If VERBOSE_P is non-zero statistics are printed of each loaded section 49 and the transfer rate (for consistency with gdb). 50 If LMA_P is non-zero the program sections are loaded at the LMA 51 rather than the VMA 52 If this fails an error message is printed and NULL is returned. 53 If it succeeds the bfd is returned. 54 NOTE: For historical reasons, older hardware simulators incorrectly 55 write the program sections at LMA interpreted as a virtual address. 56 This is still accommodated for backward compatibility reasons. */ 57 58 59 bfd * 60 sim_load_file (sd, myname, callback, prog, prog_bfd, verbose_p, lma_p, do_write) 61 SIM_DESC sd; 62 const char *myname; 63 host_callback *callback; 64 char *prog; 65 bfd *prog_bfd; 66 int verbose_p; 67 int lma_p; 68 sim_write_fn do_write; 69 { 70 asection *s; 71 /* Record separately as we don't want to close PROG_BFD if it was passed. */ 72 bfd *result_bfd; 73 time_t start_time = 0; /* Start and end times of download */ 74 time_t end_time = 0; 75 unsigned long data_count = 0; /* Number of bytes transferred to memory */ 76 int found_loadable_section; 77 78 if (prog_bfd != NULL) 79 result_bfd = prog_bfd; 80 else 81 { 82 result_bfd = bfd_openr (prog, 0); 83 if (result_bfd == NULL) 84 { 85 eprintf (callback, "%s: can't open \"%s\": %s\n", 86 myname, prog, bfd_errmsg (bfd_get_error ())); 87 return NULL; 88 } 89 } 90 91 if (!bfd_check_format (result_bfd, bfd_object)) 92 { 93 eprintf (callback, "%s: \"%s\" is not an object file: %s\n", 94 myname, prog, bfd_errmsg (bfd_get_error ())); 95 /* Only close if we opened it. */ 96 if (prog_bfd == NULL) 97 bfd_close (result_bfd); 98 return NULL; 99 } 100 101 if (verbose_p) 102 start_time = time (NULL); 103 104 found_loadable_section = 0; 105 for (s = result_bfd->sections; s; s = s->next) 106 { 107 if (s->flags & SEC_LOAD) 108 { 109 bfd_size_type size; 110 111 size = bfd_get_section_size (s); 112 if (size > 0) 113 { 114 unsigned char *buffer; 115 bfd_vma lma; 116 117 buffer = malloc (size); 118 if (buffer == NULL) 119 { 120 eprintf (callback, 121 "%s: insufficient memory to load \"%s\"\n", 122 myname, prog); 123 /* Only close if we opened it. */ 124 if (prog_bfd == NULL) 125 bfd_close (result_bfd); 126 return NULL; 127 } 128 if (lma_p) 129 lma = bfd_section_lma (result_bfd, s); 130 else 131 lma = bfd_section_vma (result_bfd, s); 132 if (verbose_p) 133 { 134 xprintf (callback, "Loading section %s, size 0x%lx %s ", 135 bfd_get_section_name (result_bfd, s), 136 (unsigned long) size, 137 (lma_p ? "lma" : "vma")); 138 xprintf_bfd_vma (callback, lma); 139 xprintf (callback, "\n"); 140 } 141 data_count += size; 142 bfd_get_section_contents (result_bfd, s, buffer, 0, size); 143 do_write (sd, lma, buffer, size); 144 found_loadable_section = 1; 145 free (buffer); 146 } 147 } 148 } 149 150 if (!found_loadable_section) 151 { 152 eprintf (callback, 153 "%s: no loadable sections \"%s\"\n", 154 myname, prog); 155 return NULL; 156 } 157 158 if (verbose_p) 159 { 160 end_time = time (NULL); 161 xprintf (callback, "Start address "); 162 xprintf_bfd_vma (callback, bfd_get_start_address (result_bfd)); 163 xprintf (callback, "\n"); 164 report_transfer_performance (callback, data_count, start_time, end_time); 165 } 166 167 bfd_cache_close (result_bfd); 168 169 return result_bfd; 170 } 171 172 static void 173 xprintf VPARAMS ((host_callback *callback, const char *fmt, ...)) 174 { 175 va_list ap; 176 177 VA_START (ap, fmt); 178 179 (*callback->vprintf_filtered) (callback, fmt, ap); 180 181 va_end (ap); 182 } 183 184 static void 185 eprintf VPARAMS ((host_callback *callback, const char *fmt, ...)) 186 { 187 va_list ap; 188 189 VA_START (ap, fmt); 190 191 (*callback->evprintf_filtered) (callback, fmt, ap); 192 193 va_end (ap); 194 } 195 196 /* Report how fast the transfer went. */ 197 198 static void 199 report_transfer_performance (callback, data_count, start_time, end_time) 200 host_callback *callback; 201 unsigned long data_count; 202 time_t start_time, end_time; 203 { 204 xprintf (callback, "Transfer rate: "); 205 if (end_time != start_time) 206 xprintf (callback, "%ld bits/sec", 207 (data_count * 8) / (end_time - start_time)); 208 else 209 xprintf (callback, "%ld bits in <1 sec", (data_count * 8)); 210 xprintf (callback, ".\n"); 211 } 212 213 /* Print a bfd_vma. 214 This is intended to handle the vagaries of 32 vs 64 bits, etc. */ 215 216 static void 217 xprintf_bfd_vma (callback, vma) 218 host_callback *callback; 219 bfd_vma vma; 220 { 221 /* FIXME: for now */ 222 xprintf (callback, "0x%lx", (unsigned long) vma); 223 } 224