sim: cris: invert sim_cpu storage

The cpu*.h changes are in generated cgen code, but that has been sent
upstream too, so the next regen should include it automatically.

diff --git a/sim/cris/cpuv10.h b/sim/cris/cpuv10.h
index 30555c8244e2bf90bba6fb23ca097650cfbc130f..a7491873490b1b155e562dcc0d28af01cf14e81c 100644 (file)
--- a/sim/cris/cpuv10.h
+++ b/sim/cris/cpuv10.h
@@ -119,7 +119,7 @@ CPU (h_sr_v10[(index)]) = (x);\
 #define GET_H_PREFIXREG_PRE_V32() CPU (h_prefixreg_pre_v32)
 #define SET_H_PREFIXREG_PRE_V32(x) (CPU (h_prefixreg_pre_v32) = (x))
   } hardware;
-#define CPU_CGEN_HW(cpu) (& (cpu)->cpu_data.hardware)
+#define CPU_CGEN_HW(cpu) (& CRIS_SIM_CPU (cpu)->cpu_data.hardware)
 } CRISV10F_CPU_DATA;
 
 /* Virtual regs.  */

diff --git a/sim/cris/cpuv32.h b/sim/cris/cpuv32.h
index b23eff4f52a023826b4d619694a9e897e21a3dc5..3708fb107025d03aa4c427fac27da6af825aefab 100644 (file)
--- a/sim/cris/cpuv32.h
+++ b/sim/cris/cpuv32.h
@@ -226,7 +226,7 @@ crisv32f_single_step_enabled (current_cpu);\
 }\
 ;} while (0)
   } hardware;
-#define CPU_CGEN_HW(cpu) (& (cpu)->cpu_data.hardware)
+#define CPU_CGEN_HW(cpu) (& CRIS_SIM_CPU (cpu)->cpu_data.hardware)
 } CRISV32F_CPU_DATA;
 
 /* Virtual regs.  */

diff --git a/sim/cris/cris-tmpl.c b/sim/cris/cris-tmpl.c
index 2b5c14a133aaf1c711d8ac8b5259cf0382121cff..8d98300001aeae3bab835cf7796c5a93624acce0 100644 (file)
--- a/sim/cris/cris-tmpl.c
+++ b/sim/cris/cris-tmpl.c
@@ -251,14 +251,13 @@ MY (set_target_thread_data) (SIM_CPU *current_cpu, USI val)
 static void *
 MY (make_thread_cpu_data) (SIM_CPU *current_cpu, void *context)
 {
-  void *info = xmalloc (current_cpu->thread_cpu_data_size);
+  struct cris_sim_cpu *cris_cpu = CRIS_SIM_CPU (current_cpu);
+  void *info = xmalloc (cris_cpu->thread_cpu_data_size);
 
   if (context != NULL)
-    memcpy (info,
-           context,
-           current_cpu->thread_cpu_data_size);
+    memcpy (info, context, cris_cpu->thread_cpu_data_size);
   else
-    memset (info, 0, current_cpu->thread_cpu_data_size),abort();
+    memset (info, 0, cris_cpu->thread_cpu_data_size),abort();
   return info;
 }
 
@@ -267,11 +266,13 @@ MY (make_thread_cpu_data) (SIM_CPU *current_cpu, void *context)
 void
 MY (f_specific_init) (SIM_CPU *current_cpu)
 {
-  current_cpu->make_thread_cpu_data = MY (make_thread_cpu_data);
-  current_cpu->thread_cpu_data_size = sizeof (current_cpu->cpu_data);
-  current_cpu->set_target_thread_data = MY (set_target_thread_data);
+  struct cris_sim_cpu *cris_cpu = CRIS_SIM_CPU (current_cpu);
+
+  cris_cpu->make_thread_cpu_data = MY (make_thread_cpu_data);
+  cris_cpu->thread_cpu_data_size = sizeof (cris_cpu->cpu_data);
+  cris_cpu->set_target_thread_data = MY (set_target_thread_data);
 #if WITH_HW
-  current_cpu->deliver_interrupt = MY (deliver_interrupt);
+  cris_cpu->deliver_interrupt = MY (deliver_interrupt);
 #endif
 }
 \f

diff --git a/sim/cris/sim-if.c b/sim/cris/sim-if.c
index 64fefd67bf2485fba89562c48ba7b7ec9f06315b..7568b856661ab4e812e3b3877f4e95eab2db3dda 100644 (file)
--- a/sim/cris/sim-if.c
+++ b/sim/cris/sim-if.c
@@ -670,7 +670,8 @@ sim_open (SIM_OPEN_KIND kind, host_callback *callback, struct bfd *abfd,
   current_target_byte_order = BFD_ENDIAN_LITTLE;
 
   /* The cpu data is kept in a separately allocated chunk of memory.  */
-  if (sim_cpu_alloc_all (sd, 1) != SIM_RC_OK)
+  if (sim_cpu_alloc_all_extra (sd, 1, sizeof (struct cris_sim_cpu))
+      != SIM_RC_OK)
     {
       free_state (sd);
       return 0;
@@ -926,6 +927,8 @@ sim_open (SIM_OPEN_KIND kind, host_callback *callback, struct bfd *abfd,
     for (i = 0; i < MAX_NR_PROCESSORS; ++i)
       {
        SIM_CPU *cpu = STATE_CPU (sd, i);
+       struct cris_sim_cpu *cris_cpu = CRIS_SIM_CPU (cpu);
+
        CPU_CPU_DESC (cpu) = cd;
        CPU_DISASSEMBLER (cpu) = cris_disassemble_insn;
 
@@ -936,20 +939,20 @@ sim_open (SIM_OPEN_KIND kind, host_callback *callback, struct bfd *abfd,
        (* CPU_REG_STORE (cpu)) (cpu, H_GR_SP, (const unsigned char *) sp_init, 4);
 
        /* Set the simulator environment data.  */
-       cpu->highest_mmapped_page = NULL;
-       cpu->endmem = endmem;
-       cpu->endbrk = endbrk;
-       cpu->stack_low = stack_low;
-       cpu->syscalls = 0;
-       cpu->m1threads = 0;
-       cpu->threadno = 0;
-       cpu->max_threadid = 0;
-       cpu->thread_data = NULL;
-       memset (cpu->sighandler, 0, sizeof (cpu->sighandler));
-       cpu->make_thread_cpu_data = NULL;
-       cpu->thread_cpu_data_size = 0;
+       cris_cpu->highest_mmapped_page = NULL;
+       cris_cpu->endmem = endmem;
+       cris_cpu->endbrk = endbrk;
+       cris_cpu->stack_low = stack_low;
+       cris_cpu->syscalls = 0;
+       cris_cpu->m1threads = 0;
+       cris_cpu->threadno = 0;
+       cris_cpu->max_threadid = 0;
+       cris_cpu->thread_data = NULL;
+       memset (cris_cpu->sighandler, 0, sizeof (cris_cpu->sighandler));
+       cris_cpu->make_thread_cpu_data = NULL;
+       cris_cpu->thread_cpu_data_size = 0;
 #if WITH_HW
-       cpu->deliver_interrupt = NULL;
+       cris_cpu->deliver_interrupt = NULL;
 #endif
       }
 #if WITH_HW

diff --git a/sim/cris/sim-main.h b/sim/cris/sim-main.h
index 2447a710d43315f88ce508105b604445961fdabc..f60c454ddc4cd1820c866ed5c969b9e00b870d0b 100644 (file)
--- a/sim/cris/sim-main.h
+++ b/sim/cris/sim-main.h
@@ -24,6 +24,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 #ifndef SIM_MAIN_H
 #define SIM_MAIN_H
 
+#define SIM_HAVE_COMMON_SIM_CPU
+
 /* This is a global setting.  Different cpu families can't mix-n-match -scache
    and -pbb.  However some cpu families may use -simple while others use
    one of -scache/-pbb.  */
@@ -103,24 +105,18 @@ typedef int (*cris_interrupt_delivery_fn) (SIM_CPU *,
                                           enum cris_interrupt_type,
                                           unsigned int);
 
-struct _sim_cpu {
-  /* sim/common cpu base.  */
-  sim_cpu_base base;
-
-  /* Static parts of cgen.  */
-  CGEN_CPU cgen_cpu;
-
+struct cris_sim_cpu {
   CRIS_MISC_PROFILE cris_misc_profile;
-#define CPU_CRIS_MISC_PROFILE(cpu) (& (cpu)->cris_misc_profile)
+#define CPU_CRIS_MISC_PROFILE(cpu) (& CRIS_SIM_CPU (cpu)->cris_misc_profile)
 
   /* Copy of previous data; only valid when emitting trace-data after
      each insn.  */
   CRIS_MISC_PROFILE cris_prev_misc_profile;
-#define CPU_CRIS_PREV_MISC_PROFILE(cpu) (& (cpu)->cris_prev_misc_profile)
+#define CPU_CRIS_PREV_MISC_PROFILE(cpu) (& CRIS_SIM_CPU (cpu)->cris_prev_misc_profile)
 
 #if WITH_HW
   cris_interrupt_delivery_fn deliver_interrupt;
-#define CPU_CRIS_DELIVER_INTERRUPT(cpu) (cpu->deliver_interrupt)
+#define CPU_CRIS_DELIVER_INTERRUPT(cpu) (CRIS_SIM_CPU (cpu)->deliver_interrupt)
 #endif
 
   /* Simulator environment data.  */
@@ -204,6 +200,7 @@ struct _sim_cpu {
   union { void *dummy[16]; } cpu_data_placeholder;
 #endif
 };
+#define CRIS_SIM_CPU(cpu) ((struct cris_sim_cpu *) CPU_ARCH_DATA (cpu))
 \f
 /* Misc.  */
 

diff --git a/sim/cris/traps.c b/sim/cris/traps.c
index 7b0140f1c9013e018a421f3e69a5329081b01734..60691e363b93f2122a424c815bde4deeb529b386 100644 (file)
--- a/sim/cris/traps.c
+++ b/sim/cris/traps.c
@@ -160,7 +160,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* Milliseconds since start of run.  We use the number of syscalls to
    avoid introducing noise in the execution time.  */
-#define TARGET_TIME_MS(cpu) ((cpu)->syscalls)
+#define TARGET_TIME_MS(cpu) (CRIS_SIM_CPU (cpu)->syscalls)
 
 /* Seconds as in time(2).  */
 #define TARGET_TIME(cpu) (TARGET_EPOCH + TARGET_TIME_MS (cpu) / 1000)
@@ -936,10 +936,11 @@ void cris_dump_map (SIM_CPU *current_cpu);
 void
 cris_dump_map (SIM_CPU *current_cpu)
 {
+  struct cris_sim_cpu *cris_cpu = CRIS_SIM_CPU (current_cpu);
   struct cris_sim_mmapped_page *mapp;
   USI start, end;
 
-  for (mapp = current_cpu->highest_mmapped_page,
+  for (mapp = cris_cpu->highest_mmapped_page,
         start = mapp == NULL ? 0 : mapp->addr + 8192,
         end = mapp == NULL ? 0 : mapp->addr + 8191;
        mapp != NULL;
@@ -954,7 +955,7 @@ cris_dump_map (SIM_CPU *current_cpu)
       start = mapp->addr;
     }
 
-  if (current_cpu->highest_mmapped_page != NULL)
+  if (cris_cpu->highest_mmapped_page != NULL)
     sim_io_eprintf (CPU_STATE (current_cpu), "0x%x..0x%x\n", start, end);
 }
 
@@ -1077,6 +1078,8 @@ sim_engine_invalid_insn (SIM_CPU *current_cpu, IADDR cia, SEM_PC vpc)
 static void
 schedule (SIM_CPU *current_cpu, int next)
 {
+  struct cris_sim_cpu *cris_cpu = CRIS_SIM_CPU (current_cpu);
+
   /* Need to mark context-switches in the trace output.  */
   if ((CPU_CRIS_MISC_PROFILE (current_cpu)->flags
        & FLAG_CRIS_MISC_PROFILE_XSIM_TRACE))
@@ -1084,34 +1087,34 @@ schedule (SIM_CPU *current_cpu, int next)
                       "\t#:%d\n", next);
 
   /* Copy the current context (if there is one) to its slot.  */
-  if (current_cpu->thread_data[current_cpu->threadno].cpu_context)
-    memcpy (current_cpu->thread_data[current_cpu->threadno].cpu_context,
-           &current_cpu->cpu_data_placeholder,
-           current_cpu->thread_cpu_data_size);
+  if (cris_cpu->thread_data[cris_cpu->threadno].cpu_context)
+    memcpy (cris_cpu->thread_data[cris_cpu->threadno].cpu_context,
+           &cris_cpu->cpu_data_placeholder,
+           cris_cpu->thread_cpu_data_size);
 
   /* Copy the new context from its slot.  */
-  memcpy (&current_cpu->cpu_data_placeholder,
-         current_cpu->thread_data[next].cpu_context,
-         current_cpu->thread_cpu_data_size);
+  memcpy (&cris_cpu->cpu_data_placeholder,
+         cris_cpu->thread_data[next].cpu_context,
+         cris_cpu->thread_cpu_data_size);
 
   /* Update needed stuff to indicate the new context.  */
-  current_cpu->threadno = next;
+  cris_cpu->threadno = next;
 
   /* Handle pending signals.  */
-  if (current_cpu->thread_data[next].sigpending
+  if (cris_cpu->thread_data[next].sigpending
       /* We don't run nested signal handlers.  This means that pause(2)
         and sigsuspend(2) do not work in sighandlers, but that
         shouldn't be too hard a restriction.  It also greatly
         simplifies the code.  */
-      && current_cpu->thread_data[next].cpu_context_atsignal == NULL)
+      && cris_cpu->thread_data[next].cpu_context_atsignal == NULL)
   {
     int sig;
 
     /* See if there's really a pending, non-blocked handler.  We don't
        queue signals, so just use the first one in ascending order.  */
     for (sig = 0; sig < 64; sig++)
-      if (current_cpu->thread_data[next].sigdata[sig].pending
-         && !current_cpu->thread_data[next].sigdata[sig].blocked)
+      if (cris_cpu->thread_data[next].sigdata[sig].pending
+         && !cris_cpu->thread_data[next].sigdata[sig].blocked)
       {
        bfd_byte regbuf[4];
        USI sp;
@@ -1121,11 +1124,10 @@ schedule (SIM_CPU *current_cpu, int next)
 
        /* It's simpler to save the CPU context inside the simulator
           than on the stack.  */
-       current_cpu->thread_data[next].cpu_context_atsignal
-         = (*current_cpu
-            ->make_thread_cpu_data) (current_cpu,
-                                     current_cpu->thread_data[next]
-                                     .cpu_context);
+       cris_cpu->thread_data[next].cpu_context_atsignal
+         = (*cris_cpu->make_thread_cpu_data) (current_cpu,
+                                              cris_cpu->thread_data[next]
+                                              .cpu_context);
 
        (*CPU_REG_FETCH (current_cpu)) (current_cpu, H_GR_SP, regbuf, 4);
        sp = bfd_getl32 (regbuf);
@@ -1146,12 +1148,12 @@ schedule (SIM_CPU *current_cpu, int next)
        blocked = 0;
        for (i = 0; i < 32; i++)
          blocked
-           |= current_cpu->thread_data[next].sigdata[i + 1].blocked << i;
+           |= cris_cpu->thread_data[next].sigdata[i + 1].blocked << i;
        sim_core_write_aligned_4 (current_cpu, pc, 0, sp, blocked);
        blocked = 0;
        for (i = 0; i < 31; i++)
          blocked
-           |= current_cpu->thread_data[next].sigdata[i + 33].blocked << i;
+           |= cris_cpu->thread_data[next].sigdata[i + 33].blocked << i;
        sim_core_write_aligned_4 (current_cpu, pc, 0, sp + 4, blocked);
 
        /* Then, the actual instructions.  This is CPU-specific, but we
@@ -1180,12 +1182,12 @@ schedule (SIM_CPU *current_cpu, int next)
        (*CPU_REG_STORE (current_cpu)) (current_cpu, TARGET_SRP_REGNUM,
                                        regbuf, 4);
 
-       current_cpu->thread_data[next].sigdata[sig].pending = 0;
+       cris_cpu->thread_data[next].sigdata[sig].pending = 0;
 
        /* Block this signal (for the duration of the sighandler).  */
-       current_cpu->thread_data[next].sigdata[sig].blocked = 1;
+       cris_cpu->thread_data[next].sigdata[sig].blocked = 1;
 
-       sim_pc_set (current_cpu, current_cpu->sighandler[sig]);
+       sim_pc_set (current_cpu, cris_cpu->sighandler[sig]);
        bfd_putl32 (sig, regbuf);
        (*CPU_REG_STORE (current_cpu)) (current_cpu, H_GR_R10,
                                        regbuf, 4);
@@ -1211,7 +1213,7 @@ schedule (SIM_CPU *current_cpu, int next)
 
     /* No, there actually was no pending signal for this thread.  Reset
        this flag.  */
-    current_cpu->thread_data[next].sigpending = 0;
+    cris_cpu->thread_data[next].sigpending = 0;
   }
 }
 
@@ -1226,25 +1228,26 @@ static void
 reschedule (SIM_CPU *current_cpu)
 {
   SIM_DESC sd = CPU_STATE (current_cpu);
+  struct cris_sim_cpu *cris_cpu = CRIS_SIM_CPU (current_cpu);
   int i;
 
   /* Iterate over all thread slots, because after a few thread creations
      and exits, we don't know where the live ones are.  */
-  for (i = (current_cpu->threadno + 1) % SIM_TARGET_MAX_THREADS;
-       i != current_cpu->threadno;
+  for (i = (cris_cpu->threadno + 1) % SIM_TARGET_MAX_THREADS;
+       i != cris_cpu->threadno;
        i = (i + 1) % SIM_TARGET_MAX_THREADS)
-    if (current_cpu->thread_data[i].cpu_context
-       && current_cpu->thread_data[i].at_syscall == 0)
+    if (cris_cpu->thread_data[i].cpu_context
+       && cris_cpu->thread_data[i].at_syscall == 0)
       {
        schedule (current_cpu, i);
        return;
       }
 
   /* Pick any next live thread.  */
-  for (i = (current_cpu->threadno + 1) % SIM_TARGET_MAX_THREADS;
-       i != current_cpu->threadno;
+  for (i = (cris_cpu->threadno + 1) % SIM_TARGET_MAX_THREADS;
+       i != cris_cpu->threadno;
        i = (i + 1) % SIM_TARGET_MAX_THREADS)
-    if (current_cpu->thread_data[i].cpu_context)
+    if (cris_cpu->thread_data[i].cpu_context)
       {
        schedule (current_cpu, i);
        return;
@@ -1260,18 +1263,18 @@ reschedule (SIM_CPU *current_cpu)
 static int
 deliver_signal (SIM_CPU *current_cpu, int sig, unsigned int pid)
 {
+  struct cris_sim_cpu *cris_cpu = CRIS_SIM_CPU (current_cpu);
   int i;
   USI pc = sim_pc_get (current_cpu);
 
   /* Find the thread index of the pid. */
   for (i = 0; i < SIM_TARGET_MAX_THREADS; i++)
     /* Apparently it's ok to send signals to zombies (so a check for
-       current_cpu->thread_data[i].cpu_context != NULL would be
-       wrong). */
-    if (current_cpu->thread_data[i].threadid == pid - TARGET_PID)
+       cris_cpu->thread_data[i].cpu_context != NULL would be wrong).  */
+    if (cris_cpu->thread_data[i].threadid == pid - TARGET_PID)
       {
        if (sig < 64)
-         switch (current_cpu->sighandler[sig])
+         switch (cris_cpu->sighandler[sig])
            {
            case TARGET_SIG_DFL:
              switch (sig)
@@ -1340,8 +1343,8 @@ deliver_signal (SIM_CPU *current_cpu, int sig, unsigned int pid)
              /* Mark the signal as pending, making schedule () check
                 closer.  The signal will be handled when the thread is
                 scheduled and the signal is unblocked.  */
-             current_cpu->thread_data[i].sigdata[sig].pending = 1;
-             current_cpu->thread_data[i].sigpending = 1;
+             cris_cpu->thread_data[i].sigdata[sig].pending = 1;
+             cris_cpu->thread_data[i].sigpending = 1;
              return 0;
            }
        else
@@ -1364,15 +1367,14 @@ static void
 make_first_thread (SIM_CPU *current_cpu)
 {
   SIM_DESC sd = CPU_STATE (current_cpu);
-  current_cpu->thread_data
-    = xcalloc (1,
-              SIM_TARGET_MAX_THREADS
-              * sizeof (current_cpu->thread_data[0]));
-  current_cpu->thread_data[0].cpu_context
-    = (*current_cpu->make_thread_cpu_data) (current_cpu,
-                                           &current_cpu
-                                           ->cpu_data_placeholder);
-  current_cpu->thread_data[0].parent_threadid = -1;
+  struct cris_sim_cpu *cris_cpu = CRIS_SIM_CPU (current_cpu);
+
+  cris_cpu->thread_data
+    = xcalloc (1, SIM_TARGET_MAX_THREADS * sizeof (cris_cpu->thread_data[0]));
+  cris_cpu->thread_data[0].cpu_context
+    = (*cris_cpu->make_thread_cpu_data) (current_cpu,
+                                        &cris_cpu->cpu_data_placeholder);
+  cris_cpu->thread_data[0].parent_threadid = -1;
 
   /* For good measure.  */
   if (TARGET_SIG_DFL != 0)
@@ -1413,11 +1415,12 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
 {
   CB_SYSCALL s;
   SIM_DESC sd = CPU_STATE (current_cpu);
+  struct cris_sim_cpu *cris_cpu = CRIS_SIM_CPU (current_cpu);
   host_callback *cb = STATE_CALLBACK (sd);
   int retval;
-  int threadno = current_cpu->threadno;
+  int threadno = cris_cpu->threadno;
 
-  current_cpu->syscalls++;
+  cris_cpu->syscalls++;
 
   CB_SYSCALL_INIT (&s);
   s.func = callnum;
@@ -1434,7 +1437,7 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
     s.arg2 = (SI) arg2;
 
   if (callnum == TARGET_SYS_exit_group
-      || (callnum == TARGET_SYS_exit && current_cpu->m1threads == 0))
+      || (callnum == TARGET_SYS_exit && cris_cpu->m1threads == 0))
     {
       if (CPU_CRIS_MISC_PROFILE (current_cpu)->flags
          & FLAG_CRIS_MISC_PROFILE_ALL)
@@ -1477,8 +1480,8 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
             forever"; we re-run this insn.  The wait is ended by a
             callback.  Sanity check that this is the reason we got
             here. */
-         if (current_cpu->thread_data == NULL
-             || (current_cpu->thread_data[threadno].pipe_write_fd == 0))
+         if (cris_cpu->thread_data == NULL
+             || (cris_cpu->thread_data[threadno].pipe_write_fd == 0))
            goto unimplemented_syscall;
 
          sim_pc_set (current_cpu, pc);
@@ -1507,10 +1510,10 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
 
            case 3:
              /* F_GETFL.  Check for the special case for open+fdopen.  */
-             if (current_cpu->last_syscall == TARGET_SYS_open
-                 && arg1 == current_cpu->last_open_fd)
+             if (cris_cpu->last_syscall == TARGET_SYS_open
+                 && arg1 == cris_cpu->last_open_fd)
                {
-                 retval = current_cpu->last_open_flags & TARGET_O_ACCMODE;
+                 retval = cris_cpu->last_open_flags & TARGET_O_ACCMODE;
                  break;
                }
              else if (arg1 == 0)
@@ -1598,9 +1601,9 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
          retval = arg1;
 
          if (arg1 == 0)
-           retval = current_cpu->endbrk;
-         else if (arg1 <= current_cpu->endmem)
-           current_cpu->endbrk = arg1;
+           retval = cris_cpu->endbrk;
+         else if (arg1 <= cris_cpu->endmem)
+           cris_cpu->endbrk = arg1;
          else
            {
              USI new_end = (arg1 + 8191) & ~8191;
@@ -1608,35 +1611,35 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
              /* If the simulator wants to brk more than a certain very
                 large amount, something is wrong.  FIXME: Return an error
                 or abort?  Have command-line selectable?  */
-             if (new_end - current_cpu->endmem > SIM_MAX_ALLOC_CHUNK)
+             if (new_end - cris_cpu->endmem > SIM_MAX_ALLOC_CHUNK)
                {
-                 current_cpu->endbrk = current_cpu->endmem;
-                 retval = current_cpu->endmem;
+                 cris_cpu->endbrk = cris_cpu->endmem;
+                 retval = cris_cpu->endmem;
                  break;
                }
 
              sim_core_attach (sd, NULL, 0, access_read_write_exec, 0,
-                              current_cpu->endmem,
-                              new_end - current_cpu->endmem,
+                              cris_cpu->endmem,
+                              new_end - cris_cpu->endmem,
                               0, NULL, NULL);
-             current_cpu->endbrk = arg1;
-             current_cpu->endmem = new_end;
+             cris_cpu->endbrk = arg1;
+             cris_cpu->endmem = new_end;
            }
          break;
 
        case TARGET_SYS_getpid:
          /* Correct until CLONE_THREAD is implemented.  */
-         retval = current_cpu->thread_data == NULL
+         retval = cris_cpu->thread_data == NULL
            ? TARGET_PID
-           : TARGET_PID + current_cpu->thread_data[threadno].threadid;
+           : TARGET_PID + cris_cpu->thread_data[threadno].threadid;
          break;
 
        case TARGET_SYS_getppid:
          /* Correct until CLONE_THREAD is implemented.  */
-         retval = current_cpu->thread_data == NULL
+         retval = cris_cpu->thread_data == NULL
            ? TARGET_PID - 1
            : (TARGET_PID
-              + current_cpu->thread_data[threadno].parent_threadid);
+              + cris_cpu->thread_data[threadno].parent_threadid);
          break;
 
        case TARGET_SYS_mmap2:
@@ -1714,14 +1717,14 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
                  abort ();
 
                if (flags & TARGET_MAP_FIXED)
-                 unmap_pages (sd, &current_cpu->highest_mmapped_page,
+                 unmap_pages (sd, &cris_cpu->highest_mmapped_page,
                               addr, newlen);
-               else if (is_mapped (sd, &current_cpu->highest_mmapped_page,
+               else if (is_mapped (sd, &cris_cpu->highest_mmapped_page,
                                    addr, newlen))
                  addr = 0;
 
                newaddr
-                 = create_map (sd, &current_cpu->highest_mmapped_page,
+                 = create_map (sd, &cris_cpu->highest_mmapped_page,
                                addr != 0 || (flags & TARGET_MAP_FIXED)
                                ? addr : -1,
                                newlen);
@@ -1737,7 +1740,7 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
                if ((flags & TARGET_MAP_FIXED) && newaddr != addr)
                  {
                    abort ();
-                   unmap_pages (sd, &current_cpu->highest_mmapped_page,
+                   unmap_pages (sd, &cris_cpu->highest_mmapped_page,
                                 newaddr, newlen);
                    retval = -cb_host_to_target_errno (cb, EINVAL);
                    break;
@@ -1799,13 +1802,13 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
                USI newaddr;
 
                if (flags & TARGET_MAP_FIXED)
-                 unmap_pages (sd, &current_cpu->highest_mmapped_page,
+                 unmap_pages (sd, &cris_cpu->highest_mmapped_page,
                               addr, newlen);
-               else if (is_mapped (sd, &current_cpu->highest_mmapped_page,
+               else if (is_mapped (sd, &cris_cpu->highest_mmapped_page,
                                    addr, newlen))
                  addr = 0;
 
-               newaddr = create_map (sd, &current_cpu->highest_mmapped_page,
+               newaddr = create_map (sd, &cris_cpu->highest_mmapped_page,
                                      addr != 0 || (flags & TARGET_MAP_FIXED)
                                      ? addr : -1,
                                      newlen);
@@ -1818,7 +1821,7 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
                if ((flags & TARGET_MAP_FIXED) && newaddr != addr)
                  {
                    abort ();
-                   unmap_pages (sd, &current_cpu->highest_mmapped_page,
+                   unmap_pages (sd, &cris_cpu->highest_mmapped_page,
                                 newaddr, newlen);
                    retval = -cb_host_to_target_errno (cb, EINVAL);
                    break;
@@ -1838,7 +1841,7 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
            USI prot = arg3;
 
            if (prot != TARGET_PROT_NONE
-               || !is_mapped_only (sd, &current_cpu->highest_mmapped_page,
+               || !is_mapped_only (sd, &cris_cpu->highest_mmapped_page,
                                    addr, (len + 8191) & ~8191))
              {
                retval
@@ -1880,7 +1883,7 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
            USI addr = arg1;
            USI len = arg2;
            USI result
-             = unmap_pages (sd, &current_cpu->highest_mmapped_page, addr,
+             = unmap_pages (sd, &cris_cpu->highest_mmapped_page, addr,
                             len);
            retval = result != 0 ? -cb_host_to_target_errno (cb, result) : 0;
            break;
@@ -1904,7 +1907,7 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
                      && (options == TARGET___WCLONE
                          || options == TARGET___WALL)))
                || rusagep != 0
-               || current_cpu->thread_data == NULL)
+               || cris_cpu->thread_data == NULL)
              {
                retval
                  = cris_unknown_syscall (current_cpu, pc,
@@ -1920,20 +1923,20 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
            if (pid == (USI) -1)
              for (i = 1; i < SIM_TARGET_MAX_THREADS; i++)
                {
-                 if (current_cpu->thread_data[threadno].threadid
-                     == current_cpu->thread_data[i].parent_threadid
-                     && current_cpu->thread_data[i].threadid != 0
-                     && current_cpu->thread_data[i].cpu_context == NULL)
+                 if (cris_cpu->thread_data[threadno].threadid
+                     == cris_cpu->thread_data[i].parent_threadid
+                     && cris_cpu->thread_data[i].threadid != 0
+                     && cris_cpu->thread_data[i].cpu_context == NULL)
                    {
                      /* A zombied child.  Get the exit value and clear the
                         zombied entry so it will be reused.  */
                      sim_core_write_unaligned_4 (current_cpu, pc, 0, saddr,
-                                                 current_cpu
+                                                 cris_cpu
                                                  ->thread_data[i].exitval);
                      retval
-                       = current_cpu->thread_data[i].threadid + TARGET_PID;
-                     memset (&current_cpu->thread_data[i], 0,
-                             sizeof (current_cpu->thread_data[i]));
+                       = cris_cpu->thread_data[i].threadid + TARGET_PID;
+                     memset (&cris_cpu->thread_data[i], 0,
+                             sizeof (cris_cpu->thread_data[i]));
                      goto outer_break;
                    }
                }
@@ -1942,21 +1945,20 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
                /* We're waiting for a specific PID.  If we don't find
                   it zombied on this run, rerun the syscall.  */
                for (i = 1; i < SIM_TARGET_MAX_THREADS; i++)
-                 if (pid == current_cpu->thread_data[i].threadid + TARGET_PID
-                     && current_cpu->thread_data[i].cpu_context == NULL)
+                 if (pid == cris_cpu->thread_data[i].threadid + TARGET_PID
+                     && cris_cpu->thread_data[i].cpu_context == NULL)
                    {
                      if (saddr != 0)
                        /* Get the exit value if the caller wants it.  */
                        sim_core_write_unaligned_4 (current_cpu, pc, 0,
                                                    saddr,
-                                                   current_cpu
-                                                   ->thread_data[i]
-                                                   .exitval);
+                                                   cris_cpu
+                                                     ->thread_data[i].exitval);
 
                      retval
-                       = current_cpu->thread_data[i].threadid + TARGET_PID;
-                     memset (&current_cpu->thread_data[i], 0,
-                             sizeof (current_cpu->thread_data[i]));
+                       = cris_cpu->thread_data[i].threadid + TARGET_PID;
+                     memset (&cris_cpu->thread_data[i], 0,
+                             sizeof (cris_cpu->thread_data[i]));
 
                      goto outer_break;
                    }
@@ -1986,7 +1988,7 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
            if (old_sa != 0)
              {
                sim_core_write_unaligned_4 (current_cpu, pc, 0, old_sa + 0,
-                                           current_cpu->sighandler[signum]);
+                                           cris_cpu->sighandler[signum]);
                sim_core_write_unaligned_4 (current_cpu, pc, 0, arg3 + 4, 0);
                sim_core_write_unaligned_4 (current_cpu, pc, 0, arg3 + 8, 0);
 
@@ -2037,12 +2039,12 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
                    break;
                  }
 
-               current_cpu->sighandler[signum] = target_sa_handler;
+               cris_cpu->sighandler[signum] = target_sa_handler;
 
                /* Because we may have unblocked signals, one may now be
                   pending, if there are threads, that is.  */
-               if (current_cpu->thread_data)
-                 current_cpu->thread_data[threadno].sigpending = 1;
+               if (cris_cpu->thread_data)
+                 cris_cpu->thread_data[threadno].sigpending = 1;
              }
            retval = 0;
            break;
@@ -2065,18 +2067,18 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
            else if (new_len < old_len)
              {
                /* Shrinking is easy.  */
-               if (unmap_pages (sd, &current_cpu->highest_mmapped_page,
+               if (unmap_pages (sd, &cris_cpu->highest_mmapped_page,
                                 addr + new_len, old_len - new_len) != 0)
                  retval = -cb_host_to_target_errno (cb, EINVAL);
                else
                  retval = addr;
              }
-           else if (! is_mapped (sd, &current_cpu->highest_mmapped_page,
+           else if (! is_mapped (sd, &cris_cpu->highest_mmapped_page,
                                  addr + old_len, new_len - old_len))
              {
                /* If the extension isn't mapped, we can just add it.  */
                mapped_addr
-                 = create_map (sd, &current_cpu->highest_mmapped_page,
+                 = create_map (sd, &cris_cpu->highest_mmapped_page,
                                addr + old_len, new_len - old_len);
 
                if (mapped_addr > (USI) -8192)
@@ -2094,7 +2096,7 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
                USI prev_len = old_len;
 
                mapped_addr
-                 = create_map (sd, &current_cpu->highest_mmapped_page,
+                 = create_map (sd, &cris_cpu->highest_mmapped_page,
                                -1, new_len);
 
                if (mapped_addr > (USI) -8192)
@@ -2115,7 +2117,7 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
                      abort ();
                  }
 
-               if (unmap_pages (sd, &current_cpu->highest_mmapped_page,
+               if (unmap_pages (sd, &cris_cpu->highest_mmapped_page,
                                 prev_addr, prev_len) != 0)
                  abort ();
              }
@@ -2153,7 +2155,7 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
                    != TARGET_POLLIN)
                || ((cb->to_fstat) (cb, fd, &buf) != 0
                    || (buf.st_mode & S_IFIFO) == 0)
-               || current_cpu->thread_data == NULL)
+               || cris_cpu->thread_data == NULL)
              {
                retval
                  = cris_unknown_syscall (current_cpu, pc,
@@ -2171,8 +2173,8 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
            /* Iterate over threads; find a marker that a writer is
               sleeping, waiting for a reader.  */
            for (i = 0; i < SIM_TARGET_MAX_THREADS; i++)
-             if (current_cpu->thread_data[i].cpu_context != NULL
-                 && current_cpu->thread_data[i].pipe_read_fd == fd)
+             if (cris_cpu->thread_data[i].cpu_context != NULL
+                 && cris_cpu->thread_data[i].pipe_read_fd == fd)
                {
                  revents = TARGET_POLLIN;
                  retval = 1;
@@ -2186,7 +2188,7 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
               case.  */
            timeout
              -= (TARGET_TIME_MS (current_cpu)
-                 - (current_cpu->thread_data[threadno].last_execution));
+                 - (cris_cpu->thread_data[threadno].last_execution));
 
            /* Arrange to repeat this syscall until timeout or event,
                decreasing timeout at each iteration.  */
@@ -2347,7 +2349,7 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
            /* At kill(2), glibc sets signal masks such that the thread
               machinery is initialized.  Still, there is and was only
               one thread.  */
-           if (current_cpu->max_threadid == 0)
+           if (cris_cpu->max_threadid == 0)
              {
                if (pid != TARGET_PID)
                  {
@@ -2406,26 +2408,26 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
 
                /* The sigmask is kept in the per-thread data, so we may
                   need to create the first one.  */
-               if (current_cpu->thread_data == NULL)
+               if (cris_cpu->thread_data == NULL)
                  make_first_thread (current_cpu);
 
                if (how == TARGET_SIG_SETMASK)
                  for (i = 0; i < 64; i++)
-                   current_cpu->thread_data[threadno].sigdata[i].blocked = 0;
+                   cris_cpu->thread_data[threadno].sigdata[i].blocked = 0;
 
                for (i = 0; i < 32; i++)
                  if ((set_low & (1 << i)))
-                   current_cpu->thread_data[threadno].sigdata[i + 1].blocked
+                   cris_cpu->thread_data[threadno].sigdata[i + 1].blocked
                      = (how != TARGET_SIG_UNBLOCK);
 
                for (i = 0; i < 31; i++)
                  if ((set_high & (1 << i)))
-                   current_cpu->thread_data[threadno].sigdata[i + 33].blocked
+                   cris_cpu->thread_data[threadno].sigdata[i + 33].blocked
                      = (how != TARGET_SIG_UNBLOCK);
 
                /* The mask changed, so a signal may be unblocked for
                    execution.  */
-               current_cpu->thread_data[threadno].sigpending = 1;
+               cris_cpu->thread_data[threadno].sigpending = 1;
              }
 
            if (oldsetp != 0)
@@ -2434,11 +2436,11 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
                USI set_high = 0;
 
                for (i = 0; i < 32; i++)
-                 if (current_cpu->thread_data[threadno]
+                 if (cris_cpu->thread_data[threadno]
                      .sigdata[i + 1].blocked)
                    set_low |= 1 << i;
                for (i = 0; i < 31; i++)
-                 if (current_cpu->thread_data[threadno]
+                 if (cris_cpu->thread_data[threadno]
                      .sigdata[i + 33].blocked)
                    set_high |= 1 << i;
 
@@ -2456,10 +2458,10 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
            bfd_byte regbuf[4];
            int was_sigsuspended;
 
-           if (current_cpu->thread_data == NULL
+           if (cris_cpu->thread_data == NULL
                /* The CPU context is saved with the simulator data, not
                   on the stack as in the real world.  */
-               || (current_cpu->thread_data[threadno].cpu_context_atsignal
+               || (cris_cpu->thread_data[threadno].cpu_context_atsignal
                    == NULL))
              {
                retval
@@ -2478,17 +2480,17 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
              }
 
            was_sigsuspended
-             = current_cpu->thread_data[threadno].sigsuspended;
+             = cris_cpu->thread_data[threadno].sigsuspended;
 
            /* Restore the sigmask, either from the stack copy made when
               the sighandler was called, or from the saved state
               specifically for sigsuspend(2).  */
            if (was_sigsuspended)
              {
-               current_cpu->thread_data[threadno].sigsuspended = 0;
+               cris_cpu->thread_data[threadno].sigsuspended = 0;
                for (i = 0; i < 64; i++)
-                 current_cpu->thread_data[threadno].sigdata[i].blocked
-                   = current_cpu->thread_data[threadno]
+                 cris_cpu->thread_data[threadno].sigdata[i].blocked
+                   = cris_cpu->thread_data[threadno]
                    .sigdata[i].blocked_suspendsave;
              }
            else
@@ -2506,22 +2508,22 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
                  = sim_core_read_unaligned_4 (current_cpu, pc, 0, sp + 4);
 
                for (i = 0; i < 32; i++)
-                 current_cpu->thread_data[threadno].sigdata[i + 1].blocked
+                 cris_cpu->thread_data[threadno].sigdata[i + 1].blocked
                    = (set_low & (1 << i)) != 0;
                for (i = 0; i < 31; i++)
-                 current_cpu->thread_data[threadno].sigdata[i + 33].blocked
+                 cris_cpu->thread_data[threadno].sigdata[i + 33].blocked
                    = (set_high & (1 << i)) != 0;
              }
 
            /* The mask changed, so a signal may be unblocked for
               execution.  */
-           current_cpu->thread_data[threadno].sigpending = 1;
+           cris_cpu->thread_data[threadno].sigpending = 1;
 
-           memcpy (&current_cpu->cpu_data_placeholder,
-                   current_cpu->thread_data[threadno].cpu_context_atsignal,
-                   current_cpu->thread_cpu_data_size);
-           free (current_cpu->thread_data[threadno].cpu_context_atsignal);
-           current_cpu->thread_data[threadno].cpu_context_atsignal = NULL;
+           memcpy (&cris_cpu->cpu_data_placeholder,
+                   cris_cpu->thread_data[threadno].cpu_context_atsignal,
+                   cris_cpu->thread_cpu_data_size);
+           free (cris_cpu->thread_data[threadno].cpu_context_atsignal);
+           cris_cpu->thread_data[threadno].cpu_context_atsignal = NULL;
 
            /* The return value must come from the saved R10.  */
            (*CPU_REG_FETCH (current_cpu)) (current_cpu, H_GR_R10, regbuf, 4);
@@ -2551,7 +2553,7 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
 
            /* Don't change the signal mask if we're already in
               sigsuspend state (i.e. this syscall is a rerun).  */
-           else if (!current_cpu->thread_data[threadno].sigsuspended)
+           else if (!cris_cpu->thread_data[threadno].sigsuspended)
              {
                USI set_low
                  = sim_core_read_unaligned_4 (current_cpu, pc, 0,
@@ -2565,29 +2567,29 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
                    one.  */
                for (i = 0; i < 32; i++)
                  {
-                   current_cpu->thread_data[threadno]
+                   cris_cpu->thread_data[threadno]
                      .sigdata[i + 1].blocked_suspendsave
-                     = current_cpu->thread_data[threadno]
+                     = cris_cpu->thread_data[threadno]
                      .sigdata[i + 1].blocked;
 
-                   current_cpu->thread_data[threadno]
+                   cris_cpu->thread_data[threadno]
                      .sigdata[i + 1].blocked = (set_low & (1 << i)) != 0;
                  }
                for (i = 0; i < 31; i++)
                  {
-                   current_cpu->thread_data[threadno]
+                   cris_cpu->thread_data[threadno]
                      .sigdata[i + 33].blocked_suspendsave
-                     = current_cpu->thread_data[threadno]
+                     = cris_cpu->thread_data[threadno]
                      .sigdata[i + 33].blocked;
-                   current_cpu->thread_data[threadno]
+                   cris_cpu->thread_data[threadno]
                      .sigdata[i + 33].blocked = (set_high & (1 << i)) != 0;
                  }
 
-               current_cpu->thread_data[threadno].sigsuspended = 1;
+               cris_cpu->thread_data[threadno].sigsuspended = 1;
 
                /* The mask changed, so a signal may be unblocked for
                    execution. */
-               current_cpu->thread_data[threadno].sigpending = 1;
+               cris_cpu->thread_data[threadno].sigpending = 1;
              }
 
            /* Because we don't use arg1 (newsetp) when this syscall is
@@ -2837,8 +2839,8 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
                /* FIXME: Save scheduler setting before threads are
                   created too.  */
                sim_core_write_unaligned_4 (current_cpu, pc, 0, paramp,
-                                           current_cpu->thread_data != NULL
-                                           ? (current_cpu
+                                           cris_cpu->thread_data != NULL
+                                           ? (cris_cpu
                                               ->thread_data[threadno]
                                               .priority)
                                            : 0);
@@ -3005,24 +3007,24 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
            /* Here for all but the last thread.  */
            int i;
            int pid
-             = current_cpu->thread_data[threadno].threadid + TARGET_PID;
+             = cris_cpu->thread_data[threadno].threadid + TARGET_PID;
            int ppid
-             = (current_cpu->thread_data[threadno].parent_threadid
+             = (cris_cpu->thread_data[threadno].parent_threadid
                 + TARGET_PID);
-           int exitsig = current_cpu->thread_data[threadno].exitsig;
+           int exitsig = cris_cpu->thread_data[threadno].exitsig;
 
            /* Any children are now all orphans.  */
            for (i = 0; i < SIM_TARGET_MAX_THREADS; i++)
-             if (current_cpu->thread_data[i].parent_threadid
-                 == current_cpu->thread_data[threadno].threadid)
+             if (cris_cpu->thread_data[i].parent_threadid
+                 == cris_cpu->thread_data[threadno].threadid)
                /* Make getppid(2) return 1 for them, poor little ones.  */
-               current_cpu->thread_data[i].parent_threadid = -TARGET_PID + 1;
+               cris_cpu->thread_data[i].parent_threadid = -TARGET_PID + 1;
 
            /* Free the cpu context data.  When the parent has received
               the exit status, we'll clear the entry too.  */
-           free (current_cpu->thread_data[threadno].cpu_context);
-           current_cpu->thread_data[threadno].cpu_context = NULL;
-           current_cpu->m1threads--;
+           free (cris_cpu->thread_data[threadno].cpu_context);
+           cris_cpu->thread_data[threadno].cpu_context = NULL;
+           cris_cpu->m1threads--;
            if (arg1 != 0)
              {
                sim_io_eprintf (sd, "Thread %d exited with status %d\n",
@@ -3032,7 +3034,7 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
              }
 
            /* Still, we may want to support non-zero exit values.  */
-           current_cpu->thread_data[threadno].exitval = arg1 << 8;
+           cris_cpu->thread_data[threadno].exitval = arg1 << 8;
 
            if (exitsig)
              deliver_signal (current_cpu, exitsig, ppid);
@@ -3041,7 +3043,7 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
 
        case TARGET_SYS_clone:
          {
-           int nthreads = current_cpu->m1threads + 1;
+           int nthreads = cris_cpu->m1threads + 1;
            void *thread_cpu_data;
            bfd_byte old_sp_buf[4];
            bfd_byte sp_buf[4];
@@ -3078,7 +3080,7 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
                break;
              }
 
-           if (current_cpu->thread_data == NULL)
+           if (cris_cpu->thread_data == NULL)
              make_first_thread (current_cpu);
 
            /* The created thread will get the new SP and a cleared R10.
@@ -3095,39 +3097,39 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
            (*CPU_REG_STORE (current_cpu)) (current_cpu,
                                            H_GR_R10, (bfd_byte *) zeros, 4);
            thread_cpu_data
-             = (*current_cpu
+             = (*cris_cpu
                 ->make_thread_cpu_data) (current_cpu,
-                                         &current_cpu->cpu_data_placeholder);
+                                         &cris_cpu->cpu_data_placeholder);
            (*CPU_REG_STORE (current_cpu)) (current_cpu,
                                            H_GR_SP, old_sp_buf, 4);
 
-           retval = ++current_cpu->max_threadid + TARGET_PID;
+           retval = ++cris_cpu->max_threadid + TARGET_PID;
 
            /* Find an unused slot.  After a few threads have been created
               and exited, the array is expected to be a bit fragmented.
               We don't reuse the first entry, though, that of the
               original thread.  */
            for (i = 1; i < SIM_TARGET_MAX_THREADS; i++)
-             if (current_cpu->thread_data[i].cpu_context == NULL
+             if (cris_cpu->thread_data[i].cpu_context == NULL
                  /* Don't reuse a zombied entry.  */
-                 && current_cpu->thread_data[i].threadid == 0)
+                 && cris_cpu->thread_data[i].threadid == 0)
                break;
 
-           memcpy (&current_cpu->thread_data[i],
-                   &current_cpu->thread_data[threadno],
-                   sizeof (current_cpu->thread_data[i]));
-           current_cpu->thread_data[i].cpu_context = thread_cpu_data;
-           current_cpu->thread_data[i].cpu_context_atsignal = NULL;
-           current_cpu->thread_data[i].threadid = current_cpu->max_threadid;
-           current_cpu->thread_data[i].parent_threadid
-             = current_cpu->thread_data[threadno].threadid;
-           current_cpu->thread_data[i].pipe_read_fd = 0;
-           current_cpu->thread_data[i].pipe_write_fd = 0;
-           current_cpu->thread_data[i].at_syscall = 0;
-           current_cpu->thread_data[i].sigpending = 0;
-           current_cpu->thread_data[i].sigsuspended = 0;
-           current_cpu->thread_data[i].exitsig = flags & TARGET_CSIGNAL;
-           current_cpu->m1threads = nthreads;
+           memcpy (&cris_cpu->thread_data[i],
+                   &cris_cpu->thread_data[threadno],
+                   sizeof (cris_cpu->thread_data[i]));
+           cris_cpu->thread_data[i].cpu_context = thread_cpu_data;
+           cris_cpu->thread_data[i].cpu_context_atsignal = NULL;
+           cris_cpu->thread_data[i].threadid = cris_cpu->max_threadid;
+           cris_cpu->thread_data[i].parent_threadid
+             = cris_cpu->thread_data[threadno].threadid;
+           cris_cpu->thread_data[i].pipe_read_fd = 0;
+           cris_cpu->thread_data[i].pipe_write_fd = 0;
+           cris_cpu->thread_data[i].at_syscall = 0;
+           cris_cpu->thread_data[i].sigpending = 0;
+           cris_cpu->thread_data[i].sigsuspended = 0;
+           cris_cpu->thread_data[i].exitsig = flags & TARGET_CSIGNAL;
+           cris_cpu->m1threads = nthreads;
            break;
          }
 
@@ -3143,7 +3145,7 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
              retval = -cb_host_to_target_errno (cb, EINVAL);
              break;
            }
-         (*current_cpu->set_target_thread_data) (current_cpu, arg1);
+         (*cris_cpu->set_target_thread_data) (current_cpu, arg1);
          retval = 0;
          break;
 
@@ -3161,28 +3163,28 @@ cris_break_13_handler (SIM_CPU *current_cpu, USI callnum, USI arg1,
   /* Minimal support for fcntl F_GETFL as used in open+fdopen.  */
   if (callnum == TARGET_SYS_open)
     {
-      current_cpu->last_open_fd = retval;
-      current_cpu->last_open_flags = arg2;
+      cris_cpu->last_open_fd = retval;
+      cris_cpu->last_open_flags = arg2;
     }
 
-  current_cpu->last_syscall = callnum;
+  cris_cpu->last_syscall = callnum;
 
   /* A system call is a rescheduling point.  For the time being, we don't
      reschedule anywhere else.  */
-  if (current_cpu->m1threads != 0
+  if (cris_cpu->m1threads != 0
       /* We need to schedule off from an exiting thread that is the
         second-last one.  */
-      || (current_cpu->thread_data != NULL
-         && current_cpu->thread_data[threadno].cpu_context == NULL))
+      || (cris_cpu->thread_data != NULL
+         && cris_cpu->thread_data[threadno].cpu_context == NULL))
     {
       bfd_byte retval_buf[4];
 
-      current_cpu->thread_data[threadno].last_execution
+      cris_cpu->thread_data[threadno].last_execution
        = TARGET_TIME_MS (current_cpu);
       bfd_putl32 (retval, retval_buf);
       (*CPU_REG_STORE (current_cpu)) (current_cpu, H_GR_R10, retval_buf, 4);
 
-      current_cpu->thread_data[threadno].at_syscall = 1;
+      cris_cpu->thread_data[threadno].at_syscall = 1;
       reschedule (current_cpu);
 
       (*CPU_REG_FETCH (current_cpu)) (current_cpu, H_GR_R10, retval_buf, 4);
@@ -3202,6 +3204,7 @@ cris_pipe_nonempty (host_callback *cb ATTRIBUTE_UNUSED,
                    int reader, int writer)
 {
   SIM_CPU *cpu = current_cpu_for_cb_callback;
+  struct cris_sim_cpu *cris_cpu = CRIS_SIM_CPU (cpu);
   const bfd_byte zeros[4] = { 0, 0, 0, 0 };
 
   /* It's the current thread: we just have to re-run the current
@@ -3213,7 +3216,7 @@ cris_pipe_nonempty (host_callback *cb ATTRIBUTE_UNUSED,
      This function may be called multiple times between cris_pipe_empty,
      but we must avoid e.g. decreasing PC every time.  Check fd markers
      to tell.  */
-  if (cpu->thread_data == NULL)
+  if (cris_cpu->thread_data == NULL)
     {
       sim_io_eprintf (CPU_STATE (cpu),
                      "Terminating simulation due to writing pipe rd:wr %d:%d"
@@ -3221,10 +3224,10 @@ cris_pipe_nonempty (host_callback *cb ATTRIBUTE_UNUSED,
       sim_engine_halt (CPU_STATE (cpu), cpu,
                       NULL, sim_pc_get (cpu), sim_stopped, SIM_SIGILL);
     }
-  else if (cpu->thread_data[cpu->threadno].pipe_write_fd == 0)
+  else if (cris_cpu->thread_data[cris_cpu->threadno].pipe_write_fd == 0)
     {
-      cpu->thread_data[cpu->threadno].pipe_write_fd = writer;
-      cpu->thread_data[cpu->threadno].pipe_read_fd = reader;
+      cris_cpu->thread_data[cris_cpu->threadno].pipe_write_fd = writer;
+      cris_cpu->thread_data[cris_cpu->threadno].pipe_read_fd = reader;
       /* FIXME: We really shouldn't change registers other than R10 in
         syscalls (like R9), here or elsewhere.  */
       (*CPU_REG_STORE (cpu)) (cpu, H_GR_R9, (bfd_byte *) zeros, 4);
@@ -3244,6 +3247,7 @@ cris_pipe_empty (host_callback *cb,
 {
   int i;
   SIM_CPU *cpu = current_cpu_for_cb_callback;
+  struct cris_sim_cpu *cris_cpu = CRIS_SIM_CPU (cpu);
   SIM_DESC sd = CPU_STATE (current_cpu_for_cb_callback);
   bfd_byte r10_buf[4];
   int remaining
@@ -3251,20 +3255,20 @@ cris_pipe_empty (host_callback *cb,
 
   /* We need to find the thread that waits for this pipe.  */
   for (i = 0; i < SIM_TARGET_MAX_THREADS; i++)
-    if (cpu->thread_data[i].cpu_context
-       && cpu->thread_data[i].pipe_write_fd == writer)
+    if (cris_cpu->thread_data[i].cpu_context
+       && cris_cpu->thread_data[i].pipe_write_fd == writer)
       {
        int retval;
 
        /* Temporarily switch to this cpu context, so we can change the
           PC by ordinary calls.  */
 
-       memcpy (cpu->thread_data[cpu->threadno].cpu_context,
-               &cpu->cpu_data_placeholder,
-               cpu->thread_cpu_data_size);
-       memcpy (&cpu->cpu_data_placeholder,
-               cpu->thread_data[i].cpu_context,
-               cpu->thread_cpu_data_size);
+       memcpy (cris_cpu->thread_data[cris_cpu->threadno].cpu_context,
+               &cris_cpu->cpu_data_placeholder,
+               cris_cpu->thread_cpu_data_size);
+       memcpy (&cris_cpu->cpu_data_placeholder,
+               cris_cpu->thread_data[i].cpu_context,
+               cris_cpu->thread_cpu_data_size);
 
        /* The return value is supposed to contain the number of
           written bytes, which is the number of bytes requested and
@@ -3286,14 +3290,14 @@ cris_pipe_empty (host_callback *cb,
            (*CPU_REG_STORE (cpu)) (cpu, H_GR_R10, r10_buf, 4);
          }
        sim_pc_set (cpu, sim_pc_get (cpu) + 2);
-       memcpy (cpu->thread_data[i].cpu_context,
-               &cpu->cpu_data_placeholder,
-               cpu->thread_cpu_data_size);
-       memcpy (&cpu->cpu_data_placeholder,
-               cpu->thread_data[cpu->threadno].cpu_context,
-               cpu->thread_cpu_data_size);
-       cpu->thread_data[i].pipe_read_fd = 0;
-       cpu->thread_data[i].pipe_write_fd = 0;
+       memcpy (cris_cpu->thread_data[i].cpu_context,
+               &cris_cpu->cpu_data_placeholder,
+               cris_cpu->thread_cpu_data_size);
+       memcpy (&cris_cpu->cpu_data_placeholder,
+               cris_cpu->thread_data[cris_cpu->threadno].cpu_context,
+               cris_cpu->thread_cpu_data_size);
+       cris_cpu->thread_data[i].pipe_read_fd = 0;
+       cris_cpu->thread_data[i].pipe_write_fd = 0;
        return;
       }