sim/common/sim-load.c

   1 /* Utility to load a file into the simulator.
   2    Copyright (C) 1997-2023 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 }