#include "config.h"
#include "B3FixSSA.h"
#if ENABLE(B3_JIT)
#include "B3BasicBlockInlines.h"
#include "B3BreakCriticalEdges.h"
#include "B3ControlValue.h"
#include "B3Dominators.h"
#include "B3IndexSet.h"
#include "B3InsertionSetInlines.h"
#include "B3PhaseScope.h"
#include "B3ProcedureInlines.h"
#include "B3SSACalculator.h"
#include "B3UpsilonValue.h"
#include "B3ValueInlines.h"
#include "B3Variable.h"
#include "B3VariableValue.h"
#include <wtf/CommaPrinter.h>
namespace JSC { namespace B3 {
namespace {
const bool verbose = false;
}
void demoteValues(Procedure& proc, const IndexSet<Value>& values)
{
HashMap<Value*, Variable*> map;
HashMap<Value*, Variable*> phiMap;
for (Value* value : values.values(proc.values())) {
map.add(value, proc.addVariable(value->type()));
if (value->opcode() == Phi)
phiMap.add(value, proc.addVariable(value->type()));
}
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");
}
InsertionSet insertionSet(proc);
for (BasicBlock* block : proc) {
for (unsigned valueIndex = 0; valueIndex < block->size(); ++valueIndex) {
Value* value = block->at(valueIndex);
if (value->opcode() == Phi) {
if (Variable* variable = phiMap.get(value)) {
value->replaceWithIdentity(
insertionSet.insert<VariableValue>(
valueIndex, Get, value->origin(), variable));
}
} else {
for (Value*& child : value->children()) {
if (Variable* variable = map.get(child)) {
child = insertionSet.insert<VariableValue>(
valueIndex, Get, value->origin(), variable);
}
}
if (UpsilonValue* upsilon = value->as<UpsilonValue>()) {
if (Variable* variable = phiMap.get(upsilon->phi())) {
insertionSet.insert<VariableValue>(
valueIndex, Set, upsilon->origin(), variable, upsilon->child(0));
value->replaceWithNop();
}
}
}
if (Variable* variable = map.get(value)) {
insertionSet.insert<VariableValue>(
valueIndex + 1, Set, value->origin(), variable, value);
}
}
insertionSet.execute(block);
}
}
bool fixSSA(Procedure& proc)
{
PhaseScope phaseScope(proc, "fixSSA");
IndexSet<Variable> liveVariables;
for (Value* value : proc.values()) {
if (VariableValue* variableValue = value->as<VariableValue>())
liveVariables.add(variableValue->variable());
}
for (Variable* variable : proc.variables()) {
if (!liveVariables.contains(variable))
proc.deleteVariable(variable);
}
if (proc.variables().isEmpty())
return false;
breakCriticalEdges(proc);
SSACalculator ssa(proc);
Vector<Variable*> calcVarToVariable;
IndexMap<Variable, SSACalculator::Variable*> variableToCalcVar(proc.variables().size());
for (Variable* variable : proc.variables()) {
SSACalculator::Variable* calcVar = ssa.newVariable();
RELEASE_ASSERT(calcVar->index() == calcVarToVariable.size());
calcVarToVariable.append(variable);
variableToCalcVar[variable] = calcVar;
}
for (BasicBlock* block : proc) {
for (Value* value : *block) {
if (value->opcode() != Set)
continue;
Variable* variable = value->as<VariableValue>()->variable();
if (SSACalculator::Variable* calcVar = variableToCalcVar[variable])
ssa.newDef(calcVar, block, value->child(0));
}
}
ssa.computePhis(
[&] (SSACalculator::Variable* calcVar, BasicBlock* block) -> Value* {
Variable* variable = calcVarToVariable[calcVar->index()];
Value* phi = proc.add<Value>(Phi, variable->type(), block->at(0)->origin());
if (verbose) {
dataLog(
"Adding Phi for ", pointerDump(variable), " at ", *block, ": ",
deepDump(proc, phi), "\n");
}
return phi;
});
InsertionSet insertionSet(proc);
IndexMap<Variable, Value*> mapping(proc.variables().size());
for (BasicBlock* block : proc.blocksInPreOrder()) {
mapping.clear();
for (unsigned index = calcVarToVariable.size(); index--;) {
Variable* variable = calcVarToVariable[index];
SSACalculator::Variable* calcVar = ssa.variable(index);
SSACalculator::Def* def = ssa.reachingDefAtHead(block, calcVar);
if (def)
mapping[variable] = def->value();
}
for (SSACalculator::Def* phiDef : ssa.phisForBlock(block)) {
Variable* variable = calcVarToVariable[phiDef->variable()->index()];
insertionSet.insertValue(0, phiDef->value());
mapping[variable] = phiDef->value();
}
for (unsigned valueIndex = 0; valueIndex < block->size(); ++valueIndex) {
Value* value = block->at(valueIndex);
value->performSubstitution();
switch (value->opcode()) {
case Get: {
VariableValue* variableValue = value->as<VariableValue>();
Variable* variable = variableValue->variable();
if (Value* replacement = mapping[variable])
value->replaceWithIdentity(replacement);
else {
value->replaceWithIdentity(
insertionSet.insertBottom(valueIndex, value));
}
break;
}
case Set: {
VariableValue* variableValue = value->as<VariableValue>();
Variable* variable = variableValue->variable();
mapping[variable] = value->child(0);
value->replaceWithNop();
break;
}
default:
break;
}
}
unsigned upsilonInsertionPoint = block->size() - 1;
Origin upsilonOrigin = block->last()->origin();
for (BasicBlock* successorBlock : block->successorBlocks()) {
for (SSACalculator::Def* phiDef : ssa.phisForBlock(successorBlock)) {
Value* phi = phiDef->value();
SSACalculator::Variable* calcVar = phiDef->variable();
Variable* variable = calcVarToVariable[calcVar->index()];
Value* mappedValue = mapping[variable];
if (verbose) {
dataLog(
"Mapped value for ", *variable, " with successor Phi ", *phi,
" at end of ", *block, ": ", pointerDump(mappedValue), "\n");
}
if (!mappedValue)
mappedValue = insertionSet.insertBottom(upsilonInsertionPoint, phi);
insertionSet.insert<UpsilonValue>(
upsilonInsertionPoint, upsilonOrigin, mappedValue, phi);
}
}
insertionSet.execute(block);
}
if (verbose) {
dataLog("B3 after SSA conversion:\n");
dataLog(proc);
}
return true;
}
} }
#endif // ENABLE(B3_JIT)