llvm-project

1
#!/usr/bin/env python3
2

3
# Automatically formatted with yapf (https://github.com/google/yapf)
4

5
# Script for automatic 'opt' pipeline reduction for when using the new
6
# pass-manager (NPM). Based around the '-print-pipeline-passes' option.
7
#
8
# The reduction algorithm consists of several phases (steps).
9
#
10
# Step #0: Verify that input fails with the given pipeline and make note of the
11
# error code.
12
#
13
# Step #1: Split pipeline in two starting from front and move forward as long as
14
# first pipeline exits normally and the second pipeline fails with the expected
15
# error code. Move on to step #2 with the IR from the split point and the
16
# pipeline from the second invocation.
17
#
18
# Step #2: Remove passes from end of the pipeline as long as the pipeline fails
19
# with the expected error code.
20
#
21
# Step #3: Make several sweeps over the remaining pipeline trying to remove one
22
# pass at a time. Repeat sweeps until unable to remove any more passes.
23
#
24
# Usage example:
25
# reduce_pipeline.py --opt-binary=./build-all-Debug/bin/opt --input=input.ll --output=output.ll --passes=PIPELINE [EXTRA-OPT-ARGS ...]
26

27
import argparse
28
import pipeline
29
import shutil
30
import subprocess
31
import tempfile
32

33
parser = argparse.ArgumentParser(
34
    description="Automatic opt pipeline reducer. Unrecognized arguments are forwarded to opt."
35
)
36
parser.add_argument("--opt-binary", action="store", dest="opt_binary", default="opt")
37
parser.add_argument("--passes", action="store", dest="passes", required=True)
38
parser.add_argument("--input", action="store", dest="input", required=True)
39
parser.add_argument("--output", action="store", dest="output")
40
parser.add_argument(
41
    "--dont-expand-passes",
42
    action="store_true",
43
    dest="dont_expand_passes",
44
    help="Do not expand pipeline before starting reduction.",
45
)
46
parser.add_argument(
47
    "--dont-remove-empty-pm",
48
    action="store_true",
49
    dest="dont_remove_empty_pm",
50
    help="Do not remove empty pass-managers from the pipeline during reduction.",
51
)
52
[args, extra_opt_args] = parser.parse_known_args()
53

54
print("The following extra args will be passed to opt: {}".format(extra_opt_args))
55

56
lst = pipeline.fromStr(args.passes)
57
ll_input = args.input
58

59
# Step #-1
60
# Launch 'opt' once with '-print-pipeline-passes' to expand pipeline before
61
# starting reduction. Allows specifying a default pipelines (e.g.
62
# '-passes=default<O3>').
63
if not args.dont_expand_passes:
64
    run_args = [
65
        args.opt_binary,
66
        "-disable-symbolication",
67
        "-disable-output",
68
        "-print-pipeline-passes",
69
        "-passes={}".format(pipeline.toStr(lst)),
70
        ll_input,
71
    ]
72
    run_args.extend(extra_opt_args)
73
    opt = subprocess.run(run_args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
74
    if opt.returncode != 0:
75
        print("Failed to expand passes. Aborting.")
76
        print(run_args)
77
        print("exitcode: {}".format(opt.returncode))
78
        print(opt.stderr.decode())
79
        exit(1)
80
    stdout = opt.stdout.decode()
81
    stdout = stdout[: stdout.rfind("\n")]
82
    lst = pipeline.fromStr(stdout)
83
    print("Expanded pass sequence: {}".format(pipeline.toStr(lst)))
84

85
# Step #0
86
# Confirm that the given input, passes and options result in failure.
87
print("---Starting step #0---")
88
run_args = [
89
    args.opt_binary,
90
    "-disable-symbolication",
91
    "-disable-output",
92
    "-passes={}".format(pipeline.toStr(lst)),
93
    ll_input,
94
]
95
run_args.extend(extra_opt_args)
96
opt = subprocess.run(run_args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
97
if opt.returncode >= 0:
98
    print("Input does not result in failure as expected. Aborting.")
99
    print(run_args)
100
    print("exitcode: {}".format(opt.returncode))
101
    print(opt.stderr.decode())
102
    exit(1)
103

104
expected_error_returncode = opt.returncode
105
print('-passes="{}"'.format(pipeline.toStr(lst)))
106

107
# Step #1
108
# Try to narrow down the failing pass sequence by splitting the pipeline in two
109
# opt invocations (A and B) starting with invocation A only running the first
110
# pipeline pass and invocation B the remaining. Keep moving the split point
111
# forward as long as invocation A exits normally and invocation B fails with
112
# the expected error. This will accomplish two things first the input IR will be
113
# further reduced and second, with that IR, the reduced pipeline for invocation
114
# B will be sufficient to reproduce.
115
print("---Starting step #1---")
116
prevLstB = None
117
prevIntermediate = None
118
tmpd = tempfile.TemporaryDirectory()
119

120
for idx in range(pipeline.count(lst)):
121
    [lstA, lstB] = pipeline.split(lst, idx)
122
    if not args.dont_remove_empty_pm:
123
        lstA = pipeline.prune(lstA)
124
        lstB = pipeline.prune(lstB)
125

126
    intermediate = "intermediate-0.ll" if idx % 2 else "intermediate-1.ll"
127
    intermediate = tmpd.name + "/" + intermediate
128
    run_args = [
129
        args.opt_binary,
130
        "-disable-symbolication",
131
        "-S",
132
        "-o",
133
        intermediate,
134
        "-passes={}".format(pipeline.toStr(lstA)),
135
        ll_input,
136
    ]
137
    run_args.extend(extra_opt_args)
138
    optA = subprocess.run(run_args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
139
    run_args = [
140
        args.opt_binary,
141
        "-disable-symbolication",
142
        "-disable-output",
143
        "-passes={}".format(pipeline.toStr(lstB)),
144
        intermediate,
145
    ]
146
    run_args.extend(extra_opt_args)
147
    optB = subprocess.run(run_args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
148
    if not (optA.returncode == 0 and optB.returncode == expected_error_returncode):
149
        break
150
    prevLstB = lstB
151
    prevIntermediate = intermediate
152
if prevLstB:
153
    lst = prevLstB
154
    ll_input = prevIntermediate
155
print('-passes="{}"'.format(pipeline.toStr(lst)))
156

157
# Step #2
158
# Try removing passes from the end of the remaining pipeline while still
159
# reproducing the error.
160
print("---Starting step #2---")
161
prevLstA = None
162
for idx in reversed(range(pipeline.count(lst))):
163
    [lstA, lstB] = pipeline.split(lst, idx)
164
    if not args.dont_remove_empty_pm:
165
        lstA = pipeline.prune(lstA)
166
    run_args = [
167
        args.opt_binary,
168
        "-disable-symbolication",
169
        "-disable-output",
170
        "-passes={}".format(pipeline.toStr(lstA)),
171
        ll_input,
172
    ]
173
    run_args.extend(extra_opt_args)
174
    optA = subprocess.run(run_args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
175
    if optA.returncode != expected_error_returncode:
176
        break
177
    prevLstA = lstA
178
if prevLstA:
179
    lst = prevLstA
180
print('-passes="{}"'.format(pipeline.toStr(lst)))
181

182
# Step #3
183
# Now that we have a pipeline that is reduced both front and back we do
184
# exhaustive sweeps over the remainder trying to remove one pass at a time.
185
# Repeat as long as reduction is possible.
186
print("---Starting step #3---")
187
while True:
188
    keepGoing = False
189
    for idx in range(pipeline.count(lst)):
190
        candLst = pipeline.remove(lst, idx)
191
        if not args.dont_remove_empty_pm:
192
            candLst = pipeline.prune(candLst)
193
        run_args = [
194
            args.opt_binary,
195
            "-disable-symbolication",
196
            "-disable-output",
197
            "-passes={}".format(pipeline.toStr(candLst)),
198
            ll_input,
199
        ]
200
        run_args.extend(extra_opt_args)
201
        opt = subprocess.run(run_args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
202
        if opt.returncode == expected_error_returncode:
203
            lst = candLst
204
            keepGoing = True
205
    if not keepGoing:
206
        break
207
print('-passes="{}"'.format(pipeline.toStr(lst)))
208

209
print("---FINISHED---")
210
if args.output:
211
    shutil.copy(ll_input, args.output)
212
    print("Wrote output to '{}'.".format(args.output))
213
print('-passes="{}"'.format(pipeline.toStr(lst)))
214
exit(0)
215