--- /dev/null 2016-05-31 09:42:47.975716356 -0700 +++ new/src/jdk.vm.compiler/share/classes/org.graalvm.compiler.lir.sparc/src/org/graalvm/compiler/lir/sparc/SPARCControlFlow.java 2016-12-09 00:53:51.034849720 -0800 @@ -0,0 +1,754 @@ +/* + * Copyright (c) 2013, 2016, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package org.graalvm.compiler.lir.sparc; + +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.BPCC; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.CBCOND; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.FBPCC; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.INSTRUCTION_SIZE; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.isSimm10; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.isSimm11; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.isSimm13; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.isSimm5; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.Annul.ANNUL; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.Annul.NOT_ANNUL; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.BranchPredict.PREDICT_NOT_TAKEN; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.BranchPredict.PREDICT_TAKEN; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.CC.Fcc0; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.CC.Icc; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.CC.Xcc; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.Always; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.Equal; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.F_Equal; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.F_Greater; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.F_GreaterOrEqual; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.F_Less; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.F_LessOrEqual; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.F_UnorderedGreaterOrEqual; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.F_UnorderedOrEqual; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.F_UnorderedOrGreater; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.F_UnorderedOrLess; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.F_UnorderedOrLessOrEqual; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.Greater; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.GreaterEqual; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.GreaterEqualUnsigned; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.GreaterUnsigned; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.Less; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.LessEqual; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.LessEqualUnsigned; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.LessUnsigned; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.NotEqual; +import static org.graalvm.compiler.asm.sparc.SPARCAssembler.Op3s.Subcc; +import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.CONST; +import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.HINT; +import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.ILLEGAL; +import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.REG; +import static org.graalvm.compiler.lir.LIRValueUtil.asJavaConstant; +import static org.graalvm.compiler.lir.LIRValueUtil.isConstantValue; +import static org.graalvm.compiler.lir.LIRValueUtil.isJavaConstant; +import static org.graalvm.compiler.lir.sparc.SPARCMove.const2reg; +import static org.graalvm.compiler.lir.sparc.SPARCOP3Op.emitOp3; +import static jdk.vm.ci.code.ValueUtil.asRegister; +import static jdk.vm.ci.sparc.SPARC.CPU; +import static jdk.vm.ci.sparc.SPARC.g0; +import static jdk.vm.ci.sparc.SPARCKind.WORD; +import static jdk.vm.ci.sparc.SPARCKind.XWORD; + +import java.util.ArrayList; +import java.util.EnumSet; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.graalvm.compiler.asm.Assembler; +import org.graalvm.compiler.asm.Assembler.LabelHint; +import org.graalvm.compiler.asm.Label; +import org.graalvm.compiler.asm.NumUtil; +import org.graalvm.compiler.asm.sparc.SPARCAssembler; +import org.graalvm.compiler.asm.sparc.SPARCAssembler.BranchPredict; +import org.graalvm.compiler.asm.sparc.SPARCAssembler.CC; +import org.graalvm.compiler.asm.sparc.SPARCAssembler.CMOV; +import org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag; +import org.graalvm.compiler.asm.sparc.SPARCMacroAssembler; +import org.graalvm.compiler.asm.sparc.SPARCMacroAssembler.ScratchRegister; +import org.graalvm.compiler.core.common.calc.Condition; +import org.graalvm.compiler.debug.GraalError; +import org.graalvm.compiler.lir.LIRInstructionClass; +import org.graalvm.compiler.lir.LabelRef; +import org.graalvm.compiler.lir.Opcode; +import org.graalvm.compiler.lir.StandardOp; +import org.graalvm.compiler.lir.SwitchStrategy; +import org.graalvm.compiler.lir.SwitchStrategy.BaseSwitchClosure; +import org.graalvm.compiler.lir.Variable; +import org.graalvm.compiler.lir.asm.CompilationResultBuilder; + +import jdk.vm.ci.code.Register; +import jdk.vm.ci.meta.AllocatableValue; +import jdk.vm.ci.meta.Constant; +import jdk.vm.ci.meta.JavaConstant; +import jdk.vm.ci.meta.PlatformKind; +import jdk.vm.ci.meta.Value; +import jdk.vm.ci.sparc.SPARC.CPUFeature; +import jdk.vm.ci.sparc.SPARCKind; + +public class SPARCControlFlow { + // This describes the maximum offset between the first emitted (load constant in to scratch, + // if does not fit into simm5 of cbcond) instruction and the final branch instruction + private static final int maximumSelfOffsetInstructions = 2; + + public static final class ReturnOp extends SPARCBlockEndOp { + public static final LIRInstructionClass TYPE = LIRInstructionClass.create(ReturnOp.class); + public static final SizeEstimate SIZE = SizeEstimate.create(2); + + @Use({REG, ILLEGAL}) protected Value x; + + public ReturnOp(Value x) { + super(TYPE, SIZE); + this.x = x; + } + + @Override + public void emitCode(CompilationResultBuilder crb, SPARCMacroAssembler masm) { + emitCodeHelper(crb, masm); + } + + public static void emitCodeHelper(CompilationResultBuilder crb, SPARCMacroAssembler masm) { + masm.ret(); + // On SPARC we always leave the frame (in the delay slot). + crb.frameContext.leave(crb); + } + } + + public static final class CompareBranchOp extends SPARCBlockEndOp implements SPARCDelayedControlTransfer { + public static final LIRInstructionClass TYPE = LIRInstructionClass.create(CompareBranchOp.class); + public static final SizeEstimate SIZE = SizeEstimate.create(3); + static final EnumSet SUPPORTED_KINDS = EnumSet.of(XWORD, WORD); + + @Use({REG}) protected Value x; + @Use({REG, CONST}) protected Value y; + private ConditionFlag conditionFlag; + protected final LabelRef trueDestination; + protected LabelHint trueDestinationHint; + protected final LabelRef falseDestination; + protected LabelHint falseDestinationHint; + protected final SPARCKind kind; + protected final boolean unorderedIsTrue; + private boolean emitted = false; + private int delaySlotPosition = -1; + private double trueDestinationProbability; + + public CompareBranchOp(Value x, Value y, Condition condition, LabelRef trueDestination, LabelRef falseDestination, SPARCKind kind, boolean unorderedIsTrue, double trueDestinationProbability) { + super(TYPE, SIZE); + this.x = x; + this.y = y; + this.trueDestination = trueDestination; + this.falseDestination = falseDestination; + this.kind = kind; + this.unorderedIsTrue = unorderedIsTrue; + this.trueDestinationProbability = trueDestinationProbability; + conditionFlag = fromCondition(kind.isInteger(), condition, unorderedIsTrue); + } + + @Override + public void emitCode(CompilationResultBuilder crb, SPARCMacroAssembler masm) { + if (emitted) { // Only if delayed control transfer is used we must check this + assert masm.position() - delaySlotPosition == 4 : "Only one instruction can be stuffed into the delay slot"; + } + if (!emitted) { + requestHints(masm); + int targetPosition = getTargetPosition(masm); + if (canUseShortBranch(crb, masm, targetPosition)) { + emitted = emitShortCompareBranch(crb, masm); + } + if (!emitted) { // No short compare/branch was used, so we go into fallback + emitted = emitLongCompareBranch(crb, masm, true); + emitted = true; + } + } + assert emitted; + } + + private boolean emitLongCompareBranch(CompilationResultBuilder crb, SPARCMacroAssembler masm, boolean withDelayedNop) { + emitOp3(masm, Subcc, x, y); + return emitBranch(crb, masm, kind, conditionFlag, trueDestination, falseDestination, withDelayedNop, trueDestinationProbability); + } + + private static int getTargetPosition(Assembler asm) { + return asm.position() + maximumSelfOffsetInstructions * asm.target.wordSize; + } + + @Override + public void emitControlTransfer(CompilationResultBuilder crb, SPARCMacroAssembler masm) { + requestHints(masm); + // When we use short branches, no delay slot is available + int targetPosition = getTargetPosition(masm); + if (!canUseShortBranch(crb, masm, targetPosition)) { + emitted = emitLongCompareBranch(crb, masm, false); + if (emitted) { + delaySlotPosition = masm.position(); + } + } + } + + private void requestHints(SPARCMacroAssembler masm) { + if (trueDestinationHint == null) { + this.trueDestinationHint = masm.requestLabelHint(trueDestination.label()); + } + if (falseDestinationHint == null) { + this.falseDestinationHint = masm.requestLabelHint(falseDestination.label()); + } + } + + /** + * Tries to use the emit the compare/branch instruction. + *

+ * CBcond has follwing limitations + *

    + *
  • Immediate field is only 5 bit and is on the right + *
  • Jump offset is maximum of -+512 instruction + * + *

    + * We get from outside + *

      + *
    • at least one of trueDestination falseDestination is within reach of +-512 + * instructions + *
    • two registers OR one register and a constant which fits simm13 + * + *

      + * We do: + *

        + *
      • find out which target needs to be branched conditionally + *
      • find out if fall-through is possible, if not, a unconditional branch is needed after + * cbcond (needJump=true) + *
      • if no fall through: we need to put the closer jump into the cbcond branch and the + * farther into the jmp (unconditional branch) + *
      • if constant on the left side, mirror to be on the right + *
      • if constant on right does not fit into simm5, put it into a scratch register + * + * @param crb + * @param masm + * @return true if the branch could be emitted + */ + private boolean emitShortCompareBranch(CompilationResultBuilder crb, SPARCMacroAssembler masm) { + ConditionFlag actualConditionFlag = conditionFlag; + Label actualTrueTarget = trueDestination.label(); + Label actualFalseTarget = falseDestination.label(); + Label tmpTarget; + boolean needJump; + if (crb.isSuccessorEdge(trueDestination)) { + actualConditionFlag = conditionFlag.negate(); + tmpTarget = actualTrueTarget; + actualTrueTarget = actualFalseTarget; + actualFalseTarget = tmpTarget; + needJump = false; + } else { + needJump = !crb.isSuccessorEdge(falseDestination); + int targetPosition = getTargetPosition(masm); + if (needJump && !isShortBranch(masm, targetPosition, trueDestinationHint, actualTrueTarget)) { + // we have to jump in either way, so we must put the shorter + // branch into the actualTarget as only one of the two jump targets + // is guaranteed to be simm10 + actualConditionFlag = actualConditionFlag.negate(); + tmpTarget = actualTrueTarget; + actualTrueTarget = actualFalseTarget; + actualFalseTarget = tmpTarget; + } + } + emitCBCond(masm, x, y, actualTrueTarget, actualConditionFlag); + if (needJump) { + masm.jmp(actualFalseTarget); + masm.nop(); + } + return true; + } + + private void emitCBCond(SPARCMacroAssembler masm, Value actualX, Value actualY, Label actualTrueTarget, ConditionFlag cFlag) { + PlatformKind xKind = actualX.getPlatformKind(); + boolean isLong = kind == SPARCKind.XWORD; + if (isJavaConstant(actualY)) { + JavaConstant c = asJavaConstant(actualY); + long constantY = c.isNull() ? 0 : c.asLong(); + assert NumUtil.isInt(constantY); + CBCOND.emit(masm, cFlag, isLong, asRegister(actualX, xKind), (int) constantY, actualTrueTarget); + } else { + CBCOND.emit(masm, cFlag, isLong, asRegister(actualX, xKind), asRegister(actualY, xKind), actualTrueTarget); + } + } + + private boolean canUseShortBranch(CompilationResultBuilder crb, SPARCAssembler asm, int position) { + if (!asm.hasFeature(CPUFeature.CBCOND)) { + return false; + } + if (!((SPARCKind) x.getPlatformKind()).isInteger()) { + return false; + } + // Do not use short branch, if the y value is a constant and does not fit into simm5 but + // fits into simm13; this means the code with CBcond would be longer as the code without + // CBcond. + if (isJavaConstant(y) && !isSimm5(asJavaConstant(y)) && isSimm13(asJavaConstant(y))) { + return false; + } + boolean hasShortJumpTarget = false; + if (!crb.isSuccessorEdge(trueDestination)) { + hasShortJumpTarget |= isShortBranch(asm, position, trueDestinationHint, trueDestination.label()); + } + if (!crb.isSuccessorEdge(falseDestination)) { + hasShortJumpTarget |= isShortBranch(asm, position, falseDestinationHint, falseDestination.label()); + } + return hasShortJumpTarget; + } + + @Override + public void resetState() { + emitted = false; + delaySlotPosition = -1; + } + + @Override + public void verify() { + super.verify(); + assert SUPPORTED_KINDS.contains(kind) : kind; + assert !isConstantValue(x); + assert x.getPlatformKind().equals(kind) && (isConstantValue(y) || y.getPlatformKind().equals(kind)) : x + " " + y; + } + } + + public static boolean isShortBranch(SPARCAssembler asm, int position, LabelHint hint, Label label) { + int disp = 0; + boolean dispValid = true; + if (label.isBound()) { + disp = label.position() - position; + } else if (hint != null && hint.isValid()) { + disp = hint.getTarget() - hint.getPosition(); + } else { + dispValid = false; + } + if (dispValid) { + if (disp < 0) { + disp -= maximumSelfOffsetInstructions * asm.target.wordSize; + } else { + disp += maximumSelfOffsetInstructions * asm.target.wordSize; + } + return isSimm10(disp >> 2); + } else if (hint == null) { + asm.requestLabelHint(label); + } + return false; + } + + public static final class BranchOp extends SPARCBlockEndOp implements StandardOp.BranchOp { + public static final LIRInstructionClass TYPE = LIRInstructionClass.create(BranchOp.class); + public static final SizeEstimate SIZE = SizeEstimate.create(2); + protected final ConditionFlag conditionFlag; + protected final LabelRef trueDestination; + protected final LabelRef falseDestination; + protected final SPARCKind kind; + protected final double trueDestinationProbability; + + public BranchOp(ConditionFlag conditionFlag, LabelRef trueDestination, LabelRef falseDestination, SPARCKind kind, double trueDestinationProbability) { + super(TYPE, SIZE); + this.trueDestination = trueDestination; + this.falseDestination = falseDestination; + this.kind = kind; + this.conditionFlag = conditionFlag; + this.trueDestinationProbability = trueDestinationProbability; + } + + @Override + public void emitCode(CompilationResultBuilder crb, SPARCMacroAssembler masm) { + emitBranch(crb, masm, kind, conditionFlag, trueDestination, falseDestination, true, trueDestinationProbability); + } + } + + private static boolean emitBranch(CompilationResultBuilder crb, SPARCMacroAssembler masm, SPARCKind kind, ConditionFlag conditionFlag, LabelRef trueDestination, LabelRef falseDestination, + boolean withDelayedNop, double trueDestinationProbability) { + Label actualTarget; + ConditionFlag actualConditionFlag; + boolean needJump; + BranchPredict predictTaken; + if (falseDestination != null && crb.isSuccessorEdge(trueDestination)) { + actualConditionFlag = conditionFlag != null ? conditionFlag.negate() : null; + actualTarget = falseDestination.label(); + needJump = false; + predictTaken = trueDestinationProbability < .5d ? PREDICT_TAKEN : PREDICT_NOT_TAKEN; + } else { + actualConditionFlag = conditionFlag; + actualTarget = trueDestination.label(); + needJump = falseDestination != null && !crb.isSuccessorEdge(falseDestination); + predictTaken = trueDestinationProbability > .5d ? PREDICT_TAKEN : PREDICT_NOT_TAKEN; + } + if (!withDelayedNop && needJump) { + // We cannot make use of the delay slot when we jump in true-case and false-case + return false; + } + if (kind.isFloat()) { + FBPCC.emit(masm, Fcc0, actualConditionFlag, NOT_ANNUL, predictTaken, actualTarget); + } else { + assert kind.isInteger(); + CC cc = kind.equals(WORD) ? Icc : Xcc; + BPCC.emit(masm, cc, actualConditionFlag, NOT_ANNUL, predictTaken, actualTarget); + } + if (withDelayedNop) { + masm.nop(); // delay slot + } + if (needJump) { + masm.jmp(falseDestination.label()); + } + return true; + } + + public static class StrategySwitchOp extends SPARCBlockEndOp { + public static final LIRInstructionClass TYPE = LIRInstructionClass.create(StrategySwitchOp.class); + protected Constant[] keyConstants; + private final LabelRef[] keyTargets; + private LabelRef defaultTarget; + @Alive({REG}) protected Value key; + @Alive({REG, ILLEGAL}) protected Value constantTableBase; + @Temp({REG}) protected Value scratch; + protected final SwitchStrategy strategy; + private final Map labelHints; + private final List