[deliverable/binutils-gdb.git] / sim / v850 / simops.c

#include <signal.h>
#include "v850_sim.h"
#include "simops.h"

void
OP_220 ()
{
}

void
OP_10760 ()
{
}

void
OP_C7C0 ()
{
}

void
OP_760 ()
{
}

void
OP_580 ()
{
}

void
OP_700 ()
{
}

void
OP_581 ()
{
}

void
OP_582 ()
{
}

void
OP_583 ()
{
}

void
OP_584 ()
{
}

void
OP_585 ()
{
}

void
OP_586 ()
{
}

void
OP_587 ()
{
}

void
OP_588 ()
{
}

void
OP_589 ()
{
}

void
OP_58A ()
{
}

void
OP_58B ()
{
}

void
OP_58C ()
{
}

void
OP_400 ()
{
}

void
OP_160 ()
{
}

void
OP_58D ()
{
}

void
OP_58E ()
{
}

void
OP_58F ()
{
}

void
OP_660 ()
{
}


/* add reg, reg

   XXX condition codes.  */
void
OP_1C0 ()
{
  State.regs[OP[1]] += State.regs[OP[0]];
}

/* add sign_extend(imm5), reg

   XXX condition codes.  */
void
OP_240 ()
{
  int value = OP[0];
 
  value = (value << 27) >> 27;

  State.regs[OP[1]] += value;
}

/* addi sign_extend(imm16), reg, reg

   XXX condition codes.  */
void
OP_600 ()
{
  int value = OP[0];
 
  value = (value << 16) >> 16;

  State.regs[OP[2]] = State.regs[OP[1]] + value;
}

/* sub reg1, reg2

   XXX condition codes  */
void
OP_1A0 ()
{
  State.regs[OP[1]] -= State.regs[OP[0]];
}

/* subr reg1, reg2

   XXX condition codes */
void
OP_180 ()
{
  State.regs[OP[1]] = State.regs[OP[0]] - State.regs[OP[1]];
}

/* mulh reg1, reg2

   XXX condition codes */
void
OP_E0 ()
{
  State.regs[OP[1]] = ((State.regs[OP[1]] & 0xffff)
		       * (State.regs[OP[0]] & 0xffff));
}

/* mulh sign_extend(imm5), reg2

   Condition codes */
void
OP_2E0 ()
{
  int value = OP[0];
 
  value = (value << 27) >> 27;

  State.regs[OP[1]] = (State.regs[OP[1]] & 0xffff) * value;
}

/* mulhi imm16, reg1, reg2

   XXX condition codes */
void
OP_6E0 ()
{
  int value = OP[0];
 
  value = value & 0xffff;

  State.regs[OP[2]] = (State.regs[OP[1]] & 0xffff) * value;
}

/* divh reg1, reg2

   XXX condition codes.
   XXX Is this signed or unsigned?  */
void
OP_40 ()
{
  State.regs[OP[1]] /= (State.regs[OP[0]] & 0xffff);
}

void
OP_10720 ()
{
}

void
OP_780 ()
{
}

void
OP_720 ()
{
}

void
OP_60 ()
{
}

void
OP_87C0 ()
{
}

void
OP_300 ()
{
}

/* mov reg, reg */
void
OP_0 ()
{
  State.regs[OP[1]] = State.regs[OP[0]];
}

/* mov sign_extend(imm5), reg */
void
OP_200 ()
{
  int value = OP[0];
 
  value = (value << 27) >> 27;
  State.regs[OP[1]] = value;
}

/* movea sign_extend(imm16), reg, reg  */

void
OP_620 ()
{
  int value = OP[0];
 
  value = (value << 16) >> 16;

  State.regs[OP[2]] = State.regs[OP[1]] + value;
}

/* movhi imm16, reg, reg */
void
OP_640 ()
{
  int value = OP[0];
 
  value = (value & 0xffff) << 16; 

  State.regs[OP[2]] = State.regs[OP[1]] + value;
}

void
OP_7C0 ()
{
}

void
OP_1687E0 ()
{
}

void
OP_1E0 ()
{
}

void
OP_A0 ()
{
}

void
OP_260 ()
{
}

void
OP_740 ()
{
}

void
OP_80 ()
{
}

/* not reg1, reg2

   XXX condition codes */
void
OP_20 ()
{
  State.regs[OP[1]] = ~State.regs[OP[0]];
}

/* sar zero_extend(imm5),reg1

   XXX condition codes.  */
void
OP_2A0 ()
{
  int temp = State.regs[OP[1]];

  temp >>= (OP[0] & 0x1f);

  State.regs[OP[1]] = temp;
}

/* sar reg1, reg2

   XXX condition codes.  */
void
OP_A007E0 ()
{
  int temp = State.regs[OP[1]];

  temp >>= (State.regs[OP[0]] & 0x1f);

  State.regs[OP[1]] = temp;
}

/* shl zero_extend(imm5),reg1

   XXX condition codes.  */
void
OP_2C0 ()
{
  State.regs[OP[1]] <<= (OP[0] & 0x1f);
}

/* shl reg1, reg2

   XXX condition codes.  */
void
OP_C007E0 ()
{
  State.regs[OP[1]] <<= (State.regs[OP[0]] & 0x1f);
}

/* shr zero_extend(imm5),reg1

   XXX condition codes.  */
void
OP_280 ()
{
  State.regs[OP[1]] >>= (OP[0] & 0x1f);
}

/* shr reg1, reg2

   XXX condition codes.  */
void
OP_8007E0 ()
{
  State.regs[OP[1]] >>= (State.regs[OP[0]] & 0x1f);
}

void
OP_500 ()
{
}

void
OP_47C0 ()
{
}

void
OP_7E0 ()
{
}

/* or reg, reg

   XXX condition codes.  */
void
OP_100 ()
{
  State.regs[OP[1]] |= State.regs[OP[0]];
}

/* ori zero_extend(imm16), reg, reg

   XXX condition codes */
void
OP_680 ()
{
  int value = OP[0];
 
  value &= 0xffff;

  State.regs[OP[2]] = State.regs[OP[1]] | value;
}

/* and reg, reg

   XXX condition codes.  */
void
OP_140 ()
{
  State.regs[OP[1]] &= State.regs[OP[0]];
}

/* andi zero_extend(imm16), reg, reg

   XXX condition codes.  */
void
OP_6C0 ()
{
  int value = OP[0];
 
  value &= 0xffff;

  State.regs[OP[2]] = State.regs[OP[1]] & value;
}

/* xor reg, reg

   XXX condition codes.  */
void
OP_120 ()
{
  State.regs[OP[1]] ^= State.regs[OP[0]];
}

/* xori zero_extend(imm16), reg, reg

   XXX condition codes.  */
void
OP_6A0 ()
{
  int value = OP[0];
 
  value &= 0xffff;

  State.regs[OP[2]] = State.regs[OP[1]] ^ value;
}

void
OP_C0 ()
{
}

void
OP_480 ()
{
}

void
OP_380 ()
{
}

void
OP_501 ()
{
}

/* di, not supported */
void
OP_16007E0 ()
{
  abort ();
}

/* ei, not supported */
void
OP_16087E0 ()
{
  abort ();
}

/* halt, not supported */
void
OP_12007E0 ()
{
  abort ();
}

/* reti, not supported */
void
OP_14007E0 ()
{
  abort ();
}

/* trap, not supportd */
void
OP_10007E0 ()
{
  abort ();
}

/* ldsr, not supported */
void
OP_2007E0 ()
{
  abort ();
}

/* stsr, not supported */
void
OP_4007E0 ()
{
  abort ();
}
Commit	Line	Data
22c1c7dd JL	1	#include <signal.h>
	2	#include "v850_sim.h"
	3	#include "simops.h"
	4
22c1c7dd JL	5	void
	6	OP_220 ()
	7	{
	8	}
	9
	10	void
	11	OP_10760 ()
	12	{
	13	}
	14
	15	void
	16	OP_C7C0 ()
	17	{
	18	}
	19
	20	void
	21	OP_760 ()
	22	{
	23	}
	24
22c1c7dd JL	25	void
	26	OP_580 ()
	27	{
	28	}
	29
	30	void
	31	OP_700 ()
	32	{
	33	}
	34
	35	void
	36	OP_581 ()
	37	{
	38	}
	39
22c1c7dd JL	40	void
	41	OP_582 ()
	42	{
	43	}
	44
	45	void
	46	OP_583 ()
	47	{
	48	}
	49
	50	void
	51	OP_584 ()
	52	{
	53	}
	54
	55	void
	56	OP_585 ()
	57	{
	58	}
	59
	60	void
	61	OP_586 ()
	62	{
	63	}
	64
	65	void
	66	OP_587 ()
	67	{
	68	}
	69
	70	void
	71	OP_588 ()
	72	{
	73	}
	74
	75	void
	76	OP_589 ()
	77	{
	78	}
	79
	80	void
	81	OP_58A ()
	82	{
	83	}
	84
	85	void
	86	OP_58B ()
	87	{
	88	}
	89
	90	void
	91	OP_58C ()
	92	{
	93	}
	94
	95	void
	96	OP_400 ()
	97	{
	98	}
	99
22c1c7dd JL	100	void
	101	OP_160 ()
	102	{
	103	}
	104
	105	void
	106	OP_58D ()
	107	{
	108	}
	109
	110	void
	111	OP_58E ()
	112	{
	113	}
	114
	115	void
	116	OP_58F ()
	117	{
	118	}
	119
	120	void
	121	OP_660 ()
	122	{
	123	}
	124
22c1c7dd	125
1fe983dc JL	126	/* add reg, reg
	127
	128	XXX condition codes. */
22c1c7dd	129	void
1fe983dc	130	OP_1C0 ()
22c1c7dd	131	{
1fe983dc	132	State.regs[OP[1]] += State.regs[OP[0]];
22c1c7dd JL	133	}
22c1c7dd JL	134
1fe983dc JL	135	/* add sign_extend(imm5), reg
	136
	137	XXX condition codes. */
22c1c7dd	138	void
1fe983dc	139	OP_240 ()
22c1c7dd	140	{
1fe983dc JL	141	int value = OP[0];
	142
	143	value = (value << 27) >> 27;
	144
	145	State.regs[OP[1]] += value;
22c1c7dd JL	146	}
22c1c7dd JL	147
1fe983dc JL	148	/* addi sign_extend(imm16), reg, reg
	149
	150	XXX condition codes. */
22c1c7dd	151	void
1fe983dc	152	OP_600 ()
22c1c7dd	153	{
1fe983dc JL	154	int value = OP[0];
	155
	156	value = (value << 16) >> 16;
	157
	158	State.regs[OP[2]] = State.regs[OP[1]] + value;
22c1c7dd JL	159	}
22c1c7dd JL	160
1fe983dc JL	161	/* sub reg1, reg2
	162
	163	XXX condition codes */
22c1c7dd	164	void
1fe983dc	165	OP_1A0 ()
22c1c7dd	166	{
1fe983dc	167	State.regs[OP[1]] -= State.regs[OP[0]];
22c1c7dd JL	168	}
22c1c7dd JL	169
1fe983dc JL	170	/* subr reg1, reg2
	171
	172	XXX condition codes */
22c1c7dd	173	void
1fe983dc	174	OP_180 ()
22c1c7dd	175	{
1fe983dc	176	State.regs[OP[1]] = State.regs[OP[0]] - State.regs[OP[1]];
22c1c7dd JL	177	}
22c1c7dd JL	178
e98e3b2c JL	179	/* mulh reg1, reg2
	180
	181	XXX condition codes */
22c1c7dd	182	void
e98e3b2c	183	OP_E0 ()
22c1c7dd	184	{
e98e3b2c	185	State.regs[OP[1]] = ((State.regs[OP[1]] & 0xffff)
fb8eb42b	186	* (State.regs[OP[0]] & 0xffff));
22c1c7dd JL	187	}
22c1c7dd JL	188
e98e3b2c JL	189	/* mulh sign_extend(imm5), reg2
	190
	191	Condition codes */
22c1c7dd	192	void
e98e3b2c	193	OP_2E0 ()
22c1c7dd	194	{
e98e3b2c JL	195	int value = OP[0];
	196
	197	value = (value << 27) >> 27;
	198
	199	State.regs[OP[1]] = (State.regs[OP[1]] & 0xffff) * value;
22c1c7dd JL	200	}
22c1c7dd JL	201
e98e3b2c JL	202	/* mulhi imm16, reg1, reg2
	203
	204	XXX condition codes */
22c1c7dd	205	void
e98e3b2c JL	206	OP_6E0 ()
	207	{
	208	int value = OP[0];
	209
	210	value = value & 0xffff;
	211
fb8eb42b	212	State.regs[OP[2]] = (State.regs[OP[1]] & 0xffff) * value;
e98e3b2c JL	213	}
	214
	215	/* divh reg1, reg2
	216
	217	XXX condition codes.
	218	XXX Is this signed or unsigned? */
	219	void
	220	OP_40 ()
22c1c7dd	221	{
fb8eb42b	222	State.regs[OP[1]] /= (State.regs[OP[0]] & 0xffff);
22c1c7dd JL	223	}
22c1c7dd JL	224
22c1c7dd	225	void
1fe983dc	226	OP_10720 ()
22c1c7dd JL	227	{
	228	}
	229
	230	void
1fe983dc	231	OP_780 ()
22c1c7dd JL	232	{
	233	}
	234
	235	void
	236	OP_720 ()
	237	{
	238	}
	239
	240	void
	241	OP_60 ()
	242	{
	243	}
	244
22c1c7dd JL	245	void
	246	OP_87C0 ()
	247	{
	248	}
	249
22c1c7dd JL	250	void
	251	OP_300 ()
	252	{
	253	}
	254
1fe983dc	255	/* mov reg, reg */
22c1c7dd JL	256	void
	257	OP_0 ()
	258	{
1fe983dc	259	State.regs[OP[1]] = State.regs[OP[0]];
22c1c7dd JL	260	}
22c1c7dd JL	261
1fe983dc	262	/* mov sign_extend(imm5), reg */
22c1c7dd	263	void
1fe983dc	264	OP_200 ()
22c1c7dd	265	{
1fe983dc JL	266	int value = OP[0];
	267
	268	value = (value << 27) >> 27;
	269	State.regs[OP[1]] = value;
22c1c7dd JL	270	}
22c1c7dd JL	271
1fe983dc JL	272	/* movea sign_extend(imm16), reg, reg */
1fe983dc JL	273
22c1c7dd	274	void
1fe983dc	275	OP_620 ()
22c1c7dd	276	{
1fe983dc JL	277	int value = OP[0];
	278
	279	value = (value << 16) >> 16;
	280
	281	State.regs[OP[2]] = State.regs[OP[1]] + value;
22c1c7dd JL	282	}
22c1c7dd JL	283
1fe983dc	284	/* movhi imm16, reg, reg */
22c1c7dd	285	void
1fe983dc	286	OP_640 ()
22c1c7dd	287	{
1fe983dc JL	288	int value = OP[0];
	289
	290	value = (value & 0xffff) << 16;
	291
	292	State.regs[OP[2]] = State.regs[OP[1]] + value;
22c1c7dd JL	293	}
	294
	295	void
1fe983dc	296	OP_7C0 ()
22c1c7dd JL	297	{
	298	}
	299
	300	void
1fe983dc	301	OP_1687E0 ()
22c1c7dd JL	302	{
	303	}
	304
	305	void
	306	OP_1E0 ()
	307	{
	308	}
	309
	310	void
	311	OP_A0 ()
	312	{
	313	}
	314
	315	void
	316	OP_260 ()
	317	{
	318	}
	319
22c1c7dd JL	320	void
	321	OP_740 ()
	322	{
	323	}
	324
	325	void
	326	OP_80 ()
	327	{
	328	}
	329
1fe983dc JL	330	/* not reg1, reg2
	331
	332	XXX condition codes */
22c1c7dd JL	333	void
	334	OP_20 ()
	335	{
1fe983dc	336	State.regs[OP[1]] = ~State.regs[OP[0]];
22c1c7dd JL	337	}
22c1c7dd JL	338
77553374 JL	339	/* sar zero_extend(imm5),reg1
	340
	341	XXX condition codes. */
22c1c7dd	342	void
77553374	343	OP_2A0 ()
22c1c7dd	344	{
77553374 JL	345	int temp = State.regs[OP[1]];
	346
	347	temp >>= (OP[0] & 0x1f);
	348
	349	State.regs[OP[1]] = temp;
22c1c7dd JL	350	}
22c1c7dd JL	351
77553374 JL	352	/* sar reg1, reg2
	353
	354	XXX condition codes. */
22c1c7dd	355	void
77553374	356	OP_A007E0 ()
22c1c7dd	357	{
77553374 JL	358	int temp = State.regs[OP[1]];
	359
	360	temp >>= (State.regs[OP[0]] & 0x1f);
	361
	362	State.regs[OP[1]] = temp;
22c1c7dd JL	363	}
22c1c7dd JL	364
77553374 JL	365	/* shl zero_extend(imm5),reg1
	366
	367	XXX condition codes. */
22c1c7dd JL	368	void
22c1c7dd JL	369	OP_2C0 ()
77553374 JL	370	{
	371	State.regs[OP[1]] <<= (OP[0] & 0x1f);
	372	}
	373
	374	/* shl reg1, reg2
	375
	376	XXX condition codes. */
	377	void
	378	OP_C007E0 ()
	379	{
	380	State.regs[OP[1]] <<= (State.regs[OP[0]] & 0x1f);
	381	}
	382
	383	/* shr zero_extend(imm5),reg1
	384
	385	XXX condition codes. */
	386	void
	387	OP_280 ()
	388	{
	389	State.regs[OP[1]] >>= (OP[0] & 0x1f);
	390	}
	391
	392	/* shr reg1, reg2
	393
	394	XXX condition codes. */
	395	void
	396	OP_8007E0 ()
	397	{
	398	State.regs[OP[1]] >>= (State.regs[OP[0]] & 0x1f);
	399	}
	400
	401	void
	402	OP_500 ()
22c1c7dd JL	403	{
	404	}
	405
22c1c7dd JL	406	void
	407	OP_47C0 ()
	408	{
	409	}
	410
22c1c7dd JL	411	void
	412	OP_7E0 ()
	413	{
	414	}
	415
1fe983dc JL	416	/* or reg, reg
	417
	418	XXX condition codes. */
	419	void
	420	OP_100 ()
	421	{
	422	State.regs[OP[1]] \|= State.regs[OP[0]];
	423	}
	424
	425	/* ori zero_extend(imm16), reg, reg
	426
	427	XXX condition codes */
	428	void
	429	OP_680 ()
	430	{
	431	int value = OP[0];
	432
	433	value &= 0xffff;
	434
	435	State.regs[OP[2]] = State.regs[OP[1]] \| value;
	436	}
	437
	438	/* and reg, reg
	439
	440	XXX condition codes. */
22c1c7dd JL	441	void
	442	OP_140 ()
	443	{
1fe983dc	444	State.regs[OP[1]] &= State.regs[OP[0]];
22c1c7dd JL	445	}
22c1c7dd JL	446
1fe983dc JL	447	/* andi zero_extend(imm16), reg, reg
	448
	449	XXX condition codes. */
22c1c7dd	450	void
1fe983dc JL	451	OP_6C0 ()
	452	{
	453	int value = OP[0];
	454
	455	value &= 0xffff;
	456
	457	State.regs[OP[2]] = State.regs[OP[1]] & value;
	458	}
	459
	460	/* xor reg, reg
	461
	462	XXX condition codes. */
	463	void
	464	OP_120 ()
22c1c7dd	465	{
1fe983dc JL	466	State.regs[OP[1]] ^= State.regs[OP[0]];
	467	}
	468
	469	/* xori zero_extend(imm16), reg, reg
	470
	471	XXX condition codes. */
	472	void
	473	OP_6A0 ()
	474	{
	475	int value = OP[0];
	476
	477	value &= 0xffff;
	478
	479	State.regs[OP[2]] = State.regs[OP[1]] ^ value;
22c1c7dd JL	480	}
	481
	482	void
	483	OP_C0 ()
	484	{
	485	}
	486
1fe983dc JL	487	void
	488	OP_480 ()
	489	{
	490	}
	491
	492	void
	493	OP_380 ()
	494	{
	495	}
	496
	497	void
	498	OP_501 ()
	499	{
	500	}
e98e3b2c JL	501
	502	/* di, not supported */
	503	void
	504	OP_16007E0 ()
	505	{
	506	abort ();
	507	}
	508
	509	/* ei, not supported */
	510	void
	511	OP_16087E0 ()
	512	{
	513	abort ();
	514	}
	515
	516	/* halt, not supported */
	517	void
	518	OP_12007E0 ()
	519	{
	520	abort ();
	521	}
	522
	523	/* reti, not supported */
	524	void
	525	OP_14007E0 ()
	526	{
	527	abort ();
	528	}
	529
	530	/* trap, not supportd */
	531	void
	532	OP_10007E0 ()
	533	{
	534	abort ();
	535	}
	536
	537	/* ldsr, not supported */
	538	void
	539	OP_2007E0 ()
	540	{
	541	abort ();
	542	}
	543
	544	/* stsr, not supported */
	545	void
	546	OP_4007E0 ()
	547	{
	548	abort ();
	549	}
	550