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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
// Copyright (c) 2017 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "source/opt/strength_reduction_pass.h"
#include <cstring>
#include <memory>
#include <utility>
#include <vector>
#include "source/opt/def_use_manager.h"
#include "source/opt/ir_context.h"
#include "source/opt/log.h"
#include "source/opt/reflect.h"
namespace spvtools {
namespace opt {
namespace {
// Count the number of trailing zeros in the binary representation of
// |constVal|.
uint32_t CountTrailingZeros(uint32_t constVal) {
// Faster if we use the hardware count trailing zeros instruction.
// If not available, we could create a table.
uint32_t shiftAmount = 0;
while ((constVal & 1) == 0) {
++shiftAmount;
constVal = (constVal >> 1);
}
return shiftAmount;
}
// Return true if |val| is a power of 2.
bool IsPowerOf2(uint32_t val) {
// The idea is that the & will clear out the least
// significant 1 bit. If it is a power of 2, then
// there is exactly 1 bit set, and the value becomes 0.
if (val == 0) return false;
return ((val - 1) & val) == 0;
}
} // namespace
Pass::Status StrengthReductionPass::Process() {
// Initialize the member variables on a per module basis.
int32_type_id_ = 0;
uint32_type_id_ = 0;
std::memset(constant_ids_, 0, sizeof(constant_ids_));
FindIntTypesAndConstants();
return ScanFunctions();
}
Pass::Status StrengthReductionPass::ReplaceMultiplyByPowerOf2(
BasicBlock::iterator* inst) {
assert((*inst)->opcode() == spv::Op::OpIMul &&
"Only works for multiplication of integers.");
bool modified = false;
// Currently only works on 32-bit integers.
if ((*inst)->type_id() != int32_type_id_ &&
(*inst)->type_id() != uint32_type_id_) {
return Status::SuccessWithoutChange;
}
// Check the operands for a constant that is a power of 2.
for (int i = 0; i < 2; i++) {
uint32_t opId = (*inst)->GetSingleWordInOperand(i);
Instruction* opInst = get_def_use_mgr()->GetDef(opId);
if (opInst->opcode() == spv::Op::OpConstant) {
// We found a constant operand.
uint32_t constVal = opInst->GetSingleWordOperand(2);
if (IsPowerOf2(constVal)) {
modified = true;
uint32_t shiftAmount = CountTrailingZeros(constVal);
uint32_t shiftConstResultId = GetConstantId(shiftAmount);
if (shiftConstResultId == 0) return Status::Failure;
// Create the new instruction.
uint32_t newResultId = TakeNextId();
if (newResultId == 0) return Status::Failure;
std::vector<Operand> newOperands;
newOperands.push_back((*inst)->GetInOperand(1 - i));
Operand shiftOperand(spv_operand_type_t::SPV_OPERAND_TYPE_ID,
{shiftConstResultId});
newOperands.push_back(shiftOperand);
std::unique_ptr<Instruction> newInstruction(
new Instruction(context(), spv::Op::OpShiftLeftLogical,
(*inst)->type_id(), newResultId, newOperands));
// Insert the new instruction and update the data structures.
(*inst) = (*inst).InsertBefore(std::move(newInstruction));
get_def_use_mgr()->AnalyzeInstDefUse(&*(*inst));
++(*inst);
context()->ReplaceAllUsesWith((*inst)->result_id(), newResultId);
// Remove the old instruction.
Instruction* inst_to_delete = &*(*inst);
--(*inst);
context()->KillInst(inst_to_delete);
// We do not want to replace the instruction twice if both operands
// are constants that are a power of 2. So we break here.
break;
}
}
}
return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange;
}
void StrengthReductionPass::FindIntTypesAndConstants() {
analysis::Integer int32(32, true);
int32_type_id_ = context()->get_type_mgr()->GetId(&int32);
analysis::Integer uint32(32, false);
uint32_type_id_ = context()->get_type_mgr()->GetId(&uint32);
for (auto iter = get_module()->types_values_begin();
iter != get_module()->types_values_end(); ++iter) {
switch (iter->opcode()) {
case spv::Op::OpConstant:
if (iter->type_id() == uint32_type_id_) {
uint32_t value = iter->GetSingleWordOperand(2);
if (value <= 32) constant_ids_[value] = iter->result_id();
}
break;
default:
break;
}
}
}
uint32_t StrengthReductionPass::GetConstantId(uint32_t val) {
assert(val <= 32 &&
"This function does not handle constants larger than 32.");
if (constant_ids_[val] == 0) {
if (uint32_type_id_ == 0) {
analysis::Integer uint(32, false);
uint32_type_id_ = context()->get_type_mgr()->GetTypeInstruction(&uint);
}
// Construct the constant.
uint32_t resultId = TakeNextId();
if (resultId == 0) return 0;
Operand constant(spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER,
{val});
std::unique_ptr<Instruction> newConstant(new Instruction(
context(), spv::Op::OpConstant, uint32_type_id_, resultId, {constant}));
get_module()->AddGlobalValue(std::move(newConstant));
// Notify the DefUseManager about this constant.
auto constantIter = --get_module()->types_values_end();
get_def_use_mgr()->AnalyzeInstDef(&*constantIter);
// Store the result id for next time.
constant_ids_[val] = resultId;
}
return constant_ids_[val];
}
Pass::Status StrengthReductionPass::ScanFunctions() {
// I did not use |ForEachInst| in the module because the function that acts on
// the instruction gets a pointer to the instruction. We cannot use that to
// insert a new instruction. I want an iterator.
bool modified = false;
for (auto& func : *get_module()) {
for (auto& bb : func) {
for (auto inst = bb.begin(); inst != bb.end(); ++inst) {
switch (inst->opcode()) {
case spv::Op::OpIMul: {
Status s = ReplaceMultiplyByPowerOf2(&inst);
if (s == Status::Failure) return Status::Failure;
if (s == Status::SuccessWithChange) modified = true;
break;
}
default:
break;
}
}
}
}
return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange;
}
} // namespace opt
} // namespace spvtools
|
