OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [sim/] [common/] [sim-model.c] - Blame information for rev 402

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Model support.
2
   Copyright (C) 1996, 1997, 1998, 2007, 2008 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 3 of the License, or
10
(at your option) 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
18
along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
 
20
#include "sim-main.h"
21
#include "libiberty.h"
22
#include "sim-options.h"
23
#include "sim-io.h"
24
#include "sim-assert.h"
25
#include "bfd.h"
26
 
27
static void model_set (sim_cpu *, const MODEL *);
28
 
29
static DECLARE_OPTION_HANDLER (model_option_handler);
30
 
31
static MODULE_INIT_FN sim_model_init;
32
 
33
#define OPTION_MODEL (OPTION_START + 0)
34
 
35
static const OPTION model_options[] = {
36
  { {"model", required_argument, NULL, OPTION_MODEL},
37
      '\0', "MODEL", "Specify model to simulate",
38
      model_option_handler },
39
  { {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL }
40
};
41
 
42
static SIM_RC
43
model_option_handler (SIM_DESC sd, sim_cpu *cpu, int opt,
44
                      char *arg, int is_command)
45
{
46
  switch (opt)
47
    {
48
    case OPTION_MODEL :
49
      {
50
        const MODEL *model = sim_model_lookup (arg);
51
        if (! model)
52
          {
53
            sim_io_eprintf (sd, "unknown model `%s'\n", arg);
54
            return SIM_RC_FAIL;
55
          }
56
        sim_model_set (sd, cpu, model);
57
        break;
58
      }
59
    }
60
 
61
  return SIM_RC_OK;
62
}
63
 
64
SIM_RC
65
sim_model_install (SIM_DESC sd)
66
{
67
  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
68
 
69
  sim_add_option_table (sd, NULL, model_options);
70
  sim_module_add_init_fn (sd, sim_model_init);
71
 
72
  return SIM_RC_OK;
73
}
74
 
75
/* Subroutine of sim_model_set to set the model for one cpu.  */
76
 
77
static void
78
model_set (sim_cpu *cpu, const MODEL *model)
79
{
80
  CPU_MACH (cpu) = MODEL_MACH (model);
81
  CPU_MODEL (cpu) = model;
82
  (* MACH_INIT_CPU (MODEL_MACH (model))) (cpu);
83
  (* MODEL_INIT (model)) (cpu);
84
}
85
 
86
/* Set the current model of CPU to MODEL.
87
   If CPU is NULL, all cpus are set to MODEL.  */
88
 
89
void
90
sim_model_set (SIM_DESC sd, sim_cpu *cpu, const MODEL *model)
91
{
92
  if (! cpu)
93
    {
94
      int c;
95
 
96
      for (c = 0; c < MAX_NR_PROCESSORS; ++c)
97
        if (STATE_CPU (sd, c))
98
          model_set (STATE_CPU (sd, c), model);
99
    }
100
  else
101
    {
102
      model_set (cpu, model);
103
    }
104
}
105
 
106
/* Look up model named NAME.
107
   Result is pointer to MODEL entry or NULL if not found.  */
108
 
109
const MODEL *
110
sim_model_lookup (const char *name)
111
{
112
  const MACH **machp;
113
  const MODEL *model;
114
 
115
  for (machp = & sim_machs[0]; *machp != NULL; ++machp)
116
    {
117
      for (model = MACH_MODELS (*machp); MODEL_NAME (model) != NULL; ++model)
118
        {
119
          if (strcmp (MODEL_NAME (model), name) == 0)
120
            return model;
121
        }
122
    }
123
  return NULL;
124
}
125
 
126
/* Look up machine named NAME.
127
   Result is pointer to MACH entry or NULL if not found.  */
128
 
129
const MACH *
130
sim_mach_lookup (const char *name)
131
{
132
  const MACH **machp;
133
 
134
  for (machp = & sim_machs[0]; *machp != NULL; ++machp)
135
    {
136
      if (strcmp (MACH_NAME (*machp), name) == 0)
137
        return *machp;
138
    }
139
  return NULL;
140
}
141
 
142
/* Look up a machine via its bfd name.
143
   Result is pointer to MACH entry or NULL if not found.  */
144
 
145
const MACH *
146
sim_mach_lookup_bfd_name (const char *name)
147
{
148
  const MACH **machp;
149
 
150
  for (machp = & sim_machs[0]; *machp != NULL; ++machp)
151
    {
152
      if (strcmp (MACH_BFD_NAME (*machp), name) == 0)
153
        return *machp;
154
    }
155
  return NULL;
156
}
157
 
158
/* Initialize model support.  */
159
 
160
static SIM_RC
161
sim_model_init (SIM_DESC sd)
162
{
163
  SIM_CPU *cpu;
164
 
165
  /* If both cpu model and state architecture are set, ensure they're
166
     compatible.  If only one is set, set the other.  If neither are set,
167
     use the default model.  STATE_ARCHITECTURE is the bfd_arch_info data
168
     for the selected "mach" (bfd terminology).  */
169
 
170
  /* Only check cpu 0.  STATE_ARCHITECTURE is for that one only.  */
171
  /* ??? At present this only supports homogeneous multiprocessors.  */
172
  cpu = STATE_CPU (sd, 0);
173
 
174
  if (! STATE_ARCHITECTURE (sd)
175
      && ! CPU_MACH (cpu))
176
    {
177
      /* Set the default model.  */
178
      const MODEL *model = sim_model_lookup (WITH_DEFAULT_MODEL);
179
      sim_model_set (sd, NULL, model);
180
    }
181
 
182
  if (STATE_ARCHITECTURE (sd)
183
      && CPU_MACH (cpu))
184
    {
185
      if (strcmp (STATE_ARCHITECTURE (sd)->printable_name,
186
                  MACH_BFD_NAME (CPU_MACH (cpu))) != 0)
187
        {
188
          sim_io_eprintf (sd, "invalid model `%s' for `%s'\n",
189
                          MODEL_NAME (CPU_MODEL (cpu)),
190
                          STATE_ARCHITECTURE (sd)->printable_name);
191
          return SIM_RC_FAIL;
192
        }
193
    }
194
  else if (STATE_ARCHITECTURE (sd))
195
    {
196
      /* Use the default model for the selected machine.
197
         The default model is the first one in the list.  */
198
      const MACH *mach = sim_mach_lookup_bfd_name (STATE_ARCHITECTURE (sd)->printable_name);
199
 
200
      if (mach == NULL)
201
        {
202
          sim_io_eprintf (sd, "unsupported machine `%s'\n",
203
                          STATE_ARCHITECTURE (sd)->printable_name);
204
          return SIM_RC_FAIL;
205
        }
206
      sim_model_set (sd, NULL, MACH_MODELS (mach));
207
    }
208
  else
209
    {
210
      STATE_ARCHITECTURE (sd) = bfd_scan_arch (MACH_BFD_NAME (CPU_MACH (cpu)));
211
    }
212
 
213
  return SIM_RC_OK;
214
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.