protected virtual void GetOperationsToMutate(
ProgramGraph programGraph, ValueNode rootVal, int depth,
IList operationsToMutate)
{
if (depth > 0) {
if (!rootVal.IsInputValue()) {
OperationNode op =
(OperationNode) rootVal.ProducingOperation;
if (!operationsToMutate.Contains(op)) {
operationsToMutate.Add(op);
foreach (ValueNode opVal in op.OperandValues) {
GetOperationsToMutate(programGraph, opVal, depth - 1,
operationsToMutate);
}
}
}
}
}
protected virtual void CloneEdgesForValue(
ValueNode val,
InstructionGraph clone,
IDictionary instructionMap,
IDictionary valueMap,
IDictionary valueProcessed)
{
if (!(bool) valueProcessed[val] && !val.IsInputValue()) {
valueProcessed[val] = true;
ValueNode cloneResValue = (ValueNode) valueMap[val];
InstructionNode cloneInstr =
(InstructionNode) instructionMap[val.ProducingInstruction];
clone.AddEdge(cloneInstr, cloneResValue);
foreach (ValueNode opVal in val.ProducingInstruction.OperandValues) {
ValueNode cloneOpVal = (ValueNode) valueMap[opVal];
clone.AddEdge(cloneOpVal, cloneInstr);
CloneEdgesForValue(opVal, clone, instructionMap, valueMap,
valueProcessed);
}
}
}
public virtual bool Cover(
ValueNode patternValue, CoveringInfo coveringInfo)
{
bool result = false;
if (IsCoverableWith(patternValue)) {
if (!IsInputValue() && !patternValue.IsInputValue()) {
if (patternValue.OutNodes.Count == 0 ||
ConsumingOperations.Count <= 1 && !OutputFlag) {
if (ProducingOperation.Cover(
patternValue.ProducingOperation,
coveringInfo)) {
result = true;
}
}
} else if (patternValue.IsInputValue()) {
coveringInfo.OperandValues.Add(this);
result = true;
}
if (result == true)
coveringInfo.CoveredValues.Add(this);
}
return result;
}
protected virtual void InsertTransferInstructionBefore(
ValueNode val, Register fromReg, Register toReg,
RegisterSet fromSet, RegisterSet toSet)
{
IList applicableTransferInstr =
GetTransferInstructions(fromReg, toReg);
ValueNode newVal = new RegisterValueNode(val.Datatype);
instructionGraph.AddNode(newVal);
if (!val.IsInputValue()) {
InstructionNode prodInstr = val.ProducingInstruction;
instructionGraph.RemoveEdge(prodInstr, val);
instructionGraph.AddEdge(prodInstr, newVal);
}
Instruction transferInstr =
(Instruction) applicableTransferInstr[
GA.Random.Next(applicableTransferInstr.Count)];
InstructionNode transferNode =
new InstructionNode(transferInstr);
instructionGraph.AddNode(transferNode);
instructionGraph.AddEdge(newVal, transferNode);
instructionGraph.AddEdge(transferNode, val);
instructionGraph.AssignableRegisters[val] = toSet;
instructionGraph.AssignableRegisters[newVal] = fromSet;
}
protected virtual void InitializeValue(
ValueNode val, IDictionary valueInitialized)
{
if (!((bool) valueInitialized[val])) {
valueInitialized[val] = true;
if (!val.IsInputValue()) {
IList coveringDesc = (IList) CoveringDesc[val];
CoveringInfo ci = (CoveringInfo)
coveringDesc[GA.Random.Next(coveringDesc.Count)];
foreach (OperationNode op in ci.CoveredOperations)
selection[op] = ci;
foreach (ValueNode opVal in ci.OperandValues)
InitializeValue(opVal, valueInitialized);
}
}
}
protected virtual RegisterSet ComputeAssignableRegistersForValue(
ValueNode val, Queue registerValues)
{
RegisterSet assignableRegs = new RegisterSet();
if (!val.IsInputValue()) {
InstructionNode prodInstr = val.ProducingInstruction;
assignableRegs = assignableRegs
+ prodInstr.Instruction.ResultRegisters;
} else {
InstructionNode consInstr0 =
(InstructionNode) val.ConsumingInstructions[0];
int valIndex =
consInstr0.OperandValues.IndexOf(val);
assignableRegs = assignableRegs
+ consInstr0.Instruction.OperandsRegisters[valIndex];
}
if (val.OutNodes.Count > 0) {
IList consumingInstructions = new ArrayList();
foreach (InstructionNode consInstr in val.ConsumingInstructions)
consumingInstructions.Add(consInstr);
foreach (InstructionNode consInstr in consumingInstructions) {
int valIndex =
consInstr.OperandValues.IndexOf(val);
RegisterSet consRegs =
consInstr.Instruction.OperandsRegisters[valIndex];
if ((assignableRegs * consRegs).Count == 0) {
ValueNode newVal =
InsertTransferInstruction(
val, consInstr, assignableRegs);
registerValues.Enqueue(val);
registerValues.Enqueue(newVal);
} else {
assignableRegs = assignableRegs * consRegs;
}
}
}
return assignableRegs;
}
protected virtual void BuildInstructionGraphForValue(
ValueNode val, IDictionary valueProcessed,
IDictionary valueNodeMap)
{
if (!(bool) valueProcessed[val]) {
ValueNode iVal = (ValueNode) val.Clone();
instructionGraph.AddNode(iVal);
valueProcessed[val] = true;
valueNodeMap[val] = iVal;
if (!val.IsInputValue()) {
CoveringInfo ci =
(CoveringInfo) selection[val.ProducingOperation];
InstructionNode instr =
new InstructionNode(ci.Instruction);
instructionGraph.AddNode(instr);
instructionGraph.AddEdge(instr, iVal);
foreach (ValueNode opVal in ci.OperandValues) {
BuildInstructionGraphForValue(
opVal, valueProcessed, valueNodeMap);
ValueNode iOpVal = (ValueNode) valueNodeMap[opVal];
instructionGraph.AddEdge(iOpVal, instr);
}
}
}
}
