1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
|
result code = 0
standard error = {
}
standard output = {
let %63 : Ptr<Array<Vec<Float32,4>,64>,1> = var()
let %96 : Ptr<StructuredBuffer<Vec<Float32,4>>,0> = var()
let %282 : Ptr<RWStructuredBuffer<Vec<Float32,4>>,0> = var()
func @_S04mainp3 : (Int32, Int32, Int32) -> Void
{
block %14( param %15 : Int32,
param %24 : Int32,
param %32 : Int32)
:
let %21 : Ptr<Int32,0> = var()
store(%21, %15)
let %29 : Ptr<Int32,0> = var()
store(%29, %24)
let %37 : Ptr<Int32,0> = var()
store(%37, %32)
let %64 : Int32 = load(%29)
let %69 : Ptr<Vec<Float32,4>,0> = getElementPtr(%63, %64)
let %97 : StructuredBuffer<Vec<Float32,4>> = load(%96)
let %100 : Int32 = load(%21)
let %101 : Vec<Float32,4> = bufferLoad(%97, %100)
store(%69, %101)
let %110 : Ptr<Int32,0> = var()
let %118 : Int32 = construct(1)
store(%110, %118)
loop(%123, %129, %132)
block %123:
let %139 : Int32 = load(%110)
let %148 : Int32 = construct(64)
let %149 : Bool = cmpLT(%139, %148)
loopTest(%149, %126, %129)
block %126:
GroupMemoryBarrierWithGroupSync()
let %174 : Int32 = load(%29)
let %179 : Ptr<Vec<Float32,4>,0> = getElementPtr(%63, %174)
let %184 : Ptr<Vec<Float32,4>,0> = var()
let %185 : Vec<Float32,4> = load(%179)
store(%184, %185)
let %204 : Int32 = load(%29)
let %207 : Int32 = load(%110)
let %208 : Int32 = sub(%204, %207)
let %213 : Ptr<Vec<Float32,4>,0> = getElementPtr(%63, %208)
let %214 : Vec<Float32,4> = load(%213)
let %215 : Vec<Float32,4> = load(%184)
let %216 : Vec<Float32,4> = add(%215, %214)
store(%184, %216)
let %219 : Vec<Float32,4> = load(%184)
store(%179, %219)
unconditionalBranch(%132)
block %132:
let %232 : Ptr<Int32,0> = var()
let %233 : Int32 = load(%110)
store(%232, %233)
let %244 : Int32 = construct(1)
let %245 : Int32 = load(%232)
let %246 : Int32 = shl(%245, %244)
store(%232, %246)
let %249 : Int32 = load(%232)
store(%110, %249)
unconditionalBranch(%123)
block %129:
GroupMemoryBarrierWithGroupSync()
let %283 : RWStructuredBuffer<Vec<Float32,4>> = load(%282)
let %286 : Int32 = load(%21)
let %300 : Ptr<Vec<Float32,4>,0> = getElementPtr(%63, 0)
let %301 : Vec<Float32,4> = load(%300)
bufferStore(%283, %286, %301)
return_void()
}
}
|
