Mercurial > hg > truffle
changeset 14888:f6630873316b
Rename NodeLIRGenerator (and related classes and interfaces) to NodeLIRBuilder.
line wrap: on
line diff
--- a/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64MemoryPeephole.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64MemoryPeephole.java Mon Mar 31 10:03:32 2014 +0200 @@ -45,10 +45,10 @@ import com.oracle.graal.nodes.type.*; public class AMD64MemoryPeephole implements MemoryArithmeticLIRLowerer { - protected final AMD64NodeLIRGenerator gen; + protected final AMD64NodeLIRBuilder gen; protected List<ValueNode> deferredNodes; - protected AMD64MemoryPeephole(AMD64NodeLIRGenerator gen) { + protected AMD64MemoryPeephole(AMD64NodeLIRBuilder gen) { this.gen = gen; }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64NodeLIRBuilder.java Mon Mar 31 10:03:32 2014 +0200 @@ -0,0 +1,113 @@ +/* + * Copyright (c) 2009, 2012, 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.compiler.amd64; + +import com.oracle.graal.amd64.*; +import com.oracle.graal.api.code.*; +import com.oracle.graal.api.meta.*; +import com.oracle.graal.compiler.gen.*; +import com.oracle.graal.lir.*; +import com.oracle.graal.lir.amd64.*; +import com.oracle.graal.nodes.*; +import com.oracle.graal.nodes.calc.*; +import com.oracle.graal.nodes.spi.*; + +public abstract class AMD64NodeLIRBuilder extends NodeLIRBuilder { + + public AMD64NodeLIRBuilder(StructuredGraph graph, LIRGenerationResult res, LIRGenerator gen) { + super(graph, res, gen); + } + + protected MemoryArithmeticLIRLowerer memoryPeephole; + + @Override + public MemoryArithmeticLIRLowerer getMemoryLowerer() { + if (memoryPeephole == null) { + // Use the generic one + memoryPeephole = new AMD64MemoryPeephole(this); + } + return memoryPeephole; + } + + @Override + protected void emitIndirectCall(IndirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) { + AllocatableValue targetAddress = AMD64.rax.asValue(); + gen.emitMove(targetAddress, operand(callTarget.computedAddress())); + append(new AMD64Call.IndirectCallOp(callTarget.target(), result, parameters, temps, targetAddress, callState)); + } + + @Override + public void emitNullCheck(ValueNode v, DeoptimizingNode deopt) { + assert v.getKind() == Kind.Object : v + " - " + v.stamp() + " @ " + deopt; + append(new AMD64Move.NullCheckOp(gen.load(operand(v)), gen.state(deopt))); + } + + @Override + protected boolean peephole(ValueNode valueNode) { + if ((valueNode instanceof IntegerDivNode) || (valueNode instanceof IntegerRemNode)) { + FixedBinaryNode divRem = (FixedBinaryNode) valueNode; + FixedNode node = divRem.next(); + while (node instanceof FixedWithNextNode) { + FixedWithNextNode fixedWithNextNode = (FixedWithNextNode) node; + if (((fixedWithNextNode instanceof IntegerDivNode) || (fixedWithNextNode instanceof IntegerRemNode)) && fixedWithNextNode.getClass() != divRem.getClass()) { + FixedBinaryNode otherDivRem = (FixedBinaryNode) fixedWithNextNode; + if (otherDivRem.x() == divRem.x() && otherDivRem.y() == divRem.y() && operand(otherDivRem) == null) { + Value[] results = ((AMD64LIRGenerator) gen).emitIntegerDivRem(operand(divRem.x()), operand(divRem.y()), (DeoptimizingNode) valueNode); + if (divRem instanceof IntegerDivNode) { + setResult(divRem, results[0]); + setResult(otherDivRem, results[1]); + } else { + setResult(divRem, results[1]); + setResult(otherDivRem, results[0]); + } + return true; + } + } + node = fixedWithNextNode.next(); + } + } + return false; + } + + @Override + public void visitBreakpointNode(BreakpointNode node) { + JavaType[] sig = new JavaType[node.arguments().size()]; + for (int i = 0; i < sig.length; i++) { + sig[i] = node.arguments().get(i).stamp().javaType(gen.getMetaAccess()); + } + + Value[] parameters = visitInvokeArguments(res.getFrameMap().registerConfig.getCallingConvention(CallingConvention.Type.JavaCall, null, sig, gen.target(), false), node.arguments()); + append(new AMD64BreakpointOp(parameters)); + } + + @Override + public void visitInfopointNode(InfopointNode i) { + append(new InfopointOp(gen.stateFor(i.getState()), i.reason)); + } + + @Override + public AMD64LIRGenerator getLIRGenerator() { + return (AMD64LIRGenerator) gen; + } +}
--- a/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64NodeLIRGenerator.java Fri Mar 28 14:28:27 2014 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,113 +0,0 @@ -/* - * Copyright (c) 2009, 2012, 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.compiler.amd64; - -import com.oracle.graal.amd64.*; -import com.oracle.graal.api.code.*; -import com.oracle.graal.api.meta.*; -import com.oracle.graal.compiler.gen.*; -import com.oracle.graal.lir.*; -import com.oracle.graal.lir.amd64.*; -import com.oracle.graal.nodes.*; -import com.oracle.graal.nodes.calc.*; -import com.oracle.graal.nodes.spi.*; - -public abstract class AMD64NodeLIRGenerator extends NodeLIRGenerator { - - public AMD64NodeLIRGenerator(StructuredGraph graph, LIRGenerationResult res, LIRGenerator gen) { - super(graph, res, gen); - } - - protected MemoryArithmeticLIRLowerer memoryPeephole; - - @Override - public MemoryArithmeticLIRLowerer getMemoryLowerer() { - if (memoryPeephole == null) { - // Use the generic one - memoryPeephole = new AMD64MemoryPeephole(this); - } - return memoryPeephole; - } - - @Override - protected void emitIndirectCall(IndirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) { - AllocatableValue targetAddress = AMD64.rax.asValue(); - gen.emitMove(targetAddress, operand(callTarget.computedAddress())); - append(new AMD64Call.IndirectCallOp(callTarget.target(), result, parameters, temps, targetAddress, callState)); - } - - @Override - public void emitNullCheck(ValueNode v, DeoptimizingNode deopt) { - assert v.getKind() == Kind.Object : v + " - " + v.stamp() + " @ " + deopt; - append(new AMD64Move.NullCheckOp(gen.load(operand(v)), gen.state(deopt))); - } - - @Override - protected boolean peephole(ValueNode valueNode) { - if ((valueNode instanceof IntegerDivNode) || (valueNode instanceof IntegerRemNode)) { - FixedBinaryNode divRem = (FixedBinaryNode) valueNode; - FixedNode node = divRem.next(); - while (node instanceof FixedWithNextNode) { - FixedWithNextNode fixedWithNextNode = (FixedWithNextNode) node; - if (((fixedWithNextNode instanceof IntegerDivNode) || (fixedWithNextNode instanceof IntegerRemNode)) && fixedWithNextNode.getClass() != divRem.getClass()) { - FixedBinaryNode otherDivRem = (FixedBinaryNode) fixedWithNextNode; - if (otherDivRem.x() == divRem.x() && otherDivRem.y() == divRem.y() && operand(otherDivRem) == null) { - Value[] results = ((AMD64LIRGenerator) gen).emitIntegerDivRem(operand(divRem.x()), operand(divRem.y()), (DeoptimizingNode) valueNode); - if (divRem instanceof IntegerDivNode) { - setResult(divRem, results[0]); - setResult(otherDivRem, results[1]); - } else { - setResult(divRem, results[1]); - setResult(otherDivRem, results[0]); - } - return true; - } - } - node = fixedWithNextNode.next(); - } - } - return false; - } - - @Override - public void visitBreakpointNode(BreakpointNode node) { - JavaType[] sig = new JavaType[node.arguments().size()]; - for (int i = 0; i < sig.length; i++) { - sig[i] = node.arguments().get(i).stamp().javaType(gen.getMetaAccess()); - } - - Value[] parameters = visitInvokeArguments(res.getFrameMap().registerConfig.getCallingConvention(CallingConvention.Type.JavaCall, null, sig, gen.target(), false), node.arguments()); - append(new AMD64BreakpointOp(parameters)); - } - - @Override - public void visitInfopointNode(InfopointNode i) { - append(new InfopointOp(gen.stateFor(i.getState()), i.reason)); - } - - @Override - public AMD64LIRGenerator getLIRGenerator() { - return (AMD64LIRGenerator) gen; - } -}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.compiler.hsail/src/com/oracle/graal/compiler/hsail/HSAILNodeLIRBuilder.java Mon Mar 31 10:03:32 2014 +0200 @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2013, 2014, 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.compiler.hsail; + +import com.oracle.graal.api.meta.*; +import com.oracle.graal.compiler.gen.*; +import com.oracle.graal.debug.*; +import com.oracle.graal.graph.*; +import com.oracle.graal.lir.*; +import com.oracle.graal.lir.hsail.*; +import com.oracle.graal.nodes.*; +import com.oracle.graal.nodes.type.*; + +/** + * This class implements the HSAIL specific portion of the LIR generator. + */ +public abstract class HSAILNodeLIRBuilder extends NodeLIRBuilder { + + public HSAILNodeLIRBuilder(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen) { + super(graph, lirGenRes, lirGen); + } + + @Override + protected boolean peephole(ValueNode valueNode) { + // No peephole optimizations for now. + return false; + } + + @Override + protected void emitDirectCall(DirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) { + throw GraalInternalError.unimplemented(); + } + + @Override + protected void emitIndirectCall(IndirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) { + throw GraalInternalError.unimplemented(); + } + + @Override + public void visitBreakpointNode(BreakpointNode node) { + throw GraalInternalError.unimplemented(); + } + + @Override + public void visitSafepointNode(SafepointNode i) { + Debug.log("visitSafePointNode unimplemented"); + } + + @Override + public void emitNullCheck(ValueNode v, DeoptimizingNode deopting) { + assert v.stamp() instanceof ObjectStamp; + Variable obj = newVariable(Kind.Object); + gen.emitMove(obj, operand(v)); + append(new HSAILMove.NullCheckOp(obj, gen.state(deopting))); + } + + @Override + public void visitInfopointNode(InfopointNode i) { + throw GraalInternalError.unimplemented(); + } +}
--- a/graal/com.oracle.graal.compiler.hsail/src/com/oracle/graal/compiler/hsail/HSAILNodeLIRGenerator.java Fri Mar 28 14:28:27 2014 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,82 +0,0 @@ -/* - * Copyright (c) 2013, 2014, 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.compiler.hsail; - -import com.oracle.graal.api.meta.*; -import com.oracle.graal.compiler.gen.*; -import com.oracle.graal.debug.*; -import com.oracle.graal.graph.*; -import com.oracle.graal.lir.*; -import com.oracle.graal.lir.hsail.*; -import com.oracle.graal.nodes.*; -import com.oracle.graal.nodes.type.*; - -/** - * This class implements the HSAIL specific portion of the LIR generator. - */ -public abstract class HSAILNodeLIRGenerator extends NodeLIRGenerator { - - public HSAILNodeLIRGenerator(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen) { - super(graph, lirGenRes, lirGen); - } - - @Override - protected boolean peephole(ValueNode valueNode) { - // No peephole optimizations for now. - return false; - } - - @Override - protected void emitDirectCall(DirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) { - throw GraalInternalError.unimplemented(); - } - - @Override - protected void emitIndirectCall(IndirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) { - throw GraalInternalError.unimplemented(); - } - - @Override - public void visitBreakpointNode(BreakpointNode node) { - throw GraalInternalError.unimplemented(); - } - - @Override - public void visitSafepointNode(SafepointNode i) { - Debug.log("visitSafePointNode unimplemented"); - } - - @Override - public void emitNullCheck(ValueNode v, DeoptimizingNode deopting) { - assert v.stamp() instanceof ObjectStamp; - Variable obj = newVariable(Kind.Object); - gen.emitMove(obj, operand(v)); - append(new HSAILMove.NullCheckOp(obj, gen.state(deopting))); - } - - @Override - public void visitInfopointNode(InfopointNode i) { - throw GraalInternalError.unimplemented(); - } -}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.compiler.ptx/src/com/oracle/graal/compiler/ptx/PTXNodeLIRBuilder.java Mon Mar 31 10:03:32 2014 +0200 @@ -0,0 +1,208 @@ +/* + * Copyright (c) 2013, 2014, 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.compiler.ptx; + +import java.lang.reflect.*; + +import com.oracle.graal.api.code.*; +import com.oracle.graal.api.meta.*; +import com.oracle.graal.compiler.gen.*; +import com.oracle.graal.debug.*; +import com.oracle.graal.graph.*; +import com.oracle.graal.lir.*; +import com.oracle.graal.lir.ptx.*; +import com.oracle.graal.nodes.*; +import com.oracle.graal.nodes.cfg.*; +import com.oracle.graal.nodes.java.*; + +/** + * This class implements the PTX specific portion of the LIR generator. + */ +public class PTXNodeLIRBuilder extends NodeLIRBuilder { + + // Number of the predicate register that can be used when needed. + // This value will be recorded and incremented in the LIR instruction + // that sets a predicate register. (e.g., CompareOp) + private int nextPredRegNum; + + public static final ForeignCallDescriptor ARITHMETIC_FREM = new ForeignCallDescriptor("arithmeticFrem", float.class, float.class, float.class); + public static final ForeignCallDescriptor ARITHMETIC_DREM = new ForeignCallDescriptor("arithmeticDrem", double.class, double.class, double.class); + + public static class PTXSpillMoveFactory implements LIR.SpillMoveFactory { + + @Override + public LIRInstruction createMove(AllocatableValue result, Value input) { + throw GraalInternalError.unimplemented("PTXSpillMoveFactory.createMove()"); + } + } + + public PTXNodeLIRBuilder(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen) { + super(graph, lirGenRes, lirGen); + } + + public int getNextPredRegNumber() { + return nextPredRegNum; + } + + @Override + public void emitPrologue(StructuredGraph graph) { + // Need to emit .param directives based on incoming arguments and return value + CallingConvention incomingArguments = gen.getCallingConvention(); + Object returnObject = incomingArguments.getReturn(); + AllocatableValue[] params = incomingArguments.getArguments(); + int argCount = incomingArguments.getArgumentCount(); + + if (returnObject.equals(Value.ILLEGAL)) { + params = incomingArguments.getArguments(); + append(new PTXParameterOp(params, false)); + } else { + argCount = incomingArguments.getArgumentCount(); + params = new Variable[argCount + 1]; + for (int i = 0; i < argCount; i++) { + params[i] = incomingArguments.getArgument(i); + } + params[argCount] = (Variable) returnObject; + append(new PTXParameterOp(params, true)); + } + + for (ParameterNode param : graph.getNodes(ParameterNode.class)) { + int localIndex = param.index(); + Value paramValue = params[param.index()]; + int parameterIndex = localIndex; + if (!Modifier.isStatic(graph.method().getModifiers())) { + parameterIndex--; + } + Warp warpAnnotation = parameterIndex >= 0 ? MetaUtil.getParameterAnnotation(Warp.class, parameterIndex, graph.method()) : null; + if (warpAnnotation != null) { + setResult(param, getGen().emitWarpParam(paramValue.getKind().getStackKind(), warpAnnotation)); + } else { + setResult(param, getGen().emitLoadParam(paramValue.getKind().getStackKind(), paramValue, null)); + } + } + } + + private PTXLIRGenerator getGen() { + return (PTXLIRGenerator) gen; + } + + @Override + protected <T extends AbstractBlock<T>> void emitPrologue(ResolvedJavaMethod method, BytecodeParser<T> parser) { + // Need to emit .param directives based on incoming arguments and return value + CallingConvention incomingArguments = gen.getCallingConvention(); + Object returnObject = incomingArguments.getReturn(); + AllocatableValue[] params = incomingArguments.getArguments(); + int argCount = incomingArguments.getArgumentCount(); + + if (returnObject.equals(Value.ILLEGAL)) { + params = incomingArguments.getArguments(); + append(new PTXParameterOp(params, false)); + } else { + argCount = incomingArguments.getArgumentCount(); + params = new Variable[argCount + 1]; + for (int i = 0; i < argCount; i++) { + params[i] = incomingArguments.getArgument(i); + } + params[argCount] = (Variable) returnObject; + append(new PTXParameterOp(params, true)); + } + + Signature sig = method.getSignature(); + boolean isStatic = Modifier.isStatic(method.getModifiers()); + + for (int i = 0; i < sig.getParameterCount(!isStatic); i++) { + Value paramValue = params[i]; + int parameterIndex = i; + if (!isStatic) { + parameterIndex--; + } + Warp warpAnnotation = parameterIndex >= 0 ? MetaUtil.getParameterAnnotation(Warp.class, parameterIndex, method) : null; + if (warpAnnotation != null) { + // setResult(param, emitWarpParam(paramValue.getKind().getStackKind(), + // warpAnnotation)); + parser.setParameter(i, getGen().emitWarpParam(paramValue.getKind().getStackKind(), warpAnnotation)); + } else { + // setResult(param, emitLoadParam(paramValue.getKind().getStackKind(), paramValue, + // null)); + parser.setParameter(i, getGen().emitLoadParam(paramValue.getKind().getStackKind(), paramValue, null)); + } + } + } + + @Override + protected boolean peephole(ValueNode valueNode) { + // No peephole optimizations for now + return false; + } + + @Override + protected void emitDirectCall(DirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) { + throw GraalInternalError.unimplemented("PTXLIRGenerator.emitDirectCall()"); + } + + @Override + protected void emitIndirectCall(IndirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) { + throw GraalInternalError.unimplemented("PTXLIRGenerator.emitIndirectCall()"); + } + + @Override + public void visitCompareAndSwap(LoweredCompareAndSwapNode node, Value address) { + throw GraalInternalError.unimplemented("PTXLIRGenerator.visitCompareAndSwap()"); + } + + @Override + public void visitBreakpointNode(BreakpointNode node) { + throw GraalInternalError.unimplemented("PTXLIRGenerator.visitBreakpointNode()"); + } + + @Override + public void visitSafepointNode(SafepointNode i) { + // LIRFrameState info = state(i); + // append(new PTXSafepointOp(info, runtime().config, this)); + Debug.log("visitSafePointNode unimplemented"); + } + + @Override + public void emitNullCheck(ValueNode v, DeoptimizingNode deopting) { + assert v.getKind() == Kind.Object; + append(new PTXMove.NullCheckOp(gen.load(operand(v)), gen.state(deopting))); + } + + @Override + public void visitInfopointNode(InfopointNode i) { + throw GraalInternalError.unimplemented("PTXLIRGenerator.visitInfopointNode()"); + } + + @Override + public void visitReturn(ReturnNode x) { + AllocatableValue operand = Value.ILLEGAL; + if (x.result() != null) { + operand = gen.resultOperandFor(x.result().getKind()); + // Load the global memory address from return parameter + Variable loadVar = getGen().emitLoadReturnAddress(operand.getKind(), operand, null); + // Store result in global memory whose location is loadVar + getGen().emitStoreReturnValue(operand.getKind(), loadVar, operand(x.result()), null); + } + getGen().emitReturnNoVal(); + } +}
--- a/graal/com.oracle.graal.compiler.ptx/src/com/oracle/graal/compiler/ptx/PTXNodeLIRGenerator.java Fri Mar 28 14:28:27 2014 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,208 +0,0 @@ -/* - * Copyright (c) 2013, 2014, 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.compiler.ptx; - -import java.lang.reflect.*; - -import com.oracle.graal.api.code.*; -import com.oracle.graal.api.meta.*; -import com.oracle.graal.compiler.gen.*; -import com.oracle.graal.debug.*; -import com.oracle.graal.graph.*; -import com.oracle.graal.lir.*; -import com.oracle.graal.lir.ptx.*; -import com.oracle.graal.nodes.*; -import com.oracle.graal.nodes.cfg.*; -import com.oracle.graal.nodes.java.*; - -/** - * This class implements the PTX specific portion of the LIR generator. - */ -public class PTXNodeLIRGenerator extends NodeLIRGenerator { - - // Number of the predicate register that can be used when needed. - // This value will be recorded and incremented in the LIR instruction - // that sets a predicate register. (e.g., CompareOp) - private int nextPredRegNum; - - public static final ForeignCallDescriptor ARITHMETIC_FREM = new ForeignCallDescriptor("arithmeticFrem", float.class, float.class, float.class); - public static final ForeignCallDescriptor ARITHMETIC_DREM = new ForeignCallDescriptor("arithmeticDrem", double.class, double.class, double.class); - - public static class PTXSpillMoveFactory implements LIR.SpillMoveFactory { - - @Override - public LIRInstruction createMove(AllocatableValue result, Value input) { - throw GraalInternalError.unimplemented("PTXSpillMoveFactory.createMove()"); - } - } - - public PTXNodeLIRGenerator(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen) { - super(graph, lirGenRes, lirGen); - } - - public int getNextPredRegNumber() { - return nextPredRegNum; - } - - @Override - public void emitPrologue(StructuredGraph graph) { - // Need to emit .param directives based on incoming arguments and return value - CallingConvention incomingArguments = gen.getCallingConvention(); - Object returnObject = incomingArguments.getReturn(); - AllocatableValue[] params = incomingArguments.getArguments(); - int argCount = incomingArguments.getArgumentCount(); - - if (returnObject.equals(Value.ILLEGAL)) { - params = incomingArguments.getArguments(); - append(new PTXParameterOp(params, false)); - } else { - argCount = incomingArguments.getArgumentCount(); - params = new Variable[argCount + 1]; - for (int i = 0; i < argCount; i++) { - params[i] = incomingArguments.getArgument(i); - } - params[argCount] = (Variable) returnObject; - append(new PTXParameterOp(params, true)); - } - - for (ParameterNode param : graph.getNodes(ParameterNode.class)) { - int localIndex = param.index(); - Value paramValue = params[param.index()]; - int parameterIndex = localIndex; - if (!Modifier.isStatic(graph.method().getModifiers())) { - parameterIndex--; - } - Warp warpAnnotation = parameterIndex >= 0 ? MetaUtil.getParameterAnnotation(Warp.class, parameterIndex, graph.method()) : null; - if (warpAnnotation != null) { - setResult(param, getGen().emitWarpParam(paramValue.getKind().getStackKind(), warpAnnotation)); - } else { - setResult(param, getGen().emitLoadParam(paramValue.getKind().getStackKind(), paramValue, null)); - } - } - } - - private PTXLIRGenerator getGen() { - return (PTXLIRGenerator) gen; - } - - @Override - protected <T extends AbstractBlock<T>> void emitPrologue(ResolvedJavaMethod method, BytecodeParser<T> parser) { - // Need to emit .param directives based on incoming arguments and return value - CallingConvention incomingArguments = gen.getCallingConvention(); - Object returnObject = incomingArguments.getReturn(); - AllocatableValue[] params = incomingArguments.getArguments(); - int argCount = incomingArguments.getArgumentCount(); - - if (returnObject.equals(Value.ILLEGAL)) { - params = incomingArguments.getArguments(); - append(new PTXParameterOp(params, false)); - } else { - argCount = incomingArguments.getArgumentCount(); - params = new Variable[argCount + 1]; - for (int i = 0; i < argCount; i++) { - params[i] = incomingArguments.getArgument(i); - } - params[argCount] = (Variable) returnObject; - append(new PTXParameterOp(params, true)); - } - - Signature sig = method.getSignature(); - boolean isStatic = Modifier.isStatic(method.getModifiers()); - - for (int i = 0; i < sig.getParameterCount(!isStatic); i++) { - Value paramValue = params[i]; - int parameterIndex = i; - if (!isStatic) { - parameterIndex--; - } - Warp warpAnnotation = parameterIndex >= 0 ? MetaUtil.getParameterAnnotation(Warp.class, parameterIndex, method) : null; - if (warpAnnotation != null) { - // setResult(param, emitWarpParam(paramValue.getKind().getStackKind(), - // warpAnnotation)); - parser.setParameter(i, getGen().emitWarpParam(paramValue.getKind().getStackKind(), warpAnnotation)); - } else { - // setResult(param, emitLoadParam(paramValue.getKind().getStackKind(), paramValue, - // null)); - parser.setParameter(i, getGen().emitLoadParam(paramValue.getKind().getStackKind(), paramValue, null)); - } - } - } - - @Override - protected boolean peephole(ValueNode valueNode) { - // No peephole optimizations for now - return false; - } - - @Override - protected void emitDirectCall(DirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) { - throw GraalInternalError.unimplemented("PTXLIRGenerator.emitDirectCall()"); - } - - @Override - protected void emitIndirectCall(IndirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) { - throw GraalInternalError.unimplemented("PTXLIRGenerator.emitIndirectCall()"); - } - - @Override - public void visitCompareAndSwap(LoweredCompareAndSwapNode node, Value address) { - throw GraalInternalError.unimplemented("PTXLIRGenerator.visitCompareAndSwap()"); - } - - @Override - public void visitBreakpointNode(BreakpointNode node) { - throw GraalInternalError.unimplemented("PTXLIRGenerator.visitBreakpointNode()"); - } - - @Override - public void visitSafepointNode(SafepointNode i) { - // LIRFrameState info = state(i); - // append(new PTXSafepointOp(info, runtime().config, this)); - Debug.log("visitSafePointNode unimplemented"); - } - - @Override - public void emitNullCheck(ValueNode v, DeoptimizingNode deopting) { - assert v.getKind() == Kind.Object; - append(new PTXMove.NullCheckOp(gen.load(operand(v)), gen.state(deopting))); - } - - @Override - public void visitInfopointNode(InfopointNode i) { - throw GraalInternalError.unimplemented("PTXLIRGenerator.visitInfopointNode()"); - } - - @Override - public void visitReturn(ReturnNode x) { - AllocatableValue operand = Value.ILLEGAL; - if (x.result() != null) { - operand = gen.resultOperandFor(x.result().getKind()); - // Load the global memory address from return parameter - Variable loadVar = getGen().emitLoadReturnAddress(operand.getKind(), operand, null); - // Store result in global memory whose location is loadVar - getGen().emitStoreReturnValue(operand.getKind(), loadVar, operand(x.result()), null); - } - getGen().emitReturnNoVal(); - } -}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCNodeLIRBuilder.java Mon Mar 31 10:03:32 2014 +0200 @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2009, 2014, 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.compiler.sparc; + +import com.oracle.graal.api.code.*; +import com.oracle.graal.api.meta.*; +import com.oracle.graal.compiler.gen.*; +import com.oracle.graal.lir.sparc.*; +import com.oracle.graal.lir.sparc.SPARCMove.NullCheckOp; +import com.oracle.graal.nodes.*; +import com.oracle.graal.nodes.java.*; + +/** + * This class implements the SPARC specific portion of the LIR generator. + */ +public abstract class SPARCNodeLIRBuilder extends NodeLIRBuilder { + + public SPARCNodeLIRBuilder(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen) { + super(graph, lirGenRes, lirGen); + } + + @Override + protected boolean peephole(ValueNode valueNode) { + // No peephole optimizations for now + return false; + } + + @Override + public void visitCompareAndSwap(LoweredCompareAndSwapNode i, Value address) { + throw new InternalError("NYI"); + } + + @Override + public void visitBreakpointNode(BreakpointNode node) { + JavaType[] sig = new JavaType[node.arguments().size()]; + for (int i = 0; i < sig.length; i++) { + sig[i] = node.arguments().get(i).stamp().javaType(gen.getMetaAccess()); + } + + Value[] parameters = visitInvokeArguments(res.getFrameMap().registerConfig.getCallingConvention(CallingConvention.Type.JavaCall, null, sig, gen.target(), false), node.arguments()); + append(new SPARCBreakpointOp(parameters)); + } + + @Override + public void emitNullCheck(ValueNode v, DeoptimizingNode deopting) { + assert v.getKind() == Kind.Object; + append(new NullCheckOp(gen.load(operand(v)), gen.state(deopting))); + } + + @Override + public void visitInfopointNode(InfopointNode i) { + throw new InternalError("NYI"); + } +}
--- a/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCNodeLIRGenerator.java Fri Mar 28 14:28:27 2014 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,75 +0,0 @@ -/* - * Copyright (c) 2009, 2014, 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.compiler.sparc; - -import com.oracle.graal.api.code.*; -import com.oracle.graal.api.meta.*; -import com.oracle.graal.compiler.gen.*; -import com.oracle.graal.lir.sparc.*; -import com.oracle.graal.lir.sparc.SPARCMove.NullCheckOp; -import com.oracle.graal.nodes.*; -import com.oracle.graal.nodes.java.*; - -/** - * This class implements the SPARC specific portion of the LIR generator. - */ -public abstract class SPARCNodeLIRGenerator extends NodeLIRGenerator { - - public SPARCNodeLIRGenerator(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen) { - super(graph, lirGenRes, lirGen); - } - - @Override - protected boolean peephole(ValueNode valueNode) { - // No peephole optimizations for now - return false; - } - - @Override - public void visitCompareAndSwap(LoweredCompareAndSwapNode i, Value address) { - throw new InternalError("NYI"); - } - - @Override - public void visitBreakpointNode(BreakpointNode node) { - JavaType[] sig = new JavaType[node.arguments().size()]; - for (int i = 0; i < sig.length; i++) { - sig[i] = node.arguments().get(i).stamp().javaType(gen.getMetaAccess()); - } - - Value[] parameters = visitInvokeArguments(res.getFrameMap().registerConfig.getCallingConvention(CallingConvention.Type.JavaCall, null, sig, gen.target(), false), node.arguments()); - append(new SPARCBreakpointOp(parameters)); - } - - @Override - public void emitNullCheck(ValueNode v, DeoptimizingNode deopting) { - assert v.getKind() == Kind.Object; - append(new NullCheckOp(gen.load(operand(v)), gen.state(deopting))); - } - - @Override - public void visitInfopointNode(InfopointNode i) { - throw new InternalError("NYI"); - } -}
--- a/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/GraalCompiler.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/GraalCompiler.java Mon Mar 31 10:03:32 2014 +0200 @@ -205,7 +205,7 @@ } - private static void emitBlock(NodeLIRGenerator nodeLirGen, LIRGenerationResult lirGenRes, Block b, StructuredGraph graph, BlockMap<List<ScheduledNode>> blockMap) { + private static void emitBlock(NodeLIRBuilder nodeLirGen, LIRGenerationResult lirGenRes, Block b, StructuredGraph graph, BlockMap<List<ScheduledNode>> blockMap) { if (lirGenRes.getLIR().getLIRforBlock(b) == null) { for (Block pred : b.getPredecessors()) { if (!b.isLoopHeader() || !pred.isLoopEnd()) { @@ -244,7 +244,7 @@ FrameMap frameMap = backend.newFrameMap(); LIRGenerationResult lirGenRes = backend.newLIRGenerationResult(lir, frameMap, stub); LIRGenerator lirGen = backend.newLIRGenerator(cc, lirGenRes); - NodeLIRGenerator nodeLirGen = backend.newNodeLIRGenerator(graph, lirGenRes, lirGen); + NodeLIRBuilder nodeLirGen = backend.newNodeLIRGenerator(graph, lirGenRes, lirGen); try (Scope s = Debug.scope("LIRGen", lirGen)) { for (Block b : linearScanOrder) {
--- a/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/alloc/LinearScan.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/alloc/LinearScan.java Mon Mar 31 10:03:32 2014 +0200 @@ -884,9 +884,9 @@ } } - private static NodeLIRGenerator getNodeLIRGeneratorFromDebugContext() { + private static NodeLIRBuilder getNodeLIRGeneratorFromDebugContext() { if (Debug.isEnabled()) { - NodeLIRGenerator lirGen = Debug.contextLookup(NodeLIRGenerator.class); + NodeLIRBuilder lirGen = Debug.contextLookup(NodeLIRBuilder.class); assert lirGen != null; return lirGen; } @@ -894,7 +894,7 @@ } private static ValueNode getValueForOperandFromDebugContext(Value value) { - NodeLIRGenerator gen = getNodeLIRGeneratorFromDebugContext(); + NodeLIRBuilder gen = getNodeLIRGeneratorFromDebugContext(); if (gen != null) { return gen.valueForOperand(value); }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/NodeLIRBuilder.java Mon Mar 31 10:03:32 2014 +0200 @@ -0,0 +1,789 @@ +/* + * Copyright (c) 2009, 2012, 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.compiler.gen; + +import static com.oracle.graal.api.code.ValueUtil.*; +import static com.oracle.graal.api.meta.Value.*; +import static com.oracle.graal.lir.LIR.*; +import static com.oracle.graal.nodes.ConstantNode.*; + +import java.lang.reflect.*; +import java.util.*; +import java.util.Map.Entry; + +import com.oracle.graal.api.code.*; +import com.oracle.graal.api.meta.*; +import com.oracle.graal.asm.*; +import com.oracle.graal.compiler.gen.LIRGenerator.LoadConstant; +import com.oracle.graal.compiler.target.*; +import com.oracle.graal.debug.*; +import com.oracle.graal.debug.Debug.Scope; +import com.oracle.graal.graph.*; +import com.oracle.graal.lir.*; +import com.oracle.graal.lir.StandardOp.BlockEndOp; +import com.oracle.graal.lir.StandardOp.JumpOp; +import com.oracle.graal.lir.StandardOp.LabelOp; +import com.oracle.graal.nodes.*; +import com.oracle.graal.nodes.PhiNode.PhiType; +import com.oracle.graal.nodes.calc.*; +import com.oracle.graal.nodes.cfg.*; +import com.oracle.graal.nodes.extended.*; +import com.oracle.graal.nodes.spi.*; +import com.oracle.graal.nodes.type.*; +import com.oracle.graal.nodes.virtual.*; +import com.oracle.graal.phases.*; + +/** + * This class traverses the HIR instructions and generates LIR instructions from them. + */ +public abstract class NodeLIRBuilder implements NodeLIRBuiderTool { + + private final NodeMap<Value> nodeOperands; + private final DebugInfoBuilder debugInfoBuilder; + + private final int traceLevel; + private final boolean printIRWithLIR; + + protected final LIRGenerator gen; + + private ValueNode currentInstruction; + private ValueNode lastInstructionPrinted; // Debugging only + + protected LIRGenerationResult res; + + public NodeLIRBuilder(StructuredGraph graph, LIRGenerationResult res, LIRGenerator gen) { + this.res = res; + this.nodeOperands = graph.createNodeMap(); + this.debugInfoBuilder = createDebugInfoBuilder(nodeOperands); + this.gen = gen; + this.traceLevel = LIRGenerator.Options.TraceLIRGeneratorLevel.getValue(); + this.printIRWithLIR = LIRGenerator.Options.PrintIRWithLIR.getValue(); + gen.setDebugInfoBuilder(debugInfoBuilder); + } + + @SuppressWarnings("hiding") + protected DebugInfoBuilder createDebugInfoBuilder(NodeMap<Value> nodeOperands) { + return new DebugInfoBuilder(nodeOperands); + } + + /** + * Returns the operand that has been previously initialized by + * {@link #setResult(ValueNode, Value)} with the result of an instruction. It's a code + * generation error to ask for the operand of ValueNode that doesn't have one yet. + * + * @param node A node that produces a result value. + */ + @Override + public Value operand(ValueNode node) { + Value operand = getOperand(node); + assert operand != null : String.format("missing operand for %1s", node); + return operand; + } + + @Override + public boolean hasOperand(ValueNode node) { + return getOperand(node) != null; + } + + private Value getOperand(ValueNode node) { + if (nodeOperands == null) { + return null; + } + Value operand = nodeOperands.get(node); + if (operand == null) { + operand = getConstantOperand(node); + } + return operand; + } + + private Value getConstantOperand(ValueNode node) { + if (!ConstantNodeRecordsUsages) { + Constant value = node.asConstant(); + if (value != null) { + if (gen.canInlineConstant(value)) { + return setResult(node, value); + } else { + Variable loadedValue; + if (gen.constantLoads == null) { + gen.constantLoads = new HashMap<>(); + } + LoadConstant load = gen.constantLoads.get(value); + assert gen.getCurrentBlock() instanceof Block; + if (load == null) { + int index = res.getLIR().getLIRforBlock(gen.getCurrentBlock()).size(); + loadedValue = gen.emitMove(value); + LIRInstruction op = res.getLIR().getLIRforBlock(gen.getCurrentBlock()).get(index); + gen.constantLoads.put(value, new LoadConstant(loadedValue, (Block) gen.getCurrentBlock(), index, op)); + } else { + Block dominator = ControlFlowGraph.commonDominator(load.block, (Block) gen.getCurrentBlock()); + loadedValue = load.variable; + if (dominator != load.block) { + load.unpin(res.getLIR()); + } else { + assert load.block != gen.getCurrentBlock() || load.index < res.getLIR().getLIRforBlock(gen.getCurrentBlock()).size(); + } + load.block = dominator; + } + return loadedValue; + } + } + } else { + // Constant is loaded by ConstantNode.generate() + } + return null; + } + + public ValueNode valueForOperand(Value value) { + for (Entry<Node, Value> entry : getNodeOperands().entries()) { + if (entry.getValue().equals(value)) { + return (ValueNode) entry.getKey(); + } + } + return null; + } + + @Override + public Value setResult(ValueNode x, Value operand) { + assert (!isRegister(operand) || !gen.attributes(asRegister(operand)).isAllocatable()); + assert nodeOperands == null || nodeOperands.get(x) == null : "operand cannot be set twice"; + assert operand != null && isLegal(operand) : "operand must be legal"; + assert operand.getKind().getStackKind() == x.getKind() || x.getKind() == Kind.Illegal : operand.getKind().getStackKind() + " must match " + x.getKind(); + assert !(x instanceof VirtualObjectNode); + nodeOperands.set(x, operand); + return operand; + } + + public LabelRef getLIRBlock(FixedNode b) { + assert res.getLIR().getControlFlowGraph() instanceof ControlFlowGraph; + Block result = ((ControlFlowGraph) res.getLIR().getControlFlowGraph()).blockFor(b); + int suxIndex = gen.getCurrentBlock().getSuccessors().indexOf(result); + assert suxIndex != -1 : "Block not in successor list of current block"; + + assert gen.getCurrentBlock() instanceof Block; + return LabelRef.forSuccessor(res.getLIR(), (Block) gen.getCurrentBlock(), suxIndex); + } + + public final void append(LIRInstruction op) { + if (printIRWithLIR && !TTY.isSuppressed()) { + if (currentInstruction != null && lastInstructionPrinted != currentInstruction) { + lastInstructionPrinted = currentInstruction; + InstructionPrinter ip = new InstructionPrinter(TTY.out()); + ip.printInstructionListing(currentInstruction); + } + } + gen.append(op); + } + + public final void doBlockStart(AbstractBlock<?> block) { + if (printIRWithLIR) { + TTY.print(block.toString()); + } + + gen.setCurrentBlock(block); + + // set up the list of LIR instructions + assert res.getLIR().getLIRforBlock(block) == null : "LIR list already computed for this block"; + res.getLIR().setLIRforBlock(block, new ArrayList<LIRInstruction>()); + + append(new LabelOp(new Label(block.getId()), block.isAligned())); + + if (traceLevel >= 1) { + TTY.println("BEGIN Generating LIR for block B" + block.getId()); + } + } + + public final void doBlockEnd(AbstractBlock<?> block) { + + if (traceLevel >= 1) { + TTY.println("END Generating LIR for block B" + block.getId()); + } + + gen.setCurrentBlock(null); + + if (printIRWithLIR) { + TTY.println(); + } + } + + public void doBlock(Block block, StructuredGraph graph, BlockMap<List<ScheduledNode>> blockMap) { + doBlockStart(block); + + if (block == res.getLIR().getControlFlowGraph().getStartBlock()) { + assert block.getPredecessorCount() == 0; + emitPrologue(graph); + } else { + assert block.getPredecessorCount() > 0; + } + + List<ScheduledNode> nodes = blockMap.get(block); + int instructionsFolded = 0; + for (int i = 0; i < nodes.size(); i++) { + Node instr = nodes.get(i); + if (traceLevel >= 3) { + TTY.println("LIRGen for " + instr); + } + if (instructionsFolded > 0) { + instructionsFolded--; + continue; + } + if (!ConstantNodeRecordsUsages && instr instanceof ConstantNode) { + // Loading of constants is done lazily by operand() + + } else if (instr instanceof ValueNode) { + ValueNode valueNode = (ValueNode) instr; + if (!hasOperand(valueNode)) { + if (!peephole(valueNode)) { + instructionsFolded = maybeFoldMemory(nodes, i, valueNode); + if (instructionsFolded == 0) { + try { + doRoot((ValueNode) instr); + } catch (GraalInternalError e) { + throw e.addContext(instr); + } catch (Throwable e) { + throw new GraalInternalError(e).addContext(instr); + } + } + } + } else { + // There can be cases in which the result of an instruction is already set + // before by other instructions. + } + } + } + + if (!hasBlockEnd(block)) { + NodeClassIterable successors = block.getEndNode().successors(); + assert successors.count() == block.getSuccessorCount(); + if (block.getSuccessorCount() != 1) { + /* + * If we have more than one successor, we cannot just use the first one. Since + * successors are unordered, this would be a random choice. + */ + throw new GraalInternalError("Block without BlockEndOp: " + block.getEndNode()); + } + gen.emitJump(getLIRBlock((FixedNode) successors.first())); + } + + assert verifyBlock(res.getLIR(), block); + doBlockEnd(block); + } + + private static final DebugMetric MemoryFoldSuccess = Debug.metric("MemoryFoldSuccess"); + private static final DebugMetric MemoryFoldFailed = Debug.metric("MemoryFoldFailed"); + private static final DebugMetric MemoryFoldFailedNonAdjacent = Debug.metric("MemoryFoldedFailedNonAdjacent"); + private static final DebugMetric MemoryFoldFailedDifferentBlock = Debug.metric("MemoryFoldedFailedDifferentBlock"); + + /** + * Subclass can provide helper to fold memory operations into other operations. + */ + public MemoryArithmeticLIRLowerer getMemoryLowerer() { + return null; + } + + private static final Object LOG_OUTPUT_LOCK = new Object(); + + /** + * Try to find a sequence of Nodes which can be passed to the backend to look for optimized + * instruction sequences using memory. Currently this basically is a read with a single + * arithmetic user followed by an possible if use. This should generalized to more generic + * pattern matching so that it can be more flexibly used. + */ + private int maybeFoldMemory(List<ScheduledNode> nodes, int i, ValueNode access) { + MemoryArithmeticLIRLowerer lowerer = getMemoryLowerer(); + if (lowerer != null && GraalOptions.OptFoldMemory.getValue() && (access instanceof ReadNode || access instanceof FloatingReadNode) && access.usages().count() == 1 && i + 1 < nodes.size()) { + try (Scope s = Debug.scope("MaybeFoldMemory", access)) { + // This is all bit hacky since it's happening on the linearized schedule. This needs + // to be revisited at some point. + + // Find a memory lowerable usage of this operation + if (access.usages().first() instanceof MemoryArithmeticLIRLowerable) { + ValueNode operation = (ValueNode) access.usages().first(); + if (!nodes.contains(operation)) { + Debug.log("node %1s in different block from %1s", access, operation); + MemoryFoldFailedDifferentBlock.increment(); + return 0; + } + ValueNode firstOperation = operation; + if (operation instanceof LogicNode) { + if (operation.usages().count() == 1 && operation.usages().first() instanceof IfNode) { + ValueNode ifNode = (ValueNode) operation.usages().first(); + if (!nodes.contains(ifNode)) { + MemoryFoldFailedDifferentBlock.increment(); + Debug.log("if node %1s in different block from %1s", ifNode, operation); + try (Indent indent = Debug.logAndIndent("checking operations")) { + int start = nodes.indexOf(access); + int end = nodes.indexOf(operation); + for (int i1 = Math.min(start, end); i1 <= Math.max(start, end); i1++) { + Debug.log("%d: (%d) %1s", i1, nodes.get(i1).usages().count(), nodes.get(i1)); + } + } + return 0; + } else { + operation = ifNode; + } + } + } + if (Debug.isLogEnabled()) { + synchronized (LOG_OUTPUT_LOCK) { // Hack to ensure the output is grouped. + try (Indent indent = Debug.logAndIndent("checking operations")) { + int start = nodes.indexOf(access); + int end = nodes.indexOf(operation); + for (int i1 = Math.min(start, end); i1 <= Math.max(start, end); i1++) { + Debug.log("%d: (%d) %1s", i1, nodes.get(i1).usages().count(), nodes.get(i1)); + } + } + } + } + // Possible lowerable operation in the same block. Check out the dependencies. + int opIndex = nodes.indexOf(operation); + int current = i + 1; + ArrayList<ValueNode> deferred = null; + while (current < opIndex) { + ScheduledNode node = nodes.get(current); + if (node != firstOperation) { + if (node instanceof LocationNode || node instanceof VirtualObjectNode) { + // nothing to do + } else if (node instanceof ConstantNode) { + if (deferred == null) { + deferred = new ArrayList<>(2); + } + // These nodes are collected and the backend is expended to + // evaluate them before generating the lowered form. This + // basically works around unfriendly scheduling of values which + // are defined in a block but not used there. + deferred.add((ValueNode) node); + } else { + Debug.log("unexpected node %1s", node); + // Unexpected inline node + break; + } + } + current++; + } + + if (current == opIndex) { + if (lowerer.memoryPeephole((Access) access, (MemoryArithmeticLIRLowerable) operation, deferred)) { + MemoryFoldSuccess.increment(); + // if this operation had multiple access inputs, then previous attempts + // would be marked as failures which is wrong. Try to adjust the + // counters to account for this. + for (Node input : operation.inputs()) { + if (input == access) { + continue; + } + if (input instanceof Access && nodes.contains(input)) { + MemoryFoldFailedNonAdjacent.add(-1); + } + } + if (deferred != null) { + // Ensure deferred nodes were evaluated + for (ValueNode node : deferred) { + assert hasOperand(node); + } + } + return opIndex - i; + } else { + // This isn't true failure, it just means there wasn't match for the + // pattern. Usually that means it's just not supported by the backend. + MemoryFoldFailed.increment(); + return 0; + } + } else { + MemoryFoldFailedNonAdjacent.increment(); + } + } else { + // memory usage which isn't considered lowerable. Mostly these are + // uninteresting but it might be worth looking at to ensure that interesting + // nodes are being properly handled. + // Debug.log("usage isn't lowerable %1s", access.usages().first()); + } + } + } + return 0; + } + + protected abstract boolean peephole(ValueNode valueNode); + + private boolean hasBlockEnd(Block block) { + List<LIRInstruction> ops = res.getLIR().getLIRforBlock(block); + if (ops.size() == 0) { + return false; + } + return ops.get(ops.size() - 1) instanceof BlockEndOp; + } + + private void doRoot(ValueNode instr) { + if (traceLevel >= 2) { + TTY.println("Emitting LIR for instruction " + instr); + } + currentInstruction = instr; + + Debug.log("Visiting %s", instr); + emitNode(instr); + Debug.log("Operand for %s = %s", instr, getOperand(instr)); + } + + protected void emitNode(ValueNode node) { + if (Debug.isLogEnabled() && node.stamp() instanceof IllegalStamp) { + Debug.log("This node has invalid type, we are emitting dead code(?): %s", node); + } + if (node instanceof LIRGenLowerable) { + ((LIRGenLowerable) node).generate(this); + } else if (node instanceof LIRGenResLowerable) { + ((LIRGenResLowerable) node).generate(this, res); + } else if (node instanceof LIRLowerable) { + ((LIRLowerable) node).generate(this); + } else if (node instanceof ArithmeticLIRLowerable) { + ((ArithmeticLIRLowerable) node).generate(this); + } else { + throw GraalInternalError.shouldNotReachHere("node is not LIRLowerable: " + node); + } + } + + protected void emitPrologue(StructuredGraph graph) { + CallingConvention incomingArguments = gen.getCallingConvention(); + + Value[] params = new Value[incomingArguments.getArgumentCount()]; + for (int i = 0; i < params.length; i++) { + params[i] = toStackKind(incomingArguments.getArgument(i)); + if (ValueUtil.isStackSlot(params[i])) { + StackSlot slot = ValueUtil.asStackSlot(params[i]); + if (slot.isInCallerFrame() && !res.getLIR().hasArgInCallerFrame()) { + res.getLIR().setHasArgInCallerFrame(); + } + } + } + + emitIncomingValues(params); + + for (ParameterNode param : graph.getNodes(ParameterNode.class)) { + Value paramValue = params[param.index()]; + assert paramValue.getKind() == param.getKind().getStackKind(); + setResult(param, gen.emitMove(paramValue)); + } + } + + protected <T extends AbstractBlock<T>> void emitPrologue(ResolvedJavaMethod method, BytecodeParser<T> parser) { + CallingConvention incomingArguments = gen.getCallingConvention(); + + Value[] params = new Value[incomingArguments.getArgumentCount()]; + for (int i = 0; i < params.length; i++) { + params[i] = toStackKind(incomingArguments.getArgument(i)); + if (ValueUtil.isStackSlot(params[i])) { + StackSlot slot = ValueUtil.asStackSlot(params[i]); + if (slot.isInCallerFrame() && !res.getLIR().hasArgInCallerFrame()) { + res.getLIR().setHasArgInCallerFrame(); + } + } + } + + emitIncomingValues(params); + + Signature sig = method.getSignature(); + boolean isStatic = Modifier.isStatic(method.getModifiers()); + for (int i = 0; i < sig.getParameterCount(!isStatic); i++) { + Value paramValue = params[i]; + assert paramValue.getKind() == sig.getParameterKind(i).getStackKind(); + // TODO setResult(param, emitMove(paramValue)); + parser.setParameter(i, gen.emitMove(paramValue)); + } + + // return arguments; + } + + public void emitIncomingValues(Value[] params) { + ((LabelOp) res.getLIR().getLIRforBlock(gen.getCurrentBlock()).get(0)).setIncomingValues(params); + } + + @Override + public void visitReturn(ReturnNode x) { + AllocatableValue operand = ILLEGAL; + if (x.result() != null) { + operand = gen.resultOperandFor(x.result().getKind()); + gen.emitMove(operand, operand(x.result())); + } + gen.emitReturn(operand); + } + + @Override + public void visitMerge(MergeNode x) { + } + + @Override + public void visitEndNode(AbstractEndNode end) { + moveToPhi(end.merge(), end); + } + + /** + * Runtime specific classes can override this to insert a safepoint at the end of a loop. + */ + @Override + public void visitLoopEnd(LoopEndNode x) { + } + + private void moveToPhi(MergeNode merge, AbstractEndNode pred) { + if (traceLevel >= 1) { + TTY.println("MOVE TO PHI from " + pred + " to " + merge); + } + PhiResolver resolver = new PhiResolver(gen); + for (PhiNode phi : merge.phis()) { + if (phi.type() == PhiType.Value) { + ValueNode curVal = phi.valueAt(pred); + resolver.move(operandForPhi(phi), operand(curVal)); + } + } + resolver.dispose(); + + append(new JumpOp(getLIRBlock(merge))); + } + + protected PlatformKind getPhiKind(PhiNode phi) { + return phi.getKind(); + } + + private Value operandForPhi(PhiNode phi) { + assert phi.type() == PhiType.Value : "wrong phi type: " + phi; + Value result = getOperand(phi); + if (result == null) { + // allocate a variable for this phi + Variable newOperand = gen.newVariable(getPhiKind(phi)); + setResult(phi, newOperand); + return newOperand; + } else { + return result; + } + } + + @Override + public void emitIf(IfNode x) { + emitBranch(x.condition(), getLIRBlock(x.trueSuccessor()), getLIRBlock(x.falseSuccessor()), x.probability(x.trueSuccessor())); + } + + public void emitBranch(LogicNode node, LabelRef trueSuccessor, LabelRef falseSuccessor, double trueSuccessorProbability) { + if (node instanceof IsNullNode) { + emitNullCheckBranch((IsNullNode) node, trueSuccessor, falseSuccessor, trueSuccessorProbability); + } else if (node instanceof CompareNode) { + emitCompareBranch((CompareNode) node, trueSuccessor, falseSuccessor, trueSuccessorProbability); + } else if (node instanceof LogicConstantNode) { + emitConstantBranch(((LogicConstantNode) node).getValue(), trueSuccessor, falseSuccessor); + } else if (node instanceof IntegerTestNode) { + emitIntegerTestBranch((IntegerTestNode) node, trueSuccessor, falseSuccessor, trueSuccessorProbability); + } else { + throw GraalInternalError.unimplemented(node.toString()); + } + } + + private void emitNullCheckBranch(IsNullNode node, LabelRef trueSuccessor, LabelRef falseSuccessor, double trueSuccessorProbability) { + gen.emitCompareBranch(operand(node.object()), Constant.NULL_OBJECT, Condition.EQ, false, trueSuccessor, falseSuccessor, trueSuccessorProbability); + } + + public void emitCompareBranch(CompareNode compare, LabelRef trueSuccessor, LabelRef falseSuccessor, double trueSuccessorProbability) { + gen.emitCompareBranch(operand(compare.x()), operand(compare.y()), compare.condition(), compare.unorderedIsTrue(), trueSuccessor, falseSuccessor, trueSuccessorProbability); + } + + public void emitIntegerTestBranch(IntegerTestNode test, LabelRef trueSuccessor, LabelRef falseSuccessor, double trueSuccessorProbability) { + gen.emitIntegerTestBranch(operand(test.x()), operand(test.y()), trueSuccessor, falseSuccessor, trueSuccessorProbability); + } + + public void emitConstantBranch(boolean value, LabelRef trueSuccessorBlock, LabelRef falseSuccessorBlock) { + LabelRef block = value ? trueSuccessorBlock : falseSuccessorBlock; + gen.emitJump(block); + } + + @Override + public void emitConditional(ConditionalNode conditional) { + Value tVal = operand(conditional.trueValue()); + Value fVal = operand(conditional.falseValue()); + setResult(conditional, emitConditional(conditional.condition(), tVal, fVal)); + } + + public Variable emitConditional(LogicNode node, Value trueValue, Value falseValue) { + if (node instanceof IsNullNode) { + IsNullNode isNullNode = (IsNullNode) node; + return gen.emitConditionalMove(operand(isNullNode.object()), Constant.NULL_OBJECT, Condition.EQ, false, trueValue, falseValue); + } else if (node instanceof CompareNode) { + CompareNode compare = (CompareNode) node; + return gen.emitConditionalMove(operand(compare.x()), operand(compare.y()), compare.condition(), compare.unorderedIsTrue(), trueValue, falseValue); + } else if (node instanceof LogicConstantNode) { + return gen.emitMove(((LogicConstantNode) node).getValue() ? trueValue : falseValue); + } else if (node instanceof IntegerTestNode) { + IntegerTestNode test = (IntegerTestNode) node; + return gen.emitIntegerTestMove(operand(test.x()), operand(test.y()), trueValue, falseValue); + } else { + throw GraalInternalError.unimplemented(node.toString()); + } + } + + @Override + public void emitInvoke(Invoke x) { + LoweredCallTargetNode callTarget = (LoweredCallTargetNode) x.callTarget(); + CallingConvention invokeCc = res.getFrameMap().registerConfig.getCallingConvention(callTarget.callType(), x.asNode().stamp().javaType(gen.getMetaAccess()), callTarget.signature(), + gen.target(), false); + res.getFrameMap().callsMethod(invokeCc); + + Value[] parameters = visitInvokeArguments(invokeCc, callTarget.arguments()); + + LabelRef exceptionEdge = null; + if (x instanceof InvokeWithExceptionNode) { + exceptionEdge = getLIRBlock(((InvokeWithExceptionNode) x).exceptionEdge()); + } + LIRFrameState callState = gen.stateWithExceptionEdge(x, exceptionEdge); + + Value result = invokeCc.getReturn(); + if (callTarget instanceof DirectCallTargetNode) { + emitDirectCall((DirectCallTargetNode) callTarget, result, parameters, AllocatableValue.NONE, callState); + } else if (callTarget instanceof IndirectCallTargetNode) { + emitIndirectCall((IndirectCallTargetNode) callTarget, result, parameters, AllocatableValue.NONE, callState); + } else { + throw GraalInternalError.shouldNotReachHere(); + } + + if (isLegal(result)) { + setResult(x.asNode(), gen.emitMove(result)); + } + + if (x instanceof InvokeWithExceptionNode) { + gen.emitJump(getLIRBlock(((InvokeWithExceptionNode) x).next())); + } + } + + protected abstract void emitDirectCall(DirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState); + + protected abstract void emitIndirectCall(IndirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState); + + protected static AllocatableValue toStackKind(AllocatableValue value) { + if (value.getKind().getStackKind() != value.getKind()) { + // We only have stack-kinds in the LIR, so convert the operand kind for values from the + // calling convention. + if (isRegister(value)) { + return asRegister(value).asValue(value.getKind().getStackKind()); + } else if (isStackSlot(value)) { + return StackSlot.get(value.getKind().getStackKind(), asStackSlot(value).getRawOffset(), asStackSlot(value).getRawAddFrameSize()); + } else { + throw GraalInternalError.shouldNotReachHere(); + } + } + return value; + } + + @Override + public Value[] visitInvokeArguments(CallingConvention invokeCc, Collection<ValueNode> arguments) { + // for each argument, load it into the correct location + Value[] result = new Value[arguments.size()]; + int j = 0; + for (ValueNode arg : arguments) { + if (arg != null) { + AllocatableValue operand = toStackKind(invokeCc.getArgument(j)); + gen.emitMove(operand, operand(arg)); + result[j] = operand; + j++; + } else { + throw GraalInternalError.shouldNotReachHere("I thought we no longer have null entries for two-slot types..."); + } + } + return result; + } + + /** + * This method tries to create a switch implementation that is optimal for the given switch. It + * will either generate a sequential if/then/else cascade, a set of range tests or a table + * switch. + * + * If the given switch does not contain int keys, it will always create a sequential + * implementation. + */ + @Override + public void emitSwitch(SwitchNode x) { + assert x.defaultSuccessor() != null; + LabelRef defaultTarget = getLIRBlock(x.defaultSuccessor()); + int keyCount = x.keyCount(); + if (keyCount == 0) { + gen.emitJump(defaultTarget); + } else { + Variable value = gen.load(operand(x.value())); + if (keyCount == 1) { + assert defaultTarget != null; + double probability = x.probability(x.keySuccessor(0)); + gen.emitCompareBranch(gen.load(operand(x.value())), x.keyAt(0), Condition.EQ, false, getLIRBlock(x.keySuccessor(0)), defaultTarget, probability); + } else { + LabelRef[] keyTargets = new LabelRef[keyCount]; + Constant[] keyConstants = new Constant[keyCount]; + double[] keyProbabilities = new double[keyCount]; + for (int i = 0; i < keyCount; i++) { + keyTargets[i] = getLIRBlock(x.keySuccessor(i)); + keyConstants[i] = x.keyAt(i); + keyProbabilities[i] = x.keyProbability(i); + } + if (value.getKind() != Kind.Int || !x.isSorted()) { + // hopefully only a few entries + gen.emitStrategySwitch(new SwitchStrategy.SequentialStrategy(keyProbabilities, keyConstants), value, keyTargets, defaultTarget); + } else { + gen.emitStrategySwitch(keyConstants, keyProbabilities, keyTargets, defaultTarget, value); + } + } + } + } + + public final NodeMap<Value> getNodeOperands() { + assert nodeOperands != null; + return nodeOperands; + } + + public DebugInfoBuilder getDebugInfoBuilder() { + assert debugInfoBuilder != null; + return debugInfoBuilder; + } + + public void emitOverflowCheckBranch(AbstractBeginNode overflowSuccessor, AbstractBeginNode next, double probability) { + gen.emitOverflowCheckBranch(getLIRBlock(overflowSuccessor), getLIRBlock(next), probability); + } + + public final void emitArrayEquals(Kind kind, Variable result, Value array1, Value array2, Value length) { + gen.emitArrayEquals(kind, result, array1, array2, length); + } + + public final Variable newVariable(Kind i) { + return gen.newVariable(i); + } + + public final void emitBitCount(Variable result, Value operand) { + gen.emitBitCount(result, operand); + } + + public final void emitBitScanForward(Variable result, Value operand) { + gen.emitBitScanForward(result, operand); + } + + final void emitBitScanReverse(Variable result, Value operand) { + gen.emitBitScanReverse(result, operand); + } + + @Override + public LIRGenerator getLIRGeneratorTool() { + return gen; + } + + public LIRGenerator getLIRGenerator() { + return gen; + } +}
--- a/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/NodeLIRGenerator.java Fri Mar 28 14:28:27 2014 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,789 +0,0 @@ -/* - * Copyright (c) 2009, 2012, 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.compiler.gen; - -import static com.oracle.graal.api.code.ValueUtil.*; -import static com.oracle.graal.api.meta.Value.*; -import static com.oracle.graal.lir.LIR.*; -import static com.oracle.graal.nodes.ConstantNode.*; - -import java.lang.reflect.*; -import java.util.*; -import java.util.Map.Entry; - -import com.oracle.graal.api.code.*; -import com.oracle.graal.api.meta.*; -import com.oracle.graal.asm.*; -import com.oracle.graal.compiler.gen.LIRGenerator.LoadConstant; -import com.oracle.graal.compiler.target.*; -import com.oracle.graal.debug.*; -import com.oracle.graal.debug.Debug.Scope; -import com.oracle.graal.graph.*; -import com.oracle.graal.lir.*; -import com.oracle.graal.lir.StandardOp.BlockEndOp; -import com.oracle.graal.lir.StandardOp.JumpOp; -import com.oracle.graal.lir.StandardOp.LabelOp; -import com.oracle.graal.nodes.*; -import com.oracle.graal.nodes.PhiNode.PhiType; -import com.oracle.graal.nodes.calc.*; -import com.oracle.graal.nodes.cfg.*; -import com.oracle.graal.nodes.extended.*; -import com.oracle.graal.nodes.spi.*; -import com.oracle.graal.nodes.type.*; -import com.oracle.graal.nodes.virtual.*; -import com.oracle.graal.phases.*; - -/** - * This class traverses the HIR instructions and generates LIR instructions from them. - */ -public abstract class NodeLIRGenerator implements NodeLIRGeneratorTool { - - private final NodeMap<Value> nodeOperands; - private final DebugInfoBuilder debugInfoBuilder; - - private final int traceLevel; - private final boolean printIRWithLIR; - - protected final LIRGenerator gen; - - private ValueNode currentInstruction; - private ValueNode lastInstructionPrinted; // Debugging only - - protected LIRGenerationResult res; - - public NodeLIRGenerator(StructuredGraph graph, LIRGenerationResult res, LIRGenerator gen) { - this.res = res; - this.nodeOperands = graph.createNodeMap(); - this.debugInfoBuilder = createDebugInfoBuilder(nodeOperands); - this.gen = gen; - this.traceLevel = LIRGenerator.Options.TraceLIRGeneratorLevel.getValue(); - this.printIRWithLIR = LIRGenerator.Options.PrintIRWithLIR.getValue(); - gen.setDebugInfoBuilder(debugInfoBuilder); - } - - @SuppressWarnings("hiding") - protected DebugInfoBuilder createDebugInfoBuilder(NodeMap<Value> nodeOperands) { - return new DebugInfoBuilder(nodeOperands); - } - - /** - * Returns the operand that has been previously initialized by - * {@link #setResult(ValueNode, Value)} with the result of an instruction. It's a code - * generation error to ask for the operand of ValueNode that doesn't have one yet. - * - * @param node A node that produces a result value. - */ - @Override - public Value operand(ValueNode node) { - Value operand = getOperand(node); - assert operand != null : String.format("missing operand for %1s", node); - return operand; - } - - @Override - public boolean hasOperand(ValueNode node) { - return getOperand(node) != null; - } - - private Value getOperand(ValueNode node) { - if (nodeOperands == null) { - return null; - } - Value operand = nodeOperands.get(node); - if (operand == null) { - operand = getConstantOperand(node); - } - return operand; - } - - private Value getConstantOperand(ValueNode node) { - if (!ConstantNodeRecordsUsages) { - Constant value = node.asConstant(); - if (value != null) { - if (gen.canInlineConstant(value)) { - return setResult(node, value); - } else { - Variable loadedValue; - if (gen.constantLoads == null) { - gen.constantLoads = new HashMap<>(); - } - LoadConstant load = gen.constantLoads.get(value); - assert gen.getCurrentBlock() instanceof Block; - if (load == null) { - int index = res.getLIR().getLIRforBlock(gen.getCurrentBlock()).size(); - loadedValue = gen.emitMove(value); - LIRInstruction op = res.getLIR().getLIRforBlock(gen.getCurrentBlock()).get(index); - gen.constantLoads.put(value, new LoadConstant(loadedValue, (Block) gen.getCurrentBlock(), index, op)); - } else { - Block dominator = ControlFlowGraph.commonDominator(load.block, (Block) gen.getCurrentBlock()); - loadedValue = load.variable; - if (dominator != load.block) { - load.unpin(res.getLIR()); - } else { - assert load.block != gen.getCurrentBlock() || load.index < res.getLIR().getLIRforBlock(gen.getCurrentBlock()).size(); - } - load.block = dominator; - } - return loadedValue; - } - } - } else { - // Constant is loaded by ConstantNode.generate() - } - return null; - } - - public ValueNode valueForOperand(Value value) { - for (Entry<Node, Value> entry : getNodeOperands().entries()) { - if (entry.getValue().equals(value)) { - return (ValueNode) entry.getKey(); - } - } - return null; - } - - @Override - public Value setResult(ValueNode x, Value operand) { - assert (!isRegister(operand) || !gen.attributes(asRegister(operand)).isAllocatable()); - assert nodeOperands == null || nodeOperands.get(x) == null : "operand cannot be set twice"; - assert operand != null && isLegal(operand) : "operand must be legal"; - assert operand.getKind().getStackKind() == x.getKind() || x.getKind() == Kind.Illegal : operand.getKind().getStackKind() + " must match " + x.getKind(); - assert !(x instanceof VirtualObjectNode); - nodeOperands.set(x, operand); - return operand; - } - - public LabelRef getLIRBlock(FixedNode b) { - assert res.getLIR().getControlFlowGraph() instanceof ControlFlowGraph; - Block result = ((ControlFlowGraph) res.getLIR().getControlFlowGraph()).blockFor(b); - int suxIndex = gen.getCurrentBlock().getSuccessors().indexOf(result); - assert suxIndex != -1 : "Block not in successor list of current block"; - - assert gen.getCurrentBlock() instanceof Block; - return LabelRef.forSuccessor(res.getLIR(), (Block) gen.getCurrentBlock(), suxIndex); - } - - public final void append(LIRInstruction op) { - if (printIRWithLIR && !TTY.isSuppressed()) { - if (currentInstruction != null && lastInstructionPrinted != currentInstruction) { - lastInstructionPrinted = currentInstruction; - InstructionPrinter ip = new InstructionPrinter(TTY.out()); - ip.printInstructionListing(currentInstruction); - } - } - gen.append(op); - } - - public final void doBlockStart(AbstractBlock<?> block) { - if (printIRWithLIR) { - TTY.print(block.toString()); - } - - gen.setCurrentBlock(block); - - // set up the list of LIR instructions - assert res.getLIR().getLIRforBlock(block) == null : "LIR list already computed for this block"; - res.getLIR().setLIRforBlock(block, new ArrayList<LIRInstruction>()); - - append(new LabelOp(new Label(block.getId()), block.isAligned())); - - if (traceLevel >= 1) { - TTY.println("BEGIN Generating LIR for block B" + block.getId()); - } - } - - public final void doBlockEnd(AbstractBlock<?> block) { - - if (traceLevel >= 1) { - TTY.println("END Generating LIR for block B" + block.getId()); - } - - gen.setCurrentBlock(null); - - if (printIRWithLIR) { - TTY.println(); - } - } - - public void doBlock(Block block, StructuredGraph graph, BlockMap<List<ScheduledNode>> blockMap) { - doBlockStart(block); - - if (block == res.getLIR().getControlFlowGraph().getStartBlock()) { - assert block.getPredecessorCount() == 0; - emitPrologue(graph); - } else { - assert block.getPredecessorCount() > 0; - } - - List<ScheduledNode> nodes = blockMap.get(block); - int instructionsFolded = 0; - for (int i = 0; i < nodes.size(); i++) { - Node instr = nodes.get(i); - if (traceLevel >= 3) { - TTY.println("LIRGen for " + instr); - } - if (instructionsFolded > 0) { - instructionsFolded--; - continue; - } - if (!ConstantNodeRecordsUsages && instr instanceof ConstantNode) { - // Loading of constants is done lazily by operand() - - } else if (instr instanceof ValueNode) { - ValueNode valueNode = (ValueNode) instr; - if (!hasOperand(valueNode)) { - if (!peephole(valueNode)) { - instructionsFolded = maybeFoldMemory(nodes, i, valueNode); - if (instructionsFolded == 0) { - try { - doRoot((ValueNode) instr); - } catch (GraalInternalError e) { - throw e.addContext(instr); - } catch (Throwable e) { - throw new GraalInternalError(e).addContext(instr); - } - } - } - } else { - // There can be cases in which the result of an instruction is already set - // before by other instructions. - } - } - } - - if (!hasBlockEnd(block)) { - NodeClassIterable successors = block.getEndNode().successors(); - assert successors.count() == block.getSuccessorCount(); - if (block.getSuccessorCount() != 1) { - /* - * If we have more than one successor, we cannot just use the first one. Since - * successors are unordered, this would be a random choice. - */ - throw new GraalInternalError("Block without BlockEndOp: " + block.getEndNode()); - } - gen.emitJump(getLIRBlock((FixedNode) successors.first())); - } - - assert verifyBlock(res.getLIR(), block); - doBlockEnd(block); - } - - private static final DebugMetric MemoryFoldSuccess = Debug.metric("MemoryFoldSuccess"); - private static final DebugMetric MemoryFoldFailed = Debug.metric("MemoryFoldFailed"); - private static final DebugMetric MemoryFoldFailedNonAdjacent = Debug.metric("MemoryFoldedFailedNonAdjacent"); - private static final DebugMetric MemoryFoldFailedDifferentBlock = Debug.metric("MemoryFoldedFailedDifferentBlock"); - - /** - * Subclass can provide helper to fold memory operations into other operations. - */ - public MemoryArithmeticLIRLowerer getMemoryLowerer() { - return null; - } - - private static final Object LOG_OUTPUT_LOCK = new Object(); - - /** - * Try to find a sequence of Nodes which can be passed to the backend to look for optimized - * instruction sequences using memory. Currently this basically is a read with a single - * arithmetic user followed by an possible if use. This should generalized to more generic - * pattern matching so that it can be more flexibly used. - */ - private int maybeFoldMemory(List<ScheduledNode> nodes, int i, ValueNode access) { - MemoryArithmeticLIRLowerer lowerer = getMemoryLowerer(); - if (lowerer != null && GraalOptions.OptFoldMemory.getValue() && (access instanceof ReadNode || access instanceof FloatingReadNode) && access.usages().count() == 1 && i + 1 < nodes.size()) { - try (Scope s = Debug.scope("MaybeFoldMemory", access)) { - // This is all bit hacky since it's happening on the linearized schedule. This needs - // to be revisited at some point. - - // Find a memory lowerable usage of this operation - if (access.usages().first() instanceof MemoryArithmeticLIRLowerable) { - ValueNode operation = (ValueNode) access.usages().first(); - if (!nodes.contains(operation)) { - Debug.log("node %1s in different block from %1s", access, operation); - MemoryFoldFailedDifferentBlock.increment(); - return 0; - } - ValueNode firstOperation = operation; - if (operation instanceof LogicNode) { - if (operation.usages().count() == 1 && operation.usages().first() instanceof IfNode) { - ValueNode ifNode = (ValueNode) operation.usages().first(); - if (!nodes.contains(ifNode)) { - MemoryFoldFailedDifferentBlock.increment(); - Debug.log("if node %1s in different block from %1s", ifNode, operation); - try (Indent indent = Debug.logAndIndent("checking operations")) { - int start = nodes.indexOf(access); - int end = nodes.indexOf(operation); - for (int i1 = Math.min(start, end); i1 <= Math.max(start, end); i1++) { - Debug.log("%d: (%d) %1s", i1, nodes.get(i1).usages().count(), nodes.get(i1)); - } - } - return 0; - } else { - operation = ifNode; - } - } - } - if (Debug.isLogEnabled()) { - synchronized (LOG_OUTPUT_LOCK) { // Hack to ensure the output is grouped. - try (Indent indent = Debug.logAndIndent("checking operations")) { - int start = nodes.indexOf(access); - int end = nodes.indexOf(operation); - for (int i1 = Math.min(start, end); i1 <= Math.max(start, end); i1++) { - Debug.log("%d: (%d) %1s", i1, nodes.get(i1).usages().count(), nodes.get(i1)); - } - } - } - } - // Possible lowerable operation in the same block. Check out the dependencies. - int opIndex = nodes.indexOf(operation); - int current = i + 1; - ArrayList<ValueNode> deferred = null; - while (current < opIndex) { - ScheduledNode node = nodes.get(current); - if (node != firstOperation) { - if (node instanceof LocationNode || node instanceof VirtualObjectNode) { - // nothing to do - } else if (node instanceof ConstantNode) { - if (deferred == null) { - deferred = new ArrayList<>(2); - } - // These nodes are collected and the backend is expended to - // evaluate them before generating the lowered form. This - // basically works around unfriendly scheduling of values which - // are defined in a block but not used there. - deferred.add((ValueNode) node); - } else { - Debug.log("unexpected node %1s", node); - // Unexpected inline node - break; - } - } - current++; - } - - if (current == opIndex) { - if (lowerer.memoryPeephole((Access) access, (MemoryArithmeticLIRLowerable) operation, deferred)) { - MemoryFoldSuccess.increment(); - // if this operation had multiple access inputs, then previous attempts - // would be marked as failures which is wrong. Try to adjust the - // counters to account for this. - for (Node input : operation.inputs()) { - if (input == access) { - continue; - } - if (input instanceof Access && nodes.contains(input)) { - MemoryFoldFailedNonAdjacent.add(-1); - } - } - if (deferred != null) { - // Ensure deferred nodes were evaluated - for (ValueNode node : deferred) { - assert hasOperand(node); - } - } - return opIndex - i; - } else { - // This isn't true failure, it just means there wasn't match for the - // pattern. Usually that means it's just not supported by the backend. - MemoryFoldFailed.increment(); - return 0; - } - } else { - MemoryFoldFailedNonAdjacent.increment(); - } - } else { - // memory usage which isn't considered lowerable. Mostly these are - // uninteresting but it might be worth looking at to ensure that interesting - // nodes are being properly handled. - // Debug.log("usage isn't lowerable %1s", access.usages().first()); - } - } - } - return 0; - } - - protected abstract boolean peephole(ValueNode valueNode); - - private boolean hasBlockEnd(Block block) { - List<LIRInstruction> ops = res.getLIR().getLIRforBlock(block); - if (ops.size() == 0) { - return false; - } - return ops.get(ops.size() - 1) instanceof BlockEndOp; - } - - private void doRoot(ValueNode instr) { - if (traceLevel >= 2) { - TTY.println("Emitting LIR for instruction " + instr); - } - currentInstruction = instr; - - Debug.log("Visiting %s", instr); - emitNode(instr); - Debug.log("Operand for %s = %s", instr, getOperand(instr)); - } - - protected void emitNode(ValueNode node) { - if (Debug.isLogEnabled() && node.stamp() instanceof IllegalStamp) { - Debug.log("This node has invalid type, we are emitting dead code(?): %s", node); - } - if (node instanceof LIRGenLowerable) { - ((LIRGenLowerable) node).generate(this); - } else if (node instanceof LIRGenResLowerable) { - ((LIRGenResLowerable) node).generate(this, res); - } else if (node instanceof LIRLowerable) { - ((LIRLowerable) node).generate(this); - } else if (node instanceof ArithmeticLIRLowerable) { - ((ArithmeticLIRLowerable) node).generate(this); - } else { - throw GraalInternalError.shouldNotReachHere("node is not LIRLowerable: " + node); - } - } - - protected void emitPrologue(StructuredGraph graph) { - CallingConvention incomingArguments = gen.getCallingConvention(); - - Value[] params = new Value[incomingArguments.getArgumentCount()]; - for (int i = 0; i < params.length; i++) { - params[i] = toStackKind(incomingArguments.getArgument(i)); - if (ValueUtil.isStackSlot(params[i])) { - StackSlot slot = ValueUtil.asStackSlot(params[i]); - if (slot.isInCallerFrame() && !res.getLIR().hasArgInCallerFrame()) { - res.getLIR().setHasArgInCallerFrame(); - } - } - } - - emitIncomingValues(params); - - for (ParameterNode param : graph.getNodes(ParameterNode.class)) { - Value paramValue = params[param.index()]; - assert paramValue.getKind() == param.getKind().getStackKind(); - setResult(param, gen.emitMove(paramValue)); - } - } - - protected <T extends AbstractBlock<T>> void emitPrologue(ResolvedJavaMethod method, BytecodeParser<T> parser) { - CallingConvention incomingArguments = gen.getCallingConvention(); - - Value[] params = new Value[incomingArguments.getArgumentCount()]; - for (int i = 0; i < params.length; i++) { - params[i] = toStackKind(incomingArguments.getArgument(i)); - if (ValueUtil.isStackSlot(params[i])) { - StackSlot slot = ValueUtil.asStackSlot(params[i]); - if (slot.isInCallerFrame() && !res.getLIR().hasArgInCallerFrame()) { - res.getLIR().setHasArgInCallerFrame(); - } - } - } - - emitIncomingValues(params); - - Signature sig = method.getSignature(); - boolean isStatic = Modifier.isStatic(method.getModifiers()); - for (int i = 0; i < sig.getParameterCount(!isStatic); i++) { - Value paramValue = params[i]; - assert paramValue.getKind() == sig.getParameterKind(i).getStackKind(); - // TODO setResult(param, emitMove(paramValue)); - parser.setParameter(i, gen.emitMove(paramValue)); - } - - // return arguments; - } - - public void emitIncomingValues(Value[] params) { - ((LabelOp) res.getLIR().getLIRforBlock(gen.getCurrentBlock()).get(0)).setIncomingValues(params); - } - - @Override - public void visitReturn(ReturnNode x) { - AllocatableValue operand = ILLEGAL; - if (x.result() != null) { - operand = gen.resultOperandFor(x.result().getKind()); - gen.emitMove(operand, operand(x.result())); - } - gen.emitReturn(operand); - } - - @Override - public void visitMerge(MergeNode x) { - } - - @Override - public void visitEndNode(AbstractEndNode end) { - moveToPhi(end.merge(), end); - } - - /** - * Runtime specific classes can override this to insert a safepoint at the end of a loop. - */ - @Override - public void visitLoopEnd(LoopEndNode x) { - } - - private void moveToPhi(MergeNode merge, AbstractEndNode pred) { - if (traceLevel >= 1) { - TTY.println("MOVE TO PHI from " + pred + " to " + merge); - } - PhiResolver resolver = new PhiResolver(gen); - for (PhiNode phi : merge.phis()) { - if (phi.type() == PhiType.Value) { - ValueNode curVal = phi.valueAt(pred); - resolver.move(operandForPhi(phi), operand(curVal)); - } - } - resolver.dispose(); - - append(new JumpOp(getLIRBlock(merge))); - } - - protected PlatformKind getPhiKind(PhiNode phi) { - return phi.getKind(); - } - - private Value operandForPhi(PhiNode phi) { - assert phi.type() == PhiType.Value : "wrong phi type: " + phi; - Value result = getOperand(phi); - if (result == null) { - // allocate a variable for this phi - Variable newOperand = gen.newVariable(getPhiKind(phi)); - setResult(phi, newOperand); - return newOperand; - } else { - return result; - } - } - - @Override - public void emitIf(IfNode x) { - emitBranch(x.condition(), getLIRBlock(x.trueSuccessor()), getLIRBlock(x.falseSuccessor()), x.probability(x.trueSuccessor())); - } - - public void emitBranch(LogicNode node, LabelRef trueSuccessor, LabelRef falseSuccessor, double trueSuccessorProbability) { - if (node instanceof IsNullNode) { - emitNullCheckBranch((IsNullNode) node, trueSuccessor, falseSuccessor, trueSuccessorProbability); - } else if (node instanceof CompareNode) { - emitCompareBranch((CompareNode) node, trueSuccessor, falseSuccessor, trueSuccessorProbability); - } else if (node instanceof LogicConstantNode) { - emitConstantBranch(((LogicConstantNode) node).getValue(), trueSuccessor, falseSuccessor); - } else if (node instanceof IntegerTestNode) { - emitIntegerTestBranch((IntegerTestNode) node, trueSuccessor, falseSuccessor, trueSuccessorProbability); - } else { - throw GraalInternalError.unimplemented(node.toString()); - } - } - - private void emitNullCheckBranch(IsNullNode node, LabelRef trueSuccessor, LabelRef falseSuccessor, double trueSuccessorProbability) { - gen.emitCompareBranch(operand(node.object()), Constant.NULL_OBJECT, Condition.EQ, false, trueSuccessor, falseSuccessor, trueSuccessorProbability); - } - - public void emitCompareBranch(CompareNode compare, LabelRef trueSuccessor, LabelRef falseSuccessor, double trueSuccessorProbability) { - gen.emitCompareBranch(operand(compare.x()), operand(compare.y()), compare.condition(), compare.unorderedIsTrue(), trueSuccessor, falseSuccessor, trueSuccessorProbability); - } - - public void emitIntegerTestBranch(IntegerTestNode test, LabelRef trueSuccessor, LabelRef falseSuccessor, double trueSuccessorProbability) { - gen.emitIntegerTestBranch(operand(test.x()), operand(test.y()), trueSuccessor, falseSuccessor, trueSuccessorProbability); - } - - public void emitConstantBranch(boolean value, LabelRef trueSuccessorBlock, LabelRef falseSuccessorBlock) { - LabelRef block = value ? trueSuccessorBlock : falseSuccessorBlock; - gen.emitJump(block); - } - - @Override - public void emitConditional(ConditionalNode conditional) { - Value tVal = operand(conditional.trueValue()); - Value fVal = operand(conditional.falseValue()); - setResult(conditional, emitConditional(conditional.condition(), tVal, fVal)); - } - - public Variable emitConditional(LogicNode node, Value trueValue, Value falseValue) { - if (node instanceof IsNullNode) { - IsNullNode isNullNode = (IsNullNode) node; - return gen.emitConditionalMove(operand(isNullNode.object()), Constant.NULL_OBJECT, Condition.EQ, false, trueValue, falseValue); - } else if (node instanceof CompareNode) { - CompareNode compare = (CompareNode) node; - return gen.emitConditionalMove(operand(compare.x()), operand(compare.y()), compare.condition(), compare.unorderedIsTrue(), trueValue, falseValue); - } else if (node instanceof LogicConstantNode) { - return gen.emitMove(((LogicConstantNode) node).getValue() ? trueValue : falseValue); - } else if (node instanceof IntegerTestNode) { - IntegerTestNode test = (IntegerTestNode) node; - return gen.emitIntegerTestMove(operand(test.x()), operand(test.y()), trueValue, falseValue); - } else { - throw GraalInternalError.unimplemented(node.toString()); - } - } - - @Override - public void emitInvoke(Invoke x) { - LoweredCallTargetNode callTarget = (LoweredCallTargetNode) x.callTarget(); - CallingConvention invokeCc = res.getFrameMap().registerConfig.getCallingConvention(callTarget.callType(), x.asNode().stamp().javaType(gen.getMetaAccess()), callTarget.signature(), - gen.target(), false); - res.getFrameMap().callsMethod(invokeCc); - - Value[] parameters = visitInvokeArguments(invokeCc, callTarget.arguments()); - - LabelRef exceptionEdge = null; - if (x instanceof InvokeWithExceptionNode) { - exceptionEdge = getLIRBlock(((InvokeWithExceptionNode) x).exceptionEdge()); - } - LIRFrameState callState = gen.stateWithExceptionEdge(x, exceptionEdge); - - Value result = invokeCc.getReturn(); - if (callTarget instanceof DirectCallTargetNode) { - emitDirectCall((DirectCallTargetNode) callTarget, result, parameters, AllocatableValue.NONE, callState); - } else if (callTarget instanceof IndirectCallTargetNode) { - emitIndirectCall((IndirectCallTargetNode) callTarget, result, parameters, AllocatableValue.NONE, callState); - } else { - throw GraalInternalError.shouldNotReachHere(); - } - - if (isLegal(result)) { - setResult(x.asNode(), gen.emitMove(result)); - } - - if (x instanceof InvokeWithExceptionNode) { - gen.emitJump(getLIRBlock(((InvokeWithExceptionNode) x).next())); - } - } - - protected abstract void emitDirectCall(DirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState); - - protected abstract void emitIndirectCall(IndirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState); - - protected static AllocatableValue toStackKind(AllocatableValue value) { - if (value.getKind().getStackKind() != value.getKind()) { - // We only have stack-kinds in the LIR, so convert the operand kind for values from the - // calling convention. - if (isRegister(value)) { - return asRegister(value).asValue(value.getKind().getStackKind()); - } else if (isStackSlot(value)) { - return StackSlot.get(value.getKind().getStackKind(), asStackSlot(value).getRawOffset(), asStackSlot(value).getRawAddFrameSize()); - } else { - throw GraalInternalError.shouldNotReachHere(); - } - } - return value; - } - - @Override - public Value[] visitInvokeArguments(CallingConvention invokeCc, Collection<ValueNode> arguments) { - // for each argument, load it into the correct location - Value[] result = new Value[arguments.size()]; - int j = 0; - for (ValueNode arg : arguments) { - if (arg != null) { - AllocatableValue operand = toStackKind(invokeCc.getArgument(j)); - gen.emitMove(operand, operand(arg)); - result[j] = operand; - j++; - } else { - throw GraalInternalError.shouldNotReachHere("I thought we no longer have null entries for two-slot types..."); - } - } - return result; - } - - /** - * This method tries to create a switch implementation that is optimal for the given switch. It - * will either generate a sequential if/then/else cascade, a set of range tests or a table - * switch. - * - * If the given switch does not contain int keys, it will always create a sequential - * implementation. - */ - @Override - public void emitSwitch(SwitchNode x) { - assert x.defaultSuccessor() != null; - LabelRef defaultTarget = getLIRBlock(x.defaultSuccessor()); - int keyCount = x.keyCount(); - if (keyCount == 0) { - gen.emitJump(defaultTarget); - } else { - Variable value = gen.load(operand(x.value())); - if (keyCount == 1) { - assert defaultTarget != null; - double probability = x.probability(x.keySuccessor(0)); - gen.emitCompareBranch(gen.load(operand(x.value())), x.keyAt(0), Condition.EQ, false, getLIRBlock(x.keySuccessor(0)), defaultTarget, probability); - } else { - LabelRef[] keyTargets = new LabelRef[keyCount]; - Constant[] keyConstants = new Constant[keyCount]; - double[] keyProbabilities = new double[keyCount]; - for (int i = 0; i < keyCount; i++) { - keyTargets[i] = getLIRBlock(x.keySuccessor(i)); - keyConstants[i] = x.keyAt(i); - keyProbabilities[i] = x.keyProbability(i); - } - if (value.getKind() != Kind.Int || !x.isSorted()) { - // hopefully only a few entries - gen.emitStrategySwitch(new SwitchStrategy.SequentialStrategy(keyProbabilities, keyConstants), value, keyTargets, defaultTarget); - } else { - gen.emitStrategySwitch(keyConstants, keyProbabilities, keyTargets, defaultTarget, value); - } - } - } - } - - public final NodeMap<Value> getNodeOperands() { - assert nodeOperands != null; - return nodeOperands; - } - - public DebugInfoBuilder getDebugInfoBuilder() { - assert debugInfoBuilder != null; - return debugInfoBuilder; - } - - public void emitOverflowCheckBranch(AbstractBeginNode overflowSuccessor, AbstractBeginNode next, double probability) { - gen.emitOverflowCheckBranch(getLIRBlock(overflowSuccessor), getLIRBlock(next), probability); - } - - public final void emitArrayEquals(Kind kind, Variable result, Value array1, Value array2, Value length) { - gen.emitArrayEquals(kind, result, array1, array2, length); - } - - public final Variable newVariable(Kind i) { - return gen.newVariable(i); - } - - public final void emitBitCount(Variable result, Value operand) { - gen.emitBitCount(result, operand); - } - - public final void emitBitScanForward(Variable result, Value operand) { - gen.emitBitScanForward(result, operand); - } - - final void emitBitScanReverse(Variable result, Value operand) { - gen.emitBitScanReverse(result, operand); - } - - @Override - public LIRGenerator getLIRGeneratorTool() { - return gen; - } - - public LIRGenerator getLIRGenerator() { - return gen; - } -}
--- a/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/target/Backend.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/target/Backend.java Mon Mar 31 10:03:32 2014 +0200 @@ -69,7 +69,7 @@ public abstract LIRGenerationResult newLIRGenerationResult(LIR lir, FrameMap frameMap, Object stub); - public abstract NodeLIRGenerator newNodeLIRGenerator(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen); + public abstract NodeLIRBuilder newNodeLIRGenerator(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen); /** * Creates the assembler used to emit the machine code.
--- a/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/target/LIRGenLowerable.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/target/LIRGenLowerable.java Mon Mar 31 10:03:32 2014 +0200 @@ -32,5 +32,5 @@ */ public interface LIRGenLowerable { - void generate(NodeLIRGenerator generator); + void generate(NodeLIRBuilder generator); }
--- a/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/target/LIRGenResLowerable.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/target/LIRGenResLowerable.java Mon Mar 31 10:03:32 2014 +0200 @@ -32,5 +32,5 @@ */ public interface LIRGenResLowerable { - void generate(NodeLIRGeneratorTool generator, LIRGenerationResult genRes); + void generate(NodeLIRBuiderTool generator, LIRGenerationResult genRes); }
--- a/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotBackend.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotBackend.java Mon Mar 31 10:03:32 2014 +0200 @@ -82,8 +82,8 @@ } @Override - public NodeLIRGenerator newNodeLIRGenerator(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen) { - return new AMD64HotSpotNodeLIRGenerator(graph, lirGenRes, lirGen); + public NodeLIRBuilder newNodeLIRGenerator(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen) { + return new AMD64HotSpotNodeLIRBuilder(graph, lirGenRes, lirGen); } /**
--- a/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotMemoryPeephole.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotMemoryPeephole.java Mon Mar 31 10:03:32 2014 +0200 @@ -77,7 +77,7 @@ } } - AMD64HotSpotMemoryPeephole(AMD64NodeLIRGenerator gen) { + AMD64HotSpotMemoryPeephole(AMD64NodeLIRBuilder gen) { super(gen); }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotNodeLIRBuilder.java Mon Mar 31 10:03:32 2014 +0200 @@ -0,0 +1,229 @@ +/* + * Copyright (c) 2012, 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.amd64.AMD64.*; +import static com.oracle.graal.api.code.ValueUtil.*; +import static com.oracle.graal.hotspot.HotSpotBackend.*; + +import java.lang.reflect.*; + +import com.oracle.graal.amd64.*; +import com.oracle.graal.api.code.*; +import com.oracle.graal.api.meta.*; +import com.oracle.graal.asm.*; +import com.oracle.graal.asm.amd64.AMD64Address.Scale; +import com.oracle.graal.compiler.amd64.*; +import com.oracle.graal.compiler.gen.*; +import com.oracle.graal.debug.*; +import com.oracle.graal.graph.*; +import com.oracle.graal.hotspot.*; +import com.oracle.graal.hotspot.amd64.AMD64HotSpotLIRGenerator.SaveRbp; +import com.oracle.graal.hotspot.amd64.AMD64HotSpotMove.CompareAndSwapCompressedOp; +import com.oracle.graal.hotspot.meta.*; +import com.oracle.graal.hotspot.nodes.*; +import com.oracle.graal.lir.*; +import com.oracle.graal.lir.StandardOp.NoOp; +import com.oracle.graal.lir.amd64.*; +import com.oracle.graal.lir.amd64.AMD64ControlFlow.CondMoveOp; +import com.oracle.graal.lir.amd64.AMD64Move.CompareAndSwapOp; +import com.oracle.graal.nodes.*; +import com.oracle.graal.nodes.calc.*; +import com.oracle.graal.nodes.java.*; +import com.oracle.graal.nodes.java.MethodCallTargetNode.InvokeKind; + +/** + * LIR generator specialized for AMD64 HotSpot. + */ +public class AMD64HotSpotNodeLIRBuilder extends AMD64NodeLIRBuilder implements HotSpotNodeLIRBuilder { + + public AMD64HotSpotNodeLIRBuilder(StructuredGraph graph, LIRGenerationResult res, LIRGenerator gen) { + super(graph, res, gen); + memoryPeephole = new AMD64HotSpotMemoryPeephole(this); + } + + private AMD64HotSpotLIRGenerator getGen() { + return (AMD64HotSpotLIRGenerator) gen; + } + + private SaveRbp getSaveRbp() { + return getGen().saveRbp; + } + + private void setSaveRbp(SaveRbp saveRbp) { + getGen().saveRbp = saveRbp; + } + + @Override + protected DebugInfoBuilder createDebugInfoBuilder(NodeMap<Value> nodeOperands) { + HotSpotLockStack lockStack = new HotSpotLockStack(res.getFrameMap(), Kind.Long); + return new HotSpotDebugInfoBuilder(nodeOperands, lockStack); + } + + @Override + protected void emitPrologue(StructuredGraph graph) { + + CallingConvention incomingArguments = gen.getCallingConvention(); + + Value[] params = new Value[incomingArguments.getArgumentCount() + 1]; + for (int i = 0; i < params.length - 1; i++) { + params[i] = toStackKind(incomingArguments.getArgument(i)); + if (isStackSlot(params[i])) { + StackSlot slot = ValueUtil.asStackSlot(params[i]); + if (slot.isInCallerFrame() && !res.getLIR().hasArgInCallerFrame()) { + res.getLIR().setHasArgInCallerFrame(); + } + } + } + params[params.length - 1] = rbp.asValue(Kind.Long); + + emitIncomingValues(params); + + setSaveRbp(((AMD64HotSpotLIRGenerator) gen).new SaveRbp(new NoOp(gen.getCurrentBlock(), res.getLIR().getLIRforBlock(gen.getCurrentBlock()).size()))); + append(getSaveRbp().placeholder); + + for (ParameterNode param : graph.getNodes(ParameterNode.class)) { + Value paramValue = params[param.index()]; + assert paramValue.getKind() == param.getKind().getStackKind(); + setResult(param, gen.emitMove(paramValue)); + } + } + + @Override + public void visitSafepointNode(SafepointNode i) { + LIRFrameState info = gen.state(i); + append(new AMD64HotSpotSafepointOp(info, getGen().config, this)); + } + + @Override + protected void emitDirectCall(DirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) { + InvokeKind invokeKind = ((HotSpotDirectCallTargetNode) callTarget).invokeKind(); + if (invokeKind == InvokeKind.Interface || invokeKind == InvokeKind.Virtual) { + append(new AMD64HotspotDirectVirtualCallOp(callTarget.target(), result, parameters, temps, callState, invokeKind)); + } else { + assert invokeKind == InvokeKind.Static || invokeKind == InvokeKind.Special; + HotSpotResolvedJavaMethod resolvedMethod = (HotSpotResolvedJavaMethod) callTarget.target(); + assert !Modifier.isAbstract(resolvedMethod.getModifiers()) : "Cannot make direct call to abstract method."; + Constant metaspaceMethod = resolvedMethod.getMetaspaceMethodConstant(); + append(new AMD64HotspotDirectStaticCallOp(callTarget.target(), result, parameters, temps, callState, invokeKind, metaspaceMethod)); + } + } + + @Override + protected void emitIndirectCall(IndirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) { + if (callTarget instanceof HotSpotIndirectCallTargetNode) { + AllocatableValue metaspaceMethod = AMD64.rbx.asValue(); + gen.emitMove(metaspaceMethod, operand(((HotSpotIndirectCallTargetNode) callTarget).metaspaceMethod())); + AllocatableValue targetAddress = AMD64.rax.asValue(); + gen.emitMove(targetAddress, operand(callTarget.computedAddress())); + append(new AMD64IndirectCallOp(callTarget.target(), result, parameters, temps, metaspaceMethod, targetAddress, callState)); + } else { + super.emitIndirectCall(callTarget, result, parameters, temps, callState); + } + } + + @Override + public void emitPatchReturnAddress(ValueNode address) { + append(new AMD64HotSpotPatchReturnAddressOp(gen.load(operand(address)))); + } + + @Override + public void emitJumpToExceptionHandlerInCaller(ValueNode handlerInCallerPc, ValueNode exception, ValueNode exceptionPc) { + Variable handler = gen.load(operand(handlerInCallerPc)); + ForeignCallLinkage linkage = gen.getForeignCalls().lookupForeignCall(EXCEPTION_HANDLER_IN_CALLER); + CallingConvention outgoingCc = linkage.getOutgoingCallingConvention(); + assert outgoingCc.getArgumentCount() == 2; + RegisterValue exceptionFixed = (RegisterValue) outgoingCc.getArgument(0); + RegisterValue exceptionPcFixed = (RegisterValue) outgoingCc.getArgument(1); + gen.emitMove(exceptionFixed, operand(exception)); + gen.emitMove(exceptionPcFixed, operand(exceptionPc)); + Register thread = getGen().getProviders().getRegisters().getThreadRegister(); + AMD64HotSpotJumpToExceptionHandlerInCallerOp op = new AMD64HotSpotJumpToExceptionHandlerInCallerOp(handler, exceptionFixed, exceptionPcFixed, getGen().config.threadIsMethodHandleReturnOffset, + thread); + append(op); + } + + @Override + public void visitInfopointNode(InfopointNode i) { + if (i.getState() != null && i.getState().bci == FrameState.AFTER_BCI) { + Debug.log("Ignoring InfopointNode for AFTER_BCI"); + } else { + super.visitInfopointNode(i); + } + } + + public void emitPrefetchAllocate(ValueNode address, ValueNode distance) { + AMD64AddressValue addr = getGen().emitAddress(operand(address), 0, gen.loadNonConst(operand(distance)), 1); + append(new AMD64PrefetchOp(addr, getGen().config.allocatePrefetchInstr)); + } + + @Override + public void visitDirectCompareAndSwap(DirectCompareAndSwapNode x) { + Kind kind = x.newValue().getKind(); + assert kind == x.expectedValue().getKind(); + + Value expected = gen.loadNonConst(operand(x.expectedValue())); + Variable newVal = gen.load(operand(x.newValue())); + + int disp = 0; + AMD64AddressValue address; + Value index = operand(x.offset()); + if (ValueUtil.isConstant(index) && NumUtil.isInt(ValueUtil.asConstant(index).asLong() + disp)) { + assert !gen.getCodeCache().needsDataPatch(asConstant(index)); + disp += (int) ValueUtil.asConstant(index).asLong(); + address = new AMD64AddressValue(kind, gen.load(operand(x.object())), disp); + } else { + address = new AMD64AddressValue(kind, gen.load(operand(x.object())), gen.load(index), Scale.Times1, disp); + } + + RegisterValue raxLocal = AMD64.rax.asValue(kind); + gen.emitMove(raxLocal, expected); + append(new CompareAndSwapOp(raxLocal, address, raxLocal, newVal)); + + Variable result = newVariable(x.getKind()); + gen.emitMove(result, raxLocal); + setResult(x, result); + } + + @Override + public void visitCompareAndSwap(LoweredCompareAndSwapNode node, Value address) { + Kind kind = node.getNewValue().getKind(); + assert kind == node.getExpectedValue().getKind(); + Value expected = gen.loadNonConst(operand(node.getExpectedValue())); + Variable newValue = gen.load(operand(node.getNewValue())); + AMD64AddressValue addressValue = getGen().asAddressValue(address); + RegisterValue raxRes = AMD64.rax.asValue(kind); + gen.emitMove(raxRes, expected); + if (getGen().config.useCompressedOops && node.isCompressible()) { + Variable scratch = newVariable(Kind.Long); + Register heapBaseReg = getGen().getProviders().getRegisters().getHeapBaseRegister(); + append(new CompareAndSwapCompressedOp(raxRes, addressValue, raxRes, newValue, scratch, getGen().config.getOopEncoding(), heapBaseReg)); + } else { + append(new CompareAndSwapOp(raxRes, addressValue, raxRes, newValue)); + } + Variable result = newVariable(node.getKind()); + append(new CondMoveOp(result, Condition.EQ, gen.load(Constant.TRUE), Constant.FALSE)); + setResult(node, result); + } + +}
--- a/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotNodeLIRGenerator.java Fri Mar 28 14:28:27 2014 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,229 +0,0 @@ -/* - * Copyright (c) 2012, 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.amd64.AMD64.*; -import static com.oracle.graal.api.code.ValueUtil.*; -import static com.oracle.graal.hotspot.HotSpotBackend.*; - -import java.lang.reflect.*; - -import com.oracle.graal.amd64.*; -import com.oracle.graal.api.code.*; -import com.oracle.graal.api.meta.*; -import com.oracle.graal.asm.*; -import com.oracle.graal.asm.amd64.AMD64Address.Scale; -import com.oracle.graal.compiler.amd64.*; -import com.oracle.graal.compiler.gen.*; -import com.oracle.graal.debug.*; -import com.oracle.graal.graph.*; -import com.oracle.graal.hotspot.*; -import com.oracle.graal.hotspot.amd64.AMD64HotSpotLIRGenerator.SaveRbp; -import com.oracle.graal.hotspot.amd64.AMD64HotSpotMove.CompareAndSwapCompressedOp; -import com.oracle.graal.hotspot.meta.*; -import com.oracle.graal.hotspot.nodes.*; -import com.oracle.graal.lir.*; -import com.oracle.graal.lir.StandardOp.NoOp; -import com.oracle.graal.lir.amd64.*; -import com.oracle.graal.lir.amd64.AMD64ControlFlow.CondMoveOp; -import com.oracle.graal.lir.amd64.AMD64Move.CompareAndSwapOp; -import com.oracle.graal.nodes.*; -import com.oracle.graal.nodes.calc.*; -import com.oracle.graal.nodes.java.*; -import com.oracle.graal.nodes.java.MethodCallTargetNode.InvokeKind; - -/** - * LIR generator specialized for AMD64 HotSpot. - */ -public class AMD64HotSpotNodeLIRGenerator extends AMD64NodeLIRGenerator implements HotSpotNodeLIRGenerator { - - public AMD64HotSpotNodeLIRGenerator(StructuredGraph graph, LIRGenerationResult res, LIRGenerator gen) { - super(graph, res, gen); - memoryPeephole = new AMD64HotSpotMemoryPeephole(this); - } - - private AMD64HotSpotLIRGenerator getGen() { - return (AMD64HotSpotLIRGenerator) gen; - } - - private SaveRbp getSaveRbp() { - return getGen().saveRbp; - } - - private void setSaveRbp(SaveRbp saveRbp) { - getGen().saveRbp = saveRbp; - } - - @Override - protected DebugInfoBuilder createDebugInfoBuilder(NodeMap<Value> nodeOperands) { - HotSpotLockStack lockStack = new HotSpotLockStack(res.getFrameMap(), Kind.Long); - return new HotSpotDebugInfoBuilder(nodeOperands, lockStack); - } - - @Override - protected void emitPrologue(StructuredGraph graph) { - - CallingConvention incomingArguments = gen.getCallingConvention(); - - Value[] params = new Value[incomingArguments.getArgumentCount() + 1]; - for (int i = 0; i < params.length - 1; i++) { - params[i] = toStackKind(incomingArguments.getArgument(i)); - if (isStackSlot(params[i])) { - StackSlot slot = ValueUtil.asStackSlot(params[i]); - if (slot.isInCallerFrame() && !res.getLIR().hasArgInCallerFrame()) { - res.getLIR().setHasArgInCallerFrame(); - } - } - } - params[params.length - 1] = rbp.asValue(Kind.Long); - - emitIncomingValues(params); - - setSaveRbp(((AMD64HotSpotLIRGenerator) gen).new SaveRbp(new NoOp(gen.getCurrentBlock(), res.getLIR().getLIRforBlock(gen.getCurrentBlock()).size()))); - append(getSaveRbp().placeholder); - - for (ParameterNode param : graph.getNodes(ParameterNode.class)) { - Value paramValue = params[param.index()]; - assert paramValue.getKind() == param.getKind().getStackKind(); - setResult(param, gen.emitMove(paramValue)); - } - } - - @Override - public void visitSafepointNode(SafepointNode i) { - LIRFrameState info = gen.state(i); - append(new AMD64HotSpotSafepointOp(info, getGen().config, this)); - } - - @Override - protected void emitDirectCall(DirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) { - InvokeKind invokeKind = ((HotSpotDirectCallTargetNode) callTarget).invokeKind(); - if (invokeKind == InvokeKind.Interface || invokeKind == InvokeKind.Virtual) { - append(new AMD64HotspotDirectVirtualCallOp(callTarget.target(), result, parameters, temps, callState, invokeKind)); - } else { - assert invokeKind == InvokeKind.Static || invokeKind == InvokeKind.Special; - HotSpotResolvedJavaMethod resolvedMethod = (HotSpotResolvedJavaMethod) callTarget.target(); - assert !Modifier.isAbstract(resolvedMethod.getModifiers()) : "Cannot make direct call to abstract method."; - Constant metaspaceMethod = resolvedMethod.getMetaspaceMethodConstant(); - append(new AMD64HotspotDirectStaticCallOp(callTarget.target(), result, parameters, temps, callState, invokeKind, metaspaceMethod)); - } - } - - @Override - protected void emitIndirectCall(IndirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) { - if (callTarget instanceof HotSpotIndirectCallTargetNode) { - AllocatableValue metaspaceMethod = AMD64.rbx.asValue(); - gen.emitMove(metaspaceMethod, operand(((HotSpotIndirectCallTargetNode) callTarget).metaspaceMethod())); - AllocatableValue targetAddress = AMD64.rax.asValue(); - gen.emitMove(targetAddress, operand(callTarget.computedAddress())); - append(new AMD64IndirectCallOp(callTarget.target(), result, parameters, temps, metaspaceMethod, targetAddress, callState)); - } else { - super.emitIndirectCall(callTarget, result, parameters, temps, callState); - } - } - - @Override - public void emitPatchReturnAddress(ValueNode address) { - append(new AMD64HotSpotPatchReturnAddressOp(gen.load(operand(address)))); - } - - @Override - public void emitJumpToExceptionHandlerInCaller(ValueNode handlerInCallerPc, ValueNode exception, ValueNode exceptionPc) { - Variable handler = gen.load(operand(handlerInCallerPc)); - ForeignCallLinkage linkage = gen.getForeignCalls().lookupForeignCall(EXCEPTION_HANDLER_IN_CALLER); - CallingConvention outgoingCc = linkage.getOutgoingCallingConvention(); - assert outgoingCc.getArgumentCount() == 2; - RegisterValue exceptionFixed = (RegisterValue) outgoingCc.getArgument(0); - RegisterValue exceptionPcFixed = (RegisterValue) outgoingCc.getArgument(1); - gen.emitMove(exceptionFixed, operand(exception)); - gen.emitMove(exceptionPcFixed, operand(exceptionPc)); - Register thread = getGen().getProviders().getRegisters().getThreadRegister(); - AMD64HotSpotJumpToExceptionHandlerInCallerOp op = new AMD64HotSpotJumpToExceptionHandlerInCallerOp(handler, exceptionFixed, exceptionPcFixed, getGen().config.threadIsMethodHandleReturnOffset, - thread); - append(op); - } - - @Override - public void visitInfopointNode(InfopointNode i) { - if (i.getState() != null && i.getState().bci == FrameState.AFTER_BCI) { - Debug.log("Ignoring InfopointNode for AFTER_BCI"); - } else { - super.visitInfopointNode(i); - } - } - - public void emitPrefetchAllocate(ValueNode address, ValueNode distance) { - AMD64AddressValue addr = getGen().emitAddress(operand(address), 0, gen.loadNonConst(operand(distance)), 1); - append(new AMD64PrefetchOp(addr, getGen().config.allocatePrefetchInstr)); - } - - @Override - public void visitDirectCompareAndSwap(DirectCompareAndSwapNode x) { - Kind kind = x.newValue().getKind(); - assert kind == x.expectedValue().getKind(); - - Value expected = gen.loadNonConst(operand(x.expectedValue())); - Variable newVal = gen.load(operand(x.newValue())); - - int disp = 0; - AMD64AddressValue address; - Value index = operand(x.offset()); - if (ValueUtil.isConstant(index) && NumUtil.isInt(ValueUtil.asConstant(index).asLong() + disp)) { - assert !gen.getCodeCache().needsDataPatch(asConstant(index)); - disp += (int) ValueUtil.asConstant(index).asLong(); - address = new AMD64AddressValue(kind, gen.load(operand(x.object())), disp); - } else { - address = new AMD64AddressValue(kind, gen.load(operand(x.object())), gen.load(index), Scale.Times1, disp); - } - - RegisterValue raxLocal = AMD64.rax.asValue(kind); - gen.emitMove(raxLocal, expected); - append(new CompareAndSwapOp(raxLocal, address, raxLocal, newVal)); - - Variable result = newVariable(x.getKind()); - gen.emitMove(result, raxLocal); - setResult(x, result); - } - - @Override - public void visitCompareAndSwap(LoweredCompareAndSwapNode node, Value address) { - Kind kind = node.getNewValue().getKind(); - assert kind == node.getExpectedValue().getKind(); - Value expected = gen.loadNonConst(operand(node.getExpectedValue())); - Variable newValue = gen.load(operand(node.getNewValue())); - AMD64AddressValue addressValue = getGen().asAddressValue(address); - RegisterValue raxRes = AMD64.rax.asValue(kind); - gen.emitMove(raxRes, expected); - if (getGen().config.useCompressedOops && node.isCompressible()) { - Variable scratch = newVariable(Kind.Long); - Register heapBaseReg = getGen().getProviders().getRegisters().getHeapBaseRegister(); - append(new CompareAndSwapCompressedOp(raxRes, addressValue, raxRes, newValue, scratch, getGen().config.getOopEncoding(), heapBaseReg)); - } else { - append(new CompareAndSwapOp(raxRes, addressValue, raxRes, newValue)); - } - Variable result = newVariable(node.getKind()); - append(new CondMoveOp(result, Condition.EQ, gen.load(Constant.TRUE), Constant.FALSE)); - setResult(node, result); - } - -}
--- a/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotSafepointOp.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotSafepointOp.java Mon Mar 31 10:03:32 2014 +0200 @@ -47,7 +47,7 @@ private final HotSpotVMConfig config; - public AMD64HotSpotSafepointOp(LIRFrameState state, HotSpotVMConfig config, NodeLIRGeneratorTool tool) { + public AMD64HotSpotSafepointOp(LIRFrameState state, HotSpotVMConfig config, NodeLIRBuiderTool tool) { this.state = state; this.config = config; if (isPollingPageFar(config) || ImmutableCode.getValue()) {
--- a/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64RawNativeCallNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64RawNativeCallNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -44,8 +44,8 @@ } @Override - public void generate(NodeLIRGenerator generator) { - AMD64NodeLIRGenerator gen = (AMD64NodeLIRGenerator) generator; + public void generate(NodeLIRBuilder generator) { + AMD64NodeLIRBuilder gen = (AMD64NodeLIRBuilder) generator; Value[] parameter = new Value[args.count()]; JavaType[] parameterTypes = new JavaType[args.count()]; for (int i = 0; i < args.count(); i++) {
--- a/graal/com.oracle.graal.hotspot.hsail/src/com/oracle/graal/hotspot/hsail/HSAILHotSpotBackend.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot.hsail/src/com/oracle/graal/hotspot/hsail/HSAILHotSpotBackend.java Mon Mar 31 10:03:32 2014 +0200 @@ -375,8 +375,8 @@ } @Override - public NodeLIRGenerator newNodeLIRGenerator(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen) { - return new HSAILHotSpotNodeLIRGenerator(graph, lirGenRes, lirGen); + public NodeLIRBuilder newNodeLIRGenerator(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen) { + return new HSAILHotSpotNodeLIRBuilder(graph, lirGenRes, lirGen); } class HotSpotFrameContext implements FrameContext {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.hotspot.hsail/src/com/oracle/graal/hotspot/hsail/HSAILHotSpotNodeLIRBuilder.java Mon Mar 31 10:03:32 2014 +0200 @@ -0,0 +1,110 @@ +/* + * Copyright (c) 2013, 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.hsail; + +import sun.misc.*; + +import com.oracle.graal.api.meta.*; +import com.oracle.graal.compiler.gen.*; +import com.oracle.graal.compiler.hsail.*; +import com.oracle.graal.graph.*; +import com.oracle.graal.hotspot.HotSpotVMConfig.CompressEncoding; +import com.oracle.graal.hotspot.nodes.*; +import com.oracle.graal.lir.*; +import com.oracle.graal.lir.hsail.*; +import com.oracle.graal.lir.hsail.HSAILControlFlow.CondMoveOp; +import com.oracle.graal.lir.hsail.HSAILMove.CompareAndSwapCompressedOp; +import com.oracle.graal.lir.hsail.HSAILMove.CompareAndSwapOp; +import com.oracle.graal.nodes.*; +import com.oracle.graal.nodes.calc.*; +import com.oracle.graal.nodes.java.*; + +/** + * The HotSpot specific portion of the HSAIL LIR generator. + */ +public class HSAILHotSpotNodeLIRBuilder extends HSAILNodeLIRBuilder { + + public HSAILHotSpotNodeLIRBuilder(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen) { + super(graph, lirGenRes, lirGen); + } + + private HSAILHotSpotLIRGenerator getGen() { + return (HSAILHotSpotLIRGenerator) gen; + } + + /** + * Appends either a {@link CompareAndSwapOp} or a {@link CompareAndSwapCompressedOp} depending + * on whether the memory location of a given {@link LoweredCompareAndSwapNode} contains a + * compressed oop. For the {@link CompareAndSwapCompressedOp} case, allocates a number of + * scratch registers. The result {@link #operand(ValueNode) operand} for {@code node} complies + * with the API for {@link Unsafe#compareAndSwapInt(Object, long, int, int)}. + * + * @param address the memory location targeted by the operation + */ + @Override + public void visitCompareAndSwap(LoweredCompareAndSwapNode node, Value address) { + Kind kind = node.getNewValue().getKind(); + assert kind == node.getExpectedValue().getKind(); + Variable expected = gen.load(operand(node.getExpectedValue())); + Variable newValue = gen.load(operand(node.getNewValue())); + HSAILAddressValue addressValue = getGen().asAddressValue(address); + Variable casResult = newVariable(kind); + if (getGen().config.useCompressedOops && node.isCompressible()) { + // make 64-bit scratch variables for expected and new + Variable scratchExpected64 = newVariable(Kind.Long); + Variable scratchNewValue64 = newVariable(Kind.Long); + // make 32-bit scratch variables for expected and new and result + Variable scratchExpected32 = newVariable(Kind.Int); + Variable scratchNewValue32 = newVariable(Kind.Int); + Variable scratchCasResult32 = newVariable(Kind.Int); + append(new CompareAndSwapCompressedOp(casResult, addressValue, expected, newValue, scratchExpected64, scratchNewValue64, scratchExpected32, scratchNewValue32, scratchCasResult32, + getGen().getNarrowOopBase(), getGen().getNarrowOopShift(), getGen().getLogMinObjectAlignment())); + } else { + append(new CompareAndSwapOp(casResult, addressValue, expected, newValue)); + } + Variable nodeResult = newVariable(node.getKind()); + append(new CondMoveOp(HSAILLIRGenerator.mapKindToCompareOp(kind), casResult, expected, nodeResult, Condition.EQ, Constant.INT_1, Constant.INT_0)); + setResult(node, nodeResult); + } + + @Override + protected void emitNode(ValueNode node) { + if (node instanceof CurrentJavaThreadNode) { + throw new GraalInternalError("HSAILHotSpotLIRGenerator cannot handle node: " + node); + } else { + super.emitNode(node); + } + } + + /** + * @return a compressed version of the incoming constant lifted from AMD64HotSpotLIRGenerator + */ + protected static Constant compress(Constant c, CompressEncoding encoding) { + if (c.getKind() == Kind.Long) { + return Constant.forIntegerKind(Kind.Int, (int) (((c.asLong() - encoding.base) >> encoding.shift) & 0xffffffffL), c.getPrimitiveAnnotation()); + } else { + throw GraalInternalError.shouldNotReachHere(); + } + } +}
--- a/graal/com.oracle.graal.hotspot.hsail/src/com/oracle/graal/hotspot/hsail/HSAILHotSpotNodeLIRGenerator.java Fri Mar 28 14:28:27 2014 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,110 +0,0 @@ -/* - * Copyright (c) 2013, 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.hsail; - -import sun.misc.*; - -import com.oracle.graal.api.meta.*; -import com.oracle.graal.compiler.gen.*; -import com.oracle.graal.compiler.hsail.*; -import com.oracle.graal.graph.*; -import com.oracle.graal.hotspot.HotSpotVMConfig.CompressEncoding; -import com.oracle.graal.hotspot.nodes.*; -import com.oracle.graal.lir.*; -import com.oracle.graal.lir.hsail.*; -import com.oracle.graal.lir.hsail.HSAILControlFlow.CondMoveOp; -import com.oracle.graal.lir.hsail.HSAILMove.CompareAndSwapCompressedOp; -import com.oracle.graal.lir.hsail.HSAILMove.CompareAndSwapOp; -import com.oracle.graal.nodes.*; -import com.oracle.graal.nodes.calc.*; -import com.oracle.graal.nodes.java.*; - -/** - * The HotSpot specific portion of the HSAIL LIR generator. - */ -public class HSAILHotSpotNodeLIRGenerator extends HSAILNodeLIRGenerator { - - public HSAILHotSpotNodeLIRGenerator(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen) { - super(graph, lirGenRes, lirGen); - } - - private HSAILHotSpotLIRGenerator getGen() { - return (HSAILHotSpotLIRGenerator) gen; - } - - /** - * Appends either a {@link CompareAndSwapOp} or a {@link CompareAndSwapCompressedOp} depending - * on whether the memory location of a given {@link LoweredCompareAndSwapNode} contains a - * compressed oop. For the {@link CompareAndSwapCompressedOp} case, allocates a number of - * scratch registers. The result {@link #operand(ValueNode) operand} for {@code node} complies - * with the API for {@link Unsafe#compareAndSwapInt(Object, long, int, int)}. - * - * @param address the memory location targeted by the operation - */ - @Override - public void visitCompareAndSwap(LoweredCompareAndSwapNode node, Value address) { - Kind kind = node.getNewValue().getKind(); - assert kind == node.getExpectedValue().getKind(); - Variable expected = gen.load(operand(node.getExpectedValue())); - Variable newValue = gen.load(operand(node.getNewValue())); - HSAILAddressValue addressValue = getGen().asAddressValue(address); - Variable casResult = newVariable(kind); - if (getGen().config.useCompressedOops && node.isCompressible()) { - // make 64-bit scratch variables for expected and new - Variable scratchExpected64 = newVariable(Kind.Long); - Variable scratchNewValue64 = newVariable(Kind.Long); - // make 32-bit scratch variables for expected and new and result - Variable scratchExpected32 = newVariable(Kind.Int); - Variable scratchNewValue32 = newVariable(Kind.Int); - Variable scratchCasResult32 = newVariable(Kind.Int); - append(new CompareAndSwapCompressedOp(casResult, addressValue, expected, newValue, scratchExpected64, scratchNewValue64, scratchExpected32, scratchNewValue32, scratchCasResult32, - getGen().getNarrowOopBase(), getGen().getNarrowOopShift(), getGen().getLogMinObjectAlignment())); - } else { - append(new CompareAndSwapOp(casResult, addressValue, expected, newValue)); - } - Variable nodeResult = newVariable(node.getKind()); - append(new CondMoveOp(HSAILLIRGenerator.mapKindToCompareOp(kind), casResult, expected, nodeResult, Condition.EQ, Constant.INT_1, Constant.INT_0)); - setResult(node, nodeResult); - } - - @Override - protected void emitNode(ValueNode node) { - if (node instanceof CurrentJavaThreadNode) { - throw new GraalInternalError("HSAILHotSpotLIRGenerator cannot handle node: " + node); - } else { - super.emitNode(node); - } - } - - /** - * @return a compressed version of the incoming constant lifted from AMD64HotSpotLIRGenerator - */ - protected static Constant compress(Constant c, CompressEncoding encoding) { - if (c.getKind() == Kind.Long) { - return Constant.forIntegerKind(Kind.Int, (int) (((c.asLong() - encoding.base) >> encoding.shift) & 0xffffffffL), c.getPrimitiveAnnotation()); - } else { - throw GraalInternalError.shouldNotReachHere(); - } - } -}
--- a/graal/com.oracle.graal.hotspot.ptx/src/com/oracle/graal/hotspot/ptx/PTXHotSpotBackend.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot.ptx/src/com/oracle/graal/hotspot/ptx/PTXHotSpotBackend.java Mon Mar 31 10:03:32 2014 +0200 @@ -358,8 +358,8 @@ } @Override - public NodeLIRGenerator newNodeLIRGenerator(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen) { - return new PTXHotSpotNodeLIRGenerator(graph, lirGenRes, lirGen); + public NodeLIRBuilder newNodeLIRGenerator(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen) { + return new PTXHotSpotNodeLIRBuilder(graph, lirGenRes, lirGen); } private static void emitKernelEntry(CompilationResultBuilder crb, LIR lir, ResolvedJavaMethod codeCacheOwner) {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.hotspot.ptx/src/com/oracle/graal/hotspot/ptx/PTXHotSpotNodeLIRBuilder.java Mon Mar 31 10:03:32 2014 +0200 @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2014, 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.ptx; + +import com.oracle.graal.compiler.gen.*; +import com.oracle.graal.compiler.ptx.*; +import com.oracle.graal.graph.*; +import com.oracle.graal.hotspot.*; +import com.oracle.graal.hotspot.nodes.*; +import com.oracle.graal.nodes.*; + +/** + * LIR generator specialized for PTX HotSpot. + */ +public class PTXHotSpotNodeLIRBuilder extends PTXNodeLIRBuilder implements HotSpotNodeLIRBuilder { + + protected PTXHotSpotNodeLIRBuilder(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen) { + super(graph, lirGenRes, lirGen); + } + + public void emitPrefetchAllocate(ValueNode address, ValueNode distance) { + // nop + } + + public void emitPatchReturnAddress(ValueNode address) { + throw GraalInternalError.unimplemented(); + } + + public void emitJumpToExceptionHandlerInCaller(ValueNode handlerInCallerPc, ValueNode exception, ValueNode exceptionPc) { + throw GraalInternalError.unimplemented(); + } + + public void visitDirectCompareAndSwap(DirectCompareAndSwapNode x) { + throw GraalInternalError.unimplemented(); + } + +}
--- a/graal/com.oracle.graal.hotspot.ptx/src/com/oracle/graal/hotspot/ptx/PTXHotSpotNodeLIRGenerator.java Fri Mar 28 14:28:27 2014 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,58 +0,0 @@ -/* - * Copyright (c) 2014, 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.ptx; - -import com.oracle.graal.compiler.gen.*; -import com.oracle.graal.compiler.ptx.*; -import com.oracle.graal.graph.*; -import com.oracle.graal.hotspot.*; -import com.oracle.graal.hotspot.nodes.*; -import com.oracle.graal.nodes.*; - -/** - * LIR generator specialized for PTX HotSpot. - */ -public class PTXHotSpotNodeLIRGenerator extends PTXNodeLIRGenerator implements HotSpotNodeLIRGenerator { - - protected PTXHotSpotNodeLIRGenerator(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen) { - super(graph, lirGenRes, lirGen); - } - - public void emitPrefetchAllocate(ValueNode address, ValueNode distance) { - // nop - } - - public void emitPatchReturnAddress(ValueNode address) { - throw GraalInternalError.unimplemented(); - } - - public void emitJumpToExceptionHandlerInCaller(ValueNode handlerInCallerPc, ValueNode exception, ValueNode exceptionPc) { - throw GraalInternalError.unimplemented(); - } - - public void visitDirectCompareAndSwap(DirectCompareAndSwapNode x) { - throw GraalInternalError.unimplemented(); - } - -}
--- a/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotBackend.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotBackend.java Mon Mar 31 10:03:32 2014 +0200 @@ -84,8 +84,8 @@ } @Override - public NodeLIRGenerator newNodeLIRGenerator(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen) { - return new SPARCHotSpotNodeLIRGenerator(graph, lirGenRes, lirGen); + public NodeLIRBuilder newNodeLIRGenerator(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen) { + return new SPARCHotSpotNodeLIRBuilder(graph, lirGenRes, lirGen); } /**
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotNodeLIRBuilder.java Mon Mar 31 10:03:32 2014 +0200 @@ -0,0 +1,144 @@ +/* + * Copyright (c) 2013, 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.sparc; + +import static com.oracle.graal.api.code.ValueUtil.*; +import static com.oracle.graal.hotspot.HotSpotBackend.*; +import static com.oracle.graal.sparc.SPARC.*; + +import java.lang.reflect.*; + +import com.oracle.graal.api.code.*; +import com.oracle.graal.api.meta.*; +import com.oracle.graal.compiler.gen.*; +import com.oracle.graal.compiler.sparc.*; +import com.oracle.graal.graph.*; +import com.oracle.graal.hotspot.*; +import com.oracle.graal.hotspot.meta.*; +import com.oracle.graal.hotspot.nodes.*; +import com.oracle.graal.lir.*; +import com.oracle.graal.lir.sparc.*; +import com.oracle.graal.lir.sparc.SPARCMove.CompareAndSwapOp; +import com.oracle.graal.nodes.*; +import com.oracle.graal.nodes.java.MethodCallTargetNode.InvokeKind; + +public class SPARCHotSpotNodeLIRBuilder extends SPARCNodeLIRBuilder implements HotSpotNodeLIRBuilder { + + public SPARCHotSpotNodeLIRBuilder(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen) { + super(graph, lirGenRes, lirGen); + } + + @Override + protected DebugInfoBuilder createDebugInfoBuilder(NodeMap<Value> nodeOperands) { + HotSpotLockStack lockStack = new HotSpotLockStack(res.getFrameMap(), Kind.Long); + return new HotSpotDebugInfoBuilder(nodeOperands, lockStack); + } + + private SPARCHotSpotLIRGenerator getGen() { + return (SPARCHotSpotLIRGenerator) gen; + } + + @Override + public void visitSafepointNode(SafepointNode i) { + LIRFrameState info = gen.state(i); + append(new SPARCHotSpotSafepointOp(info, getGen().config, gen)); + } + + @Override + public void visitDirectCompareAndSwap(DirectCompareAndSwapNode x) { + Kind kind = x.newValue().getKind(); + assert kind == x.expectedValue().getKind(); + + Variable address = gen.load(operand(x.object())); + Value offset = operand(x.offset()); + Variable cmpValue = (Variable) gen.loadNonConst(operand(x.expectedValue())); + Variable newValue = gen.load(operand(x.newValue())); + + if (ValueUtil.isConstant(offset)) { + assert !gen.getCodeCache().needsDataPatch(asConstant(offset)); + Variable longAddress = newVariable(Kind.Long); + gen.emitMove(longAddress, address); + address = getGen().emitAdd(longAddress, asConstant(offset)); + } else { + if (isLegal(offset)) { + address = getGen().emitAdd(address, offset); + } + } + + append(new CompareAndSwapOp(address, cmpValue, newValue)); + + Variable result = newVariable(x.getKind()); + gen.emitMove(result, newValue); + setResult(x, result); + } + + @Override + protected void emitDirectCall(DirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) { + InvokeKind invokeKind = ((HotSpotDirectCallTargetNode) callTarget).invokeKind(); + if (invokeKind == InvokeKind.Interface || invokeKind == InvokeKind.Virtual) { + append(new SPARCHotspotDirectVirtualCallOp(callTarget.target(), result, parameters, temps, callState, invokeKind)); + } else { + assert invokeKind == InvokeKind.Static || invokeKind == InvokeKind.Special; + HotSpotResolvedJavaMethod resolvedMethod = (HotSpotResolvedJavaMethod) callTarget.target(); + assert !Modifier.isAbstract(resolvedMethod.getModifiers()) : "Cannot make direct call to abstract method."; + Constant metaspaceMethod = resolvedMethod.getMetaspaceMethodConstant(); + append(new SPARCHotspotDirectStaticCallOp(callTarget.target(), result, parameters, temps, callState, invokeKind, metaspaceMethod)); + } + } + + @Override + protected void emitIndirectCall(IndirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) { + AllocatableValue metaspaceMethod = g5.asValue(); + gen.emitMove(metaspaceMethod, operand(((HotSpotIndirectCallTargetNode) callTarget).metaspaceMethod())); + AllocatableValue targetAddress = g3.asValue(); + gen.emitMove(targetAddress, operand(callTarget.computedAddress())); + append(new SPARCIndirectCallOp(callTarget.target(), result, parameters, temps, metaspaceMethod, targetAddress, callState)); + } + + @Override + public void emitPatchReturnAddress(ValueNode address) { + append(new SPARCHotSpotPatchReturnAddressOp(gen.load(operand(address)))); + } + + @Override + public void emitJumpToExceptionHandlerInCaller(ValueNode handlerInCallerPc, ValueNode exception, ValueNode exceptionPc) { + Variable handler = gen.load(operand(handlerInCallerPc)); + ForeignCallLinkage linkage = gen.getForeignCalls().lookupForeignCall(EXCEPTION_HANDLER_IN_CALLER); + CallingConvention linkageCc = linkage.getOutgoingCallingConvention(); + assert linkageCc.getArgumentCount() == 2; + RegisterValue exceptionFixed = (RegisterValue) linkageCc.getArgument(0); + RegisterValue exceptionPcFixed = (RegisterValue) linkageCc.getArgument(1); + gen.emitMove(exceptionFixed, operand(exception)); + gen.emitMove(exceptionPcFixed, operand(exceptionPc)); + Register thread = getGen().getProviders().getRegisters().getThreadRegister(); + SPARCHotSpotJumpToExceptionHandlerInCallerOp op = new SPARCHotSpotJumpToExceptionHandlerInCallerOp(handler, exceptionFixed, exceptionPcFixed, getGen().config.threadIsMethodHandleReturnOffset, + thread); + append(op); + } + + public void emitPrefetchAllocate(ValueNode address, ValueNode distance) { + SPARCAddressValue addr = getGen().emitAddress(operand(address), 0, getGen().loadNonConst(operand(distance)), 1); + append(new SPARCPrefetchOp(addr, getGen().config.allocatePrefetchInstr)); + } + +}
--- a/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotNodeLIRGenerator.java Fri Mar 28 14:28:27 2014 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,144 +0,0 @@ -/* - * Copyright (c) 2013, 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.sparc; - -import static com.oracle.graal.api.code.ValueUtil.*; -import static com.oracle.graal.hotspot.HotSpotBackend.*; -import static com.oracle.graal.sparc.SPARC.*; - -import java.lang.reflect.*; - -import com.oracle.graal.api.code.*; -import com.oracle.graal.api.meta.*; -import com.oracle.graal.compiler.gen.*; -import com.oracle.graal.compiler.sparc.*; -import com.oracle.graal.graph.*; -import com.oracle.graal.hotspot.*; -import com.oracle.graal.hotspot.meta.*; -import com.oracle.graal.hotspot.nodes.*; -import com.oracle.graal.lir.*; -import com.oracle.graal.lir.sparc.*; -import com.oracle.graal.lir.sparc.SPARCMove.CompareAndSwapOp; -import com.oracle.graal.nodes.*; -import com.oracle.graal.nodes.java.MethodCallTargetNode.InvokeKind; - -public class SPARCHotSpotNodeLIRGenerator extends SPARCNodeLIRGenerator implements HotSpotNodeLIRGenerator { - - public SPARCHotSpotNodeLIRGenerator(StructuredGraph graph, LIRGenerationResult lirGenRes, LIRGenerator lirGen) { - super(graph, lirGenRes, lirGen); - } - - @Override - protected DebugInfoBuilder createDebugInfoBuilder(NodeMap<Value> nodeOperands) { - HotSpotLockStack lockStack = new HotSpotLockStack(res.getFrameMap(), Kind.Long); - return new HotSpotDebugInfoBuilder(nodeOperands, lockStack); - } - - private SPARCHotSpotLIRGenerator getGen() { - return (SPARCHotSpotLIRGenerator) gen; - } - - @Override - public void visitSafepointNode(SafepointNode i) { - LIRFrameState info = gen.state(i); - append(new SPARCHotSpotSafepointOp(info, getGen().config, gen)); - } - - @Override - public void visitDirectCompareAndSwap(DirectCompareAndSwapNode x) { - Kind kind = x.newValue().getKind(); - assert kind == x.expectedValue().getKind(); - - Variable address = gen.load(operand(x.object())); - Value offset = operand(x.offset()); - Variable cmpValue = (Variable) gen.loadNonConst(operand(x.expectedValue())); - Variable newValue = gen.load(operand(x.newValue())); - - if (ValueUtil.isConstant(offset)) { - assert !gen.getCodeCache().needsDataPatch(asConstant(offset)); - Variable longAddress = newVariable(Kind.Long); - gen.emitMove(longAddress, address); - address = getGen().emitAdd(longAddress, asConstant(offset)); - } else { - if (isLegal(offset)) { - address = getGen().emitAdd(address, offset); - } - } - - append(new CompareAndSwapOp(address, cmpValue, newValue)); - - Variable result = newVariable(x.getKind()); - gen.emitMove(result, newValue); - setResult(x, result); - } - - @Override - protected void emitDirectCall(DirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) { - InvokeKind invokeKind = ((HotSpotDirectCallTargetNode) callTarget).invokeKind(); - if (invokeKind == InvokeKind.Interface || invokeKind == InvokeKind.Virtual) { - append(new SPARCHotspotDirectVirtualCallOp(callTarget.target(), result, parameters, temps, callState, invokeKind)); - } else { - assert invokeKind == InvokeKind.Static || invokeKind == InvokeKind.Special; - HotSpotResolvedJavaMethod resolvedMethod = (HotSpotResolvedJavaMethod) callTarget.target(); - assert !Modifier.isAbstract(resolvedMethod.getModifiers()) : "Cannot make direct call to abstract method."; - Constant metaspaceMethod = resolvedMethod.getMetaspaceMethodConstant(); - append(new SPARCHotspotDirectStaticCallOp(callTarget.target(), result, parameters, temps, callState, invokeKind, metaspaceMethod)); - } - } - - @Override - protected void emitIndirectCall(IndirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) { - AllocatableValue metaspaceMethod = g5.asValue(); - gen.emitMove(metaspaceMethod, operand(((HotSpotIndirectCallTargetNode) callTarget).metaspaceMethod())); - AllocatableValue targetAddress = g3.asValue(); - gen.emitMove(targetAddress, operand(callTarget.computedAddress())); - append(new SPARCIndirectCallOp(callTarget.target(), result, parameters, temps, metaspaceMethod, targetAddress, callState)); - } - - @Override - public void emitPatchReturnAddress(ValueNode address) { - append(new SPARCHotSpotPatchReturnAddressOp(gen.load(operand(address)))); - } - - @Override - public void emitJumpToExceptionHandlerInCaller(ValueNode handlerInCallerPc, ValueNode exception, ValueNode exceptionPc) { - Variable handler = gen.load(operand(handlerInCallerPc)); - ForeignCallLinkage linkage = gen.getForeignCalls().lookupForeignCall(EXCEPTION_HANDLER_IN_CALLER); - CallingConvention linkageCc = linkage.getOutgoingCallingConvention(); - assert linkageCc.getArgumentCount() == 2; - RegisterValue exceptionFixed = (RegisterValue) linkageCc.getArgument(0); - RegisterValue exceptionPcFixed = (RegisterValue) linkageCc.getArgument(1); - gen.emitMove(exceptionFixed, operand(exception)); - gen.emitMove(exceptionPcFixed, operand(exceptionPc)); - Register thread = getGen().getProviders().getRegisters().getThreadRegister(); - SPARCHotSpotJumpToExceptionHandlerInCallerOp op = new SPARCHotSpotJumpToExceptionHandlerInCallerOp(handler, exceptionFixed, exceptionPcFixed, getGen().config.threadIsMethodHandleReturnOffset, - thread); - append(op); - } - - public void emitPrefetchAllocate(ValueNode address, ValueNode distance) { - SPARCAddressValue addr = getGen().emitAddress(operand(address), 0, getGen().loadNonConst(operand(distance)), 1); - append(new SPARCPrefetchOp(addr, getGen().config.allocatePrefetchInstr)); - } - -}
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/HotSpotLIRGenerator.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/HotSpotLIRGenerator.java Mon Mar 31 10:03:32 2014 +0200 @@ -30,7 +30,7 @@ /** * This interface defines the contract a HotSpot backend LIR generator needs to fulfill in addition - * to abstract methods from {@link LIRGenerator} and {@link NodeLIRGeneratorTool}. + * to abstract methods from {@link LIRGenerator} and {@link NodeLIRBuiderTool}. */ public interface HotSpotLIRGenerator {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/HotSpotNodeLIRBuilder.java Mon Mar 31 10:03:32 2014 +0200 @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2012, 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; + +import com.oracle.graal.compiler.gen.*; +import com.oracle.graal.hotspot.nodes.*; +import com.oracle.graal.nodes.*; +import com.oracle.graal.nodes.spi.*; + +/** + * This interface defines the contract a HotSpot backend LIR generator needs to fulfill in addition + * to abstract methods from {@link LIRGenerator} and {@link NodeLIRBuiderTool}. + */ +public interface HotSpotNodeLIRBuilder { + + void emitPatchReturnAddress(ValueNode address); + + void emitJumpToExceptionHandlerInCaller(ValueNode handlerInCallerPc, ValueNode exception, ValueNode exceptionPc); + + void emitPrefetchAllocate(ValueNode address, ValueNode distance); + + void visitDirectCompareAndSwap(DirectCompareAndSwapNode x); + +}
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/HotSpotNodeLIRGenerator.java Fri Mar 28 14:28:27 2014 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,44 +0,0 @@ -/* - * Copyright (c) 2012, 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; - -import com.oracle.graal.compiler.gen.*; -import com.oracle.graal.hotspot.nodes.*; -import com.oracle.graal.nodes.*; -import com.oracle.graal.nodes.spi.*; - -/** - * This interface defines the contract a HotSpot backend LIR generator needs to fulfill in addition - * to abstract methods from {@link LIRGenerator} and {@link NodeLIRGeneratorTool}. - */ -public interface HotSpotNodeLIRGenerator { - - void emitPatchReturnAddress(ValueNode address); - - void emitJumpToExceptionHandlerInCaller(ValueNode handlerInCallerPc, ValueNode exception, ValueNode exceptionPc); - - void emitPrefetchAllocate(ValueNode address, ValueNode distance); - - void visitDirectCompareAndSwap(DirectCompareAndSwapNode x); - -}
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/AllocaNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/AllocaNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -58,7 +58,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen, LIRGenerationResult res) { + public void generate(NodeLIRBuiderTool gen, LIRGenerationResult res) { StackSlot array = res.getFrameMap().allocateStackSlots(slots, objects, null); Value result = gen.getLIRGeneratorTool().emitAddress(array); gen.setResult(this, result);
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/BeginLockScopeNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/BeginLockScopeNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -57,7 +57,7 @@ } @Override - public void generate(NodeLIRGenerator gen) { + public void generate(NodeLIRBuilder gen) { assert lockDepth != -1; HotSpotLIRGenerator hsGen = (HotSpotLIRGenerator) gen.getLIRGeneratorTool(); StackSlot slot = hsGen.getLockSlot(lockDepth);
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/CStringNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/CStringNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -41,11 +41,11 @@ this.string = string; } - public void generate(NodeLIRGenerator gen) { + public void generate(NodeLIRBuilder gen) { gen.setResult(this, emitCString(gen, string)); } - public static AllocatableValue emitCString(NodeLIRGeneratorTool gen, String value) { + public static AllocatableValue emitCString(NodeLIRBuiderTool gen, String value) { AllocatableValue dst = gen.getLIRGeneratorTool().newVariable(gen.getLIRGeneratorTool().target().wordKind); gen.getLIRGeneratorTool().emitData(dst, toCString(value)); return dst;
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/CurrentJavaThreadNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/CurrentJavaThreadNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -41,7 +41,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { Register rawThread = ((HotSpotLIRGenerator) gen.getLIRGeneratorTool()).getProviders().getRegisters().getThreadRegister(); gen.setResult(this, rawThread.asValue(this.getKind())); }
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/CurrentLockNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/CurrentLockNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -42,7 +42,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { assert lockDepth != -1; HotSpotLIRGenerator hsGen = (HotSpotLIRGenerator) gen.getLIRGeneratorTool(); StackSlot slot = hsGen.getLockSlot(lockDepth);
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/DeoptimizeCallerNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/DeoptimizeCallerNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -45,7 +45,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { ((HotSpotLIRGenerator) gen.getLIRGeneratorTool()).emitDeoptimizeCaller(action, reason); }
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/DimensionsNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/DimensionsNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -48,7 +48,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen, LIRGenerationResult res) { + public void generate(NodeLIRBuiderTool gen, LIRGenerationResult res) { int size = rank * 4; int wordSize = gen.getLIRGeneratorTool().target().wordSize; int slots = roundUp(size, wordSize) / wordSize;
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/DirectCompareAndSwapNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/DirectCompareAndSwapNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -77,8 +77,8 @@ } @Override - public void generate(NodeLIRGenerator gen) { - ((HotSpotNodeLIRGenerator) gen).visitDirectCompareAndSwap(this); + public void generate(NodeLIRBuilder gen) { + ((HotSpotNodeLIRBuilder) gen).visitDirectCompareAndSwap(this); } /**
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/EndLockScopeNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/EndLockScopeNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -49,7 +49,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { } @NodeIntrinsic
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/GetObjectAddressNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/GetObjectAddressNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -45,7 +45,7 @@ public static native long get(Object array); @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { AllocatableValue obj = gen.getLIRGeneratorTool().newVariable(gen.getLIRGeneratorTool().target().wordKind); gen.getLIRGeneratorTool().emitMove(obj, gen.operand(object)); gen.setResult(this, obj);
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/JumpToExceptionHandlerInCallerNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/JumpToExceptionHandlerInCallerNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -46,8 +46,8 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { - ((HotSpotNodeLIRGenerator) gen).emitJumpToExceptionHandlerInCaller(handlerInCallerPc, exception, exceptionPc); + public void generate(NodeLIRBuiderTool gen) { + ((HotSpotNodeLIRBuilder) gen).emitJumpToExceptionHandlerInCaller(handlerInCallerPc, exception, exceptionPc); } @NodeIntrinsic
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/MonitorCounterNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/MonitorCounterNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -42,7 +42,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen, LIRGenerationResult res) { + public void generate(NodeLIRBuiderTool gen, LIRGenerationResult res) { assert graph().getNodes().filter(MonitorCounterNode.class).count() == 1 : "monitor counters not canonicalized to single instance"; StackSlot counter = res.getFrameMap().allocateStackSlots(1, new BitSet(0), null); Value result = gen.getLIRGeneratorTool().emitAddress(counter);
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/MonitorExitStubCall.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/MonitorExitStubCall.java Mon Mar 31 10:03:32 2014 +0200 @@ -47,7 +47,7 @@ } @Override - public void generate(NodeLIRGenerator gen) { + public void generate(NodeLIRBuilder gen) { assert lockDepth != -1; HotSpotLIRGenerator hsGen = (HotSpotLIRGenerator) gen.getLIRGeneratorTool(); StackSlot slot = hsGen.getLockSlot(lockDepth);
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/NewArrayStubCall.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/NewArrayStubCall.java Mon Mar 31 10:03:32 2014 +0200 @@ -61,7 +61,7 @@ } @Override - public void generate(NodeLIRGenerator gen) { + public void generate(NodeLIRBuilder gen) { ForeignCallLinkage linkage = gen.getLIRGeneratorTool().getForeignCalls().lookupForeignCall(NEW_ARRAY); Variable result = gen.getLIRGenerator().emitForeignCall(linkage, this, gen.operand(hub), gen.operand(length)); gen.setResult(this, result);
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/NewInstanceStubCall.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/NewInstanceStubCall.java Mon Mar 31 10:03:32 2014 +0200 @@ -57,7 +57,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { ForeignCallLinkage linkage = gen.getLIRGeneratorTool().getForeignCalls().lookupForeignCall(NEW_INSTANCE); Value result = gen.getLIRGeneratorTool().emitForeignCall(linkage, this, gen.operand(hub)); gen.setResult(this, result);
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/NewMultiArrayStubCall.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/NewMultiArrayStubCall.java Mon Mar 31 10:03:32 2014 +0200 @@ -61,7 +61,7 @@ } @Override - protected Value[] operands(NodeLIRGeneratorTool gen) { + protected Value[] operands(NodeLIRBuiderTool gen) { return new Value[]{gen.operand(hub), Constant.forInt(rank), gen.operand(dims)}; }
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/PatchReturnAddressNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/PatchReturnAddressNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -41,8 +41,8 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { - ((HotSpotNodeLIRGenerator) gen).emitPatchReturnAddress(address); + public void generate(NodeLIRBuiderTool gen) { + ((HotSpotNodeLIRBuilder) gen).emitPatchReturnAddress(address); } @NodeIntrinsic
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/PrefetchAllocateNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/PrefetchAllocateNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -42,8 +42,8 @@ } @Override - public void generate(NodeLIRGenerator gen) { - ((HotSpotNodeLIRGenerator) gen).emitPrefetchAllocate(address, distance); + public void generate(NodeLIRBuilder gen) { + ((HotSpotNodeLIRBuilder) gen).emitPrefetchAllocate(address, distance); } @NodeIntrinsic
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/StubForeignCallNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/StubForeignCallNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -57,7 +57,7 @@ return foreignCalls.getKilledLocations(descriptor); } - protected Value[] operands(NodeLIRGeneratorTool gen) { + protected Value[] operands(NodeLIRBuiderTool gen) { Value[] operands = new Value[arguments.size()]; for (int i = 0; i < operands.length; i++) { operands[i] = gen.operand(arguments.get(i)); @@ -66,7 +66,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { assert graph().start() instanceof StubStartNode; ForeignCallLinkage linkage = gen.getLIRGeneratorTool().getForeignCalls().lookupForeignCall(descriptor); Value[] operands = operands(gen);
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/TailcallNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/TailcallNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -58,7 +58,7 @@ this.frameState = frameState; } - public void generate(NodeLIRGeneratorTool gen, LIRGenerationResult res) { + public void generate(NodeLIRBuiderTool gen, LIRGenerationResult res) { HotSpotVMConfig config = runtime().getConfig(); ResolvedJavaMethod method = frameState.method(); boolean isStatic = Modifier.isStatic(method.getModifiers());
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/VMErrorNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/VMErrorNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -49,7 +49,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { String whereString; if (stateBefore() != null) { String nl = CodeUtil.NEW_LINE;
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/AbstractBeginNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/AbstractBeginNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -128,7 +128,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { // nop }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/AbstractEndNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/AbstractEndNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -35,7 +35,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.visitEndNode(this); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/BreakpointNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/BreakpointNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -54,7 +54,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.visitBreakpointNode(this); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/CallTargetNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/CallTargetNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -54,7 +54,7 @@ public abstract String targetName(); @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { // nop } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ConstantNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ConstantNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -120,7 +120,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { assert ConstantNodeRecordsUsages : "LIR generator should generate constants per-usage"; if (gen.getLIRGeneratorTool().canInlineConstant(value) || onlyUsedInVirtualState()) { gen.setResult(this, value);
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/DeoptimizeNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/DeoptimizeNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -62,7 +62,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.getLIRGeneratorTool().emitDeoptimize(gen.getLIRGeneratorTool().getMetaAccess().encodeDeoptActionAndReason(action, reason, debugId), speculation, this); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/DynamicDeoptimizeNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/DynamicDeoptimizeNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -54,7 +54,7 @@ return getSpeculation(); } - public void generate(NodeLIRGeneratorTool generator) { + public void generate(NodeLIRBuiderTool generator) { generator.getLIRGeneratorTool().emitDeoptimize(generator.operand(actionAndReason), generator.operand(speculation), this); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/EntryMarkerNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/EntryMarkerNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -38,7 +38,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { throw new GraalInternalError("OnStackReplacementNode should not survive"); } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/GuardedValueNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/GuardedValueNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -53,7 +53,7 @@ } @Override - public void generate(NodeLIRGeneratorTool generator) { + public void generate(NodeLIRBuiderTool generator) { if (object.getKind() != Kind.Void && object.getKind() != Kind.Illegal) { generator.setResult(this, generator.operand(object)); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/IfNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/IfNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -127,7 +127,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.emitIf(this); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/InfopointNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/InfopointNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -41,7 +41,7 @@ } @Override - public void generate(NodeLIRGeneratorTool generator) { + public void generate(NodeLIRBuiderTool generator) { generator.visitInfopointNode(this); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/InvokeNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/InvokeNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -113,7 +113,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.emitInvoke(this); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/InvokeWithExceptionNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/InvokeWithExceptionNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -133,7 +133,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.emitInvoke(this); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/LogicConstantNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/LogicConstantNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -68,7 +68,7 @@ } @Override - public void generate(NodeLIRGeneratorTool generator) { + public void generate(NodeLIRBuiderTool generator) { // nothing to do } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/LoopBeginNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/LoopBeginNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -98,7 +98,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { // Nothing to emit, since this is node is used for structural purposes only. }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/LoopEndNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/LoopEndNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -64,7 +64,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.visitLoopEnd(this); super.generate(gen); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/MemoryProxyNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/MemoryProxyNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -42,7 +42,7 @@ } @Override - public void generate(NodeLIRGeneratorTool generator) { + public void generate(NodeLIRBuiderTool generator) { } @Override
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/MergeNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/MergeNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -41,7 +41,7 @@ @Input(notDataflow = true) private final NodeInputList<AbstractEndNode> ends = new NodeInputList<>(this); @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.visitMerge(this); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/PiNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/PiNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -62,7 +62,7 @@ } @Override - public void generate(NodeLIRGeneratorTool generator) { + public void generate(NodeLIRBuiderTool generator) { if (object.getKind() != Kind.Void && object.getKind() != Kind.Illegal) { generator.setResult(this, generator.operand(object)); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ReturnNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ReturnNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -57,7 +57,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.visitReturn(this); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/SafepointNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/SafepointNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -35,7 +35,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.visitSafepointNode(this); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/UnwindNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/UnwindNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -49,7 +49,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.getLIRGeneratorTool().emitUnwind(gen.operand(exception())); } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/AndNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/AndNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -81,7 +81,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitAnd(gen.operand(x()), gen.operand(y()))); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/CompareNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/CompareNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -75,7 +75,7 @@ public abstract boolean unorderedIsTrue(); @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { } private LogicNode optimizeConditional(Constant constant, ConditionalNode conditionalNode, ConstantReflectionProvider constantReflection, Condition cond) {
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/ConditionalNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/ConditionalNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -109,7 +109,7 @@ } @Override - public void generate(NodeLIRGeneratorTool generator) { + public void generate(NodeLIRBuiderTool generator) { generator.emitConditional(this); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/FloatAddNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/FloatAddNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -65,7 +65,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { Value op1 = gen.operand(x()); Value op2 = gen.operand(y()); if (!y().isConstant() && !livesLonger(this, y(), gen)) { @@ -76,7 +76,7 @@ gen.setResult(this, gen.getLIRGeneratorTool().emitAdd(op1, op2)); } - public static boolean livesLonger(ValueNode after, ValueNode value, NodeLIRGeneratorTool gen) { + public static boolean livesLonger(ValueNode after, ValueNode value, NodeLIRBuiderTool gen) { for (Node usage : value.usages()) { if (usage != after && usage instanceof ValueNode && gen.hasOperand(((ValueNode) usage))) { return true;
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/FloatConvertNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/FloatConvertNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -192,7 +192,7 @@ tool.getLowerer().lower(this, tool); } - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitFloatConvert(op, gen.operand(getInput()))); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/FloatDivNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/FloatDivNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -57,7 +57,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitDiv(gen.operand(x()), gen.operand(y()), null)); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/FloatMulNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/FloatMulNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -60,7 +60,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { Value op1 = gen.operand(x()); Value op2 = gen.operand(y()); if (!y().isConstant() && !FloatAddNode.livesLonger(this, y(), gen)) {
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/FloatRemNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/FloatRemNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -57,7 +57,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitRem(gen.operand(x()), gen.operand(y()), null)); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/FloatSubNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/FloatSubNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -76,7 +76,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitSub(gen.operand(x()), gen.operand(y()))); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/IntegerAddNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/IntegerAddNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -89,7 +89,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { Value op1 = gen.operand(x()); assert op1 != null : x() + ", this=" + this; Value op2 = gen.operand(y());
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/IntegerDivNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/IntegerDivNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -106,7 +106,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitDiv(gen.operand(x()), gen.operand(y()), this)); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/IntegerMulNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/IntegerMulNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -75,7 +75,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { Value op1 = gen.operand(x()); Value op2 = gen.operand(y()); if (!y().isConstant() && !FloatAddNode.livesLonger(this, y(), gen)) {
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/IntegerRemNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/IntegerRemNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -61,7 +61,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitRem(gen.operand(x()), gen.operand(y()), this)); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/IntegerSubNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/IntegerSubNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -117,7 +117,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitSub(gen.operand(x()), gen.operand(y()))); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/IntegerTestNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/IntegerTestNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -60,7 +60,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { } @Override
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/IsNullNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/IsNullNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -50,7 +50,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { // Nothing to do. }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/LeftShiftNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/LeftShiftNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -92,7 +92,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitShl(gen.operand(x()), gen.operand(y()))); } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/NarrowNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/NarrowNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -110,7 +110,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitNarrow(gen.operand(getInput()), getResultBits())); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/NegateNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/NegateNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -88,7 +88,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitNegate(gen.operand(x()))); } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/NotNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/NotNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -73,7 +73,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitNot(gen.operand(x()))); } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/OrNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/OrNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -73,7 +73,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitOr(gen.operand(x()), gen.operand(y()))); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/ReinterpretNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/ReinterpretNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -102,7 +102,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { PlatformKind kind = gen.getLIRGeneratorTool().getPlatformKind(stamp()); gen.setResult(this, gen.getLIRGeneratorTool().emitReinterpret(kind, gen.operand(value()))); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/RightShiftNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/RightShiftNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -98,7 +98,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitShr(gen.operand(x()), gen.operand(y()))); } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/SignExtendNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/SignExtendNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -105,7 +105,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitSignExtend(gen.operand(getInput()), getInputBits(), getResultBits())); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/UnsignedDivNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/UnsignedDivNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -71,7 +71,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitUDiv(gen.operand(x()), gen.operand(y()), this)); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/UnsignedRemNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/UnsignedRemNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -70,7 +70,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitURem(gen.operand(x()), gen.operand(y()), this)); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/UnsignedRightShiftNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/UnsignedRightShiftNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -92,7 +92,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitUShr(gen.operand(x()), gen.operand(y()))); } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/XorNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/XorNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -72,7 +72,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitXor(gen.operand(x()), gen.operand(y()))); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/ZeroExtendNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/ZeroExtendNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -85,7 +85,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitZeroExtend(gen.operand(getInput()), getInputBits(), getResultBits())); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/AddLocationNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/AddLocationNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -107,7 +107,7 @@ } @Override - public Value generateAddress(NodeLIRGeneratorTool gen, Value base) { + public Value generateAddress(NodeLIRBuiderTool gen, Value base) { Value xAddr = getX().generateAddress(gen, base); return getY().generateAddress(gen, xAddr); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ComputeAddressNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ComputeAddressNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -48,7 +48,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { Value addr = getLocation().generateAddress(gen, gen.operand(getObject())); gen.setResult(this, addr); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ConstantLocationNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ConstantLocationNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -65,7 +65,7 @@ } @Override - public Value generateAddress(NodeLIRGeneratorTool gen, Value base) { + public Value generateAddress(NodeLIRBuiderTool gen, Value base) { return gen.getLIRGeneratorTool().emitAddress(base, getDisplacement(), Value.ILLEGAL, 0); } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/FixedValueAnchorNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/FixedValueAnchorNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -49,7 +49,7 @@ public static native <T> T getObject(Object object); @Override - public void generate(NodeLIRGeneratorTool generator) { + public void generate(NodeLIRBuiderTool generator) { generator.setResult(this, generator.operand(object)); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/FloatingReadNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/FloatingReadNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -60,7 +60,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { Value address = location().generateAddress(gen, gen.operand(object())); gen.setResult(this, gen.getLIRGeneratorTool().emitLoad(location().getValueKind(), address, this)); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ForeignCallNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ForeignCallNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -82,7 +82,7 @@ return foreignCalls.getKilledLocations(descriptor); } - protected Value[] operands(NodeLIRGeneratorTool gen) { + protected Value[] operands(NodeLIRBuiderTool gen) { Value[] operands = new Value[arguments.size()]; for (int i = 0; i < operands.length; i++) { operands[i] = gen.operand(arguments.get(i)); @@ -91,7 +91,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { ForeignCallLinkage linkage = gen.getLIRGeneratorTool().getForeignCalls().lookupForeignCall(descriptor); Value[] operands = operands(gen); Value result = gen.getLIRGeneratorTool().emitForeignCall(linkage, this, operands);
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/IndexedLocationNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/IndexedLocationNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -96,7 +96,7 @@ } @Override - public Value generateAddress(NodeLIRGeneratorTool gen, Value base) { + public Value generateAddress(NodeLIRBuiderTool gen, Value base) { return gen.getLIRGeneratorTool().emitAddress(base, displacement, gen.operand(getIndex()), getIndexScaling()); } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/IntegerSwitchNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/IntegerSwitchNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -101,7 +101,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.emitSwitch(this); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/LocationNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/LocationNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -56,9 +56,9 @@ public abstract LocationIdentity getLocationIdentity(); @Override - public final void generate(NodeLIRGeneratorTool generator) { + public final void generate(NodeLIRBuiderTool generator) { // nothing to do... } - public abstract Value generateAddress(NodeLIRGeneratorTool gen, Value base); + public abstract Value generateAddress(NodeLIRBuiderTool gen, Value base); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/MembarNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/MembarNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -56,7 +56,7 @@ } @Override - public void generate(NodeLIRGeneratorTool generator) { + public void generate(NodeLIRBuiderTool generator) { generator.getLIRGeneratorTool().emitMembar(barriers); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/NullCheckNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/NullCheckNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -40,7 +40,7 @@ } @Override - public void generate(NodeLIRGeneratorTool generator) { + public void generate(NodeLIRBuiderTool generator) { generator.emitNullCheck(object, this); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ReadNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ReadNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -53,7 +53,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { Value address = location().generateAddress(gen, gen.operand(object())); gen.setResult(this, gen.getLIRGeneratorTool().emitLoad(location().getValueKind(), address, this)); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/SnippetLocationNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/SnippetLocationNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -100,7 +100,7 @@ } @Override - public Value generateAddress(NodeLIRGeneratorTool gen, Value base) { + public Value generateAddress(NodeLIRBuiderTool gen, Value base) { throw new GraalInternalError("locationIdentity must be a constant so that this node can be canonicalized: " + locationIdentity); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/UnsafeCastNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/UnsafeCastNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -94,7 +94,7 @@ } @Override - public void generate(NodeLIRGeneratorTool generator) { + public void generate(NodeLIRBuiderTool generator) { assert getKind() == Kind.Object && object.getKind() == Kind.Object; /* * The LIR only cares about the kind of an operand, not the actual type of an object. So we
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ValueAnchorNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ValueAnchorNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -42,7 +42,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { // Nothing to emit, since this node is used for structural purposes only. }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/WriteNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/WriteNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -80,7 +80,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { Value address = location().generateAddress(gen, gen.operand(object())); // It's possible a constant was forced for other usages so inspect the value directly and // use a constant if it can be directly stored.
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/LoweredCompareAndSwapNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/LoweredCompareAndSwapNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -72,7 +72,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.visitCompareAndSwap(this, location().generateAddress(gen, gen.operand(object()))); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/MonitorIdNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/MonitorIdNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -49,7 +49,7 @@ this.lockDepth = lockDepth; } - public void generate(NodeLIRGeneratorTool generator) { + public void generate(NodeLIRBuiderTool generator) { // nothing to do } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/RegisterFinalizerNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/RegisterFinalizerNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -51,7 +51,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { ForeignCallLinkage linkage = gen.getLIRGeneratorTool().getForeignCalls().lookupForeignCall(REGISTER_FINALIZER); gen.getLIRGeneratorTool().emitForeignCall(linkage, this, gen.operand(object())); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/SelfReplacingMethodCallTargetNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/SelfReplacingMethodCallTargetNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -29,7 +29,7 @@ import com.oracle.graal.graph.GraalInternalError; import com.oracle.graal.graph.NodeInputList; import com.oracle.graal.nodes.*; -import com.oracle.graal.nodes.spi.NodeLIRGeneratorTool; +import com.oracle.graal.nodes.spi.NodeLIRBuiderTool; import com.oracle.graal.nodes.spi.Lowerable; import com.oracle.graal.nodes.spi.LoweringTool; @@ -78,7 +78,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { throw GraalInternalError.shouldNotReachHere("should have replaced itself"); } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/TypeSwitchNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/TypeSwitchNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -92,7 +92,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.emitSwitch(this); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/ArithmeticLIRLowerable.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/ArithmeticLIRLowerable.java Mon Mar 31 10:03:32 2014 +0200 @@ -26,5 +26,5 @@ public interface ArithmeticLIRLowerable extends ArithmeticOperation { - void generate(NodeLIRGeneratorTool gen); + void generate(NodeLIRBuiderTool gen); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/LIRLowerable.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/LIRLowerable.java Mon Mar 31 10:03:32 2014 +0200 @@ -24,5 +24,5 @@ public interface LIRLowerable { - void generate(NodeLIRGeneratorTool generator); + void generate(NodeLIRBuiderTool generator); }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/NodeLIRBuiderTool.java Mon Mar 31 10:03:32 2014 +0200 @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2011, 2012, 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.nodes.spi; + +import java.util.*; + +import com.oracle.graal.api.code.*; +import com.oracle.graal.api.meta.*; +import com.oracle.graal.nodes.*; +import com.oracle.graal.nodes.calc.*; +import com.oracle.graal.nodes.extended.*; +import com.oracle.graal.nodes.java.*; + +public interface NodeLIRBuiderTool extends NodeMappableLIRBuilder { + + void emitNullCheck(ValueNode v, DeoptimizingNode deopting); + + void emitIf(IfNode i); + + void emitConditional(ConditionalNode i); + + void emitSwitch(SwitchNode i); + + void emitInvoke(Invoke i); + + // Handling of block-end nodes still needs to be unified in the LIRGenerator. + void visitMerge(MergeNode i); + + void visitEndNode(AbstractEndNode i); + + void visitLoopEnd(LoopEndNode i); + + void visitCompareAndSwap(LoweredCompareAndSwapNode i, Value address); + + // These methods define the contract a runtime specific backend must provide. + + void visitReturn(ReturnNode i); + + void visitSafepointNode(SafepointNode i); + + void visitBreakpointNode(BreakpointNode i); + + void visitInfopointNode(InfopointNode i); + + LIRGeneratorTool getLIRGeneratorTool(); + + void emitOverflowCheckBranch(AbstractBeginNode overflowSuccessor, AbstractBeginNode next, double probability); + + Value[] visitInvokeArguments(CallingConvention cc, Collection<ValueNode> arguments); + + MemoryArithmeticLIRLowerer getMemoryLowerer(); +}
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/NodeLIRGeneratorTool.java Fri Mar 28 14:28:27 2014 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,72 +0,0 @@ -/* - * Copyright (c) 2011, 2012, 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.nodes.spi; - -import java.util.*; - -import com.oracle.graal.api.code.*; -import com.oracle.graal.api.meta.*; -import com.oracle.graal.nodes.*; -import com.oracle.graal.nodes.calc.*; -import com.oracle.graal.nodes.extended.*; -import com.oracle.graal.nodes.java.*; - -public interface NodeLIRGeneratorTool extends NodeMappableLIRGenerator { - - void emitNullCheck(ValueNode v, DeoptimizingNode deopting); - - void emitIf(IfNode i); - - void emitConditional(ConditionalNode i); - - void emitSwitch(SwitchNode i); - - void emitInvoke(Invoke i); - - // Handling of block-end nodes still needs to be unified in the LIRGenerator. - void visitMerge(MergeNode i); - - void visitEndNode(AbstractEndNode i); - - void visitLoopEnd(LoopEndNode i); - - void visitCompareAndSwap(LoweredCompareAndSwapNode i, Value address); - - // These methods define the contract a runtime specific backend must provide. - - void visitReturn(ReturnNode i); - - void visitSafepointNode(SafepointNode i); - - void visitBreakpointNode(BreakpointNode i); - - void visitInfopointNode(InfopointNode i); - - LIRGeneratorTool getLIRGeneratorTool(); - - void emitOverflowCheckBranch(AbstractBeginNode overflowSuccessor, AbstractBeginNode next, double probability); - - Value[] visitInvokeArguments(CallingConvention cc, Collection<ValueNode> arguments); - - MemoryArithmeticLIRLowerer getMemoryLowerer(); -}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/NodeMappableLIRBuilder.java Mon Mar 31 10:03:32 2014 +0200 @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2014, 2014, 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.nodes.spi; + +import com.oracle.graal.api.meta.*; +import com.oracle.graal.nodes.*; + +public interface NodeMappableLIRBuilder { + + Value operand(ValueNode object); + + boolean hasOperand(ValueNode object); + + Value setResult(ValueNode x, Value operand); +}
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/NodeMappableLIRGenerator.java Fri Mar 28 14:28:27 2014 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,36 +0,0 @@ -/* - * Copyright (c) 2014, 2014, 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.nodes.spi; - -import com.oracle.graal.api.meta.*; -import com.oracle.graal.nodes.*; - -public interface NodeMappableLIRGenerator { - - Value operand(ValueNode object); - - boolean hasOperand(ValueNode object); - - Value setResult(ValueNode x, Value operand); -}
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/virtual/VirtualArrayNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/virtual/VirtualArrayNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -56,7 +56,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { // nothing to do... }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/virtual/VirtualObjectNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/virtual/VirtualObjectNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -91,7 +91,7 @@ public abstract ValueNode getMaterializedRepresentation(FixedNode fixed, ValueNode[] entries, LockState locks); @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { // nothing to do... } }
--- a/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/CFGPrinter.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/CFGPrinter.java Mon Mar 31 10:03:32 2014 +0200 @@ -50,7 +50,7 @@ protected TargetDescription target; protected LIR lir; - protected NodeLIRGenerator nodeLirGenerator; + protected NodeLIRBuilder nodeLirGenerator; protected ControlFlowGraph cfg; protected SchedulePhase schedule;
--- a/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/CFGPrinterObserver.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/CFGPrinterObserver.java Mon Mar 31 10:03:32 2014 +0200 @@ -137,7 +137,7 @@ } else { cfgPrinter.lir = Debug.contextLookup(LIR.class); } - cfgPrinter.nodeLirGenerator = Debug.contextLookup(NodeLIRGenerator.class); + cfgPrinter.nodeLirGenerator = Debug.contextLookup(NodeLIRBuilder.class); if (cfgPrinter.nodeLirGenerator != null) { cfgPrinter.target = cfgPrinter.nodeLirGenerator.getLIRGeneratorTool().target(); }
--- a/graal/com.oracle.graal.replacements.amd64/src/com/oracle/graal/replacements/amd64/AMD64FloatConvertNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.replacements.amd64/src/com/oracle/graal/replacements/amd64/AMD64FloatConvertNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -51,7 +51,7 @@ throw GraalInternalError.shouldNotReachHere(); } - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitFloatConvert(op, gen.operand(value))); } }
--- a/graal/com.oracle.graal.replacements.hsail/src/com/oracle/graal/replacements/hsail/HSAILMathIntrinsicsNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.replacements.hsail/src/com/oracle/graal/replacements/hsail/HSAILMathIntrinsicsNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -85,7 +85,7 @@ * Generates the LIR instructions for the math operation represented by this node. */ @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { Value input = gen.operand(getParameter()); Value result; switch (operation()) {
--- a/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/nodes/ArrayEqualsNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/nodes/ArrayEqualsNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -131,7 +131,7 @@ public static native boolean equals(double[] array1, double[] array2, int length); @Override - public void generate(NodeLIRGenerator gen) { + public void generate(NodeLIRBuilder gen) { Variable result = gen.newVariable(Kind.Int); gen.emitArrayEquals(kind, result, gen.operand(array1), gen.operand(array2), gen.operand(length)); gen.setResult(this, result);
--- a/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/nodes/BitCountNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/nodes/BitCountNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -65,7 +65,7 @@ } @Override - public void generate(NodeLIRGenerator gen) { + public void generate(NodeLIRBuilder gen) { Variable result = gen.newVariable(Kind.Int); gen.emitBitCount(result, gen.operand(value)); gen.setResult(this, result);
--- a/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/nodes/BitScanForwardNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/nodes/BitScanForwardNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -72,7 +72,7 @@ } @Override - public void generate(NodeLIRGenerator gen) { + public void generate(NodeLIRBuilder gen) { Variable result = gen.newVariable(Kind.Int); gen.emitBitScanForward(result, gen.operand(value)); gen.setResult(this, result);
--- a/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/nodes/BitScanReverseNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/nodes/BitScanReverseNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -79,7 +79,7 @@ } @Override - public void generate(NodeLIRGenerator gen) { + public void generate(NodeLIRBuilder gen) { Variable result = gen.newVariable(Kind.Int); gen.getLIRGeneratorTool().emitBitScanReverse(result, gen.operand(value)); gen.setResult(this, result);
--- a/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/nodes/DirectReadNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/nodes/DirectReadNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -46,7 +46,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { gen.setResult(this, gen.getLIRGeneratorTool().emitLoad(readKind, gen.operand(address), null)); }
--- a/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/nodes/DirectStoreNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/nodes/DirectStoreNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -48,7 +48,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { Value v = gen.operand(value); gen.getLIRGeneratorTool().emitStore(kind, gen.operand(address), v, null); }
--- a/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/nodes/MathIntrinsicNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/nodes/MathIntrinsicNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -55,7 +55,7 @@ } @Override - public void generate(NodeLIRGeneratorTool gen) { + public void generate(NodeLIRBuiderTool gen) { Value input = gen.operand(x()); Value result; switch (operation()) {
--- a/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/nodes/ReadRegisterNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/nodes/ReadRegisterNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -74,7 +74,7 @@ } @Override - public void generate(NodeLIRGeneratorTool generator) { + public void generate(NodeLIRBuiderTool generator) { Value result = register.asValue(getKind()); if (incoming) { generator.getLIRGeneratorTool().emitIncomingValues(new Value[]{result});
--- a/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/nodes/ReverseBytesNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/nodes/ReverseBytesNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -66,7 +66,7 @@ } @Override - public void generate(NodeLIRGenerator gen) { + public void generate(NodeLIRBuilder gen) { Variable result = gen.newVariable(value.getKind()); gen.getLIRGenerator().emitByteSwap(result, gen.operand(value)); gen.setResult(this, result);
--- a/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/nodes/WriteRegisterNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/nodes/WriteRegisterNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -52,7 +52,7 @@ } @Override - public void generate(NodeLIRGeneratorTool generator) { + public void generate(NodeLIRBuiderTool generator) { Value val = generator.operand(value); generator.getLIRGeneratorTool().emitMove(register.asValue(val.getKind()), val); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerAddExactSplitNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerAddExactSplitNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -34,7 +34,7 @@ } @Override - protected Value generateArithmetic(NodeLIRGeneratorTool gen) { + protected Value generateArithmetic(NodeLIRBuiderTool gen) { return gen.getLIRGeneratorTool().emitAdd(gen.operand(getX()), gen.operand(getY())); } }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerExactArithmeticSplitNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerExactArithmeticSplitNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -70,12 +70,12 @@ } @Override - public void generate(NodeLIRGeneratorTool generator) { + public void generate(NodeLIRBuiderTool generator) { generator.setResult(this, generateArithmetic(generator)); generator.emitOverflowCheckBranch(getOverflowSuccessor(), getNext(), probability(getOverflowSuccessor())); } - protected abstract Value generateArithmetic(NodeLIRGeneratorTool generator); + protected abstract Value generateArithmetic(NodeLIRBuiderTool generator); static void lower(LoweringTool tool, IntegerExactArithmeticNode node) { if (node.asNode().graph().getGuardsStage() == StructuredGraph.GuardsStage.FIXED_DEOPTS) {
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerMulExactSplitNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerMulExactSplitNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -34,7 +34,7 @@ } @Override - protected Value generateArithmetic(NodeLIRGeneratorTool gen) { + protected Value generateArithmetic(NodeLIRBuiderTool gen) { return gen.getLIRGeneratorTool().emitMul(gen.operand(getX()), gen.operand(getY())); } }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerSubExactSplitNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerSubExactSplitNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -34,7 +34,7 @@ } @Override - protected Value generateArithmetic(NodeLIRGeneratorTool gen) { + protected Value generateArithmetic(NodeLIRBuiderTool gen) { return gen.getLIRGeneratorTool().emitSub(gen.operand(getX()), gen.operand(getY())); } }
--- a/graal/com.oracle.graal.word/src/com/oracle/graal/word/nodes/WordCastNode.java Fri Mar 28 14:28:27 2014 +0100 +++ b/graal/com.oracle.graal.word/src/com/oracle/graal/word/nodes/WordCastNode.java Mon Mar 31 10:03:32 2014 +0200 @@ -67,7 +67,7 @@ } @Override - public void generate(NodeLIRGeneratorTool generator) { + public void generate(NodeLIRBuiderTool generator) { assert getKind() != input.getKind(); assert generator.getLIRGeneratorTool().target().getSizeInBytes(getKind()) == generator.getLIRGeneratorTool().target().getSizeInBytes(input.getKind());