Mercurial > hg > truffle
changeset 14820:2ff2a660c4d8
merge
line wrap: on
line diff
--- a/graal/com.oracle.graal.baseline/src/com/oracle/graal/baseline/BaselineCompiler.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.baseline/src/com/oracle/graal/baseline/BaselineCompiler.java Wed Mar 19 15:22:14 2014 +0100 @@ -35,9 +35,11 @@ import com.oracle.graal.api.meta.ResolvedJavaType.Representation; import com.oracle.graal.bytecode.*; import com.oracle.graal.compiler.*; +import com.oracle.graal.compiler.alloc.*; import com.oracle.graal.compiler.gen.*; 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.java.*; import com.oracle.graal.java.BciBlockMapping.Block; @@ -116,21 +118,37 @@ List<? extends AbstractBlock<?>> linearScanOrder = ComputeBlockOrder.computeLinearScanOrder(blocks.length, b, blockProbabilities); List<? extends AbstractBlock<?>> codeEmittingOrder = ComputeBlockOrder.computeCodeEmittingOrder(blocks.length, b, blockProbabilities); LIR lir = new LIR(cfg, linearScanOrder, codeEmittingOrder); - CallingConvention cc = CodeUtil.getCallingConvention(backend.getProviders().getCodeCache(), CallingConvention.Type.JavaCallee, method, false); - LIRGenerator lirGen = backend.newLIRGenerator(null, null, backend.newFrameMap(), cc, lir); + LIRGenerationResult lirGenRes = null; + try (Scope ds = Debug.scope("BackEnd", lir)) { + FrameMap frameMap = backend.newFrameMap(); + TargetDescription target = backend.getTarget(); + CallingConvention cc = CodeUtil.getCallingConvention(backend.getProviders().getCodeCache(), CallingConvention.Type.JavaCallee, method, false); + lirGenRes = backend.newLIRGenerationResult(lir, frameMap, null); + LIRGenerator lirGen = backend.newLIRGenerator(null, cc, lirGenRes); - // add instruction - lirGen.emitAdd(Constant.forLong(42), Constant.forLong(73)); + try (Scope s = Debug.scope("LIRGen", lirGen)) { + lirGen.doBlock(b); + // lirGen.beforeRegisterAllocation(); - List<LIRInstruction> lirList = null; - lir.setLir(b, lirList); + Debug.dump(lir, "After LIR generation"); + } catch (Throwable e) { + throw Debug.handle(e); + } - // register allocation - lirGen.getFrameMap().finish(); + try (Scope s = Debug.scope("Allocator", lirGen)) { + if (backend.shouldAllocateRegisters()) { + new LinearScan(target, lir, frameMap).allocate(); + } + } catch (Throwable e) { + throw Debug.handle(e); + } + } catch (Throwable e) { + throw Debug.handle(e); + } // emitCode Assumptions assumptions = new Assumptions(OptAssumptions.getValue()); - GraalCompiler.emitCode(backend, assumptions, lirGen, compilationResult, installedCodeOwner, factory); + GraalCompiler.emitCode(backend, assumptions, lirGenRes, compilationResult, installedCodeOwner, factory); return compilationResult; }
--- a/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64LIRGenerator.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64LIRGenerator.java Wed Mar 19 15:22:14 2014 +0100 @@ -87,9 +87,9 @@ } } - public AMD64LIRGenerator(StructuredGraph graph, Providers providers, FrameMap frameMap, CallingConvention cc, LIR lir) { - super(graph, providers, frameMap, cc, lir); - lir.setSpillMoveFactory(new AMD64SpillMoveFactory()); + public AMD64LIRGenerator(StructuredGraph graph, Providers providers, CallingConvention cc, LIRGenerationResult lirGenRes) { + super(graph, providers, cc, lirGenRes); + lirGenRes.getLIR().setSpillMoveFactory(new AMD64SpillMoveFactory()); } @Override @@ -982,7 +982,7 @@ sig[i] = node.arguments().get(i).stamp().javaType(getMetaAccess()); } - Value[] parameters = visitInvokeArguments(getFrameMap().registerConfig.getCallingConvention(CallingConvention.Type.JavaCall, null, sig, target(), false), node.arguments()); + Value[] parameters = visitInvokeArguments(res.getFrameMap().registerConfig.getCallingConvention(CallingConvention.Type.JavaCall, null, sig, target(), false), node.arguments()); append(new AMD64BreakpointOp(parameters)); }
--- a/graal/com.oracle.graal.compiler.hsail/src/com/oracle/graal/compiler/hsail/HSAILLIRGenerator.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.compiler.hsail/src/com/oracle/graal/compiler/hsail/HSAILLIRGenerator.java Wed Mar 19 15:22:14 2014 +0100 @@ -76,9 +76,9 @@ } } - public HSAILLIRGenerator(StructuredGraph graph, Providers providers, FrameMap frameMap, CallingConvention cc, LIR lir) { - super(graph, providers, frameMap, cc, lir); - lir.setSpillMoveFactory(new HSAILSpillMoveFactory()); + public HSAILLIRGenerator(StructuredGraph graph, Providers providers, CallingConvention cc, LIRGenerationResult lirGenRes) { + super(graph, providers, cc, lirGenRes); + lirGenRes.getLIR().setSpillMoveFactory(new HSAILSpillMoveFactory()); } @Override
--- a/graal/com.oracle.graal.compiler.ptx/src/com/oracle/graal/compiler/ptx/PTXLIRGenerator.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.compiler.ptx/src/com/oracle/graal/compiler/ptx/PTXLIRGenerator.java Wed Mar 19 15:22:14 2014 +0100 @@ -89,11 +89,11 @@ } } - public PTXLIRGenerator(StructuredGraph graph, Providers providers, FrameMap frameMap, CallingConvention cc, LIR lir) { - super(graph, providers, frameMap, cc, lir); - lir.setSpillMoveFactory(new PTXSpillMoveFactory()); + public PTXLIRGenerator(StructuredGraph graph, Providers providers, CallingConvention cc, LIRGenerationResult lirGenRes) { + super(graph, providers, cc, lirGenRes); + lirGenRes.getLIR().setSpillMoveFactory(new PTXSpillMoveFactory()); int callVariables = cc.getArgumentCount() + (cc.getReturn().equals(Value.ILLEGAL) ? 0 : 1); - lir.setFirstVariableNumber(callVariables); + lirGenRes.getLIR().setFirstVariableNumber(callVariables); nextPredRegNum = 0; } @@ -137,7 +137,7 @@ @Override public void emitPrologue(StructuredGraph graph) { // Need to emit .param directives based on incoming arguments and return value - CallingConvention incomingArguments = cc; + CallingConvention incomingArguments = getCallingConvention(); Object returnObject = incomingArguments.getReturn(); AllocatableValue[] params = incomingArguments.getArguments(); int argCount = incomingArguments.getArgumentCount();
--- a/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCLIRGenerator.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCLIRGenerator.java Wed Mar 19 15:22:14 2014 +0100 @@ -78,9 +78,9 @@ } } - public SPARCLIRGenerator(StructuredGraph graph, Providers providers, FrameMap frameMap, CallingConvention cc, LIR lir) { - super(graph, providers, frameMap, cc, lir); - lir.setSpillMoveFactory(new SPARCSpillMoveFactory()); + public SPARCLIRGenerator(StructuredGraph graph, Providers providers, CallingConvention cc, LIRGenerationResult lirGenRes) { + super(graph, providers, cc, lirGenRes); + lirGenRes.getLIR().setSpillMoveFactory(new SPARCSpillMoveFactory()); } @Override @@ -930,7 +930,7 @@ sig[i] = node.arguments().get(i).stamp().javaType(getMetaAccess()); } - Value[] parameters = visitInvokeArguments(getFrameMap().registerConfig.getCallingConvention(CallingConvention.Type.JavaCall, null, sig, target(), false), node.arguments()); + Value[] parameters = visitInvokeArguments(res.getFrameMap().registerConfig.getCallingConvention(CallingConvention.Type.JavaCall, null, sig, target(), false), node.arguments()); append(new SPARCBreakpointOp(parameters)); }
--- a/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/GraalCompilerTest.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/GraalCompilerTest.java Wed Mar 19 15:22:14 2014 +0100 @@ -498,7 +498,7 @@ } private CompilationResult compileBaseline(ResolvedJavaMethod javaMethod) { - try (Scope bds = Debug.scope("compileBaseline")) { + try (Scope bds = Debug.scope("compileBaseline", javaMethod)) { BaselineCompiler baselineCompiler = new BaselineCompiler(GraphBuilderConfiguration.getDefault(), providers.getMetaAccess()); return baselineCompiler.generate(javaMethod, -1, getBackend(), new CompilationResult(), javaMethod, CompilationResultBuilderFactory.Default); } catch (Throwable e) {
--- a/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/backend/AllocatorTest.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/backend/AllocatorTest.java Wed Mar 19 15:22:14 2014 +0100 @@ -74,7 +74,7 @@ this.lir = lir; for (AbstractBlock<?> block : lir.codeEmittingOrder()) { - for (LIRInstruction instr : lir.lir(block)) { + for (LIRInstruction instr : lir.getLIRforBlock(block)) { collectStats(instr); } } @@ -120,7 +120,7 @@ } CallingConvention cc = getCallingConvention(getCodeCache(), Type.JavaCallee, graph.method(), false); - LIRGenerator lirGen = GraalCompiler.emitLIR(getBackend(), getBackend().getTarget(), schedule, graph, null, cc); + LIRGenerationResult lirGen = GraalCompiler.emitLIR(getBackend(), getBackend().getTarget(), schedule, graph, null, cc); return new RegisterStats(lirGen.getLIR()); } }
--- a/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/GraalCompiler.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/GraalCompiler.java Wed Mar 19 15:22:14 2014 +0100 @@ -145,10 +145,10 @@ throw Debug.handle(e); } try (TimerCloseable a = BackEnd.start()) { - LIRGenerator lirGen = null; - lirGen = emitLIR(backend, target, schedule, graph, stub, cc); - try (Scope s = Debug.scope("CodeGen", lirGen)) { - emitCode(backend, assumptions, lirGen, compilationResult, installedCodeOwner, factory); + LIRGenerationResult lirGenRes = null; + lirGenRes = emitLIR(backend, target, schedule, graph, stub, cc); + try (Scope s = Debug.scope("CodeGen", lirGenRes)) { + emitCode(backend, assumptions, lirGenRes, compilationResult, installedCodeOwner, factory); } catch (Throwable e) { throw Debug.handle(e); } @@ -210,18 +210,18 @@ } - private static void emitBlock(LIRGenerator lirGen, Block b, StructuredGraph graph, BlockMap<List<ScheduledNode>> blockMap) { - if (lirGen.getLIR().lir(b) == null) { + private static void emitBlock(LIRGenerator lirGen, 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()) { - emitBlock(lirGen, pred, graph, blockMap); + emitBlock(lirGen, lirGenRes, pred, graph, blockMap); } } lirGen.doBlock(b, graph, blockMap); } } - public static LIRGenerator emitLIR(Backend backend, TargetDescription target, SchedulePhase schedule, StructuredGraph graph, Object stub, CallingConvention cc) { + public static LIRGenerationResult emitLIR(Backend backend, TargetDescription target, SchedulePhase schedule, StructuredGraph graph, Object stub, CallingConvention cc) { Block[] blocks = schedule.getCFG().getBlocks(); Block startBlock = schedule.getCFG().getStartBlock(); assert startBlock != null; @@ -247,11 +247,12 @@ } try (Scope ds = Debug.scope("BackEnd", lir)) { FrameMap frameMap = backend.newFrameMap(); - LIRGenerator lirGen = backend.newLIRGenerator(graph, stub, frameMap, cc, lir); + LIRGenerationResult lirGenRes = backend.newLIRGenerationResult(lir, frameMap, stub); + LIRGenerator lirGen = backend.newLIRGenerator(graph, cc, lirGenRes); try (Scope s = Debug.scope("LIRGen", lirGen)) { for (Block b : linearScanOrder) { - emitBlock(lirGen, b, graph, schedule.getBlockToNodesMap()); + emitBlock(lirGen, lirGenRes, b, graph, schedule.getBlockToNodesMap()); } lirGen.beforeRegisterAllocation(); @@ -280,16 +281,16 @@ } catch (Throwable e) { throw Debug.handle(e); } - return lirGen; + return lirGenRes; } catch (Throwable e) { throw Debug.handle(e); } } - public static void emitCode(Backend backend, Assumptions assumptions, LIRGenerator lirGen, CompilationResult compilationResult, ResolvedJavaMethod installedCodeOwner, + public static void emitCode(Backend backend, Assumptions assumptions, LIRGenerationResult lirGenRes, CompilationResult compilationResult, ResolvedJavaMethod installedCodeOwner, CompilationResultBuilderFactory factory) { - CompilationResultBuilder crb = backend.newCompilationResultBuilder(lirGen, compilationResult, factory); - backend.emitCode(crb, lirGen.getLIR(), installedCodeOwner); + CompilationResultBuilder crb = backend.newCompilationResultBuilder(lirGenRes, compilationResult, factory); + backend.emitCode(crb, lirGenRes.getLIR(), installedCodeOwner); crb.finish(); if (!assumptions.isEmpty()) { compilationResult.setAssumptions(assumptions);
--- a/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/alloc/LinearScan.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/alloc/LinearScan.java Wed Mar 19 15:22:14 2014 +0100 @@ -172,13 +172,13 @@ } public int getFirstLirInstructionId(AbstractBlock<?> block) { - int result = ir.lir(block).get(0).id(); + int result = ir.getLIRforBlock(block).get(0).id(); assert result >= 0; return result; } public int getLastLirInstructionId(AbstractBlock<?> block) { - List<LIRInstruction> instructions = ir.lir(block); + List<LIRInstruction> instructions = ir.getLIRforBlock(block); int result = instructions.get(instructions.size() - 1).id(); assert result >= 0; return result; @@ -517,7 +517,7 @@ LIRInsertionBuffer insertionBuffer = new LIRInsertionBuffer(); for (AbstractBlock<?> block : sortedBlocks) { - List<LIRInstruction> instructions = ir.lir(block); + List<LIRInstruction> instructions = ir.getLIRforBlock(block); int numInst = instructions.size(); // iterate all instructions of the block. skip the first because it is always a label @@ -624,7 +624,7 @@ // Assign IDs to LIR nodes and build a mapping, lirOps, from ID to LIRInstruction node. int numInstructions = 0; for (AbstractBlock<?> block : sortedBlocks) { - numInstructions += ir.lir(block).size(); + numInstructions += ir.getLIRforBlock(block).size(); } // initialize with correct length @@ -636,7 +636,7 @@ for (AbstractBlock<?> block : sortedBlocks) { blockData.put(block, new BlockData()); - List<LIRInstruction> instructions = ir.lir(block); + List<LIRInstruction> instructions = ir.getLIRforBlock(block); int numInst = instructions.size(); for (int j = 0; j < numInst; j++) { @@ -681,7 +681,7 @@ final BitSet liveGen = new BitSet(liveSize); final BitSet liveKill = new BitSet(liveSize); - List<LIRInstruction> instructions = ir.lir(block); + List<LIRInstruction> instructions = ir.getLIRforBlock(block); int numInst = instructions.size(); // iterate all instructions of the block @@ -920,7 +920,7 @@ if (blockData.get(block).liveGen.get(operandNum)) { usedIn.add(block); try (Indent indent3 = Debug.logAndIndent("used in block B%d", block.getId())) { - for (LIRInstruction ins : ir.lir(block)) { + for (LIRInstruction ins : ir.getLIRforBlock(block)) { try (Indent indent4 = Debug.logAndIndent("%d: %s", ins.id(), ins)) { ins.forEachState(new ValueProcedure() { @@ -937,7 +937,7 @@ if (blockData.get(block).liveKill.get(operandNum)) { definedIn.add(block); try (Indent indent3 = Debug.logAndIndent("defined in block B%d", block.getId())) { - for (LIRInstruction ins : ir.lir(block)) { + for (LIRInstruction ins : ir.getLIRforBlock(block)) { Debug.log("%d: %s", ins.id(), ins); } } @@ -1161,7 +1161,7 @@ AbstractBlock<?> block = blockAt(i); Indent indent2 = Debug.logAndIndent("handle block %d", block.getId()); - List<LIRInstruction> instructions = ir.lir(block); + List<LIRInstruction> instructions = ir.getLIRforBlock(block); final int blockFrom = getFirstLirInstructionId(block); int blockTo = getLastLirInstructionId(block); @@ -1510,7 +1510,7 @@ if (fromBlock.getSuccessorCount() <= 1) { Debug.log("inserting moves at end of fromBlock B%d", fromBlock.getId()); - List<LIRInstruction> instructions = ir.lir(fromBlock); + List<LIRInstruction> instructions = ir.getLIRforBlock(fromBlock); LIRInstruction instr = instructions.get(instructions.size() - 1); if (instr instanceof StandardOp.JumpOp) { // insert moves before branch @@ -1523,7 +1523,7 @@ Debug.log("inserting moves at beginning of toBlock B%d", toBlock.getId()); if (DetailedAsserts.getValue()) { - assert ir.lir(fromBlock).get(0) instanceof StandardOp.LabelOp : "block does not start with a label"; + assert ir.getLIRforBlock(fromBlock).get(0) instanceof StandardOp.LabelOp : "block does not start with a label"; // because the number of predecessor edges matches the number of // successor edges, blocks which are reached by switch statements @@ -1534,7 +1534,7 @@ } } - moveResolver.setInsertPosition(ir.lir(toBlock), 1); + moveResolver.setInsertPosition(ir.getLIRforBlock(toBlock), 1); } } @@ -1554,7 +1554,7 @@ // check if block has only one predecessor and only one successor if (block.getPredecessorCount() == 1 && block.getSuccessorCount() == 1) { - List<LIRInstruction> instructions = ir.lir(block); + List<LIRInstruction> instructions = ir.getLIRforBlock(block); assert instructions.get(0) instanceof StandardOp.LabelOp : "block must start with label"; assert instructions.get(instructions.size() - 1) instanceof StandardOp.JumpOp : "block with successor must end with unconditional jump"; @@ -1636,7 +1636,7 @@ // before the branch instruction. So the split child information for this branch // would // be incorrect. - LIRInstruction instr = ir.lir(block).get(ir.lir(block).size() - 1); + LIRInstruction instr = ir.getLIRforBlock(block).get(ir.getLIRforBlock(block).size() - 1); if (instr instanceof StandardOp.JumpOp) { if (blockData.get(block).liveOut.get(operandNumber(operand))) { assert false : "can't get split child for the last branch of a block because the information would be incorrect (moves are inserted before the branch in resolveDataFlow)"; @@ -1752,7 +1752,7 @@ // are not // considered in the live ranges of intervals) // Solution: use the first opId of the branch target block instead. - final LIRInstruction instr = ir.lir(block).get(ir.lir(block).size() - 1); + final LIRInstruction instr = ir.getLIRforBlock(block).get(ir.getLIRforBlock(block).size() - 1); if (instr instanceof StandardOp.JumpOp) { if (blockData.get(block).liveOut.get(operandNumber(operand))) { tempOpId = getFirstLirInstructionId(block.getSuccessors().iterator().next()); @@ -1846,7 +1846,7 @@ try (Indent indent = Debug.logAndIndent("assign locations")) { for (AbstractBlock<?> block : sortedBlocks) { try (Indent indent2 = Debug.logAndIndent("assign locations in block B%d", block.getId())) { - assignLocations(ir.lir(block), iw); + assignLocations(ir.getLIRforBlock(block), iw); } } } @@ -2060,7 +2060,7 @@ IntervalWalker iw = new IntervalWalker(this, fixedIntervals, otherIntervals); for (AbstractBlock<?> block : sortedBlocks) { - List<LIRInstruction> instructions = ir.lir(block); + List<LIRInstruction> instructions = ir.getLIRforBlock(block); for (int j = 0; j < instructions.size(); j++) { LIRInstruction op = instructions.get(j);
--- a/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/alloc/LinearScanWalker.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/alloc/LinearScanWalker.java Wed Mar 19 15:22:14 2014 +0100 @@ -244,7 +244,7 @@ // numbering of instructions is known. // When the block already contains spill moves, the index must be increased until the // correct index is reached. - List<LIRInstruction> instructions = allocator.ir.lir(opBlock); + List<LIRInstruction> instructions = allocator.ir.getLIRforBlock(opBlock); int index = (opId - instructions.get(0).id()) >> 1; assert instructions.get(index).id() <= opId : "error in calculation";
--- a/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/alloc/RegisterVerifier.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/alloc/RegisterVerifier.java Wed Mar 19 15:22:14 2014 +0100 @@ -106,7 +106,7 @@ } // process all operations of the block - processOperations(allocator.ir.lir(block), inputState); + processOperations(allocator.ir.getLIRforBlock(block), inputState); // iterate all successors for (AbstractBlock<?> succ : block.getSuccessors()) {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/LIRGenerationResult.java Wed Mar 19 15:22:14 2014 +0100 @@ -0,0 +1,35 @@ +/* + * 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.compiler.gen; + +import com.oracle.graal.lir.*; + +public interface LIRGenerationResult { + FrameMap getFrameMap(); + + LIR getLIR(); + + boolean hasForeignCall(); + + void setForeignCall(boolean b); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/LIRGenerationResultBase.java Wed Mar 19 15:22:14 2014 +0100 @@ -0,0 +1,59 @@ +/* + * 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.compiler.gen; + +import com.oracle.graal.lir.*; + +public class LIRGenerationResultBase implements LIRGenerationResult { + private final LIR lir; + private final FrameMap frameMap; + /** + * Records whether the code being generated makes at least one foreign call. + */ + private boolean hasForeignCall; + + public LIRGenerationResultBase(LIR lir, FrameMap frameMap) { + this.lir = lir; + this.frameMap = frameMap; + } + + public LIR getLIR() { + return lir; + } + + /** + * Determines whether the code being generated makes at least one foreign call. + */ + public boolean hasForeignCall() { + return hasForeignCall; + } + + public final void setForeignCall(boolean hasForeignCall) { + this.hasForeignCall = hasForeignCall; + } + + public final FrameMap getFrameMap() { + return frameMap; + } + +}
--- a/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/LIRGenerator.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/LIRGenerator.java Wed Mar 19 15:22:14 2014 +0100 @@ -57,7 +57,7 @@ /** * This class traverses the HIR instructions and generates LIR instructions from them. */ -public abstract class LIRGenerator implements LIRGeneratorTool, LIRTypeTool { +public abstract class LIRGenerator implements LIRGeneratorTool, LIRTypeTool, LIRGeneratorCommon, NodeBasedLIRGenerator { public static class Options { // @formatter:off @@ -68,16 +68,13 @@ // @formatter:on } - private final FrameMap frameMap; - private final NodeMap<Value> nodeOperands; - private final LIR lir; + private final Providers providers; + private final CallingConvention cc; - private final Providers providers; - protected final CallingConvention cc; + private final NodeMap<Value> nodeOperands; + private final DebugInfoBuilder debugInfoBuilder; - protected final DebugInfoBuilder debugInfoBuilder; - - protected Block currentBlock; + protected AbstractBlock<?> currentBlock; private final int traceLevel; private final boolean printIRWithLIR; @@ -143,7 +140,7 @@ if (index >= 0) { // Replace the move with a filler op so that the operation // list does not need to be adjusted. - List<LIRInstruction> instructions = lir.lir(block); + List<LIRInstruction> instructions = lir.getLIRforBlock(block); instructions.set(index, new NoOp(null, -1)); index = -1; } @@ -155,10 +152,7 @@ private ValueNode currentInstruction; private ValueNode lastInstructionPrinted; // Debugging only - /** - * Records whether the code being generated makes at least one foreign call. - */ - private boolean hasForeignCall; + protected LIRGenerationResult res; /** * Checks whether the supplied constant can be used without loading it into a register for store @@ -170,13 +164,21 @@ */ public abstract boolean canStoreConstant(Constant c, boolean isCompressed); - public LIRGenerator(StructuredGraph graph, Providers providers, FrameMap frameMap, CallingConvention cc, LIR lir) { + public LIRGenerator(Providers providers, CallingConvention cc, LIRGenerationResult res) { + this(null, providers, cc, res); + } + + public LIRGenerator(StructuredGraph graph, Providers providers, CallingConvention cc, LIRGenerationResult res) { + this.res = res; this.providers = providers; - this.frameMap = frameMap; this.cc = cc; - this.nodeOperands = graph.createNodeMap(); - this.lir = lir; - this.debugInfoBuilder = createDebugInfoBuilder(nodeOperands); + if (graph != null) { + this.nodeOperands = graph.createNodeMap(); + this.debugInfoBuilder = createDebugInfoBuilder(nodeOperands); + } else { + this.nodeOperands = null; + this.debugInfoBuilder = null; + } this.traceLevel = Options.TraceLIRGeneratorLevel.getValue(); this.printIRWithLIR = Options.PrintIRWithLIR.getValue(); } @@ -219,13 +221,6 @@ } /** - * Determines whether the code being generated makes at least one foreign call. - */ - public boolean hasForeignCall() { - return hasForeignCall; - } - - /** * Returns the operand that has been previously initialized by * {@link #setResult(ValueNode, Value)} with the result of an instruction. * @@ -255,18 +250,19 @@ constantLoads = new HashMap<>(); } LoadConstant load = constantLoads.get(value); + assert currentBlock instanceof Block; if (load == null) { - int index = lir.lir(currentBlock).size(); + int index = res.getLIR().getLIRforBlock(currentBlock).size(); loadedValue = emitMove(value); - LIRInstruction op = lir.lir(currentBlock).get(index); - constantLoads.put(value, new LoadConstant(loadedValue, currentBlock, index, op)); + LIRInstruction op = res.getLIR().getLIRforBlock(currentBlock).get(index); + constantLoads.put(value, new LoadConstant(loadedValue, (Block) currentBlock, index, op)); } else { - Block dominator = ControlFlowGraph.commonDominator(load.block, currentBlock); + Block dominator = ControlFlowGraph.commonDominator(load.block, (Block) currentBlock); loadedValue = load.variable; if (dominator != load.block) { - load.unpin(lir); + load.unpin(res.getLIR()); } else { - assert load.block != currentBlock || load.index < lir.lir(currentBlock).size(); + assert load.block != currentBlock || load.index < res.getLIR().getLIRforBlock(currentBlock).size(); } load.block = dominator; } @@ -280,7 +276,7 @@ } public ValueNode valueForOperand(Value value) { - for (Entry<Node, Value> entry : nodeOperands.entries()) { + for (Entry<Node, Value> entry : getNodeOperands().entries()) { if (entry.getValue().equals(value)) { return (ValueNode) entry.getKey(); } @@ -296,12 +292,12 @@ */ @Override public Variable newVariable(PlatformKind platformKind) { - return new Variable(platformKind, lir.nextVariable()); + return new Variable(platformKind, res.getLIR().nextVariable()); } @Override public RegisterAttributes attributes(Register register) { - return frameMap.registerConfig.getAttributesMap()[register.number]; + return res.getFrameMap().registerConfig.getAttributesMap()[register.number]; } @Override @@ -341,12 +337,13 @@ } public LabelRef getLIRBlock(FixedNode b) { - assert lir.getControlFlowGraph() instanceof ControlFlowGraph; - Block result = ((ControlFlowGraph) lir.getControlFlowGraph()).blockFor(b); + assert res.getLIR().getControlFlowGraph() instanceof ControlFlowGraph; + Block result = ((ControlFlowGraph) res.getLIR().getControlFlowGraph()).blockFor(b); int suxIndex = currentBlock.getSuccessors().indexOf(result); assert suxIndex != -1 : "Block not in successor list of current block"; - return LabelRef.forSuccessor(lir, currentBlock, suxIndex); + assert currentBlock instanceof Block; + return LabelRef.forSuccessor(res.getLIR(), (Block) currentBlock, suxIndex); } /** @@ -379,7 +376,7 @@ return new LIRFrameState(null, null, null); } assert state != null; - return debugInfoBuilder.build(state, exceptionEdge); + return getDebugInfoBuilder().build(state, exceptionEdge); } /** @@ -393,7 +390,7 @@ if (kind == Kind.Void) { return ILLEGAL; } - return frameMap.registerConfig.getReturnRegister(kind).asValue(kind); + return res.getFrameMap().registerConfig.getReturnRegister(kind).asValue(kind); } public void append(LIRInstruction op) { @@ -407,10 +404,10 @@ TTY.println(); } assert LIRVerifier.verify(op); - lir.lir(currentBlock).add(op); + res.getLIR().getLIRforBlock(currentBlock).add(op); } - public void doBlock(Block block, StructuredGraph graph, BlockMap<List<ScheduledNode>> blockMap) { + private final void doBlockStart(AbstractBlock<?> block) { if (printIRWithLIR) { TTY.print(block.toString()); } @@ -418,16 +415,43 @@ currentBlock = block; // set up the list of LIR instructions - assert lir.lir(block) == null : "LIR list already computed for this block"; - lir.setLir(block, new ArrayList<LIRInstruction>()); + 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()); } + } - if (block == lir.getControlFlowGraph().getStartBlock()) { + private final void doBlockEnd(AbstractBlock<?> block) { + + if (traceLevel >= 1) { + TTY.println("END Generating LIR for block B" + block.getId()); + } + + currentBlock = null; + + if (printIRWithLIR) { + TTY.println(); + } + } + + /** + * For Baseline compilation + */ + public void doBlock(AbstractBlock<?> block) { + doBlockStart(block); + // add instruction + emitAdd(Constant.forLong(42), Constant.forLong(73)); + doBlockEnd(block); + } + + 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 { @@ -474,23 +498,14 @@ emitJump(getLIRBlock((FixedNode) successors.first())); } - assert verifyBlock(lir, block); - - if (traceLevel >= 1) { - TTY.println("END Generating LIR for block B" + block.getId()); - } - - currentBlock = null; - - if (printIRWithLIR) { - TTY.println(); - } + assert verifyBlock(res.getLIR(), block); + doBlockEnd(block); } protected abstract boolean peephole(ValueNode valueNode); private boolean hasBlockEnd(Block block) { - List<LIRInstruction> ops = lir.lir(block); + List<LIRInstruction> ops = res.getLIR().getLIRforBlock(block); if (ops.size() == 0) { return false; } @@ -514,6 +529,8 @@ } 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) { @@ -524,15 +541,15 @@ } protected void emitPrologue(StructuredGraph graph) { - CallingConvention incomingArguments = cc; + CallingConvention incomingArguments = 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() && !lir.hasArgInCallerFrame()) { - lir.setHasArgInCallerFrame(); + if (slot.isInCallerFrame() && !res.getLIR().hasArgInCallerFrame()) { + res.getLIR().setHasArgInCallerFrame(); } } } @@ -547,7 +564,7 @@ } public void emitIncomingValues(Value[] params) { - ((LabelOp) lir.lir(currentBlock).get(0)).setIncomingValues(params); + ((LabelOp) res.getLIR().getLIRforBlock(currentBlock).get(0)).setIncomingValues(params); } @Override @@ -686,8 +703,8 @@ @Override public void emitInvoke(Invoke x) { LoweredCallTargetNode callTarget = (LoweredCallTargetNode) x.callTarget(); - CallingConvention invokeCc = frameMap.registerConfig.getCallingConvention(callTarget.callType(), x.asNode().stamp().javaType(getMetaAccess()), callTarget.signature(), target(), false); - frameMap.callsMethod(invokeCc); + CallingConvention invokeCc = res.getFrameMap().registerConfig.getCallingConvention(callTarget.callType(), x.asNode().stamp().javaType(getMetaAccess()), callTarget.signature(), target(), false); + res.getFrameMap().callsMethod(invokeCc); Value[] parameters = visitInvokeArguments(invokeCc, callTarget.arguments()); @@ -767,7 +784,7 @@ // move the arguments into the correct location CallingConvention linkageCc = linkage.getOutgoingCallingConvention(); - frameMap.callsMethod(linkageCc); + res.getFrameMap().callsMethod(linkageCc); assert linkageCc.getArgumentCount() == args.length : "argument count mismatch"; Value[] argLocations = new Value[args.length]; for (int i = 0; i < args.length; i++) { @@ -776,7 +793,7 @@ emitMove(loc, arg); argLocations[i] = loc; } - this.hasForeignCall = true; + res.setForeignCall(true); emitForeignCall(linkage, linkageCc.getReturn(), argLocations, linkage.getTemporaries(), state); if (isLegal(linkageCc.getReturn())) { @@ -857,16 +874,18 @@ protected abstract void emitTableSwitch(int lowKey, LabelRef defaultTarget, LabelRef[] targets, Value key); - public final LIR getLIR() { - return lir; - } - public final NodeMap<Value> getNodeOperands() { + assert nodeOperands != null; return nodeOperands; } - public final FrameMap getFrameMap() { - return frameMap; + public CallingConvention getCallingConvention() { + return cc; + } + + public DebugInfoBuilder getDebugInfoBuilder() { + assert debugInfoBuilder != null; + return debugInfoBuilder; } @Override @@ -892,13 +911,13 @@ outOfLoopDominator = outOfLoopDominator.getDominator(); } if (outOfLoopDominator != lc.block) { - lc.unpin(lir); + lc.unpin(res.getLIR()); lc.block = outOfLoopDominator; } } if (lc.index != -1) { - assert lir.lir(lc.block).get(lc.index) == lc.op; + assert res.getLIR().getLIRforBlock(lc.block).get(lc.index) == lc.op; iter.remove(); } } @@ -919,7 +938,7 @@ } int groupSize = groupEnd - groupBegin; - List<LIRInstruction> ops = lir.lir(block); + List<LIRInstruction> ops = res.getLIR().getLIRforBlock(block); int lastIndex = ops.size() - 1; assert ops.get(lastIndex) instanceof BlockEndOp; int insertionIndex = lastIndex;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/LIRGeneratorCommon.java Wed Mar 19 15:22:14 2014 +0100 @@ -0,0 +1,106 @@ +package com.oracle.graal.compiler.gen; + +import com.oracle.graal.api.code.*; +import com.oracle.graal.api.meta.*; +import com.oracle.graal.lir.*; +import com.oracle.graal.nodes.calc.*; +import com.oracle.graal.nodes.cfg.*; +import com.oracle.graal.nodes.type.*; + +public interface LIRGeneratorCommon { + + /** + * Checks whether the supplied constant can be used without loading it into a register for store + * operations, i.e., on the right hand side of a memory access. + * + * @param c The constant to check. + * @return True if the constant can be used directly, false if the constant needs to be in a + * register. + */ + boolean canStoreConstant(Constant c, boolean isCompressed); + + /** + * Returns true if the redundant move elimination optimization should be done after register + * allocation. + */ + boolean canEliminateRedundantMoves(); + + TargetDescription target(); + + MetaAccessProvider getMetaAccess(); + + CodeCacheProvider getCodeCache(); + + ForeignCallsProvider getForeignCalls(); + + /** + * Creates a new {@linkplain Variable variable}. + * + * @param platformKind The kind of the new variable. + * @return a new variable + */ + Variable newVariable(PlatformKind platformKind); + + RegisterAttributes attributes(Register register); + + Variable emitMove(Value input); + + AllocatableValue asAllocatable(Value value); + + Variable load(Value value); + + Value loadNonConst(Value value); + + void doBlock(AbstractBlock<?> block); + + /** + * Gets the ABI specific operand used to return a value of a given kind from a method. + * + * @param kind the kind of value being returned + * @return the operand representing the ABI defined location used return a value of kind + * {@code kind} + */ + AllocatableValue resultOperandFor(Kind kind); + + void append(LIRInstruction op); + + void emitIncomingValues(Value[] params); + + void emitConstantBranch(boolean value, LabelRef trueSuccessorBlock, LabelRef falseSuccessorBlock); + + void emitJump(LabelRef label); + + void emitCompareBranch(Value left, Value right, Condition cond, boolean unorderedIsTrue, LabelRef trueDestination, LabelRef falseDestination, double trueDestinationProbability); + + void emitOverflowCheckBranch(LabelRef overflow, LabelRef noOverflow, double overflowProbability); + + void emitIntegerTestBranch(Value left, Value right, LabelRef trueDestination, LabelRef falseDestination, double trueSuccessorProbability); + + Variable emitConditionalMove(Value leftVal, Value right, Condition cond, boolean unorderedIsTrue, Value trueValue, Value falseValue); + + Variable emitIntegerTestMove(Value leftVal, Value right, Value trueValue, Value falseValue); + + CallingConvention getCallingConvention(); + + /** + * Default implementation: Return the Java stack kind for each stamp. + */ + PlatformKind getPlatformKind(Stamp stamp); + + PlatformKind getIntegerKind(int bits, boolean unsigned); + + PlatformKind getFloatingKind(int bits); + + PlatformKind getObjectKind(); + + void emitBitCount(Variable result, Value operand); + + void emitBitScanForward(Variable result, Value operand); + + void emitBitScanReverse(Variable result, Value operand); + + void emitByteSwap(Variable result, Value operand); + + void emitArrayEquals(Kind kind, Variable result, Value array1, Value array2, Value length); + +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/NodeBasedLIRGenerator.java Wed Mar 19 15:22:14 2014 +0100 @@ -0,0 +1,82 @@ +package com.oracle.graal.compiler.gen; + +import java.util.*; + +import com.oracle.graal.api.code.*; +import com.oracle.graal.api.meta.*; +import com.oracle.graal.lir.*; +import com.oracle.graal.nodes.*; +import com.oracle.graal.nodes.calc.*; +import com.oracle.graal.nodes.cfg.*; +import com.oracle.graal.nodes.extended.*; + +public interface NodeBasedLIRGenerator { + + /** + * Returns the operand that has been previously initialized by + * {@link #setResult(ValueNode, Value)} with the result of an instruction. + * + * @param node A node that produces a result value. + */ + Value operand(ValueNode node); + + ValueNode valueForOperand(Value value); + + Value setResult(ValueNode x, Value operand); + + LabelRef getLIRBlock(FixedNode b); + + LIRFrameState state(DeoptimizingNode deopt); + + LIRFrameState stateWithExceptionEdge(DeoptimizingNode deopt, LabelRef exceptionEdge); + + LIRFrameState stateFor(FrameState state); + + LIRFrameState stateForWithExceptionEdge(FrameState state, LabelRef exceptionEdge); + + void append(LIRInstruction op); + + void doBlock(Block block, StructuredGraph graph, BlockMap<List<ScheduledNode>> blockMap); + + void visitReturn(ReturnNode x); + + void visitMerge(MergeNode x); + + void visitEndNode(AbstractEndNode end); + + /** + * Runtime specific classes can override this to insert a safepoint at the end of a loop. + */ + void visitLoopEnd(LoopEndNode x); + + void emitIf(IfNode x); + + void emitBranch(LogicNode node, LabelRef trueSuccessor, LabelRef falseSuccessor, double trueSuccessorProbability); + + void emitCompareBranch(CompareNode compare, LabelRef trueSuccessor, LabelRef falseSuccessor, double trueSuccessorProbability); + + void emitIntegerTestBranch(IntegerTestNode test, LabelRef trueSuccessor, LabelRef falseSuccessor, double trueSuccessorProbability); + + void emitConditional(ConditionalNode conditional); + + Variable emitConditional(LogicNode node, Value trueValue, Value falseValue); + + void emitInvoke(Invoke x); + + Value[] visitInvokeArguments(CallingConvention invokeCc, Collection<ValueNode> arguments); + + Variable emitForeignCall(ForeignCallLinkage linkage, DeoptimizingNode info, Value... args); + + /** + * 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. + */ + void emitSwitch(SwitchNode x); + + void beforeRegisterAllocation(); + +} \ No newline at end of file
--- a/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/target/Backend.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/target/Backend.java Wed Mar 19 15:22:14 2014 +0100 @@ -65,7 +65,9 @@ public abstract FrameMap newFrameMap(); - public abstract LIRGenerator newLIRGenerator(StructuredGraph graph, Object stub, FrameMap frameMap, CallingConvention cc, LIR lir); + public abstract LIRGenerator newLIRGenerator(StructuredGraph graph, CallingConvention cc, LIRGenerationResult lirGenRes); + + public abstract LIRGenerationResult newLIRGenerationResult(LIR lir, FrameMap frameMap, Object stub); /** * Creates the assembler used to emit the machine code. @@ -75,7 +77,7 @@ /** * Creates the object used to fill in the details of a given compilation result. */ - public abstract CompilationResultBuilder newCompilationResultBuilder(LIRGenerator lirGen, CompilationResult compilationResult, CompilationResultBuilderFactory factory); + public abstract CompilationResultBuilder newCompilationResultBuilder(LIRGenerationResult lirGenResult, CompilationResult compilationResult, CompilationResultBuilderFactory factory); public abstract boolean shouldAllocateRegisters();
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/target/LIRGenResLowerable.java Wed Mar 19 15:22:14 2014 +0100 @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2011, 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.target; + +import com.oracle.graal.compiler.gen.*; +import com.oracle.graal.lir.*; +import com.oracle.graal.nodes.spi.*; + +/** + * An alternative to {@link LIRLowerable} for lowering that is tightly coupled to + * {@link LIRGenerationResult} and {@link LIRInstruction}. + */ +public interface LIRGenResLowerable { + + void generate(LIRGenerator generator, LIRGenerationResult genRes); +}
--- a/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotBackend.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotBackend.java Wed Mar 19 15:22:14 2014 +0100 @@ -72,8 +72,13 @@ } @Override - public LIRGenerator newLIRGenerator(StructuredGraph graph, Object stub, FrameMap frameMap, CallingConvention cc, LIR lir) { - return new AMD64HotSpotLIRGenerator(graph, stub, getProviders(), getRuntime().getConfig(), frameMap, cc, lir); + public LIRGenerator newLIRGenerator(StructuredGraph graph, CallingConvention cc, LIRGenerationResult lirGenRes) { + return new AMD64HotSpotLIRGenerator(graph, getProviders(), getRuntime().getConfig(), cc, lirGenRes); + } + + @Override + public LIRGenerationResult newLIRGenerationResult(LIR lir, FrameMap frameMap, Object stub) { + return new AMD64HotSpotLIRGenerationResult(lir, frameMap, stub); } /** @@ -192,17 +197,17 @@ } @Override - public CompilationResultBuilder newCompilationResultBuilder(LIRGenerator lirGen, CompilationResult compilationResult, CompilationResultBuilderFactory factory) { + public CompilationResultBuilder newCompilationResultBuilder(LIRGenerationResult lirGenRen, CompilationResult compilationResult, CompilationResultBuilderFactory factory) { // Omit the frame if the method: // - has no spill slots or other slots allocated during register allocation // - has no callee-saved registers // - has no incoming arguments passed on the stack // - has no deoptimization points // - makes no foreign calls (which require an aligned stack) - AMD64HotSpotLIRGenerator gen = (AMD64HotSpotLIRGenerator) lirGen; + AMD64HotSpotLIRGenerationResult gen = (AMD64HotSpotLIRGenerationResult) lirGenRen; FrameMap frameMap = gen.getFrameMap(); LIR lir = gen.getLIR(); - assert gen.deoptimizationRescueSlot == null || frameMap.frameNeedsAllocating() : "method that can deoptimize must have a frame"; + assert gen.getDeoptimizationRescueSlot() == null || frameMap.frameNeedsAllocating() : "method that can deoptimize must have a frame"; boolean omitFrame = CanOmitFrame.getValue() && !frameMap.frameNeedsAllocating() && !lir.hasArgInCallerFrame() && !gen.hasForeignCall(); Stub stub = gen.getStub(); @@ -210,14 +215,14 @@ HotSpotFrameContext frameContext = new HotSpotFrameContext(stub != null, omitFrame); CompilationResultBuilder crb = factory.createBuilder(getCodeCache(), getForeignCalls(), frameMap, masm, frameContext, compilationResult); crb.setFrameSize(frameMap.frameSize()); - StackSlot deoptimizationRescueSlot = gen.deoptimizationRescueSlot; + StackSlot deoptimizationRescueSlot = gen.getDeoptimizationRescueSlot(); if (deoptimizationRescueSlot != null && stub == null) { crb.compilationResult.setCustomStackAreaOffset(frameMap.offsetForStackSlot(deoptimizationRescueSlot)); } if (stub != null) { Set<Register> definedRegisters = gatherDefinedRegisters(lir); - updateStub(stub, definedRegisters, gen.calleeSaveInfo, frameMap); + updateStub(stub, definedRegisters, gen.getCalleeSaveInfo(), frameMap); } return crb;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotLIRGenerationResult.java Wed Mar 19 15:22:14 2014 +0100 @@ -0,0 +1,70 @@ +/* + * 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.hotspot.amd64; + +import java.util.*; + +import com.oracle.graal.api.code.*; +import com.oracle.graal.compiler.gen.*; +import com.oracle.graal.hotspot.stubs.*; +import com.oracle.graal.lir.*; +import com.oracle.graal.lir.StandardOp.SaveRegistersOp; + +public class AMD64HotSpotLIRGenerationResult extends LIRGenerationResultBase { + + /** + * The slot reserved for storing the original return address when a frame is marked for + * deoptimization. The return address slot in the callee is overwritten with the address of a + * deoptimization stub. + */ + private StackSlot deoptimizationRescueSlot; + private final Object stub; + + /** + * Map from debug infos that need to be updated with callee save information to the operations + * that provide the information. + */ + private Map<LIRFrameState, SaveRegistersOp> calleeSaveInfo = new HashMap<>(); + + public AMD64HotSpotLIRGenerationResult(LIR lir, FrameMap frameMap, Object stub) { + super(lir, frameMap); + this.stub = stub; + } + + StackSlot getDeoptimizationRescueSlot() { + return deoptimizationRescueSlot; + } + + public final void setDeoptimizationRescueSlot(StackSlot deoptimizationRescueSlot) { + this.deoptimizationRescueSlot = deoptimizationRescueSlot; + } + + Stub getStub() { + return (Stub) stub; + } + + Map<LIRFrameState, SaveRegistersOp> getCalleeSaveInfo() { + return calleeSaveInfo; + } + +}
--- a/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotLIRGenerator.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotLIRGenerator.java Wed Mar 19 15:22:14 2014 +0100 @@ -50,7 +50,6 @@ import com.oracle.graal.hotspot.stubs.*; import com.oracle.graal.lir.*; import com.oracle.graal.lir.StandardOp.NoOp; -import com.oracle.graal.lir.StandardOp.SaveRegistersOp; import com.oracle.graal.lir.amd64.*; import com.oracle.graal.lir.amd64.AMD64ControlFlow.CondMoveOp; import com.oracle.graal.lir.amd64.AMD64Move.CompareAndSwapOp; @@ -60,6 +59,7 @@ import com.oracle.graal.lir.amd64.AMD64Move.StoreOp; import com.oracle.graal.nodes.*; import com.oracle.graal.nodes.calc.*; +import com.oracle.graal.nodes.cfg.*; import com.oracle.graal.nodes.extended.*; import com.oracle.graal.nodes.java.*; import com.oracle.graal.nodes.java.MethodCallTargetNode.InvokeKind; @@ -71,13 +71,10 @@ private final HotSpotVMConfig config; - private final Object stub; - - protected AMD64HotSpotLIRGenerator(StructuredGraph graph, Object stub, HotSpotProviders providers, HotSpotVMConfig config, FrameMap frameMap, CallingConvention cc, LIR lir) { - super(graph, providers, frameMap, cc, lir); + protected AMD64HotSpotLIRGenerator(StructuredGraph graph, HotSpotProviders providers, HotSpotVMConfig config, CallingConvention cc, LIRGenerationResult lirGenRes) { + super(graph, providers, cc, lirGenRes); assert config.basicLockSize == 8; this.config = config; - this.stub = stub; } @Override @@ -86,13 +83,6 @@ } /** - * The slot reserved for storing the original return address when a frame is marked for - * deoptimization. The return address slot in the callee is overwritten with the address of a - * deoptimization stub. - */ - StackSlot deoptimizationRescueSlot; - - /** * Utility for emitting the instruction to save RBP. */ class SaveRbp { @@ -106,7 +96,7 @@ public SaveRbp(NoOp placeholder) { this.placeholder = placeholder; - this.reservedSlot = getFrameMap().allocateSpillSlot(Kind.Long); + this.reservedSlot = res.getFrameMap().allocateSpillSlot(Kind.Long); assert reservedSlot.getRawOffset() == -16 : reservedSlot.getRawOffset(); } @@ -120,11 +110,11 @@ if (useStack) { dst = reservedSlot; } else { - getFrameMap().freeSpillSlot(reservedSlot); + res.getFrameMap().freeSpillSlot(reservedSlot); dst = newVariable(Kind.Long); } - placeholder.replace(getLIR(), new MoveFromRegOp(dst, rbp.asValue(Kind.Long))); + placeholder.replace(res.getLIR(), new MoveFromRegOp(dst, rbp.asValue(Kind.Long))); return dst; } } @@ -146,27 +136,27 @@ @Override protected DebugInfoBuilder createDebugInfoBuilder(NodeMap<Value> nodeOperands) { - HotSpotLockStack lockStack = new HotSpotLockStack(getFrameMap(), Kind.Long); + HotSpotLockStack lockStack = new HotSpotLockStack(res.getFrameMap(), Kind.Long); return new HotSpotDebugInfoBuilder(nodeOperands, lockStack); } @Override public StackSlot getLockSlot(int lockDepth) { - return ((HotSpotDebugInfoBuilder) debugInfoBuilder).lockStack().makeLockSlot(lockDepth); + return ((HotSpotDebugInfoBuilder) getDebugInfoBuilder()).lockStack().makeLockSlot(lockDepth); } @Override protected void emitPrologue(StructuredGraph graph) { - CallingConvention incomingArguments = cc; + CallingConvention incomingArguments = 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() && !getLIR().hasArgInCallerFrame()) { - getLIR().setHasArgInCallerFrame(); + if (slot.isInCallerFrame() && !res.getLIR().hasArgInCallerFrame()) { + res.getLIR().setHasArgInCallerFrame(); } } } @@ -174,7 +164,8 @@ emitIncomingValues(params); - saveRbp = new SaveRbp(new NoOp(currentBlock, getLIR().lir(currentBlock).size())); + assert currentBlock instanceof Block; + saveRbp = new SaveRbp(new NoOp((Block) currentBlock, res.getLIR().getLIRforBlock(currentBlock).size())); append(saveRbp.placeholder); for (ParameterNode param : graph.getNodes(ParameterNode.class)) { @@ -207,15 +198,9 @@ @Override protected boolean needOnlyOopMaps() { // Stubs only need oop maps - return stub != null; + return ((AMD64HotSpotLIRGenerationResult) res).getStub() != null; } - /** - * Map from debug infos that need to be updated with callee save information to the operations - * that provide the information. - */ - Map<LIRFrameState, SaveRegistersOp> calleeSaveInfo = new HashMap<>(); - private LIRFrameState currentRuntimeCallInfo; @Override @@ -234,8 +219,8 @@ append(new AMD64RestoreRegistersOp(save.getSlots().clone(), save)); } - Stub getStub() { - return (Stub) stub; + public Stub getStub() { + return ((AMD64HotSpotLIRGenerationResult) res).getStub(); } @Override @@ -247,12 +232,12 @@ if (destroysRegisters) { if (getStub() != null) { if (getStub().preservesRegisters()) { - Register[] savedRegisters = getFrameMap().registerConfig.getAllocatableRegisters(); + Register[] savedRegisters = res.getFrameMap().registerConfig.getAllocatableRegisters(); savedRegisterLocations = new StackSlot[savedRegisters.length]; for (int i = 0; i < savedRegisters.length; i++) { PlatformKind kind = target().arch.getLargestStorableKind(savedRegisters[i].getRegisterCategory()); assert kind != Kind.Illegal; - StackSlot spillSlot = getFrameMap().allocateSpillSlot(kind); + StackSlot spillSlot = res.getFrameMap().allocateSpillSlot(kind); savedRegisterLocations[i] = spillSlot; } save = emitSaveRegisters(savedRegisters, savedRegisterLocations); @@ -263,7 +248,7 @@ Variable result; if (linkage.canDeoptimize()) { - assert info != null || stub != null; + assert info != null || ((AMD64HotSpotLIRGenerationResult) res).getStub() != null; Register thread = getProviders().getRegisters().getThreadRegister(); append(new AMD64HotSpotCRuntimeCallPrologueOp(config.threadLastJavaSpOffset(), thread)); result = super.emitForeignCall(linkage, info, args); @@ -275,8 +260,8 @@ if (destroysRegisters) { if (getStub() != null) { if (getStub().preservesRegisters()) { - assert !calleeSaveInfo.containsKey(currentRuntimeCallInfo); - calleeSaveInfo.put(currentRuntimeCallInfo, save); + assert !((AMD64HotSpotLIRGenerationResult) res).getCalleeSaveInfo().containsKey(currentRuntimeCallInfo); + ((AMD64HotSpotLIRGenerationResult) res).getCalleeSaveInfo().put(currentRuntimeCallInfo, save); emitRestoreRegisters(save); } else { @@ -295,14 +280,14 @@ } protected boolean zapRegisters() { - Register[] zappedRegisters = getFrameMap().registerConfig.getAllocatableRegisters(); + Register[] zappedRegisters = res.getFrameMap().registerConfig.getAllocatableRegisters(); Constant[] zapValues = new Constant[zappedRegisters.length]; for (int i = 0; i < zappedRegisters.length; i++) { PlatformKind kind = target().arch.getLargestStorableKind(zappedRegisters[i].getRegisterCategory()); assert kind != Kind.Illegal; zapValues[i] = zapValueForKind(kind); } - calleeSaveInfo.put(currentRuntimeCallInfo, emitZapRegisters(zappedRegisters, zapValues)); + ((AMD64HotSpotLIRGenerationResult) res).getCalleeSaveInfo().put(currentRuntimeCallInfo, emitZapRegisters(zappedRegisters, zapValues)); return true; } @@ -349,7 +334,7 @@ @Override public void emitCCall(long address, CallingConvention nativeCallingConvention, Value[] args, int numberOfFloatingPointArguments) { Value[] argLocations = new Value[args.length]; - getFrameMap().callsMethod(nativeCallingConvention); + res.getFrameMap().callsMethod(nativeCallingConvention); // TODO(mg): in case a native function uses floating point varargs, the ABI requires that // RAX contains the length of the varargs AllocatableValue numberOfFloatingPointArgumentsRegister = AMD64.rax.asValue(); @@ -448,10 +433,10 @@ @Override public void beforeRegisterAllocation() { super.beforeRegisterAllocation(); - boolean hasDebugInfo = getLIR().hasDebugInfo(); + boolean hasDebugInfo = res.getLIR().hasDebugInfo(); AllocatableValue savedRbp = saveRbp.finalize(hasDebugInfo); if (hasDebugInfo) { - deoptimizationRescueSlot = getFrameMap().allocateSpillSlot(Kind.Long); + ((AMD64HotSpotLIRGenerationResult) res).setDeoptimizationRescueSlot(res.getFrameMap().allocateSpillSlot(Kind.Long)); } for (AMD64HotSpotEpilogueOp op : epilogueOps) {
--- a/graal/com.oracle.graal.hotspot.hsail/src/com/oracle/graal/hotspot/hsail/HSAILHotSpotBackend.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.hotspot.hsail/src/com/oracle/graal/hotspot/hsail/HSAILHotSpotBackend.java Wed Mar 19 15:22:14 2014 +0100 @@ -188,8 +188,13 @@ } @Override - public LIRGenerator newLIRGenerator(StructuredGraph graph, Object stub, FrameMap frameMap, CallingConvention cc, LIR lir) { - return new HSAILHotSpotLIRGenerator(graph, getProviders(), getRuntime().getConfig(), frameMap, cc, lir); + public LIRGenerator newLIRGenerator(StructuredGraph graph, CallingConvention cc, LIRGenerationResult lirGenRes) { + return new HSAILHotSpotLIRGenerator(graph, getProviders(), getRuntime().getConfig(), cc, lirGenRes); + } + + @Override + public LIRGenerationResult newLIRGenerationResult(LIR lir, FrameMap frameMap, Object stub) { + return new LIRGenerationResultBase(lir, frameMap); } class HotSpotFrameContext implements FrameContext { @@ -215,8 +220,8 @@ } @Override - public CompilationResultBuilder newCompilationResultBuilder(LIRGenerator lirGen, CompilationResult compilationResult, CompilationResultBuilderFactory factory) { - FrameMap frameMap = lirGen.getFrameMap(); + public CompilationResultBuilder newCompilationResultBuilder(LIRGenerationResult lirGenRes, CompilationResult compilationResult, CompilationResultBuilderFactory factory) { + FrameMap frameMap = lirGenRes.getFrameMap(); Assembler masm = createAssembler(frameMap); HotSpotFrameContext frameContext = new HotSpotFrameContext(); CompilationResultBuilder crb = factory.createBuilder(getCodeCache(), getForeignCalls(), frameMap, masm, frameContext, compilationResult); @@ -402,4 +407,5 @@ asm.emitString0("};"); asm.emitString(""); } + }
--- a/graal/com.oracle.graal.hotspot.hsail/src/com/oracle/graal/hotspot/hsail/HSAILHotSpotLIRGenerator.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.hotspot.hsail/src/com/oracle/graal/hotspot/hsail/HSAILHotSpotLIRGenerator.java Wed Mar 19 15:22:14 2014 +0100 @@ -26,9 +26,12 @@ import sun.misc.*; import com.oracle.graal.api.code.*; + import static com.oracle.graal.api.code.ValueUtil.asConstant; import static com.oracle.graal.api.code.ValueUtil.isConstant; + import com.oracle.graal.api.meta.*; +import com.oracle.graal.compiler.gen.*; import com.oracle.graal.compiler.hsail.*; import com.oracle.graal.hotspot.*; import com.oracle.graal.lir.*; @@ -49,8 +52,8 @@ private final HotSpotVMConfig config; - public HSAILHotSpotLIRGenerator(StructuredGraph graph, Providers providers, HotSpotVMConfig config, FrameMap frameMap, CallingConvention cc, LIR lir) { - super(graph, providers, frameMap, cc, lir); + public HSAILHotSpotLIRGenerator(StructuredGraph graph, Providers providers, HotSpotVMConfig config, CallingConvention cc, LIRGenerationResult lirGenRes) { + super(graph, providers, cc, lirGenRes); this.config = config; }
--- a/graal/com.oracle.graal.hotspot.ptx/src/com/oracle/graal/hotspot/ptx/PTXHotSpotBackend.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.hotspot.ptx/src/com/oracle/graal/hotspot/ptx/PTXHotSpotBackend.java Wed Mar 19 15:22:14 2014 +0100 @@ -327,13 +327,13 @@ } @Override - public CompilationResultBuilder newCompilationResultBuilder(LIRGenerator lirGen, CompilationResult compilationResult, CompilationResultBuilderFactory factory) { + public CompilationResultBuilder newCompilationResultBuilder(LIRGenerationResult lirGenRes, CompilationResult compilationResult, CompilationResultBuilderFactory factory) { // Omit the frame of the method: // - has no spill slots or other slots allocated during register allocation // - has no callee-saved registers // - has no incoming arguments passed on the stack // - has no instructions with debug info - FrameMap frameMap = lirGen.getFrameMap(); + FrameMap frameMap = lirGenRes.getFrameMap(); Assembler masm = createAssembler(frameMap); PTXFrameContext frameContext = new PTXFrameContext(); CompilationResultBuilder crb = factory.createBuilder(getCodeCache(), getForeignCalls(), frameMap, masm, frameContext, compilationResult); @@ -342,13 +342,18 @@ } @Override + public LIRGenerationResult newLIRGenerationResult(LIR lir, FrameMap frameMap, Object stub) { + return new LIRGenerationResultBase(lir, frameMap); + } + + @Override protected Assembler createAssembler(FrameMap frameMap) { return new PTXMacroAssembler(getTarget(), frameMap.registerConfig); } @Override - public LIRGenerator newLIRGenerator(StructuredGraph graph, Object stub, FrameMap frameMap, CallingConvention cc, LIR lir) { - return new PTXHotSpotLIRGenerator(graph, getProviders(), getRuntime().getConfig(), frameMap, cc, lir); + public LIRGenerator newLIRGenerator(StructuredGraph graph, CallingConvention cc, LIRGenerationResult lirGenRes) { + return new PTXHotSpotLIRGenerator(graph, getProviders(), getRuntime().getConfig(), cc, lirGenRes); } private static void emitKernelEntry(CompilationResultBuilder crb, LIR lir, ResolvedJavaMethod codeCacheOwner) { @@ -374,7 +379,7 @@ // Emit .param arguments to kernel entry based on ParameterOp // instruction. - for (LIRInstruction op : lir.lir(startBlock)) { + for (LIRInstruction op : lir.getLIRforBlock(startBlock)) { if (op instanceof PTXParameterOp) { op.emitCode(crb); deleteOps.add(op); @@ -383,7 +388,7 @@ // Delete ParameterOp instructions. for (LIRInstruction op : deleteOps) { - lir.lir(startBlock).remove(op); + lir.getLIRforBlock(startBlock).remove(op); } // Start emiting body of the PTX kernel. @@ -399,7 +404,7 @@ RegisterAnalysis registerAnalysis = new RegisterAnalysis(); for (AbstractBlock<?> b : lir.codeEmittingOrder()) { - for (LIRInstruction op : lir.lir(b)) { + for (LIRInstruction op : lir.getLIRforBlock(b)) { if (op instanceof LabelOp) { // Don't consider this as a definition } else {
--- a/graal/com.oracle.graal.hotspot.ptx/src/com/oracle/graal/hotspot/ptx/PTXHotSpotLIRGenerator.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.hotspot.ptx/src/com/oracle/graal/hotspot/ptx/PTXHotSpotLIRGenerator.java Wed Mar 19 15:22:14 2014 +0100 @@ -23,29 +23,23 @@ package com.oracle.graal.hotspot.ptx; -import com.oracle.graal.api.code.CallingConvention; -import com.oracle.graal.api.code.StackSlot; -import com.oracle.graal.api.meta.DeoptimizationAction; -import com.oracle.graal.api.meta.DeoptimizationReason; -import com.oracle.graal.api.meta.Value; -import com.oracle.graal.compiler.ptx.PTXLIRGenerator; -import com.oracle.graal.graph.GraalInternalError; -import com.oracle.graal.hotspot.HotSpotLIRGenerator; -import com.oracle.graal.hotspot.HotSpotVMConfig; -import com.oracle.graal.hotspot.meta.HotSpotProviders; -import com.oracle.graal.hotspot.nodes.DirectCompareAndSwapNode; -import com.oracle.graal.lir.FrameMap; -import com.oracle.graal.lir.LIR; -import com.oracle.graal.nodes.StructuredGraph; -import com.oracle.graal.nodes.ValueNode; +import com.oracle.graal.api.code.*; +import com.oracle.graal.api.meta.*; +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.meta.*; +import com.oracle.graal.hotspot.nodes.*; +import com.oracle.graal.nodes.*; /** * LIR generator specialized for PTX HotSpot. */ public class PTXHotSpotLIRGenerator extends PTXLIRGenerator implements HotSpotLIRGenerator { - protected PTXHotSpotLIRGenerator(StructuredGraph graph, HotSpotProviders providers, HotSpotVMConfig config, FrameMap frameMap, CallingConvention cc, LIR lir) { - super(graph, providers, frameMap, cc, lir); + protected PTXHotSpotLIRGenerator(StructuredGraph graph, HotSpotProviders providers, HotSpotVMConfig config, CallingConvention cc, LIRGenerationResult lirGenRes) { + super(graph, providers, cc, lirGenRes); assert config.basicLockSize == 8; }
--- a/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotBackend.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotBackend.java Wed Mar 19 15:22:14 2014 +0100 @@ -79,8 +79,8 @@ } @Override - public LIRGenerator newLIRGenerator(StructuredGraph graph, Object stub, FrameMap frameMap, CallingConvention cc, LIR lir) { - return new SPARCHotSpotLIRGenerator(graph, stub, getProviders(), getRuntime().getConfig(), frameMap, cc, lir); + public LIRGenerator newLIRGenerator(StructuredGraph graph, CallingConvention cc, LIRGenerationResult lirGenRes) { + return new SPARCHotSpotLIRGenerator(graph, getProviders(), getRuntime().getConfig(), cc, lirGenRes); } /** @@ -159,10 +159,10 @@ } @Override - public CompilationResultBuilder newCompilationResultBuilder(LIRGenerator lirGen, CompilationResult compilationResult, CompilationResultBuilderFactory factory) { - SPARCHotSpotLIRGenerator gen = (SPARCHotSpotLIRGenerator) lirGen; + public CompilationResultBuilder newCompilationResultBuilder(LIRGenerationResult lirGenRes, CompilationResult compilationResult, CompilationResultBuilderFactory factory) { + SPARCHotSpotLIRGenerationResult gen = (SPARCHotSpotLIRGenerationResult) lirGenRes; FrameMap frameMap = gen.getFrameMap(); - assert gen.deoptimizationRescueSlot == null || frameMap.frameNeedsAllocating() : "method that can deoptimize must have a frame"; + assert gen.getDeoptimizationRescueSlot() == null || frameMap.frameNeedsAllocating() : "method that can deoptimize must have a frame"; Stub stub = gen.getStub(); Assembler masm = createAssembler(frameMap); @@ -170,7 +170,7 @@ HotSpotFrameContext frameContext = new HotSpotFrameContext(stub != null); CompilationResultBuilder crb = factory.createBuilder(getProviders().getCodeCache(), getProviders().getForeignCalls(), frameMap, masm, frameContext, compilationResult); crb.setFrameSize(frameMap.frameSize()); - StackSlot deoptimizationRescueSlot = gen.deoptimizationRescueSlot; + StackSlot deoptimizationRescueSlot = gen.getDeoptimizationRescueSlot(); if (deoptimizationRescueSlot != null && stub == null) { crb.compilationResult.setCustomStackAreaOffset(frameMap.offsetForStackSlot(deoptimizationRescueSlot)); } @@ -186,6 +186,11 @@ } @Override + public LIRGenerationResult newLIRGenerationResult(LIR lir, FrameMap frameMap, Object stub) { + return new LIRGenerationResultBase(lir, frameMap); + } + + @Override public void emitCode(CompilationResultBuilder crb, LIR lir, ResolvedJavaMethod installedCodeOwner) { SPARCMacroAssembler masm = (SPARCMacroAssembler) crb.asm; FrameMap frameMap = crb.frameMap; @@ -240,4 +245,5 @@ public NativeFunctionInterface getNativeFunctionInterface() { throw GraalInternalError.unimplemented("No NativeFunctionInterface of SPARC"); } + }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotLIRGenerationResult.java Wed Mar 19 15:22:14 2014 +0100 @@ -0,0 +1,35 @@ +/* + * 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.hotspot.sparc; + +import com.oracle.graal.api.code.*; +import com.oracle.graal.compiler.gen.*; +import com.oracle.graal.hotspot.stubs.*; + +public interface SPARCHotSpotLIRGenerationResult extends LIRGenerationResult { + + StackSlot getDeoptimizationRescueSlot(); + + Stub getStub(); + +}
--- a/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotLIRGenerator.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotLIRGenerator.java Wed Mar 19 15:22:14 2014 +0100 @@ -51,12 +51,10 @@ public class SPARCHotSpotLIRGenerator extends SPARCLIRGenerator implements HotSpotLIRGenerator { private final HotSpotVMConfig config; - private final Object stub; - public SPARCHotSpotLIRGenerator(StructuredGraph graph, Object stub, HotSpotProviders providers, HotSpotVMConfig config, FrameMap frameMap, CallingConvention cc, LIR lir) { - super(graph, providers, frameMap, cc, lir); + public SPARCHotSpotLIRGenerator(StructuredGraph graph, HotSpotProviders providers, HotSpotVMConfig config, CallingConvention cc, LIRGenerationResult lirGenRes) { + super(graph, providers, cc, lirGenRes); this.config = config; - this.stub = stub; } @Override @@ -69,27 +67,27 @@ * deoptimization. The return address slot in the callee is overwritten with the address of a * deoptimization stub. */ - StackSlot deoptimizationRescueSlot; + private StackSlot deoptimizationRescueSlot; @Override protected DebugInfoBuilder createDebugInfoBuilder(NodeMap<Value> nodeOperands) { - HotSpotLockStack lockStack = new HotSpotLockStack(getFrameMap(), Kind.Long); + HotSpotLockStack lockStack = new HotSpotLockStack(res.getFrameMap(), Kind.Long); return new HotSpotDebugInfoBuilder(nodeOperands, lockStack); } @Override public StackSlot getLockSlot(int lockDepth) { - return ((HotSpotDebugInfoBuilder) debugInfoBuilder).lockStack().makeLockSlot(lockDepth); + return ((HotSpotDebugInfoBuilder) getDebugInfoBuilder()).lockStack().makeLockSlot(lockDepth); } @Override protected boolean needOnlyOopMaps() { // Stubs only need oop maps - return stub != null; + return getStub() != null; } - Stub getStub() { - return (Stub) stub; + public Stub getStub() { + return ((SPARCHotSpotLIRGenerationResult) res).getStub(); } @Override @@ -324,4 +322,8 @@ SPARCAddressValue addr = emitAddress(operand(address), 0, loadNonConst(operand(distance)), 1); append(new SPARCPrefetchOp(addr, config.allocatePrefetchInstr)); } + + public StackSlot getDeoptimizationRescueSlot() { + return deoptimizationRescueSlot; + } }
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/HotSpotBackend.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/HotSpotBackend.java Wed Mar 19 15:22:14 2014 +0100 @@ -114,7 +114,7 @@ } }; for (AbstractBlock<?> block : lir.codeEmittingOrder()) { - for (LIRInstruction op : lir.lir(block)) { + for (LIRInstruction op : lir.getLIRforBlock(block)) { if (op instanceof LabelOp) { // Don't consider this as a definition } else {
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/AllocaNode.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/AllocaNode.java Wed Mar 19 15:22:14 2014 +0100 @@ -36,7 +36,7 @@ * Reserves a block of memory in the stack frame of a method. The block is reserved in the frame for * the entire execution of the associated method. */ -public final class AllocaNode extends FixedWithNextNode implements LIRGenLowerable { +public final class AllocaNode extends FixedWithNextNode implements LIRGenResLowerable { /** * The number of slots in block. @@ -57,8 +57,8 @@ } @Override - public void generate(LIRGenerator gen) { - StackSlot array = gen.getFrameMap().allocateStackSlots(slots, objects, null); + public void generate(LIRGenerator gen, LIRGenerationResult res) { + StackSlot array = res.getFrameMap().allocateStackSlots(slots, objects, null); Value result = gen.emitAddress(array); gen.setResult(this, result); }
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/DimensionsNode.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/DimensionsNode.java Wed Mar 19 15:22:14 2014 +0100 @@ -37,7 +37,7 @@ * Intrinsic for allocating an on-stack array of integers to hold the dimensions of a multianewarray * instruction. */ -public final class DimensionsNode extends FixedWithNextNode implements LIRGenLowerable { +public final class DimensionsNode extends FixedWithNextNode implements LIRGenResLowerable { private final int rank; @@ -47,11 +47,11 @@ } @Override - public void generate(LIRGenerator gen) { + public void generate(LIRGenerator gen, LIRGenerationResult res) { int size = rank * 4; int wordSize = gen.target().wordSize; int slots = roundUp(size, wordSize) / wordSize; - StackSlot array = gen.getFrameMap().allocateStackSlots(slots, new BitSet(0), null); + StackSlot array = res.getFrameMap().allocateStackSlots(slots, new BitSet(0), null); Value result = gen.emitAddress(array); gen.setResult(this, result); }
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/MonitorCounterNode.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/MonitorCounterNode.java Wed Mar 19 15:22:14 2014 +0100 @@ -34,16 +34,16 @@ /** * Node that is used to maintain a stack based counter of how many locks are currently held. */ -public final class MonitorCounterNode extends FloatingNode implements LIRGenLowerable { +public final class MonitorCounterNode extends FloatingNode implements LIRGenResLowerable { private MonitorCounterNode() { super(null); } @Override - public void generate(LIRGenerator gen) { + public void generate(LIRGenerator gen, LIRGenerationResult res) { assert graph().getNodes().filter(MonitorCounterNode.class).count() == 1 : "monitor counters not canonicalized to single instance"; - StackSlot counter = gen.getFrameMap().allocateStackSlots(1, new BitSet(0), null); + StackSlot counter = res.getFrameMap().allocateStackSlots(1, new BitSet(0), null); Value result = gen.emitAddress(counter); gen.setResult(this, result); }
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/TailcallNode.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/TailcallNode.java Wed Mar 19 15:22:14 2014 +0100 @@ -30,17 +30,17 @@ import com.oracle.graal.api.code.*; import com.oracle.graal.api.meta.*; import com.oracle.graal.compiler.gen.*; +import com.oracle.graal.compiler.target.*; import com.oracle.graal.hotspot.*; import com.oracle.graal.java.*; import com.oracle.graal.nodes.*; -import com.oracle.graal.nodes.spi.*; import com.oracle.graal.nodes.type.*; /** * Performs a tail call to the specified target compiled method, with the parameter taken from the * supplied FrameState. */ -public class TailcallNode extends FixedWithNextNode implements LIRLowerable { +public class TailcallNode extends FixedWithNextNode implements LIRGenResLowerable { @Input private FrameState frameState; @Input private ValueNode target; @@ -57,15 +57,13 @@ this.frameState = frameState; } - @Override - public void generate(LIRGeneratorTool generator) { - LIRGenerator gen = (LIRGenerator) generator; + public void generate(LIRGenerator gen, LIRGenerationResult res) { HotSpotVMConfig config = runtime().getConfig(); ResolvedJavaMethod method = frameState.method(); boolean isStatic = Modifier.isStatic(method.getModifiers()); JavaType[] signature = MetaUtil.signatureToTypes(method.getSignature(), isStatic ? null : method.getDeclaringClass()); - CallingConvention cc = gen.getFrameMap().registerConfig.getCallingConvention(CallingConvention.Type.JavaCall, null, signature, gen.target(), false); + CallingConvention cc = res.getFrameMap().registerConfig.getCallingConvention(CallingConvention.Type.JavaCall, null, signature, gen.target(), false); List<ValueNode> parameters = new ArrayList<>(); for (int i = 0, slot = 0; i < cc.getArgumentCount(); i++, slot += HIRFrameStateBuilder.stackSlots(frameState.localAt(slot).getKind())) { parameters.add(frameState.localAt(slot));
--- a/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/ControlFlowOptimizer.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/ControlFlowOptimizer.java Wed Mar 19 15:22:14 2014 +0100 @@ -58,12 +58,12 @@ return false; } - List<LIRInstruction> instructions = lir.lir(block); + List<LIRInstruction> instructions = lir.getLIRforBlock(block); assert instructions.size() >= 2 : "block must have label and branch"; assert instructions.get(0) instanceof StandardOp.LabelOp : "first instruction must always be a label"; assert instructions.get(instructions.size() - 1) instanceof StandardOp.JumpOp : "last instruction must always be a branch"; - assert ((StandardOp.JumpOp) instructions.get(instructions.size() - 1)).destination().label() == ((StandardOp.LabelOp) lir.lir(block.getSuccessors().iterator().next()).get(0)).getLabel() : "branch target must be the successor"; + assert ((StandardOp.JumpOp) instructions.get(instructions.size() - 1)).destination().label() == ((StandardOp.LabelOp) lir.getLIRforBlock(block.getSuccessors().iterator().next()).get(0)).getLabel() : "branch target must be the successor"; // Block must have exactly one successor. return instructions.size() == 2 && !instructions.get(instructions.size() - 1).hasState() && !block.isExceptionEntry(); @@ -72,7 +72,7 @@ private static void alignBlock(LIR lir, AbstractBlock<?> block) { if (!block.isAligned()) { block.setAlign(true); - List<LIRInstruction> instructions = lir.lir(block); + List<LIRInstruction> instructions = lir.getLIRforBlock(block); assert instructions.get(0) instanceof StandardOp.LabelOp : "first instruction must always be a label"; StandardOp.LabelOp label = (StandardOp.LabelOp) instructions.get(0); instructions.set(0, new StandardOp.LabelOp(label.getLabel(), true));
--- a/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/EdgeMoveOptimizer.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/EdgeMoveOptimizer.java Wed Mar 19 15:22:14 2014 +0100 @@ -120,8 +120,8 @@ // setup a list with the LIR instructions of all predecessors for (AbstractBlock<?> pred : block.getPredecessors()) { assert pred != null; - assert ir.lir(pred) != null; - List<LIRInstruction> predInstructions = ir.lir(pred); + assert ir.getLIRforBlock(pred) != null; + List<LIRInstruction> predInstructions = ir.getLIRforBlock(pred); if (pred.getSuccessorCount() != 1) { // this can happen with switch-statements where multiple edges are between @@ -158,7 +158,7 @@ } // insert the instruction at the beginning of the current block - ir.lir(block).add(1, op); + ir.getLIRforBlock(block).add(1, op); // delete the instruction at the end of all predecessors for (int i = 0; i < numPreds; i++) { @@ -178,7 +178,7 @@ edgeInstructionSeqences.clear(); int numSux = block.getSuccessorCount(); - List<LIRInstruction> instructions = ir.lir(block); + List<LIRInstruction> instructions = ir.getLIRforBlock(block); assert numSux == 2 : "method should not be called otherwise"; @@ -204,7 +204,7 @@ // setup a list with the lir-instructions of all successors for (AbstractBlock<?> sux : block.getSuccessors()) { - List<LIRInstruction> suxInstructions = ir.lir(sux); + List<LIRInstruction> suxInstructions = ir.getLIRforBlock(sux); assert suxInstructions.get(0) instanceof StandardOp.LabelOp : "block must start with label"; @@ -238,7 +238,7 @@ } // insert instruction at end of current block - ir.lir(block).add(insertIdx, op); + ir.getLIRforBlock(block).add(insertIdx, op); insertIdx++; // delete the instructions at the beginning of all successors
--- a/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/LIR.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/LIR.java Wed Mar 19 15:22:14 2014 +0100 @@ -81,7 +81,7 @@ */ public boolean hasDebugInfo() { for (AbstractBlock<?> b : linearScanOrder()) { - for (LIRInstruction op : lir(b)) { + for (LIRInstruction op : getLIRforBlock(b)) { if (op.hasState()) { return true; } @@ -94,12 +94,12 @@ return spillMoveFactory; } - public List<LIRInstruction> lir(AbstractBlock<?> block) { + public List<LIRInstruction> getLIRforBlock(AbstractBlock<?> block) { return lirInstructions.get(block); } - public void setLir(AbstractBlock<?> block, List<LIRInstruction> list) { - assert lir(block) == null : "lir instruction list should only be initialized once"; + public void setLIRforBlock(AbstractBlock<?> block, List<LIRInstruction> list) { + assert getLIRforBlock(block) == null : "lir instruction list should only be initialized once"; lirInstructions.put(block, list); } @@ -170,7 +170,7 @@ public static final int MAX_EXCEPTION_EDGE_OP_DISTANCE_FROM_END = 3; public static boolean verifyBlock(LIR lir, AbstractBlock<?> block) { - List<LIRInstruction> ops = lir.lir(block); + List<LIRInstruction> ops = lir.getLIRforBlock(block); if (ops.size() == 0) { return false; }
--- a/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/LIRVerifier.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/LIRVerifier.java Wed Mar 19 15:22:14 2014 +0100 @@ -129,14 +129,14 @@ curVariablesLive.or(liveOutFor(block.getDominator())); } - assert lir.lir(block).get(0) instanceof StandardOp.LabelOp : "block must start with label"; + assert lir.getLIRforBlock(block).get(0) instanceof StandardOp.LabelOp : "block must start with label"; if (block.getSuccessorCount() > 0) { - LIRInstruction last = lir.lir(block).get(lir.lir(block).size() - 1); + LIRInstruction last = lir.getLIRforBlock(block).get(lir.getLIRforBlock(block).size() - 1); assert last instanceof StandardOp.JumpOp : "block with successor must end with unconditional jump"; } - for (LIRInstruction op : lir.lir(block)) { + for (LIRInstruction op : lir.getLIRforBlock(block)) { curInstruction = op; op.forEachInput(useProc);
--- a/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/LabelRef.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/LabelRef.java Wed Mar 19 15:22:14 2014 +0100 @@ -73,7 +73,7 @@ } public Label label() { - return ((StandardOp.LabelOp) lir.lir(getTargetBlock()).get(0)).getLabel(); + return ((StandardOp.LabelOp) lir.getLIRforBlock(getTargetBlock()).get(0)).getLabel(); } @Override
--- a/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/NullCheckOptimizer.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/NullCheckOptimizer.java Wed Mar 19 15:22:14 2014 +0100 @@ -40,7 +40,7 @@ private static void foldNullChecks(LIR ir, List<? extends AbstractBlock<?>> blocks, int implicitNullCheckLimit) { for (AbstractBlock<?> block : blocks) { - List<LIRInstruction> list = ir.lir(block); + List<LIRInstruction> list = ir.getLIRforBlock(block); if (!list.isEmpty()) {
--- a/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/RedundantMoveElimination.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/RedundantMoveElimination.java Wed Mar 19 15:22:14 2014 +0100 @@ -144,7 +144,7 @@ * which occur as destinations of move instructions. */ for (AbstractBlock<?> block : blocks) { - List<LIRInstruction> instructions = lir.lir(block); + List<LIRInstruction> instructions = lir.getLIRforBlock(block); for (LIRInstruction op : instructions) { if (isEligibleMove(op)) { Value dest = ((MoveOp) op).getResult(); @@ -244,7 +244,7 @@ */ int[] iterState = data.exitState; copyState(iterState, data.entryState); - List<LIRInstruction> instructions = lir.lir(block); + List<LIRInstruction> instructions = lir.getLIRforBlock(block); for (LIRInstruction op : instructions) { valueNum = updateState(iterState, op, valueNum); @@ -287,7 +287,7 @@ Indent indent2 = indent.logAndIndent("eliminate moves in block %d", block.getId()); - List<LIRInstruction> instructions = lir.lir(block); + List<LIRInstruction> instructions = lir.getLIRforBlock(block); BlockData data = blockData.get(block); boolean hasDead = false;
--- a/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/StandardOp.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/StandardOp.java Wed Mar 19 15:22:14 2014 +0100 @@ -195,7 +195,7 @@ } public void replace(LIR lir, LIRInstruction replacement) { - lir.lir(block).set(index, replacement); + lir.getLIRforBlock(block).set(index, replacement); } @Override
--- a/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/asm/CompilationResultBuilder.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.lir/src/com/oracle/graal/lir/asm/CompilationResultBuilder.java Wed Mar 19 15:22:14 2014 +0100 @@ -325,7 +325,7 @@ blockComment(String.format("block B%d %s", block.getId(), block.getLoop())); } - for (LIRInstruction op : lir.lir(block)) { + for (LIRInstruction op : lir.getLIRforBlock(block)) { if (Debug.isDumpEnabled()) { blockComment(String.format("%d %s", op.id(), op)); }
--- a/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/CFGPrinter.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/CFGPrinter.java Wed Mar 19 15:22:14 2014 +0100 @@ -145,18 +145,15 @@ } } } - printedNodes = new NodeBitMap(cfg.graph); begin("cfg"); out.print("name \"").print(label).println('"'); - for (AbstractBlock<?> abstractBlock : blocks) { - Block block = (Block) abstractBlock; + for (AbstractBlock<?> block : blocks) { printBlock(block, printNodes); } end("cfg"); latestScheduling = null; - printedNodes = null; } private void scheduleInputs(Node node, Block nodeBlock) { @@ -187,7 +184,7 @@ } } - private void printBlock(Block block, boolean printNodes) { + private void printBlock(AbstractBlock<?> block, boolean printNodes) { begin("block"); out.print("name \"").print(blockToString(block)).println('"'); @@ -195,13 +192,13 @@ out.println("to_bci -1"); out.print("predecessors "); - for (Block pred : block.getPredecessors()) { + for (AbstractBlock<?> pred : block.getPredecessors()) { out.print("\"").print(blockToString(pred)).print("\" "); } out.println(); out.print("successors "); - for (Block succ : block.getSuccessors()) { + for (AbstractBlock<?> succ : block.getSuccessors()) { if (!succ.isExceptionEntry()) { out.print("\"").print(blockToString(succ)).print("\" "); } @@ -209,7 +206,7 @@ out.println(); out.print("xhandlers"); - for (Block succ : block.getSuccessors()) { + for (AbstractBlock<?> succ : block.getSuccessors()) { if (succ.isExceptionEntry()) { out.print("\"").print(blockToString(succ)).print("\" "); } @@ -234,7 +231,10 @@ } if (printNodes) { - printNodes(block); + printedNodes = new NodeBitMap(cfg.graph); + assert block instanceof Block; + printNodes((Block) block); + printedNodes = null; } printLIR(block); end("block"); @@ -419,11 +419,11 @@ * * @param block the block to print */ - private void printLIR(Block block) { + private void printLIR(AbstractBlock<?> block) { if (lir == null) { return; } - List<LIRInstruction> lirInstructions = lir.lir(block); + List<LIRInstruction> lirInstructions = lir.getLIRforBlock(block); if (lirInstructions == null) { return; } @@ -481,13 +481,13 @@ return prefix + node.toString(Verbosity.Id); } - private String blockToString(Block block) { - if (lir == null) { + private String blockToString(AbstractBlock<?> block) { + if (lir == null && block instanceof Block) { // During all the front-end phases, the block schedule is built only for the debug // output. // Therefore, the block numbers would be different for every CFG printed -> use the id // of the first instruction. - return "B" + block.getBeginNode().toString(Verbosity.Id); + return "B" + ((Block) block).getBeginNode().toString(Verbosity.Id); } else { // LIR instructions contain references to blocks and these blocks are printed as the // blockID -> use the blockID.
--- a/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/CFGPrinterObserver.java Wed Mar 19 14:25:45 2014 +0000 +++ b/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/CFGPrinterObserver.java Wed Mar 19 15:22:14 2014 +0100 @@ -140,8 +140,7 @@ if (cfgPrinter.lirGenerator != null) { cfgPrinter.target = cfgPrinter.lirGenerator.target(); } - if (cfgPrinter.lir != null) { - assert cfgPrinter.lir.getControlFlowGraph() instanceof ControlFlowGraph; + if (cfgPrinter.lir != null && cfgPrinter.lir.getControlFlowGraph() instanceof ControlFlowGraph) { cfgPrinter.cfg = (ControlFlowGraph) cfgPrinter.lir.getControlFlowGraph(); } @@ -160,7 +159,7 @@ } else if (object instanceof LIR) { // No need to print the HIR nodes again if this is not the first // time dumping the same LIR since the HIR will not have changed. - boolean printNodes = previousObject != object; + boolean printNodes = previousObject != object && cfgPrinter.cfg != null; cfgPrinter.printCFG(message, cfgPrinter.lir.codeEmittingOrder(), printNodes); } else if (object instanceof StructuredGraph) {