diff options
| -rw-r--r-- | compiler/optimizing/constant_folding.cc | 180 | ||||
| -rw-r--r-- | compiler/optimizing/instruction_simplifier.cc | 265 | ||||
| -rw-r--r-- | compiler/optimizing/nodes.cc | 33 | ||||
| -rw-r--r-- | compiler/optimizing/nodes.h | 48 | ||||
| -rw-r--r-- | runtime/primitive.h | 4 | ||||
| -rw-r--r-- | runtime/utils.h | 6 | ||||
| -rw-r--r-- | test/442-checker-constant-folding/src/Main.java | 230 | ||||
| -rw-r--r-- | test/458-checker-instruction-simplification/expected.txt | 0 | ||||
| -rw-r--r-- | test/458-checker-instruction-simplification/info.txt | 1 | ||||
| -rw-r--r-- | test/458-checker-instruction-simplification/src/Main.java | 300 |
10 files changed, 1039 insertions, 28 deletions
diff --git a/compiler/optimizing/constant_folding.cc b/compiler/optimizing/constant_folding.cc index fca9933..ec0cc3e 100644 --- a/compiler/optimizing/constant_folding.cc +++ b/compiler/optimizing/constant_folding.cc @@ -18,7 +18,28 @@ namespace art { +// This visitor tries to simplify operations that yield a constant. For example +// `input * 0` is replaced by a null constant. +class InstructionWithAbsorbingInputSimplifier : public HGraphVisitor { + public: + explicit InstructionWithAbsorbingInputSimplifier(HGraph* graph) : HGraphVisitor(graph) {} + + private: + void VisitShift(HBinaryOperation* shift); + + void VisitAnd(HAnd* instruction) OVERRIDE; + void VisitMul(HMul* instruction) OVERRIDE; + void VisitOr(HOr* instruction) OVERRIDE; + void VisitRem(HRem* instruction) OVERRIDE; + void VisitShl(HShl* instruction) OVERRIDE; + void VisitShr(HShr* instruction) OVERRIDE; + void VisitSub(HSub* instruction) OVERRIDE; + void VisitUShr(HUShr* instruction) OVERRIDE; + void VisitXor(HXor* instruction) OVERRIDE; +}; + void HConstantFolding::Run() { + InstructionWithAbsorbingInputSimplifier simplifier(graph_); // Process basic blocks in reverse post-order in the dominator tree, // so that an instruction turned into a constant, used as input of // another instruction, may possibly be used to turn that second @@ -38,6 +59,8 @@ void HConstantFolding::Run() { inst->AsBinaryOperation()->TryStaticEvaluation(); if (constant != nullptr) { inst->GetBlock()->ReplaceAndRemoveInstructionWith(inst, constant); + } else { + inst->Accept(&simplifier); } } else if (inst->IsUnaryOperation()) { // Constant folding: replace `op(a)' with a constant at compile @@ -47,9 +70,166 @@ void HConstantFolding::Run() { if (constant != nullptr) { inst->GetBlock()->ReplaceAndRemoveInstructionWith(inst, constant); } + } else if (inst->IsDivZeroCheck()) { + // We can safely remove the check if the input is a non-null constant. + HDivZeroCheck* check = inst->AsDivZeroCheck(); + HInstruction* check_input = check->InputAt(0); + if (check_input->IsConstant() && !check_input->AsConstant()->IsZero()) { + check->ReplaceWith(check_input); + check->GetBlock()->RemoveInstruction(check); + } } } } } +void InstructionWithAbsorbingInputSimplifier::VisitShift(HBinaryOperation* instruction) { + DCHECK(instruction->IsShl() || instruction->IsShr() || instruction->IsUShr()); + HInstruction* left = instruction->GetLeft(); + if (left->IsConstant() && left->AsConstant()->IsZero()) { + // Replace code looking like + // SHL dst, 0, shift_amount + // with + // CONSTANT 0 + instruction->ReplaceWith(left); + instruction->GetBlock()->RemoveInstruction(instruction); + } +} + +void InstructionWithAbsorbingInputSimplifier::VisitAnd(HAnd* instruction) { + HConstant* input_cst = instruction->GetConstantRight(); + if ((input_cst != nullptr) && input_cst->IsZero()) { + // Replace code looking like + // AND dst, src, 0 + // with + // CONSTANT 0 + instruction->ReplaceWith(input_cst); + instruction->GetBlock()->RemoveInstruction(instruction); + } +} + +void InstructionWithAbsorbingInputSimplifier::VisitMul(HMul* instruction) { + HConstant* input_cst = instruction->GetConstantRight(); + Primitive::Type type = instruction->GetType(); + if (Primitive::IsIntOrLongType(type) && + (input_cst != nullptr) && input_cst->IsZero()) { + // Replace code looking like + // MUL dst, src, 0 + // with + // CONSTANT 0 + // Integral multiplication by zero always yields zero, but floating-point + // multiplication by zero does not always do. For example `Infinity * 0.0` + // should yield a NaN. + instruction->ReplaceWith(input_cst); + instruction->GetBlock()->RemoveInstruction(instruction); + } +} + +void InstructionWithAbsorbingInputSimplifier::VisitOr(HOr* instruction) { + HConstant* input_cst = instruction->GetConstantRight(); + + if (input_cst == nullptr) { + return; + } + + if (Int64FromConstant(input_cst) == -1) { + // Replace code looking like + // OR dst, src, 0xFFF...FF + // with + // CONSTANT 0xFFF...FF + instruction->ReplaceWith(input_cst); + instruction->GetBlock()->RemoveInstruction(instruction); + } +} + +void InstructionWithAbsorbingInputSimplifier::VisitRem(HRem* instruction) { + Primitive::Type type = instruction->GetType(); + + if (!Primitive::IsIntegralType(type)) { + return; + } + + HBasicBlock* block = instruction->GetBlock(); + + if (instruction->GetLeft()->IsConstant() && + instruction->GetLeft()->AsConstant()->IsZero()) { + // Replace code looking like + // REM dst, 0, src + // with + // CONSTANT 0 + instruction->ReplaceWith(instruction->GetLeft()); + block->RemoveInstruction(instruction); + } + + HConstant* cst_right = instruction->GetRight()->AsConstant(); + if (((cst_right != nullptr) && + (cst_right->IsOne() || cst_right->IsMinusOne())) || + (instruction->GetLeft() == instruction->GetRight())) { + // Replace code looking like + // REM dst, src, 1 + // or + // REM dst, src, -1 + // or + // REM dst, src, src + // with + // CONSTANT 0 + ArenaAllocator* allocator = GetGraph()->GetArena(); + block->ReplaceAndRemoveInstructionWith(instruction, + HConstant::NewConstant(allocator, type, 0)); + } +} + +void InstructionWithAbsorbingInputSimplifier::VisitShl(HShl* instruction) { + VisitShift(instruction); +} + +void InstructionWithAbsorbingInputSimplifier::VisitShr(HShr* instruction) { + VisitShift(instruction); +} + +void InstructionWithAbsorbingInputSimplifier::VisitSub(HSub* instruction) { + Primitive::Type type = instruction->GetType(); + + if (!Primitive::IsIntegralType(type)) { + return; + } + + HBasicBlock* block = instruction->GetBlock(); + ArenaAllocator* allocator = GetGraph()->GetArena(); + + // We assume that GVN has run before, so we only perform a pointer + // comparison. If for some reason the values are equal but the pointers are + // different, we are still correct and only miss an optimisation + // opportunity. + if (instruction->GetLeft() == instruction->GetRight()) { + // Replace code looking like + // SUB dst, src, src + // with + // CONSTANT 0 + // Note that we cannot optimise `x - x` to `0` for floating-point. It does + // not work when `x` is an infinity. + block->ReplaceAndRemoveInstructionWith(instruction, + HConstant::NewConstant(allocator, type, 0)); + } +} + +void InstructionWithAbsorbingInputSimplifier::VisitUShr(HUShr* instruction) { + VisitShift(instruction); +} + +void InstructionWithAbsorbingInputSimplifier::VisitXor(HXor* instruction) { + if (instruction->GetLeft() == instruction->GetRight()) { + // Replace code looking like + // XOR dst, src, src + // with + // CONSTANT 0 + Primitive::Type type = instruction->GetType(); + HBasicBlock* block = instruction->GetBlock(); + ArenaAllocator* allocator = GetGraph()->GetArena(); + + block->ReplaceAndRemoveInstructionWith(instruction, + HConstant::NewConstant(allocator, type, 0)); + } +} + } // namespace art diff --git a/compiler/optimizing/instruction_simplifier.cc b/compiler/optimizing/instruction_simplifier.cc index fd99070..2ef19b9 100644 --- a/compiler/optimizing/instruction_simplifier.cc +++ b/compiler/optimizing/instruction_simplifier.cc @@ -27,6 +27,8 @@ class InstructionSimplifierVisitor : public HGraphVisitor { : HGraphVisitor(graph), stats_(stats) {} private: + void VisitShift(HBinaryOperation* shift); + void VisitSuspendCheck(HSuspendCheck* check) OVERRIDE; void VisitEqual(HEqual* equal) OVERRIDE; void VisitArraySet(HArraySet* equal) OVERRIDE; @@ -34,6 +36,16 @@ class InstructionSimplifierVisitor : public HGraphVisitor { void VisitNullCheck(HNullCheck* instruction) OVERRIDE; void VisitArrayLength(HArrayLength* instruction) OVERRIDE; void VisitCheckCast(HCheckCast* instruction) OVERRIDE; + void VisitAdd(HAdd* instruction) OVERRIDE; + void VisitAnd(HAnd* instruction) OVERRIDE; + void VisitDiv(HDiv* instruction) OVERRIDE; + void VisitMul(HMul* instruction) OVERRIDE; + void VisitOr(HOr* instruction) OVERRIDE; + void VisitShl(HShl* instruction) OVERRIDE; + void VisitShr(HShr* instruction) OVERRIDE; + void VisitSub(HSub* instruction) OVERRIDE; + void VisitUShr(HUShr* instruction) OVERRIDE; + void VisitXor(HXor* instruction) OVERRIDE; OptimizingCompilerStats* stats_; }; @@ -43,6 +55,29 @@ void InstructionSimplifier::Run() { visitor.VisitInsertionOrder(); } +namespace { + +bool AreAllBitsSet(HConstant* constant) { + return Int64FromConstant(constant) == -1; +} + +} // namespace + +void InstructionSimplifierVisitor::VisitShift(HBinaryOperation* instruction) { + DCHECK(instruction->IsShl() || instruction->IsShr() || instruction->IsUShr()); + HConstant* input_cst = instruction->GetConstantRight(); + HInstruction* input_other = instruction->GetLeastConstantLeft(); + + if ((input_cst != nullptr) && input_cst->IsZero()) { + // Replace code looking like + // SHL dst, src, 0 + // with + // src + instruction->ReplaceWith(input_other); + instruction->GetBlock()->RemoveInstruction(instruction); + } +} + void InstructionSimplifierVisitor::VisitNullCheck(HNullCheck* null_check) { HInstruction* obj = null_check->InputAt(0); if (!obj->CanBeNull()) { @@ -137,4 +172,234 @@ void InstructionSimplifierVisitor::VisitTypeConversion(HTypeConversion* instruct } } +void InstructionSimplifierVisitor::VisitAdd(HAdd* instruction) { + HConstant* input_cst = instruction->GetConstantRight(); + HInstruction* input_other = instruction->GetLeastConstantLeft(); + if ((input_cst != nullptr) && input_cst->IsZero()) { + // Replace code looking like + // ADD dst, src, 0 + // with + // src + instruction->ReplaceWith(input_other); + instruction->GetBlock()->RemoveInstruction(instruction); + } +} + +void InstructionSimplifierVisitor::VisitAnd(HAnd* instruction) { + HConstant* input_cst = instruction->GetConstantRight(); + HInstruction* input_other = instruction->GetLeastConstantLeft(); + + if ((input_cst != nullptr) && AreAllBitsSet(input_cst)) { + // Replace code looking like + // AND dst, src, 0xFFF...FF + // with + // src + instruction->ReplaceWith(input_other); + instruction->GetBlock()->RemoveInstruction(instruction); + return; + } + + // We assume that GVN has run before, so we only perform a pointer comparison. + // If for some reason the values are equal but the pointers are different, we + // are still correct and only miss an optimisation opportunity. + if (instruction->GetLeft() == instruction->GetRight()) { + // Replace code looking like + // AND dst, src, src + // with + // src + instruction->ReplaceWith(instruction->GetLeft()); + instruction->GetBlock()->RemoveInstruction(instruction); + } +} + +void InstructionSimplifierVisitor::VisitDiv(HDiv* instruction) { + HConstant* input_cst = instruction->GetConstantRight(); + HInstruction* input_other = instruction->GetLeastConstantLeft(); + Primitive::Type type = instruction->GetType(); + + if ((input_cst != nullptr) && input_cst->IsOne()) { + // Replace code looking like + // DIV dst, src, 1 + // with + // src + instruction->ReplaceWith(input_other); + instruction->GetBlock()->RemoveInstruction(instruction); + return; + } + + if ((input_cst != nullptr) && input_cst->IsMinusOne() && + (Primitive::IsFloatingPointType(type) || Primitive::IsIntOrLongType(type))) { + // Replace code looking like + // DIV dst, src, -1 + // with + // NEG dst, src + instruction->GetBlock()->ReplaceAndRemoveInstructionWith( + instruction, (new (GetGraph()->GetArena()) HNeg(type, input_other))); + } +} + +void InstructionSimplifierVisitor::VisitMul(HMul* instruction) { + HConstant* input_cst = instruction->GetConstantRight(); + HInstruction* input_other = instruction->GetLeastConstantLeft(); + Primitive::Type type = instruction->GetType(); + HBasicBlock* block = instruction->GetBlock(); + ArenaAllocator* allocator = GetGraph()->GetArena(); + + if (input_cst == nullptr) { + return; + } + + if (input_cst->IsOne()) { + // Replace code looking like + // MUL dst, src, 1 + // with + // src + instruction->ReplaceWith(input_other); + instruction->GetBlock()->RemoveInstruction(instruction); + return; + } + + if (input_cst->IsMinusOne() && + (Primitive::IsFloatingPointType(type) || Primitive::IsIntOrLongType(type))) { + // Replace code looking like + // MUL dst, src, -1 + // with + // NEG dst, src + HNeg* neg = new (allocator) HNeg(type, input_other); + block->ReplaceAndRemoveInstructionWith(instruction, neg); + return; + } + + if (Primitive::IsFloatingPointType(type) && + ((input_cst->IsFloatConstant() && input_cst->AsFloatConstant()->GetValue() == 2.0f) || + (input_cst->IsDoubleConstant() && input_cst->AsDoubleConstant()->GetValue() == 2.0))) { + // Replace code looking like + // FP_MUL dst, src, 2.0 + // with + // FP_ADD dst, src, src + // The 'int' and 'long' cases are handled below. + block->ReplaceAndRemoveInstructionWith(instruction, + new (allocator) HAdd(type, input_other, input_other)); + return; + } + + if (Primitive::IsIntOrLongType(type)) { + int64_t factor = Int64FromConstant(input_cst); + // We expect the `0` case to have been handled in the constant folding pass. + DCHECK_NE(factor, 0); + if (IsPowerOfTwo(factor)) { + // Replace code looking like + // MUL dst, src, pow_of_2 + // with + // SHL dst, src, log2(pow_of_2) + HIntConstant* shift = new (allocator) HIntConstant(WhichPowerOf2(factor)); + block->InsertInstructionBefore(shift, instruction); + HShl* shl = new(allocator) HShl(type, input_other, shift); + block->ReplaceAndRemoveInstructionWith(instruction, shl); + } + } +} + +void InstructionSimplifierVisitor::VisitOr(HOr* instruction) { + HConstant* input_cst = instruction->GetConstantRight(); + HInstruction* input_other = instruction->GetLeastConstantLeft(); + + if ((input_cst != nullptr) && input_cst->IsZero()) { + // Replace code looking like + // OR dst, src, 0 + // with + // src + instruction->ReplaceWith(input_other); + instruction->GetBlock()->RemoveInstruction(instruction); + return; + } + + // We assume that GVN has run before, so we only perform a pointer comparison. + // If for some reason the values are equal but the pointers are different, we + // are still correct and only miss an optimisation opportunity. + if (instruction->GetLeft() == instruction->GetRight()) { + // Replace code looking like + // OR dst, src, src + // with + // src + instruction->ReplaceWith(instruction->GetLeft()); + instruction->GetBlock()->RemoveInstruction(instruction); + } +} + +void InstructionSimplifierVisitor::VisitShl(HShl* instruction) { + VisitShift(instruction); +} + +void InstructionSimplifierVisitor::VisitShr(HShr* instruction) { + VisitShift(instruction); +} + +void InstructionSimplifierVisitor::VisitSub(HSub* instruction) { + HConstant* input_cst = instruction->GetConstantRight(); + HInstruction* input_other = instruction->GetLeastConstantLeft(); + + if ((input_cst != nullptr) && input_cst->IsZero()) { + // Replace code looking like + // SUB dst, src, 0 + // with + // src + instruction->ReplaceWith(input_other); + instruction->GetBlock()->RemoveInstruction(instruction); + return; + } + + Primitive::Type type = instruction->GetType(); + if (!Primitive::IsIntegralType(type)) { + return; + } + + HBasicBlock* block = instruction->GetBlock(); + ArenaAllocator* allocator = GetGraph()->GetArena(); + + if (instruction->GetLeft()->IsConstant()) { + int64_t left = Int64FromConstant(instruction->GetLeft()->AsConstant()); + if (left == 0) { + // Replace code looking like + // SUB dst, 0, src + // with + // NEG dst, src + // Note that we cannot optimise `0.0 - x` to `-x` for floating-point. When + // `x` is `0.0`, the former expression yields `0.0`, while the later + // yields `-0.0`. + HNeg* neg = new (allocator) HNeg(type, instruction->GetRight()); + block->ReplaceAndRemoveInstructionWith(instruction, neg); + } + } +} + +void InstructionSimplifierVisitor::VisitUShr(HUShr* instruction) { + VisitShift(instruction); +} + +void InstructionSimplifierVisitor::VisitXor(HXor* instruction) { + HConstant* input_cst = instruction->GetConstantRight(); + HInstruction* input_other = instruction->GetLeastConstantLeft(); + + if ((input_cst != nullptr) && input_cst->IsZero()) { + // Replace code looking like + // XOR dst, src, 0 + // with + // src + instruction->ReplaceWith(input_other); + instruction->GetBlock()->RemoveInstruction(instruction); + return; + } + + if ((input_cst != nullptr) && AreAllBitsSet(input_cst)) { + // Replace code looking like + // XOR dst, src, 0xFFF...FF + // with + // NOT dst, src + HNot* bitwise_not = new (GetGraph()->GetArena()) HNot(instruction->GetType(), input_other); + instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, bitwise_not); + return; + } +} + } // namespace art diff --git a/compiler/optimizing/nodes.cc b/compiler/optimizing/nodes.cc index a6adcca..a90ebce 100644 --- a/compiler/optimizing/nodes.cc +++ b/compiler/optimizing/nodes.cc @@ -673,10 +673,43 @@ HConstant* HBinaryOperation::TryStaticEvaluation() const { return nullptr; } +HConstant* HBinaryOperation::GetConstantRight() const { + if (GetRight()->IsConstant()) { + return GetRight()->AsConstant(); + } else if (IsCommutative() && GetLeft()->IsConstant()) { + return GetLeft()->AsConstant(); + } else { + return nullptr; + } +} + +// If `GetConstantRight()` returns one of the input, this returns the other +// one. Otherwise it returns nullptr. +HInstruction* HBinaryOperation::GetLeastConstantLeft() const { + HInstruction* most_constant_right = GetConstantRight(); + if (most_constant_right == nullptr) { + return nullptr; + } else if (most_constant_right == GetLeft()) { + return GetRight(); + } else { + return GetLeft(); + } +} + bool HCondition::IsBeforeWhenDisregardMoves(HIf* if_) const { return this == if_->GetPreviousDisregardingMoves(); } +HConstant* HConstant::NewConstant(ArenaAllocator* allocator, Primitive::Type type, int64_t val) { + if (type == Primitive::kPrimInt) { + DCHECK(IsInt<32>(val)); + return new (allocator) HIntConstant(val); + } else { + DCHECK_EQ(type, Primitive::kPrimLong); + return new (allocator) HLongConstant(val); + } +} + bool HInstruction::Equals(HInstruction* other) const { if (!InstructionTypeEquals(other)) return false; DCHECK_EQ(GetKind(), other->GetKind()); diff --git a/compiler/optimizing/nodes.h b/compiler/optimizing/nodes.h index 0ef174d..ec3d743 100644 --- a/compiler/optimizing/nodes.h +++ b/compiler/optimizing/nodes.h @@ -1574,6 +1574,14 @@ class HBinaryOperation : public HExpression<2> { virtual int32_t Evaluate(int32_t x, int32_t y) const = 0; virtual int64_t Evaluate(int64_t x, int64_t y) const = 0; + // Returns an input that can legally be used as the right input and is + // constant, or nullptr. + HConstant* GetConstantRight() const; + + // If `GetConstantRight()` returns one of the input, this returns the other + // one. Otherwise it returns nullptr. + HInstruction* GetLeastConstantLeft() const; + DECLARE_INSTRUCTION(BinaryOperation); private: @@ -1845,6 +1853,12 @@ class HConstant : public HExpression<0> { bool CanBeMoved() const OVERRIDE { return true; } + virtual bool IsMinusOne() const { return false; } + virtual bool IsZero() const { return false; } + virtual bool IsOne() const { return false; } + + static HConstant* NewConstant(ArenaAllocator* allocator, Primitive::Type type, int64_t val); + DECLARE_INSTRUCTION(Constant); private: @@ -1864,6 +1878,16 @@ class HFloatConstant : public HConstant { size_t ComputeHashCode() const OVERRIDE { return static_cast<size_t>(GetValue()); } + bool IsMinusOne() const OVERRIDE { + return bit_cast<uint32_t>(AsFloatConstant()->GetValue()) == bit_cast<uint32_t>((-1.0f)); + } + bool IsZero() const OVERRIDE { + return AsFloatConstant()->GetValue() == 0.0f; + } + bool IsOne() const OVERRIDE { + return bit_cast<uint32_t>(AsFloatConstant()->GetValue()) == bit_cast<uint32_t>(1.0f); + } + DECLARE_INSTRUCTION(FloatConstant); private: @@ -1885,6 +1909,16 @@ class HDoubleConstant : public HConstant { size_t ComputeHashCode() const OVERRIDE { return static_cast<size_t>(GetValue()); } + bool IsMinusOne() const OVERRIDE { + return bit_cast<uint64_t>(AsDoubleConstant()->GetValue()) == bit_cast<uint64_t>((-1.0)); + } + bool IsZero() const OVERRIDE { + return AsDoubleConstant()->GetValue() == 0.0; + } + bool IsOne() const OVERRIDE { + return bit_cast<uint64_t>(AsDoubleConstant()->GetValue()) == bit_cast<uint64_t>(1.0); + } + DECLARE_INSTRUCTION(DoubleConstant); private: @@ -1930,6 +1964,10 @@ class HIntConstant : public HConstant { // method is an workaround until we fix the above. bool ActAsNullConstant() const OVERRIDE { return value_ == 0; } + bool IsMinusOne() const OVERRIDE { return GetValue() == -1; } + bool IsZero() const OVERRIDE { return GetValue() == 0; } + bool IsOne() const OVERRIDE { return GetValue() == 1; } + DECLARE_INSTRUCTION(IntConstant); private: @@ -1950,6 +1988,10 @@ class HLongConstant : public HConstant { size_t ComputeHashCode() const OVERRIDE { return static_cast<size_t>(GetValue()); } + bool IsMinusOne() const OVERRIDE { return GetValue() == -1; } + bool IsZero() const OVERRIDE { return GetValue() == 0; } + bool IsOne() const OVERRIDE { return GetValue() == 1; } + DECLARE_INSTRUCTION(LongConstant); private: @@ -3478,6 +3520,12 @@ class HBlocksInLoopIterator : public ValueObject { DISALLOW_COPY_AND_ASSIGN(HBlocksInLoopIterator); }; +inline int64_t Int64FromConstant(HConstant* constant) { + DCHECK(constant->IsIntConstant() || constant->IsLongConstant()); + return constant->IsIntConstant() ? constant->AsIntConstant()->GetValue() + : constant->AsLongConstant()->GetValue(); +} + } // namespace art #endif // ART_COMPILER_OPTIMIZING_NODES_H_ diff --git a/runtime/primitive.h b/runtime/primitive.h index 9dda144..2d6b6b3 100644 --- a/runtime/primitive.h +++ b/runtime/primitive.h @@ -165,6 +165,10 @@ class Primitive { } } + static bool IsIntOrLongType(Type type) { + return type == kPrimInt || type == kPrimLong; + } + static bool Is64BitType(Type type) { return type == kPrimLong || type == kPrimDouble; } diff --git a/runtime/utils.h b/runtime/utils.h index 0c11610..cd04c3f 100644 --- a/runtime/utils.h +++ b/runtime/utils.h @@ -289,6 +289,12 @@ static constexpr int CTZ(T x) { } template<typename T> +static inline int WhichPowerOf2(T x) { + DCHECK((x != 0) && IsPowerOfTwo(x)); + return CTZ(x); +} + +template<typename T> static constexpr int POPCOUNT(T x) { return (sizeof(T) == sizeof(uint32_t)) ? __builtin_popcount(x) diff --git a/test/442-checker-constant-folding/src/Main.java b/test/442-checker-constant-folding/src/Main.java index de2c5c7..6b21fed 100644 --- a/test/442-checker-constant-folding/src/Main.java +++ b/test/442-checker-constant-folding/src/Main.java @@ -16,6 +16,18 @@ public class Main { + public static void assertIntEquals(int expected, int result) { + if (expected != result) { + throw new Error("Expected: " + expected + ", found: " + result); + } + } + + public static void assertLongEquals(long expected, long result) { + if (expected != result) { + throw new Error("Expected: " + expected + ", found: " + result); + } + } + /** * Tiny three-register program exercising int constant folding * on negation. @@ -219,41 +231,203 @@ public class Main { return c; } - public static void main(String[] args) { - if (IntNegation() != -42) { - throw new Error(); - } + /** + * Test optimizations of arithmetic identities yielding a constant result. + */ - if (IntAddition1() != 3) { - throw new Error(); - } + // CHECK-START: int Main.And0(int) constant_folding (before) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[Const0:i\d+]] IntConstant 0 + // CHECK-DAG: [[And:i\d+]] And [ [[Arg]] [[Const0]] ] + // CHECK-DAG: Return [ [[And]] ] - if (IntAddition2() != 14) { - throw new Error(); - } + // CHECK-START: int Main.And0(int) constant_folding (after) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[Const0:i\d+]] IntConstant 0 + // CHECK-NOT: And + // CHECK-DAG: Return [ [[Const0]] ] - if (IntSubtraction() != 4) { - throw new Error(); - } + public static int And0(int arg) { + return arg & 0; + } - if (LongAddition() != 3L) { - throw new Error(); - } + // CHECK-START: long Main.Mul0(long) constant_folding (before) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-DAG: [[Const0:j\d+]] LongConstant 0 + // CHECK-DAG: [[Mul:j\d+]] Mul [ [[Arg]] [[Const0]] ] + // CHECK-DAG: Return [ [[Mul]] ] - if (LongSubtraction() != 4L) { - throw new Error(); - } + // CHECK-START: long Main.Mul0(long) constant_folding (after) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-DAG: [[Const0:j\d+]] LongConstant 0 + // CHECK-NOT: Mul + // CHECK-DAG: Return [ [[Const0]] ] - if (StaticCondition() != 5) { - throw new Error(); - } + public static long Mul0(long arg) { + return arg * 0; + } - if (JumpsAndConditionals(true) != 7) { - throw new Error(); - } + // CHECK-START: int Main.OrAllOnes(int) constant_folding (before) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[ConstF:i\d+]] IntConstant -1 + // CHECK-DAG: [[Or:i\d+]] Or [ [[Arg]] [[ConstF]] ] + // CHECK-DAG: Return [ [[Or]] ] - if (JumpsAndConditionals(false) != 3) { - throw new Error(); - } + // CHECK-START: int Main.OrAllOnes(int) constant_folding (after) + // CHECK-DAG: [[ConstF:i\d+]] IntConstant -1 + // CHECK-NOT: Or + // CHECK-DAG: Return [ [[ConstF]] ] + + public static int OrAllOnes(int arg) { + return arg | -1; + } + + // CHECK-START: long Main.Rem0(long) constant_folding (before) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-DAG: [[Const0:j\d+]] LongConstant 0 + // CHECK-DAG: [[DivZeroCheck:j\d+]] DivZeroCheck [ [[Arg]] ] + // CHECK-DAG: [[Rem:j\d+]] Rem [ [[Const0]] [[DivZeroCheck]] ] + // CHECK-DAG: Return [ [[Rem]] ] + + // CHECK-START: long Main.Rem0(long) constant_folding (after) + // CHECK-DAG: [[Const0:j\d+]] LongConstant 0 + // CHECK-NOT: Rem + // CHECK-DAG: Return [ [[Const0]] ] + + public static long Rem0(long arg) { + return 0 % arg; + } + + // CHECK-START: int Main.Rem1(int) constant_folding (before) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[Const1:i\d+]] IntConstant 1 + // CHECK-DAG: [[Rem:i\d+]] Rem [ [[Arg]] [[Const1]] ] + // CHECK-DAG: Return [ [[Rem]] ] + + // CHECK-START: int Main.Rem1(int) constant_folding (after) + // CHECK-DAG: [[Const0:i\d+]] IntConstant 0 + // CHECK-NOT: Rem + // CHECK-DAG: Return [ [[Const0]] ] + + public static int Rem1(int arg) { + return arg % 1; + } + + // CHECK-START: long Main.RemN1(long) constant_folding (before) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-DAG: [[ConstN1:j\d+]] LongConstant -1 + // CHECK-DAG: [[DivZeroCheck:j\d+]] DivZeroCheck [ [[Arg]] ] + // CHECK-DAG: [[Rem:j\d+]] Rem [ [[Arg]] [[DivZeroCheck]] ] + // CHECK-DAG: Return [ [[Rem]] ] + + // CHECK-START: long Main.RemN1(long) constant_folding (after) + // CHECK-DAG: [[Const0:j\d+]] LongConstant 0 + // CHECK-NOT: Rem + // CHECK-DAG: Return [ [[Const0]] ] + + public static long RemN1(long arg) { + return arg % -1; + } + + // CHECK-START: int Main.Shl0(int) constant_folding (before) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[Const0:i\d+]] IntConstant 0 + // CHECK-DAG: [[Shl:i\d+]] Shl [ [[Const0]] [[Arg]] ] + // CHECK-DAG: Return [ [[Shl]] ] + + // CHECK-START: int Main.Shl0(int) constant_folding (after) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[Const0:i\d+]] IntConstant 0 + // CHECK-NOT: Shl + // CHECK-DAG: Return [ [[Const0]] ] + + public static int Shl0(int arg) { + return 0 << arg; + } + + // CHECK-START: long Main.Shr0(int) constant_folding (before) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[Const0:j\d+]] LongConstant 0 + // CHECK-DAG: [[Shr:j\d+]] Shr [ [[Const0]] [[Arg]] ] + // CHECK-DAG: Return [ [[Shr]] ] + + // CHECK-START: long Main.Shr0(int) constant_folding (after) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[Const0:j\d+]] LongConstant 0 + // CHECK-NOT: Shr + // CHECK-DAG: Return [ [[Const0]] ] + + public static long Shr0(int arg) { + return (long)0 >> arg; + } + + // CHECK-START: long Main.SubSameLong(long) constant_folding (before) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-DAG: [[Sub:j\d+]] Sub [ [[Arg]] [[Arg]] ] + // CHECK-DAG: Return [ [[Sub]] ] + + // CHECK-START: long Main.SubSameLong(long) constant_folding (after) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-DAG: [[Const0:j\d+]] LongConstant 0 + // CHECK-NOT: Sub + // CHECK-DAG: Return [ [[Const0]] ] + + public static long SubSameLong(long arg) { + return arg - arg; + } + + // CHECK-START: int Main.UShr0(int) constant_folding (before) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[Const0:i\d+]] IntConstant 0 + // CHECK-DAG: [[UShr:i\d+]] UShr [ [[Const0]] [[Arg]] ] + // CHECK-DAG: Return [ [[UShr]] ] + + // CHECK-START: int Main.UShr0(int) constant_folding (after) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[Const0:i\d+]] IntConstant 0 + // CHECK-NOT: UShr + // CHECK-DAG: Return [ [[Const0]] ] + + public static int UShr0(int arg) { + return 0 >>> arg; + } + + // CHECK-START: int Main.XorSameInt(int) constant_folding (before) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[Xor:i\d+]] Xor [ [[Arg]] [[Arg]] ] + // CHECK-DAG: Return [ [[Xor]] ] + + // CHECK-START: int Main.XorSameInt(int) constant_folding (after) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[Const0:i\d+]] IntConstant 0 + // CHECK-NOT: Xor + // CHECK-DAG: Return [ [[Const0]] ] + + public static int XorSameInt(int arg) { + return arg ^ arg; + } + + public static void main(String[] args) { + assertIntEquals(IntNegation(), -42); + assertIntEquals(IntAddition1(), 3); + assertIntEquals(IntAddition2(), 14); + assertIntEquals(IntSubtraction(), 4); + assertLongEquals(LongAddition(), 3L); + assertLongEquals(LongSubtraction(), 4L); + assertIntEquals(StaticCondition(), 5); + assertIntEquals(JumpsAndConditionals(true), 7); + assertIntEquals(JumpsAndConditionals(false), 3); + int random = 123456; // Chosen randomly. + assertIntEquals(And0(random), 0); + assertLongEquals(Mul0(random), 0); + assertIntEquals(OrAllOnes(random), -1); + assertLongEquals(Rem0(random), 0); + assertIntEquals(Rem1(random), 0); + assertLongEquals(RemN1(random), 0); + assertIntEquals(Shl0(random), 0); + assertLongEquals(Shr0(random), 0); + assertLongEquals(SubSameLong(random), 0); + assertIntEquals(UShr0(random), 0); + assertIntEquals(XorSameInt(random), 0); } } diff --git a/test/458-checker-instruction-simplification/expected.txt b/test/458-checker-instruction-simplification/expected.txt new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/test/458-checker-instruction-simplification/expected.txt diff --git a/test/458-checker-instruction-simplification/info.txt b/test/458-checker-instruction-simplification/info.txt new file mode 100644 index 0000000..09da84b --- /dev/null +++ b/test/458-checker-instruction-simplification/info.txt @@ -0,0 +1 @@ +Tests arithmetic identities optimizations in the optimizing compiler. diff --git a/test/458-checker-instruction-simplification/src/Main.java b/test/458-checker-instruction-simplification/src/Main.java new file mode 100644 index 0000000..ef6428d --- /dev/null +++ b/test/458-checker-instruction-simplification/src/Main.java @@ -0,0 +1,300 @@ +/* +* Copyright (C) 2015 The Android Open Source Project +* +* 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. +*/ + +public class Main { + + public static void assertIntEquals(int expected, int result) { + if (expected != result) { + throw new Error("Expected: " + expected + ", found: " + result); + } + } + + public static void assertLongEquals(long expected, long result) { + if (expected != result) { + throw new Error("Expected: " + expected + ", found: " + result); + } + } + + /** + * Tiny programs exercising optimizations of arithmetic identities. + */ + + // CHECK-START: long Main.Add0(long) instruction_simplifier (before) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-DAG: [[Const0:j\d+]] LongConstant 0 + // CHECK-DAG: [[Add:j\d+]] Add [ [[Const0]] [[Arg]] ] + // CHECK-DAG: Return [ [[Add]] ] + + // CHECK-START: long Main.Add0(long) instruction_simplifier (after) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-NOT: Add + // CHECK-DAG: Return [ [[Arg]] ] + + public static long Add0(long arg) { + return 0 + arg; + } + + // CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (before) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[ConstF:i\d+]] IntConstant -1 + // CHECK-DAG: [[And:i\d+]] And [ [[Arg]] [[ConstF]] ] + // CHECK-DAG: Return [ [[And]] ] + + // CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-NOT: And + // CHECK-DAG: Return [ [[Arg]] ] + + public static int AndAllOnes(int arg) { + return arg & -1; + } + + // CHECK-START: long Main.Div1(long) instruction_simplifier (before) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-DAG: [[Const1:j\d+]] LongConstant 1 + // CHECK-DAG: [[Div:j\d+]] Div [ [[Arg]] [[Const1]] ] + // CHECK-DAG: Return [ [[Div]] ] + + // CHECK-START: long Main.Div1(long) instruction_simplifier (after) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-NOT: Div + // CHECK-DAG: Return [ [[Arg]] ] + + public static long Div1(long arg) { + return arg / 1; + } + + // CHECK-START: int Main.DivN1(int) instruction_simplifier (before) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[ConstN1:i\d+]] IntConstant -1 + // CHECK-DAG: [[Div:i\d+]] Div [ [[Arg]] [[ConstN1]] ] + // CHECK-DAG: Return [ [[Div]] ] + + // CHECK-START: int Main.DivN1(int) instruction_simplifier (after) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[Neg:i\d+]] Neg [ [[Arg]] ] + // CHECK-NOT: Div + // CHECK-DAG: Return [ [[Neg]] ] + + public static int DivN1(int arg) { + return arg / -1; + } + + // CHECK-START: long Main.Mul1(long) instruction_simplifier (before) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-DAG: [[Const1:j\d+]] LongConstant 1 + // CHECK-DAG: [[Mul:j\d+]] Mul [ [[Arg]] [[Const1]] ] + // CHECK-DAG: Return [ [[Mul]] ] + + // CHECK-START: long Main.Mul1(long) instruction_simplifier (after) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-NOT: Mul + // CHECK-DAG: Return [ [[Arg]] ] + + public static long Mul1(long arg) { + return arg * 1; + } + + // CHECK-START: int Main.MulN1(int) instruction_simplifier (before) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[ConstN1:i\d+]] IntConstant -1 + // CHECK-DAG: [[Mul:i\d+]] Mul [ [[Arg]] [[ConstN1]] ] + // CHECK-DAG: Return [ [[Mul]] ] + + // CHECK-START: int Main.MulN1(int) instruction_simplifier (after) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[Neg:i\d+]] Neg [ [[Arg]] ] + // CHECK-NOT: Mul + // CHECK-DAG: Return [ [[Neg]] ] + + public static int MulN1(int arg) { + return arg * -1; + } + + // CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (before) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-DAG: [[Const128:j\d+]] LongConstant 128 + // CHECK-DAG: [[Mul:j\d+]] Mul [ [[Arg]] [[Const128]] ] + // CHECK-DAG: Return [ [[Mul]] ] + + // CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-DAG: [[Const7:i\d+]] IntConstant 7 + // CHECK-DAG: [[Shl:j\d+]] Shl [ [[Arg]] [[Const7]] ] + // CHECK-NOT: Mul + // CHECK-DAG: Return [ [[Shl]] ] + + public static long MulPowerOfTwo128(long arg) { + return arg * 128; + } + + // CHECK-START: int Main.Or0(int) instruction_simplifier (before) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[Const0:i\d+]] IntConstant 0 + // CHECK-DAG: [[Or:i\d+]] Or [ [[Arg]] [[Const0]] ] + // CHECK-DAG: Return [ [[Or]] ] + + // CHECK-START: int Main.Or0(int) instruction_simplifier (after) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-NOT: Or + // CHECK-DAG: Return [ [[Arg]] ] + + public static int Or0(int arg) { + return arg | 0; + } + + // CHECK-START: long Main.OrSame(long) instruction_simplifier (before) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-DAG: [[Or:j\d+]] Or [ [[Arg]] [[Arg]] ] + // CHECK-DAG: Return [ [[Or]] ] + + // CHECK-START: long Main.OrSame(long) instruction_simplifier (after) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-NOT: Or + // CHECK-DAG: Return [ [[Arg]] ] + + public static long OrSame(long arg) { + return arg | arg; + } + + // CHECK-START: int Main.Shl0(int) instruction_simplifier (before) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[Const0:i\d+]] IntConstant 0 + // CHECK-DAG: [[Shl:i\d+]] Shl [ [[Arg]] [[Const0]] ] + // CHECK-DAG: Return [ [[Shl]] ] + + // CHECK-START: int Main.Shl0(int) instruction_simplifier (after) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-NOT: Shl + // CHECK-DAG: Return [ [[Arg]] ] + + public static int Shl0(int arg) { + return arg << 0; + } + + // CHECK-START: long Main.Shr0(long) instruction_simplifier (before) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-DAG: [[Const0:i\d+]] IntConstant 0 + // CHECK-DAG: [[Shr:j\d+]] Shr [ [[Arg]] [[Const0]] ] + // CHECK-DAG: Return [ [[Shr]] ] + + // CHECK-START: long Main.Shr0(long) instruction_simplifier (after) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-NOT: Shr + // CHECK-DAG: Return [ [[Arg]] ] + + public static long Shr0(long arg) { + return arg >> 0; + } + + // CHECK-START: long Main.Sub0(long) instruction_simplifier (before) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-DAG: [[Const0:j\d+]] LongConstant 0 + // CHECK-DAG: [[Sub:j\d+]] Sub [ [[Arg]] [[Const0]] ] + // CHECK-DAG: Return [ [[Sub]] ] + + // CHECK-START: long Main.Sub0(long) instruction_simplifier (after) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-NOT: Sub + // CHECK-DAG: Return [ [[Arg]] ] + + public static long Sub0(long arg) { + return arg - 0; + } + + // CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (before) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[Const0:i\d+]] IntConstant 0 + // CHECK-DAG: [[Sub:i\d+]] Sub [ [[Const0]] [[Arg]] ] + // CHECK-DAG: Return [ [[Sub]] ] + + // CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[Neg:i\d+]] Neg [ [[Arg]] ] + // CHECK-NOT: Sub + // CHECK-DAG: Return [ [[Neg]] ] + + public static int SubAliasNeg(int arg) { + return 0 - arg; + } + + // CHECK-START: long Main.UShr0(long) instruction_simplifier (before) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-DAG: [[Const0:i\d+]] IntConstant 0 + // CHECK-DAG: [[UShr:j\d+]] UShr [ [[Arg]] [[Const0]] ] + // CHECK-DAG: Return [ [[UShr]] ] + + // CHECK-START: long Main.UShr0(long) instruction_simplifier (after) + // CHECK-DAG: [[Arg:j\d+]] ParameterValue + // CHECK-NOT: UShr + // CHECK-DAG: Return [ [[Arg]] ] + + public static long UShr0(long arg) { + return arg >>> 0; + } + + // CHECK-START: int Main.Xor0(int) instruction_simplifier (before) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[Const0:i\d+]] IntConstant 0 + // CHECK-DAG: [[Xor:i\d+]] Xor [ [[Arg]] [[Const0]] ] + // CHECK-DAG: Return [ [[Xor]] ] + + // CHECK-START: int Main.Xor0(int) instruction_simplifier (after) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-NOT: Xor + // CHECK-DAG: Return [ [[Arg]] ] + + public static int Xor0(int arg) { + return arg ^ 0; + } + + // CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (before) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[ConstF:i\d+]] IntConstant -1 + // CHECK-DAG: [[Xor:i\d+]] Xor [ [[Arg]] [[ConstF]] ] + // CHECK-DAG: Return [ [[Xor]] ] + + // CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after) + // CHECK-DAG: [[Arg:i\d+]] ParameterValue + // CHECK-DAG: [[Not:i\d+]] Not [ [[Arg]] ] + // CHECK-NOT: Xor + // CHECK-DAG: Return [ [[Not]] ] + + public static int XorAllOnes(int arg) { + return arg ^ -1; + } + + public static void main(String[] args) { + int arg = 123456; + + assertLongEquals(Add0(arg), arg); + assertIntEquals(AndAllOnes(arg), arg); + assertLongEquals(Div1(arg), arg); + assertIntEquals(DivN1(arg), -arg); + assertLongEquals(Mul1(arg), arg); + assertIntEquals(MulN1(arg), -arg); + assertLongEquals(MulPowerOfTwo128(arg), (128 * arg)); + assertIntEquals(Or0(arg), arg); + assertLongEquals(OrSame(arg), arg); + assertIntEquals(Shl0(arg), arg); + assertLongEquals(Shr0(arg), arg); + assertLongEquals(Sub0(arg), arg); + assertIntEquals(SubAliasNeg(arg), -arg); + assertLongEquals(UShr0(arg), arg); + assertIntEquals(Xor0(arg), arg); + assertIntEquals(XorAllOnes(arg), ~arg); + } +} |