# HG changeset patch # User Stefan Anzinger # Date 1409265824 25200 # Node ID 4feac7e51f42400ebb35c4231c034663ed99789c # Parent f8e60d11c0ec5e1f699438f49cc42cd7803b5ae9 [SPARC] Fixing float register allocation diff -r f8e60d11c0ec -r 4feac7e51f42 graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCLIRGenerator.java --- a/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCLIRGenerator.java Mon Aug 25 21:15:59 2014 -0700 +++ b/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCLIRGenerator.java Thu Aug 28 15:43:44 2014 -0700 @@ -224,6 +224,8 @@ double trueDestinationProbability) { boolean mirrored = emitCompare(cmpKind, left, right); Condition finalCondition = mirrored ? cond.mirror() : cond; + boolean finalUnorderedIsTrue = mirrored ? !unorderedIsTrue : unorderedIsTrue; + Kind kind = left.getKind().getStackKind(); switch (kind) { case Int: @@ -233,7 +235,7 @@ break; case Float: case Double: - append(new BranchOp(finalCondition, trueDestination, falseDestination, kind)); + append(new BranchOp(finalCondition, trueDestination, falseDestination, kind, finalUnorderedIsTrue)); break; default: throw GraalInternalError.shouldNotReachHere("" + left.getKind()); diff -r f8e60d11c0ec -r 4feac7e51f42 graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotLIRGenerator.java --- a/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotLIRGenerator.java Mon Aug 25 21:15:59 2014 -0700 +++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotLIRGenerator.java Thu Aug 28 15:43:44 2014 -0700 @@ -250,11 +250,15 @@ Register[] savedRegisters = { // CPU g1, g3, g4, g5, - // FPU - f0, f1, f2, f3, f4, f5, f6, f7, - f8, f9, f10, f11, f12, f13, f14, f15, - f16, f17, f18, f19, f20, f21, f22, f23, - f24, f25, f26, f27, f28, f29, f30, f31 + // FPU, use only every second register as doubles are stored anyways + f0, /*f1, */ f2, /*f3, */ f4, /*f5, */ f6, /*f7, */ + f8, /*f9, */ f10, /*f11,*/ f12, /*f13,*/ f14, /*f15,*/ + f16, /*f17,*/ f18, /*f19,*/ f20, /*f21,*/ f22, /*f23,*/ + f24, /*f25,*/ f26, /*f27,*/ f28, /*f29,*/ f30, /*f31 */ + d32, d34, d36, d38, + d40, d42, d44, d46, + d48, d50, d52, d54, + d56, d58, d60, d62 }; // @formatter:on StackSlot[] savedRegisterLocations = new StackSlot[savedRegisters.length]; diff -r f8e60d11c0ec -r 4feac7e51f42 graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotRegisterConfig.java --- a/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotRegisterConfig.java Mon Aug 25 21:15:59 2014 -0700 +++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotRegisterConfig.java Thu Aug 28 15:43:44 2014 -0700 @@ -61,9 +61,12 @@ if (architecture.canStoreValue(reg.getRegisterCategory(), kind)) { // Special treatment for double precision // TODO: This is wasteful it uses only half of the registers as float. - if (kind == Kind.Double || kind == Kind.Float) { - // Only even register numbers are valid double precision regs - if (reg.number % 2 == 0) { + if (kind == Kind.Double) { + if (reg.name.startsWith("d")) { + list.add(reg); + } + } else if (kind == Kind.Float) { + if (reg.name.startsWith("f")) { list.add(reg); } } else { @@ -92,7 +95,9 @@ f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, - f24, f25, f26, f27, f28, f29, f30, f31}; + f24, f25, f26, f27, f28, f29, f30, f31, + d32, d34, d36, d38, d40, d42, d44, d46, + d48, d50, d52, d54, d56, d58, d60, d62}; // @formatter:on /** @@ -125,7 +130,12 @@ o0, o1, o2, o3, o4, o5, /*o6, o7,*/ l0, l1, l2, l3, l4, l5, l6, l7, i0, i1, i2, i3, i4, i5, /*i6,*/ /*i7,*/ - f0, f1, f2, f3, f4, f5, f6, f7 + //f0, f1, f2, f3, f4, f5, f6, f7, + f8, f9, f10, f11, f12, f13, f14, f15, + f16, f17, f18, f19, f20, f21, f22, f23, + f24, f25, f26, f27, f28, f29, f30, f31, + d32, d34, d36, d38, d40, d42, d44, d46, + d48, d50, d52, d54, d56, d58, d60, d62 }; // @formatter:on } else { @@ -135,7 +145,12 @@ o0, o1, o2, o3, o4, o5, /*o6, o7,*/ l0, l1, l2, l3, l4, l5, l6, l7, i0, i1, i2, i3, i4, i5, /*i6,*/ /*i7,*/ - f0, f1, f2, f3, f4, f5, f6, f7 +// f0, f1, f2, f3, f4, f5, f6, f7 + f8, f9, f10, f11, f12, f13, f14, f15, + f16, f17, f18, f19, f20, f21, f22, f23, + f24, f25, f26, f27, f28, f29, f30, f31, + d32, d34, d36, d38, d40, d42, d44, d46, + d48, d50, d52, d54, d56, d58, d60, d62 }; // @formatter:on } diff -r f8e60d11c0ec -r 4feac7e51f42 graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCControlFlow.java --- a/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCControlFlow.java Mon Aug 25 21:15:59 2014 -0700 +++ b/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCControlFlow.java Thu Aug 28 15:43:44 2014 -0700 @@ -68,6 +68,7 @@ protected final LabelRef trueDestination; protected final LabelRef falseDestination; protected final Kind kind; + protected final boolean unorderedIsTrue; public BranchOp(ConditionFlag condition, LabelRef trueDestination, LabelRef falseDestination, Kind kind) { this.conditionFlag = condition; @@ -75,6 +76,7 @@ this.falseDestination = falseDestination; this.kind = kind; this.condition = null; + this.unorderedIsTrue = true; } public BranchOp(Condition condition, LabelRef trueDestination, LabelRef falseDestination, Kind kind) { @@ -83,6 +85,16 @@ this.falseDestination = falseDestination; this.kind = kind; this.conditionFlag = null; + this.unorderedIsTrue = true; + } + + public BranchOp(Condition finalCondition, LabelRef trueDestination, LabelRef falseDestination, Kind kind, boolean unorderedIsTrue) { + this.trueDestination = trueDestination; + this.falseDestination = falseDestination; + this.kind = kind; + this.conditionFlag = null; + this.unorderedIsTrue = unorderedIsTrue; + this.condition = finalCondition; } @Override @@ -91,21 +103,24 @@ Label actualTarget; Condition actualCondition; ConditionFlag actualConditionFlag; + boolean branchOnUnordered; boolean needJump; if (crb.isSuccessorEdge(trueDestination)) { actualCondition = condition != null ? condition.negate() : null; actualConditionFlag = conditionFlag != null ? conditionFlag.negate() : null; actualTarget = falseDestination.label(); needJump = false; + branchOnUnordered = !unorderedIsTrue; } else { actualCondition = condition; actualConditionFlag = conditionFlag; actualTarget = trueDestination.label(); needJump = !crb.isSuccessorEdge(falseDestination); + branchOnUnordered = unorderedIsTrue; } assert kind == Kind.Int || kind == Kind.Long || kind == Kind.Object || kind == Kind.Double || kind == Kind.Float : kind; if (kind == Kind.Double || kind == Kind.Float) { - emitFloatCompare(masm, actualTarget, actualCondition); + emitFloatCompare(masm, actualTarget, actualCondition, branchOnUnordered); } else { CC cc = kind == Kind.Int ? CC.Icc : CC.Xcc; if (actualCondition != null) { @@ -123,7 +138,11 @@ } } - private static void emitFloatCompare(SPARCMacroAssembler masm, Label target, Condition actualCondition) { + private static void emitFloatCompare(SPARCMacroAssembler masm, Label target, Condition actualCondition, boolean branchOnUnordered) { + if (branchOnUnordered) { +// new Fbu(false, target).emit(masm); +// new Nop().emit(masm); + } switch (actualCondition) { case EQ: new Fbe(false, target).emit(masm); diff -r f8e60d11c0ec -r 4feac7e51f42 graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCMove.java --- a/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCMove.java Mon Aug 25 21:15:59 2014 -0700 +++ b/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCMove.java Thu Aug 28 15:43:44 2014 -0700 @@ -505,9 +505,11 @@ new Stx(src, dst).emit(masm); break; case Float: + // assert isSingleFloatRegister(src); new Stf(src, dst).emit(masm); break; case Double: + // assert isDoubleFloatRegister(src); new Stdf(src, dst).emit(masm); break; default: @@ -538,9 +540,11 @@ new Ldx(src, dst).emit(masm); break; case Float: +// assert isSingleFloatRegister(dst); new Ldf(src, dst).emit(masm); break; case Double: +// assert isDoubleFloatRegister(dst); new Lddf(src, dst).emit(masm); break; default: diff -r f8e60d11c0ec -r 4feac7e51f42 graal/com.oracle.graal.sparc/src/com/oracle/graal/sparc/SPARC.java --- a/graal/com.oracle.graal.sparc/src/com/oracle/graal/sparc/SPARC.java Mon Aug 25 21:15:59 2014 -0700 +++ b/graal/com.oracle.graal.sparc/src/com/oracle/graal/sparc/SPARC.java Thu Aug 28 15:43:44 2014 -0700 @@ -161,12 +161,32 @@ public static final Register f30 = new Register(62, 30, "f30", FPU); public static final Register f31 = new Register(63, 31, "f31", FPU); + public static final Register d32 = new Register(64, getDoubleEncoding(32), "d32", FPU); + public static final Register d34 = new Register(65, getDoubleEncoding(34), "d34", FPU); + public static final Register d36 = new Register(66, getDoubleEncoding(36), "d36", FPU); + public static final Register d38 = new Register(67, getDoubleEncoding(38), "d38", FPU); + public static final Register d40 = new Register(68, getDoubleEncoding(40), "d40", FPU); + public static final Register d42 = new Register(69, getDoubleEncoding(42), "d42", FPU); + public static final Register d44 = new Register(70, getDoubleEncoding(44), "d44", FPU); + public static final Register d46 = new Register(71, getDoubleEncoding(46), "d46", FPU); + + public static final Register d48 = new Register(72, getDoubleEncoding(48), "d48", FPU); + public static final Register d50 = new Register(73, getDoubleEncoding(50), "d50", FPU); + public static final Register d52 = new Register(74, getDoubleEncoding(52), "d52", FPU); + public static final Register d54 = new Register(75, getDoubleEncoding(54), "d54", FPU); + public static final Register d56 = new Register(76, getDoubleEncoding(56), "d56", FPU); + public static final Register d58 = new Register(77, getDoubleEncoding(58), "d58", FPU); + public static final Register d60 = new Register(78, getDoubleEncoding(60), "d60", FPU); + public static final Register d62 = new Register(79, getDoubleEncoding(62), "d62", FPU); + // @formatter:off public static final Register[] fpuRegisters = { f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, - f24, f25, f26, f27, f28, f29, f30, f31 + f24, f25, f26, f27, f28, f29, f30, f31, + d32, d34, d36, d38, d40, d42, d44, d46, + d48, d50, d52, d54, d56, d58, d60, d62 }; // @formatter:on @@ -181,7 +201,9 @@ f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, - f24, f25, f26, f27, f28, f29, f30, f31 + f24, f25, f26, f27, f28, f29, f30, f31, + d32, d34, d36, d38, d40, d42, d44, d46, + d48, d50, d52, d54, d56, d58, d60, d62 }; // @formatter:on @@ -246,4 +268,18 @@ public static int spillSlotSize(TargetDescription td, PlatformKind kind) { return Math.max(td.getSizeInBytes(kind), MEMORY_ACCESS_ALIGN); } + + public static int getDoubleEncoding(int reg) { + assert reg < 64 && ((reg & 1) == 0); + // ignore v8 assertion for now + return (reg & 0x1e) | ((reg & 0x20) >> 5); + } + + public static boolean isSingleFloatRegister(Register r) { + return r.name.startsWith("f"); + } + + public static boolean isDoubleFloatRegister(Register r) { + return r.name.startsWith("d"); + } }