void CodeBlockSet::dump(PrintStream& out) const
{
CommaPrinter comma;
out.print("{old = [");
for (CodeBlock* codeBlock : m_oldCodeBlocks)
out.print(comma, pointerDump(codeBlock));
out.print("], new = [");
comma = CommaPrinter();
for (CodeBlock* codeBlock : m_newCodeBlocks)
out.print(comma, pointerDump(codeBlock));
out.print("], currentlyExecuting = [");
comma = CommaPrinter();
for (CodeBlock* codeBlock : m_currentlyExecuting)
out.print(comma, pointerDump(codeBlock));
out.print("]}");
}
void SSACalculator::dump(PrintStream& out) const
{
out.print("<Variables: [");
CommaPrinter comma;
for (unsigned i = 0; i < m_variables.size(); ++i) {
out.print(comma);
m_variables[i].dumpVerbose(out);
}
out.print("], Defs: [");
comma = CommaPrinter();
for (Def* def : const_cast<SSACalculator*>(this)->m_defs)
out.print(comma, *def);
out.print("], Phis: [");
comma = CommaPrinter();
for (Def* def : const_cast<SSACalculator*>(this)->m_phis)
out.print(comma, *def);
out.print("], Block data: [");
comma = CommaPrinter();
for (BlockIndex blockIndex = 0; blockIndex < m_graph.numBlocks(); ++blockIndex) {
BasicBlock* block = m_graph.block(blockIndex);
if (!block)
continue;
out.print(comma, *block, "=>(");
out.print("Defs: {");
CommaPrinter innerComma;
for (auto entry : m_data[block].m_defs)
out.print(innerComma, *entry.key, "->", *entry.value);
out.print("}, Phis: {");
innerComma = CommaPrinter();
for (Def* def : m_data[block].m_phis)
out.print(innerComma, *def);
out.print("})");
}
out.print("]>");
}
void demoteValues(Procedure& proc, const IndexSet<Value>& values)
{
HashMap<Value*, StackSlotValue*> map;
HashMap<Value*, StackSlotValue*> phiMap;
// Create stack slots.
InsertionSet insertionSet(proc);
for (Value* value : values.values(proc.values())) {
StackSlotValue* stack = insertionSet.insert<StackSlotValue>(
0, value->origin(), sizeofType(value->type()), StackSlotKind::Anonymous);
map.add(value, stack);
if (value->opcode() == Phi) {
StackSlotValue* phiStack = insertionSet.insert<StackSlotValue>(
0, value->origin(), sizeofType(value->type()), StackSlotKind::Anonymous);
phiMap.add(value, phiStack);
}
}
insertionSet.execute(proc[0]);
if (verbose) {
dataLog("Demoting values as follows:\n");
dataLog(" map = ");
CommaPrinter comma;
for (auto& entry : map)
dataLog(comma, *entry.key, "=>", *entry.value);
dataLog("\n");
dataLog(" phiMap = ");
comma = CommaPrinter();
for (auto& entry : phiMap)
dataLog(comma, *entry.key, "=>", *entry.value);
dataLog("\n");
}
// Change accesses to the values to accesses to the stack slots.
for (BasicBlock* block : proc) {
for (unsigned valueIndex = 0; valueIndex < block->size(); ++valueIndex) {
Value* value = block->at(valueIndex);
if (value->opcode() == Phi) {
if (StackSlotValue* stack = phiMap.get(value)) {
value->replaceWithIdentity(
insertionSet.insert<MemoryValue>(
valueIndex, Load, value->type(), value->origin(), stack));
}
} else {
for (Value*& child : value->children()) {
if (StackSlotValue* stack = map.get(child)) {
child = insertionSet.insert<MemoryValue>(
valueIndex, Load, child->type(), value->origin(), stack);
}
}
if (UpsilonValue* upsilon = value->as<UpsilonValue>()) {
if (StackSlotValue* stack = phiMap.get(upsilon->phi())) {
insertionSet.insert<MemoryValue>(
valueIndex, Store, upsilon->origin(), upsilon->child(0), stack);
value->replaceWithNop();
}
}
}
if (StackSlotValue* stack = map.get(value)) {
insertionSet.insert<MemoryValue>(
valueIndex + 1, Store, value->origin(), value, stack);
}
}
insertionSet.execute(block);
}
}