Mercurial > hg > graal-compiler
changeset 22928:de89e36eaec6
Remove unnecessary specialization in AMD64HotSpotLIRGenerator.
| author | Roland Schatz <roland.schatz@oracle.com> |
|---|---|
| date | Mon, 02 Nov 2015 17:52:27 +0100 |
| parents | 526b102d5a20 |
| children | 098c285cc3b8 |
| files | graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64LIRGenerator.java graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotBinaryConsumer.java graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotLIRGenerator.java graal/com.oracle.graal.lir.amd64/src/com/oracle/graal/lir/amd64/AMD64BinaryConsumer.java |
| diffstat | 4 files changed, 113 insertions(+), 184 deletions(-) [+] |
line wrap: on
line diff
--- a/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64LIRGenerator.java Mon Nov 02 15:55:00 2015 +0100 +++ b/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64LIRGenerator.java Mon Nov 02 17:52:27 2015 +0100 @@ -41,6 +41,7 @@ import static com.oracle.graal.asm.amd64.AMD64Assembler.OperandSize.WORD; import static com.oracle.graal.lir.LIRValueUtil.asConstantValue; import static com.oracle.graal.lir.LIRValueUtil.asJavaConstant; +import static com.oracle.graal.lir.LIRValueUtil.isConstantValue; import static com.oracle.graal.lir.LIRValueUtil.isJavaConstant; import static jdk.vm.ci.code.ValueUtil.isAllocatableValue; import jdk.vm.ci.amd64.AMD64; @@ -49,10 +50,12 @@ import jdk.vm.ci.code.RegisterValue; import jdk.vm.ci.common.JVMCIError; import jdk.vm.ci.meta.AllocatableValue; +import jdk.vm.ci.meta.Constant; import jdk.vm.ci.meta.JavaConstant; import jdk.vm.ci.meta.JavaKind; import jdk.vm.ci.meta.LIRKind; import jdk.vm.ci.meta.PlatformKind; +import jdk.vm.ci.meta.VMConstant; import jdk.vm.ci.meta.Value; import com.oracle.graal.asm.NumUtil; @@ -62,6 +65,7 @@ import com.oracle.graal.asm.amd64.AMD64Assembler.ConditionFlag; import com.oracle.graal.asm.amd64.AMD64Assembler.OperandSize; import com.oracle.graal.asm.amd64.AMD64Assembler.SSEOp; +import com.oracle.graal.compiler.common.GraalOptions; import com.oracle.graal.compiler.common.calc.Condition; import com.oracle.graal.compiler.common.spi.ForeignCallLinkage; import com.oracle.graal.compiler.common.spi.LIRKindTool; @@ -217,12 +221,26 @@ } protected void emitStoreConst(AMD64Kind kind, AMD64AddressValue address, ConstantValue value, LIRFrameState state) { - JavaConstant c = value.getJavaConstant(); - if (c.isNull()) { + Constant c = value.getConstant(); + if (JavaConstant.isNull(c)) { assert kind == AMD64Kind.DWORD || kind == AMD64Kind.QWORD; OperandSize size = kind == AMD64Kind.DWORD ? DWORD : QWORD; append(new AMD64BinaryConsumer.MemoryConstOp(AMD64MIOp.MOV, size, address, 0, state)); + return; + } else if (c instanceof VMConstant) { + // only 32-bit constants can be patched + if (kind == AMD64Kind.DWORD) { + if (target().inlineObjects || !(c instanceof JavaConstant)) { + // if c is a JavaConstant, it's an oop, otherwise it's a metaspace constant + assert !(c instanceof JavaConstant) || ((JavaConstant) c).getJavaKind() == JavaKind.Object; + append(new AMD64BinaryConsumer.MemoryVMConstOp(AMD64MIOp.MOV, address, (VMConstant) c, state)); + return; + } + } } else { + JavaConstant jc = (JavaConstant) c; + assert jc.getJavaKind().isPrimitive(); + AMD64MIOp op = AMD64MIOp.MOV; OperandSize size; long imm; @@ -231,27 +249,27 @@ case BYTE: op = AMD64MIOp.MOVB; size = BYTE; - imm = c.asInt(); + imm = jc.asInt(); break; case WORD: size = WORD; - imm = c.asInt(); + imm = jc.asInt(); break; case DWORD: size = DWORD; - imm = c.asInt(); + imm = jc.asInt(); break; case QWORD: size = QWORD; - imm = c.asLong(); + imm = jc.asLong(); break; case SINGLE: size = DWORD; - imm = Float.floatToRawIntBits(c.asFloat()); + imm = Float.floatToRawIntBits(jc.asFloat()); break; case DOUBLE: size = QWORD; - imm = Double.doubleToRawLongBits(c.asDouble()); + imm = Double.doubleToRawLongBits(jc.asDouble()); break; default: throw JVMCIError.shouldNotReachHere("unexpected kind " + kind); @@ -259,10 +277,12 @@ if (NumUtil.isInt(imm)) { append(new AMD64BinaryConsumer.MemoryConstOp(op, size, address, (int) imm, state)); - } else { - emitStore(kind, address, asAllocatable(value), state); + return; } } + + // fallback: load, then store + emitStore(kind, address, asAllocatable(value), state); } protected void emitStore(AMD64Kind kind, AMD64AddressValue address, AllocatableValue value, LIRFrameState state) { @@ -294,7 +314,7 @@ public void emitStore(LIRKind lirKind, Value address, Value input, LIRFrameState state) { AMD64AddressValue storeAddress = asAddressValue(address); AMD64Kind kind = (AMD64Kind) lirKind.getPlatformKind(); - if (isJavaConstant(input)) { + if (isConstantValue(input)) { emitStoreConst(kind, storeAddress, asConstantValue(input), state); } else { emitStore(kind, storeAddress, asAllocatable(input), state); @@ -441,20 +461,36 @@ throw JVMCIError.shouldNotReachHere("unexpected kind: " + cmpKind); } - if (isJavaConstant(right)) { - JavaConstant c = asJavaConstant(right); - if (c.isDefaultForKind()) { - AMD64RMOp op = size == BYTE ? TESTB : TEST; - append(new AMD64BinaryConsumer.Op(op, size, left, left)); + if (isConstantValue(right)) { + Constant c = LIRValueUtil.asConstant(right); + if (JavaConstant.isNull(c)) { + append(new AMD64BinaryConsumer.Op(TEST, DWORD, left, left)); return; - } else if (NumUtil.is32bit(c.asLong())) { - append(new AMD64BinaryConsumer.ConstOp(CMP, size, left, (int) c.asLong())); + } else if (c instanceof VMConstant) { + VMConstant vc = (VMConstant) c; + boolean isImmutable = GraalOptions.ImmutableCode.getValue(); + boolean generatePIC = GraalOptions.GeneratePIC.getValue(); + if (size == DWORD && !(isImmutable && generatePIC)) { + append(new AMD64BinaryConsumer.VMConstOp(CMP.getMIOpcode(DWORD, false), left, vc)); + } else { + append(new AMD64BinaryConsumer.DataOp(CMP.getRMOpcode(size), size, left, vc)); + } return; + } else if (c instanceof JavaConstant) { + JavaConstant jc = (JavaConstant) c; + if (jc.isDefaultForKind()) { + AMD64RMOp op = size == BYTE ? TESTB : TEST; + append(new AMD64BinaryConsumer.Op(op, size, left, left)); + return; + } else if (NumUtil.is32bit(jc.asLong())) { + append(new AMD64BinaryConsumer.ConstOp(CMP, size, left, (int) jc.asLong())); + return; + } } } - AMD64RMOp op = CMP.getRMOpcode(size); - append(new AMD64BinaryConsumer.Op(op, size, left, asAllocatable(right))); + // fallback: load, then compare + append(new AMD64BinaryConsumer.Op(CMP.getRMOpcode(size), size, left, asAllocatable(right))); } /** @@ -497,12 +533,21 @@ } protected boolean emitCompareMemoryConOp(OperandSize size, ConstantValue a, AMD64AddressValue b, LIRFrameState state) { - long value = a.getJavaConstant().asLong(); - if (NumUtil.is32bit(value)) { - append(new AMD64BinaryConsumer.MemoryConstOp(CMP, size, b, (int) value, state)); + if (JavaConstant.isNull(a.getConstant())) { + append(new AMD64BinaryConsumer.MemoryConstOp(CMP, size, b, 0, state)); + return true; + } else if (a.getConstant() instanceof VMConstant && size == DWORD) { + VMConstant vc = (VMConstant) a.getConstant(); + append(new AMD64BinaryConsumer.MemoryVMConstOp(CMP.getMIOpcode(size, false), b, vc, state)); return true; } else { - return emitCompareRegMemoryOp(size, asAllocatable(a), b, state); + long value = a.getJavaConstant().asLong(); + if (NumUtil.is32bit(value)) { + append(new AMD64BinaryConsumer.MemoryConstOp(CMP, size, b, (int) value, state)); + return true; + } else { + return emitCompareRegMemoryOp(size, asAllocatable(a), b, state); + } } }
--- a/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotBinaryConsumer.java Mon Nov 02 15:55:00 2015 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,85 +0,0 @@ -/* - * Copyright (c) 2015, 2015, 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 com.oracle.graal.hotspot.amd64; - -import static com.oracle.graal.asm.amd64.AMD64Assembler.OperandSize.DWORD; -import jdk.vm.ci.hotspot.HotSpotConstant; -import jdk.vm.ci.hotspot.HotSpotObjectConstant; -import jdk.vm.ci.meta.AllocatableValue; - -import com.oracle.graal.asm.amd64.AMD64Assembler.AMD64MIOp; -import com.oracle.graal.asm.amd64.AMD64MacroAssembler; -import com.oracle.graal.lir.LIRFrameState; -import com.oracle.graal.lir.LIRInstructionClass; -import com.oracle.graal.lir.amd64.AMD64AddressValue; -import com.oracle.graal.lir.amd64.AMD64BinaryConsumer; -import com.oracle.graal.lir.asm.CompilationResultBuilder; - -public class AMD64HotSpotBinaryConsumer { - - /** - * Instruction that has one {@link AllocatableValue} operand and one {@link HotSpotConstant} - * operand. - */ - public static class ConstOp extends AMD64BinaryConsumer.ConstOp { - public static final LIRInstructionClass<ConstOp> TYPE = LIRInstructionClass.create(ConstOp.class); - - protected final HotSpotConstant c; - - public ConstOp(AMD64MIOp opcode, AllocatableValue x, HotSpotConstant c) { - super(TYPE, opcode, DWORD, x, 0xDEADDEAD); - this.c = c; - assert c.isCompressed(); - } - - @Override - public void emitCode(CompilationResultBuilder crb, AMD64MacroAssembler masm) { - assert crb.target.inlineObjects || !(c instanceof HotSpotObjectConstant); - crb.recordInlineDataInCode(c); - super.emitCode(crb, masm); - } - } - - /** - * Instruction that has one {@link AMD64AddressValue memory} operand and one - * {@link HotSpotConstant} operand. - */ - public static class MemoryConstOp extends AMD64BinaryConsumer.MemoryConstOp { - public static final LIRInstructionClass<MemoryConstOp> TYPE = LIRInstructionClass.create(MemoryConstOp.class); - - protected final HotSpotConstant c; - - public MemoryConstOp(AMD64MIOp opcode, AMD64AddressValue x, HotSpotConstant c, LIRFrameState state) { - super(TYPE, opcode, DWORD, x, 0xDEADDEAD, state); - this.c = c; - assert c.isCompressed(); - } - - @Override - public void emitCode(CompilationResultBuilder crb, AMD64MacroAssembler masm) { - assert crb.target.inlineObjects || !(c instanceof HotSpotObjectConstant); - crb.recordInlineDataInCode(c); - super.emitCode(crb, masm); - } - } -}
--- a/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotLIRGenerator.java Mon Nov 02 15:55:00 2015 +0100 +++ b/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotLIRGenerator.java Mon Nov 02 17:52:27 2015 +0100 @@ -22,14 +22,8 @@ */ package com.oracle.graal.hotspot.amd64; -import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64BinaryArithmetic.CMP; -import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64RMOp.TEST; -import static com.oracle.graal.asm.amd64.AMD64Assembler.OperandSize.DWORD; -import static com.oracle.graal.asm.amd64.AMD64Assembler.OperandSize.QWORD; import static com.oracle.graal.hotspot.HotSpotBackend.FETCH_UNROLL_INFO; import static com.oracle.graal.hotspot.HotSpotBackend.UNCOMMON_TRAP; -import static com.oracle.graal.lir.LIRValueUtil.asConstant; -import static com.oracle.graal.lir.LIRValueUtil.isConstantValue; import static jdk.vm.ci.amd64.AMD64.rbp; import java.util.ArrayList; @@ -44,13 +38,9 @@ import jdk.vm.ci.code.RegisterValue; import jdk.vm.ci.code.StackSlot; import jdk.vm.ci.common.JVMCIError; -import jdk.vm.ci.hotspot.HotSpotCompressedNullConstant; -import jdk.vm.ci.hotspot.HotSpotConstant; -import jdk.vm.ci.hotspot.HotSpotObjectConstant; import jdk.vm.ci.hotspot.HotSpotVMConfig; import jdk.vm.ci.hotspot.HotSpotVMConfig.CompressEncoding; import jdk.vm.ci.meta.AllocatableValue; -import jdk.vm.ci.meta.Constant; import jdk.vm.ci.meta.DeoptimizationAction; import jdk.vm.ci.meta.DeoptimizationReason; import jdk.vm.ci.meta.JavaConstant; @@ -61,12 +51,9 @@ import jdk.vm.ci.meta.Value; import com.oracle.graal.asm.amd64.AMD64Address.Scale; -import com.oracle.graal.asm.amd64.AMD64Assembler.AMD64MIOp; -import com.oracle.graal.asm.amd64.AMD64Assembler.OperandSize; import com.oracle.graal.compiler.amd64.AMD64ArithmeticLIRGenerator; import com.oracle.graal.compiler.amd64.AMD64LIRGenerator; import com.oracle.graal.compiler.amd64.AMD64MoveFactoryBase.BackupSlotProvider; -import com.oracle.graal.compiler.common.GraalOptions; import com.oracle.graal.compiler.common.spi.ForeignCallLinkage; import com.oracle.graal.compiler.common.spi.LIRKindTool; import com.oracle.graal.debug.Debug; @@ -77,7 +64,6 @@ import com.oracle.graal.hotspot.debug.BenchmarkCounters; import com.oracle.graal.hotspot.meta.HotSpotProviders; import com.oracle.graal.hotspot.stubs.Stub; -import com.oracle.graal.lir.ConstantValue; import com.oracle.graal.lir.LIR; import com.oracle.graal.lir.LIRFrameState; import com.oracle.graal.lir.LIRInstruction; @@ -89,7 +75,6 @@ import com.oracle.graal.lir.Variable; import com.oracle.graal.lir.VirtualStackSlot; import com.oracle.graal.lir.amd64.AMD64AddressValue; -import com.oracle.graal.lir.amd64.AMD64BinaryConsumer; import com.oracle.graal.lir.amd64.AMD64CCall; import com.oracle.graal.lir.amd64.AMD64ControlFlow.StrategySwitchOp; import com.oracle.graal.lir.amd64.AMD64FrameMapBuilder; @@ -565,26 +550,6 @@ } @Override - protected void emitStoreConst(AMD64Kind kind, AMD64AddressValue address, ConstantValue value, LIRFrameState state) { - Constant c = value.getConstant(); - if (c instanceof HotSpotConstant && !JavaConstant.isNull(c)) { - HotSpotConstant hc = (HotSpotConstant) c; - if (hc.isCompressed()) { - assert kind == AMD64Kind.DWORD; - if (!target().inlineObjects && hc instanceof HotSpotObjectConstant) { - emitStore(kind, address, asAllocatable(value), state); - } else { - append(new AMD64HotSpotBinaryConsumer.MemoryConstOp(AMD64MIOp.MOV, address, hc, state)); - } - } else { - emitStore(kind, address, asAllocatable(value), state); - } - } else { - super.emitStoreConst(kind, address, value, state); - } - } - - @Override public Value emitCompress(Value pointer, CompressEncoding encoding, boolean nonNull) { LIRKind inputKind = pointer.getLIRKind(); assert inputKind.getPlatformKind() == AMD64Kind.QWORD; @@ -644,46 +609,6 @@ } @Override - protected void emitCompareOp(PlatformKind cmpKind, Variable left, Value right) { - if (isConstantValue(right)) { - Constant c = asConstant(right); - if (HotSpotCompressedNullConstant.COMPRESSED_NULL.equals(c)) { - append(new AMD64BinaryConsumer.Op(TEST, DWORD, left, left)); - return; - } else if (c instanceof HotSpotConstant) { - HotSpotConstant hsc = (HotSpotConstant) c; - - boolean isImmutable = GraalOptions.ImmutableCode.getValue(); - boolean generatePIC = GraalOptions.GeneratePIC.getValue(); - if (hsc.isCompressed() && !(isImmutable && generatePIC)) { - append(new AMD64HotSpotBinaryConsumer.ConstOp(CMP.getMIOpcode(DWORD, false), left, hsc)); - } else { - OperandSize size = hsc.isCompressed() ? DWORD : QWORD; - append(new AMD64BinaryConsumer.DataOp(CMP.getRMOpcode(size), size, left, hsc)); - } - return; - } - } - - super.emitCompareOp(cmpKind, left, right); - } - - @Override - protected boolean emitCompareMemoryConOp(OperandSize size, ConstantValue a, AMD64AddressValue b, LIRFrameState state) { - if (JavaConstant.isNull(a.getConstant())) { - append(new AMD64BinaryConsumer.MemoryConstOp(CMP, size, b, 0, state)); - return true; - } else if (a.getConstant() instanceof HotSpotConstant && size == DWORD) { - HotSpotConstant hc = (HotSpotConstant) a.getConstant(); - assert hc.isCompressed(); - append(new AMD64HotSpotBinaryConsumer.MemoryConstOp(CMP.getMIOpcode(size, false), b, hc, state)); - return true; - } else { - return super.emitCompareMemoryConOp(size, a, b, state); - } - } - - @Override public LIRInstruction createBenchmarkCounter(String name, String group, Value increment) { if (BenchmarkCounters.enabled) { return new AMD64HotSpotCounterOp(name, group, increment, getProviders().getRegisters(), config, getOrInitRescueSlot());
--- a/graal/com.oracle.graal.lir.amd64/src/com/oracle/graal/lir/amd64/AMD64BinaryConsumer.java Mon Nov 02 15:55:00 2015 +0100 +++ b/graal/com.oracle.graal.lir.amd64/src/com/oracle/graal/lir/amd64/AMD64BinaryConsumer.java Mon Nov 02 17:52:27 2015 +0100 @@ -22,6 +22,7 @@ */ package com.oracle.graal.lir.amd64; +import static com.oracle.graal.asm.amd64.AMD64Assembler.OperandSize.DWORD; import static com.oracle.graal.lir.LIRInstruction.OperandFlag.COMPOSITE; import static com.oracle.graal.lir.LIRInstruction.OperandFlag.REG; import static com.oracle.graal.lir.LIRInstruction.OperandFlag.STACK; @@ -31,6 +32,7 @@ import jdk.vm.ci.code.CompilationResult.DataSectionReference; import jdk.vm.ci.meta.AllocatableValue; import jdk.vm.ci.meta.Constant; +import jdk.vm.ci.meta.VMConstant; import jdk.vm.ci.meta.Value; import com.oracle.graal.asm.NumUtil; @@ -125,6 +127,27 @@ } /** + * Instruction that has one {@link AllocatableValue} operand and one 32-bit immediate operand + * that needs to be patched at runtime. + */ + public static class VMConstOp extends ConstOp { + public static final LIRInstructionClass<VMConstOp> TYPE = LIRInstructionClass.create(VMConstOp.class); + + protected final VMConstant c; + + public VMConstOp(AMD64MIOp opcode, AllocatableValue x, VMConstant c) { + super(TYPE, opcode, DWORD, x, 0xDEADDEAD); + this.c = c; + } + + @Override + public void emitCode(CompilationResultBuilder crb, AMD64MacroAssembler masm) { + crb.recordInlineDataInCode(c); + super.emitCode(crb, masm); + } + } + + /** * Instruction that has one {@link AllocatableValue} operand and one * {@link DataSectionReference} operand. */ @@ -299,4 +322,25 @@ return false; } } + + /** + * Instruction that has one {@link AMD64AddressValue memory} operand and one 32-bit immediate + * operand that needs to be patched at runtime. + */ + public static class MemoryVMConstOp extends MemoryConstOp { + public static final LIRInstructionClass<MemoryVMConstOp> TYPE = LIRInstructionClass.create(MemoryVMConstOp.class); + + protected final VMConstant c; + + public MemoryVMConstOp(AMD64MIOp opcode, AMD64AddressValue x, VMConstant c, LIRFrameState state) { + super(TYPE, opcode, DWORD, x, 0xDEADDEAD, state); + this.c = c; + } + + @Override + public void emitCode(CompilationResultBuilder crb, AMD64MacroAssembler masm) { + crb.recordInlineDataInCode(c); + super.emitCode(crb, masm); + } + } }