use of com.oracle.svm.core.graal.llvm.util.LLVMUtils.LLVMPendingSpecialRegisterRead in project graal by oracle.
the class NodeLLVMBuilder method doBlock.
@Override
public void doBlock(Block block, StructuredGraph graph, BlockMap<List<Node>> blockMap) {
assert !processedBlocks.contains(block) : "Block already processed " + block;
assert verifyPredecessors(block);
gen.beginBlock(block);
if (block == graph.getLastSchedule().getCFG().getStartBlock()) {
assert block.getPredecessorCount() == 0;
long startPatchpointID = LLVMGenerator.nextPatchpointId.getAndIncrement();
builder.buildStackmap(builder.constantLong(startPatchpointID));
gen.getCompilationResult().recordInfopoint(NumUtil.safeToInt(startPatchpointID), null, InfopointReason.METHOD_START);
for (ParameterNode param : graph.getNodes(ParameterNode.TYPE)) {
int offset = (gen.isEntryPoint() ? 0 : SpecialRegister.count());
LLVMValueRef paramValue = builder.getFunctionParam(param.index() + offset);
setResult(param, paramValue);
}
for (SpecialRegister reg : SpecialRegister.registers()) {
gen.setInitialSpecialRegisterValue(reg, gen.isEntryPoint() ? builder.constantNull(builder.wordType()) : builder.getFunctionParam(reg.getIndex()));
}
gen.getDebugInfoPrinter().printFunction(graph, this);
} else {
assert block.getPredecessorCount() > 0;
// create phi-in value array
AbstractBeginNode begin = block.getBeginNode();
if (begin instanceof AbstractMergeNode) {
AbstractMergeNode merge = (AbstractMergeNode) begin;
for (SpecialRegister reg : SpecialRegister.registers()) {
List<LLVMValueRef> forwardPredValues = new ArrayList<>();
List<LLVMBasicBlockRef> forwardBlocks = new ArrayList<>();
for (Block predecessor : block.getPredecessors()) {
if (processedBlocks.contains(predecessor)) {
forwardPredValues.add(block.isExceptionEntry() ? gen.getHandlerSpecialRegisterValue(reg, predecessor) : gen.getSpecialRegisterValue(reg, predecessor));
forwardBlocks.add(gen.getBlockEnd(predecessor));
}
}
LLVMValueRef registerPhi = builder.buildPhi(builder.wordType(), forwardPredValues.toArray(new LLVMValueRef[0]), forwardBlocks.toArray(new LLVMBasicBlockRef[0]));
gen.setInitialSpecialRegisterValue(reg, registerPhi);
}
for (ValuePhiNode phiNode : merge.valuePhis()) {
List<LLVMValueRef> forwardPhis = new ArrayList<>();
List<LLVMBasicBlockRef> forwardBlocks = new ArrayList<>();
LLVMTypeRef phiType = getLLVMType(phiNode);
boolean hasBackwardIncomingEdges = false;
for (Block predecessor : block.getPredecessors()) {
if (processedBlocks.contains(predecessor)) {
ValueNode phiValue = phiNode.valueAt((AbstractEndNode) predecessor.getEndNode());
LLVMValueRef value;
if (operand(phiValue) instanceof LLVMPendingSpecialRegisterRead) {
/*
* The pending read may need to perform instructions to load the
* value, so we put them at the end of the predecessor block
*/
Block currentBlock = (Block) gen.getCurrentBlock();
gen.editBlock(predecessor);
value = llvmOperand(phiValue);
gen.resumeBlock(currentBlock);
} else {
value = llvmOperand(phiValue);
}
LLVMBasicBlockRef parentBlock = gen.getBlockEnd(predecessor);
forwardPhis.add(value);
forwardBlocks.add(parentBlock);
} else {
hasBackwardIncomingEdges = true;
}
}
LLVMValueRef[] incomingValues = forwardPhis.toArray(new LLVMValueRef[0]);
LLVMBasicBlockRef[] incomingBlocks = forwardBlocks.toArray(new LLVMBasicBlockRef[0]);
LLVMValueRef phi = builder.buildPhi(phiType, incomingValues, incomingBlocks);
if (hasBackwardIncomingEdges) {
backwardsPhi.put(phiNode, phi);
}
setResult(phiNode, phi);
}
} else {
assert block.getPredecessorCount() == 1;
Block predecessor = block.getFirstPredecessor();
for (SpecialRegister reg : SpecialRegister.registers()) {
gen.setInitialSpecialRegisterValue(reg, block.isExceptionEntry() ? gen.getHandlerSpecialRegisterValue(reg, predecessor) : gen.getSpecialRegisterValue(reg, predecessor));
}
}
}
gen.getDebugInfoPrinter().printBlock(block);
for (Node node : blockMap.get(block)) {
if (node instanceof ValueNode) {
/*
* There can be cases in which the result of an instruction is already set before by
* other instructions.
*/
if (!valueMap.containsKey(node)) {
ValueNode valueNode = (ValueNode) node;
try {
gen.getDebugInfoPrinter().printNode(valueNode);
emitNode(valueNode);
} catch (GraalError e) {
throw GraalGraphError.transformAndAddContext(e, valueNode);
} catch (Throwable e) {
throw new GraalGraphError(e).addContext(valueNode);
}
}
}
}
if (builder.blockTerminator(gen.getBlockEnd(block)) == null) {
NodeIterable<Node> successors = block.getEndNode().successors();
assert successors.count() == block.getSuccessorCount();
if (block.getSuccessorCount() != 1) {
/*
* If we have more than one successor, we cannot just use the first one. Since
* successors are unordered, this would be a random choice.
*/
throw new GraalError("Block without BlockEndOp: " + block.getEndNode());
}
builder.buildBranch(gen.getBlock(block.getFirstSuccessor()));
}
processedBlocks.add(block);
}
use of com.oracle.svm.core.graal.llvm.util.LLVMUtils.LLVMPendingSpecialRegisterRead in project graal by oracle.
the class NodeLLVMBuilder method setResult.
@Override
public Value setResult(ValueNode node, Value operand) {
LLVMValueWrapper llvmOperand;
boolean typeOverride = false;
if (operand instanceof LLVMValueWrapper) {
llvmOperand = (LLVMValueWrapper) operand;
} else if (operand instanceof ConstantValue) {
/* This only happens when emitting null or illegal object constants */
PlatformKind kind = operand.getPlatformKind();
if (kind instanceof LLVMKind) {
llvmOperand = new LLVMVariable(builder.constantNull(((LLVMKind) kind).get()));
} else {
assert kind == ValueKind.Illegal.getPlatformKind();
llvmOperand = new LLVMVariable(builder.getUndef());
}
} else if (operand instanceof LLVMAddressValue) {
LLVMAddressValue addressValue = (LLVMAddressValue) operand;
Value wrappedBase = addressValue.getBase();
Value index = addressValue.getIndex();
if (wrappedBase instanceof LLVMPendingSpecialRegisterRead) {
LLVMPendingSpecialRegisterRead pendingRead = (LLVMPendingSpecialRegisterRead) wrappedBase;
if (index != null && index != Value.ILLEGAL) {
pendingRead = new LLVMPendingSpecialRegisterRead(pendingRead, LLVMUtils.getVal(addressValue.getIndex()));
}
llvmOperand = pendingRead;
} else {
LLVMValueRef base = LLVMUtils.getVal(wrappedBase);
LLVMTypeRef baseType = LLVMIRBuilder.typeOf(base);
if (LLVMIRBuilder.isWordType(baseType)) {
base = builder.buildIntToPtr(base, builder.rawPointerType());
} else if (LLVMIRBuilder.isObjectType(baseType)) {
typeOverride = true;
} else {
throw shouldNotReachHere(LLVMUtils.dumpValues("unsupported base for address", base));
}
LLVMValueRef intermediate;
if (index == null || index == Value.ILLEGAL) {
intermediate = base;
} else {
intermediate = builder.buildGEP(base, LLVMUtils.getVal(index));
}
llvmOperand = new LLVMVariable(intermediate);
}
} else if (operand instanceof RegisterValue) {
RegisterValue registerValue = (RegisterValue) operand;
llvmOperand = (LLVMValueWrapper) gen.emitReadRegister(registerValue.getRegister(), registerValue.getValueKind());
} else {
throw shouldNotReachHere("unknown operand: " + operand.toString());
}
assert typeOverride || LLVMIRBuilder.compatibleTypes(getLLVMType(node), LLVMIRBuilder.typeOf(llvmOperand.get())) : LLVMUtils.dumpValues("value type doesn't match node stamp (" + node.stamp(NodeView.DEFAULT).toString() + ")", llvmOperand.get());
gen.getDebugInfoPrinter().setValueName(llvmOperand, node);
valueMap.put(node, llvmOperand);
return operand;
}
Aggregations