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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
;; Both functions in this testcase should codegen to the same function, and
;; neither of them should require spilling anything to the stack.
; RUN: llvm-upgrade < %s | llvm-as | llc -march=x86 -stats 2>&1 | not grep 'Number of register spills'
;; This can be compiled to use three registers if the loads are not
;; folded into the multiplies, 2 registers otherwise.
int %regpressure1(int* %P) {
%A = load int* %P
%Bp = getelementptr int* %P, int 1
%B = load int* %Bp
%s1 = mul int %A, %B
%Cp = getelementptr int* %P, int 2
%C = load int* %Cp
%s2 = mul int %s1, %C
%Dp = getelementptr int* %P, int 3
%D = load int* %Dp
%s3 = mul int %s2, %D
%Ep = getelementptr int* %P, int 4
%E = load int* %Ep
%s4 = mul int %s3, %E
%Fp = getelementptr int* %P, int 5
%F = load int* %Fp
%s5 = mul int %s4, %F
%Gp = getelementptr int* %P, int 6
%G = load int* %Gp
%s6 = mul int %s5, %G
%Hp = getelementptr int* %P, int 7
%H = load int* %Hp
%s7 = mul int %s6, %H
%Ip = getelementptr int* %P, int 8
%I = load int* %Ip
%s8 = mul int %s7, %I
%Jp = getelementptr int* %P, int 9
%J = load int* %Jp
%s9 = mul int %s8, %J
ret int %s9
}
;; This testcase should produce identical code to the test above.
int %regpressure2(int* %P) {
%A = load int* %P
%Bp = getelementptr int* %P, int 1
%B = load int* %Bp
%Cp = getelementptr int* %P, int 2
%C = load int* %Cp
%Dp = getelementptr int* %P, int 3
%D = load int* %Dp
%Ep = getelementptr int* %P, int 4
%E = load int* %Ep
%Fp = getelementptr int* %P, int 5
%F = load int* %Fp
%Gp = getelementptr int* %P, int 6
%G = load int* %Gp
%Hp = getelementptr int* %P, int 7
%H = load int* %Hp
%Ip = getelementptr int* %P, int 8
%I = load int* %Ip
%Jp = getelementptr int* %P, int 9
%J = load int* %Jp
%s1 = mul int %A, %B
%s2 = mul int %s1, %C
%s3 = mul int %s2, %D
%s4 = mul int %s3, %E
%s5 = mul int %s4, %F
%s6 = mul int %s5, %G
%s7 = mul int %s6, %H
%s8 = mul int %s7, %I
%s9 = mul int %s8, %J
ret int %s9
}
;; adds should be the same as muls.
int %regpressure3(short* %P, bool %Cond, int* %Other) {
%A = load short* %P
%Bp = getelementptr short* %P, int 1
%B = load short* %Bp
%Cp = getelementptr short* %P, int 2
%C = load short* %Cp
%Dp = getelementptr short* %P, int 3
%D = load short* %Dp
%Ep = getelementptr short* %P, int 4
%E = load short* %Ep
%Fp = getelementptr short* %P, int 5
%F = load short* %Fp
%Gp = getelementptr short* %P, int 6
%G = load short* %Gp
%Hp = getelementptr short* %P, int 7
%H = load short* %Hp
%Ip = getelementptr short* %P, int 8
%I = load short* %Ip
%Jp = getelementptr short* %P, int 9
%J = load short* %Jp
;; These casts prevent folding the loads into the adds.
%A = cast short %A to int
%B = cast short %B to int
%D = cast short %D to int
%C = cast short %C to int
%E = cast short %E to int
%F = cast short %F to int
%G = cast short %G to int
%H = cast short %H to int
%I = cast short %I to int
%J = cast short %J to int
%s1 = add int %A, %B
%s2 = add int %C, %s1
%s3 = add int %D, %s2
%s4 = add int %E, %s3
%s5 = add int %F, %s4
%s6 = add int %G, %s5
%s7 = add int %H, %s6
%s8 = add int %I, %s7
%s9 = add int %J, %s8
ret int %s9
}
|
