← Back to branch summary

~ubuntu-branches/ubuntu/hoary/binutils/hoary

« back to all changes in this revision

Viewing changes to gas/testsuite/gas/ia64/dv-raw-err.s

  • Committer: Bazaar Package Importer
  • Author(s): James Troup
  • Date: 2004-05-19 10:35:44 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20040519103544-17h3o6e8pwndydrg
Tags: 2.14.90.0.7-8
debian/rules: don't use gcc-2.95 on m68k.  Thanks to Adam Conrad for
pointing this out.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gas/testsuite/gas/ia64/dv-raw-err.s
 
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
        
 
344
// PR%, 1 - 15
 
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
        ;;
 
548
        srlz.d
 
549
        ;;
 
550
// RSE
 
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
        ;;
 
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
        
 
579
L: