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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Test control flow
package main
import "testing"
// nor_ssa calculates NOR(a, b).
// It is implemented in a way that generates
// phi control values.
func nor_ssa(a, b bool) bool {
var c bool
if a {
c = true
}
if b {
c = true
}
if c {
return false
}
return true
}
func testPhiControl(t *testing.T) {
tests := [...][3]bool{ // a, b, want
{false, false, true},
{true, false, false},
{false, true, false},
{true, true, false},
}
for _, test := range tests {
a, b := test[0], test[1]
got := nor_ssa(a, b)
want := test[2]
if want != got {
t.Errorf("nor(%t, %t)=%t got %t", a, b, want, got)
}
}
}
func emptyRange_ssa(b []byte) bool {
for _, x := range b {
_ = x
}
return true
}
func testEmptyRange(t *testing.T) {
if !emptyRange_ssa([]byte{}) {
t.Errorf("emptyRange_ssa([]byte{})=false, want true")
}
}
func switch_ssa(a int) int {
ret := 0
switch a {
case 5:
ret += 5
case 4:
ret += 4
case 3:
ret += 3
case 2:
ret += 2
case 1:
ret += 1
}
return ret
}
func fallthrough_ssa(a int) int {
ret := 0
switch a {
case 5:
ret++
fallthrough
case 4:
ret++
fallthrough
case 3:
ret++
fallthrough
case 2:
ret++
fallthrough
case 1:
ret++
}
return ret
}
func testFallthrough(t *testing.T) {
for i := 0; i < 6; i++ {
if got := fallthrough_ssa(i); got != i {
t.Errorf("fallthrough_ssa(i) = %d, wanted %d", got, i)
}
}
}
func testSwitch(t *testing.T) {
for i := 0; i < 6; i++ {
if got := switch_ssa(i); got != i {
t.Errorf("switch_ssa(i) = %d, wanted %d", got, i)
}
}
}
type junk struct {
step int
}
// flagOverwrite_ssa is intended to reproduce an issue seen where a XOR
// was scheduled between a compare and branch, clearing flags.
//
//go:noinline
func flagOverwrite_ssa(s *junk, c int) int {
if '0' <= c && c <= '9' {
s.step = 0
return 1
}
if c == 'e' || c == 'E' {
s.step = 0
return 2
}
s.step = 0
return 3
}
func testFlagOverwrite(t *testing.T) {
j := junk{}
if got := flagOverwrite_ssa(&j, ' '); got != 3 {
t.Errorf("flagOverwrite_ssa = %d, wanted 3", got)
}
}
func TestCtl(t *testing.T) {
testPhiControl(t)
testEmptyRange(t)
testSwitch(t)
testFallthrough(t)
testFlagOverwrite(t)
}
|
