private void ApplyRuleForMoveTupleLiteral(ref bool appliedRule, Core.InstructionMoveLiteralTuple inst)
{
var destType = TypeResolver.GetDataAccessType(session, funct, inst.destination);
var tupleElements = new Core.Type[inst.sourceElements.Length];
for (var i = 0; i < inst.sourceElements.Length; i++)
{
tupleElements[i] = TypeResolver.GetDataAccessType(session, funct, inst.sourceElements[i]);
}
var srcTuple = Core.TypeTuple.Of(tupleElements);
var srcType = (Core.Type)srcTuple;
var inferredDest = TypeInferencer.Try(session, srcType, ref destType);
var inferredSrc = TypeInferencer.Try(session, destType, ref srcType);
if (inferredDest)
{
appliedRule = ApplyToDataAccess(inst.destination, destType);
}
if (inferredSrc)
{
for (var i = 0; i < inst.sourceElements.Length; i++)
{
appliedRule = ApplyToDataAccess(inst.sourceElements[i], srcTuple.elementTypes[i]);
}
}
}
private void ApplyRuleForMoveIntLiteral(ref bool appliedRule, Core.InstructionMoveLiteralInt inst)
{
var destType = TypeResolver.GetDataAccessType(session, funct, inst.destination);
var srcType = Core.TypeStruct.Of(session.PrimitiveInt);
var inferredDest = TypeInferencer.Try(session, srcType, ref destType);
if (inferredDest)
{
appliedRule = ApplyToDataAccess(inst.destination, destType);
}
}
private void ApplyRuleForBranch(ref bool appliedRule, Core.SegmentFlowBranch flow)
{
var destType = Core.TypeStruct.Of(session.PrimitiveBool);
var srcType = TypeResolver.GetDataAccessType(session, funct, flow.conditionReg);
var inferredSrc = TypeInferencer.Try(session, destType, ref srcType);
if (inferredSrc)
{
appliedRule = ApplyToDataAccess(flow.conditionReg, destType);
}
}
private void ApplyRuleForMoveData(ref bool appliedRule, Core.InstructionMoveData inst)
{
var destType = TypeResolver.GetDataAccessType(session, funct, inst.destination);
var srcType = TypeResolver.GetDataAccessType(session, funct, inst.source);
var inferredDest = TypeInferencer.Try(session, srcType, ref destType);
var inferredSrc = TypeInferencer.Try(session, destType, ref srcType);
if (inferredDest)
{
appliedRule = ApplyToDataAccess(inst.destination, destType);
}
if (inferredSrc)
{
appliedRule = ApplyToDataAccess(inst.source, destType);
}
}
private void ApplyRuleForMoveCallResult(ref bool appliedRule, Core.InstructionMoveCallResult inst)
{
var destType = TypeResolver.GetDataAccessType(session, funct, inst.destination);
var callType = TypeResolver.GetDataAccessType(session, funct, inst.callTargetSource);
var callFunct = callType as Core.TypeFunct;
if (callFunct == null)
{
return;
}
var inferredResult = TypeInferencer.Try(session, callFunct.returnType, ref destType);
if (inferredResult)
{
appliedRule = ApplyToDataAccess(inst.destination, destType);
}
/*var srcArgumentTypes = new Core.Type[inst.argumentSources.Length];
* for (var i = 0; i < inst.argumentSources.Length; i++)
* srcArgumentTypes[i] = GetDataAccessType(inst.argumentSources[i]);
*
* var srcFunct = Core.TypeFunct.Of(destType, srcArgumentTypes);
* var srcType = (Core.Type)srcFunct;
*
* var inferredFunct = TypeInferencer.Try(session, callType, ref srcType);
* var inferredFunctArgs = TypeInferencer.Try(session, srcType, ref callType);
* var inferredResult = TypeInferencer.Try(session, callFunct.returnType, ref destType);
* var inferredFunctResult = TypeInferencer.Try(session, destType, ref callFunct.returnType);*/
/*if (result)
* {
* this.appliedAnyRule = true;
*
* routine.registers[inst.calledSource.registerIndex].type = callType;
* routine.registers[inst.destination.registerIndex].type = callFunct.returnType;
*
* for (var i = 0; i < inst.argumentSources.Count; i++)
* {
* this.routine.registers[inst.argumentSources[i].registerIndex].type =
* srcFunct.argumentTypes[i];
* }
* }*/
}
private void ApplyRuleForMoveAddr(ref bool appliedRule, Core.InstructionMoveAddr inst)
{
var destType = TypeResolver.GetDataAccessType(session, funct, inst.destination);
var srcPtr = Core.TypePointer.Of(
inst.mutable,
TypeResolver.GetDataAccessType(session, funct, inst.source));
var srcType = (Core.Type)srcPtr;
var inferredDest = TypeInferencer.Try(session, srcType, ref destType);
var inferredSrc = TypeInferencer.Try(session, destType, ref srcType);
if (inferredDest)
{
appliedRule = ApplyToDataAccess(inst.destination, destType);
}
if (inferredSrc)
{
appliedRule = ApplyToDataAccess(inst.source, srcPtr.pointedToType);
}
}
private void ApplyRuleForMoveFunctLiteral(ref bool appliedRule, Core.InstructionMoveLiteralFunct inst)
{
var destType = TypeResolver.GetDataAccessType(session, funct, inst.destination);
var srcType = (Core.Type) this.session.GetFunct(inst.functIndex).MakeFunctType();
var inferredDest = TypeInferencer.Try(session, srcType, ref destType);
if (inferredDest)
{
appliedRule = ApplyToDataAccess(inst.destination, destType);
}
/*if (inst.destination.fieldAccesses.Count > 0)
* throw new InternalException("not implemented");
*
* if (inst.potentialFuncts.Count > 0)
* {
* for (var i = inst.potentialFuncts.Count - 1; i >= 0; i--)
* {
* var functType = new TypeFunct(inst.potentialFuncts[i]);
* if (!functType.IsMatch(this.routine.registers[inst.destination.registerIndex].type))
* {
* inst.potentialFuncts.RemoveAt(i);
* this.appliedAnyRule = true;
* }
* }
* }
*
* if (inst.potentialFuncts.Count == 1)
* {
* if (TryInference(this.session,
* new TypeFunct(inst.potentialFuncts[0]),
* ref routine.registers[inst.destination.registerIndex].type))
* this.appliedAnyRule = true;
* }*/
}
