private void GenerateCombiningRequest()
{
var acrequest = AH.MakeGenericTypeSpecific("ArmadaCombiningRequest",
new List <Type> {
AH.ReferToType("LPlusState"),
AH.ReferToType("L.Armada_TraceEntry"),
AH.ReferToType("L.Armada_PC"),
AH.ReferToType("HState"),
AH.ReferToType("H.Armada_TraceEntry"),
AH.ReferToType("H.Armada_PC")
});
pgp.MainProof.AddTypeSynonymDecl("ACRequest", acrequest);
string str = @"
function GetArmadaCombiningRequest() : ACRequest
{
ArmadaCombiningRequest(LPlus_GetSpecFunctions(), H.Armada_GetSpecFunctions(),
GetLPlusHRefinementRelation(), InductiveInv,
ConvertTotalState_LPlusH, ConvertTraceEntry_LH, ConvertPC_LH, IsInnerPC)
}
";
pgp.AddFunction(str);
}
protected override void GenerateConvertStackFrame_HL()
{
var cases = new List <MatchCaseExpr>();
var methodNames = pgp.symbolsHigh.MethodNames;
foreach (var methodName in methodNames)
{
var smst = pgp.symbolsHigh.GetMethodSymbolTable(methodName);
var ps = new List <Expression>();
var bvs = new List <BoundVar>();
foreach (var v in smst.AllVariablesInOrder)
{
var ty = (v is AddressableArmadaVariable) ? AH.ReferToType("Armada_Pointer") : v.ty;
var e = AH.MakeNameSegment(v.FieldName, ty);
if (methodName != strategy.MethodName || v.name != strategy.VariableName)
{
ps.Add(e);
}
var bv = AH.MakeBoundVar(v.FieldName, v.GetFlattenedType(pgp.symbolsHigh));
bvs.Add(bv);
}
var case_body = AH.MakeApplyN($"L.Armada_StackFrame_{methodName}", ps, "L.Armada_StackFrame");
cases.Add(AH.MakeMatchCaseExpr($"Armada_StackFrame_{methodName}", bvs, case_body));
}
var source = AH.MakeNameSegment("frame", "H.Armada_StackFrame");
var body = AH.MakeMatchExpr(source, cases, "L.Armada_StackFrame");
var formals = new List <Formal> {
AH.MakeFormal("frame", "H.Armada_StackFrame")
};
var fn = AH.MakeFunction("ConvertStackFrame_HL", formals, body);
pgp.AddDefaultClassDecl(fn, "convert");
}
protected override void GenerateConvertStackFrame_LH()
{
var cases = new List <MatchCaseExpr>();
var methodNames = pgp.symbolsLow.MethodNames;
foreach (var methodName in methodNames)
{
var smst = pgp.symbolsLow.GetMethodSymbolTable(methodName);
var ps = new List <Expression>();
var bvs = new List <BoundVar>();
var lowVarNames = new List <string>(smst.AllVariableNamesInOrder);
foreach (var varName in lowVarNames)
{
var v = smst.LookupVariable(varName);
var ty = (v is AddressableArmadaVariable) ? AH.ReferToType("Armada_Pointer") : v.ty;
var e = AH.MakeNameSegment(v.FieldName, ty);
ps.Add(e);
var bv = AH.MakeBoundVar(v.FieldName, v.GetFlattenedType(pgp.symbolsLow));
bvs.Add(bv);
}
smst = pgp.symbolsHigh.GetMethodSymbolTable(methodName);
var highVars = new List <ArmadaVariable>(smst.AllVariablesInOrder);
if (highVars.Count() != lowVarNames.Count())
{
for (var i = 0; i < highVars.Count(); ++i)
{
if (!lowVarNames.Contains(highVars[i].name))
{
var v = highVars[i];
var ty = (v is AddressableArmadaVariable) ? AH.ReferToType("Armada_Pointer") : v.ty;
ps.Insert(i, AH.MakeNameSegment(strategy.InitializationExpression, ty));
}
}
}
var case_body = AH.MakeApplyN($"H.Armada_StackFrame_{methodName}", ps, "H.Armada_StackFrame");
cases.Add(AH.MakeMatchCaseExpr($"Armada_StackFrame_{methodName}", bvs, case_body));
}
var source = AH.MakeNameSegment("frame", "L.Armada_StackFrame");
var body = AH.MakeMatchExpr(source, cases, "H.Armada_StackFrame");
var formals = new List <Formal> {
AH.MakeFormal("frame", "L.Armada_StackFrame")
};
var fn = AH.MakeFunction("ConvertStackFrame_LH", formals, body);
pgp.AddDefaultClassDecl(fn, "convert");
}
////////////////////////////////////////////////////////////////////////
/// Variable-hiding request
////////////////////////////////////////////////////////////////////////
private void GenerateVarHidingRequest()
{
string str;
var lplusstate = AH.ReferToType("LPlusState");
var hstate = AH.ReferToType("HState");
var lstep = AH.ReferToType("LStep");
var hstep = AH.ReferToType("HStep");
var vhrequest = AH.MakeGenericTypeSpecific("VarHidingRequest", new List <Type> {
lplusstate, hstate, lstep, hstep
});
pgp.MainProof.AddTypeSynonymDecl("VHRequest", vhrequest);
if (suppressedPCs.Count > 0)
{
str = @"
predicate IsSuppressedPC(pc:L.Armada_PC)
{
";
str += string.Join(" || ", suppressedPCs.Select(s => $"pc.{s}?"));
str += "\n}\n";
}
else
{
str = @"
predicate IsSuppressedPC(pc:L.Armada_PC)
{
false
}
";
}
pgp.AddPredicate(str);
str = @"
function GetVarHidingRequest() : VHRequest
{
VarHidingRequest(GetLPlusSpec(), GetHSpec(), GetLPlusHRefinementRelation(), InductiveInv, ConvertTotalState_LPlusH,
ConvertAndSuppressMultistep)
}
";
pgp.AddFunction(str);
}
private void GenerateWeakeningRequest()
{
var lplusstate = AH.ReferToType("LPlusState");
var hstate = AH.ReferToType("HState");
var lstep = AH.ReferToType("LStep");
var hstep = AH.ReferToType("HStep");
var wrequest = AH.MakeGenericTypeSpecific("WeakeningRequest", new List <Type> {
lplusstate, hstate, lstep, hstep
});
pgp.MainProof.AddTypeSynonymDecl("WRequest", wrequest);
var str = @"
function GetWeakeningRequest(): WRequest
{
WeakeningRequest(GetLPlusSpec(), GetHSpec(), GetLPlusHRefinementRelation(), iset lps : LPlusState | InductiveInv(lps) :: lps, ConvertTotalState_LPlusH, ConvertMultistep_LH)
}
";
pgp.AddFunction(str);
}
public Type FlattenType(Type t, string moduleName = null)
{
if (t is UserDefinedType)
{
var ut = (UserDefinedType)t;
if (DoesStructExist(ut.Name))
{
return(AH.ReferToType("Armada_Struct_" + ut.Name, moduleName));
}
}
else if (t is SizedArrayType)
{
var ssa = (SizedArrayType)t;
return(new SeqType(FlattenType(ssa.Range, moduleName)));
}
else if (t is PointerType)
{
return(AH.ReferToType("Armada_Pointer"));
}
return(t);
}
public Expression ReserveVariableName(string varName, string typeName)
{
return(ReserveVariableName(varName, AH.ReferToType(typeName)));
}
public override Type GetFlattenedType(ArmadaSymbolTable symbols, string moduleName = null)
{
return(AH.ReferToType("Armada_Pointer"));
}
public NextFormal(string globallyUniqueVarName, string localVarName, string varTypeName)
{
GloballyUniqueVarName = globallyUniqueVarName;
LocalVarName = localVarName;
VarType = AH.ReferToType(varTypeName);
}
public GhostsArmadaLValue() : base(Token.NoToken, AH.ReferToType("Armada_Ghosts"), new UndefinedBehaviorAvoidanceConstraint())
{
}
public TopStackFrameArmadaLValue(UndefinedBehaviorAvoidanceConstraint i_crashAvoidance) : base(Token.NoToken, AH.ReferToType("Armada_StackFrame"), i_crashAvoidance)
{
}
public TopStackVarsArmadaLValue(UndefinedBehaviorAvoidanceConstraint i_crashAvoidance, string i_methodName)
: base(Token.NoToken, AH.ReferToType($"Armada_StackVars_{i_methodName}"), i_crashAvoidance)
{
methodName = i_methodName;
}
