[deliverable/binutils-gdb.git] / sim / cris / cris-tmpl.c

/* CRIS base simulator support code
   Copyright (C) 2004, 2005 Free Software Foundation, Inc.
   Contributed by Axis Communications.

This file is part of the GNU simulators.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

/* The infrastructure is based on that of i960.c.  */

#define WANT_CPU

#include "sim-main.h"
#include "cgen-mem.h"
#include "cgen-ops.h"

#define MY(f) XCONCAT3(crisv,BASENUM,f)

/* Dispatcher for break insn.  */

USI
MY (f_break_handler) (SIM_CPU *cpu, USI breaknum, USI pc)
{
  SIM_DESC sd = CPU_STATE (cpu);
  USI ret = pc + 2;

  MY (f_h_pc_set) (cpu, ret);

  /* FIXME: Error out if IBR or ERP set.  */
  switch (breaknum)
    {
    case 13:
      MY (f_h_gr_set (cpu, 10,
		      cris_break_13_handler (cpu,
					     MY (f_h_gr_get (cpu, 9)),
					     MY (f_h_gr_get (cpu, 10)),
					     MY (f_h_gr_get (cpu, 11)),
					     MY (f_h_gr_get (cpu, 12)),
					     MY (f_h_gr_get (cpu, 13)),
					     MY (f_h_sr_get (cpu, 7)),
					     MY (f_h_sr_get (cpu, 11)),
					     pc)));
      break;

    case 14:
      sim_io_printf (sd, "%x\n", MY (f_h_gr_get (cpu, 3)));
      break;

    case 15:
      /* Re-use the Linux exit call.  */
      cris_break_13_handler (cpu, /* TARGET_SYS_exit */ 1, 0,
			     0, 0, 0, 0, 0, pc);

    default:
      abort ();
    }

  return MY (f_h_pc_get) (cpu);
}

/* Accessor function for simulator internal use.
   Note the contents of BUF are in target byte order.  */

int
MY (f_fetch_register) (SIM_CPU *current_cpu, int rn,
		      unsigned char *buf, int len ATTRIBUTE_UNUSED)
{
  SETTSI (buf, XCONCAT3(crisv,BASENUM,f_h_gr_get) (current_cpu, rn));
  return -1;
}

/* Accessor function for simulator internal use.
   Note the contents of BUF are in target byte order.  */

int
MY (f_store_register) (SIM_CPU *current_cpu, int rn,
		      unsigned char *buf, int len ATTRIBUTE_UNUSED)
{
  XCONCAT3(crisv,BASENUM,f_h_gr_set) (current_cpu, rn, GETTSI (buf));
  return -1;
}
\f
#if WITH_PROFILE_MODEL_P

/* FIXME: Some of these should be inline or macros.  Later.  */

/* Initialize cycle counting for an insn.
   FIRST_P is non-zero if this is the first insn in a set of parallel
   insns.  */

void
MY (f_model_insn_before) (SIM_CPU *current_cpu, int first_p ATTRIBUTE_UNUSED)
{
  /* To give the impression that we actually know what PC is, we have to
     dump register contents *before* the *next* insn, not after the
     *previous* insn.  Uhh...  */

  /* FIXME: Move this to separate, overridable function.  */
  if ((CPU_CRIS_MISC_PROFILE (current_cpu)->flags
       & FLAG_CRIS_MISC_PROFILE_XSIM_TRACE)
#ifdef GET_H_INSN_PREFIXED_P
      /* For versions with prefixed insns, trace the combination as
	 one insn.  */
      && !GET_H_INSN_PREFIXED_P ()
#endif
      && 1)
  {
    int i;
    char flags[7];
    SIM_DESC sd = CPU_STATE (current_cpu);

    cris_trace_printf (sd, current_cpu, "%lx ",
		       0xffffffffUL & (unsigned long) (CPU (h_pc)));

    for (i = 0; i < 15; i++)
      cris_trace_printf (sd, current_cpu, "%lx ",
			 0xffffffffUL
			 & (unsigned long) (XCONCAT3(crisv,BASENUM,
						     f_h_gr_get) (current_cpu,
								  i)));
    flags[0] = GET_H_IBIT () != 0 ? 'I' : 'i';
    flags[1] = GET_H_XBIT () != 0 ? 'X' : 'x';
    flags[2] = GET_H_NBIT () != 0 ? 'N' : 'n';
    flags[3] = GET_H_ZBIT () != 0 ? 'Z' : 'z';
    flags[4] = GET_H_VBIT () != 0 ? 'V' : 'v';
    flags[5] = GET_H_CBIT () != 0 ? 'C' : 'c';
    flags[6] = 0;

    /* Emit ACR after flags and cycle count for this insn.  */
    if (BASENUM == 32)
      cris_trace_printf (sd, current_cpu, "%s %d %lx\n", flags,
			 (int)
			 ((CPU_CRIS_MISC_PROFILE (current_cpu)
			   ->basic_cycle_count
			   - CPU_CRIS_PREV_MISC_PROFILE (current_cpu)
			   ->basic_cycle_count)
			  + (CPU_CRIS_MISC_PROFILE (current_cpu)
			     ->unaligned_mem_dword_count
			     - CPU_CRIS_PREV_MISC_PROFILE (current_cpu)
			     ->unaligned_mem_dword_count)),
			 0xffffffffUL
			 & (unsigned long) (XCONCAT3(crisv,BASENUM,
						     f_h_gr_get) (current_cpu,
								  15)));
    else
      cris_trace_printf (sd, current_cpu, "%s %d\n", flags,
			 (int)
			 ((CPU_CRIS_MISC_PROFILE (current_cpu)
			   ->basic_cycle_count
			   - CPU_CRIS_PREV_MISC_PROFILE (current_cpu)
			   ->basic_cycle_count)
			  + (CPU_CRIS_MISC_PROFILE (current_cpu)
			     ->unaligned_mem_dword_count
			     - CPU_CRIS_PREV_MISC_PROFILE (current_cpu)
			     ->unaligned_mem_dword_count)));

    CPU_CRIS_PREV_MISC_PROFILE (current_cpu)[0]
      = CPU_CRIS_MISC_PROFILE (current_cpu)[0];
  }
}

/* Record the cycles computed for an insn.
   LAST_P is non-zero if this is the last insn in a set of parallel insns,
   and we update the total cycle count.
   CYCLES is the cycle count of the insn.  */

void
MY (f_model_insn_after) (SIM_CPU *current_cpu, int last_p ATTRIBUTE_UNUSED,
			 int cycles)
{
  PROFILE_DATA *p = CPU_PROFILE_DATA (current_cpu);

  PROFILE_MODEL_TOTAL_CYCLES (p) += cycles;
  CPU_CRIS_MISC_PROFILE (current_cpu)->basic_cycle_count += cycles;
  PROFILE_MODEL_CUR_INSN_CYCLES (p) = cycles;
}

/* Initialize cycle counting for an insn.
   FIRST_P is non-zero if this is the first insn in a set of parallel
   insns.  */

void
MY (f_model_init_insn_cycles) (SIM_CPU *current_cpu ATTRIBUTE_UNUSED,
			       int first_p ATTRIBUTE_UNUSED)
{
  abort ();
}

/* Record the cycles computed for an insn.
   LAST_P is non-zero if this is the last insn in a set of parallel insns,
   and we update the total cycle count.  */

void
MY (f_model_update_insn_cycles) (SIM_CPU *current_cpu ATTRIBUTE_UNUSED,
				 int last_p ATTRIBUTE_UNUSED)
{
  abort ();
}

#if 0
void
MY (f_model_record_cycles) (SIM_CPU *current_cpu, unsigned long cycles)
{
  abort ();
}

void
MY (f_model_mark_get_h_gr) (SIM_CPU *current_cpu, ARGBUF *abuf)
{
  abort ();
}

void
MY (f_model_mark_set_h_gr) (SIM_CPU *current_cpu, ARGBUF *abuf)
{
  abort ();
}
#endif
\f
/* Create the context for a thread.  */

void *
MY (make_thread_cpu_data) (SIM_CPU *current_cpu, void *context)
{
  void *info = xmalloc (current_cpu->thread_cpu_data_size);

  if (context != NULL)
    memcpy (info,
	    context,
	    current_cpu->thread_cpu_data_size);
  else
    memset (info, 0, current_cpu->thread_cpu_data_size),abort();
  return info;
}

/* Hook function for per-cpu simulator initialization.  */

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);
}
\f
/* Model function for arbitrary single stall cycles.  */

int
MY (XCONCAT3 (f_model_crisv,BASENUM,
	      _u_stall)) (SIM_CPU *current_cpu ATTRIBUTE_UNUSED,
			  const IDESC *idesc,
			  int unit_num,
			  int referenced ATTRIBUTE_UNUSED)
{
  return idesc->timing->units[unit_num].done;
}

#ifndef SPECIFIC_U_SKIP4_FN

/* Model function for u-skip4 unit.  */

int
MY (XCONCAT3 (f_model_crisv,BASENUM,
	      _u_skip4)) (SIM_CPU *current_cpu,
			  const IDESC *idesc,
			  int unit_num,
			  int referenced ATTRIBUTE_UNUSED)
{
  /* Handle PC not being updated with pbb.  FIXME: What if not pbb?  */
  CPU (h_pc) += 4;
  return idesc->timing->units[unit_num].done;
}

#endif

#ifndef SPECIFIC_U_EXEC_FN

/* Model function for u-exec unit.  */

int
MY (XCONCAT3 (f_model_crisv,BASENUM,
	      _u_exec)) (SIM_CPU *current_cpu,
			 const IDESC *idesc,
			 int unit_num, int referenced ATTRIBUTE_UNUSED)
{
  /* Handle PC not being updated with pbb.  FIXME: What if not pbb?  */
  CPU (h_pc) += 2;
  return idesc->timing->units[unit_num].done;
}
#endif

#ifndef SPECIFIC_U_MEM_FN

/* Model function for u-mem unit.  */

int
MY (XCONCAT3 (f_model_crisv,BASENUM,
	      _u_mem)) (SIM_CPU *current_cpu ATTRIBUTE_UNUSED,
			const IDESC *idesc,
			int unit_num,
			int referenced ATTRIBUTE_UNUSED)
{
  return idesc->timing->units[unit_num].done;
}
#endif

#ifndef SPECIFIC_U_CONST16_FN

/* Model function for u-const16 unit.  */

int
MY (XCONCAT3 (f_model_crisv,BASENUM,
	      _u_const16)) (SIM_CPU *current_cpu,
			    const IDESC *idesc,
			    int unit_num,
			    int referenced ATTRIBUTE_UNUSED)
{
  CPU (h_pc) += 2;
  return idesc->timing->units[unit_num].done;
}
#endif /* SPECIFIC_U_CONST16_FN */

#ifndef SPECIFIC_U_CONST32_FN

/* This will be incorrect for early models, where a dword always take
   two cycles.  */
#define CRIS_MODEL_MASK_PC_STALL 2

/* Model function for u-const32 unit.  */

int
MY (XCONCAT3 (f_model_crisv,BASENUM,
	      _u_const32)) (SIM_CPU *current_cpu,
			    const IDESC *idesc,
			    int unit_num,
			    int referenced ATTRIBUTE_UNUSED)
{
  int unaligned_extra
    = (((CPU (h_pc) + 2) & CRIS_MODEL_MASK_PC_STALL)
       == CRIS_MODEL_MASK_PC_STALL);

  /* Handle PC not being updated with pbb.  FIXME: What if not pbb?  */
  CPU_CRIS_MISC_PROFILE (current_cpu)->unaligned_mem_dword_count
    += unaligned_extra;

  CPU (h_pc) += 4;
  return idesc->timing->units[unit_num].done;
}
#endif /* SPECIFIC_U_CONST32_FN */

#ifndef SPECIFIC_U_MOVEM_FN

/* Model function for u-movem unit.  */

int
MY (XCONCAT3 (f_model_crisv,BASENUM,
	      _u_movem)) (SIM_CPU *current_cpu ATTRIBUTE_UNUSED,
			  const IDESC *idesc ATTRIBUTE_UNUSED,
			  int unit_num ATTRIBUTE_UNUSED,
			  int referenced ATTRIBUTE_UNUSED,
			  INT limreg)
{
  /* FIXME: Add cycles for misalignment.  */

  if (limreg == -1)
    abort ();

  /* We don't record movem move cycles in movemsrc_stall_count since
     those cycles have historically been handled as ordinary cycles.  */
  return limreg + 1;
}
#endif /* SPECIFIC_U_MOVEM_FN */

#endif /* WITH_PROFILE_MODEL_P */
Commit	Line	Data
f6bcefef HPN	1	/* CRIS base simulator support code
	2	Copyright (C) 2004, 2005 Free Software Foundation, Inc.
	3	Contributed by Axis Communications.
	4
	5	This file is part of the GNU simulators.
	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	/* The infrastructure is based on that of i960.c. */
	22
	23	#define WANT_CPU
	24
	25	#include "sim-main.h"
	26	#include "cgen-mem.h"
	27	#include "cgen-ops.h"
	28
	29	#define MY(f) XCONCAT3(crisv,BASENUM,f)
	30
	31	/* Dispatcher for break insn. */
	32
	33	USI
	34	MY (f_break_handler) (SIM_CPU *cpu, USI breaknum, USI pc)
	35	{
	36	SIM_DESC sd = CPU_STATE (cpu);
	37	USI ret = pc + 2;
	38
	39	MY (f_h_pc_set) (cpu, ret);
	40
	41	/* FIXME: Error out if IBR or ERP set. */
	42	switch (breaknum)
	43	{
	44	case 13:
	45	MY (f_h_gr_set (cpu, 10,
	46	cris_break_13_handler (cpu,
	47	MY (f_h_gr_get (cpu, 9)),
	48	MY (f_h_gr_get (cpu, 10)),
	49	MY (f_h_gr_get (cpu, 11)),
	50	MY (f_h_gr_get (cpu, 12)),
	51	MY (f_h_gr_get (cpu, 13)),
	52	MY (f_h_sr_get (cpu, 7)),
	53	MY (f_h_sr_get (cpu, 11)),
	54	pc)));
	55	break;
	56
	57	case 14:
	58	sim_io_printf (sd, "%x\n", MY (f_h_gr_get (cpu, 3)));
	59	break;
	60
	61	case 15:
	62	/* Re-use the Linux exit call. */
	63	cris_break_13_handler (cpu, /* TARGET_SYS_exit */ 1, 0,
	64	0, 0, 0, 0, 0, pc);
65
66	default:
67	abort ();
68	}
69
70	return MY (f_h_pc_get) (cpu);
71	}
72
73	/* Accessor function for simulator internal use.
74	Note the contents of BUF are in target byte order. */
75
76	int
77	MY (f_fetch_register) (SIM_CPU *current_cpu, int rn,
78	unsigned char *buf, int len ATTRIBUTE_UNUSED)
79	{
80	SETTSI (buf, XCONCAT3(crisv,BASENUM,f_h_gr_get) (current_cpu, rn));
81	return -1;
82	}
83
84	/* Accessor function for simulator internal use.
85	Note the contents of BUF are in target byte order. */
86
87	int
88	MY (f_store_register) (SIM_CPU *current_cpu, int rn,
89	unsigned char *buf, int len ATTRIBUTE_UNUSED)
90	{
91	XCONCAT3(crisv,BASENUM,f_h_gr_set) (current_cpu, rn, GETTSI (buf));
92	return -1;
93	}
94	\f
95	#if WITH_PROFILE_MODEL_P
96
97	/* FIXME: Some of these should be inline or macros. Later. */
98
99	/* Initialize cycle counting for an insn.
100	FIRST_P is non-zero if this is the first insn in a set of parallel
101	insns. */
102
103	void
104	MY (f_model_insn_before) (SIM_CPU *current_cpu, int first_p ATTRIBUTE_UNUSED)
105	{
106	/* To give the impression that we actually know what PC is, we have to
107	dump register contents before the next insn, not after the
108	previous insn. Uhh... */
109
110	/* FIXME: Move this to separate, overridable function. */
111	if ((CPU_CRIS_MISC_PROFILE (current_cpu)->flags
112	& FLAG_CRIS_MISC_PROFILE_XSIM_TRACE)
113	#ifdef GET_H_INSN_PREFIXED_P
114	/* For versions with prefixed insns, trace the combination as
115	one insn. */
116	&& !GET_H_INSN_PREFIXED_P ()
117	#endif
118	&& 1)
119	{
120	int i;
121	char flags[7];
122	SIM_DESC sd = CPU_STATE (current_cpu);
123
ae81c235 HPN	124	cris_trace_printf (sd, current_cpu, "%lx ",
ae81c235 HPN	125	0xffffffffUL & (unsigned long) (CPU (h_pc)));
f6bcefef HPN	126
	127	for (i = 0; i < 15; i++)
	128	cris_trace_printf (sd, current_cpu, "%lx ",
ae81c235 HPN	129	0xffffffffUL
	130	& (unsigned long) (XCONCAT3(crisv,BASENUM,
	131	f_h_gr_get) (current_cpu,
	132	i)));
f6bcefef HPN	133	flags[0] = GET_H_IBIT () != 0 ? 'I' : 'i';
	134	flags[1] = GET_H_XBIT () != 0 ? 'X' : 'x';
	135	flags[2] = GET_H_NBIT () != 0 ? 'N' : 'n';
	136	flags[3] = GET_H_ZBIT () != 0 ? 'Z' : 'z';
	137	flags[4] = GET_H_VBIT () != 0 ? 'V' : 'v';
	138	flags[5] = GET_H_CBIT () != 0 ? 'C' : 'c';
	139	flags[6] = 0;
	140
	141	/* Emit ACR after flags and cycle count for this insn. */
	142	if (BASENUM == 32)
	143	cris_trace_printf (sd, current_cpu, "%s %d %lx\n", flags,
	144	(int)
	145	((CPU_CRIS_MISC_PROFILE (current_cpu)
	146	->basic_cycle_count
	147	- CPU_CRIS_PREV_MISC_PROFILE (current_cpu)
	148	->basic_cycle_count)
	149	+ (CPU_CRIS_MISC_PROFILE (current_cpu)
	150	->unaligned_mem_dword_count
	151	- CPU_CRIS_PREV_MISC_PROFILE (current_cpu)
	152	->unaligned_mem_dword_count)),
ae81c235 HPN	153	0xffffffffUL
	154	& (unsigned long) (XCONCAT3(crisv,BASENUM,
	155	f_h_gr_get) (current_cpu,
	156	15)));
f6bcefef HPN	157	else
	158	cris_trace_printf (sd, current_cpu, "%s %d\n", flags,
	159	(int)
	160	((CPU_CRIS_MISC_PROFILE (current_cpu)
	161	->basic_cycle_count
	162	- CPU_CRIS_PREV_MISC_PROFILE (current_cpu)
	163	->basic_cycle_count)
	164	+ (CPU_CRIS_MISC_PROFILE (current_cpu)
	165	->unaligned_mem_dword_count
	166	- CPU_CRIS_PREV_MISC_PROFILE (current_cpu)
	167	->unaligned_mem_dword_count)));
	168
	169	CPU_CRIS_PREV_MISC_PROFILE (current_cpu)[0]
	170	= CPU_CRIS_MISC_PROFILE (current_cpu)[0];
	171	}
	172	}
	173
	174	/* Record the cycles computed for an insn.
	175	LAST_P is non-zero if this is the last insn in a set of parallel insns,
	176	and we update the total cycle count.
	177	CYCLES is the cycle count of the insn. */
	178
	179	void
	180	MY (f_model_insn_after) (SIM_CPU *current_cpu, int last_p ATTRIBUTE_UNUSED,
	181	int cycles)
	182	{
	183	PROFILE_DATA *p = CPU_PROFILE_DATA (current_cpu);
	184
	185	PROFILE_MODEL_TOTAL_CYCLES (p) += cycles;
	186	CPU_CRIS_MISC_PROFILE (current_cpu)->basic_cycle_count += cycles;
	187	PROFILE_MODEL_CUR_INSN_CYCLES (p) = cycles;
	188	}
	189
	190	/* Initialize cycle counting for an insn.
	191	FIRST_P is non-zero if this is the first insn in a set of parallel
	192	insns. */
	193
	194	void
	195	MY (f_model_init_insn_cycles) (SIM_CPU *current_cpu ATTRIBUTE_UNUSED,
	196	int first_p ATTRIBUTE_UNUSED)
	197	{
	198	abort ();
	199	}
	200
	201	/* Record the cycles computed for an insn.
	202	LAST_P is non-zero if this is the last insn in a set of parallel insns,
	203	and we update the total cycle count. */
	204
	205	void
	206	MY (f_model_update_insn_cycles) (SIM_CPU *current_cpu ATTRIBUTE_UNUSED,
	207	int last_p ATTRIBUTE_UNUSED)
	208	{
	209	abort ();
	210	}
	211
	212	#if 0
	213	void
	214	MY (f_model_record_cycles) (SIM_CPU *current_cpu, unsigned long cycles)
	215	{
	216	abort ();
	217	}
	218
	219	void
	220	MY (f_model_mark_get_h_gr) (SIM_CPU current_cpu, ARGBUF abuf)
221	{
222	abort ();
223	}
224
225	void
226	MY (f_model_mark_set_h_gr) (SIM_CPU current_cpu, ARGBUF abuf)
227	{
228	abort ();
229	}
230	#endif
231	\f
232	/* Create the context for a thread. */
233
234	void *
235	MY (make_thread_cpu_data) (SIM_CPU current_cpu, void context)
236	{
237	void *info = xmalloc (current_cpu->thread_cpu_data_size);
238
239	if (context != NULL)
240	memcpy (info,
241	context,
242	current_cpu->thread_cpu_data_size);
243	else
244	memset (info, 0, current_cpu->thread_cpu_data_size),abort();
245	return info;
246	}
247
248	/* Hook function for per-cpu simulator initialization. */
249
250	void
251	MY (f_specific_init) (SIM_CPU *current_cpu)
252	{
253	current_cpu->make_thread_cpu_data = MY (make_thread_cpu_data);
254	current_cpu->thread_cpu_data_size = sizeof (current_cpu->cpu_data);
255	}
256	\f
257	/* Model function for arbitrary single stall cycles. */
258
259	int
260	MY (XCONCAT3 (f_model_crisv,BASENUM,
261	_u_stall)) (SIM_CPU *current_cpu ATTRIBUTE_UNUSED,
262	const IDESC *idesc,
263	int unit_num,
264	int referenced ATTRIBUTE_UNUSED)
265	{
266	return idesc->timing->units[unit_num].done;
267	}
268
269	#ifndef SPECIFIC_U_SKIP4_FN
270
271	/* Model function for u-skip4 unit. */
272
273	int
274	MY (XCONCAT3 (f_model_crisv,BASENUM,
275	_u_skip4)) (SIM_CPU *current_cpu,
276	const IDESC *idesc,
277	int unit_num,
278	int referenced ATTRIBUTE_UNUSED)
279	{
280	/* Handle PC not being updated with pbb. FIXME: What if not pbb? */
281	CPU (h_pc) += 4;
282	return idesc->timing->units[unit_num].done;
283	}
284
285	#endif
286
287	#ifndef SPECIFIC_U_EXEC_FN
288
289	/* Model function for u-exec unit. */
290
291	int
292	MY (XCONCAT3 (f_model_crisv,BASENUM,
293	_u_exec)) (SIM_CPU *current_cpu,
294	const IDESC *idesc,
295	int unit_num, int referenced ATTRIBUTE_UNUSED)
296	{
297	/* Handle PC not being updated with pbb. FIXME: What if not pbb? */
298	CPU (h_pc) += 2;
299	return idesc->timing->units[unit_num].done;
300	}
301	#endif
302
303	#ifndef SPECIFIC_U_MEM_FN
304
305	/* Model function for u-mem unit. */
306
307	int
308	MY (XCONCAT3 (f_model_crisv,BASENUM,
309	_u_mem)) (SIM_CPU *current_cpu ATTRIBUTE_UNUSED,
310	const IDESC *idesc,
311	int unit_num,
312	int referenced ATTRIBUTE_UNUSED)
313	{
314	return idesc->timing->units[unit_num].done;
315	}
316	#endif
317
318	#ifndef SPECIFIC_U_CONST16_FN
319
320	/* Model function for u-const16 unit. */
321
322	int
323	MY (XCONCAT3 (f_model_crisv,BASENUM,
324	_u_const16)) (SIM_CPU *current_cpu,
325	const IDESC *idesc,
326	int unit_num,
327	int referenced ATTRIBUTE_UNUSED)
328	{
329	CPU (h_pc) += 2;
330	return idesc->timing->units[unit_num].done;
331	}
332	#endif /* SPECIFIC_U_CONST16_FN */
333
334	#ifndef SPECIFIC_U_CONST32_FN
335
336	/* This will be incorrect for early models, where a dword always take
337	two cycles. */
338	#define CRIS_MODEL_MASK_PC_STALL 2
339
340	/* Model function for u-const32 unit. */
341
342	int
343	MY (XCONCAT3 (f_model_crisv,BASENUM,
344	_u_const32)) (SIM_CPU *current_cpu,
345	const IDESC *idesc,
346	int unit_num,
347	int referenced ATTRIBUTE_UNUSED)
348	{
349	int unaligned_extra
350	= (((CPU (h_pc) + 2) & CRIS_MODEL_MASK_PC_STALL)
351	== CRIS_MODEL_MASK_PC_STALL);
352
353	/* Handle PC not being updated with pbb. FIXME: What if not pbb? */
354	CPU_CRIS_MISC_PROFILE (current_cpu)->unaligned_mem_dword_count
355	+= unaligned_extra;
356
357	CPU (h_pc) += 4;
358	return idesc->timing->units[unit_num].done;
359	}
360	#endif /* SPECIFIC_U_CONST32_FN */
361
362	#ifndef SPECIFIC_U_MOVEM_FN
363
364	/* Model function for u-movem unit. */
365
366	int
367	MY (XCONCAT3 (f_model_crisv,BASENUM,
368	_u_movem)) (SIM_CPU *current_cpu ATTRIBUTE_UNUSED,
369	const IDESC *idesc ATTRIBUTE_UNUSED,
370	int unit_num ATTRIBUTE_UNUSED,
371	int referenced ATTRIBUTE_UNUSED,
372	INT limreg)
373	{
374	/* FIXME: Add cycles for misalignment. */
375
376	if (limreg == -1)
377	abort ();
378
379	/* We don't record movem move cycles in movemsrc_stall_count since
380	those cycles have historically been handled as ordinary cycles. */
381	return limreg + 1;
382	}
383	#endif /* SPECIFIC_U_MOVEM_FN */
384
385	#endif /* WITH_PROFILE_MODEL_P */