Blame - lib/Target/CellSPU/SPUInstrInfo.td - fp2-dev/platform/external/llvm

blob: 792041ea376d5cbb5b527263bafef8a7fe90c383 [file] [log] [blame]

Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1	//==- SPUInstrInfo.td - Describe the Cell SPU Instructions -- tablegen --==//
				2	//
				3	// The LLVM Compiler Infrastructure
				4	//
Scott Michel	43e7c5e	2007-12-05 01:40:25 +0000	[diff] [blame]	5	// This file was developed by a team from the Computer Systems Research
				6	// Department at The Aerospace Corporation and is distributed under the
				7	// University of Illinois Open Source License. See LICENSE.TXT for details.
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	8	//
				9	//===----------------------------------------------------------------------===//
				10	// Cell SPU Instructions:
				11	//===----------------------------------------------------------------------===//
				12
				13	//===----------------------------------------------------------------------===//
				14	// TODO Items (not urgent today, but would be nice, low priority)
				15	//
				16	// ANDBI, ORBI: SPU constructs a 4-byte constant for these instructions by
				17	// concatenating the byte argument b as "bbbb". Could recognize this bit pattern
				18	// in 16-bit and 32-bit constants and reduce instruction count.
				19	//===----------------------------------------------------------------------===//
				20
				21	//===----------------------------------------------------------------------===//
				22	// Pseudo instructions:
				23	//===----------------------------------------------------------------------===//
				24
				25	let hasCtrlDep = 1, Defs = [R1], Uses = [R1] in {
				26	def ADJCALLSTACKDOWN : Pseudo<(outs), (ins u16imm:$amt),
				27	"${:comment} ADJCALLSTACKDOWN",
				28	[(callseq_start imm:$amt)]>;
				29	def ADJCALLSTACKUP : Pseudo<(outs), (ins u16imm:$amt),
				30	"${:comment} ADJCALLSTACKUP",
				31	[(callseq_end imm:$amt)]>;
				32	}
				33
				34	//===----------------------------------------------------------------------===//
				35	// DWARF debugging Pseudo Instructions
				36	//===----------------------------------------------------------------------===//
				37
				38	def DWARF_LOC : Pseudo<(outs), (ins i32imm:$line, i32imm:$col, i32imm:$file),
				39	"${:comment} .loc $file, $line, $col",
				40	[(dwarf_loc (i32 imm:$line), (i32 imm:$col),
				41	(i32 imm:$file))]>;
				42
				43	//===----------------------------------------------------------------------===//
				44	// Loads:
				45	// NB: The ordering is actually important, since the instruction selection
				46	// will try each of the instructions in sequence, i.e., the D-form first with
				47	// the 10-bit displacement, then the A-form with the 16 bit displacement, and
				48	// finally the X-form with the register-register.
				49	//===----------------------------------------------------------------------===//
				50
				51	let isLoad = 1 in {
				52	def LQDv16i8:
				53	RI10Form<0b00101100, (outs VECREG:$rT), (ins memri10:$src),
				54	"lqd\t$rT, $src", LoadStore,
				55	[(set (v16i8 VECREG:$rT), (load dform_addr:$src))]>;
				56
				57	def LQDv8i16:
				58	RI10Form<0b00101100, (outs VECREG:$rT), (ins memri10:$src),
				59	"lqd\t$rT, $src", LoadStore,
				60	[(set (v8i16 VECREG:$rT), (load dform_addr:$src))]>;
				61
				62	def LQDv4i32:
				63	RI10Form<0b00101100, (outs VECREG:$rT), (ins memri10:$src),
				64	"lqd\t$rT, $src", LoadStore,
				65	[(set (v4i32 VECREG:$rT), (load dform_addr:$src))]>;
				66
				67	def LQDv2i64:
				68	RI10Form<0b00101100, (outs VECREG:$rT), (ins memri10:$src),
				69	"lqd\t$rT, $src", LoadStore,
				70	[(set (v2i64 VECREG:$rT), (load dform_addr:$src))]>;
				71
				72	def LQDv4f32:
				73	RI10Form<0b00101100, (outs VECREG:$rT), (ins memri10:$src),
				74	"lqd\t$rT, $src", LoadStore,
				75	[(set (v4f32 VECREG:$rT), (load dform_addr:$src))]>;
				76
				77	def LQDv2f64:
				78	RI10Form<0b00101100, (outs VECREG:$rT), (ins memri10:$src),
				79	"lqd\t$rT, $src", LoadStore,
				80	[(set (v2f64 VECREG:$rT), (load dform_addr:$src))]>;
				81
				82	def LQDr128:
				83	RI10Form<0b00101100, (outs GPRC:$rT), (ins memri10:$src),
				84	"lqd\t$rT, $src", LoadStore,
				85	[(set GPRC:$rT, (load dform_addr:$src))]>;
				86
				87	def LQDr64:
				88	RI10Form<0b00101100, (outs R64C:$rT), (ins memri10:$src),
				89	"lqd\t$rT, $src", LoadStore,
				90	[(set R64C:$rT, (load dform_addr:$src))]>;
				91
				92	def LQDr32:
				93	RI10Form<0b00101100, (outs R32C:$rT), (ins memri10:$src),
				94	"lqd\t$rT, $src", LoadStore,
				95	[(set R32C:$rT, (load dform_addr:$src))]>;
				96
				97	// Floating Point
				98	def LQDf32:
				99	RI10Form<0b00101100, (outs R32FP:$rT), (ins memri10:$src),
				100	"lqd\t$rT, $src", LoadStore,
				101	[(set R32FP:$rT, (load dform_addr:$src))]>;
				102
				103	def LQDf64:
				104	RI10Form<0b00101100, (outs R64FP:$rT), (ins memri10:$src),
				105	"lqd\t$rT, $src", LoadStore,
				106	[(set R64FP:$rT, (load dform_addr:$src))]>;
				107	// END Floating Point
				108
				109	def LQDr16:
				110	RI10Form<0b00101100, (outs R16C:$rT), (ins memri10:$src),
				111	"lqd\t$rT, $src", LoadStore,
				112	[(set R16C:$rT, (load dform_addr:$src))]>;
				113
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	114	def LQDr8:
				115	RI10Form<0b00101100, (outs R8C:$rT), (ins memri10:$src),
				116	"lqd\t$rT, $src", LoadStore,
				117	[(set R8C:$rT, (load dform_addr:$src))]>;
				118
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	119	def LQAv16i8:
				120	RI16Form<0b100001100, (outs VECREG:$rT), (ins addr256k:$src),
				121	"lqa\t$rT, $src", LoadStore,
				122	[(set (v16i8 VECREG:$rT), (load aform_addr:$src))]>;
				123
				124	def LQAv8i16:
				125	RI16Form<0b100001100, (outs VECREG:$rT), (ins addr256k:$src),
				126	"lqa\t$rT, $src", LoadStore,
				127	[(set (v8i16 VECREG:$rT), (load aform_addr:$src))]>;
				128
				129	def LQAv4i32:
				130	RI16Form<0b100001100, (outs VECREG:$rT), (ins addr256k:$src),
				131	"lqa\t$rT, $src", LoadStore,
				132	[(set (v4i32 VECREG:$rT), (load aform_addr:$src))]>;
				133
				134	def LQAv2i64:
				135	RI16Form<0b100001100, (outs VECREG:$rT), (ins addr256k:$src),
				136	"lqa\t$rT, $src", LoadStore,
				137	[(set (v2i64 VECREG:$rT), (load aform_addr:$src))]>;
				138
				139	def LQAv4f32:
				140	RI16Form<0b100001100, (outs VECREG:$rT), (ins addr256k:$src),
				141	"lqa\t$rT, $src", LoadStore,
				142	[(set (v4f32 VECREG:$rT), (load aform_addr:$src))]>;
				143
				144	def LQAv2f64:
				145	RI16Form<0b100001100, (outs VECREG:$rT), (ins addr256k:$src),
				146	"lqa\t$rT, $src", LoadStore,
				147	[(set (v2f64 VECREG:$rT), (load aform_addr:$src))]>;
				148
				149	def LQAr128:
				150	RI16Form<0b100001100, (outs GPRC:$rT), (ins addr256k:$src),
				151	"lqa\t$rT, $src", LoadStore,
				152	[(set GPRC:$rT, (load aform_addr:$src))]>;
				153
				154	def LQAr64:
				155	RI16Form<0b100001100, (outs R64C:$rT), (ins addr256k:$src),
				156	"lqa\t$rT, $src", LoadStore,
				157	[(set R64C:$rT, (load aform_addr:$src))]>;
				158
				159	def LQAr32:
				160	RI16Form<0b100001100, (outs R32C:$rT), (ins addr256k:$src),
				161	"lqa\t$rT, $src", LoadStore,
				162	[(set R32C:$rT, (load aform_addr:$src))]>;
				163
				164	def LQAf32:
				165	RI16Form<0b100001100, (outs R32FP:$rT), (ins addr256k:$src),
				166	"lqa\t$rT, $src", LoadStore,
				167	[(set R32FP:$rT, (load aform_addr:$src))]>;
				168
				169	def LQAf64:
				170	RI16Form<0b100001100, (outs R64FP:$rT), (ins addr256k:$src),
				171	"lqa\t$rT, $src", LoadStore,
				172	[(set R64FP:$rT, (load aform_addr:$src))]>;
				173
				174	def LQAr16:
				175	RI16Form<0b100001100, (outs R16C:$rT), (ins addr256k:$src),
				176	"lqa\t$rT, $src", LoadStore,
				177	[(set R16C:$rT, (load aform_addr:$src))]>;
				178
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	179	def LQAr8:
				180	RI16Form<0b100001100, (outs R8C:$rT), (ins addr256k:$src),
				181	"lqa\t$rT, $src", LoadStore,
				182	[(set R8C:$rT, (load aform_addr:$src))]>;
				183
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	184	def LQXv16i8:
				185	RRForm<0b00100011100, (outs VECREG:$rT), (ins memrr:$src),
				186	"lqx\t$rT, $src", LoadStore,
				187	[(set (v16i8 VECREG:$rT), (load xform_addr:$src))]>;
				188
				189	def LQXv8i16:
				190	RRForm<0b00100011100, (outs VECREG:$rT), (ins memrr:$src),
				191	"lqx\t$rT, $src", LoadStore,
				192	[(set (v8i16 VECREG:$rT), (load xform_addr:$src))]>;
				193
				194	def LQXv4i32:
				195	RRForm<0b00100011100, (outs VECREG:$rT), (ins memrr:$src),
				196	"lqx\t$rT, $src", LoadStore,
				197	[(set (v4i32 VECREG:$rT), (load xform_addr:$src))]>;
				198
				199	def LQXv2i64:
				200	RRForm<0b00100011100, (outs VECREG:$rT), (ins memrr:$src),
				201	"lqx\t$rT, $src", LoadStore,
				202	[(set (v2i64 VECREG:$rT), (load xform_addr:$src))]>;
				203
				204	def LQXv4f32:
				205	RRForm<0b00100011100, (outs VECREG:$rT), (ins memrr:$src),
				206	"lqx\t$rT, $src", LoadStore,
				207	[(set (v4f32 VECREG:$rT), (load xform_addr:$src))]>;
				208
				209	def LQXv2f64:
				210	RRForm<0b00100011100, (outs VECREG:$rT), (ins memrr:$src),
				211	"lqx\t$rT, $src", LoadStore,
				212	[(set (v2f64 VECREG:$rT), (load xform_addr:$src))]>;
				213
				214	def LQXr128:
				215	RRForm<0b00100011100, (outs GPRC:$rT), (ins memrr:$src),
				216	"lqx\t$rT, $src", LoadStore,
				217	[(set GPRC:$rT, (load xform_addr:$src))]>;
				218
				219	def LQXr64:
				220	RRForm<0b00100011100, (outs R64C:$rT), (ins memrr:$src),
				221	"lqx\t$rT, $src", LoadStore,
				222	[(set R64C:$rT, (load xform_addr:$src))]>;
				223
				224	def LQXr32:
				225	RRForm<0b00100011100, (outs R32C:$rT), (ins memrr:$src),
				226	"lqx\t$rT, $src", LoadStore,
				227	[(set R32C:$rT, (load xform_addr:$src))]>;
				228
				229	def LQXf32:
				230	RRForm<0b00100011100, (outs R32FP:$rT), (ins memrr:$src),
				231	"lqx\t$rT, $src", LoadStore,
				232	[(set R32FP:$rT, (load xform_addr:$src))]>;
				233
				234	def LQXf64:
				235	RRForm<0b00100011100, (outs R64FP:$rT), (ins memrr:$src),
				236	"lqx\t$rT, $src", LoadStore,
				237	[(set R64FP:$rT, (load xform_addr:$src))]>;
				238
				239	def LQXr16:
				240	RRForm<0b00100011100, (outs R16C:$rT), (ins memrr:$src),
				241	"lqx\t$rT, $src", LoadStore,
				242	[(set R16C:$rT, (load xform_addr:$src))]>;
				243
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	244	def LQXr8:
				245	RRForm<0b00100011100, (outs R8C:$rT), (ins memrr:$src),
				246	"lqx\t$rT, $src", LoadStore,
				247	[(set R8C:$rT, (load xform_addr:$src))]>;
				248
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	249	/* Load quadword, PC relative: Not much use at this point in time.
				250	Might be of use later for relocatable code.
				251	def LQR : RI16Form<0b111001100, (outs VECREG:$rT), (ins s16imm:$disp),
				252	"lqr\t$rT, $disp", LoadStore,
				253	[(set VECREG:$rT, (load iaddr:$disp))]>;
				254	*/
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	255	}
				256
				257	//===----------------------------------------------------------------------===//
				258	// Stores:
				259	//===----------------------------------------------------------------------===//
				260
				261	let isStore = 1 in {
				262	def STQDv16i8 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memri10:$src),
				263	"stqd\t$rT, $src", LoadStore,
				264	[(store (v16i8 VECREG:$rT), dform_addr:$src)]>;
				265
				266	def STQDv8i16 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memri10:$src),
				267	"stqd\t$rT, $src", LoadStore,
				268	[(store (v8i16 VECREG:$rT), dform_addr:$src)]>;
				269
				270	def STQDv4i32 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memri10:$src),
				271	"stqd\t$rT, $src", LoadStore,
				272	[(store (v4i32 VECREG:$rT), dform_addr:$src)]>;
				273
				274	def STQDv2i64 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memri10:$src),
				275	"stqd\t$rT, $src", LoadStore,
				276	[(store (v2i64 VECREG:$rT), dform_addr:$src)]>;
				277
				278	def STQDv4f32 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memri10:$src),
				279	"stqd\t$rT, $src", LoadStore,
				280	[(store (v4f32 VECREG:$rT), dform_addr:$src)]>;
				281
				282	def STQDv2f64 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memri10:$src),
				283	"stqd\t$rT, $src", LoadStore,
				284	[(store (v2f64 VECREG:$rT), dform_addr:$src)]>;
				285
				286	def STQDr128 : RI10Form<0b00100100, (outs), (ins GPRC:$rT, memri10:$src),
				287	"stqd\t$rT, $src", LoadStore,
				288	[(store GPRC:$rT, dform_addr:$src)]>;
				289
				290	def STQDr64 : RI10Form<0b00100100, (outs), (ins R64C:$rT, memri10:$src),
				291	"stqd\t$rT, $src", LoadStore,
				292	[(store R64C:$rT, dform_addr:$src)]>;
				293
				294	def STQDr32 : RI10Form<0b00100100, (outs), (ins R32C:$rT, memri10:$src),
				295	"stqd\t$rT, $src", LoadStore,
				296	[(store R32C:$rT, dform_addr:$src)]>;
				297
				298	// Floating Point
				299	def STQDf32 : RI10Form<0b00100100, (outs), (ins R32FP:$rT, memri10:$src),
				300	"stqd\t$rT, $src", LoadStore,
				301	[(store R32FP:$rT, dform_addr:$src)]>;
				302
				303	def STQDf64 : RI10Form<0b00100100, (outs), (ins R64FP:$rT, memri10:$src),
				304	"stqd\t$rT, $src", LoadStore,
				305	[(store R64FP:$rT, dform_addr:$src)]>;
				306
				307	def STQDr16 : RI10Form<0b00100100, (outs), (ins R16C:$rT, memri10:$src),
				308	"stqd\t$rT, $src", LoadStore,
				309	[(store R16C:$rT, dform_addr:$src)]>;
				310
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	311	def STQDr8 : RI10Form<0b00100100, (outs), (ins R8C:$rT, memri10:$src),
				312	"stqd\t$rT, $src", LoadStore,
				313	[(store R8C:$rT, dform_addr:$src)]>;
				314
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	315	def STQAv16i8 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, addr256k:$src),
				316	"stqa\t$rT, $src", LoadStore,
				317	[(store (v16i8 VECREG:$rT), aform_addr:$src)]>;
				318
				319	def STQAv8i16 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, addr256k:$src),
				320	"stqa\t$rT, $src", LoadStore,
				321	[(store (v8i16 VECREG:$rT), aform_addr:$src)]>;
				322
				323	def STQAv4i32 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, addr256k:$src),
				324	"stqa\t$rT, $src", LoadStore,
				325	[(store (v4i32 VECREG:$rT), aform_addr:$src)]>;
				326
				327	def STQAv2i64 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, addr256k:$src),
				328	"stqa\t$rT, $src", LoadStore,
				329	[(store (v2i64 VECREG:$rT), aform_addr:$src)]>;
				330
				331	def STQAv4f32 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, addr256k:$src),
				332	"stqa\t$rT, $src", LoadStore,
				333	[(store (v4f32 VECREG:$rT), aform_addr:$src)]>;
				334
				335	def STQAv2f64 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, addr256k:$src),
				336	"stqa\t$rT, $src", LoadStore,
				337	[(store (v2f64 VECREG:$rT), aform_addr:$src)]>;
				338
				339	def STQAr128 : RI10Form<0b00100100, (outs), (ins GPRC:$rT, addr256k:$src),
				340	"stqa\t$rT, $src", LoadStore,
				341	[(store GPRC:$rT, aform_addr:$src)]>;
				342
				343	def STQAr64 : RI10Form<0b00100100, (outs), (ins R64C:$rT, addr256k:$src),
				344	"stqa\t$rT, $src", LoadStore,
				345	[(store R64C:$rT, aform_addr:$src)]>;
				346
				347	def STQAr32 : RI10Form<0b00100100, (outs), (ins R32C:$rT, addr256k:$src),
				348	"stqa\t$rT, $src", LoadStore,
				349	[(store R32C:$rT, aform_addr:$src)]>;
				350
				351	// Floating Point
				352	def STQAf32 : RI10Form<0b00100100, (outs), (ins R32FP:$rT, addr256k:$src),
				353	"stqa\t$rT, $src", LoadStore,
				354	[(store R32FP:$rT, aform_addr:$src)]>;
				355
				356	def STQAf64 : RI10Form<0b00100100, (outs), (ins R64FP:$rT, addr256k:$src),
				357	"stqa\t$rT, $src", LoadStore,
				358	[(store R64FP:$rT, aform_addr:$src)]>;
				359
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	360	def STQAr16 : RI10Form<0b00100100, (outs), (ins R16C:$rT, addr256k:$src),
				361	"stqa\t$rT, $src", LoadStore,
				362	[(store R16C:$rT, aform_addr:$src)]>;
				363
				364	def STQAr8 : RI10Form<0b00100100, (outs), (ins R8C:$rT, addr256k:$src),
				365	"stqa\t$rT, $src", LoadStore,
				366	[(store R8C:$rT, aform_addr:$src)]>;
				367
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	368	def STQXv16i8 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memrr:$src),
				369	"stqx\t$rT, $src", LoadStore,
				370	[(store (v16i8 VECREG:$rT), xform_addr:$src)]>;
				371
				372	def STQXv8i16 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memrr:$src),
				373	"stqx\t$rT, $src", LoadStore,
				374	[(store (v8i16 VECREG:$rT), xform_addr:$src)]>;
				375
				376	def STQXv4i32 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memrr:$src),
				377	"stqx\t$rT, $src", LoadStore,
				378	[(store (v4i32 VECREG:$rT), xform_addr:$src)]>;
				379
				380	def STQXv2i64 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memrr:$src),
				381	"stqx\t$rT, $src", LoadStore,
				382	[(store (v2i64 VECREG:$rT), xform_addr:$src)]>;
				383
				384	def STQXv4f32 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memrr:$src),
				385	"stqx\t$rT, $src", LoadStore,
				386	[(store (v4f32 VECREG:$rT), xform_addr:$src)]>;
				387
				388	def STQXv2f64 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memrr:$src),
				389	"stqx\t$rT, $src", LoadStore,
				390	[(store (v2f64 VECREG:$rT), xform_addr:$src)]>;
				391
				392	def STQXr128 : RI10Form<0b00100100, (outs), (ins GPRC:$rT, memrr:$src),
				393	"stqx\t$rT, $src", LoadStore,
				394	[(store GPRC:$rT, xform_addr:$src)]>;
				395
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	396	def STQXr64:
				397	RI10Form<0b00100100, (outs), (ins R64C:$rT, memrr:$src),
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	398	"stqx\t$rT, $src", LoadStore,
				399	[(store R64C:$rT, xform_addr:$src)]>;
				400
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	401	def STQXr32:
				402	RI10Form<0b00100100, (outs), (ins R32C:$rT, memrr:$src),
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	403	"stqx\t$rT, $src", LoadStore,
				404	[(store R32C:$rT, xform_addr:$src)]>;
				405
				406	// Floating Point
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	407	def STQXf32:
				408	RI10Form<0b00100100, (outs), (ins R32FP:$rT, memrr:$src),
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	409	"stqx\t$rT, $src", LoadStore,
				410	[(store R32FP:$rT, xform_addr:$src)]>;
				411
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	412	def STQXf64:
				413	RI10Form<0b00100100, (outs), (ins R64FP:$rT, memrr:$src),
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	414	"stqx\t$rT, $src", LoadStore,
				415	[(store R64FP:$rT, xform_addr:$src)]>;
				416
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	417	def STQXr16:
				418	RI10Form<0b00100100, (outs), (ins R16C:$rT, memrr:$src),
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	419	"stqx\t$rT, $src", LoadStore,
				420	[(store R16C:$rT, xform_addr:$src)]>;
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	421
				422	def STQXr8:
				423	RI10Form<0b00100100, (outs), (ins R8C:$rT, memrr:$src),
				424	"stqx\t$rT, $src", LoadStore,
				425	[(store R8C:$rT, xform_addr:$src)]>;
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	426
				427	/* Store quadword, PC relative: Not much use at this point in time. Might
				428	be useful for relocatable code.
				429	def STQR : RI16Form<0b111000100, (outs), (ins VECREG:$rT, s16imm:$disp),
				430	"stqr\t$rT, $disp", LoadStore,
				431	[(store VECREG:$rT, iaddr:$disp)]>;
				432	*/
				433	}
				434
				435	//===----------------------------------------------------------------------===//
				436	// Generate Controls for Insertion:
				437	//===----------------------------------------------------------------------===//
				438
				439	def CBD :
				440	RI7Form<0b10101111100, (outs VECREG:$rT), (ins memri7:$src),
				441	"cbd\t$rT, $src", ShuffleOp,
				442	[(set (v16i8 VECREG:$rT), (SPUvecinsmask dform2_addr:$src))]>;
				443
				444	def CBX : RRForm<0b00101011100, (outs VECREG:$rT), (ins memrr:$src),
				445	"cbx\t$rT, $src", ShuffleOp,
				446	[(set (v16i8 VECREG:$rT), (SPUvecinsmask xform_addr:$src))]>;
				447
				448	def CHD : RI7Form<0b10101111100, (outs VECREG:$rT), (ins memri7:$src),
				449	"chd\t$rT, $src", ShuffleOp,
				450	[(set (v8i16 VECREG:$rT), (SPUvecinsmask dform2_addr:$src))]>;
				451
				452	def CHX : RRForm<0b10101011100, (outs VECREG:$rT), (ins memrr:$src),
				453	"chx\t$rT, $src", ShuffleOp,
				454	[(set (v8i16 VECREG:$rT), (SPUvecinsmask xform_addr:$src))]>;
				455
				456	def CWD : RI7Form<0b01101111100, (outs VECREG:$rT), (ins memri7:$src),
				457	"cwd\t$rT, $src", ShuffleOp,
				458	[(set (v4i32 VECREG:$rT), (SPUvecinsmask dform2_addr:$src))]>;
				459
				460	def CWX : RRForm<0b01101011100, (outs VECREG:$rT), (ins memrr:$src),
				461	"cwx\t$rT, $src", ShuffleOp,
				462	[(set (v4i32 VECREG:$rT), (SPUvecinsmask xform_addr:$src))]>;
				463
				464	def CDD : RI7Form<0b11101111100, (outs VECREG:$rT), (ins memri7:$src),
				465	"cdd\t$rT, $src", ShuffleOp,
				466	[(set (v2i64 VECREG:$rT), (SPUvecinsmask dform2_addr:$src))]>;
				467
				468	def CDX : RRForm<0b11101011100, (outs VECREG:$rT), (ins memrr:$src),
				469	"cdx\t$rT, $src", ShuffleOp,
				470	[(set (v2i64 VECREG:$rT), (SPUvecinsmask xform_addr:$src))]>;
				471
				472	//===----------------------------------------------------------------------===//
				473	// Constant formation:
				474	//===----------------------------------------------------------------------===//
				475
				476	def ILHv8i16:
				477	RI16Form<0b110000010, (outs VECREG:$rT), (ins s16imm:$val),
				478	"ilh\t$rT, $val", ImmLoad,
				479	[(set (v8i16 VECREG:$rT), (v8i16 v8i16SExt16Imm:$val))]>;
				480
				481	def ILHr16:
				482	RI16Form<0b110000010, (outs R16C:$rT), (ins s16imm:$val),
				483	"ilh\t$rT, $val", ImmLoad,
				484	[(set R16C:$rT, immSExt16:$val)]>;
				485
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	486	// Cell SPU doesn't have a native 8-bit immediate load, but ILH works ("with
				487	// the right constant")
				488	def ILHr8:
				489	RI16Form<0b110000010, (outs R8C:$rT), (ins s16imm_i8:$val),
				490	"ilh\t$rT, $val", ImmLoad,
				491	[(set R8C:$rT, immSExt8:$val)]>;
				492
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	493	// IL does sign extension!
				494	def ILr64:
				495	RI16Form<0b100000010, (outs R64C:$rT), (ins s16imm_i64:$val),
				496	"il\t$rT, $val", ImmLoad,
				497	[(set R64C:$rT, immSExt16:$val)]>;
				498
				499	def ILv2i64:
				500	RI16Form<0b100000010, (outs VECREG:$rT), (ins s16imm_i64:$val),
				501	"il\t$rT, $val", ImmLoad,
				502	[(set VECREG:$rT, (v2i64 v2i64SExt16Imm:$val))]>;
				503
				504	def ILv4i32:
				505	RI16Form<0b100000010, (outs VECREG:$rT), (ins s16imm:$val),
				506	"il\t$rT, $val", ImmLoad,
				507	[(set VECREG:$rT, (v4i32 v4i32SExt16Imm:$val))]>;
				508
				509	def ILr32:
				510	RI16Form<0b100000010, (outs R32C:$rT), (ins s16imm_i32:$val),
				511	"il\t$rT, $val", ImmLoad,
				512	[(set R32C:$rT, immSExt16:$val)]>;
				513
				514	def ILf32:
				515	RI16Form<0b100000010, (outs R32FP:$rT), (ins s16imm_f32:$val),
				516	"il\t$rT, $val", ImmLoad,
				517	[(set R32FP:$rT, (SPUFPconstant fpimmSExt16:$val))]>;
				518
				519	def ILf64:
				520	RI16Form<0b100000010, (outs R64FP:$rT), (ins s16imm_f64:$val),
				521	"il\t$rT, $val", ImmLoad,
				522	[(set R64FP:$rT, (SPUFPconstant fpimmSExt16:$val))]>;
				523
				524	def ILHUv4i32:
				525	RI16Form<0b010000010, (outs VECREG:$rT), (ins u16imm:$val),
				526	"ilhu\t$rT, $val", ImmLoad,
				527	[(set VECREG:$rT, (v4i32 immILHUvec:$val))]>;
				528
				529	def ILHUr32:
				530	RI16Form<0b010000010, (outs R32C:$rT), (ins u16imm:$val),
				531	"ilhu\t$rT, $val", ImmLoad,
				532	[(set R32C:$rT, hi16:$val)]>;
				533
				534	// ILHUf32: Used to custom lower float constant loads
				535	def ILHUf32:
				536	RI16Form<0b010000010, (outs R32FP:$rT), (ins f16imm:$val),
				537	"ilhu\t$rT, $val", ImmLoad,
				538	[(set R32FP:$rT, (SPUFPconstant hi16_f32:$val))]>;
				539
				540	// ILHUhi: Used for loading high portion of an address. Note the symbolHi
				541	// printer used for the operand.
				542	def ILHUhi : RI16Form<0b010000010, (outs R32C:$rT), (ins symbolHi:$val),
				543	"ilhu\t$rT, $val", ImmLoad,
				544	[(set R32C:$rT, hi16:$val)]>;
				545
				546	// Immediate load address (can also be used to load 18-bit unsigned constants,
				547	// see the zext 16->32 pattern)
				548	def ILAr64:
				549	RI18Form<0b1000010, (outs R64C:$rT), (ins u18imm_i64:$val),
				550	"ila\t$rT, $val", LoadNOP,
				551	[(set R64C:$rT, imm18:$val)]>;
				552
				553	// TODO: ILAv2i64
				554
				555	def ILAv2i64:
				556	RI18Form<0b1000010, (outs VECREG:$rT), (ins u18imm:$val),
				557	"ila\t$rT, $val", LoadNOP,
				558	[(set (v2i64 VECREG:$rT), v2i64Uns18Imm:$val)]>;
				559
				560	def ILAv4i32:
				561	RI18Form<0b1000010, (outs VECREG:$rT), (ins u18imm:$val),
				562	"ila\t$rT, $val", LoadNOP,
				563	[(set (v4i32 VECREG:$rT), v4i32Uns18Imm:$val)]>;
				564
				565	def ILAr32:
				566	RI18Form<0b1000010, (outs R32C:$rT), (ins u18imm:$val),
				567	"ila\t$rT, $val", LoadNOP,
				568	[(set R32C:$rT, imm18:$val)]>;
				569
				570	def ILAf32:
				571	RI18Form<0b1000010, (outs R32FP:$rT), (ins f18imm:$val),
				572	"ila\t$rT, $val", LoadNOP,
				573	[(set R32FP:$rT, (SPUFPconstant fpimm18:$val))]>;
				574
				575	def ILAf64:
				576	RI18Form<0b1000010, (outs R64FP:$rT), (ins f18imm_f64:$val),
				577	"ila\t$rT, $val", LoadNOP,
				578	[(set R64FP:$rT, (SPUFPconstant fpimm18:$val))]>;
				579
				580	def ILAlo:
				581	RI18Form<0b1000010, (outs R32C:$rT), (ins symbolLo:$val),
				582	"ila\t$rT, $val", ImmLoad,
				583	[(set R32C:$rT, imm18:$val)]>;
				584
				585	def ILAlsa:
				586	RI18Form<0b1000010, (outs R32C:$rT), (ins symbolLSA:$val),
				587	"ila\t$rT, $val", ImmLoad,
				588	[/* no pattern */]>;
				589
				590	// Immediate OR, Halfword Lower: The "other" part of loading large constants
				591	// into 32-bit registers. See the anonymous pattern Pat<(i32 imm:$imm), ...>
				592	// Note that these are really two operand instructions, but they're encoded
				593	// as three operands with the first two arguments tied-to each other.
				594
				595	def IOHLvec:
				596	RI16Form<0b100000110, (outs VECREG:$rT), (ins VECREG:$rS, u16imm:$val),
				597	"iohl\t$rT, $val", ImmLoad,
				598	[/* insert intrinsic here */]>,
				599	RegConstraint<"$rS = $rT">,
				600	NoEncode<"$rS">;
				601
				602	def IOHLr32:
				603	RI16Form<0b100000110, (outs R32C:$rT), (ins R32C:$rS, i32imm:$val),
				604	"iohl\t$rT, $val", ImmLoad,
				605	[/* insert intrinsic here */]>,
				606	RegConstraint<"$rS = $rT">,
				607	NoEncode<"$rS">;
				608
				609	def IOHLf32:
				610	RI16Form<0b100000110, (outs R32FP:$rT), (ins R32FP:$rS, f32imm:$val),
				611	"iohl\t$rT, $val", ImmLoad,
				612	[/* insert intrinsic here */]>,
				613	RegConstraint<"$rS = $rT">,
				614	NoEncode<"$rS">;
				615
				616	// Form select mask for bytes using immediate, used in conjunction with the
				617	// SELB instruction:
				618
				619	def FSMBIv16i8 : RI16Form<0b101001100, (outs VECREG:$rT), (ins u16imm:$val),
				620	"fsmbi\t$rT, $val", SelectOp,
				621	[(set (v16i8 VECREG:$rT), (SPUfsmbi_v16i8 immU16:$val))]>;
				622
				623	def FSMBIv8i16 : RI16Form<0b101001100, (outs VECREG:$rT), (ins u16imm:$val),
				624	"fsmbi\t$rT, $val", SelectOp,
				625	[(set (v8i16 VECREG:$rT), (SPUfsmbi_v8i16 immU16:$val))]>;
				626
				627	def FSMBIvecv4i32 : RI16Form<0b101001100, (outs VECREG:$rT), (ins u16imm:$val),
				628	"fsmbi\t$rT, $val", SelectOp,
				629	[(set (v4i32 VECREG:$rT), (SPUfsmbi_v4i32 immU16:$val))]>;
				630
				631	//===----------------------------------------------------------------------===//
				632	// Integer and Logical Operations:
				633	//===----------------------------------------------------------------------===//
				634
				635	def AHv8i16:
				636	RRForm<0b00010011000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				637	"ah\t$rT, $rA, $rB", IntegerOp,
				638	[(set (v8i16 VECREG:$rT), (int_spu_si_ah VECREG:$rA, VECREG:$rB))]>;
				639
				640	def : Pat<(add (v8i16 VECREG:$rA), (v8i16 VECREG:$rB)),
				641	(AHv8i16 VECREG:$rA, VECREG:$rB)>;
				642
				643	// [(set (v8i16 VECREG:$rT), (add (v8i16 VECREG:$rA), (v8i16 VECREG:$rB)))]>;
				644
				645	def AHr16:
				646	RRForm<0b00010011000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
				647	"ah\t$rT, $rA, $rB", IntegerOp,
				648	[(set R16C:$rT, (add R16C:$rA, R16C:$rB))]>;
				649
				650	def AHIvec:
				651	RI10Form<0b10111000, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
				652	"ahi\t$rT, $rA, $val", IntegerOp,
				653	[(set (v8i16 VECREG:$rT), (add (v8i16 VECREG:$rA),
				654	v8i16SExt10Imm:$val))]>;
				655
				656	def AHIr16 : RI10Form<0b10111000, (outs R16C:$rT), (ins R16C:$rA, s10imm:$val),
				657	"ahi\t$rT, $rA, $val", IntegerOp,
				658	[(set R16C:$rT, (add R16C:$rA, v8i16SExt10Imm:$val))]>;
				659
				660	def Avec : RRForm<0b00000011000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				661	"a\t$rT, $rA, $rB", IntegerOp,
				662	[(set (v4i32 VECREG:$rT), (add (v4i32 VECREG:$rA), (v4i32 VECREG:$rB)))]>;
				663
				664	def : Pat<(add (v16i8 VECREG:$rA), (v16i8 VECREG:$rB)),
				665	(Avec VECREG:$rA, VECREG:$rB)>;
				666
				667	def Ar32 : RRForm<0b00000011000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				668	"a\t$rT, $rA, $rB", IntegerOp,
				669	[(set R32C:$rT, (add R32C:$rA, R32C:$rB))]>;
				670
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	671	def Ar8:
				672	RRForm<0b00000011000, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB),
				673	"a\t$rT, $rA, $rB", IntegerOp,
				674	[(set R8C:$rT, (add R8C:$rA, R8C:$rB))]>;
				675
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	676	def AIvec:
				677	RI10Form<0b00111000, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
				678	"ai\t$rT, $rA, $val", IntegerOp,
				679	[(set (v4i32 VECREG:$rT), (add (v4i32 VECREG:$rA),
				680	v4i32SExt10Imm:$val))]>;
				681
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	682	def AIr32:
				683	RI10Form<0b00111000, (outs R32C:$rT), (ins R32C:$rA, s10imm_i32:$val),
				684	"ai\t$rT, $rA, $val", IntegerOp,
				685	[(set R32C:$rT, (add R32C:$rA, i32ImmSExt10:$val))]>;
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	686
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	687	def SFHvec:
				688	RRForm<0b00010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				689	"sfh\t$rT, $rA, $rB", IntegerOp,
				690	[(set (v8i16 VECREG:$rT), (sub (v8i16 VECREG:$rA),
				691	(v8i16 VECREG:$rB)))]>;
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	692
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	693	def SFHr16:
				694	RRForm<0b00010010000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
				695	"sfh\t$rT, $rA, $rB", IntegerOp,
				696	[(set R16C:$rT, (sub R16C:$rA, R16C:$rB))]>;
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	697
				698	def SFHIvec:
				699	RI10Form<0b10110000, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
				700	"sfhi\t$rT, $rA, $val", IntegerOp,
				701	[(set (v8i16 VECREG:$rT), (sub v8i16SExt10Imm:$val,
				702	(v8i16 VECREG:$rA)))]>;
				703
				704	def SFHIr16 : RI10Form<0b10110000, (outs R16C:$rT), (ins R16C:$rA, s10imm:$val),
				705	"sfhi\t$rT, $rA, $val", IntegerOp,
				706	[(set R16C:$rT, (sub i16ImmSExt10:$val, R16C:$rA))]>;
				707
				708	def SFvec : RRForm<0b00000010000, (outs VECREG:$rT),
				709	(ins VECREG:$rA, VECREG:$rB),
				710	"sf\t$rT, $rA, $rB", IntegerOp,
				711	[(set (v4i32 VECREG:$rT), (sub (v4i32 VECREG:$rA), (v4i32 VECREG:$rB)))]>;
				712
				713	def SFr32 : RRForm<0b00000010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				714	"sf\t$rT, $rA, $rB", IntegerOp,
				715	[(set R32C:$rT, (sub R32C:$rA, R32C:$rB))]>;
				716
				717	def SFIvec:
				718	RI10Form<0b00110000, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
				719	"sfi\t$rT, $rA, $val", IntegerOp,
				720	[(set (v4i32 VECREG:$rT), (sub v4i32SExt10Imm:$val,
				721	(v4i32 VECREG:$rA)))]>;
				722
				723	def SFIr32 : RI10Form<0b00110000, (outs R32C:$rT),
				724	(ins R32C:$rA, s10imm_i32:$val),
				725	"sfi\t$rT, $rA, $val", IntegerOp,
				726	[(set R32C:$rT, (sub i32ImmSExt10:$val, R32C:$rA))]>;
				727
				728	// ADDX: only available in vector form, doesn't match a pattern.
				729	def ADDXvec:
				730	RRForm<0b00000010110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB,
				731	VECREG:$rCarry),
				732	"addx\t$rT, $rA, $rB", IntegerOp,
				733	[]>,
				734	RegConstraint<"$rCarry = $rT">,
				735	NoEncode<"$rCarry">;
				736
				737	// CG: only available in vector form, doesn't match a pattern.
				738	def CGvec:
				739	RRForm<0b01000011000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB,
				740	VECREG:$rCarry),
				741	"cg\t$rT, $rA, $rB", IntegerOp,
				742	[]>,
				743	RegConstraint<"$rCarry = $rT">,
				744	NoEncode<"$rCarry">;
				745
				746	// SFX: only available in vector form, doesn't match a pattern
				747	def SFXvec:
				748	RRForm<0b10000010110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB,
				749	VECREG:$rCarry),
				750	"sfx\t$rT, $rA, $rB", IntegerOp,
				751	[]>,
				752	RegConstraint<"$rCarry = $rT">,
				753	NoEncode<"$rCarry">;
				754
				755	// BG: only available in vector form, doesn't match a pattern.
				756	def BGvec:
				757	RRForm<0b01000010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB,
				758	VECREG:$rCarry),
				759	"bg\t$rT, $rA, $rB", IntegerOp,
				760	[]>,
				761	RegConstraint<"$rCarry = $rT">,
				762	NoEncode<"$rCarry">;
				763
				764	// BGX: only available in vector form, doesn't match a pattern.
				765	def BGXvec:
				766	RRForm<0b11000010110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB,
				767	VECREG:$rCarry),
				768	"bgx\t$rT, $rA, $rB", IntegerOp,
				769	[]>,
				770	RegConstraint<"$rCarry = $rT">,
				771	NoEncode<"$rCarry">;
				772
				773	// Halfword multiply variants:
				774	// N.B: These can be used to build up larger quantities (16x16 -> 32)
				775
				776	def MPYv8i16:
				777	RRForm<0b00100011110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				778	"mpy\t$rT, $rA, $rB", IntegerMulDiv,
				779	[(set (v8i16 VECREG:$rT), (SPUmpy_v8i16 (v8i16 VECREG:$rA),
				780	(v8i16 VECREG:$rB)))]>;
				781
				782	def MPYr16:
				783	RRForm<0b00100011110, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
				784	"mpy\t$rT, $rA, $rB", IntegerMulDiv,
				785	[(set R16C:$rT, (mul R16C:$rA, R16C:$rB))]>;
				786
				787	def MPYUv4i32:
				788	RRForm<0b00110011110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				789	"mpyu\t$rT, $rA, $rB", IntegerMulDiv,
				790	[(set (v4i32 VECREG:$rT),
				791	(SPUmpyu_v4i32 (v4i32 VECREG:$rA), (v4i32 VECREG:$rB)))]>;
				792
				793	def MPYUr16:
				794	RRForm<0b00110011110, (outs R32C:$rT), (ins R16C:$rA, R16C:$rB),
				795	"mpyu\t$rT, $rA, $rB", IntegerMulDiv,
				796	[(set R32C:$rT, (mul (zext R16C:$rA),
				797	(zext R16C:$rB)))]>;
				798
				799	def MPYUr32:
				800	RRForm<0b00110011110, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				801	"mpyu\t$rT, $rA, $rB", IntegerMulDiv,
				802	[(set R32C:$rT, (SPUmpyu_i32 R32C:$rA, R32C:$rB))]>;
				803
				804	// mpyi: multiply 16 x s10imm -> 32 result (custom lowering for 32 bit result,
				805	// this only produces the lower 16 bits)
				806	def MPYIvec:
				807	RI10Form<0b00101110, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
				808	"mpyi\t$rT, $rA, $val", IntegerMulDiv,
				809	[(set (v8i16 VECREG:$rT), (mul (v8i16 VECREG:$rA), v8i16SExt10Imm:$val))]>;
				810
				811	def MPYIr16:
				812	RI10Form<0b00101110, (outs R16C:$rT), (ins R16C:$rA, s10imm:$val),
				813	"mpyi\t$rT, $rA, $val", IntegerMulDiv,
				814	[(set R16C:$rT, (mul R16C:$rA, i16ImmSExt10:$val))]>;
				815
				816	// mpyui: same issues as other multiplies, plus, this doesn't match a
				817	// pattern... but may be used during target DAG selection or lowering
				818	def MPYUIvec:
				819	RI10Form<0b10101110, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
				820	"mpyui\t$rT, $rA, $val", IntegerMulDiv,
				821	[]>;
				822
				823	def MPYUIr16:
				824	RI10Form<0b10101110, (outs R16C:$rT), (ins R16C:$rA, s10imm:$val),
				825	"mpyui\t$rT, $rA, $val", IntegerMulDiv,
				826	[]>;
				827
				828	// mpya: 16 x 16 + 16 -> 32 bit result
				829	def MPYAvec:
				830	RRRForm<0b0011, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
				831	"mpya\t$rT, $rA, $rB, $rC", IntegerMulDiv,
				832	[(set (v4i32 VECREG:$rT), (add (v4i32 (bitconvert (mul (v8i16 VECREG:$rA),
				833	(v8i16 VECREG:$rB)))),
				834	(v4i32 VECREG:$rC)))]>;
				835
				836	def MPYAr32:
				837	RRRForm<0b0011, (outs R32C:$rT), (ins R16C:$rA, R16C:$rB, R32C:$rC),
				838	"mpya\t$rT, $rA, $rB, $rC", IntegerMulDiv,
				839	[(set R32C:$rT, (add (sext (mul R16C:$rA, R16C:$rB)),
				840	R32C:$rC))]>;
				841
				842	def : Pat<(add (mul (sext R16C:$rA), (sext R16C:$rB)), R32C:$rC),
				843	(MPYAr32 R16C:$rA, R16C:$rB, R32C:$rC)>;
				844
				845	def MPYAr32_sextinreg:
				846	RRRForm<0b0011, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB, R32C:$rC),
				847	"mpya\t$rT, $rA, $rB, $rC", IntegerMulDiv,
				848	[(set R32C:$rT, (add (mul (sext_inreg R32C:$rA, i16),
				849	(sext_inreg R32C:$rB, i16)),
				850	R32C:$rC))]>;
				851
				852	//def MPYAr32:
				853	// RRRForm<0b0011, (outs R32C:$rT), (ins R16C:$rA, R16C:$rB, R32C:$rC),
				854	// "mpya\t$rT, $rA, $rB, $rC", IntegerMulDiv,
				855	// [(set R32C:$rT, (add (sext (mul R16C:$rA, R16C:$rB)),
				856	// R32C:$rC))]>;
				857
				858	// mpyh: multiply high, used to synthesize 32-bit multiplies
				859	def MPYHv4i32:
				860	RRForm<0b10100011110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				861	"mpyh\t$rT, $rA, $rB", IntegerMulDiv,
				862	[(set (v4i32 VECREG:$rT),
				863	(SPUmpyh_v4i32 (v4i32 VECREG:$rA), (v4i32 VECREG:$rB)))]>;
				864
				865	def MPYHr32:
				866	RRForm<0b10100011110, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				867	"mpyh\t$rT, $rA, $rB", IntegerMulDiv,
				868	[(set R32C:$rT, (SPUmpyh_i32 R32C:$rA, R32C:$rB))]>;
				869
				870	// mpys: multiply high and shift right (returns the top half of
				871	// a 16-bit multiply, sign extended to 32 bits.)
				872	def MPYSvec:
				873	RRForm<0b11100011110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				874	"mpys\t$rT, $rA, $rB", IntegerMulDiv,
				875	[]>;
				876
				877	def MPYSr16:
				878	RRForm<0b11100011110, (outs R32C:$rT), (ins R16C:$rA, R16C:$rB),
				879	"mpys\t$rT, $rA, $rB", IntegerMulDiv,
				880	[]>;
				881
				882	// mpyhh: multiply high-high (returns the 32-bit result from multiplying
				883	// the top 16 bits of the $rA, $rB)
				884	def MPYHHv8i16:
				885	RRForm<0b01100011110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				886	"mpyhh\t$rT, $rA, $rB", IntegerMulDiv,
				887	[(set (v8i16 VECREG:$rT),
				888	(SPUmpyhh_v8i16 (v8i16 VECREG:$rA), (v8i16 VECREG:$rB)))]>;
				889
				890	def MPYHHr32:
				891	RRForm<0b01100011110, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				892	"mpyhh\t$rT, $rA, $rB", IntegerMulDiv,
				893	[]>;
				894
				895	// mpyhha: Multiply high-high, add to $rT:
				896	def MPYHHAvec:
				897	RRForm<0b01100010110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				898	"mpyhha\t$rT, $rA, $rB", IntegerMulDiv,
				899	[]>;
				900
				901	def MPYHHAr32:
				902	RRForm<0b01100010110, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				903	"mpyhha\t$rT, $rA, $rB", IntegerMulDiv,
				904	[]>;
				905
				906	// mpyhhu: Multiply high-high, unsigned
				907	def MPYHHUvec:
				908	RRForm<0b01110011110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				909	"mpyhhu\t$rT, $rA, $rB", IntegerMulDiv,
				910	[]>;
				911
				912	def MPYHHUr32:
				913	RRForm<0b01110011110, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				914	"mpyhhu\t$rT, $rA, $rB", IntegerMulDiv,
				915	[]>;
				916
				917	// mpyhhau: Multiply high-high, unsigned
				918	def MPYHHAUvec:
				919	RRForm<0b01110010110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				920	"mpyhhau\t$rT, $rA, $rB", IntegerMulDiv,
				921	[]>;
				922
				923	def MPYHHAUr32:
				924	RRForm<0b01110010110, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				925	"mpyhhau\t$rT, $rA, $rB", IntegerMulDiv,
				926	[]>;
				927
				928	// clz: Count leading zeroes
				929	def CLZv4i32:
				930	RRForm_1<0b10100101010, (outs VECREG:$rT), (ins VECREG:$rA),
				931	"clz\t$rT, $rA", IntegerOp,
				932	[/* intrinsic */]>;
				933
				934	def CLZr32:
				935	RRForm_1<0b10100101010, (outs R32C:$rT), (ins R32C:$rA),
				936	"clz\t$rT, $rA", IntegerOp,
				937	[(set R32C:$rT, (ctlz R32C:$rA))]>;
				938
				939	// cntb: Count ones in bytes (aka "population count")
				940	// NOTE: This instruction is really a vector instruction, but the custom
				941	// lowering code uses it in unorthodox ways to support CTPOP for other
				942	// data types!
				943	def CNTBv16i8:
				944	RRForm_1<0b00101101010, (outs VECREG:$rT), (ins VECREG:$rA),
				945	"cntb\t$rT, $rA", IntegerOp,
				946	[(set (v16i8 VECREG:$rT), (SPUcntb_v16i8 (v16i8 VECREG:$rA)))]>;
				947
				948	def CNTBv8i16 :
				949	RRForm_1<0b00101101010, (outs VECREG:$rT), (ins VECREG:$rA),
				950	"cntb\t$rT, $rA", IntegerOp,
				951	[(set (v8i16 VECREG:$rT), (SPUcntb_v8i16 (v8i16 VECREG:$rA)))]>;
				952
				953	def CNTBv4i32 :
				954	RRForm_1<0b00101101010, (outs VECREG:$rT), (ins VECREG:$rA),
				955	"cntb\t$rT, $rA", IntegerOp,
				956	[(set (v4i32 VECREG:$rT), (SPUcntb_v4i32 (v4i32 VECREG:$rA)))]>;
				957
				958	// fsmb: Form select mask for bytes. N.B. Input operand, $rA, is 16-bits
				959	def FSMB:
				960	RRForm_1<0b01101101100, (outs VECREG:$rT), (ins R16C:$rA),
				961	"fsmb\t$rT, $rA", SelectOp,
				962	[]>;
				963
				964	// fsmh: Form select mask for halfwords. N.B., Input operand, $rA, is
				965	// only 8-bits wide (even though it's input as 16-bits here)
				966	def FSMH:
				967	RRForm_1<0b10101101100, (outs VECREG:$rT), (ins R16C:$rA),
				968	"fsmh\t$rT, $rA", SelectOp,
				969	[]>;
				970
				971	// fsm: Form select mask for words. Like the other fsm* instructions,
				972	// only the lower 4 bits of $rA are significant.
				973	def FSM:
				974	RRForm_1<0b00101101100, (outs VECREG:$rT), (ins R16C:$rA),
				975	"fsm\t$rT, $rA", SelectOp,
				976	[]>;
				977
				978	// gbb: Gather all low order bits from each byte in $rA into a single 16-bit
				979	// quantity stored into $rT
				980	def GBB:
				981	RRForm_1<0b01001101100, (outs R16C:$rT), (ins VECREG:$rA),
				982	"gbb\t$rT, $rA", GatherOp,
				983	[]>;
				984
				985	// gbh: Gather all low order bits from each halfword in $rA into a single
				986	// 8-bit quantity stored in $rT
				987	def GBH:
				988	RRForm_1<0b10001101100, (outs R16C:$rT), (ins VECREG:$rA),
				989	"gbh\t$rT, $rA", GatherOp,
				990	[]>;
				991
				992	// gb: Gather all low order bits from each word in $rA into a single
				993	// 4-bit quantity stored in $rT
				994	def GB:
				995	RRForm_1<0b00001101100, (outs R16C:$rT), (ins VECREG:$rA),
				996	"gb\t$rT, $rA", GatherOp,
				997	[]>;
				998
				999	// avgb: average bytes
				1000	def AVGB:
				1001	RRForm<0b11001011000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1002	"avgb\t$rT, $rA, $rB", ByteOp,
				1003	[]>;
				1004
				1005	// absdb: absolute difference of bytes
				1006	def ABSDB:
				1007	RRForm<0b11001010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1008	"absdb\t$rT, $rA, $rB", ByteOp,
				1009	[]>;
				1010
				1011	// sumb: sum bytes into halfwords
				1012	def SUMB:
				1013	RRForm<0b11001010010, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1014	"sumb\t$rT, $rA, $rB", ByteOp,
				1015	[]>;
				1016
				1017	// Sign extension operations:
				1018	def XSBHvec:
				1019	RRForm_1<0b01101101010, (outs VECREG:$rDst), (ins VECREG:$rSrc),
				1020	"xsbh\t$rDst, $rSrc", IntegerOp,
				1021	[(set (v8i16 VECREG:$rDst), (sext (v16i8 VECREG:$rSrc)))]>;
				1022
				1023	// Ordinary form for XSBH
				1024	def XSBHr16:
				1025	RRForm_1<0b01101101010, (outs R16C:$rDst), (ins R16C:$rSrc),
				1026	"xsbh\t$rDst, $rSrc", IntegerOp,
				1027	[(set R16C:$rDst, (sext_inreg R16C:$rSrc, i8))]>;
				1028
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1029	def XSBHr8:
				1030	RRForm_1<0b01101101010, (outs R16C:$rDst), (ins R8C:$rSrc),
				1031	"xsbh\t$rDst, $rSrc", IntegerOp,
				1032	[(set R16C:$rDst, (sext R8C:$rSrc))]>;
				1033
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1034	// 32-bit form for XSBH: used to sign extend 8-bit quantities to 16-bit
				1035	// quantities to 32-bit quantities via a 32-bit register (see the sext 8->32
				1036	// pattern below). Intentionally doesn't match a pattern because we want the
				1037	// sext 8->32 pattern to do the work for us, namely because we need the extra
				1038	// XSHWr32.
				1039	def XSBHr32:
				1040	RRForm_1<0b01101101010, (outs R32C:$rDst), (ins R32C:$rSrc),
				1041	"xsbh\t$rDst, $rSrc", IntegerOp,
				1042	[(set R32C:$rDst, (sext_inreg R32C:$rSrc, i8))]>;
				1043
				1044	// Sign extend halfwords to words:
				1045	def XSHWvec:
				1046	RRForm_1<0b01101101010, (outs VECREG:$rDest), (ins VECREG:$rSrc),
				1047	"xshw\t$rDest, $rSrc", IntegerOp,
				1048	[(set (v4i32 VECREG:$rDest), (sext (v8i16 VECREG:$rSrc)))]>;
				1049
				1050	def XSHWr32:
				1051	RRForm_1<0b01101101010, (outs R32C:$rDst), (ins R32C:$rSrc),
				1052	"xshw\t$rDst, $rSrc", IntegerOp,
				1053	[(set R32C:$rDst, (sext_inreg R32C:$rSrc, i16))]>;
				1054
				1055	def XSHWr16:
				1056	RRForm_1<0b01101101010, (outs R32C:$rDst), (ins R16C:$rSrc),
				1057	"xshw\t$rDst, $rSrc", IntegerOp,
				1058	[(set R32C:$rDst, (sext R16C:$rSrc))]>;
				1059
				1060	def XSWDvec:
				1061	RRForm_1<0b01100101010, (outs VECREG:$rDst), (ins VECREG:$rSrc),
				1062	"xswd\t$rDst, $rSrc", IntegerOp,
				1063	[(set (v2i64 VECREG:$rDst), (sext (v4i32 VECREG:$rSrc)))]>;
				1064
				1065	def XSWDr64:
				1066	RRForm_1<0b01100101010, (outs R64C:$rDst), (ins R64C:$rSrc),
				1067	"xswd\t$rDst, $rSrc", IntegerOp,
				1068	[(set R64C:$rDst, (sext_inreg R64C:$rSrc, i32))]>;
				1069
				1070	def XSWDr32:
				1071	RRForm_1<0b01100101010, (outs R64C:$rDst), (ins R32C:$rSrc),
				1072	"xswd\t$rDst, $rSrc", IntegerOp,
				1073	[(set R64C:$rDst, (SPUsext32_to_64 R32C:$rSrc))]>;
				1074
				1075	def : Pat<(sext R32C:$inp),
				1076	(XSWDr32 R32C:$inp)>;
				1077
				1078	// AND operations
				1079	def ANDv16i8:
				1080	RRForm<0b10000011000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1081	"and\t$rT, $rA, $rB", IntegerOp,
				1082	[(set (v16i8 VECREG:$rT), (and (v16i8 VECREG:$rA),
				1083	(v16i8 VECREG:$rB)))]>;
				1084
				1085	def ANDv8i16:
				1086	RRForm<0b10000011000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1087	"and\t$rT, $rA, $rB", IntegerOp,
				1088	[(set (v8i16 VECREG:$rT), (and (v8i16 VECREG:$rA),
				1089	(v8i16 VECREG:$rB)))]>;
				1090
				1091	def ANDv4i32:
				1092	RRForm<0b10000011000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1093	"and\t$rT, $rA, $rB", IntegerOp,
				1094	[(set (v4i32 VECREG:$rT), (and (v4i32 VECREG:$rA),
				1095	(v4i32 VECREG:$rB)))]>;
				1096
				1097	def ANDr32:
				1098	RRForm<0b10000011000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				1099	"and\t$rT, $rA, $rB", IntegerOp,
				1100	[(set R32C:$rT, (and R32C:$rA, R32C:$rB))]>;
				1101
				1102	//===---------------------------------------------
				1103	// Special instructions to perform the fabs instruction
				1104	def ANDfabs32:
				1105	RRForm<0b10000011000, (outs R32FP:$rT), (ins R32FP:$rA, R32C:$rB),
				1106	"and\t$rT, $rA, $rB", IntegerOp,
				1107	[/* Intentionally does not match a pattern */]>;
				1108
				1109	def ANDfabs64:
				1110	RRForm<0b10000011000, (outs R64FP:$rT), (ins R64FP:$rA, VECREG:$rB),
				1111	"and\t$rT, $rA, $rB", IntegerOp,
				1112	[/* Intentionally does not match a pattern */]>;
				1113
				1114	// Could use ANDv4i32, but won't for clarity
				1115	def ANDfabsvec:
				1116	RRForm<0b10000011000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1117	"and\t$rT, $rA, $rB", IntegerOp,
				1118	[/* Intentionally does not match a pattern */]>;
				1119
				1120	//===---------------------------------------------
				1121
				1122	def ANDr16:
				1123	RRForm<0b10000011000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
				1124	"and\t$rT, $rA, $rB", IntegerOp,
				1125	[(set R16C:$rT, (and R16C:$rA, R16C:$rB))]>;
				1126
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1127	def ANDr8:
				1128	RRForm<0b10000011000, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB),
				1129	"and\t$rT, $rA, $rB", IntegerOp,
				1130	[(set R8C:$rT, (and R8C:$rA, R8C:$rB))]>;
				1131
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1132	// Hacked form of AND to zero-extend 16-bit quantities to 32-bit
				1133	// quantities -- see 16->32 zext pattern.
				1134	//
				1135	// This pattern is somewhat artificial, since it might match some
				1136	// compiler generated pattern but it is unlikely to do so.
				1137	def AND2To4:
				1138	RRForm<0b10000011000, (outs R32C:$rT), (ins R16C:$rA, R32C:$rB),
				1139	"and\t$rT, $rA, $rB", IntegerOp,
				1140	[(set R32C:$rT, (and (zext R16C:$rA), R32C:$rB))]>;
				1141
				1142	// N.B.: vnot_conv is one of those special target selection pattern fragments,
				1143	// in which we expect there to be a bit_convert on the constant. Bear in mind
				1144	// that llvm translates "not <reg>" to "xor <reg>, -1" (or in this case, a
				1145	// constant -1 vector.)
				1146	def ANDCv16i8:
				1147	RRForm<0b10000011010, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1148	"andc\t$rT, $rA, $rB", IntegerOp,
				1149	[(set (v16i8 VECREG:$rT), (and (v16i8 VECREG:$rA),
				1150	(vnot (v16i8 VECREG:$rB))))]>;
				1151
				1152	def ANDCv8i16:
				1153	RRForm<0b10000011010, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1154	"andc\t$rT, $rA, $rB", IntegerOp,
				1155	[(set (v8i16 VECREG:$rT), (and (v8i16 VECREG:$rA),
				1156	(vnot (v8i16 VECREG:$rB))))]>;
				1157
				1158	def ANDCv4i32:
				1159	RRForm<0b10000011010, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1160	"andc\t$rT, $rA, $rB", IntegerOp,
				1161	[(set (v4i32 VECREG:$rT), (and (v4i32 VECREG:$rA),
				1162	(vnot (v4i32 VECREG:$rB))))]>;
				1163
				1164	def ANDCr32:
				1165	RRForm<0b10000011010, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				1166	"andc\t$rT, $rA, $rB", IntegerOp,
				1167	[(set R32C:$rT, (and R32C:$rA, (not R32C:$rB)))]>;
				1168
				1169	def ANDCr16:
				1170	RRForm<0b10000011010, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
				1171	"andc\t$rT, $rA, $rB", IntegerOp,
				1172	[(set R16C:$rT, (and R16C:$rA, (not R16C:$rB)))]>;
				1173
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1174	def ANDCr8:
				1175	RRForm<0b10000011010, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB),
				1176	"andc\t$rT, $rA, $rB", IntegerOp,
				1177	[(set R8C:$rT, (and R8C:$rA, (not R8C:$rB)))]>;
				1178
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1179	def ANDBIv16i8:
				1180	RI10Form<0b01101000, (outs VECREG:$rT), (ins VECREG:$rA, u10imm:$val),
				1181	"andbi\t$rT, $rA, $val", IntegerOp,
				1182	[(set (v16i8 VECREG:$rT),
				1183	(and (v16i8 VECREG:$rA), (v16i8 v16i8U8Imm:$val)))]>;
				1184
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1185	def ANDBIr8:
				1186	RI10Form<0b01101000, (outs R8C:$rT), (ins R8C:$rA, u10imm_i8:$val),
				1187	"andbi\t$rT, $rA, $val", IntegerOp,
				1188	[(set R8C:$rT, (and R8C:$rA, immU8:$val))]>;
				1189
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1190	def ANDHIv8i16:
				1191	RI10Form<0b10101000, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
				1192	"andhi\t$rT, $rA, $val", IntegerOp,
				1193	[(set (v8i16 VECREG:$rT),
				1194	(and (v8i16 VECREG:$rA), v8i16SExt10Imm:$val))]>;
				1195
				1196	def ANDHIr16:
				1197	RI10Form<0b10101000, (outs R16C:$rT), (ins R16C:$rA, s10imm:$val),
				1198	"andhi\t$rT, $rA, $val", IntegerOp,
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1199	[(set R16C:$rT, (and R16C:$rA, i16ImmUns10:$val))]>;
				1200
				1201	def ANDHI1To2:
				1202	RI10Form<0b10101000, (outs R16C:$rT), (ins R8C:$rA, s10imm:$val),
				1203	"andhi\t$rT, $rA, $val", IntegerOp,
				1204	[(set R16C:$rT, (and (zext R8C:$rA), i16ImmSExt10:$val))]>;
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1205
				1206	def ANDIv4i32:
				1207	RI10Form<0b00101000, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
				1208	"andi\t$rT, $rA, $val", IntegerOp,
				1209	[(set (v4i32 VECREG:$rT),
				1210	(and (v4i32 VECREG:$rA), v4i32SExt10Imm:$val))]>;
				1211
				1212	def ANDIr32:
				1213	RI10Form<0b10101000, (outs R32C:$rT), (ins R32C:$rA, s10imm_i32:$val),
				1214	"andi\t$rT, $rA, $val", IntegerOp,
				1215	[(set R32C:$rT, (and R32C:$rA, i32ImmSExt10:$val))]>;
				1216
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1217	// Hacked form of ANDI to zero-extend i8 quantities to i32. See the zext 8->32
				1218	// pattern below.
				1219	def ANDI1To4:
				1220	RI10Form<0b10101000, (outs R32C:$rT), (ins R8C:$rA, s10imm_i32:$val),
				1221	"andi\t$rT, $rA, $val", IntegerOp,
				1222	[(set R32C:$rT, (and (zext R8C:$rA), i32ImmSExt10:$val))]>;
				1223
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1224	// Hacked form of ANDI to zero-extend i16 quantities to i32. See the
				1225	// zext 16->32 pattern below.
				1226	//
				1227	// Note that this pattern is somewhat artificial, since it might match
				1228	// something the compiler generates but is unlikely to occur in practice.
				1229	def ANDI2To4:
				1230	RI10Form<0b10101000, (outs R32C:$rT), (ins R16C:$rA, s10imm_i32:$val),
				1231	"andi\t$rT, $rA, $val", IntegerOp,
				1232	[(set R32C:$rT, (and (zext R16C:$rA), i32ImmSExt10:$val))]>;
				1233
				1234	// Bitwise OR group:
				1235	// Bitwise "or" (N.B.: These are also register-register copy instructions...)
				1236	def ORv16i8:
				1237	RRForm<0b10000010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1238	"or\t$rT, $rA, $rB", IntegerOp,
				1239	[(set (v16i8 VECREG:$rT), (or (v16i8 VECREG:$rA), (v16i8 VECREG:$rB)))]>;
				1240
				1241	def ORv8i16:
				1242	RRForm<0b10000010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1243	"or\t$rT, $rA, $rB", IntegerOp,
				1244	[(set (v8i16 VECREG:$rT), (or (v8i16 VECREG:$rA), (v8i16 VECREG:$rB)))]>;
				1245
				1246	def ORv4i32:
				1247	RRForm<0b10000010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1248	"or\t$rT, $rA, $rB", IntegerOp,
				1249	[(set (v4i32 VECREG:$rT), (or (v4i32 VECREG:$rA), (v4i32 VECREG:$rB)))]>;
				1250
				1251	def ORv4f32:
				1252	RRForm<0b10000010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1253	"or\t$rT, $rA, $rB", IntegerOp,
				1254	[(set (v4f32 VECREG:$rT),
				1255	(v4f32 (bitconvert (or (v4i32 VECREG:$rA), (v4i32 VECREG:$rB)))))]>;
				1256
				1257	def ORv2f64:
				1258	RRForm<0b10000010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1259	"or\t$rT, $rA, $rB", IntegerOp,
				1260	[(set (v2f64 VECREG:$rT),
				1261	(v2f64 (bitconvert (or (v2i64 VECREG:$rA), (v2i64 VECREG:$rB)))))]>;
				1262
				1263	def ORgprc:
				1264	RRForm<0b10000010000, (outs GPRC:$rT), (ins GPRC:$rA, GPRC:$rB),
				1265	"or\t$rT, $rA, $rB", IntegerOp,
				1266	[(set GPRC:$rT, (or GPRC:$rA, GPRC:$rB))]>;
				1267
				1268	def ORr64:
				1269	RRForm<0b10000010000, (outs R64C:$rT), (ins R64C:$rA, R64C:$rB),
				1270	"or\t$rT, $rA, $rB", IntegerOp,
				1271	[(set R64C:$rT, (or R64C:$rA, R64C:$rB))]>;
				1272
				1273	def ORr32:
				1274	RRForm<0b10000010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				1275	"or\t$rT, $rA, $rB", IntegerOp,
				1276	[(set R32C:$rT, (or R32C:$rA, R32C:$rB))]>;
				1277
				1278	def ORr16:
				1279	RRForm<0b10000010000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
				1280	"or\t$rT, $rA, $rB", IntegerOp,
				1281	[(set R16C:$rT, (or R16C:$rA, R16C:$rB))]>;
				1282
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1283	def ORr8:
				1284	RRForm<0b10000010000, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB),
				1285	"or\t$rT, $rA, $rB", IntegerOp,
				1286	[(set R8C:$rT, (or R8C:$rA, R8C:$rB))]>;
				1287
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1288	// ORv_: Used in scalar->vector promotions:
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1289	def ORv16i8_i8:
				1290	RRForm<0b10000010000, (outs VECREG:$rT), (ins R8C:$rA, R8C:$rB),
				1291	"or\t$rT, $rA, $rB", IntegerOp,
				1292	[/* no pattern */]>;
				1293
				1294	def : Pat<(v16i8 (SPUpromote_scalar R8C:$rA)),
				1295	(ORv16i8_i8 R8C:$rA, R8C:$rA)>;
				1296
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1297	def ORv8i16_i16:
				1298	RRForm<0b10000010000, (outs VECREG:$rT), (ins R16C:$rA, R16C:$rB),
				1299	"or\t$rT, $rA, $rB", IntegerOp,
				1300	[/* no pattern */]>;
				1301
				1302	def : Pat<(v8i16 (SPUpromote_scalar R16C:$rA)),
				1303	(ORv8i16_i16 R16C:$rA, R16C:$rA)>;
				1304
				1305	def ORv4i32_i32:
				1306	RRForm<0b10000010000, (outs VECREG:$rT), (ins R32C:$rA, R32C:$rB),
				1307	"or\t$rT, $rA, $rB", IntegerOp,
				1308	[/* no pattern */]>;
				1309
				1310	def : Pat<(v4i32 (SPUpromote_scalar R32C:$rA)),
				1311	(ORv4i32_i32 R32C:$rA, R32C:$rA)>;
				1312
				1313	def ORv2i64_i64:
				1314	RRForm<0b10000010000, (outs VECREG:$rT), (ins R64C:$rA, R64C:$rB),
				1315	"or\t$rT, $rA, $rB", IntegerOp,
				1316	[/* no pattern */]>;
				1317
				1318	def : Pat<(v2i64 (SPUpromote_scalar R64C:$rA)),
				1319	(ORv2i64_i64 R64C:$rA, R64C:$rA)>;
				1320
				1321	def ORv4f32_f32:
				1322	RRForm<0b10000010000, (outs VECREG:$rT), (ins R32FP:$rA, R32FP:$rB),
				1323	"or\t$rT, $rA, $rB", IntegerOp,
				1324	[/* no pattern */]>;
				1325
				1326	def : Pat<(v4f32 (SPUpromote_scalar R32FP:$rA)),
				1327	(ORv4f32_f32 R32FP:$rA, R32FP:$rA)>;
				1328
				1329	def ORv2f64_f64:
				1330	RRForm<0b10000010000, (outs VECREG:$rT), (ins R64FP:$rA, R64FP:$rB),
				1331	"or\t$rT, $rA, $rB", IntegerOp,
				1332	[/* no pattern */]>;
				1333
				1334	def : Pat<(v2f64 (SPUpromote_scalar R64FP:$rA)),
				1335	(ORv2f64_f64 R64FP:$rA, R64FP:$rA)>;
				1336
				1337	// ORi_v: Used to extract vector element 0 (the preferred slot)
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1338	def ORi8_v16i8:
				1339	RRForm<0b10000010000, (outs R8C:$rT), (ins VECREG:$rA, VECREG:$rB),
				1340	"or\t$rT, $rA, $rB", IntegerOp,
				1341	[/* no pattern */]>;
				1342
				1343	def : Pat<(SPUextract_elt0 (v16i8 VECREG:$rA)),
				1344	(ORi8_v16i8 VECREG:$rA, VECREG:$rA)>;
				1345
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1346	def ORi16_v8i16:
				1347	RRForm<0b10000010000, (outs R16C:$rT), (ins VECREG:$rA, VECREG:$rB),
				1348	"or\t$rT, $rA, $rB", IntegerOp,
				1349	[/* no pattern */]>;
				1350
				1351	def : Pat<(SPUextract_elt0 (v8i16 VECREG:$rA)),
				1352	(ORi16_v8i16 VECREG:$rA, VECREG:$rA)>;
				1353
				1354	def : Pat<(SPUextract_elt0_chained (v8i16 VECREG:$rA)),
				1355	(ORi16_v8i16 VECREG:$rA, VECREG:$rA)>;
				1356
				1357	def ORi32_v4i32:
				1358	RRForm<0b10000010000, (outs R32C:$rT), (ins VECREG:$rA, VECREG:$rB),
				1359	"or\t$rT, $rA, $rB", IntegerOp,
				1360	[/* no pattern */]>;
				1361
				1362	def : Pat<(SPUextract_elt0 (v4i32 VECREG:$rA)),
				1363	(ORi32_v4i32 VECREG:$rA, VECREG:$rA)>;
				1364
				1365	def : Pat<(SPUextract_elt0_chained (v4i32 VECREG:$rA)),
				1366	(ORi32_v4i32 VECREG:$rA, VECREG:$rA)>;
				1367
				1368	def ORi64_v2i64:
				1369	RRForm<0b10000010000, (outs R64C:$rT), (ins VECREG:$rA, VECREG:$rB),
				1370	"or\t$rT, $rA, $rB", IntegerOp,
				1371	[/* no pattern */]>;
				1372
				1373	def : Pat<(SPUextract_elt0 (v2i64 VECREG:$rA)),
				1374	(ORi64_v2i64 VECREG:$rA, VECREG:$rA)>;
				1375
				1376	def : Pat<(SPUextract_elt0_chained (v2i64 VECREG:$rA)),
				1377	(ORi64_v2i64 VECREG:$rA, VECREG:$rA)>;
				1378
				1379	def ORf32_v4f32:
				1380	RRForm<0b10000010000, (outs R32FP:$rT), (ins VECREG:$rA, VECREG:$rB),
				1381	"or\t$rT, $rA, $rB", IntegerOp,
				1382	[/* no pattern */]>;
				1383
				1384	def : Pat<(SPUextract_elt0 (v4f32 VECREG:$rA)),
				1385	(ORf32_v4f32 VECREG:$rA, VECREG:$rA)>;
				1386
				1387	def : Pat<(SPUextract_elt0_chained (v4f32 VECREG:$rA)),
				1388	(ORf32_v4f32 VECREG:$rA, VECREG:$rA)>;
				1389
				1390	def ORf64_v2f64:
				1391	RRForm<0b10000010000, (outs R64FP:$rT), (ins VECREG:$rA, VECREG:$rB),
				1392	"or\t$rT, $rA, $rB", IntegerOp,
				1393	[/* no pattern */]>;
				1394
				1395	def : Pat<(SPUextract_elt0 (v2f64 VECREG:$rA)),
				1396	(ORf64_v2f64 VECREG:$rA, VECREG:$rA)>;
				1397
				1398	def : Pat<(SPUextract_elt0_chained (v2f64 VECREG:$rA)),
				1399	(ORf64_v2f64 VECREG:$rA, VECREG:$rA)>;
				1400
				1401	// ORC: Bitwise "or" with complement (match before ORvec, ORr32)
				1402	def ORCv16i8:
				1403	RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1404	"orc\t$rT, $rA, $rB", IntegerOp,
				1405	[(set (v16i8 VECREG:$rT), (or (v16i8 VECREG:$rA),
				1406	(vnot (v16i8 VECREG:$rB))))]>;
				1407
				1408	def ORCv8i16:
				1409	RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1410	"orc\t$rT, $rA, $rB", IntegerOp,
				1411	[(set (v8i16 VECREG:$rT), (or (v8i16 VECREG:$rA),
				1412	(vnot (v8i16 VECREG:$rB))))]>;
				1413
				1414	def ORCv4i32:
				1415	RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1416	"orc\t$rT, $rA, $rB", IntegerOp,
				1417	[(set (v4i32 VECREG:$rT), (or (v4i32 VECREG:$rA),
				1418	(vnot (v4i32 VECREG:$rB))))]>;
				1419
				1420	def ORCr32:
				1421	RRForm<0b10010010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				1422	"orc\t$rT, $rA, $rB", IntegerOp,
				1423	[(set R32C:$rT, (or R32C:$rA, (not R32C:$rB)))]>;
				1424
				1425	def ORCr16:
				1426	RRForm<0b10010010000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
				1427	"orc\t$rT, $rA, $rB", IntegerOp,
				1428	[(set R16C:$rT, (or R16C:$rA, (not R16C:$rB)))]>;
				1429
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1430	def ORCr8:
				1431	RRForm<0b10010010000, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB),
				1432	"orc\t$rT, $rA, $rB", IntegerOp,
				1433	[(set R8C:$rT, (or R8C:$rA, (not R8C:$rB)))]>;
				1434
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1435	// OR byte immediate
				1436	def ORBIv16i8:
				1437	RI10Form<0b01100000, (outs VECREG:$rT), (ins VECREG:$rA, u10imm:$val),
				1438	"orbi\t$rT, $rA, $val", IntegerOp,
				1439	[(set (v16i8 VECREG:$rT),
				1440	(or (v16i8 VECREG:$rA), (v16i8 v16i8U8Imm:$val)))]>;
				1441
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1442	def ORBIr8:
				1443	RI10Form<0b01100000, (outs R8C:$rT), (ins R8C:$rA, u10imm_i8:$val),
				1444	"orbi\t$rT, $rA, $val", IntegerOp,
				1445	[(set R8C:$rT, (or R8C:$rA, immU8:$val))]>;
				1446
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1447	// OR halfword immediate
				1448	def ORHIv8i16:
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1449	RI10Form<0b10100000, (outs VECREG:$rT), (ins VECREG:$rA, u10imm:$val),
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1450	"orhi\t$rT, $rA, $val", IntegerOp,
				1451	[(set (v8i16 VECREG:$rT), (or (v8i16 VECREG:$rA),
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1452	v8i16Uns10Imm:$val))]>;
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1453
				1454	def ORHIr16:
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1455	RI10Form<0b10100000, (outs R16C:$rT), (ins R16C:$rA, u10imm:$val),
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1456	"orhi\t$rT, $rA, $val", IntegerOp,
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1457	[(set R16C:$rT, (or R16C:$rA, i16ImmUns10:$val))]>;
				1458
				1459	// Hacked form of ORHI used to promote 8-bit registers to 16-bit
				1460	def ORHI1To2:
				1461	RI10Form<0b10100000, (outs R16C:$rT), (ins R8C:$rA, s10imm:$val),
				1462	"orhi\t$rT, $rA, $val", IntegerOp,
				1463	[(set R16C:$rT, (or (anyext R8C:$rA), i16ImmSExt10:$val))]>;
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1464
				1465	// Bitwise "or" with immediate
				1466	def ORIv4i32:
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1467	RI10Form<0b00100000, (outs VECREG:$rT), (ins VECREG:$rA, u10imm:$val),
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1468	"ori\t$rT, $rA, $val", IntegerOp,
				1469	[(set (v4i32 VECREG:$rT), (or (v4i32 VECREG:$rA),
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1470	v4i32Uns10Imm:$val))]>;
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1471
				1472	def ORIr32:
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1473	RI10Form<0b00100000, (outs R32C:$rT), (ins R32C:$rA, u10imm_i32:$val),
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1474	"ori\t$rT, $rA, $val", IntegerOp,
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1475	[(set R32C:$rT, (or R32C:$rA, i32ImmUns10:$val))]>;
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1476
				1477	// Hacked forms of or immediate to copy one 32- and 64-bit FP register
				1478	// to another. Do not match patterns.
				1479	def ORIf32:
				1480	RI10Form_1<0b00100000, (outs R32FP:$rT), (ins R32FP:$rA, s10imm_i32:$val),
				1481	"ori\t$rT, $rA, $val", IntegerOp,
				1482	[/* no pattern */]>;
				1483
				1484	def ORIf64:
				1485	RI10Form_1<0b00100000, (outs R64FP:$rT), (ins R64FP:$rA, s10imm_i32:$val),
				1486	"ori\t$rT, $rA, $val", IntegerOp,
				1487	[/* no pattern */]>;
				1488
				1489	def ORIr64:
				1490	RI10Form_1<0b00100000, (outs R64C:$rT), (ins R64C:$rA, s10imm_i32:$val),
				1491	"ori\t$rT, $rA, $val", IntegerOp,
				1492	[/* no pattern */]>;
				1493
				1494	// ORI2To4: hacked version of the ori instruction to extend 16-bit quantities
				1495	// to 32-bit quantities. used exclusively to match "anyext" conversions (vide
				1496	// infra "anyext 16->32" pattern.)
				1497	def ORI2To4:
				1498	RI10Form<0b00100000, (outs R32C:$rT), (ins R16C:$rA, s10imm_i32:$val),
				1499	"ori\t$rT, $rA, $val", IntegerOp,
				1500	[(set R32C:$rT, (or (anyext R16C:$rA), i32ImmSExt10:$val))]>;
				1501
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1502	// ORI1To4: Hacked version of the ORI instruction to extend 16-bit quantities
				1503	// to 32-bit quantities. Used exclusively to match "anyext" conversions (vide
				1504	// infra "anyext 16->32" pattern.)
				1505	def ORI1To4:
				1506	RI10Form<0b00100000, (outs R32C:$rT), (ins R8C:$rA, s10imm_i32:$val),
				1507	"ori\t$rT, $rA, $val", IntegerOp,
				1508	[(set R32C:$rT, (or (anyext R8C:$rA), i32ImmSExt10:$val))]>;
				1509
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1510	// ORX: "or" across the vector: or's $rA's word slots leaving the result in
				1511	// $rT[0], slots 1-3 are zeroed.
				1512	//
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1513	// FIXME: Needs to match an intrinsic pattern.
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1514	def ORXv4i32:
				1515	RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1516	"orx\t$rT, $rA, $rB", IntegerOp,
				1517	[]>;
				1518
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1519	// XOR:
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1520	def XORv16i8:
				1521	RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1522	"xor\t$rT, $rA, $rB", IntegerOp,
				1523	[(set (v16i8 VECREG:$rT), (xor (v16i8 VECREG:$rA), (v16i8 VECREG:$rB)))]>;
				1524
				1525	def XORv8i16:
				1526	RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1527	"xor\t$rT, $rA, $rB", IntegerOp,
				1528	[(set (v8i16 VECREG:$rT), (xor (v8i16 VECREG:$rA), (v8i16 VECREG:$rB)))]>;
				1529
				1530	def XORv4i32:
				1531	RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1532	"xor\t$rT, $rA, $rB", IntegerOp,
				1533	[(set (v4i32 VECREG:$rT), (xor (v4i32 VECREG:$rA), (v4i32 VECREG:$rB)))]>;
				1534
				1535	def XORr32:
				1536	RRForm<0b10010010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				1537	"xor\t$rT, $rA, $rB", IntegerOp,
				1538	[(set R32C:$rT, (xor R32C:$rA, R32C:$rB))]>;
				1539
				1540	//==----------------------------------------------------------
				1541	// Special forms for floating point instructions.
				1542	// Bitwise ORs and ANDs don't make sense for normal floating
				1543	// point numbers. These operations (fneg and fabs), however,
				1544	// require bitwise logical ops to manipulate the sign bit.
				1545	def XORfneg32:
				1546	RRForm<0b10010010000, (outs R32FP:$rT), (ins R32FP:$rA, R32C:$rB),
				1547	"xor\t$rT, $rA, $rB", IntegerOp,
				1548	[/* Intentionally does not match a pattern, see fneg32 */]>;
				1549
				1550	// KLUDGY! Better way to do this without a VECREG? bitconvert?
				1551	// VECREG is assumed to contain two identical 64-bit masks, so
				1552	// it doesn't matter which word we select for the xor
				1553	def XORfneg64:
				1554	RRForm<0b10010010000, (outs R64FP:$rT), (ins R64FP:$rA, VECREG:$rB),
				1555	"xor\t$rT, $rA, $rB", IntegerOp,
				1556	[/* Intentionally does not match a pattern, see fneg64 */]>;
				1557
				1558	// Could use XORv4i32, but will use this for clarity
				1559	def XORfnegvec:
				1560	RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1561	"xor\t$rT, $rA, $rB", IntegerOp,
				1562	[/* Intentionally does not match a pattern, see fneg{32,64} */]>;
				1563
				1564	//==----------------------------------------------------------
				1565
				1566	def XORr16:
				1567	RRForm<0b10010010000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
				1568	"xor\t$rT, $rA, $rB", IntegerOp,
				1569	[(set R16C:$rT, (xor R16C:$rA, R16C:$rB))]>;
				1570
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1571	def XORr8:
				1572	RRForm<0b10010010000, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB),
				1573	"xor\t$rT, $rA, $rB", IntegerOp,
				1574	[(set R8C:$rT, (xor R8C:$rA, R8C:$rB))]>;
				1575
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1576	def XORBIv16i8:
				1577	RI10Form<0b01100000, (outs VECREG:$rT), (ins VECREG:$rA, u10imm:$val),
				1578	"xorbi\t$rT, $rA, $val", IntegerOp,
				1579	[(set (v16i8 VECREG:$rT), (xor (v16i8 VECREG:$rA), v16i8U8Imm:$val))]>;
				1580
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1581	def XORBIr8:
				1582	RI10Form<0b01100000, (outs R8C:$rT), (ins R8C:$rA, u10imm_i8:$val),
				1583	"xorbi\t$rT, $rA, $val", IntegerOp,
				1584	[(set R8C:$rT, (xor R8C:$rA, immU8:$val))]>;
				1585
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1586	def XORHIv8i16:
				1587	RI10Form<0b10100000, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
				1588	"xorhi\t$rT, $rA, $val", IntegerOp,
				1589	[(set (v8i16 VECREG:$rT), (xor (v8i16 VECREG:$rA),
				1590	v8i16SExt10Imm:$val))]>;
				1591
				1592	def XORHIr16:
				1593	RI10Form<0b10100000, (outs R16C:$rT), (ins R16C:$rA, s10imm:$val),
				1594	"xorhi\t$rT, $rA, $val", IntegerOp,
				1595	[(set R16C:$rT, (xor R16C:$rA, i16ImmSExt10:$val))]>;
				1596
				1597	def XORIv4i32:
				1598	RI10Form<0b00100000, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
				1599	"xori\t$rT, $rA, $val", IntegerOp,
				1600	[(set (v4i32 VECREG:$rT), (xor (v4i32 VECREG:$rA),
				1601	v4i32SExt10Imm:$val))]>;
				1602
				1603	def XORIr32:
				1604	RI10Form<0b00100000, (outs R32C:$rT), (ins R32C:$rA, s10imm_i32:$val),
				1605	"xori\t$rT, $rA, $val", IntegerOp,
				1606	[(set R32C:$rT, (xor R32C:$rA, i32ImmSExt10:$val))]>;
				1607
				1608	// NAND:
				1609	def NANDv16i8:
				1610	RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1611	"nand\t$rT, $rA, $rB", IntegerOp,
				1612	[(set (v16i8 VECREG:$rT), (vnot (and (v16i8 VECREG:$rA),
				1613	(v16i8 VECREG:$rB))))]>;
				1614
				1615	def NANDv8i16:
				1616	RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1617	"nand\t$rT, $rA, $rB", IntegerOp,
				1618	[(set (v8i16 VECREG:$rT), (vnot (and (v8i16 VECREG:$rA),
				1619	(v8i16 VECREG:$rB))))]>;
				1620
				1621	def NANDv4i32:
				1622	RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1623	"nand\t$rT, $rA, $rB", IntegerOp,
				1624	[(set (v4i32 VECREG:$rT), (vnot (and (v4i32 VECREG:$rA),
				1625	(v4i32 VECREG:$rB))))]>;
				1626
				1627	def NANDr32:
				1628	RRForm<0b10010010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				1629	"nand\t$rT, $rA, $rB", IntegerOp,
				1630	[(set R32C:$rT, (not (and R32C:$rA, R32C:$rB)))]>;
				1631
				1632	def NANDr16:
				1633	RRForm<0b10010010000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
				1634	"nand\t$rT, $rA, $rB", IntegerOp,
				1635	[(set R16C:$rT, (not (and R16C:$rA, R16C:$rB)))]>;
				1636
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1637	def NANDr8:
				1638	RRForm<0b10010010000, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB),
				1639	"nand\t$rT, $rA, $rB", IntegerOp,
				1640	[(set R8C:$rT, (not (and R8C:$rA, R8C:$rB)))]>;
				1641
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1642	// NOR:
				1643	def NORv16i8:
				1644	RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1645	"nor\t$rT, $rA, $rB", IntegerOp,
				1646	[(set (v16i8 VECREG:$rT), (vnot (or (v16i8 VECREG:$rA),
				1647	(v16i8 VECREG:$rB))))]>;
				1648
				1649	def NORv8i16:
				1650	RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1651	"nor\t$rT, $rA, $rB", IntegerOp,
				1652	[(set (v8i16 VECREG:$rT), (vnot (or (v8i16 VECREG:$rA),
				1653	(v8i16 VECREG:$rB))))]>;
				1654
				1655	def NORv4i32:
				1656	RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1657	"nor\t$rT, $rA, $rB", IntegerOp,
				1658	[(set (v4i32 VECREG:$rT), (vnot (or (v4i32 VECREG:$rA),
				1659	(v4i32 VECREG:$rB))))]>;
				1660
				1661	def NORr32:
				1662	RRForm<0b10010010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				1663	"nor\t$rT, $rA, $rB", IntegerOp,
				1664	[(set R32C:$rT, (not (or R32C:$rA, R32C:$rB)))]>;
				1665
				1666	def NORr16:
				1667	RRForm<0b10010010000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
				1668	"nor\t$rT, $rA, $rB", IntegerOp,
				1669	[(set R16C:$rT, (not (or R16C:$rA, R16C:$rB)))]>;
				1670
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1671	def NORr8:
				1672	RRForm<0b10010010000, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB),
				1673	"nor\t$rT, $rA, $rB", IntegerOp,
				1674	[(set R8C:$rT, (not (or R8C:$rA, R8C:$rB)))]>;
				1675
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1676	// EQV: Equivalence (1 for each same bit, otherwise 0)
				1677	def EQVv16i8:
				1678	RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1679	"eqv\t$rT, $rA, $rB", IntegerOp,
				1680	[(set (v16i8 VECREG:$rT), (or (and (v16i8 VECREG:$rA),
				1681	(v16i8 VECREG:$rB)),
				1682	(and (vnot (v16i8 VECREG:$rA)),
				1683	(vnot (v16i8 VECREG:$rB)))))]>;
				1684
				1685	def : Pat<(xor (v16i8 VECREG:$rA), (vnot (v16i8 VECREG:$rB))),
				1686	(EQVv16i8 VECREG:$rA, VECREG:$rB)>;
				1687
				1688	def : Pat<(xor (vnot (v16i8 VECREG:$rA)), (v16i8 VECREG:$rB)),
				1689	(EQVv16i8 VECREG:$rA, VECREG:$rB)>;
				1690
				1691	def EQVv8i16:
				1692	RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1693	"eqv\t$rT, $rA, $rB", IntegerOp,
				1694	[(set (v8i16 VECREG:$rT), (or (and (v8i16 VECREG:$rA),
				1695	(v8i16 VECREG:$rB)),
				1696	(and (vnot (v8i16 VECREG:$rA)),
				1697	(vnot (v8i16 VECREG:$rB)))))]>;
				1698
				1699	def : Pat<(xor (v8i16 VECREG:$rA), (vnot (v8i16 VECREG:$rB))),
				1700	(EQVv8i16 VECREG:$rA, VECREG:$rB)>;
				1701
				1702	def : Pat<(xor (vnot (v8i16 VECREG:$rA)), (v8i16 VECREG:$rB)),
				1703	(EQVv8i16 VECREG:$rA, VECREG:$rB)>;
				1704
				1705	def EQVv4i32:
				1706	RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				1707	"eqv\t$rT, $rA, $rB", IntegerOp,
				1708	[(set (v4i32 VECREG:$rT), (or (and (v4i32 VECREG:$rA),
				1709	(v4i32 VECREG:$rB)),
				1710	(and (vnot (v4i32 VECREG:$rA)),
				1711	(vnot (v4i32 VECREG:$rB)))))]>;
				1712
				1713	def : Pat<(xor (v4i32 VECREG:$rA), (vnot (v4i32 VECREG:$rB))),
				1714	(EQVv4i32 VECREG:$rA, VECREG:$rB)>;
				1715
				1716	def : Pat<(xor (vnot (v4i32 VECREG:$rA)), (v4i32 VECREG:$rB)),
				1717	(EQVv4i32 VECREG:$rA, VECREG:$rB)>;
				1718
				1719	def EQVr32:
				1720	RRForm<0b10010010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				1721	"eqv\t$rT, $rA, $rB", IntegerOp,
				1722	[(set R32C:$rT, (or (and R32C:$rA, R32C:$rB),
				1723	(and (not R32C:$rA), (not R32C:$rB))))]>;
				1724
				1725	def : Pat<(xor R32C:$rA, (not R32C:$rB)),
				1726	(EQVr32 R32C:$rA, R32C:$rB)>;
				1727
				1728	def : Pat<(xor (not R32C:$rA), R32C:$rB),
				1729	(EQVr32 R32C:$rA, R32C:$rB)>;
				1730
				1731	def EQVr16:
				1732	RRForm<0b10010010000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
				1733	"eqv\t$rT, $rA, $rB", IntegerOp,
				1734	[(set R16C:$rT, (or (and R16C:$rA, R16C:$rB),
				1735	(and (not R16C:$rA), (not R16C:$rB))))]>;
				1736
				1737	def : Pat<(xor R16C:$rA, (not R16C:$rB)),
				1738	(EQVr16 R16C:$rA, R16C:$rB)>;
				1739
				1740	def : Pat<(xor (not R16C:$rA), R16C:$rB),
				1741	(EQVr16 R16C:$rA, R16C:$rB)>;
				1742
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1743	def EQVr8:
				1744	RRForm<0b10010010000, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB),
				1745	"eqv\t$rT, $rA, $rB", IntegerOp,
				1746	[(set R8C:$rT, (or (and R8C:$rA, R8C:$rB),
				1747	(and (not R8C:$rA), (not R8C:$rB))))]>;
				1748
				1749	def : Pat<(xor R8C:$rA, (not R8C:$rB)),
				1750	(EQVr8 R8C:$rA, R8C:$rB)>;
				1751
				1752	def : Pat<(xor (not R8C:$rA), R8C:$rB),
				1753	(EQVr8 R8C:$rA, R8C:$rB)>;
				1754
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1755	// gcc optimizes (p & q) \| (~p & ~q) -> ~(p \| q) \| (p & q), so match that
				1756	// pattern also:
				1757	def : Pat<(or (vnot (or (v16i8 VECREG:$rA), (v16i8 VECREG:$rB))),
				1758	(and (v16i8 VECREG:$rA), (v16i8 VECREG:$rB))),
				1759	(EQVv16i8 VECREG:$rA, VECREG:$rB)>;
				1760
				1761	def : Pat<(or (vnot (or (v8i16 VECREG:$rA), (v8i16 VECREG:$rB))),
				1762	(and (v8i16 VECREG:$rA), (v8i16 VECREG:$rB))),
				1763	(EQVv8i16 VECREG:$rA, VECREG:$rB)>;
				1764
				1765	def : Pat<(or (vnot (or (v4i32 VECREG:$rA), (v4i32 VECREG:$rB))),
				1766	(and (v4i32 VECREG:$rA), (v4i32 VECREG:$rB))),
				1767	(EQVv4i32 VECREG:$rA, VECREG:$rB)>;
				1768
				1769	def : Pat<(or (not (or R32C:$rA, R32C:$rB)), (and R32C:$rA, R32C:$rB)),
				1770	(EQVr32 R32C:$rA, R32C:$rB)>;
				1771
				1772	def : Pat<(or (not (or R16C:$rA, R16C:$rB)), (and R16C:$rA, R16C:$rB)),
				1773	(EQVr16 R16C:$rA, R16C:$rB)>;
				1774
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	1775	def : Pat<(or (not (or R8C:$rA, R8C:$rB)), (and R8C:$rA, R8C:$rB)),
				1776	(EQVr8 R8C:$rA, R8C:$rB)>;
				1777
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	1778	// Select bits:
				1779	def SELBv16i8:
				1780	RRRForm<0b1000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
				1781	"selb\t$rT, $rA, $rB, $rC", IntegerOp,
				1782	[(set (v16i8 VECREG:$rT),
				1783	(SPUselb_v16i8 (v16i8 VECREG:$rA), (v16i8 VECREG:$rB),
				1784	(v16i8 VECREG:$rC)))]>;
				1785
				1786	def : Pat<(or (and (v16i8 VECREG:$rA), (v16i8 VECREG:$rC)),
				1787	(and (v16i8 VECREG:$rB), (vnot (v16i8 VECREG:$rC)))),
				1788	(SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1789
				1790	def : Pat<(or (and (v16i8 VECREG:$rC), (v16i8 VECREG:$rA)),
				1791	(and (v16i8 VECREG:$rB), (vnot (v16i8 VECREG:$rC)))),
				1792	(SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1793
				1794	def : Pat<(or (and (v16i8 VECREG:$rA), (v16i8 VECREG:$rC)),
				1795	(and (vnot (v16i8 VECREG:$rC)), (v16i8 VECREG:$rB))),
				1796	(SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1797
				1798	def : Pat<(or (and (v16i8 VECREG:$rC), (v16i8 VECREG:$rA)),
				1799	(and (vnot (v16i8 VECREG:$rC)), (v16i8 VECREG:$rB))),
				1800	(SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1801
				1802	def : Pat<(or (and (v16i8 VECREG:$rA), (vnot (v16i8 VECREG:$rC))),
				1803	(and (v16i8 VECREG:$rB), (v16i8 VECREG:$rC))),
				1804	(SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1805
				1806	def : Pat<(or (and (v16i8 VECREG:$rA), (vnot (v16i8 VECREG:$rC))),
				1807	(and (v16i8 VECREG:$rC), (v16i8 VECREG:$rB))),
				1808	(SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1809
				1810	def : Pat<(or (and (vnot (v16i8 VECREG:$rC)), (v16i8 VECREG:$rA)),
				1811	(and (v16i8 VECREG:$rB), (v16i8 VECREG:$rC))),
				1812	(SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1813
				1814	def : Pat<(or (and (vnot (v16i8 VECREG:$rC)), (v16i8 VECREG:$rA)),
				1815	(and (v16i8 VECREG:$rC), (v16i8 VECREG:$rB))),
				1816	(SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1817
				1818	def : Pat<(or (and (v16i8 VECREG:$rA), (v16i8 VECREG:$rC)),
				1819	(and (v16i8 VECREG:$rB), (vnot (v16i8 VECREG:$rC)))),
				1820	(SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1821
				1822	def : Pat<(or (and (v16i8 VECREG:$rC), (v16i8 VECREG:$rA)),
				1823	(and (v16i8 VECREG:$rB), (vnot (v16i8 VECREG:$rC)))),
				1824	(SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1825
				1826	def : Pat<(or (and (v16i8 VECREG:$rA), (v16i8 VECREG:$rC)),
				1827	(and (vnot (v16i8 VECREG:$rC)), (v16i8 VECREG:$rB))),
				1828	(SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1829
				1830	def : Pat<(or (and (v16i8 VECREG:$rC), (v16i8 VECREG:$rA)),
				1831	(and (vnot (v16i8 VECREG:$rC)), (v16i8 VECREG:$rB))),
				1832	(SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1833
				1834	def : Pat<(or (and (v16i8 VECREG:$rA), (vnot (v16i8 VECREG:$rC))),
				1835	(and (v16i8 VECREG:$rB), (v16i8 VECREG:$rC))),
				1836	(SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1837
				1838	def : Pat<(or (and (v16i8 VECREG:$rA), (vnot (v16i8 VECREG:$rC))),
				1839	(and (v16i8 VECREG:$rC), (v16i8 VECREG:$rB))),
				1840	(SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1841
				1842	def : Pat<(or (and (vnot (v16i8 VECREG:$rC)), (v16i8 VECREG:$rA)),
				1843	(and (v16i8 VECREG:$rB), (v16i8 VECREG:$rC))),
				1844	(SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1845
				1846	def : Pat<(or (and (vnot (v16i8 VECREG:$rC)), (v16i8 VECREG:$rA)),
				1847	(and (v16i8 VECREG:$rC), (v16i8 VECREG:$rB))),
				1848	(SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1849
				1850	def SELBv8i16:
				1851	RRRForm<0b1000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
				1852	"selb\t$rT, $rA, $rB, $rC", IntegerOp,
				1853	[(set (v8i16 VECREG:$rT),
				1854	(SPUselb_v8i16 (v8i16 VECREG:$rA), (v8i16 VECREG:$rB),
				1855	(v8i16 VECREG:$rC)))]>;
				1856
				1857	def : Pat<(or (and (v8i16 VECREG:$rA), (v8i16 VECREG:$rC)),
				1858	(and (v8i16 VECREG:$rB), (vnot (v8i16 VECREG:$rC)))),
				1859	(SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1860
				1861	def : Pat<(or (and (v8i16 VECREG:$rC), (v8i16 VECREG:$rA)),
				1862	(and (v8i16 VECREG:$rB), (vnot (v8i16 VECREG:$rC)))),
				1863	(SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1864
				1865	def : Pat<(or (and (v8i16 VECREG:$rA), (v8i16 VECREG:$rC)),
				1866	(and (vnot (v8i16 VECREG:$rC)), (v8i16 VECREG:$rB))),
				1867	(SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1868
				1869	def : Pat<(or (and (v8i16 VECREG:$rC), (v8i16 VECREG:$rA)),
				1870	(and (vnot (v8i16 VECREG:$rC)), (v8i16 VECREG:$rB))),
				1871	(SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1872
				1873	def : Pat<(or (and (v8i16 VECREG:$rA), (vnot (v8i16 VECREG:$rC))),
				1874	(and (v8i16 VECREG:$rB), (v8i16 VECREG:$rC))),
				1875	(SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1876
				1877	def : Pat<(or (and (v8i16 VECREG:$rA), (vnot (v8i16 VECREG:$rC))),
				1878	(and (v8i16 VECREG:$rC), (v8i16 VECREG:$rB))),
				1879	(SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1880
				1881	def : Pat<(or (and (vnot (v8i16 VECREG:$rC)), (v8i16 VECREG:$rA)),
				1882	(and (v8i16 VECREG:$rB), (v8i16 VECREG:$rC))),
				1883	(SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1884
				1885	def : Pat<(or (and (vnot (v8i16 VECREG:$rC)), (v8i16 VECREG:$rA)),
				1886	(and (v8i16 VECREG:$rC), (v8i16 VECREG:$rB))),
				1887	(SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1888
				1889	def : Pat<(or (and (v8i16 VECREG:$rA), (v8i16 VECREG:$rC)),
				1890	(and (v8i16 VECREG:$rB), (vnot (v8i16 VECREG:$rC)))),
				1891	(SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1892
				1893	def : Pat<(or (and (v8i16 VECREG:$rC), (v8i16 VECREG:$rA)),
				1894	(and (v8i16 VECREG:$rB), (vnot (v8i16 VECREG:$rC)))),
				1895	(SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1896
				1897	def : Pat<(or (and (v8i16 VECREG:$rA), (v8i16 VECREG:$rC)),
				1898	(and (vnot (v8i16 VECREG:$rC)), (v8i16 VECREG:$rB))),
				1899	(SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1900
				1901	def : Pat<(or (and (v8i16 VECREG:$rC), (v8i16 VECREG:$rA)),
				1902	(and (vnot (v8i16 VECREG:$rC)), (v8i16 VECREG:$rB))),
				1903	(SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1904
				1905	def : Pat<(or (and (v8i16 VECREG:$rA), (vnot (v8i16 VECREG:$rC))),
				1906	(and (v8i16 VECREG:$rB), (v8i16 VECREG:$rC))),
				1907	(SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1908
				1909	def : Pat<(or (and (v8i16 VECREG:$rA), (vnot (v8i16 VECREG:$rC))),
				1910	(and (v8i16 VECREG:$rC), (v8i16 VECREG:$rB))),
				1911	(SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1912
				1913	def : Pat<(or (and (vnot (v8i16 VECREG:$rC)), (v8i16 VECREG:$rA)),
				1914	(and (v8i16 VECREG:$rB), (v8i16 VECREG:$rC))),
				1915	(SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1916
				1917	def : Pat<(or (and (vnot (v8i16 VECREG:$rC)), (v8i16 VECREG:$rA)),
				1918	(and (v8i16 VECREG:$rC), (v8i16 VECREG:$rB))),
				1919	(SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1920
				1921	def SELBv4i32:
				1922	RRRForm<0b1000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
				1923	"selb\t$rT, $rA, $rB, $rC", IntegerOp,
				1924	[(set (v4i32 VECREG:$rT),
				1925	(SPUselb_v4i32 (v4i32 VECREG:$rA), (v4i32 VECREG:$rB),
				1926	(v4i32 VECREG:$rC)))]>;
				1927
				1928	def : Pat<(or (and (v4i32 VECREG:$rA), (v4i32 VECREG:$rC)),
				1929	(and (v4i32 VECREG:$rB), (vnot (v4i32 VECREG:$rC)))),
				1930	(SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1931
				1932	def : Pat<(or (and (v4i32 VECREG:$rC), (v4i32 VECREG:$rA)),
				1933	(and (v4i32 VECREG:$rB), (vnot (v4i32 VECREG:$rC)))),
				1934	(SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1935
				1936	def : Pat<(or (and (v4i32 VECREG:$rA), (v4i32 VECREG:$rC)),
				1937	(and (vnot (v4i32 VECREG:$rC)), (v4i32 VECREG:$rB))),
				1938	(SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1939
				1940	def : Pat<(or (and (v4i32 VECREG:$rC), (v4i32 VECREG:$rA)),
				1941	(and (vnot (v4i32 VECREG:$rC)), (v4i32 VECREG:$rB))),
				1942	(SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1943
				1944	def : Pat<(or (and (v4i32 VECREG:$rA), (vnot (v4i32 VECREG:$rC))),
				1945	(and (v4i32 VECREG:$rB), (v4i32 VECREG:$rC))),
				1946	(SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1947
				1948	def : Pat<(or (and (v4i32 VECREG:$rA), (vnot (v4i32 VECREG:$rC))),
				1949	(and (v4i32 VECREG:$rC), (v4i32 VECREG:$rB))),
				1950	(SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1951
				1952	def : Pat<(or (and (vnot (v4i32 VECREG:$rC)), (v4i32 VECREG:$rA)),
				1953	(and (v4i32 VECREG:$rB), (v4i32 VECREG:$rC))),
				1954	(SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1955
				1956	def : Pat<(or (and (vnot (v4i32 VECREG:$rC)), (v4i32 VECREG:$rA)),
				1957	(and (v4i32 VECREG:$rC), (v4i32 VECREG:$rB))),
				1958	(SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1959
				1960	def : Pat<(or (and (v4i32 VECREG:$rA), (v4i32 VECREG:$rC)),
				1961	(and (v4i32 VECREG:$rB), (vnot (v4i32 VECREG:$rC)))),
				1962	(SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1963
				1964	def : Pat<(or (and (v4i32 VECREG:$rC), (v4i32 VECREG:$rA)),
				1965	(and (v4i32 VECREG:$rB), (vnot (v4i32 VECREG:$rC)))),
				1966	(SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1967
				1968	def : Pat<(or (and (v4i32 VECREG:$rA), (v4i32 VECREG:$rC)),
				1969	(and (vnot (v4i32 VECREG:$rC)), (v4i32 VECREG:$rB))),
				1970	(SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1971
				1972	def : Pat<(or (and (v4i32 VECREG:$rC), (v4i32 VECREG:$rA)),
				1973	(and (vnot (v4i32 VECREG:$rC)), (v4i32 VECREG:$rB))),
				1974	(SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1975
				1976	def : Pat<(or (and (v4i32 VECREG:$rA), (vnot (v4i32 VECREG:$rC))),
				1977	(and (v4i32 VECREG:$rB), (v4i32 VECREG:$rC))),
				1978	(SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1979
				1980	def : Pat<(or (and (v4i32 VECREG:$rA), (vnot (v4i32 VECREG:$rC))),
				1981	(and (v4i32 VECREG:$rC), (v4i32 VECREG:$rB))),
				1982	(SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1983
				1984	def : Pat<(or (and (vnot (v4i32 VECREG:$rC)), (v4i32 VECREG:$rA)),
				1985	(and (v4i32 VECREG:$rB), (v4i32 VECREG:$rC))),
				1986	(SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1987
				1988	def : Pat<(or (and (vnot (v4i32 VECREG:$rC)), (v4i32 VECREG:$rA)),
				1989	(and (v4i32 VECREG:$rC), (v4i32 VECREG:$rB))),
				1990	(SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				1991
				1992	def SELBr32:
				1993	RRRForm<0b1000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB, R32C:$rC),
				1994	"selb\t$rT, $rA, $rB, $rC", IntegerOp,
				1995	[]>;
				1996
				1997	// And the various patterns that can be matched... (all 8 of them :-)
				1998	def : Pat<(or (and R32C:$rA, R32C:$rC),
				1999	(and R32C:$rB, (not R32C:$rC))),
				2000	(SELBr32 R32C:$rA, R32C:$rB, R32C:$rC)>;
				2001
				2002	def : Pat<(or (and R32C:$rC, R32C:$rA),
				2003	(and R32C:$rB, (not R32C:$rC))),
				2004	(SELBr32 R32C:$rA, R32C:$rB, R32C:$rC)>;
				2005
				2006	def : Pat<(or (and R32C:$rA, R32C:$rC),
				2007	(and (not R32C:$rC), R32C:$rB)),
				2008	(SELBr32 R32C:$rA, R32C:$rB, R32C:$rC)>;
				2009
				2010	def : Pat<(or (and R32C:$rC, R32C:$rA),
				2011	(and (not R32C:$rC), R32C:$rB)),
				2012	(SELBr32 R32C:$rA, R32C:$rB, R32C:$rC)>;
				2013
				2014	def : Pat<(or (and R32C:$rA, (not R32C:$rC)),
				2015	(and R32C:$rB, R32C:$rC)),
				2016	(SELBr32 R32C:$rA, R32C:$rB, R32C:$rC)>;
				2017
				2018	def : Pat<(or (and R32C:$rA, (not R32C:$rC)),
				2019	(and R32C:$rC, R32C:$rB)),
				2020	(SELBr32 R32C:$rA, R32C:$rB, R32C:$rC)>;
				2021
				2022	def : Pat<(or (and (not R32C:$rC), R32C:$rA),
				2023	(and R32C:$rB, R32C:$rC)),
				2024	(SELBr32 R32C:$rA, R32C:$rB, R32C:$rC)>;
				2025
				2026	def : Pat<(or (and (not R32C:$rC), R32C:$rA),
				2027	(and R32C:$rC, R32C:$rB)),
				2028	(SELBr32 R32C:$rA, R32C:$rB, R32C:$rC)>;
				2029
				2030	def SELBr16:
				2031	RRRForm<0b1000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB, R16C:$rC),
				2032	"selb\t$rT, $rA, $rB, $rC", IntegerOp,
				2033	[]>;
				2034
				2035	def : Pat<(or (and R16C:$rA, R16C:$rC),
				2036	(and R16C:$rB, (not R16C:$rC))),
				2037	(SELBr16 R16C:$rA, R16C:$rB, R16C:$rC)>;
				2038
				2039	def : Pat<(or (and R16C:$rC, R16C:$rA),
				2040	(and R16C:$rB, (not R16C:$rC))),
				2041	(SELBr16 R16C:$rA, R16C:$rB, R16C:$rC)>;
				2042
				2043	def : Pat<(or (and R16C:$rA, R16C:$rC),
				2044	(and (not R16C:$rC), R16C:$rB)),
				2045	(SELBr16 R16C:$rA, R16C:$rB, R16C:$rC)>;
				2046
				2047	def : Pat<(or (and R16C:$rC, R16C:$rA),
				2048	(and (not R16C:$rC), R16C:$rB)),
				2049	(SELBr16 R16C:$rA, R16C:$rB, R16C:$rC)>;
				2050
				2051	def : Pat<(or (and R16C:$rA, (not R16C:$rC)),
				2052	(and R16C:$rB, R16C:$rC)),
				2053	(SELBr16 R16C:$rA, R16C:$rB, R16C:$rC)>;
				2054
				2055	def : Pat<(or (and R16C:$rA, (not R16C:$rC)),
				2056	(and R16C:$rC, R16C:$rB)),
				2057	(SELBr16 R16C:$rA, R16C:$rB, R16C:$rC)>;
				2058
				2059	def : Pat<(or (and (not R16C:$rC), R16C:$rA),
				2060	(and R16C:$rB, R16C:$rC)),
				2061	(SELBr16 R16C:$rA, R16C:$rB, R16C:$rC)>;
				2062
				2063	def : Pat<(or (and (not R16C:$rC), R16C:$rA),
				2064	(and R16C:$rC, R16C:$rB)),
				2065	(SELBr16 R16C:$rA, R16C:$rB, R16C:$rC)>;
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2066
				2067	def SELBr8:
				2068	RRRForm<0b1000, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB, R8C:$rC),
				2069	"selb\t$rT, $rA, $rB, $rC", IntegerOp,
				2070	[]>;
				2071
				2072	def : Pat<(or (and R8C:$rA, R8C:$rC),
				2073	(and R8C:$rB, (not R8C:$rC))),
				2074	(SELBr8 R8C:$rA, R8C:$rB, R8C:$rC)>;
				2075
				2076	def : Pat<(or (and R8C:$rC, R8C:$rA),
				2077	(and R8C:$rB, (not R8C:$rC))),
				2078	(SELBr8 R8C:$rA, R8C:$rB, R8C:$rC)>;
				2079
				2080	def : Pat<(or (and R8C:$rA, R8C:$rC),
				2081	(and (not R8C:$rC), R8C:$rB)),
				2082	(SELBr8 R8C:$rA, R8C:$rB, R8C:$rC)>;
				2083
				2084	def : Pat<(or (and R8C:$rC, R8C:$rA),
				2085	(and (not R8C:$rC), R8C:$rB)),
				2086	(SELBr8 R8C:$rA, R8C:$rB, R8C:$rC)>;
				2087
				2088	def : Pat<(or (and R8C:$rA, (not R8C:$rC)),
				2089	(and R8C:$rB, R8C:$rC)),
				2090	(SELBr8 R8C:$rA, R8C:$rB, R8C:$rC)>;
				2091
				2092	def : Pat<(or (and R8C:$rA, (not R8C:$rC)),
				2093	(and R8C:$rC, R8C:$rB)),
				2094	(SELBr8 R8C:$rA, R8C:$rB, R8C:$rC)>;
				2095
				2096	def : Pat<(or (and (not R8C:$rC), R8C:$rA),
				2097	(and R8C:$rB, R8C:$rC)),
				2098	(SELBr8 R8C:$rA, R8C:$rB, R8C:$rC)>;
				2099
				2100	def : Pat<(or (and (not R8C:$rC), R8C:$rA),
				2101	(and R8C:$rC, R8C:$rB)),
				2102	(SELBr8 R8C:$rA, R8C:$rB, R8C:$rC)>;
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2103
				2104	//===----------------------------------------------------------------------===//
				2105	// Vector shuffle...
				2106	//===----------------------------------------------------------------------===//
				2107
				2108	def SHUFB:
				2109	RRRForm<0b1000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
				2110	"shufb\t$rT, $rA, $rB, $rC", IntegerOp,
				2111	[/* insert intrinsic here */]>;
				2112
				2113	// SPUshuffle is generated in LowerVECTOR_SHUFFLE and gets replaced with SHUFB.
				2114	// See the SPUshuffle SDNode operand above, which sets up the DAG pattern
				2115	// matcher to emit something when the LowerVECTOR_SHUFFLE generates a node with
				2116	// the SPUISD::SHUFB opcode.
				2117	def : Pat<(SPUshuffle (v16i8 VECREG:$rA), (v16i8 VECREG:$rB), VECREG:$rC),
				2118	(SHUFB VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				2119
				2120	def : Pat<(SPUshuffle (v8i16 VECREG:$rA), (v8i16 VECREG:$rB), VECREG:$rC),
				2121	(SHUFB VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				2122
				2123	def : Pat<(SPUshuffle (v4i32 VECREG:$rA), (v4i32 VECREG:$rB), VECREG:$rC),
				2124	(SHUFB VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				2125
				2126	def : Pat<(SPUshuffle (v2i64 VECREG:$rA), (v2i64 VECREG:$rB), VECREG:$rC),
				2127	(SHUFB VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				2128
				2129	//===----------------------------------------------------------------------===//
				2130	// Shift and rotate group:
				2131	//===----------------------------------------------------------------------===//
				2132
				2133	def SHLHv8i16:
				2134	RRForm<0b11111010000, (outs VECREG:$rT), (ins VECREG:$rA, R16C:$rB),
				2135	"shlh\t$rT, $rA, $rB", RotateShift,
				2136	[(set (v8i16 VECREG:$rT),
				2137	(SPUvec_shl_v8i16 (v8i16 VECREG:$rA), R16C:$rB))]>;
				2138
				2139	// $rB gets promoted to 32-bit register type when confronted with
				2140	// this llvm assembly code:
				2141	//
				2142	// define i16 @shlh_i16_1(i16 %arg1, i16 %arg2) {
				2143	// %A = shl i16 %arg1, %arg2
				2144	// ret i16 %A
				2145	// }
				2146	//
				2147	// However, we will generate this code when lowering 8-bit shifts and rotates.
				2148
				2149	def SHLHr16:
				2150	RRForm<0b11111010000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
				2151	"shlh\t$rT, $rA, $rB", RotateShift,
				2152	[(set R16C:$rT, (shl R16C:$rA, R16C:$rB))]>;
				2153
				2154	def SHLHr16_r32:
				2155	RRForm<0b11111010000, (outs R16C:$rT), (ins R16C:$rA, R32C:$rB),
				2156	"shlh\t$rT, $rA, $rB", RotateShift,
				2157	[(set R16C:$rT, (shl R16C:$rA, R32C:$rB))]>;
				2158
				2159	def SHLHIv8i16:
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2160	RI7Form<0b11111010000, (outs VECREG:$rT), (ins VECREG:$rA, u7imm_i8:$val),
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2161	"shlhi\t$rT, $rA, $val", RotateShift,
				2162	[(set (v8i16 VECREG:$rT),
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2163	(SPUvec_shl_v8i16 (v8i16 VECREG:$rA), (i8 uimm7:$val)))]>;
				2164
				2165	def : Pat<(SPUvec_shl_v8i16 (v8i16 VECREG:$rA), (i16 uimm7:$val)),
				2166	(SHLHIv8i16 VECREG:$rA, imm:$val)>;
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2167
				2168	def : Pat<(SPUvec_shl_v8i16 (v8i16 VECREG:$rA), (i32 uimm7:$val)),
				2169	(SHLHIv8i16 VECREG:$rA, imm:$val)>;
				2170
				2171	def SHLHIr16:
				2172	RI7Form<0b11111010000, (outs R16C:$rT), (ins R16C:$rA, u7imm_i32:$val),
				2173	"shlhi\t$rT, $rA, $val", RotateShift,
				2174	[(set R16C:$rT, (shl R16C:$rA, (i32 uimm7:$val)))]>;
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2175
				2176	def : Pat<(shl R16C:$rA, (i8 uimm7:$val)),
				2177	(SHLHIr16 R16C:$rA, uimm7:$val)>;
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2178
				2179	def : Pat<(shl R16C:$rA, (i16 uimm7:$val)),
				2180	(SHLHIr16 R16C:$rA, uimm7:$val)>;
				2181
				2182	def SHLv4i32:
				2183	RRForm<0b11111010000, (outs VECREG:$rT), (ins VECREG:$rA, R16C:$rB),
				2184	"shl\t$rT, $rA, $rB", RotateShift,
				2185	[(set (v4i32 VECREG:$rT),
				2186	(SPUvec_shl_v4i32 (v4i32 VECREG:$rA), R16C:$rB))]>;
				2187
				2188	def SHLr32:
				2189	RRForm<0b11111010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				2190	"shl\t$rT, $rA, $rB", RotateShift,
				2191	[(set R32C:$rT, (shl R32C:$rA, R32C:$rB))]>;
				2192
				2193	def SHLIv4i32:
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2194	RI7Form<0b11111010000, (outs VECREG:$rT), (ins VECREG:$rA, u7imm_i8:$val),
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2195	"shli\t$rT, $rA, $val", RotateShift,
				2196	[(set (v4i32 VECREG:$rT),
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2197	(SPUvec_shl_v4i32 (v4i32 VECREG:$rA), (i8 uimm7:$val)))]>;
				2198
				2199	def: Pat<(SPUvec_shl_v4i32 (v4i32 VECREG:$rA), (i16 uimm7:$val)),
				2200	(SHLIv4i32 VECREG:$rA, uimm7:$val)>;
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2201
				2202	def: Pat<(SPUvec_shl_v4i32 (v4i32 VECREG:$rA), (i32 uimm7:$val)),
				2203	(SHLIv4i32 VECREG:$rA, uimm7:$val)>;
				2204
				2205	def SHLIr32:
				2206	RI7Form<0b11111010000, (outs R32C:$rT), (ins R32C:$rA, u7imm_i32:$val),
				2207	"shli\t$rT, $rA, $val", RotateShift,
				2208	[(set R32C:$rT, (shl R32C:$rA, (i32 uimm7:$val)))]>;
				2209
				2210	def : Pat<(shl R32C:$rA, (i16 uimm7:$val)),
				2211	(SHLIr32 R32C:$rA, uimm7:$val)>;
				2212
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2213	def : Pat<(shl R32C:$rA, (i8 uimm7:$val)),
				2214	(SHLIr32 R32C:$rA, uimm7:$val)>;
				2215
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2216	// SHLQBI vec form: Note that this will shift the entire vector (the 128-bit
				2217	// register) to the left. Vector form is here to ensure type correctness.
				2218	def SHLQBIvec:
				2219	RRForm<0b11011011100, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				2220	"shlqbi\t$rT, $rA, $rB", RotateShift,
				2221	[/* intrinsic */]>;
				2222
				2223	// See note above on SHLQBI.
				2224	def SHLQBIIvec:
				2225	RI7Form<0b11011111100, (outs VECREG:$rT), (ins VECREG:$rA, u7imm:$val),
				2226	"shlqbii\t$rT, $rA, $val", RotateShift,
				2227	[/* intrinsic */]>;
				2228
				2229	// SHLQBY, SHLQBYI vector forms: Shift the entire vector to the left by bytes,
				2230	// not by bits.
				2231	def SHLQBYvec:
				2232	RI7Form<0b11111011100, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				2233	"shlqbyi\t$rT, $rA, $rB", RotateShift,
				2234	[/* intrinsic */]>;
				2235
				2236	def SHLQBYIvec:
				2237	RI7Form<0b11111111100, (outs VECREG:$rT), (ins VECREG:$rA, u7imm:$val),
				2238	"shlqbyi\t$rT, $rA, $val", RotateShift,
				2239	[/* intrinsic */]>;
				2240
				2241	// ROTH v8i16 form:
				2242	def ROTHv8i16:
				2243	RRForm<0b00111010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				2244	"roth\t$rT, $rA, $rB", RotateShift,
				2245	[(set (v8i16 VECREG:$rT),
				2246	(SPUvec_rotl_v8i16 VECREG:$rA, VECREG:$rB))]>;
				2247
				2248	def ROTHr16:
				2249	RRForm<0b00111010000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
				2250	"roth\t$rT, $rA, $rB", RotateShift,
				2251	[(set R16C:$rT, (rotl R16C:$rA, R16C:$rB))]>;
				2252
				2253	def ROTHr16_r32:
				2254	RRForm<0b00111010000, (outs R16C:$rT), (ins R16C:$rA, R32C:$rB),
				2255	"roth\t$rT, $rA, $rB", RotateShift,
				2256	[(set R16C:$rT, (rotl R16C:$rA, R32C:$rB))]>;
				2257
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2258	// The rotate amount is in the same bits whether we've got an 8-bit, 16-bit or
				2259	// 32-bit register
				2260	def ROTHr16_r8:
				2261	RRForm<0b00111010000, (outs R16C:$rT), (ins R16C:$rA, R8C:$rB),
				2262	"roth\t$rT, $rA, $rB", RotateShift,
				2263	[(set R16C:$rT, (rotl R16C:$rA, (i32 (zext R8C:$rB))))]>;
				2264
				2265	def : Pat<(rotl R16C:$rA, (i32 (sext R8C:$rB))),
				2266	(ROTHr16_r8 R16C:$rA, R8C:$rB)>;
				2267
				2268	def : Pat<(rotl R16C:$rA, (i32 (zext R8C:$rB))),
				2269	(ROTHr16_r8 R16C:$rA, R8C:$rB)>;
				2270
				2271	def : Pat<(rotl R16C:$rA, (i32 (anyext R8C:$rB))),
				2272	(ROTHr16_r8 R16C:$rA, R8C:$rB)>;
				2273
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2274	def ROTHIv8i16:
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2275	RI7Form<0b00111110000, (outs VECREG:$rT), (ins VECREG:$rA, u7imm_i8:$val),
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2276	"rothi\t$rT, $rA, $val", RotateShift,
				2277	[(set (v8i16 VECREG:$rT),
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2278	(SPUvec_rotl_v8i16 VECREG:$rA, (i8 uimm7:$val)))]>;
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2279
				2280	def : Pat<(SPUvec_rotl_v8i16 VECREG:$rA, (i16 uimm7:$val)),
				2281	(ROTHIv8i16 VECREG:$rA, imm:$val)>;
				2282
				2283	def : Pat<(SPUvec_rotl_v8i16 VECREG:$rA, (i32 uimm7:$val)),
				2284	(ROTHIv8i16 VECREG:$rA, imm:$val)>;
				2285
				2286	def ROTHIr16:
				2287	RI7Form<0b00111110000, (outs R16C:$rT), (ins R16C:$rA, u7imm:$val),
				2288	"rothi\t$rT, $rA, $val", RotateShift,
				2289	[(set R16C:$rT, (rotl R16C:$rA, (i16 uimm7:$val)))]>;
				2290
				2291	def ROTHIr16_i32:
				2292	RI7Form<0b00111110000, (outs R16C:$rT), (ins R16C:$rA, u7imm_i32:$val),
				2293	"rothi\t$rT, $rA, $val", RotateShift,
				2294	[(set R16C:$rT, (rotl R16C:$rA, (i32 uimm7:$val)))]>;
				2295
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2296	def ROTHIr16_i8:
				2297	RI7Form<0b00111110000, (outs R16C:$rT), (ins R16C:$rA, u7imm_i8:$val),
				2298	"rothi\t$rT, $rA, $val", RotateShift,
				2299	[(set R16C:$rT, (rotl R16C:$rA, (i8 uimm7:$val)))]>;
				2300
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2301	def ROTv4i32:
				2302	RRForm<0b00011010000, (outs VECREG:$rT), (ins VECREG:$rA, R32C:$rB),
				2303	"rot\t$rT, $rA, $rB", RotateShift,
				2304	[(set (v4i32 VECREG:$rT),
				2305	(SPUvec_rotl_v4i32 (v4i32 VECREG:$rA), R32C:$rB))]>;
				2306
				2307	def ROTr32:
				2308	RRForm<0b00011010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				2309	"rot\t$rT, $rA, $rB", RotateShift,
				2310	[(set R32C:$rT, (rotl R32C:$rA, R32C:$rB))]>;
				2311
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2312	// The rotate amount is in the same bits whether we've got an 8-bit, 16-bit or
				2313	// 32-bit register
				2314	def ROTr32_r16_anyext:
				2315	RRForm<0b00011010000, (outs R32C:$rT), (ins R32C:$rA, R16C:$rB),
				2316	"rot\t$rT, $rA, $rB", RotateShift,
				2317	[(set R32C:$rT, (rotl R32C:$rA, (i32 (anyext R16C:$rB))))]>;
				2318
				2319	def : Pat<(rotl R32C:$rA, (i32 (zext R16C:$rB))),
				2320	(ROTr32_r16_anyext R32C:$rA, R16C:$rB)>;
				2321
				2322	def : Pat<(rotl R32C:$rA, (i32 (sext R16C:$rB))),
				2323	(ROTr32_r16_anyext R32C:$rA, R16C:$rB)>;
				2324
				2325	def ROTr32_r8_anyext:
				2326	RRForm<0b00011010000, (outs R32C:$rT), (ins R32C:$rA, R8C:$rB),
				2327	"rot\t$rT, $rA, $rB", RotateShift,
				2328	[(set R32C:$rT, (rotl R32C:$rA, (i32 (anyext R8C:$rB))))]>;
				2329
				2330	def : Pat<(rotl R32C:$rA, (i32 (zext R8C:$rB))),
				2331	(ROTr32_r8_anyext R32C:$rA, R8C:$rB)>;
				2332
				2333	def : Pat<(rotl R32C:$rA, (i32 (sext R8C:$rB))),
				2334	(ROTr32_r8_anyext R32C:$rA, R8C:$rB)>;
				2335
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2336	def ROTIv4i32:
				2337	RI7Form<0b00011110000, (outs VECREG:$rT), (ins VECREG:$rA, u7imm_i32:$val),
				2338	"roti\t$rT, $rA, $val", RotateShift,
				2339	[(set (v4i32 VECREG:$rT),
				2340	(SPUvec_rotl_v4i32 (v4i32 VECREG:$rA), (i32 uimm7:$val)))]>;
				2341
				2342	def : Pat<(SPUvec_rotl_v4i32 (v4i32 VECREG:$rA), (i16 uimm7:$val)),
				2343	(ROTIv4i32 VECREG:$rA, imm:$val)>;
				2344
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2345	def : Pat<(SPUvec_rotl_v4i32 (v4i32 VECREG:$rA), (i8 uimm7:$val)),
				2346	(ROTIv4i32 VECREG:$rA, imm:$val)>;
				2347
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2348	def ROTIr32:
				2349	RI7Form<0b00011110000, (outs R32C:$rT), (ins R32C:$rA, u7imm_i32:$val),
				2350	"roti\t$rT, $rA, $val", RotateShift,
				2351	[(set R32C:$rT, (rotl R32C:$rA, (i32 uimm7:$val)))]>;
				2352
				2353	def ROTIr32_i16:
				2354	RI7Form<0b00111110000, (outs R32C:$rT), (ins R32C:$rA, u7imm:$val),
				2355	"roti\t$rT, $rA, $val", RotateShift,
				2356	[(set R32C:$rT, (rotl R32C:$rA, (i16 uimm7:$val)))]>;
				2357
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2358	def ROTIr32_i8:
				2359	RI7Form<0b00111110000, (outs R32C:$rT), (ins R32C:$rA, u7imm_i8:$val),
				2360	"roti\t$rT, $rA, $val", RotateShift,
				2361	[(set R32C:$rT, (rotl R32C:$rA, (i8 uimm7:$val)))]>;
				2362
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2363	// ROTQBY* vector forms: This rotates the entire vector, but vector registers
				2364	// are used here for type checking (instances where ROTQBI is used actually
				2365	// use vector registers)
				2366	def ROTQBYvec:
				2367	RRForm<0b00111011100, (outs VECREG:$rT), (ins VECREG:$rA, R16C:$rB),
				2368	"rotqby\t$rT, $rA, $rB", RotateShift,
				2369	[(set (v16i8 VECREG:$rT), (SPUrotbytes_left (v16i8 VECREG:$rA), R16C:$rB))]>;
				2370
				2371	def : Pat<(SPUrotbytes_left_chained (v16i8 VECREG:$rA), R16C:$rB),
				2372	(ROTQBYvec VECREG:$rA, R16C:$rB)>;
				2373
				2374	// See ROTQBY note above.
				2375	def ROTQBYIvec:
				2376	RI7Form<0b00111111100, (outs VECREG:$rT), (ins VECREG:$rA, u7imm:$val),
				2377	"rotqbyi\t$rT, $rA, $val", RotateShift,
				2378	[(set (v16i8 VECREG:$rT),
				2379	(SPUrotbytes_left (v16i8 VECREG:$rA), (i16 uimm7:$val)))]>;
				2380
				2381	def : Pat<(SPUrotbytes_left_chained (v16i8 VECREG:$rA), (i16 uimm7:$val)),
				2382	(ROTQBYIvec VECREG:$rA, uimm7:$val)>;
				2383
				2384	// See ROTQBY note above.
				2385	def ROTQBYBIvec:
				2386	RI7Form<0b00110011100, (outs VECREG:$rT), (ins VECREG:$rA, u7imm:$val),
				2387	"rotqbybi\t$rT, $rA, $val", RotateShift,
				2388	[/* intrinsic */]>;
				2389
				2390	// See ROTQBY note above.
				2391	//
				2392	// Assume that the user of this instruction knows to shift the rotate count
				2393	// into bit 29
				2394	def ROTQBIvec:
				2395	RRForm<0b00011011100, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				2396	"rotqbi\t$rT, $rA, $rB", RotateShift,
				2397	[/* insert intrinsic here */]>;
				2398
				2399	// See ROTQBY note above.
				2400	def ROTQBIIvec:
				2401	RI7Form<0b00011111100, (outs VECREG:$rT), (ins VECREG:$rA, u7imm_i32:$val),
				2402	"rotqbii\t$rT, $rA, $val", RotateShift,
				2403	[/* insert intrinsic here */]>;
				2404
				2405	// ROTHM v8i16 form:
				2406	// NOTE(1): No vector rotate is generated by the C/C++ frontend (today),
				2407	// so this only matches a synthetically generated/lowered code
				2408	// fragment.
				2409	// NOTE(2): $rB must be negated before the right rotate!
				2410	def ROTHMv8i16:
				2411	RRForm<0b10111010000, (outs VECREG:$rT), (ins VECREG:$rA, R32C:$rB),
				2412	"rothm\t$rT, $rA, $rB", RotateShift,
				2413	[/* see patterns below - $rB must be negated */]>;
				2414
				2415	def : Pat<(SPUvec_srl_v8i16 (v8i16 VECREG:$rA), R32C:$rB),
				2416	(ROTHMv8i16 VECREG:$rA, (SFIr32 R32C:$rB, 0))>;
				2417
				2418	def : Pat<(SPUvec_srl_v8i16 (v8i16 VECREG:$rA), R16C:$rB),
				2419	(ROTHMv8i16 VECREG:$rA,
				2420	(SFIr32 (XSHWr16 R16C:$rB), 0))>;
				2421
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2422	def : Pat<(SPUvec_srl_v8i16 (v8i16 VECREG:$rA), R8C:$rB),
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2423	(ROTHMv8i16 VECREG:$rA,
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2424	(SFIr32 (XSHWr16 (XSBHr8 R8C:$rB) ), 0))>;
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2425
				2426	// ROTHM r16 form: Rotate 16-bit quantity to right, zero fill at the left
				2427	// Note: This instruction doesn't match a pattern because rB must be negated
				2428	// for the instruction to work. Thus, the pattern below the instruction!
				2429	def ROTHMr16:
				2430	RRForm<0b10111010000, (outs R16C:$rT), (ins R16C:$rA, R32C:$rB),
				2431	"rothm\t$rT, $rA, $rB", RotateShift,
				2432	[/* see patterns below - $rB must be negated! */]>;
				2433
				2434	def : Pat<(srl R16C:$rA, R32C:$rB),
				2435	(ROTHMr16 R16C:$rA, (SFIr32 R32C:$rB, 0))>;
				2436
				2437	def : Pat<(srl R16C:$rA, R16C:$rB),
				2438	(ROTHMr16 R16C:$rA,
				2439	(SFIr32 (XSHWr16 R16C:$rB), 0))>;
				2440
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2441	def : Pat<(srl R16C:$rA, R8C:$rB),
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2442	(ROTHMr16 R16C:$rA,
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2443	(SFIr32 (XSHWr16 (XSBHr8 R8C:$rB) ), 0))>;
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2444
				2445	// ROTHMI v8i16 form: See the comment for ROTHM v8i16. The difference here is
				2446	// that the immediate can be complemented, so that the user doesn't have to
				2447	// worry about it.
				2448	def ROTHMIv8i16:
				2449	RI7Form<0b10111110000, (outs VECREG:$rT), (ins VECREG:$rA, rothNeg7imm:$val),
				2450	"rothmi\t$rT, $rA, $val", RotateShift,
				2451	[(set (v8i16 VECREG:$rT),
				2452	(SPUvec_srl_v8i16 (v8i16 VECREG:$rA), (i32 imm:$val)))]>;
				2453
				2454	def: Pat<(SPUvec_srl_v8i16 (v8i16 VECREG:$rA), (i16 imm:$val)),
				2455	(ROTHMIv8i16 VECREG:$rA, imm:$val)>;
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2456
				2457	def: Pat<(SPUvec_srl_v8i16 (v8i16 VECREG:$rA), (i8 imm:$val)),
				2458	(ROTHMIv8i16 VECREG:$rA, imm:$val)>;
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2459
				2460	def ROTHMIr16:
				2461	RI7Form<0b10111110000, (outs R16C:$rT), (ins R16C:$rA, rothNeg7imm:$val),
				2462	"rothmi\t$rT, $rA, $val", RotateShift,
				2463	[(set R16C:$rT, (srl R16C:$rA, (i32 uimm7:$val)))]>;
				2464
				2465	def: Pat<(srl R16C:$rA, (i16 uimm7:$val)),
				2466	(ROTHMIr16 R16C:$rA, uimm7:$val)>;
				2467
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2468	def: Pat<(srl R16C:$rA, (i8 uimm7:$val)),
				2469	(ROTHMIr16 R16C:$rA, uimm7:$val)>;
				2470
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2471	// ROTM v4i32 form: See the ROTHM v8i16 comments.
				2472	def ROTMv4i32:
				2473	RRForm<0b10011010000, (outs VECREG:$rT), (ins VECREG:$rA, R32C:$rB),
				2474	"rotm\t$rT, $rA, $rB", RotateShift,
				2475	[/* see patterns below - $rB must be negated */]>;
				2476
				2477	def : Pat<(SPUvec_srl_v4i32 VECREG:$rA, R32C:$rB),
				2478	(ROTMv4i32 VECREG:$rA, (SFIr32 R32C:$rB, 0))>;
				2479
				2480	def : Pat<(SPUvec_srl_v4i32 VECREG:$rA, R16C:$rB),
				2481	(ROTMv4i32 VECREG:$rA,
				2482	(SFIr32 (XSHWr16 R16C:$rB), 0))>;
				2483
				2484	def : Pat<(SPUvec_srl_v4i32 VECREG:$rA, /* R8C */ R16C:$rB),
				2485	(ROTMv4i32 VECREG:$rA,
				2486	(SFIr32 (XSHWr16 /* (XSBHr8 R8C / R16C:$rB) /)*/, 0))>;
				2487
				2488	def ROTMr32:
				2489	RRForm<0b10011010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				2490	"rotm\t$rT, $rA, $rB", RotateShift,
				2491	[/* see patterns below - $rB must be negated */]>;
				2492
				2493	def : Pat<(srl R32C:$rA, R32C:$rB),
				2494	(ROTMr32 R32C:$rA, (SFIr32 R32C:$rB, 0))>;
				2495
				2496	def : Pat<(srl R32C:$rA, R16C:$rB),
				2497	(ROTMr32 R32C:$rA,
				2498	(SFIr32 (XSHWr16 R16C:$rB), 0))>;
				2499
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2500	def : Pat<(srl R32C:$rA, R8C:$rB),
				2501	(ROTMr32 R32C:$rA,
				2502	(SFIr32 (XSHWr16 (XSBHr8 R8C:$rB)), 0))>;
				2503
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2504	// ROTMI v4i32 form: See the comment for ROTHM v8i16.
				2505	def ROTMIv4i32:
				2506	RI7Form<0b10011110000, (outs VECREG:$rT), (ins VECREG:$rA, rotNeg7imm:$val),
				2507	"rotmi\t$rT, $rA, $val", RotateShift,
				2508	[(set (v4i32 VECREG:$rT),
				2509	(SPUvec_srl_v4i32 VECREG:$rA, (i32 uimm7:$val)))]>;
				2510
				2511	def : Pat<(SPUvec_srl_v4i32 VECREG:$rA, (i16 uimm7:$val)),
				2512	(ROTMIv4i32 VECREG:$rA, uimm7:$val)>;
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2513
				2514	def : Pat<(SPUvec_srl_v4i32 VECREG:$rA, (i8 uimm7:$val)),
				2515	(ROTMIv4i32 VECREG:$rA, uimm7:$val)>;
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2516
				2517	// ROTMI r32 form: know how to complement the immediate value.
				2518	def ROTMIr32:
				2519	RI7Form<0b10011110000, (outs R32C:$rT), (ins R32C:$rA, rotNeg7imm:$val),
				2520	"rotmi\t$rT, $rA, $val", RotateShift,
				2521	[(set R32C:$rT, (srl R32C:$rA, (i32 uimm7:$val)))]>;
				2522
				2523	def : Pat<(srl R32C:$rA, (i16 imm:$val)),
				2524	(ROTMIr32 R32C:$rA, uimm7:$val)>;
				2525
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2526	def : Pat<(srl R32C:$rA, (i8 imm:$val)),
				2527	(ROTMIr32 R32C:$rA, uimm7:$val)>;
				2528
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2529	// ROTQMBYvec: This is a vector form merely so that when used in an
				2530	// instruction pattern, type checking will succeed. This instruction assumes
				2531	// that the user knew to complement $rB.
				2532	def ROTQMBYvec:
				2533	RRForm<0b10111011100, (outs VECREG:$rT), (ins VECREG:$rA, R32C:$rB),
				2534	"rotqmby\t$rT, $rA, $rB", RotateShift,
				2535	[(set (v16i8 VECREG:$rT),
				2536	(SPUrotbytes_right_zfill (v16i8 VECREG:$rA), R32C:$rB))]>;
				2537
				2538	def ROTQMBYIvec:
				2539	RI7Form<0b10111111100, (outs VECREG:$rT), (ins VECREG:$rA, rotNeg7imm:$val),
				2540	"rotqmbyi\t$rT, $rA, $val", RotateShift,
				2541	[(set (v16i8 VECREG:$rT),
				2542	(SPUrotbytes_right_zfill (v16i8 VECREG:$rA), (i32 uimm7:$val)))]>;
				2543
				2544	def : Pat<(SPUrotbytes_right_zfill VECREG:$rA, (i16 uimm7:$val)),
				2545	(ROTQMBYIvec VECREG:$rA, uimm7:$val)>;
				2546
				2547	def ROTQMBYBIvec:
				2548	RRForm<0b10110011100, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				2549	"rotqmbybi\t$rT, $rA, $rB", RotateShift,
				2550	[/* intrinsic */]>;
				2551
				2552	def ROTQMBIvec:
				2553	RRForm<0b10011011100, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				2554	"rotqmbi\t$rT, $rA, $rB", RotateShift,
				2555	[/* intrinsic */]>;
				2556
				2557	def ROTQMBIIvec:
				2558	RI7Form<0b10011111100, (outs VECREG:$rT), (ins VECREG:$rA, rotNeg7imm:$val),
				2559	"rotqmbii\t$rT, $rA, $val", RotateShift,
				2560	[/* intrinsic */]>;
				2561
				2562	def ROTMAHv8i16:
				2563	RRForm<0b01111010000, (outs VECREG:$rT), (ins VECREG:$rA, R32C:$rB),
				2564	"rotmah\t$rT, $rA, $rB", RotateShift,
				2565	[/* see patterns below - $rB must be negated */]>;
				2566
				2567	def : Pat<(SPUvec_sra_v8i16 VECREG:$rA, R32C:$rB),
				2568	(ROTMAHv8i16 VECREG:$rA, (SFIr32 R32C:$rB, 0))>;
				2569
				2570	def : Pat<(SPUvec_sra_v8i16 VECREG:$rA, R16C:$rB),
				2571	(ROTMAHv8i16 VECREG:$rA,
				2572	(SFIr32 (XSHWr16 R16C:$rB), 0))>;
				2573
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2574	def : Pat<(SPUvec_sra_v8i16 VECREG:$rA, R8C:$rB),
				2575	(ROTMAHv8i16 VECREG:$rA,
				2576	(SFIr32 (XSHWr16 (XSBHr8 R8C:$rB)), 0))>;
				2577
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2578	def ROTMAHr16:
				2579	RRForm<0b01111010000, (outs R16C:$rT), (ins R16C:$rA, R32C:$rB),
				2580	"rotmah\t$rT, $rA, $rB", RotateShift,
				2581	[/* see patterns below - $rB must be negated */]>;
				2582
				2583	def : Pat<(sra R16C:$rA, R32C:$rB),
				2584	(ROTMAHr16 R16C:$rA, (SFIr32 R32C:$rB, 0))>;
				2585
				2586	def : Pat<(sra R16C:$rA, R16C:$rB),
				2587	(ROTMAHr16 R16C:$rA,
				2588	(SFIr32 (XSHWr16 R16C:$rB), 0))>;
				2589
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2590	def : Pat<(sra R16C:$rA, R8C:$rB),
				2591	(ROTMAHr16 R16C:$rA,
				2592	(SFIr32 (XSHWr16 (XSBHr8 R8C:$rB)), 0))>;
				2593
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2594	def ROTMAHIv8i16:
				2595	RRForm<0b01111110000, (outs VECREG:$rT), (ins VECREG:$rA, rothNeg7imm:$val),
				2596	"rotmahi\t$rT, $rA, $val", RotateShift,
				2597	[(set (v8i16 VECREG:$rT),
				2598	(SPUvec_sra_v8i16 (v8i16 VECREG:$rA), (i32 uimm7:$val)))]>;
				2599
				2600	def : Pat<(SPUvec_sra_v8i16 (v8i16 VECREG:$rA), (i16 uimm7:$val)),
				2601	(ROTMAHIv8i16 (v8i16 VECREG:$rA), (i32 uimm7:$val))>;
				2602
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2603	def : Pat<(SPUvec_sra_v8i16 (v8i16 VECREG:$rA), (i8 uimm7:$val)),
				2604	(ROTMAHIv8i16 (v8i16 VECREG:$rA), (i32 uimm7:$val))>;
				2605
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2606	def ROTMAHIr16:
				2607	RRForm<0b01111110000, (outs R16C:$rT), (ins R16C:$rA, rothNeg7imm_i16:$val),
				2608	"rotmahi\t$rT, $rA, $val", RotateShift,
				2609	[(set R16C:$rT, (sra R16C:$rA, (i16 uimm7:$val)))]>;
				2610
				2611	def : Pat<(sra R16C:$rA, (i32 imm:$val)),
				2612	(ROTMAHIr16 R16C:$rA, uimm7:$val)>;
				2613
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2614	def : Pat<(sra R16C:$rA, (i8 imm:$val)),
				2615	(ROTMAHIr16 R16C:$rA, uimm7:$val)>;
				2616
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2617	def ROTMAv4i32:
				2618	RRForm<0b01011010000, (outs VECREG:$rT), (ins VECREG:$rA, R32C:$rB),
				2619	"rotma\t$rT, $rA, $rB", RotateShift,
				2620	[/* see patterns below - $rB must be negated */]>;
				2621
				2622	def : Pat<(SPUvec_sra_v4i32 VECREG:$rA, R32C:$rB),
				2623	(ROTMAv4i32 (v4i32 VECREG:$rA), (SFIr32 R32C:$rB, 0))>;
				2624
				2625	def : Pat<(SPUvec_sra_v4i32 VECREG:$rA, R16C:$rB),
				2626	(ROTMAv4i32 (v4i32 VECREG:$rA),
				2627	(SFIr32 (XSHWr16 R16C:$rB), 0))>;
				2628
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2629	def : Pat<(SPUvec_sra_v4i32 VECREG:$rA, R8C:$rB),
				2630	(ROTMAv4i32 (v4i32 VECREG:$rA),
				2631	(SFIr32 (XSHWr16 (XSBHr8 R8C:$rB)), 0))>;
				2632
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2633	def ROTMAr32:
				2634	RRForm<0b01011010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				2635	"rotma\t$rT, $rA, $rB", RotateShift,
				2636	[/* see patterns below - $rB must be negated */]>;
				2637
				2638	def : Pat<(sra R32C:$rA, R32C:$rB),
				2639	(ROTMAr32 R32C:$rA, (SFIr32 R32C:$rB, 0))>;
				2640
				2641	def : Pat<(sra R32C:$rA, R16C:$rB),
				2642	(ROTMAr32 R32C:$rA,
				2643	(SFIr32 (XSHWr16 R16C:$rB), 0))>;
				2644
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2645	def : Pat<(sra R32C:$rA, R8C:$rB),
				2646	(ROTMAr32 R32C:$rA,
				2647	(SFIr32 (XSHWr16 (XSBHr8 R8C:$rB)), 0))>;
				2648
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2649	def ROTMAIv4i32:
				2650	RRForm<0b01011110000, (outs VECREG:$rT), (ins VECREG:$rA, rotNeg7imm:$val),
				2651	"rotmai\t$rT, $rA, $val", RotateShift,
				2652	[(set (v4i32 VECREG:$rT),
				2653	(SPUvec_sra_v4i32 VECREG:$rA, (i32 uimm7:$val)))]>;
				2654
				2655	def : Pat<(SPUvec_sra_v4i32 VECREG:$rA, (i16 uimm7:$val)),
				2656	(ROTMAIv4i32 VECREG:$rA, uimm7:$val)>;
				2657
				2658	def ROTMAIr32:
				2659	RRForm<0b01011110000, (outs R32C:$rT), (ins R32C:$rA, rotNeg7imm:$val),
				2660	"rotmai\t$rT, $rA, $val", RotateShift,
				2661	[(set R32C:$rT, (sra R32C:$rA, (i32 uimm7:$val)))]>;
				2662
				2663	def : Pat<(sra R32C:$rA, (i16 uimm7:$val)),
				2664	(ROTMAIr32 R32C:$rA, uimm7:$val)>;
				2665
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2666	def : Pat<(sra R32C:$rA, (i8 uimm7:$val)),
				2667	(ROTMAIr32 R32C:$rA, uimm7:$val)>;
				2668
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2669	//===----------------------------------------------------------------------===//
				2670	// Branch and conditionals:
				2671	//===----------------------------------------------------------------------===//
				2672
				2673	let isTerminator = 1, isBarrier = 1 in {
				2674	// Halt If Equal (r32 preferred slot only, no vector form)
				2675	def HEQr32:
				2676	RRForm_3<0b00011011110, (outs), (ins R32C:$rA, R32C:$rB),
				2677	"heq\t$rA, $rB", BranchResolv,
				2678	[/* no pattern to match */]>;
				2679
				2680	def HEQIr32 :
				2681	RI10Form_2<0b11111110, (outs), (ins R32C:$rA, s10imm:$val),
				2682	"heqi\t$rA, $val", BranchResolv,
				2683	[/* no pattern to match */]>;
				2684
				2685	// HGT/HGTI: These instructions use signed arithmetic for the comparison,
				2686	// contrasting with HLGT/HLGTI, which use unsigned comparison:
				2687	def HGTr32:
				2688	RRForm_3<0b00011010010, (outs), (ins R32C:$rA, R32C:$rB),
				2689	"hgt\t$rA, $rB", BranchResolv,
				2690	[/* no pattern to match */]>;
				2691
				2692	def HGTIr32:
				2693	RI10Form_2<0b11110010, (outs), (ins R32C:$rA, s10imm:$val),
				2694	"hgti\t$rA, $val", BranchResolv,
				2695	[/* no pattern to match */]>;
				2696
				2697	def HLGTr32:
				2698	RRForm_3<0b00011011010, (outs), (ins R32C:$rA, R32C:$rB),
				2699	"hlgt\t$rA, $rB", BranchResolv,
				2700	[/* no pattern to match */]>;
				2701
				2702	def HLGTIr32:
				2703	RI10Form_2<0b11111010, (outs), (ins R32C:$rA, s10imm:$val),
				2704	"hlgti\t$rA, $val", BranchResolv,
				2705	[/* no pattern to match */]>;
				2706	}
				2707
				2708	// Comparison operators:
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2709	def CEQBr8:
				2710	RRForm<0b00001011110, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB),
				2711	"ceqb\t$rT, $rA, $rB", ByteOp,
				2712	[/* no pattern to match */]>;
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2713
				2714	def CEQBv16i8:
				2715	RRForm<0b00001011110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				2716	"ceqb\t$rT, $rA, $rB", ByteOp,
				2717	[/* no pattern to match: intrinsic */]>;
				2718
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	2719	def CEQBIr8:
				2720	RI10Form<0b01111110, (outs R8C:$rT), (ins R8C:$rA, s7imm:$val),
				2721	"ceqbi\t$rT, $rA, $val", ByteOp,
				2722	[/* no pattern to match: intrinsic */]>;
				2723
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	2724	def CEQBIv16i8:
				2725	RI10Form<0b01111110, (outs VECREG:$rT), (ins VECREG:$rA, s7imm:$val),
				2726	"ceqbi\t$rT, $rA, $val", ByteOp,
				2727	[/* no pattern to match: intrinsic */]>;
				2728
				2729	def CEQHr16:
				2730	RRForm<0b00010011110, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
				2731	"ceqh\t$rT, $rA, $rB", ByteOp,
				2732	[/* no pattern to match */]>;
				2733
				2734	def CEQHv8i16:
				2735	RRForm<0b00010011110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				2736	"ceqh\t$rT, $rA, $rB", ByteOp,
				2737	[/* no pattern to match: intrinsic */]>;
				2738
				2739	def CEQHIr16:
				2740	RI10Form<0b10111110, (outs R16C:$rT), (ins R16C:$rA, s10imm:$val),
				2741	"ceqhi\t$rT, $rA, $val", ByteOp,
				2742	[/* no pattern to match: intrinsic */]>;
				2743
				2744	def CEQHIv8i16:
				2745	RI10Form<0b10111110, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
				2746	"ceqhi\t$rT, $rA, $val", ByteOp,
				2747	[/* no pattern to match: intrinsic */]>;
				2748
				2749	def CEQr32:
				2750	RRForm<0b00000011110, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
				2751	"ceq\t$rT, $rA, $rB", ByteOp,
				2752	[/* no pattern to match: intrinsic */]>;
				2753
				2754	def CEQv4i32:
				2755	RRForm<0b00000011110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				2756	"ceq\t$rT, $rA, $rB", ByteOp,
				2757	[/* no pattern to match: intrinsic */]>;
				2758
				2759	def CEQIr32:
				2760	RI10Form<0b00111110, (outs R32C:$rT), (ins R32C:$rA, s10imm:$val),
				2761	"ceqi\t$rT, $rA, $val", ByteOp,
				2762	[/* no pattern to match: intrinsic */]>;
				2763
				2764	def CEQIv4i32:
				2765	RI10Form<0b00111110, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
				2766	"ceqi\t$rT, $rA, $val", ByteOp,
				2767	[/* no pattern to match: intrinsic */]>;
				2768
				2769	let isCall = 1,
				2770	// All calls clobber the non-callee-saved registers:
				2771	Defs = [R0, R1, R2, R3, R4, R5, R6, R7, R8, R9,
				2772	R10,R11,R12,R13,R14,R15,R16,R17,R18,R19,
				2773	R20,R21,R22,R23,R24,R25,R26,R27,R28,R29,
				2774	R30,R31,R32,R33,R34,R35,R36,R37,R38,R39,
				2775	R40,R41,R42,R43,R44,R45,R46,R47,R48,R49,
				2776	R50,R51,R52,R53,R54,R55,R56,R57,R58,R59,
				2777	R60,R61,R62,R63,R64,R65,R66,R67,R68,R69,
				2778	R70,R71,R72,R73,R74,R75,R76,R77,R78,R79],
				2779	// All of these instructions use $lr (aka $0)
				2780	Uses = [R0] in {
				2781	// Branch relative and set link: Used if we actually know that the target
				2782	// is within [-32768, 32767] bytes of the target
				2783	def BRSL:
				2784	BranchSetLink<0b011001100, (outs), (ins relcalltarget:$func, variable_ops),
				2785	"brsl\t$$lr, $func",
				2786	[(SPUcall (SPUpcrel tglobaladdr:$func, 0))]>;
				2787
				2788	// Branch absolute and set link: Used if we actually know that the target
				2789	// is an absolute address
				2790	def BRASL:
				2791	BranchSetLink<0b011001100, (outs), (ins calltarget:$func, variable_ops),
				2792	"brasl\t$$lr, $func",
				2793	[(SPUcall tglobaladdr:$func)]>;
				2794
				2795	// Branch indirect and set link if external data. These instructions are not
				2796	// actually generated, matched by an intrinsic:
				2797	def BISLED_00: BISLEDForm<0b11, "bisled\t$$lr, $func", [/* empty pattern */]>;
				2798	def BISLED_E0: BISLEDForm<0b10, "bisled\t$$lr, $func", [/* empty pattern */]>;
				2799	def BISLED_0D: BISLEDForm<0b01, "bisled\t$$lr, $func", [/* empty pattern */]>;
				2800	def BISLED_ED: BISLEDForm<0b00, "bisled\t$$lr, $func", [/* empty pattern */]>;
				2801
				2802	// Branch indirect and set link. This is the "X-form" address version of a
				2803	// function call
				2804	def BISL:
				2805	BIForm<0b10010101100, "bisl\t$$lr, $func", [(SPUcall R32C:$func)]>;
				2806	}
				2807
				2808	// Unconditional branches:
				2809	let isBranch = 1, isTerminator = 1, hasCtrlDep = 1, isBarrier = 1 in {
				2810	def BR :
				2811	UncondBranch<0b001001100, (outs), (ins brtarget:$dest),
				2812	"br\t$dest",
				2813	[(br bb:$dest)]>;
				2814
				2815	// Unconditional, absolute address branch
				2816	def BRA:
				2817	UncondBranch<0b001100000, (outs), (ins brtarget:$dest),
				2818	"bra\t$dest",
				2819	[/* no pattern */]>;
				2820
				2821	// Indirect branch
				2822	def BI:
				2823	BIForm<0b00010101100, "bi\t$func", [(brind R32C:$func)]>;
				2824
				2825	// Various branches:
				2826	def BRNZ:
				2827	RI16Form<0b010000100, (outs), (ins R32C:$rCond, brtarget:$dest),
				2828	"brnz\t$rCond,$dest",
				2829	BranchResolv,
				2830	[(brcond R32C:$rCond, bb:$dest)]>;
				2831
				2832	def BRZ:
				2833	RI16Form<0b000000100, (outs), (ins R32C:$rT, brtarget:$dest),
				2834	"brz\t$rT,$dest",
				2835	BranchResolv,
				2836	[/* no pattern */]>;
				2837
				2838	def BRHNZ:
				2839	RI16Form<0b011000100, (outs), (ins R16C:$rCond, brtarget:$dest),
				2840	"brhnz\t$rCond,$dest",
				2841	BranchResolv,
				2842	[(brcond R16C:$rCond, bb:$dest)]>;
				2843
				2844	def BRHZ:
				2845	RI16Form<0b001000100, (outs), (ins R16C:$rT, brtarget:$dest),
				2846	"brhz\t$rT,$dest",
				2847	BranchResolv,
				2848	[/* no pattern */]>;
				2849
				2850	/*
				2851	def BINZ:
				2852	BICondForm<0b10010100100, "binz\t$rA, $func",
				2853	[(SPUbinz R32C:$rA, R32C:$func)]>;
				2854
				2855	def BIZ:
				2856	BICondForm<0b00010100100, "biz\t$rA, $func",
				2857	[(SPUbiz R32C:$rA, R32C:$func)]>;
				2858	*/
				2859	}
				2860
				2861	def : Pat<(brcond (i16 (seteq R16C:$rA, 0)), bb:$dest),
				2862	(BRHZ R16C:$rA, bb:$dest)>;
				2863	def : Pat<(brcond (i16 (setne R16C:$rA, 0)), bb:$dest),
				2864	(BRHNZ R16C:$rA, bb:$dest)>;
				2865
				2866	def : Pat<(brcond (i32 (seteq R32C:$rA, 0)), bb:$dest),
				2867	(BRZ R32C:$rA, bb:$dest)>;
				2868	def : Pat<(brcond (i32 (setne R32C:$rA, 0)), bb:$dest),
				2869	(BRZ R32C:$rA, bb:$dest)>;
				2870
				2871	let isTerminator = 1, isBarrier = 1 in {
				2872	let isReturn = 1 in {
				2873	def RET:
				2874	RETForm<"bi\t$$lr", [(retflag)]>;
				2875	}
				2876	}
				2877
				2878	//===----------------------------------------------------------------------===//
				2879	// Various brcond predicates:
				2880	//===----------------------------------------------------------------------===//
				2881	/*
				2882	def : Pat<(brcond (i32 (seteq R32C:$rA, 0)), bb:$dest),
				2883	(BRZ R32C:$rA, bb:$dest)>;
				2884
				2885	def : Pat<(brcond (i32 (seteq R32C:$rA, R32C:$rB)), bb:$dest),
				2886	(BRNZ (CEQr32 R32C:$rA, R32C:$rB), bb:$dest)>;
				2887
				2888	def : Pat<(brcond (i16 (seteq R16C:$rA, i16ImmSExt10:$val)), bb:$dest),
				2889	(BRHNZ (CEQHIr16 R16C:$rA, i16ImmSExt10:$val), bb:$dest)>;
				2890
				2891	def : Pat<(brcond (i16 (seteq R16C:$rA, R16C:$rB)), bb:$dest),
				2892	(BRHNZ (CEQHr16 R16C:$rA, R16C:$rB), bb:$dest)>;
				2893	*/
				2894
				2895	//===----------------------------------------------------------------------===//
				2896	// Single precision floating point instructions
				2897	//===----------------------------------------------------------------------===//
				2898
				2899	def FAv4f32:
				2900	RRForm<0b00100011010, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				2901	"fa\t$rT, $rA, $rB", SPrecFP,
				2902	[(set (v4f32 VECREG:$rT), (fadd (v4f32 VECREG:$rA), (v4f32 VECREG:$rB)))]>;
				2903
				2904	def FAf32 :
				2905	RRForm<0b00100011010, (outs R32FP:$rT), (ins R32FP:$rA, R32FP:$rB),
				2906	"fa\t$rT, $rA, $rB", SPrecFP,
				2907	[(set R32FP:$rT, (fadd R32FP:$rA, R32FP:$rB))]>;
				2908
				2909	def FSv4f32:
				2910	RRForm<0b00100011010, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				2911	"fs\t$rT, $rA, $rB", SPrecFP,
				2912	[(set (v4f32 VECREG:$rT), (fsub (v4f32 VECREG:$rA), (v4f32 VECREG:$rB)))]>;
				2913
				2914	def FSf32 :
				2915	RRForm<0b10100011010, (outs R32FP:$rT), (ins R32FP:$rA, R32FP:$rB),
				2916	"fs\t$rT, $rA, $rB", SPrecFP,
				2917	[(set R32FP:$rT, (fsub R32FP:$rA, R32FP:$rB))]>;
				2918
				2919	// Floating point reciprocal estimate
				2920	def FREv4f32 :
				2921	RRForm_1<0b00011101100, (outs VECREG:$rT), (ins VECREG:$rA),
				2922	"frest\t$rT, $rA", SPrecFP,
				2923	[(set (v4f32 VECREG:$rT), (SPUreciprocalEst (v4f32 VECREG:$rA)))]>;
				2924
				2925	def FREf32 :
				2926	RRForm_1<0b00011101100, (outs R32FP:$rT), (ins R32FP:$rA),
				2927	"frest\t$rT, $rA", SPrecFP,
				2928	[(set R32FP:$rT, (SPUreciprocalEst R32FP:$rA))]>;
				2929
				2930	// Floating point interpolate (used in conjunction with reciprocal estimate)
				2931	def FIv4f32 :
				2932	RRForm<0b00101011110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				2933	"fi\t$rT, $rA, $rB", SPrecFP,
				2934	[(set (v4f32 VECREG:$rT), (SPUinterpolate (v4f32 VECREG:$rA),
				2935	(v4f32 VECREG:$rB)))]>;
				2936
				2937	def FIf32 :
				2938	RRForm<0b00101011110, (outs R32FP:$rT), (ins R32FP:$rA, R32FP:$rB),
				2939	"fi\t$rT, $rA, $rB", SPrecFP,
				2940	[(set R32FP:$rT, (SPUinterpolate R32FP:$rA, R32FP:$rB))]>;
				2941
				2942	// Floating Compare Equal
				2943	def FCEQf32 :
				2944	RRForm<0b01000011110, (outs R32C:$rT), (ins R32FP:$rA, R32FP:$rB),
				2945	"fceq\t$rT, $rA, $rB", SPrecFP,
				2946	[(set R32C:$rT, (setoeq R32FP:$rA, R32FP:$rB))]>;
				2947
				2948	def FCMEQf32 :
				2949	RRForm<0b01010011110, (outs R32C:$rT), (ins R32FP:$rA, R32FP:$rB),
				2950	"fcmeq\t$rT, $rA, $rB", SPrecFP,
				2951	[(set R32C:$rT, (setoeq (fabs R32FP:$rA), (fabs R32FP:$rB)))]>;
				2952
				2953	def FCGTf32 :
				2954	RRForm<0b01000011010, (outs R32C:$rT), (ins R32FP:$rA, R32FP:$rB),
				2955	"fcgt\t$rT, $rA, $rB", SPrecFP,
				2956	[(set R32C:$rT, (setogt R32FP:$rA, R32FP:$rB))]>;
				2957
				2958	def FCMGTf32 :
				2959	RRForm<0b01010011010, (outs R32C:$rT), (ins R32FP:$rA, R32FP:$rB),
				2960	"fcmgt\t$rT, $rA, $rB", SPrecFP,
				2961	[(set R32C:$rT, (setogt (fabs R32FP:$rA), (fabs R32FP:$rB)))]>;
				2962
				2963	// FP Status and Control Register Write
				2964	// Why isn't rT a don't care in the ISA?
				2965	// Should we create a special RRForm_3 for this guy and zero out the rT?
				2966	def FSCRWf32 :
				2967	RRForm_1<0b01011101110, (outs R32FP:$rT), (ins R32FP:$rA),
				2968	"fscrwr\t$rA", SPrecFP,
				2969	[/* This instruction requires an intrinsic. Note: rT is unused. */]>;
				2970
				2971	// FP Status and Control Register Read
				2972	def FSCRRf32 :
				2973	RRForm_2<0b01011101110, (outs R32FP:$rT), (ins),
				2974	"fscrrd\t$rT", SPrecFP,
				2975	[/* This instruction requires an intrinsic */]>;
				2976
				2977	// llvm instruction space
				2978	// How do these map onto cell instructions?
				2979	// fdiv rA rB
				2980	// frest rC rB # c = 1/b (both lines)
				2981	// fi rC rB rC
				2982	// fm rD rA rC # d = a * 1/b
				2983	// fnms rB rD rB rA # b = - (d * b - a) --should == 0 in a perfect world
				2984	// fma rB rB rC rD # b = b * c + d
				2985	// = -(d b -a) c + d
				2986	// = a * c - c ( a b c - a)
				2987
				2988	// fcopysign (???)
				2989
				2990	// Library calls:
				2991	// These llvm instructions will actually map to library calls.
				2992	// All that's needed, then, is to check that the appropriate library is
				2993	// imported and do a brsl to the proper function name.
				2994	// frem # fmod(x, y): x - (x/y) * y
				2995	// (Note: fmod(double, double), fmodf(float,float)
				2996	// fsqrt?
				2997	// fsin?
				2998	// fcos?
				2999	// Unimplemented SPU instruction space
				3000	// floating reciprocal absolute square root estimate (frsqest)
				3001
				3002	// The following are probably just intrinsics
				3003	// status and control register write
				3004	// status and control register read
				3005
				3006	//--------------------------------------
				3007	// Floating point multiply instructions
				3008	//--------------------------------------
				3009
				3010	def FMv4f32:
				3011	RRForm<0b00100011010, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				3012	"fm\t$rT, $rA, $rB", SPrecFP,
				3013	[(set (v4f32 VECREG:$rT), (fmul (v4f32 VECREG:$rA),
				3014	(v4f32 VECREG:$rB)))]>;
				3015
				3016	def FMf32 :
				3017	RRForm<0b01100011010, (outs R32FP:$rT), (ins R32FP:$rA, R32FP:$rB),
				3018	"fm\t$rT, $rA, $rB", SPrecFP,
				3019	[(set R32FP:$rT, (fmul R32FP:$rA, R32FP:$rB))]>;
				3020
				3021	// Floating point multiply and add
				3022	// e.g. d = c + (a * b)
				3023	def FMAv4f32:
				3024	RRRForm<0b0111, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
				3025	"fma\t$rT, $rA, $rB, $rC", SPrecFP,
				3026	[(set (v4f32 VECREG:$rT),
				3027	(fadd (v4f32 VECREG:$rC),
				3028	(fmul (v4f32 VECREG:$rA), (v4f32 VECREG:$rB))))]>;
				3029
				3030	def FMAf32:
				3031	RRRForm<0b0111, (outs R32FP:$rT), (ins R32FP:$rA, R32FP:$rB, R32FP:$rC),
				3032	"fma\t$rT, $rA, $rB, $rC", SPrecFP,
				3033	[(set R32FP:$rT, (fadd R32FP:$rC, (fmul R32FP:$rA, R32FP:$rB)))]>;
				3034
				3035	// FP multiply and subtract
				3036	// Subtracts value in rC from product
				3037	// res = a * b - c
				3038	def FMSv4f32 :
				3039	RRRForm<0b0111, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
				3040	"fms\t$rT, $rA, $rB, $rC", SPrecFP,
				3041	[(set (v4f32 VECREG:$rT),
				3042	(fsub (fmul (v4f32 VECREG:$rA), (v4f32 VECREG:$rB)),
				3043	(v4f32 VECREG:$rC)))]>;
				3044
				3045	def FMSf32 :
				3046	RRRForm<0b0111, (outs R32FP:$rT), (ins R32FP:$rA, R32FP:$rB, R32FP:$rC),
				3047	"fms\t$rT, $rA, $rB, $rC", SPrecFP,
				3048	[(set R32FP:$rT,
				3049	(fsub (fmul R32FP:$rA, R32FP:$rB), R32FP:$rC))]>;
				3050
				3051	// Floating Negative Mulitply and Subtract
				3052	// Subtracts product from value in rC
				3053	// res = fneg(fms a b c)
				3054	// = - (a * b - c)
				3055	// = c - a * b
				3056	// NOTE: subtraction order
				3057	// fsub a b = a - b
				3058	// fs a b = b - a?
				3059	def FNMSf32 :
				3060	RRRForm<0b1101, (outs R32FP:$rT), (ins R32FP:$rA, R32FP:$rB, R32FP:$rC),
				3061	"fnms\t$rT, $rA, $rB, $rC", SPrecFP,
				3062	[(set R32FP:$rT, (fsub R32FP:$rC, (fmul R32FP:$rA, R32FP:$rB)))]>;
				3063
				3064	def FNMSv4f32 :
				3065	RRRForm<0b1101, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
				3066	"fnms\t$rT, $rA, $rB, $rC", SPrecFP,
				3067	[(set (v4f32 VECREG:$rT),
				3068	(fsub (v4f32 VECREG:$rC),
				3069	(fmul (v4f32 VECREG:$rA),
				3070	(v4f32 VECREG:$rB))))]>;
				3071
				3072	//--------------------------------------
				3073	// Floating Point Conversions
				3074	// Signed conversions:
				3075	def CSiFv4f32:
				3076	CVTIntFPForm<0b0101101110, (outs VECREG:$rT), (ins VECREG:$rA),
				3077	"csflt\t$rT, $rA, 0", SPrecFP,
				3078	[(set (v4f32 VECREG:$rT), (sint_to_fp (v4i32 VECREG:$rA)))]>;
				3079
				3080	// Convert signed integer to floating point
				3081	def CSiFf32 :
				3082	CVTIntFPForm<0b0101101110, (outs R32FP:$rT), (ins R32C:$rA),
				3083	"csflt\t$rT, $rA, 0", SPrecFP,
				3084	[(set R32FP:$rT, (sint_to_fp R32C:$rA))]>;
				3085
				3086	// Convert unsigned into to float
				3087	def CUiFv4f32 :
				3088	CVTIntFPForm<0b1101101110, (outs VECREG:$rT), (ins VECREG:$rA),
				3089	"cuflt\t$rT, $rA, 0", SPrecFP,
				3090	[(set (v4f32 VECREG:$rT), (uint_to_fp (v4i32 VECREG:$rA)))]>;
				3091
				3092	def CUiFf32 :
				3093	CVTIntFPForm<0b1101101110, (outs R32FP:$rT), (ins R32C:$rA),
				3094	"cuflt\t$rT, $rA, 0", SPrecFP,
				3095	[(set R32FP:$rT, (uint_to_fp R32C:$rA))]>;
				3096
				3097	// Convert float to unsigned int
				3098	// Assume that scale = 0
				3099
				3100	def CFUiv4f32 :
				3101	CVTIntFPForm<0b1101101110, (outs VECREG:$rT), (ins VECREG:$rA),
				3102	"cfltu\t$rT, $rA, 0", SPrecFP,
				3103	[(set (v4i32 VECREG:$rT), (fp_to_uint (v4f32 VECREG:$rA)))]>;
				3104
				3105	def CFUif32 :
				3106	CVTIntFPForm<0b1101101110, (outs R32C:$rT), (ins R32FP:$rA),
				3107	"cfltu\t$rT, $rA, 0", SPrecFP,
				3108	[(set R32C:$rT, (fp_to_uint R32FP:$rA))]>;
				3109
				3110	// Convert float to signed int
				3111	// Assume that scale = 0
				3112
				3113	def CFSiv4f32 :
				3114	CVTIntFPForm<0b1101101110, (outs VECREG:$rT), (ins VECREG:$rA),
				3115	"cflts\t$rT, $rA, 0", SPrecFP,
				3116	[(set (v4i32 VECREG:$rT), (fp_to_sint (v4f32 VECREG:$rA)))]>;
				3117
				3118	def CFSif32 :
				3119	CVTIntFPForm<0b1101101110, (outs R32C:$rT), (ins R32FP:$rA),
				3120	"cflts\t$rT, $rA, 0", SPrecFP,
				3121	[(set R32C:$rT, (fp_to_sint R32FP:$rA))]>;
				3122
				3123	//===----------------------------------------------------------------------==//
				3124	// Single<->Double precision conversions
				3125	//===----------------------------------------------------------------------==//
				3126
				3127	// NOTE: We use "vec" name suffix here to avoid confusion (e.g. input is a
				3128	// v4f32, output is v2f64--which goes in the name?)
				3129
				3130	// Floating point extend single to double
				3131	// NOTE: Not sure if passing in v4f32 to FESDvec is correct since it
				3132	// operates on two double-word slots (i.e. 1st and 3rd fp numbers
				3133	// are ignored).
				3134	def FESDvec :
				3135	RRForm_1<0b00011101110, (outs VECREG:$rT), (ins VECREG:$rA),
				3136	"fesd\t$rT, $rA", SPrecFP,
				3137	[(set (v2f64 VECREG:$rT), (fextend (v4f32 VECREG:$rA)))]>;
				3138
				3139	def FESDf32 :
				3140	RRForm_1<0b00011101110, (outs R64FP:$rT), (ins R32FP:$rA),
				3141	"fesd\t$rT, $rA", SPrecFP,
				3142	[(set R64FP:$rT, (fextend R32FP:$rA))]>;
				3143
				3144	// Floating point round double to single
				3145	//def FRDSvec :
				3146	// RRForm_1<0b10011101110, (outs VECREG:$rT), (ins VECREG:$rA),
				3147	// "frds\t$rT, $rA,", SPrecFP,
				3148	// [(set (v4f32 R32FP:$rT), (fround (v2f64 R64FP:$rA)))]>;
				3149
				3150	def FRDSf64 :
				3151	RRForm_1<0b10011101110, (outs R32FP:$rT), (ins R64FP:$rA),
				3152	"frds\t$rT, $rA", SPrecFP,
				3153	[(set R32FP:$rT, (fround R64FP:$rA))]>;
				3154
				3155	//ToDo include anyextend?
				3156
				3157	//===----------------------------------------------------------------------==//
				3158	// Double precision floating point instructions
				3159	//===----------------------------------------------------------------------==//
				3160	def FAf64 :
				3161	RRForm<0b00110011010, (outs R64FP:$rT), (ins R64FP:$rA, R64FP:$rB),
				3162	"dfa\t$rT, $rA, $rB", DPrecFP,
				3163	[(set R64FP:$rT, (fadd R64FP:$rA, R64FP:$rB))]>;
				3164
				3165	def FAv2f64 :
				3166	RRForm<0b00110011010, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				3167	"dfa\t$rT, $rA, $rB", DPrecFP,
				3168	[(set (v2f64 VECREG:$rT), (fadd (v2f64 VECREG:$rA), (v2f64 VECREG:$rB)))]>;
				3169
				3170	def FSf64 :
				3171	RRForm<0b10100011010, (outs R64FP:$rT), (ins R64FP:$rA, R64FP:$rB),
				3172	"dfs\t$rT, $rA, $rB", DPrecFP,
				3173	[(set R64FP:$rT, (fsub R64FP:$rA, R64FP:$rB))]>;
				3174
				3175	def FSv2f64 :
				3176	RRForm<0b10100011010, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				3177	"dfs\t$rT, $rA, $rB", DPrecFP,
				3178	[(set (v2f64 VECREG:$rT),
				3179	(fsub (v2f64 VECREG:$rA), (v2f64 VECREG:$rB)))]>;
				3180
				3181	def FMf64 :
				3182	RRForm<0b01100011010, (outs R64FP:$rT), (ins R64FP:$rA, R64FP:$rB),
				3183	"dfm\t$rT, $rA, $rB", DPrecFP,
				3184	[(set R64FP:$rT, (fmul R64FP:$rA, R64FP:$rB))]>;
				3185
				3186	def FMv2f64:
				3187	RRForm<0b00100011010, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
				3188	"dfm\t$rT, $rA, $rB", DPrecFP,
				3189	[(set (v2f64 VECREG:$rT),
				3190	(fmul (v2f64 VECREG:$rA), (v2f64 VECREG:$rB)))]>;
				3191
				3192	def FMAf64:
				3193	RRForm<0b00111010110, (outs R64FP:$rT),
				3194	(ins R64FP:$rA, R64FP:$rB, R64FP:$rC),
				3195	"dfma\t$rT, $rA, $rB", DPrecFP,
				3196	[(set R64FP:$rT, (fadd R64FP:$rC, (fmul R64FP:$rA, R64FP:$rB)))]>,
				3197	RegConstraint<"$rC = $rT">,
				3198	NoEncode<"$rC">;
				3199
				3200	def FMAv2f64:
				3201	RRForm<0b00111010110, (outs VECREG:$rT),
				3202	(ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
				3203	"dfma\t$rT, $rA, $rB", DPrecFP,
				3204	[(set (v2f64 VECREG:$rT),
				3205	(fadd (v2f64 VECREG:$rC),
				3206	(fmul (v2f64 VECREG:$rA), (v2f64 VECREG:$rB))))]>,
				3207	RegConstraint<"$rC = $rT">,
				3208	NoEncode<"$rC">;
				3209
				3210	def FMSf64 :
				3211	RRForm<0b10111010110, (outs R64FP:$rT),
				3212	(ins R64FP:$rA, R64FP:$rB, R64FP:$rC),
				3213	"dfms\t$rT, $rA, $rB", DPrecFP,
				3214	[(set R64FP:$rT, (fsub (fmul R64FP:$rA, R64FP:$rB), R64FP:$rC))]>,
				3215	RegConstraint<"$rC = $rT">,
				3216	NoEncode<"$rC">;
				3217
				3218	def FMSv2f64 :
				3219	RRForm<0b10111010110, (outs VECREG:$rT),
				3220	(ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
				3221	"dfms\t$rT, $rA, $rB", DPrecFP,
				3222	[(set (v2f64 VECREG:$rT),
				3223	(fsub (fmul (v2f64 VECREG:$rA), (v2f64 VECREG:$rB)),
				3224	(v2f64 VECREG:$rC)))]>;
				3225
				3226	// FNMS: - (a * b - c)
				3227	// - (a * b) + c => c - (a * b)
				3228	def FNMSf64 :
				3229	RRForm<0b01111010110, (outs R64FP:$rT),
				3230	(ins R64FP:$rA, R64FP:$rB, R64FP:$rC),
				3231	"dfnms\t$rT, $rA, $rB", DPrecFP,
				3232	[(set R64FP:$rT, (fsub R64FP:$rC, (fmul R64FP:$rA, R64FP:$rB)))]>,
				3233	RegConstraint<"$rC = $rT">,
				3234	NoEncode<"$rC">;
				3235
				3236	def : Pat<(fneg (fsub (fmul R64FP:$rA, R64FP:$rB), R64FP:$rC)),
				3237	(FNMSf64 R64FP:$rA, R64FP:$rB, R64FP:$rC)>;
				3238
				3239	def FNMSv2f64 :
				3240	RRForm<0b01111010110, (outs VECREG:$rT),
				3241	(ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
				3242	"dfnms\t$rT, $rA, $rB", DPrecFP,
				3243	[(set (v2f64 VECREG:$rT),
				3244	(fsub (v2f64 VECREG:$rC),
				3245	(fmul (v2f64 VECREG:$rA),
				3246	(v2f64 VECREG:$rB))))]>,
				3247	RegConstraint<"$rC = $rT">,
				3248	NoEncode<"$rC">;
				3249
				3250	def : Pat<(fneg (fsub (fmul (v2f64 VECREG:$rA), (v2f64 VECREG:$rB)),
				3251	(v2f64 VECREG:$rC))),
				3252	(FNMSv2f64 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
				3253
				3254	// - (a * b + c)
				3255	// - (a * b) - c
				3256	def FNMAf64 :
				3257	RRForm<0b11111010110, (outs R64FP:$rT),
				3258	(ins R64FP:$rA, R64FP:$rB, R64FP:$rC),
				3259	"dfnma\t$rT, $rA, $rB", DPrecFP,
				3260	[(set R64FP:$rT, (fneg (fadd R64FP:$rC, (fmul R64FP:$rA, R64FP:$rB))))]>,
				3261	RegConstraint<"$rC = $rT">,
				3262	NoEncode<"$rC">;
				3263
				3264	def FNMAv2f64 :
				3265	RRForm<0b11111010110, (outs VECREG:$rT),
				3266	(ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
				3267	"dfnma\t$rT, $rA, $rB", DPrecFP,
				3268	[(set (v2f64 VECREG:$rT),
				3269	(fneg (fadd (v2f64 VECREG:$rC),
				3270	(fmul (v2f64 VECREG:$rA),
				3271	(v2f64 VECREG:$rB)))))]>,
				3272	RegConstraint<"$rC = $rT">,
				3273	NoEncode<"$rC">;
				3274
				3275	//===----------------------------------------------------------------------==//
				3276	// Floating point negation and absolute value
				3277	//===----------------------------------------------------------------------==//
				3278
				3279	def : Pat<(fneg (v4f32 VECREG:$rA)),
				3280	(XORfnegvec (v4f32 VECREG:$rA),
				3281	(v4f32 (ILHUv4i32 0x8000)))>;
				3282
				3283	def : Pat<(fneg R32FP:$rA),
				3284	(XORfneg32 R32FP:$rA, (ILHUr32 0x8000))>;
				3285
				3286	def : Pat<(fneg (v2f64 VECREG:$rA)),
				3287	(XORfnegvec (v2f64 VECREG:$rA),
				3288	(v2f64 (ANDBIv16i8 (FSMBIv16i8 0x8080), 0x80)))>;
				3289
				3290	def : Pat<(fneg R64FP:$rA),
				3291	(XORfneg64 R64FP:$rA,
				3292	(ANDBIv16i8 (FSMBIv16i8 0x8080), 0x80))>;
				3293
				3294	// Floating point absolute value
				3295
				3296	def : Pat<(fabs R32FP:$rA),
				3297	(ANDfabs32 R32FP:$rA, (IOHLr32 (ILHUr32 0x7fff), 0xffff))>;
				3298
				3299	def : Pat<(fabs (v4f32 VECREG:$rA)),
				3300	(ANDfabsvec (v4f32 VECREG:$rA),
				3301	(v4f32 (ANDBIv16i8 (FSMBIv16i8 0xffff), 0x7f)))>;
				3302
				3303	def : Pat<(fabs R64FP:$rA),
				3304	(ANDfabs64 R64FP:$rA, (ANDBIv16i8 (FSMBIv16i8 0xffff), 0x7f))>;
				3305
				3306	def : Pat<(fabs (v2f64 VECREG:$rA)),
				3307	(ANDfabsvec (v2f64 VECREG:$rA),
				3308	(v2f64 (ANDBIv16i8 (FSMBIv16i8 0xffff), 0x7f)))>;
				3309
				3310	//===----------------------------------------------------------------------===//
				3311	// Execution, Load NOP (execute NOPs belong in even pipeline, load NOPs belong
				3312	// in the odd pipeline)
				3313	//===----------------------------------------------------------------------===//
				3314
				3315	def ENOP : I<(outs), (ins), "enop", ExecNOP> {
				3316	let Pattern = [];
				3317
				3318	let Inst{0-10} = 0b10000000010;
				3319	let Inst{11-17} = 0;
				3320	let Inst{18-24} = 0;
				3321	let Inst{25-31} = 0;
				3322	}
				3323
				3324	def LNOP : I<(outs), (ins), "lnop", LoadNOP> {
				3325	let Pattern = [];
				3326
				3327	let Inst{0-10} = 0b10000000000;
				3328	let Inst{11-17} = 0;
				3329	let Inst{18-24} = 0;
				3330	let Inst{25-31} = 0;
				3331	}
				3332
				3333	//===----------------------------------------------------------------------===//
				3334	// Bit conversions (type conversions between vector/packed types)
				3335	// NOTE: Promotions are handled using the XS* instructions. Truncation
				3336	// is not handled.
				3337	//===----------------------------------------------------------------------===//
				3338	def : Pat<(v16i8 (bitconvert (v8i16 VECREG:$src))), (v16i8 VECREG:$src)>;
				3339	def : Pat<(v16i8 (bitconvert (v4i32 VECREG:$src))), (v16i8 VECREG:$src)>;
				3340	def : Pat<(v16i8 (bitconvert (v2i64 VECREG:$src))), (v16i8 VECREG:$src)>;
				3341	def : Pat<(v16i8 (bitconvert (v4f32 VECREG:$src))), (v16i8 VECREG:$src)>;
				3342	def : Pat<(v16i8 (bitconvert (v2f64 VECREG:$src))), (v16i8 VECREG:$src)>;
				3343
				3344	def : Pat<(v8i16 (bitconvert (v16i8 VECREG:$src))), (v8i16 VECREG:$src)>;
				3345	def : Pat<(v8i16 (bitconvert (v4i32 VECREG:$src))), (v8i16 VECREG:$src)>;
				3346	def : Pat<(v8i16 (bitconvert (v2i64 VECREG:$src))), (v8i16 VECREG:$src)>;
				3347	def : Pat<(v8i16 (bitconvert (v4f32 VECREG:$src))), (v8i16 VECREG:$src)>;
				3348	def : Pat<(v8i16 (bitconvert (v2f64 VECREG:$src))), (v8i16 VECREG:$src)>;
				3349
				3350	def : Pat<(v4i32 (bitconvert (v16i8 VECREG:$src))), (v4i32 VECREG:$src)>;
				3351	def : Pat<(v4i32 (bitconvert (v8i16 VECREG:$src))), (v4i32 VECREG:$src)>;
				3352	def : Pat<(v4i32 (bitconvert (v2i64 VECREG:$src))), (v4i32 VECREG:$src)>;
				3353	def : Pat<(v4i32 (bitconvert (v4f32 VECREG:$src))), (v4i32 VECREG:$src)>;
				3354	def : Pat<(v4i32 (bitconvert (v2f64 VECREG:$src))), (v4i32 VECREG:$src)>;
				3355
				3356	def : Pat<(v2i64 (bitconvert (v16i8 VECREG:$src))), (v2i64 VECREG:$src)>;
				3357	def : Pat<(v2i64 (bitconvert (v8i16 VECREG:$src))), (v2i64 VECREG:$src)>;
				3358	def : Pat<(v2i64 (bitconvert (v4i32 VECREG:$src))), (v2i64 VECREG:$src)>;
				3359	def : Pat<(v2i64 (bitconvert (v4f32 VECREG:$src))), (v2i64 VECREG:$src)>;
				3360	def : Pat<(v2i64 (bitconvert (v2f64 VECREG:$src))), (v2i64 VECREG:$src)>;
				3361
				3362	def : Pat<(v4f32 (bitconvert (v16i8 VECREG:$src))), (v4f32 VECREG:$src)>;
				3363	def : Pat<(v4f32 (bitconvert (v8i16 VECREG:$src))), (v4f32 VECREG:$src)>;
				3364	def : Pat<(v4f32 (bitconvert (v2i64 VECREG:$src))), (v4f32 VECREG:$src)>;
				3365	def : Pat<(v4f32 (bitconvert (v4i32 VECREG:$src))), (v4f32 VECREG:$src)>;
				3366	def : Pat<(v4f32 (bitconvert (v2f64 VECREG:$src))), (v4f32 VECREG:$src)>;
				3367
				3368	def : Pat<(v2f64 (bitconvert (v16i8 VECREG:$src))), (v2f64 VECREG:$src)>;
				3369	def : Pat<(v2f64 (bitconvert (v8i16 VECREG:$src))), (v2f64 VECREG:$src)>;
				3370	def : Pat<(v2f64 (bitconvert (v4i32 VECREG:$src))), (v2f64 VECREG:$src)>;
				3371	def : Pat<(v2f64 (bitconvert (v2i64 VECREG:$src))), (v2f64 VECREG:$src)>;
				3372	def : Pat<(v2f64 (bitconvert (v2f64 VECREG:$src))), (v2f64 VECREG:$src)>;
				3373
				3374	def : Pat<(f32 (bitconvert (i32 R32C:$src))), (f32 R32FP:$src)>;
				3375
				3376	//===----------------------------------------------------------------------===//
				3377	// Instruction patterns:
				3378	//===----------------------------------------------------------------------===//
				3379
				3380	// General 32-bit constants:
				3381	def : Pat<(i32 imm:$imm),
				3382	(IOHLr32 (ILHUr32 (HI16 imm:$imm)), (LO16 imm:$imm))>;
				3383
				3384	// Single precision float constants:
				3385	def : Pat<(SPUFPconstant (f32 fpimm:$imm)),
				3386	(IOHLf32 (ILHUf32 (HI16_f32 fpimm:$imm)), (LO16_f32 fpimm:$imm))>;
				3387
				3388	// General constant 32-bit vectors
				3389	def : Pat<(v4i32 v4i32Imm:$imm),
				3390	(IOHLvec (v4i32 (ILHUv4i32 (HI16_vec v4i32Imm:$imm))),
				3391	(LO16_vec v4i32Imm:$imm))>;
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	3392
				3393	// 8-bit constants
				3394	def : Pat<(i8 imm:$imm),
				3395	(ILHr8 imm:$imm)>;
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	3396
				3397	//===----------------------------------------------------------------------===//
				3398	// Call instruction patterns:
				3399	//===----------------------------------------------------------------------===//
				3400	// Return void
				3401	def : Pat<(ret),
				3402	(RET)>;
				3403
				3404	//===----------------------------------------------------------------------===//
				3405	// Zero/Any/Sign extensions
				3406	//===----------------------------------------------------------------------===//
				3407
				3408	// zext 1->32: Zero extend i1 to i32
				3409	def : Pat<(SPUextract_i1_zext R32C:$rSrc),
				3410	(ANDIr32 R32C:$rSrc, 0x1)>;
				3411
				3412	// sext 8->32: Sign extend bytes to words
				3413	def : Pat<(sext_inreg R32C:$rSrc, i8),
				3414	(XSHWr32 (XSBHr32 R32C:$rSrc))>;
				3415
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	3416	def : Pat<(i32 (sext R8C:$rSrc)),
				3417	(XSHWr16 (XSBHr8 R8C:$rSrc))>;
				3418
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	3419	def : Pat<(SPUextract_i8_sext VECREG:$rSrc),
				3420	(XSHWr32 (XSBHr32 (ORi32_v4i32 (v4i32 VECREG:$rSrc),
				3421	(v4i32 VECREG:$rSrc))))>;
				3422
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	3423	// zext 8->16: Zero extend bytes to halfwords
				3424	def : Pat<(i16 (zext R8C:$rSrc)),
				3425	(ANDHI1To2 R8C:$rSrc, 0xff)>;
				3426
				3427	// zext 8->32 from preferred slot in load/store
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	3428	def : Pat<(SPUextract_i8_zext VECREG:$rSrc),
				3429	(ANDIr32 (ORi32_v4i32 (v4i32 VECREG:$rSrc), (v4i32 VECREG:$rSrc)),
				3430	0xff)>;
				3431
Scott Michel	438be25	2007-12-17 22:32:34 +0000	[diff] [blame^]	3432	// zext 8->32: Zero extend bytes to words
				3433	def : Pat<(i32 (zext R8C:$rSrc)),
				3434	(ANDI1To4 R8C:$rSrc, 0xff)>;
				3435
				3436	// anyext 8->16: Extend 8->16 bits, irrespective of sign
				3437	def : Pat<(i16 (anyext R8C:$rSrc)),
				3438	(ORHI1To2 R8C:$rSrc, 0)>;
				3439
				3440	// anyext 8->32: Extend 8->32 bits, irrespective of sign
				3441	def : Pat<(i32 (anyext R8C:$rSrc)),
				3442	(ORI1To4 R8C:$rSrc, 0)>;
				3443
Scott Michel	8b6b420	2007-12-04 22:35:58 +0000	[diff] [blame]	3444	// zext 16->32: Zero extend halfwords to words (note that we have to juggle the
				3445	// 0xffff constant since it will not fit into an immediate.)
				3446	def : Pat<(i32 (zext R16C:$rSrc)),
				3447	(AND2To4 R16C:$rSrc, (ILAr32 0xffff))>;
				3448
				3449	def : Pat<(i32 (zext (and R16C:$rSrc, 0xf))),
				3450	(ANDI2To4 R16C:$rSrc, 0xf)>;
				3451
				3452	def : Pat<(i32 (zext (and R16C:$rSrc, 0xff))),
				3453	(ANDI2To4 R16C:$rSrc, 0xff)>;
				3454
				3455	def : Pat<(i32 (zext (and R16C:$rSrc, 0xfff))),
				3456	(ANDI2To4 R16C:$rSrc, 0xfff)>;
				3457
				3458	// anyext 16->32: Extend 16->32 bits, irrespective of sign
				3459	def : Pat<(i32 (anyext R16C:$rSrc)),
				3460	(ORI2To4 R16C:$rSrc, 0)>;
				3461
				3462	//===----------------------------------------------------------------------===//
				3463	// Address translation: SPU, like PPC, has to split addresses into high and
				3464	// low parts in order to load them into a register.
				3465	//===----------------------------------------------------------------------===//
				3466
				3467	def : Pat<(SPUhi tglobaladdr:$in, 0), (ILHUhi tglobaladdr:$in)>;
				3468	def : Pat<(SPUlo tglobaladdr:$in, 0), (ILAlo tglobaladdr:$in)>;
				3469	def : Pat<(SPUdform tglobaladdr:$in, imm:$imm), (ILAlsa tglobaladdr:$in)>;
				3470	def : Pat<(SPUhi tconstpool:$in , 0), (ILHUhi tconstpool:$in)>;
				3471	def : Pat<(SPUlo tconstpool:$in , 0), (ILAlo tconstpool:$in)>;
				3472	def : Pat<(SPUdform tconstpool:$in, imm:$imm), (ILAlsa tconstpool:$in)>;
				3473	def : Pat<(SPUhi tjumptable:$in, 0), (ILHUhi tjumptable:$in)>;
				3474	def : Pat<(SPUlo tjumptable:$in, 0), (ILAlo tjumptable:$in)>;
				3475	def : Pat<(SPUdform tjumptable:$in, imm:$imm), (ILAlsa tjumptable:$in)>;
				3476
				3477	// Force load of global address to a register. These forms show up in
				3478	// SPUISD::DFormAddr pseudo instructions:
				3479	/*
				3480	def : Pat<(add tglobaladdr:$in, 0), (ILAlsa tglobaladdr:$in)>;
				3481	def : Pat<(add tconstpool:$in, 0), (ILAlsa tglobaladdr:$in)>;
				3482	def : Pat<(add tjumptable:$in, 0), (ILAlsa tglobaladdr:$in)>;
				3483	*/
				3484	// Instrinsics:
				3485	include "CellSDKIntrinsics.td"