ShuriZma
/
redream
mirror of https://github.com/inolen/redream.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

remove unused arg2 parameter from constant propagation pass

This commit is contained in:
Anthony Pesch 2015-07-22 00:27:42 -07:00
parent 1b24d4af57
commit a2691d1e5b
1 changed files with 61 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

124
src/cpu/ir/passes/constant_propagation_pass.cc
View File

@ -32,20 +32,18 @@ int fold_masks[NUM_OPCODES];
void Handle##op(IRBuilder &builder, Block *block, Instr *instr)
// registers a fold callback for the specified signature
#define REGISTER_FOLD(op, r, a0, a1, a2) \
static struct _##op##_##r##_##a0##_##a1##_##a2##_init { \
_##op##_##r##_##a0##_##a1##_##a2##_init() { \
CHECK(VALUE_##a2 == VALUE_V || VALUE_##a1 == VALUE_##a2) \
<< "Expected A1 and A2 to be the same type"; \
#define REGISTER_FOLD(op, r, a0, a1) \
static struct _##op##_##r##_##a0##_##a1##_init { \
_##op##_##r##_##a0##_##a1##_init() { \
int idx = CALLBACK_IDX(OP_##op, VALUE_##a0, VALUE_##a1); \
CHECK(fold_cbs[idx] == nullptr) \
<< "Registering duplicated callback for " << Opnames[OP_##op] << "_" \
<< #r << "_" << #a0 << "_" << #a1 << "_" << #a2; \
CHECK(fold_cbs[idx] == nullptr) << "Registered duplicate callback for " \
<< Opnames[OP_##op] << "_" << #r << "_" \
<< #a0 << "_" << #a1; \
fold_cbs[idx] = \
&Handle##op<ValueType<VALUE_##r>::type, ValueType<VALUE_##a0>::type, \
ValueType<VALUE_##a1>::type>; \
} \
} op##_##r##_##a0##_##a1##_##a2##_init;
} op##_##r##_##a0##_##a1##_init;
// common helpers for fold functions
#define ARG0() instr->arg0()->value<A0>()
@ -109,80 +107,80 @@ FOLD(SELECT, ARG0_CNST) {
instr->result()->ReplaceRefsWith(ARG0() ? instr->arg1() : instr->arg2());
block->RemoveInstr(instr);
}
REGISTER_FOLD(SELECT, I8, I8, I8, V)
REGISTER_FOLD(SELECT, I16, I16, I16, V)
REGISTER_FOLD(SELECT, I32, I32, I32, V)
REGISTER_FOLD(SELECT, I64, I64, I64, V)
REGISTER_FOLD(SELECT, I8, I8, I8)
REGISTER_FOLD(SELECT, I16, I16, I16)
REGISTER_FOLD(SELECT, I32, I32, I32)
REGISTER_FOLD(SELECT, I64, I64, I64)
FOLD(EQ, ARG0_CNST | ARG1_CNST) { RESULT(ARG0() == ARG1()); }
REGISTER_FOLD(EQ, I8, I8, I8, V)
REGISTER_FOLD(EQ, I8, I16, I16, V)
REGISTER_FOLD(EQ, I8, I32, I32, V)
REGISTER_FOLD(EQ, I8, I64, I64, V)
REGISTER_FOLD(EQ, I8, F32, F32, V)
REGISTER_FOLD(EQ, I8, F64, F64, V)
REGISTER_FOLD(EQ, I8, I8, I8)
REGISTER_FOLD(EQ, I8, I16, I16)
REGISTER_FOLD(EQ, I8, I32, I32)
REGISTER_FOLD(EQ, I8, I64, I64)
REGISTER_FOLD(EQ, I8, F32, F32)
REGISTER_FOLD(EQ, I8, F64, F64)
FOLD(NE, ARG0_CNST | ARG1_CNST) { RESULT(ARG0() != ARG1()); }
REGISTER_FOLD(NE, I8, I8, I8, V)
REGISTER_FOLD(NE, I8, I16, I16, V)
REGISTER_FOLD(NE, I8, I32, I32, V)
REGISTER_FOLD(NE, I8, I64, I64, V)
REGISTER_FOLD(NE, I8, F32, F32, V)
REGISTER_FOLD(NE, I8, F64, F64, V)
REGISTER_FOLD(NE, I8, I8, I8)
REGISTER_FOLD(NE, I8, I16, I16)
REGISTER_FOLD(NE, I8, I32, I32)
REGISTER_FOLD(NE, I8, I64, I64)
REGISTER_FOLD(NE, I8, F32, F32)
REGISTER_FOLD(NE, I8, F64, F64)
FOLD(SGE, ARG0_CNST | ARG1_CNST) { RESULT(ARG0() >= ARG1()); }
REGISTER_FOLD(SGE, I8, I8, I8, V)
REGISTER_FOLD(SGE, I8, I16, I16, V)
REGISTER_FOLD(SGE, I8, I32, I32, V)
REGISTER_FOLD(SGE, I8, I64, I64, V)
REGISTER_FOLD(SGE, I8, F32, F32, V)
REGISTER_FOLD(SGE, I8, F64, F64, V)
REGISTER_FOLD(SGE, I8, I8, I8)
REGISTER_FOLD(SGE, I8, I16, I16)
REGISTER_FOLD(SGE, I8, I32, I32)
REGISTER_FOLD(SGE, I8, I64, I64)
REGISTER_FOLD(SGE, I8, F32, F32)
REGISTER_FOLD(SGE, I8, F64, F64)
FOLD(ADD, ARG0_CNST | ARG1_CNST) { RESULT(ARG0() + ARG1()); }
REGISTER_FOLD(ADD, I8, I8, I8, V)
REGISTER_FOLD(ADD, I16, I16, I16, V)
REGISTER_FOLD(ADD, I32, I32, I32, V)
REGISTER_FOLD(ADD, I64, I64, I64, V)
REGISTER_FOLD(ADD, F32, F32, F32, V)
REGISTER_FOLD(ADD, F64, F64, F64, V)
REGISTER_FOLD(ADD, I8, I8, I8)
REGISTER_FOLD(ADD, I16, I16, I16)
REGISTER_FOLD(ADD, I32, I32, I32)
REGISTER_FOLD(ADD, I64, I64, I64)
REGISTER_FOLD(ADD, F32, F32, F32)
REGISTER_FOLD(ADD, F64, F64, F64)
FOLD(SUB, ARG0_CNST | ARG1_CNST) { RESULT(ARG0() - ARG1()); }
REGISTER_FOLD(SUB, I8, I8, I8, V)
REGISTER_FOLD(SUB, I16, I16, I16, V)
REGISTER_FOLD(SUB, I32, I32, I32, V)
REGISTER_FOLD(SUB, I64, I64, I64, V)
REGISTER_FOLD(SUB, F32, F32, F32, V)
REGISTER_FOLD(SUB, F64, F64, F64, V)
REGISTER_FOLD(SUB, I8, I8, I8)
REGISTER_FOLD(SUB, I16, I16, I16)
REGISTER_FOLD(SUB, I32, I32, I32)
REGISTER_FOLD(SUB, I64, I64, I64)
REGISTER_FOLD(SUB, F32, F32, F32)
REGISTER_FOLD(SUB, F64, F64, F64)
FOLD(AND, ARG0_CNST | ARG1_CNST) { RESULT(ARG0() & ARG1()); }
REGISTER_FOLD(AND, I8, I8, I8, V)
REGISTER_FOLD(AND, I16, I16, I16, V)
REGISTER_FOLD(AND, I32, I32, I32, V)
REGISTER_FOLD(AND, I64, I64, I64, V)
REGISTER_FOLD(AND, I8, I8, I8)
REGISTER_FOLD(AND, I16, I16, I16)
REGISTER_FOLD(AND, I32, I32, I32)
REGISTER_FOLD(AND, I64, I64, I64)
FOLD(OR, ARG0_CNST | ARG1_CNST) { RESULT(ARG0() | ARG1()); }
REGISTER_FOLD(OR, I8, I8, I8, V)
REGISTER_FOLD(OR, I16, I16, I16, V)
REGISTER_FOLD(OR, I32, I32, I32, V)
REGISTER_FOLD(OR, I64, I64, I64, V)
REGISTER_FOLD(OR, I8, I8, I8)
REGISTER_FOLD(OR, I16, I16, I16)
REGISTER_FOLD(OR, I32, I32, I32)
REGISTER_FOLD(OR, I64, I64, I64)
FOLD(XOR, ARG0_CNST | ARG1_CNST) { RESULT(ARG0() ^ ARG1()); }
REGISTER_FOLD(XOR, I8, I8, I8, V)
REGISTER_FOLD(XOR, I16, I16, I16, V)
REGISTER_FOLD(XOR, I32, I32, I32, V)
REGISTER_FOLD(XOR, I64, I64, I64, V)
REGISTER_FOLD(XOR, I8, I8, I8)
REGISTER_FOLD(XOR, I16, I16, I16)
REGISTER_FOLD(XOR, I32, I32, I32)
REGISTER_FOLD(XOR, I64, I64, I64)
FOLD(SHL, ARG0_CNST | ARG1_CNST) { RESULT(ARG0() << ARG1()); }
REGISTER_FOLD(SHL, I8, I8, I32, V)
REGISTER_FOLD(SHL, I16, I16, I32, V)
REGISTER_FOLD(SHL, I32, I32, I32, V)
REGISTER_FOLD(SHL, I64, I64, I32, V)
REGISTER_FOLD(SHL, I8, I8, I32)
REGISTER_FOLD(SHL, I16, I16, I32)
REGISTER_FOLD(SHL, I32, I32, I32)
REGISTER_FOLD(SHL, I64, I64, I32)
FOLD(LSHR, ARG0_CNST | ARG1_CNST) {
using U0 = typename std::make_unsigned<A0>::type;
RESULT((A0)((U0)ARG0() >> ARG1()));
}
REGISTER_FOLD(LSHR, I8, I8, I32, V)
REGISTER_FOLD(LSHR, I16, I16, I32, V)
REGISTER_FOLD(LSHR, I32, I32, I32, V)
REGISTER_FOLD(LSHR, I64, I64, I32, V)
REGISTER_FOLD(LSHR, I8, I8, I32)
REGISTER_FOLD(LSHR, I16, I16, I32)
REGISTER_FOLD(LSHR, I32, I32, I32)
REGISTER_FOLD(LSHR, I64, I64, I32)