[deliverable/binutils-gdb.git] / gas / testsuite / gas / ia64 / dv-raw-err.s

//	
// Detect RAW violations.  Cases taken from DV tables.
// This test is by no means complete but tries to hit the things that are 
// likely to be missed.
//	
.text
	.explicit
// AR[BSP]
	mov	ar.bspstore = r1
	mov	r0 = ar.bsp
	;;

// AR[BSPSTORE]	
	mov	ar.bspstore = r2
	mov	r3 = ar.bspstore
	;;
	
// AR[CCV]
	mov	ar.ccv = r4
	cmpxchg8.acq r5 = [r6],r7,ar.ccv
	;;
	
// AR[EC]	
	br.wtop.sptk	L
	mov	r8 = ar.ec
	;;

// AR[FPSR].sf0.controls 
	fsetc.s0	0x7f, 0x0f
	fpcmp.eq.s0	f2 = f3, f4
	;;

// AR[FPSR].sf1.controls
	fsetc.s1	0x7f, 0x0f
	fpcmp.eq.s1	f2 = f3, f4
	;;

// AR[FPSR].sf2.controls
	fsetc.s2	0x7f, 0x0f
	fpcmp.eq.s2	f2 = f3, f4
	;;

// AR[FPSR].sf3.controls
	fsetc.s3	0x7f, 0x0f
	fpcmp.eq.s3	f2 = f3, f4
	;;

// AR[FPSR].sf0.flags
	fpcmp.eq.s0	f2 = f3, f4
	fchkf.s0	L
	;;

// AR[FPSR].sf1.flags
	fpcmp.eq.s1	f2 = f3, f4
	fchkf.s1	L
	;;

// AR[FPSR].sf2.flags
	fpcmp.eq.s2	f2 = f3, f4
	fchkf.s2	L
	;;

// AR[FPSR].sf3.flags
	fpcmp.eq.s3	f2 = f3, f4
	fchkf.s3	L
	;;

// AR[FPSR].traps/rv
	mov	ar.fpsr = r0
	fcmp.eq.s3	p1, p2 = f5, f6
	;;

// AR[ITC]
	mov	ar.itc = r1
	mov	r2 = ar.itc
	;;

// AR[K]
	mov	ar.k1 = r3
	br.ia.sptk	b0
	;;
	
// AR[LC]
	br.cloop.sptk	L
	mov	r4 = ar.lc
	;;
	
// AR[PFS]
	mov	ar.pfs = r5
	epc

// AR[RNAT]	
	mov	ar.bspstore = r8
	mov	r9 = ar.rnat	
	;;
	
// AR[RSC]
	mov	ar.rsc = r10
	mov	r11 = ar.rnat
	;;	
	
// AR[UNAT]	
	mov	ar.unat = r12
	ld8.fill r13 = [r14]
	;;
	
// AR%

// BR%
	mov	b0 = r0
	mov	r0 = b0
	;;
	
// CFM	
	br.wtop.sptk	L
	fadd	f0 = f1, f32	// read from rotating register region
	;;
	
// CR[CMCV]
	mov	cr.cmcv = r1
	mov	r2 = cr.cmcv	
	;;

// CR[DCR]
	mov	cr.dcr = r3
	ld8.s	r4 = [r5]
	;;

// CR[EOI]
	
// CR[GPTA]
	mov	cr.gpta = r6
	thash	r7 = r8
	;;
	srlz.d

// CR[IFA]
	mov	cr.ifa = r9
	itc.i	r10
	;;

// CR[IFS]
	mov	cr.ifs = r11
	mov	r12 = cr.ifs
	;;

// CR[IHA]
	mov	cr.iha = r13
	mov	r14 = cr.iha
	;;

// CR[IIM]
	mov	cr.iim = r15
	mov	r16 = cr.iim
	;;

// CR[IIP] 
	mov	cr.iip = r17
	rfi
	;;

// CR[IIPA]
	mov	cr.iipa = r19
	mov	r20 = cr.iipa
	;;

// CR[IPSR]
	mov	cr.ipsr = r21
	rfi
	;;

// CR[IRR%]
	mov	r22 = cr.ivr
	mov	r23 = cr.irr0
	;;
	
// CR[ISR]
	mov	cr.isr = r24
	mov	r25 = cr.isr
	;;	
	
// CR[ITIR]
	mov	cr.itir = r26
	itc.d	r27
	;;	
	
// CR[ITM]
	mov	cr.itm = r28
	mov	r29 = cr.itm
	;;	
	
// CR[ITV]
	mov	cr.itv = r0
	mov	r1 = cr.itv
	;;	
	
// CR[IVR] (all writes are implicit in other resource usage)
	
// CR[IVA]
	mov	cr.iva = r0
	mov	r1 = cr.iva
	;;	
	
// CR[LID]
	mov	cr.lid = r0
	mov	r1 = cr.lid
	;;	
	srlz.d
	
// CR[LRR%]
	mov	cr.lrr0 = r0
	mov	r1 = cr.lrr0
	;;
	
// CR[PMV]
	mov	cr.pmv = r0
	mov	r1 = cr.pmv
	;;
	
// CR[PTA]
	mov	cr.pta = r0
	thash	r1 = r2
	;;
	
// CR[TPR]
	mov	cr.tpr = r0
	mov	r1 = cr.ivr	// data
	;;
	srlz.d
	mov	cr.tpr = r2
	mov	psr.l = r3	// other
	;;
	srlz.d
	
// DBR# 
	mov	dbr[r0] = r1
	mov	r2 = dbr[r3]
	;;	
	srlz.d
	mov	dbr[r4] = r5
	probe.r	r6 = r7, r8
	;;
	srlz.d
	
// DTC
	ptc.e	r0
	fc	r1
	;;
	srlz.d
	itr.i	itr[r2] = r3
	ptc.e	r4
	;;
	
// DTC_LIMIT/ITC_LIMIT 
	ptc.g	r0, r1		// NOTE: GAS automatically emits stops after 
	ptc.ga	r2, r3		//  ptc.g/ptc.ga, so this conflict is no     
	;;			//  longer possible in GAS-generated assembly
	srlz.d

// DTR
	itr.d	dtr[r0] = r1
	tak	r2 = r3
	;;
	srlz.d
	ptr.d	r4, r5
	tpa	r6 = r7
	;;
	srlz.d
	
// FR%
	ldfs.c.clr	f2 = [r1]
	mov		f3 = f2		// no DV here
	;;
	mov		f4 = f5
	mov		f6 = f4
	;;

// GR%
	ld8.c.clr	r0 = [r1]	// no DV here
	mov		r2 = r0		
	;;
	mov		r3 = r4
	mov		r5 = r3
	;;

// IBR#
	mov	ibr[r0] = r1
	mov	r2 = ibr[r3]
	;;

// InService		
	mov	cr.eoi = r0
	mov	r1 = cr.ivr
	;;
	srlz.d
	mov	r2 = cr.ivr
	mov	r3 = cr.ivr	// several DVs
	;;
	mov	cr.eoi = r4
	mov	cr.eoi = r5
	;;
	
// ITC		
	ptc.e	r0
	epc
	;;
	srlz.i
	;;
	
// ITC_LIMIT (see DTC_LIMIT)
	
// ITR	
	itr.i	itr[r0] = r1
	epc
	;;
	srlz.i
	;;
	
// PKR#
	mov	pkr[r0] = r1
	probe.r	r2 = r3, r4
	;;
	srlz.d
	mov	pkr[r5] = r6
	mov	r7 = pkr[r8]
	;;
	srlz.d
	
// PMC#
	mov	pmc[r0] = r1
	mov	r2 = pmc[r3]
	;;
	srlz.d
	mov	pmc[r4] = r5
	mov	r6 = pmd[r7]
	;;
	srlz.d
	
// PMD#
	mov	pmd[r0] = r1
	mov	r2 = pmd[r3]
	;;
	
// PR%, 1 - 15
	cmp.eq	p1, p2 = r0, r1	// pr-writer/pr-reader-nobr-nomovpr
(p1)	add	r2 = r3, r4	
	;;
	mov	pr = r5, 0xffff // mov-to-pr-allreg/pr-reader-nobr-nomovpr
(p2)	add	r6 = r7, r8	
	;;
	fcmp.eq p5, p6 = f2, f3 // pr-writer-fp/pr-reader-br
(p5)	br.cond.sptk	b0
	;;
	cmp.eq	p7, p8 = r11, r12
(p7)	br.cond.sptk	b1	// no DV here
	;;
	
// PR63
	br.wtop.sptk	L
(p63)	add	r0 = r1, r2
	;;
	fcmp.eq p62, p63 = f2, f3
(p63)	add	r3 = r4, r5	
	;;
	cmp.eq p62, p63 = r6, r7 // no DV here
(p63)	br.cond.sptk	b0
	;;	

// PSR.ac
	rum	(1<<3)
	ld8	r0 = [r1]
	;;

// PSR.be
	rum	(1<<1)
	ld8	r0 = [r1]
	;;
	
// PSR.bn
	bsw.0
	mov	r0 = r15	// no DV here, since gr < 16
	;;
	bsw.1			// GAS automatically emits a stop after bsw.n
	mov	r1 = r16	// so this conflict is avoided               
	;;
	
// PSR.cpl
	epc
	st8	[r0] = r1
	;;
	epc
	mov	r2 = ar.itc
	;;
	epc
	mov	ar.itc = r3
	;;
	epc
	mov	ar.rsc = r4
	;;
	epc
	mov	ar.k0 = r5
	;;
	epc
	mov	r6 = pmd[r7]
	;;
	epc
	mov	ar.bsp = r8	// no DV here
	;;
	epc
	mov	r9 = ar.bsp	// no DV here
	;;
	epc
	mov	cr.ifa = r10	// any mov-to/from-cr is a DV
	;;
	epc
	mov	r11 = cr.eoi	// any mov-to/from-cr is a DV
	;;

// PSR.da (rfi is the only writer)
// PSR.db (also ac,be,dt,pk)
	mov	psr.l = r0
	ld8	r1 = [r2]
	;;
	srlz.d

// PSR.dd (rfi is the only writer)
	
// PSR.dfh
	mov	psr.l = r0
	mov	f64 = f65
	;;
	srlz.d

// PSR.dfl
	mov	psr.l = r0
	mov	f3 = f4	
	;;
	srlz.d
	
// PSR.di
	rsm	(1<<22)
	mov	r0 = psr
	;;

// PSR.dt
	rsm	(1<<17)
	ld8	r0 = [r1]
	;;
	
// PSR.ed (rfi is the only writer)
// PSR.i
	ssm	(1<<14)
	mov	r0 = psr
	;;
	
// PSR.ia (no DV semantics)
// PSR.ic
	ssm	(1<<13)
	mov	r0 = psr
	;;
	srlz.d
	rsm	(1<<13)
	mov	r1 = cr.itir
	;;
	srlz.d
	rsm	(1<<13)
	mov	r1 = cr.irr0	// no DV here
	;;
	srlz.d

// PSR.id (rfi is the only writer)
// PSR.is (br.ia and rfi are the only writers)
// PSR.it (rfi is the only writer)
// PSR.lp
	mov	psr.l = r0
	br.ret.sptk	b0
	;;

// PSR.mc (rfi is the only writer)
// PSR.mfh
	mov	f32 = f33
	mov	r0 = psr
	;;

// PSR.mfl
	mov	f2 = f3
	mov	r0 = psr
	;;

// PSR.pk
	rsm	(1<<15)
	ld8	r0 = [r1]
	;;
	rsm	(1<<15)
	mov	r2 = psr
	;;

// PSR.pp
	rsm	(1<<21)
	mov	r0 = psr
	;;

// PSR.ri (no DV semantics)
// PSR.rt
	mov	psr.l = r0
	flushrs
	;;
	srlz.d

// PSR.si
	rsm	(1<<23)
	mov	r0 = ar.itc
	;;
	ssm	(1<<23)
	mov	r1 = ar.ec	// no DV here
	;;

// PSR.sp
	ssm	(1<<20)
	mov	r0 = pmd[r1]
	;;
	ssm	(1<<20)
	rum	0xff
	;;
	ssm	(1<<20)
	mov	r0 = rr[r1]
	;;

// PSR.ss (rfi is the only writer)
// PSR.tb
	mov	psr.l = r0
	chk.s	r0, L
	;;

// PSR.up
	rsm	(1<<2)
	mov	r0 = psr.um
	;;
	srlz.d

// RR#
	mov	rr[r0] = r1
	ld8	r2 = [r0]	// data
	;;
	mov	rr[r4] = r5
	mov	r6 = rr[r7]	// impliedf
	;;
	srlz.d
	;;
// RSE
	
// GR%, additional cases
// addl
	mov	r2 = r32
	addl	r3 = 12345, r2	// impliedf, IA64_OPND_R3_2
	;;
// postinc
	ld8	r2 = [r32], 8
	mov	r8 = r32	// impliedf
	;;

// PR%, 16 - 62
	cmp.eq	p21, p22 = r0, r1 // pr-writer/pr-reader-nobr-nomovpr
(p21)	add	r2 = r3, r4	
	;;
	mov	pr = r5, 0x1ffff // mov-to-pr-allreg/pr-reader-nobr-nomovpr
(p22)	add	r6 = r7, r8	
	;;
	mov	pr.rot = 0xffff0000 // mov-to-pr-rotreg/pr-reader-nobr-nomovpr
(p23)	add	r9 = r10, r11
	;;
	fcmp.eq p25, p26 = f2, f3 // pr-writer-fp/pr-reader-br
(p25)	br.cond.sptk	b0
	;;
	cmp.eq	p27, p28 = r11, r12
(p27)	br.cond.sptk	b1	// no DV here
	;;
	
// postinc
	st8	[r6] = r8, 16
	add	r7 = 8, r6	// impliedf
	;;
	ldfd	f14 = [r6], 16
	add	r7 = 8, r6	// impliedf
	;;
	stfd	[r6] = f14, 16
	add	r7 = r8, r6
	;;
	add	r6 = 8, r7
	ld8	r8 = [r6], 16	// impliedf, WAW
	;;
	add	r6 = 8, r7
	ldfd	f14 = [r6], 16	// impliedf, WAW
	;;

L:
Commit	Line	Data
800eeca4 JW	1	//
	2	// Detect RAW violations. Cases taken from DV tables.
	3	// This test is by no means complete but tries to hit the things that are
	4	// likely to be missed.
	5	//
	6	.text
	7	.explicit
	8	// AR[BSP]
	9	mov ar.bspstore = r1
	10	mov r0 = ar.bsp
	11	;;
	12
	13	// AR[BSPSTORE]
	14	mov ar.bspstore = r2
	15	mov r3 = ar.bspstore
	16	;;
	17
	18	// AR[CCV]
	19	mov ar.ccv = r4
	20	cmpxchg8.acq r5 = [r6],r7,ar.ccv
	21	;;
	22
	23	// AR[EC]
	24	br.wtop.sptk L
	25	mov r8 = ar.ec
	26	;;
	27
	28	// AR[FPSR].sf0.controls
	29	fsetc.s0 0x7f, 0x0f
	30	fpcmp.eq.s0 f2 = f3, f4
	31	;;
	32
	33	// AR[FPSR].sf1.controls
	34	fsetc.s1 0x7f, 0x0f
	35	fpcmp.eq.s1 f2 = f3, f4
	36	;;
	37
	38	// AR[FPSR].sf2.controls
	39	fsetc.s2 0x7f, 0x0f
	40	fpcmp.eq.s2 f2 = f3, f4
	41	;;
	42
	43	// AR[FPSR].sf3.controls
	44	fsetc.s3 0x7f, 0x0f
	45	fpcmp.eq.s3 f2 = f3, f4
	46	;;
	47
	48	// AR[FPSR].sf0.flags
	49	fpcmp.eq.s0 f2 = f3, f4
	50	fchkf.s0 L
	51	;;
	52
	53	// AR[FPSR].sf1.flags
	54	fpcmp.eq.s1 f2 = f3, f4
	55	fchkf.s1 L
	56	;;
	57
	58	// AR[FPSR].sf2.flags
	59	fpcmp.eq.s2 f2 = f3, f4
	60	fchkf.s2 L
	61	;;
	62
	63	// AR[FPSR].sf3.flags
	64	fpcmp.eq.s3 f2 = f3, f4
65	fchkf.s3 L
66	;;
67
68	// AR[FPSR].traps/rv
69	mov ar.fpsr = r0
70	fcmp.eq.s3 p1, p2 = f5, f6
71	;;
72
73	// AR[ITC]
74	mov ar.itc = r1
75	mov r2 = ar.itc
76	;;
77
78	// AR[K]
79	mov ar.k1 = r3
80	br.ia.sptk b0
81	;;
82
83	// AR[LC]
84	br.cloop.sptk L
85	mov r4 = ar.lc
86	;;
87
88	// AR[PFS]
89	mov ar.pfs = r5
90	epc
91
92	// AR[RNAT]
93	mov ar.bspstore = r8
94	mov r9 = ar.rnat
95	;;
96
97	// AR[RSC]
98	mov ar.rsc = r10
99	mov r11 = ar.rnat
100	;;
101
102	// AR[UNAT]
103	mov ar.unat = r12
104	ld8.fill r13 = [r14]
105	;;
106
107	// AR%
108
109	// BR%
110	mov b0 = r0
111	mov r0 = b0
112	;;
113
114	// CFM
115	br.wtop.sptk L
116	fadd f0 = f1, f32 // read from rotating register region
117	;;
118
119	// CR[CMCV]
120	mov cr.cmcv = r1
121	mov r2 = cr.cmcv
122	;;
123
124	// CR[DCR]
125	mov cr.dcr = r3
126	ld8.s r4 = [r5]
127	;;
128
129	// CR[EOI]
130
131	// CR[GPTA]
132	mov cr.gpta = r6
133	thash r7 = r8
134	;;
135	srlz.d
136
137	// CR[IFA]
138	mov cr.ifa = r9
139	itc.i r10
140	;;
141
142	// CR[IFS]
143	mov cr.ifs = r11
144	mov r12 = cr.ifs
145	;;
146
147	// CR[IHA]
148	mov cr.iha = r13
149	mov r14 = cr.iha
150	;;
151
152	// CR[IIM]
153	mov cr.iim = r15
154	mov r16 = cr.iim
155	;;
156
157	// CR[IIP]
158	mov cr.iip = r17
159	rfi
160	;;
161
162	// CR[IIPA]
163	mov cr.iipa = r19
164	mov r20 = cr.iipa
165	;;
166
167	// CR[IPSR]
168	mov cr.ipsr = r21
169	rfi
170	;;
171
172	// CR[IRR%]
173	mov r22 = cr.ivr
174	mov r23 = cr.irr0
175	;;
176
177	// CR[ISR]
178	mov cr.isr = r24
179	mov r25 = cr.isr
180	;;
181
182	// CR[ITIR]
183	mov cr.itir = r26
184	itc.d r27
185	;;
186
187	// CR[ITM]
188	mov cr.itm = r28
189	mov r29 = cr.itm
190	;;
191
192	// CR[ITV]
193	mov cr.itv = r0
194	mov r1 = cr.itv
195	;;
196
197	// CR[IVR] (all writes are implicit in other resource usage)
198
199	// CR[IVA]
200	mov cr.iva = r0
201	mov r1 = cr.iva
202	;;
203
204	// CR[LID]
205	mov cr.lid = r0
206	mov r1 = cr.lid
207	;;
208	srlz.d
209
210	// CR[LRR%]
211	mov cr.lrr0 = r0
212	mov r1 = cr.lrr0
213	;;
214
215	// CR[PMV]
216	mov cr.pmv = r0
217	mov r1 = cr.pmv
218	;;
219
220	// CR[PTA]
221	mov cr.pta = r0
222	thash r1 = r2
223	;;
224
225	// CR[TPR]
226	mov cr.tpr = r0
227	mov r1 = cr.ivr // data
228	;;
229	srlz.d
230	mov cr.tpr = r2
231	mov psr.l = r3 // other
232	;;
233	srlz.d
234
235	// DBR#
236	mov dbr[r0] = r1
237	mov r2 = dbr[r3]
238	;;
239	srlz.d
240	mov dbr[r4] = r5
241	probe.r r6 = r7, r8
242	;;
243	srlz.d
244
245	// DTC
246	ptc.e r0
247	fc r1
248	;;
249	srlz.d
250	itr.i itr[r2] = r3
251	ptc.e r4
252	;;
253
254	// DTC_LIMIT/ITC_LIMIT
255	ptc.g r0, r1 // NOTE: GAS automatically emits stops after
256	ptc.ga r2, r3 // ptc.g/ptc.ga, so this conflict is no
257	;; // longer possible in GAS-generated assembly
258	srlz.d
259
260	// DTR
261	itr.d dtr[r0] = r1
262	tak r2 = r3
263	;;
264	srlz.d
265	ptr.d r4, r5
266	tpa r6 = r7
267	;;
268	srlz.d
269
270	// FR%
271	ldfs.c.clr f2 = [r1]
272	mov f3 = f2 // no DV here
273	;;
274	mov f4 = f5
275	mov f6 = f4
276	;;
277
278	// GR%
279	ld8.c.clr r0 = [r1] // no DV here
280	mov r2 = r0
281	;;
282	mov r3 = r4
283	mov r5 = r3
284	;;
285
286	// IBR#
287	mov ibr[r0] = r1
288	mov r2 = ibr[r3]
289	;;
290
291	// InService
292	mov cr.eoi = r0
293	mov r1 = cr.ivr
294	;;
295	srlz.d
296	mov r2 = cr.ivr
297	mov r3 = cr.ivr // several DVs
298	;;
299	mov cr.eoi = r4
300	mov cr.eoi = r5
301	;;
302
303	// ITC
304	ptc.e r0
305	epc
306	;;
307	srlz.i
308	;;
309
310	// ITC_LIMIT (see DTC_LIMIT)
311
312	// ITR
313	itr.i itr[r0] = r1
314	epc
315	;;
316	srlz.i
317	;;
318
319	// PKR#
320	mov pkr[r0] = r1
321	probe.r r2 = r3, r4
322	;;
323	srlz.d
324	mov pkr[r5] = r6
325	mov r7 = pkr[r8]
326	;;
327	srlz.d
328
329	// PMC#
330	mov pmc[r0] = r1
331	mov r2 = pmc[r3]
332	;;
333	srlz.d
334	mov pmc[r4] = r5
335	mov r6 = pmd[r7]
336	;;
337	srlz.d
338
339	// PMD#
340	mov pmd[r0] = r1
341	mov r2 = pmd[r3]
342	;;
343
139368c9	344	// PR%, 1 - 15
800eeca4 JW	345	cmp.eq p1, p2 = r0, r1 // pr-writer/pr-reader-nobr-nomovpr
	346	(p1) add r2 = r3, r4
	347	;;
	348	mov pr = r5, 0xffff // mov-to-pr-allreg/pr-reader-nobr-nomovpr
	349	(p2) add r6 = r7, r8
	350	;;
	351	fcmp.eq p5, p6 = f2, f3 // pr-writer-fp/pr-reader-br
	352	(p5) br.cond.sptk b0
	353	;;
	354	cmp.eq p7, p8 = r11, r12
	355	(p7) br.cond.sptk b1 // no DV here
	356	;;
	357
	358	// PR63
	359	br.wtop.sptk L
	360	(p63) add r0 = r1, r2
	361	;;
	362	fcmp.eq p62, p63 = f2, f3
	363	(p63) add r3 = r4, r5
	364	;;
	365	cmp.eq p62, p63 = r6, r7 // no DV here
	366	(p63) br.cond.sptk b0
	367	;;
	368
	369	// PSR.ac
	370	rum (1<<3)
	371	ld8 r0 = [r1]
	372	;;
	373
	374	// PSR.be
	375	rum (1<<1)
	376	ld8 r0 = [r1]
	377	;;
	378
	379	// PSR.bn
	380	bsw.0
	381	mov r0 = r15 // no DV here, since gr < 16
	382	;;
	383	bsw.1 // GAS automatically emits a stop after bsw.n
	384	mov r1 = r16 // so this conflict is avoided
	385	;;
	386
	387	// PSR.cpl
	388	epc
	389	st8 [r0] = r1
	390	;;
	391	epc
	392	mov r2 = ar.itc
	393	;;
	394	epc
	395	mov ar.itc = r3
	396	;;
	397	epc
	398	mov ar.rsc = r4
	399	;;
	400	epc
	401	mov ar.k0 = r5
	402	;;
	403	epc
	404	mov r6 = pmd[r7]
	405	;;
	406	epc
	407	mov ar.bsp = r8 // no DV here
	408	;;
409	epc
410	mov r9 = ar.bsp // no DV here
411	;;
412	epc
413	mov cr.ifa = r10 // any mov-to/from-cr is a DV
414	;;
415	epc
416	mov r11 = cr.eoi // any mov-to/from-cr is a DV
417	;;
418
419	// PSR.da (rfi is the only writer)
420	// PSR.db (also ac,be,dt,pk)
421	mov psr.l = r0
422	ld8 r1 = [r2]
423	;;
424	srlz.d
425
426	// PSR.dd (rfi is the only writer)
427
428	// PSR.dfh
429	mov psr.l = r0
430	mov f64 = f65
431	;;
432	srlz.d
433
434	// PSR.dfl
435	mov psr.l = r0
436	mov f3 = f4
437	;;
438	srlz.d
439
440	// PSR.di
441	rsm (1<<22)
442	mov r0 = psr
443	;;
444
445	// PSR.dt
446	rsm (1<<17)
447	ld8 r0 = [r1]
448	;;
449
450	// PSR.ed (rfi is the only writer)
451	// PSR.i
452	ssm (1<<14)
453	mov r0 = psr
454	;;
455
456	// PSR.ia (no DV semantics)
457	// PSR.ic
458	ssm (1<<13)
459	mov r0 = psr
460	;;
461	srlz.d
462	rsm (1<<13)
463	mov r1 = cr.itir
464	;;
465	srlz.d
466	rsm (1<<13)
467	mov r1 = cr.irr0 // no DV here
468	;;
469	srlz.d
470
471	// PSR.id (rfi is the only writer)
472	// PSR.is (br.ia and rfi are the only writers)
473	// PSR.it (rfi is the only writer)
474	// PSR.lp
475	mov psr.l = r0
476	br.ret.sptk b0
477	;;
478
479	// PSR.mc (rfi is the only writer)
480	// PSR.mfh
481	mov f32 = f33
482	mov r0 = psr
483	;;
484
485	// PSR.mfl
486	mov f2 = f3
487	mov r0 = psr
488	;;
489
490	// PSR.pk
491	rsm (1<<15)
492	ld8 r0 = [r1]
493	;;
494	rsm (1<<15)
495	mov r2 = psr
496	;;
497
498	// PSR.pp
499	rsm (1<<21)
500	mov r0 = psr
501	;;
502
503	// PSR.ri (no DV semantics)
504	// PSR.rt
505	mov psr.l = r0
506	flushrs
507	;;
508	srlz.d
509
510	// PSR.si
511	rsm (1<<23)
512	mov r0 = ar.itc
513	;;
514	ssm (1<<23)
515	mov r1 = ar.ec // no DV here
516	;;
517
518	// PSR.sp
519	ssm (1<<20)
520	mov r0 = pmd[r1]
521	;;
522	ssm (1<<20)
523	rum 0xff
524	;;
525	ssm (1<<20)
526	mov r0 = rr[r1]
527	;;
528
529	// PSR.ss (rfi is the only writer)
530	// PSR.tb
531	mov psr.l = r0
532	chk.s r0, L
533	;;
534
535	// PSR.up
536	rsm (1<<2)
537	mov r0 = psr.um
538	;;
539	srlz.d
540
541	// RR#
542	mov rr[r0] = r1
543	ld8 r2 = [r0] // data
544	;;
545	mov rr[r4] = r5
546	mov r6 = rr[r7] // impliedf
547	;;
50b81f19 JW	548	srlz.d
50b81f19 JW	549	;;
800eeca4	550	// RSE
50b81f19 JW	551
	552	// GR%, additional cases
	553	// addl
	554	mov r2 = r32
	555	addl r3 = 12345, r2 // impliedf, IA64_OPND_R3_2
	556	;;
	557	// postinc
	558	ld8 r2 = [r32], 8
	559	mov r8 = r32 // impliedf
	560	;;
139368c9 JW	561
	562	// PR%, 16 - 62
	563	cmp.eq p21, p22 = r0, r1 // pr-writer/pr-reader-nobr-nomovpr
	564	(p21) add r2 = r3, r4
	565	;;
	566	mov pr = r5, 0x1ffff // mov-to-pr-allreg/pr-reader-nobr-nomovpr
	567	(p22) add r6 = r7, r8
	568	;;
	569	mov pr.rot = 0xffff0000 // mov-to-pr-rotreg/pr-reader-nobr-nomovpr
	570	(p23) add r9 = r10, r11
	571	;;
	572	fcmp.eq p25, p26 = f2, f3 // pr-writer-fp/pr-reader-br
	573	(p25) br.cond.sptk b0
	574	;;
	575	cmp.eq p27, p28 = r11, r12
	576	(p27) br.cond.sptk b1 // no DV here
	577	;;
	578
bad9ceea JJ	579	// postinc
	580	st8 [r6] = r8, 16
	581	add r7 = 8, r6 // impliedf
	582	;;
	583	ldfd f14 = [r6], 16
	584	add r7 = 8, r6 // impliedf
	585	;;
	586	stfd [r6] = f14, 16
	587	add r7 = r8, r6
	588	;;
	589	add r6 = 8, r7
	590	ld8 r8 = [r6], 16 // impliedf, WAW
	591	;;
	592	add r6 = 8, r7
	593	ldfd f14 = [r6], 16 // impliedf, WAW
	594	;;
	595
	596	L: