/*
|
* 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 {
|
|
// A dummy value to defeat inlining of these routines.
|
static boolean doThrow = false;
|
|
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);
|
}
|
}
|
|
/**
|
* Test basic merging of `MUL+ADD` into `MULADD`.
|
*/
|
|
/// CHECK-START-ARM64: int Main.$opt$noinline$mulAdd(int, int, int) instruction_simplifier_arm64 (before)
|
/// CHECK: <<Acc:i\d+>> ParameterValue
|
/// CHECK: <<Left:i\d+>> ParameterValue
|
/// CHECK: <<Right:i\d+>> ParameterValue
|
/// CHECK: <<Mul:i\d+>> Mul [<<Left>>,<<Right>>]
|
/// CHECK: <<Add:i\d+>> Add [<<Acc>>,<<Mul>>]
|
/// CHECK: Return [<<Add>>]
|
|
/// CHECK-START-ARM64: int Main.$opt$noinline$mulAdd(int, int, int) instruction_simplifier_arm64 (after)
|
/// CHECK: <<Acc:i\d+>> ParameterValue
|
/// CHECK: <<Left:i\d+>> ParameterValue
|
/// CHECK: <<Right:i\d+>> ParameterValue
|
/// CHECK: <<MulAdd:i\d+>> MultiplyAccumulate [<<Acc>>,<<Left>>,<<Right>>] kind:Add
|
/// CHECK: Return [<<MulAdd>>]
|
|
/// CHECK-START-ARM64: int Main.$opt$noinline$mulAdd(int, int, int) instruction_simplifier_arm64 (after)
|
/// CHECK-NOT: Mul
|
/// CHECK-NOT: Add
|
|
/// CHECK-START-ARM64: int Main.$opt$noinline$mulAdd(int, int, int) disassembly (after)
|
/// CHECK: madd w{{\d+}}, w{{\d+}}, w{{\d+}}, w{{\d+}}
|
|
/// CHECK-START-ARM: int Main.$opt$noinline$mulAdd(int, int, int) instruction_simplifier_arm (before)
|
/// CHECK: <<Acc:i\d+>> ParameterValue
|
/// CHECK: <<Left:i\d+>> ParameterValue
|
/// CHECK: <<Right:i\d+>> ParameterValue
|
/// CHECK: <<Mul:i\d+>> Mul [<<Left>>,<<Right>>]
|
/// CHECK: <<Add:i\d+>> Add [<<Acc>>,<<Mul>>]
|
/// CHECK: Return [<<Add>>]
|
|
/// CHECK-START-ARM: int Main.$opt$noinline$mulAdd(int, int, int) instruction_simplifier_arm (after)
|
/// CHECK: <<Acc:i\d+>> ParameterValue
|
/// CHECK: <<Left:i\d+>> ParameterValue
|
/// CHECK: <<Right:i\d+>> ParameterValue
|
/// CHECK: <<MulAdd:i\d+>> MultiplyAccumulate [<<Acc>>,<<Left>>,<<Right>>] kind:Add
|
/// CHECK: Return [<<MulAdd>>]
|
|
/// CHECK-START-ARM: int Main.$opt$noinline$mulAdd(int, int, int) instruction_simplifier_arm (after)
|
/// CHECK-NOT: Mul
|
/// CHECK-NOT: Add
|
|
/// CHECK-START-ARM: int Main.$opt$noinline$mulAdd(int, int, int) disassembly (after)
|
/// CHECK: mla r{{\d+}}, r{{\d+}}, r{{\d+}}, r{{\d+}}
|
|
public static int $opt$noinline$mulAdd(int acc, int left, int right) {
|
if (doThrow) throw new Error();
|
return acc + left * right;
|
}
|
|
/**
|
* Test basic merging of `MUL+SUB` into `MULSUB`.
|
*/
|
|
/// CHECK-START-ARM64: long Main.$opt$noinline$mulSub(long, long, long) instruction_simplifier_arm64 (before)
|
/// CHECK: <<Acc:j\d+>> ParameterValue
|
/// CHECK: <<Left:j\d+>> ParameterValue
|
/// CHECK: <<Right:j\d+>> ParameterValue
|
/// CHECK: <<Mul:j\d+>> Mul [<<Left>>,<<Right>>]
|
/// CHECK: <<Sub:j\d+>> Sub [<<Acc>>,<<Mul>>]
|
/// CHECK: Return [<<Sub>>]
|
|
/// CHECK-START-ARM64: long Main.$opt$noinline$mulSub(long, long, long) instruction_simplifier_arm64 (after)
|
/// CHECK: <<Acc:j\d+>> ParameterValue
|
/// CHECK: <<Left:j\d+>> ParameterValue
|
/// CHECK: <<Right:j\d+>> ParameterValue
|
/// CHECK: <<MulSub:j\d+>> MultiplyAccumulate [<<Acc>>,<<Left>>,<<Right>>] kind:Sub
|
/// CHECK: Return [<<MulSub>>]
|
|
/// CHECK-START-ARM64: long Main.$opt$noinline$mulSub(long, long, long) instruction_simplifier_arm64 (after)
|
/// CHECK-NOT: Mul
|
/// CHECK-NOT: Sub
|
|
/// CHECK-START-ARM64: long Main.$opt$noinline$mulSub(long, long, long) disassembly (after)
|
/// CHECK: msub x{{\d+}}, x{{\d+}}, x{{\d+}}, x{{\d+}}
|
|
/// CHECK-START-ARM: long Main.$opt$noinline$mulSub(long, long, long) instruction_simplifier_arm (before)
|
/// CHECK: <<Acc:j\d+>> ParameterValue
|
/// CHECK: <<Left:j\d+>> ParameterValue
|
/// CHECK: <<Right:j\d+>> ParameterValue
|
/// CHECK: <<Mul:j\d+>> Mul [<<Left>>,<<Right>>]
|
/// CHECK: <<Sub:j\d+>> Sub [<<Acc>>,<<Mul>>]
|
/// CHECK: Return [<<Sub>>]
|
|
/// CHECK-START-ARM: long Main.$opt$noinline$mulSub(long, long, long) instruction_simplifier_arm (after)
|
/// CHECK-NOT: MultiplyAccumulate
|
|
public static long $opt$noinline$mulSub(long acc, long left, long right) {
|
if (doThrow) throw new Error();
|
return acc - left * right;
|
}
|
|
/**
|
* Test that we do not create a multiply-accumulate instruction when there
|
* are other uses of the multiplication that cannot merge it.
|
*/
|
|
/// CHECK-START-ARM64: int Main.$opt$noinline$multipleUses1(int, int, int) instruction_simplifier_arm64 (before)
|
/// CHECK: <<Acc:i\d+>> ParameterValue
|
/// CHECK: <<Left:i\d+>> ParameterValue
|
/// CHECK: <<Right:i\d+>> ParameterValue
|
/// CHECK: <<Mul:i\d+>> Mul [<<Left>>,<<Right>>]
|
/// CHECK: <<Add:i\d+>> Add [<<Acc>>,<<Mul>>]
|
/// CHECK: <<Or:i\d+>> Or [<<Mul>>,<<Add>>]
|
/// CHECK: Return [<<Or>>]
|
|
/// CHECK-START-ARM64: int Main.$opt$noinline$multipleUses1(int, int, int) instruction_simplifier_arm64 (after)
|
/// CHECK: <<Acc:i\d+>> ParameterValue
|
/// CHECK: <<Left:i\d+>> ParameterValue
|
/// CHECK: <<Right:i\d+>> ParameterValue
|
/// CHECK: <<Mul:i\d+>> Mul [<<Left>>,<<Right>>]
|
/// CHECK: <<Add:i\d+>> Add [<<Acc>>,<<Mul>>]
|
/// CHECK: <<Or:i\d+>> Or [<<Mul>>,<<Add>>]
|
/// CHECK: Return [<<Or>>]
|
|
/// CHECK-START-ARM64: int Main.$opt$noinline$multipleUses1(int, int, int) instruction_simplifier_arm64 (after)
|
/// CHECK-NOT: MultiplyAccumulate
|
|
/// CHECK-START-ARM: int Main.$opt$noinline$multipleUses1(int, int, int) instruction_simplifier_arm (before)
|
/// CHECK: <<Acc:i\d+>> ParameterValue
|
/// CHECK: <<Left:i\d+>> ParameterValue
|
/// CHECK: <<Right:i\d+>> ParameterValue
|
/// CHECK: <<Mul:i\d+>> Mul [<<Left>>,<<Right>>]
|
/// CHECK: <<Add:i\d+>> Add [<<Acc>>,<<Mul>>]
|
/// CHECK: <<Or:i\d+>> Or [<<Mul>>,<<Add>>]
|
/// CHECK: Return [<<Or>>]
|
|
/// CHECK-START-ARM: int Main.$opt$noinline$multipleUses1(int, int, int) instruction_simplifier_arm (after)
|
/// CHECK: <<Acc:i\d+>> ParameterValue
|
/// CHECK: <<Left:i\d+>> ParameterValue
|
/// CHECK: <<Right:i\d+>> ParameterValue
|
/// CHECK: <<Mul:i\d+>> Mul [<<Left>>,<<Right>>]
|
/// CHECK: <<Add:i\d+>> Add [<<Acc>>,<<Mul>>]
|
/// CHECK: <<Or:i\d+>> Or [<<Mul>>,<<Add>>]
|
/// CHECK: Return [<<Or>>]
|
|
/// CHECK-START-ARM: int Main.$opt$noinline$multipleUses1(int, int, int) instruction_simplifier_arm (after)
|
/// CHECK-NOT: MultiplyAccumulate
|
|
public static int $opt$noinline$multipleUses1(int acc, int left, int right) {
|
if (doThrow) throw new Error();
|
int temp = left * right;
|
return temp | (acc + temp);
|
}
|
|
/**
|
* Test that we do not create a multiply-accumulate instruction even when all
|
* uses of the multiplication can merge it.
|
*/
|
|
/// CHECK-START-ARM64: long Main.$opt$noinline$multipleUses2(long, long, long) instruction_simplifier_arm64 (before)
|
/// CHECK: <<Acc:j\d+>> ParameterValue
|
/// CHECK: <<Left:j\d+>> ParameterValue
|
/// CHECK: <<Right:j\d+>> ParameterValue
|
/// CHECK: <<Mul:j\d+>> Mul [<<Left>>,<<Right>>]
|
/// CHECK: <<Add:j\d+>> Add [<<Acc>>,<<Mul>>]
|
/// CHECK: <<Sub:j\d+>> Sub [<<Acc>>,<<Mul>>]
|
/// CHECK: <<Res:j\d+>> Add [<<Add>>,<<Sub>>]
|
/// CHECK: Return [<<Res>>]
|
|
/// CHECK-START-ARM64: long Main.$opt$noinline$multipleUses2(long, long, long) instruction_simplifier_arm64 (after)
|
/// CHECK: <<Acc:j\d+>> ParameterValue
|
/// CHECK: <<Left:j\d+>> ParameterValue
|
/// CHECK: <<Right:j\d+>> ParameterValue
|
/// CHECK: <<Mul:j\d+>> Mul [<<Left>>,<<Right>>]
|
/// CHECK: <<Add:j\d+>> Add [<<Acc>>,<<Mul>>]
|
/// CHECK: <<Sub:j\d+>> Sub [<<Acc>>,<<Mul>>]
|
/// CHECK: <<Res:j\d+>> Add [<<Add>>,<<Sub>>]
|
/// CHECK: Return [<<Res>>]
|
|
/// CHECK-START-ARM64: long Main.$opt$noinline$multipleUses2(long, long, long) instruction_simplifier_arm64 (after)
|
/// CHECK-NOT: MultiplyAccumulate
|
|
/// CHECK-START-ARM: long Main.$opt$noinline$multipleUses2(long, long, long) instruction_simplifier_arm (before)
|
/// CHECK: <<Acc:j\d+>> ParameterValue
|
/// CHECK: <<Left:j\d+>> ParameterValue
|
/// CHECK: <<Right:j\d+>> ParameterValue
|
/// CHECK: <<Mul:j\d+>> Mul [<<Left>>,<<Right>>]
|
/// CHECK: <<Add:j\d+>> Add [<<Acc>>,<<Mul>>]
|
/// CHECK: <<Sub:j\d+>> Sub [<<Acc>>,<<Mul>>]
|
/// CHECK: <<Res:j\d+>> Add [<<Add>>,<<Sub>>]
|
/// CHECK: Return [<<Res>>]
|
|
/// CHECK-START-ARM: long Main.$opt$noinline$multipleUses2(long, long, long) instruction_simplifier_arm (after)
|
/// CHECK: <<Acc:j\d+>> ParameterValue
|
/// CHECK: <<Left:j\d+>> ParameterValue
|
/// CHECK: <<Right:j\d+>> ParameterValue
|
/// CHECK: <<Mul:j\d+>> Mul [<<Left>>,<<Right>>]
|
/// CHECK: <<Add:j\d+>> Add [<<Acc>>,<<Mul>>]
|
/// CHECK: <<Sub:j\d+>> Sub [<<Acc>>,<<Mul>>]
|
/// CHECK: <<Res:j\d+>> Add [<<Add>>,<<Sub>>]
|
/// CHECK: Return [<<Res>>]
|
|
/// CHECK-START-ARM: long Main.$opt$noinline$multipleUses2(long, long, long) instruction_simplifier_arm (after)
|
/// CHECK-NOT: MultiplyAccumulate
|
|
|
public static long $opt$noinline$multipleUses2(long acc, long left, long right) {
|
if (doThrow) throw new Error();
|
long temp = left * right;
|
return (acc + temp) + (acc - temp);
|
}
|
|
|
/**
|
* Test the interpretation of `a * (b + 1)` as `a + (a * b)`.
|
*/
|
|
/// CHECK-START-ARM64: int Main.$opt$noinline$mulPlusOne(int, int) instruction_simplifier_arm64 (before)
|
/// CHECK: <<Acc:i\d+>> ParameterValue
|
/// CHECK: <<Var:i\d+>> ParameterValue
|
/// CHECK: <<Const1:i\d+>> IntConstant 1
|
/// CHECK: <<Add:i\d+>> Add [<<Var>>,<<Const1>>]
|
/// CHECK: <<Mul:i\d+>> Mul [<<Acc>>,<<Add>>]
|
/// CHECK: Return [<<Mul>>]
|
|
/// CHECK-START-ARM64: int Main.$opt$noinline$mulPlusOne(int, int) instruction_simplifier_arm64 (after)
|
/// CHECK: <<Acc:i\d+>> ParameterValue
|
/// CHECK: <<Var:i\d+>> ParameterValue
|
/// CHECK: <<MulAdd:i\d+>> MultiplyAccumulate [<<Acc>>,<<Acc>>,<<Var>>] kind:Add
|
/// CHECK: Return [<<MulAdd>>]
|
|
/// CHECK-START-ARM64: int Main.$opt$noinline$mulPlusOne(int, int) instruction_simplifier_arm64 (after)
|
/// CHECK-NOT: Mul
|
/// CHECK-NOT: Add
|
|
/// CHECK-START-ARM64: int Main.$opt$noinline$mulPlusOne(int, int) disassembly (after)
|
/// CHECK: madd w{{\d+}}, w{{\d+}}, w{{\d+}}, w{{\d+}}
|
|
/// CHECK-START-ARM: int Main.$opt$noinline$mulPlusOne(int, int) instruction_simplifier_arm (before)
|
/// CHECK: <<Acc:i\d+>> ParameterValue
|
/// CHECK: <<Var:i\d+>> ParameterValue
|
/// CHECK: <<Const1:i\d+>> IntConstant 1
|
/// CHECK: <<Add:i\d+>> Add [<<Var>>,<<Const1>>]
|
/// CHECK: <<Mul:i\d+>> Mul [<<Acc>>,<<Add>>]
|
/// CHECK: Return [<<Mul>>]
|
|
/// CHECK-START-ARM: int Main.$opt$noinline$mulPlusOne(int, int) instruction_simplifier_arm (after)
|
/// CHECK: <<Acc:i\d+>> ParameterValue
|
/// CHECK: <<Var:i\d+>> ParameterValue
|
/// CHECK: <<MulAdd:i\d+>> MultiplyAccumulate [<<Acc>>,<<Acc>>,<<Var>>] kind:Add
|
/// CHECK: Return [<<MulAdd>>]
|
|
/// CHECK-START-ARM: int Main.$opt$noinline$mulPlusOne(int, int) instruction_simplifier_arm (after)
|
/// CHECK-NOT: Mul
|
/// CHECK-NOT: Add
|
|
/// CHECK-START-ARM: int Main.$opt$noinline$mulPlusOne(int, int) disassembly (after)
|
/// CHECK: mla r{{\d+}}, r{{\d+}}, r{{\d+}}, r{{\d+}}
|
|
public static int $opt$noinline$mulPlusOne(int acc, int var) {
|
if (doThrow) throw new Error();
|
return acc * (var + 1);
|
}
|
|
|
/**
|
* Test the interpretation of `a * (1 - b)` as `a - (a * b)`.
|
*/
|
|
/// CHECK-START-ARM64: long Main.$opt$noinline$mulMinusOne(long, long) instruction_simplifier_arm64 (before)
|
/// CHECK: <<Acc:j\d+>> ParameterValue
|
/// CHECK: <<Var:j\d+>> ParameterValue
|
/// CHECK: <<Const1:j\d+>> LongConstant 1
|
/// CHECK: <<Sub:j\d+>> Sub [<<Const1>>,<<Var>>]
|
/// CHECK: <<Mul:j\d+>> Mul [<<Acc>>,<<Sub>>]
|
/// CHECK: Return [<<Mul>>]
|
|
/// CHECK-START-ARM64: long Main.$opt$noinline$mulMinusOne(long, long) instruction_simplifier_arm64 (after)
|
/// CHECK: <<Acc:j\d+>> ParameterValue
|
/// CHECK: <<Var:j\d+>> ParameterValue
|
/// CHECK: <<MulSub:j\d+>> MultiplyAccumulate [<<Acc>>,<<Acc>>,<<Var>>] kind:Sub
|
/// CHECK: Return [<<MulSub>>]
|
|
/// CHECK-START-ARM64: long Main.$opt$noinline$mulMinusOne(long, long) instruction_simplifier_arm64 (after)
|
/// CHECK-NOT: Mul
|
/// CHECK-NOT: Sub
|
|
/// CHECK-START-ARM64: long Main.$opt$noinline$mulMinusOne(long, long) disassembly (after)
|
/// CHECK: msub x{{\d+}}, x{{\d+}}, x{{\d+}}, x{{\d+}}
|
|
/// CHECK-START-ARM: long Main.$opt$noinline$mulMinusOne(long, long) instruction_simplifier_arm (before)
|
/// CHECK: <<Acc:j\d+>> ParameterValue
|
/// CHECK: <<Var:j\d+>> ParameterValue
|
/// CHECK: <<Const1:j\d+>> LongConstant 1
|
/// CHECK: <<Sub:j\d+>> Sub [<<Const1>>,<<Var>>]
|
/// CHECK: <<Mul:j\d+>> Mul [<<Acc>>,<<Sub>>]
|
/// CHECK: Return [<<Mul>>]
|
|
/// CHECK-START-ARM: long Main.$opt$noinline$mulMinusOne(long, long) instruction_simplifier_arm (after)
|
/// CHECK-NOT: MultiplyAccumulate
|
public static long $opt$noinline$mulMinusOne(long acc, long var) {
|
if (doThrow) throw new Error();
|
return acc * (1 - var);
|
}
|
|
/**
|
* Test basic merging of `MUL+NEG` into `MULNEG`.
|
*/
|
|
/// CHECK-START-ARM64: int Main.$opt$noinline$mulNeg(int, int) instruction_simplifier_arm64 (before)
|
/// CHECK: <<Left:i\d+>> ParameterValue
|
/// CHECK: <<Right:i\d+>> ParameterValue
|
/// CHECK: <<Mul:i\d+>> Mul [<<Left>>,<<Right>>]
|
/// CHECK: <<Neg:i\d+>> Neg [<<Mul>>]
|
/// CHECK: Return [<<Neg>>]
|
|
/// CHECK-START-ARM64: int Main.$opt$noinline$mulNeg(int, int) instruction_simplifier_arm64 (after)
|
/// CHECK: <<Left:i\d+>> ParameterValue
|
/// CHECK: <<Right:i\d+>> ParameterValue
|
/// CHECK: <<Const0:i\d+>> IntConstant 0
|
/// CHECK: <<MulNeg:i\d+>> MultiplyAccumulate [<<Const0>>,<<Left>>,<<Right>>] kind:Sub
|
/// CHECK: Return [<<MulNeg>>]
|
|
/// CHECK-START-ARM64: int Main.$opt$noinline$mulNeg(int, int) instruction_simplifier_arm64 (after)
|
/// CHECK-NOT: Mul
|
/// CHECK-NOT: Neg
|
|
/// CHECK-START-ARM64: int Main.$opt$noinline$mulNeg(int, int) disassembly (after)
|
/// CHECK: mneg w{{\d+}}, w{{\d+}}, w{{\d+}}
|
|
/// CHECK-START-ARM: int Main.$opt$noinline$mulNeg(int, int) instruction_simplifier_arm (before)
|
/// CHECK: <<Left:i\d+>> ParameterValue
|
/// CHECK: <<Right:i\d+>> ParameterValue
|
/// CHECK: <<Mul:i\d+>> Mul [<<Left>>,<<Right>>]
|
/// CHECK: <<Neg:i\d+>> Neg [<<Mul>>]
|
/// CHECK: Return [<<Neg>>]
|
|
/// CHECK-START-ARM: int Main.$opt$noinline$mulNeg(int, int) instruction_simplifier_arm (after)
|
/// CHECK: <<Left:i\d+>> ParameterValue
|
/// CHECK: <<Right:i\d+>> ParameterValue
|
/// CHECK: <<Mul:i\d+>> Mul [<<Left>>,<<Right>>]
|
/// CHECK: <<Neg:i\d+>> Neg [<<Mul>>]
|
/// CHECK: Return [<<Neg>>]
|
|
/// CHECK-START-ARM: int Main.$opt$noinline$mulNeg(int, int) instruction_simplifier_arm (after)
|
/// CHECK-NOT: MultiplyAccumulate
|
|
public static int $opt$noinline$mulNeg(int left, int right) {
|
if (doThrow) throw new Error();
|
return - (left * right);
|
}
|
|
/**
|
* Test basic merging of `MUL+NEG` into `MULNEG`.
|
*/
|
|
/// CHECK-START-ARM64: long Main.$opt$noinline$mulNeg(long, long) instruction_simplifier_arm64 (before)
|
/// CHECK: <<Left:j\d+>> ParameterValue
|
/// CHECK: <<Right:j\d+>> ParameterValue
|
/// CHECK: <<Mul:j\d+>> Mul [<<Left>>,<<Right>>]
|
/// CHECK: <<Neg:j\d+>> Neg [<<Mul>>]
|
/// CHECK: Return [<<Neg>>]
|
|
/// CHECK-START-ARM64: long Main.$opt$noinline$mulNeg(long, long) instruction_simplifier_arm64 (after)
|
/// CHECK: <<Left:j\d+>> ParameterValue
|
/// CHECK: <<Right:j\d+>> ParameterValue
|
/// CHECK: <<Const0:j\d+>> LongConstant 0
|
/// CHECK: <<MulNeg:j\d+>> MultiplyAccumulate [<<Const0>>,<<Left>>,<<Right>>] kind:Sub
|
/// CHECK: Return [<<MulNeg>>]
|
|
/// CHECK-START-ARM64: long Main.$opt$noinline$mulNeg(long, long) instruction_simplifier_arm64 (after)
|
/// CHECK-NOT: Mul
|
/// CHECK-NOT: Neg
|
|
/// CHECK-START-ARM64: long Main.$opt$noinline$mulNeg(long, long) disassembly (after)
|
/// CHECK: mneg x{{\d+}}, x{{\d+}}, x{{\d+}}
|
|
/// CHECK-START-ARM: long Main.$opt$noinline$mulNeg(long, long) instruction_simplifier_arm (before)
|
/// CHECK: <<Left:j\d+>> ParameterValue
|
/// CHECK: <<Right:j\d+>> ParameterValue
|
/// CHECK: <<Mul:j\d+>> Mul [<<Left>>,<<Right>>]
|
/// CHECK: <<Neg:j\d+>> Neg [<<Mul>>]
|
/// CHECK: Return [<<Neg>>]
|
|
/// CHECK-START-ARM: long Main.$opt$noinline$mulNeg(long, long) instruction_simplifier_arm (after)
|
/// CHECK: <<Left:j\d+>> ParameterValue
|
/// CHECK: <<Right:j\d+>> ParameterValue
|
/// CHECK: <<Mul:j\d+>> Mul [<<Left>>,<<Right>>]
|
/// CHECK: <<Neg:j\d+>> Neg [<<Mul>>]
|
/// CHECK: Return [<<Neg>>]
|
|
/// CHECK-START-ARM: long Main.$opt$noinline$mulNeg(long, long) instruction_simplifier_arm (after)
|
/// CHECK-NOT: MultiplyAccumulate
|
|
public static long $opt$noinline$mulNeg(long left, long right) {
|
if (doThrow) throw new Error();
|
return - (left * right);
|
}
|
|
/// CHECK-START-{ARM64,MIPS64}: void Main.SimdMulAdd(int[], int[]) instruction_simplifier$after_bce (before)
|
/// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
|
/// CHECK-DAG: VecMul loop:<<Loop>> outer_loop:none
|
/// CHECK-DAG: VecAdd loop:<<Loop>> outer_loop:none
|
|
/// CHECK-START-{ARM64,MIPS64}: void Main.SimdMulAdd(int[], int[]) instruction_simplifier$after_bce (after)
|
/// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
|
/// CHECK-DAG: VecMultiplyAccumulate kind:Add loop:<<Loop>> outer_loop:none
|
|
/// CHECK-START-{ARM64,MIPS64}: void Main.SimdMulAdd(int[], int[]) instruction_simplifier$after_bce (after)
|
/// CHECK-NOT: VecMul
|
/// CHECK-NOT: VecAdd
|
|
public static void SimdMulAdd(int[] array1, int[] array2) {
|
for (int j = 0; j < 100; j++) {
|
array2[j] += 12345 * array1[j];
|
}
|
}
|
|
/// CHECK-START-MIPS64: void Main.SimdMulAddLong(long[], long[]) instruction_simplifier$after_bce (before)
|
/// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
|
/// CHECK-DAG: VecMul loop:<<Loop>> outer_loop:none
|
/// CHECK-DAG: VecAdd loop:<<Loop>> outer_loop:none
|
|
/// CHECK-START-MIPS64: void Main.SimdMulAddLong(long[], long[]) instruction_simplifier$after_bce (after)
|
/// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
|
/// CHECK-DAG: VecMultiplyAccumulate kind:Add loop:<<Loop>> outer_loop:none
|
|
/// CHECK-START-MIPS64: void Main.SimdMulAddLong(long[], long[]) instruction_simplifier$after_bce (after)
|
/// CHECK-NOT: VecMul
|
/// CHECK-NOT: VecAdd
|
public static void SimdMulAddLong(long[] array1, long[] array2) {
|
for (int j = 0; j < 100; j++) {
|
array2[j] += 12345 * array1[j];
|
}
|
}
|
|
/// CHECK-START-{ARM64,MIPS64}: void Main.SimdMulSub(int[], int[]) instruction_simplifier$after_bce (before)
|
/// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
|
/// CHECK-DAG: VecMul loop:<<Loop>> outer_loop:none
|
/// CHECK-DAG: VecSub loop:<<Loop>> outer_loop:none
|
|
/// CHECK-START-{ARM64,MIPS64}: void Main.SimdMulSub(int[], int[]) instruction_simplifier$after_bce (after)
|
/// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
|
/// CHECK-DAG: VecMultiplyAccumulate kind:Sub loop:<<Loop>> outer_loop:none
|
|
/// CHECK-START-{ARM64,MIPS64}: void Main.SimdMulSub(int[], int[]) instruction_simplifier$after_bce (after)
|
/// CHECK-NOT: VecMul
|
/// CHECK-NOT: VecSub
|
|
public static void SimdMulSub(int[] array1, int[] array2) {
|
for (int j = 0; j < 100; j++) {
|
array2[j] -= 12345 * array1[j];
|
}
|
}
|
|
/// CHECK-START-MIPS64: void Main.SimdMulSubLong(long[], long[]) instruction_simplifier$after_bce (before)
|
/// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
|
/// CHECK-DAG: VecMul loop:<<Loop>> outer_loop:none
|
/// CHECK-DAG: VecSub loop:<<Loop>> outer_loop:none
|
|
/// CHECK-START-MIPS64: void Main.SimdMulSubLong(long[], long[]) instruction_simplifier$after_bce (after)
|
/// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
|
/// CHECK-DAG: VecMultiplyAccumulate kind:Sub loop:<<Loop>> outer_loop:none
|
|
/// CHECK-START-MIPS64: void Main.SimdMulSubLong(long[], long[]) instruction_simplifier$after_bce (after)
|
/// CHECK-NOT: VecMul
|
/// CHECK-NOT: VecSub
|
public static void SimdMulSubLong(long[] array1, long[] array2) {
|
for (int j = 0; j < 100; j++) {
|
array2[j] -= 12345 * array1[j];
|
}
|
}
|
|
/// CHECK-START-{ARM64,MIPS64}: void Main.SimdMulMultipleUses(int[], int[]) instruction_simplifier$after_bce (before)
|
/// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
|
/// CHECK-DAG: VecMul loop:<<Loop>> outer_loop:none
|
/// CHECK-DAG: VecSub loop:<<Loop>> outer_loop:none
|
|
/// CHECK-START-{ARM64,MIPS64}: void Main.SimdMulMultipleUses(int[], int[]) instruction_simplifier$after_bce (after)
|
/// CHECK-NOT: VecMultiplyAccumulate
|
|
public static void SimdMulMultipleUses(int[] array1, int[] array2) {
|
for (int j = 0; j < 100; j++) {
|
int temp = 12345 * array1[j];
|
array2[j] -= temp;
|
array1[j] = temp;
|
}
|
}
|
|
/// CHECK-START-MIPS64: void Main.SimdMulMultipleUsesLong(long[], long[]) instruction_simplifier$after_bce (before)
|
/// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
|
/// CHECK-DAG: VecMul loop:<<Loop>> outer_loop:none
|
/// CHECK-DAG: VecSub loop:<<Loop>> outer_loop:none
|
|
/// CHECK-START-MIPS64: void Main.SimdMulMultipleUsesLong(long[], long[]) instruction_simplifier$after_bce (after)
|
/// CHECK-NOT: VecMultiplyAccumulate
|
public static void SimdMulMultipleUsesLong(long[] array1, long[] array2) {
|
for (int j = 0; j < 100; j++) {
|
long temp = 12345 * array1[j];
|
array2[j] -= temp;
|
array1[j] = temp;
|
}
|
}
|
|
public static final int ARRAY_SIZE = 1000;
|
|
public static void initArray(int[] array) {
|
for (int i = 0; i < ARRAY_SIZE; i++) {
|
array[i] = i;
|
}
|
}
|
|
public static void initArrayLong(long[] array) {
|
for (int i = 0; i < ARRAY_SIZE; i++) {
|
array[i] = i;
|
}
|
}
|
|
public static int calcArraySum(int[] array) {
|
int sum = 0;
|
for (int i = 0; i < ARRAY_SIZE; i++) {
|
sum += array[i];
|
}
|
return sum;
|
}
|
|
public static long calcArraySumLong(long[] array) {
|
long sum = 0;
|
for (int i = 0; i < ARRAY_SIZE; i++) {
|
sum += array[i];
|
}
|
return sum;
|
}
|
|
public static void testSimdMultiplyAccumulate() {
|
int[] array1 = new int[ARRAY_SIZE];
|
int[] array2 = new int[ARRAY_SIZE];
|
long[] array3 = new long[ARRAY_SIZE];
|
long[] array4 = new long[ARRAY_SIZE];
|
|
initArray(array1);
|
initArray(array2);
|
SimdMulSub(array1, array2);
|
assertIntEquals(-60608250, calcArraySum(array2));
|
|
initArrayLong(array3);
|
initArrayLong(array4);
|
SimdMulSubLong(array3, array4);
|
assertLongEquals(-60608250, calcArraySumLong(array4));
|
|
initArray(array1);
|
initArray(array2);
|
SimdMulAdd(array1, array2);
|
assertIntEquals(61607250, calcArraySum(array2));
|
|
initArrayLong(array3);
|
initArrayLong(array4);
|
SimdMulAddLong(array3, array4);
|
assertLongEquals(61607250, calcArraySumLong(array4));
|
}
|
|
public static void main(String[] args) {
|
assertIntEquals(7, $opt$noinline$mulAdd(1, 2, 3));
|
assertLongEquals(-26, $opt$noinline$mulSub(4, 5, 6));
|
assertIntEquals(79, $opt$noinline$multipleUses1(7, 8, 9));
|
assertLongEquals(20, $opt$noinline$multipleUses2(10, 11, 12));
|
assertIntEquals(195, $opt$noinline$mulPlusOne(13, 14));
|
assertLongEquals(-225, $opt$noinline$mulMinusOne(15, 16));
|
assertIntEquals(-306, $opt$noinline$mulNeg(17, 18));
|
assertLongEquals(-380, $opt$noinline$mulNeg(19, 20));
|
|
testSimdMultiplyAccumulate();
|
}
|
}
|
