sim/common/sim-utils.c

   1 /* Miscellaneous simulator utilities.
   2    Copyright (C) 1997 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.
   4
   5 This file is part of GDB, the GNU debugger.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License along
  18 with this program; if not, write to the Free Software Foundation, Inc.,
  19 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "sim-main.h"
  22 #include "sim-assert.h"
  23
  24 #ifdef HAVE_STDLIB_H
  25 #include <stdlib.h>
  26 #endif
  27
  28 #ifdef HAVE_TIME_H
  29 #include <time.h>
  30 #endif
  31
  32 #ifdef HAVE_SYS_TIME_H
  33 #include <sys/time.h> /* needed by sys/resource.h */
  34 #endif
  35
  36 #ifdef HAVE_SYS_RESOURCE_H
  37 #include <sys/resource.h>
  38 #endif
  39
  40 #ifdef HAVE_STRING_H
  41 #include <string.h>
  42 #else
  43 #ifdef HAVE_STRINGS_H
  44 #include <strings.h>
  45 #endif
  46 #endif
  47
  48 #include "libiberty.h"
  49 #include "bfd.h"
  50 #include "sim-utils.h"
  51
  52 /* Global pointer to all state data.
  53    Set by sim_resume.  */
  54 struct sim_state *current_state;
  55
  56 /* Allocate zero filled memory with xmalloc.  */
  57
  58 void *
  59 zalloc (unsigned long size)
  60 {
  61   void *memory = (void *) xmalloc (size);
  62   memset (memory, 0, size);
  63   return memory;
  64 }
  65
  66 void
  67 zfree (void *data)
  68 {
  69   free (data);
  70 }
  71
  72 /* Allocate a sim_state struct.  */
  73
  74 SIM_DESC
  75 sim_state_alloc (void)
  76 {
  77   SIM_DESC sd = zalloc (sizeof (struct sim_state));
  78   sd->base.magic = SIM_MAGIC_NUMBER;
  79   return sd;
  80 }
  81
  82 /* Free a sim_state struct.  */
  83
  84 void
  85 sim_state_free (SIM_DESC sd)
  86 {
  87   ASSERT (sd->base.magic == SIM_MAGIC_NUMBER);
  88   zfree (sd);
  89 }
  90
  91 /* Turn VALUE into a string with commas.  */
  92
  93 char *
  94 sim_add_commas (char *buf, int sizeof_buf, unsigned long value)
  95 {
  96   int comma = 3;
  97   char *endbuf = buf + sizeof_buf - 1;
  98
  99   *--endbuf = '\0';
 100   do {
 101     if (comma-- == 0)
 102       {
 103         *--endbuf = ',';
 104         comma = 2;
 105       }
 106
 107     *--endbuf = (value % 10) + '0';
 108   } while ((value /= 10) != 0);
 109
 110   return endbuf;
 111 }
 112
 113 /* Make a copy of ARGV.
 114    This can also be used to copy the environment vector.
 115    The result is a pointer to the malloc'd copy or NULL if insufficient
 116    memory available.  */
 117
 118 char **
 119 sim_copy_argv (argv)
 120      char **argv;
 121 {
 122   int i;
 123   int argc;
 124   int len;
 125   char **copy;
 126
 127   if (argv == NULL)
 128     return NULL;
 129
 130   /* the vector */
 131   for (argc = 0; argv[argc] != NULL; argc++);
 132   copy = (char **) malloc ((argc + 1) * sizeof (char *));
 133   if (copy == NULL)
 134     return NULL;
 135
 136   /* the strings */
 137   for (argc = 0; argv[argc] != NULL; argc++)
 138     {
 139       int len = strlen (argv[argc]);
 140       copy[argc] = malloc (sizeof (char *) * (len + 1));
 141       if (copy[argc] == NULL)
 142         {
 143           freeargv (copy);
 144           return NULL;
 145         }
 146       strcpy (copy[argc], argv[argc]);
 147     }
 148   copy[argc] = NULL;
 149   return copy;
 150 }
 151
 152 /* Analyze a bfd and set various fields in the state struct.  */
 153
 154 void
 155 sim_analyze_program (sd, prog_bfd)
 156      SIM_DESC sd;
 157      bfd *prog_bfd;
 158 {
 159   asection *s;
 160
 161   SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
 162   STATE_PROG_BFD (sd) = prog_bfd;
 163   STATE_START_ADDR (sd) = bfd_get_start_address (prog_bfd);
 164
 165   for (s = prog_bfd->sections; s; s = s->next)
 166     if (strcmp (bfd_get_section_name (prog_bfd, s), ".text") == 0)
 167       {
 168         STATE_TEXT_SECTION (sd) = s;
 169         STATE_TEXT_START (sd) = bfd_get_section_vma (prog_bfd, s);
 170         STATE_TEXT_END (sd) = STATE_TEXT_START (sd) + bfd_section_size (prog_bfd, s);
 171         break;
 172       }
 173 }
 174 \f
 175 /* Simulator timing support.  */
 176
 177 /* Called before sim_elapsed_time_since to get a reference point.  */
 178
 179 SIM_ELAPSED_TIME
 180 sim_elapsed_time_get ()
 181 {
 182 #ifdef HAVE_GETRUSAGE
 183   struct rusage mytime;
 184   if (getrusage (RUSAGE_SELF, &mytime) == 0)
 185     return (SIM_ELAPSED_TIME) (((double) mytime.ru_utime.tv_sec * 1000) + (((double) mytime.ru_utime.tv_usec + 500) / 1000));
 186   return 0;
 187 #else
 188 #ifdef HAVE_TIME
 189   return (SIM_ELAPSED_TIME) time ((time_t) 0);
 190 #else
 191   return 0;
 192 #endif
 193 #endif
 194 }
 195
 196 /* Return the elapsed time in milliseconds since START.
 197    The actual time may be cpu usage (prefered) or wall clock.  */
 198
 199 unsigned long
 200 sim_elapsed_time_since (start)
 201      SIM_ELAPSED_TIME start;
 202 {
 203 #ifdef HAVE_GETRUSAGE
 204   return sim_elapsed_time_get () - start;
 205 #else
 206 #ifdef HAVE_TIME
 207   return (sim_elapsed_time_get () - start) * 1000;
 208 #else
 209   return 0;
 210 #endif
 211 #endif
 212 }