/*
* Copyright (c) 2009, 2015, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package org.graalvm.compiler.lir;
import static org.graalvm.compiler.lir.LIRValueUtil.asVariable;
import static org.graalvm.compiler.lir.LIRValueUtil.isJavaConstant;
import static org.graalvm.compiler.lir.LIRValueUtil.isStackSlotValue;
import static org.graalvm.compiler.lir.LIRValueUtil.isVariable;
import static jdk.vm.ci.code.ValueUtil.asRegister;
import static jdk.vm.ci.code.ValueUtil.isIllegal;
import static jdk.vm.ci.code.ValueUtil.isRegister;
import java.util.Arrays;
import java.util.BitSet;
import java.util.EnumSet;
import org.graalvm.compiler.core.common.cfg.AbstractBlockBase;
import org.graalvm.compiler.debug.GraalError;
import org.graalvm.compiler.debug.TTY;
import org.graalvm.compiler.lir.LIRInstruction.OperandFlag;
import org.graalvm.compiler.lir.LIRInstruction.OperandMode;
import org.graalvm.compiler.lir.framemap.FrameMap;
import org.graalvm.compiler.lir.ssa.SSAUtil;
import jdk.vm.ci.code.Register;
import jdk.vm.ci.meta.Value;
public final class LIRVerifier {
private final LIR lir;
private final FrameMap frameMap;
private final boolean beforeRegisterAllocation;
private final BitSet[] blockLiveOut;
private final Object[] variableDefinitions;
private BitSet liveOutFor(AbstractBlockBase<?> block) {
return blockLiveOut[block.getId()];
}
private void setLiveOutFor(AbstractBlockBase<?> block, BitSet liveOut) {
blockLiveOut[block.getId()] = liveOut;
}
private int maxRegisterNum() {
return frameMap.getTarget().arch.getRegisters().size();
}
private boolean isAllocatableRegister(Value value) {
return isRegister(value) && frameMap.getRegisterConfig().getAttributesMap()[asRegister(value).number].isAllocatable();
}
public static boolean verify(final LIRInstruction op) {
op.visitEachInput(LIRVerifier::allowed);
op.visitEachAlive(LIRVerifier::allowed);
op.visitEachState(LIRVerifier::allowed);
op.visitEachTemp(LIRVerifier::allowed);
op.visitEachOutput(LIRVerifier::allowed);
op.verify();
return true;
}
public static boolean verify(boolean beforeRegisterAllocation, LIR lir, FrameMap frameMap) {
LIRVerifier verifier = new LIRVerifier(beforeRegisterAllocation, lir, frameMap);
verifier.verify();
return true;
}
private LIRVerifier(boolean beforeRegisterAllocation, LIR lir, FrameMap frameMap) {
this.beforeRegisterAllocation = beforeRegisterAllocation;
this.lir = lir;
this.frameMap = frameMap;
this.blockLiveOut = new BitSet[lir.linearScanOrder().length];
this.variableDefinitions = new Object[lir.numVariables()];
}
private BitSet curVariablesLive;
private Value[] curRegistersLive;
private AbstractBlockBase<?> curBlock;
private Object curInstruction;
private BitSet curRegistersDefined;
private void verify() {
ValueConsumer useConsumer = new ValueConsumer() {
@Override
public void visitValue(Value value, OperandMode mode, EnumSet<OperandFlag> flags) {
use(value, mode, flags);
}
};
ValueConsumer defConsumer = new ValueConsumer() {
@Override
public void visitValue(Value value, OperandMode mode, EnumSet<OperandFlag> flags) {
def(value, mode, flags);
}
};
int maxRegisterNum = maxRegisterNum();
curRegistersDefined = new BitSet();
for (AbstractBlockBase<?> block : lir.linearScanOrder()) {
curBlock = block;
curVariablesLive = new BitSet();
curRegistersLive = new Value[maxRegisterNum];
if (block.getDominator() != null) {
curVariablesLive.or(liveOutFor(block.getDominator()));
}
assert lir.getLIRforBlock(block).get(0) instanceof StandardOp.LabelOp : "block must start with label";
if (block.getSuccessorCount() > 0) {
LIRInstruction last = lir.getLIRforBlock(block).get(lir.getLIRforBlock(block).size() - 1);
assert last instanceof StandardOp.JumpOp : "block with successor must end with unconditional jump";
}
if (block.getPredecessorCount() > 1) {
SSAUtil.verifyPhi(lir, block);
}
for (LIRInstruction op : lir.getLIRforBlock(block)) {
curInstruction = op;
op.visitEachInput(useConsumer);
if (op.destroysCallerSavedRegisters()) {
for (Register register : frameMap.getRegisterConfig().getCallerSaveRegisters()) {
curRegistersLive[register.number] = null;
}
}
curRegistersDefined.clear();
op.visitEachAlive(useConsumer);
op.visitEachState(useConsumer);
op.visitEachTemp(defConsumer);
op.visitEachOutput(defConsumer);
curInstruction = null;
}
setLiveOutFor(block, curVariablesLive);
}
}
private void use(Value value, OperandMode mode, EnumSet<OperandFlag> flags) {
allowed(curInstruction, value, mode, flags);
if (isVariable(value)) {
assert beforeRegisterAllocation;
int variableIdx = asVariable(value).index;
if (!curVariablesLive.get(variableIdx)) {
TTY.println("block %s instruction %s", curBlock, curInstruction);
TTY.println("live variables: %s", curVariablesLive);
if (variableDefinitions[variableIdx] != null) {
TTY.println("definition of %s: %s", value, variableDefinitions[variableIdx]);
}
TTY.println("ERROR: Use of variable %s that is not defined in dominator", value);
throw GraalError.shouldNotReachHere();
}
} else if (isAllocatableRegister(value)) {
int regNum = asRegister(value).number;
if (mode == OperandMode.ALIVE) {
curRegistersDefined.set(regNum);
}
if (beforeRegisterAllocation && !curRegistersLive[regNum].equals(value)) {
TTY.println("block %s instruction %s", curBlock, curInstruction);
TTY.println("live registers: %s", Arrays.toString(curRegistersLive));
TTY.println("ERROR: Use of fixed register %s that is not defined in this block", value);
throw GraalError.shouldNotReachHere();
}
}
}
private void def(Value value, OperandMode mode, EnumSet<OperandFlag> flags) {
allowed(curInstruction, value, mode, flags);
if (isVariable(value)) {
assert beforeRegisterAllocation;
int variableIdx = asVariable(value).index;
if (variableDefinitions[variableIdx] != null) {
TTY.println("block %s instruction %s", curBlock, curInstruction);
TTY.println("live variables: %s", curVariablesLive);
TTY.println("definition of %s: %s", value, variableDefinitions[variableIdx]);
TTY.println("ERROR: Variable %s defined multiple times", value);
throw GraalError.shouldNotReachHere();
}
assert curInstruction != null;
variableDefinitions[variableIdx] = curInstruction;
assert !curVariablesLive.get(variableIdx);
if (mode == OperandMode.DEF) {
curVariablesLive.set(variableIdx);
}
} else if (isAllocatableRegister(value)) {
int regNum = asRegister(value).number;
if (curRegistersDefined.get(regNum)) {
TTY.println("block %s instruction %s", curBlock, curInstruction);
TTY.println("ERROR: Same register defined twice in the same instruction: %s", value);
throw GraalError.shouldNotReachHere();
}
curRegistersDefined.set(regNum);
if (beforeRegisterAllocation) {
if (mode == OperandMode.DEF) {
curRegistersLive[regNum] = value;
} else {
curRegistersLive[regNum] = null;
}
}
}
}
// @formatter:off
private static void allowed(Object op, Value value, OperandMode mode, EnumSet<OperandFlag> flags) {
if ((isVariable(value) && flags.contains(OperandFlag.REG)) ||
(isRegister(value) && flags.contains(OperandFlag.REG)) ||
(isStackSlotValue(value) && flags.contains(OperandFlag.STACK)) ||
(isJavaConstant(value) && flags.contains(OperandFlag.CONST) && mode != OperandMode.DEF) ||
(isIllegal(value) && flags.contains(OperandFlag.ILLEGAL))) {
return;
}
throw new GraalError("Invalid LIR%n Instruction: %s%n Mode: %s%n Flags: %s%n Unexpected value: %s %s",
op, mode, flags, value.getClass().getSimpleName(), value);
}
// @formatter:on
}