public string ToDirective(string line)
{
InstructionTranslator instructionTranslator = new InstructionTranslator();
string directive = instructionTranslator.ToDirective(line);
return(directive);
}
public override StatementList AllocObject(IVariable var, InstructionTranslator instTranslator)
{
var freshVariable = instTranslator.GetFreshVariable(Helpers.GetBoogieType(var));
var stmts = new StatementList();
stmts.Add(dispatcher.AllocObject(freshVariable));
stmts.Add(bg.VariableAssignment(var, freshVariable));
return(stmts);
}
public override StatementList AllocObject(IVariable var, InstructionTranslator instTranslator)
{
if (RequiresAllocation(var))
{
return(memAddr.AllocObject(var, instTranslator));
}
else
{
return(memBCT.AllocObject(var, instTranslator));
}
}
StatementList TranslateInstructions(out Dictionary <string, BoogieVariable> temporalVariables)
{
InstructionTranslator instTranslator = new InstructionTranslator(this.CHA, methodBody, CFG, inputAssemblies);
instTranslator.Translate();
foreach (var v in instTranslator.RemovedVariables)
{
methodBody.Variables.Remove(v);
}
foreach (var v in instTranslator.AddedVariables)
{
methodBody.Variables.Add(v);
}
temporalVariables = instTranslator.temporalVariables;
return(instTranslator.Boogie());
}
// called from Traverser
// set in Main
public static void IMethodDefinitionTraverse(IMethodDefinition mD, IMetadataHost host, ISourceLocationProvider sourceLocationProvider)
{
// TODO: Hack to for treating a method as nondet
var method = mD.ResolvedMethod;
var methodName = method.ContainingType.FullName() + "." + method.Name.Value;
if (methodName.Equals("SVX.ContractBase.getNondet"))
{
InstructionTranslator.AddToExternalMethods(method);
return;
}
// End Hack
if (!mD.IsExternal)
{
try
{
if (whitelistContains(mD.ContainingType.FullName()))
{
var disassembler = new Disassembler(host, mD, sourceLocationProvider);
MethodBody mB = disassembler.Execute();
transformBody(mB);
MethodTranslator methodTranslator = new MethodTranslator(mD, mB, Traverser.CHA);
// todo: improve this piece of code
StreamWriter streamWriter = Program.streamWriter;
streamWriter.WriteLine(methodTranslator.Translate());
Helpers.addTranslatedMethod(mD);
}
}
catch (InvalidOperationException ex)
{
Console.WriteLine("WARNING: Exception thrown while translating method (omitting): " + BoogieMethod.From(mD).Name);
if (!Settings.SilentExceptionsForMethods)
{
throw ex;
}
}
}
}
private void TranslateInstruction(TranslationContext context, Instruction instruction)
{
context.Provider.SourceInstruction = instruction;
_debugInfo.Inject(context, instruction);
AddInstructionPrefix(context, instruction);
context.CastToParamType = true;
var core = new InstructionTranslator(context);
core.Translate(instruction);
var castToParamType = context.CastToParamType;
var code = context.Code;
var set = code.ToArray();
//we should box receiver for call on boxable types
BoxReceiver(context, instruction, ref set);
if (instruction.IsEndOfBasicBlock())
{
CastToBlockParam(context);
PopScope(context.New());
}
if (WithSuffix(instruction))
{
context.Emit(set);
if (castToParamType)
{
CastToParamType(context, instruction);
}
AddInstructionSuffix(context, instruction);
}
}
public override StatementList WriteInstanceField(InstanceFieldAccess instanceFieldAccess, Expression value, InstructionTranslator instTranslator)
{
if (RequiresAllocation(instanceFieldAccess))
{
return(memAddr.WriteInstanceField(instanceFieldAccess, value, instTranslator));
}
else
{
return(memBCT.WriteInstanceField(instanceFieldAccess, value, instTranslator));
}
}
public StatementList WriteInstanceField(InstanceFieldAccess instanceFieldAccess, IVariable value, InstructionTranslator instTranslator)
{
return(WriteInstanceField(instanceFieldAccess, ReadAddr(value), instTranslator));
}
public override StatementList WriteInstanceField(InstanceFieldAccess instanceFieldAccess, Expression expr, InstructionTranslator instTranslator)
{
StatementList stmts = new StatementList();
String fieldName = FieldTranslator.GetFieldName(instanceFieldAccess.Field);
//var addr = AddressOf(instanceFieldAccess);
//var writeAddr = WriteAddr(addr, value);
if (!Settings.SplitFieldsEnabled())
{
if (!Helpers.IsBoogieRefType(expr.Type)) // int, bool, real
{
stmts.Add(Expression.AssumeInverseRelationUnionAndPrimitiveType(expr));
stmts.Add(dispatcher.WriteAddr(dispatcher.AddressOf(instanceFieldAccess), Expression.PrimitiveType2Union(expr, instTranslator.Boogie())));
//sb.AppendLine(String.Format("\t\t$Heap := Write($Heap, {0}, {1}, {2});", instanceFieldAccess.Instance, fieldName, PrimitiveType2Union(Helpers.GetBoogieType(value.Type), value.Name)));
}
else
{
stmts.Add(dispatcher.WriteAddr(dispatcher.AddressOf(instanceFieldAccess), expr));
//sb.AppendLine(String.Format("\t\t$Heap := Write($Heap, {0}, {1}, {2});", instanceFieldAccess.Instance, fieldName, value.Name));
}
}
else
{
var boogieType = expr.Type;
// var heapAccess = String.Format("{0}[{1}]", fieldName, instanceFieldAccess.Instance);
//F$ConsoleApplication3.Foo.p[f_Ref] := $ArrayContents[args][0];
if (Helpers.IsGenericField(instanceFieldAccess.Field) && !boogieType.Equals(Helpers.BoogieType.Ref))
{
stmts.Add(Expression.AssumeInverseRelationUnionAndPrimitiveType(expr));
//sb.AppendLine(VariableAssignment(heapAccess, PrimitiveType2Union(boogieType, value.Name)));
stmts.Add(dispatcher.WriteAddr(dispatcher.AddressOf(instanceFieldAccess), Expression.PrimitiveType2Union(expr, instTranslator.Boogie())));
}
else
{
stmts.Add(dispatcher.WriteAddr(dispatcher.AddressOf(instanceFieldAccess), expr));
}
}
return(stmts);
}
public override StatementList CallReadArrayElement(IVariable resultVariable, Expression array, Expression index, InstructionTranslator instructionTranslator)
{
StatementList stmts = new StatementList();
return(dispatcher.CallReadArrayElement(BoogieVariable.FromDotNetVariable(resultVariable), array, index));
}
public override StatementList CallReadArrayElement(IVariable resultVariable, Expression array, Expression index, InstructionTranslator instructionTranslator)
{
StatementList stmts = new StatementList();
BoogieVariable boogieResVar = null;
if (resultVariable != null)
{
boogieResVar = instructionTranslator.GetFreshVariable(Helpers.GetBoogieType(resultVariable));
}
stmts.Add(dispatcher.CallReadArrayElement(boogieResVar, array, index));
if (resultVariable != null)
{
stmts.Add(dispatcher.WriteAddr(dispatcher.AddressOf(resultVariable), boogieResVar));
}
return(stmts);
}
public override StatementList AllocObject(IVariable var, InstructionTranslator instTranslator)
{
return(this.AllocObject(BoogieVariable.FromDotNetVariable(var)));
}
public override StatementList WriteInstanceField(InstanceFieldAccess instanceFieldAccess, Expression expr, InstructionTranslator instTranslator)
{
StatementList stmts = new StatementList();
var boogieType = expr.Type;
if (Helpers.IsGenericField(instanceFieldAccess.Field) && !boogieType.Equals(Helpers.BoogieType.Object))
{
stmts.Add(Expression.AssumeInverseRelationUnionAndPrimitiveType(expr));
stmts.Add(dispatcher.WriteAddr(dispatcher.AddressOf(instanceFieldAccess), Expression.PrimitiveType2Union(expr, instTranslator.Boogie())));
}
else
{
stmts.Add(dispatcher.WriteAddr(dispatcher.AddressOf(instanceFieldAccess), expr));
}
return(stmts);
}
public override StatementList CallReadArrayElement(IVariable resultVariable, Expression array, Expression index, InstructionTranslator instructionTranslator)
{
if (RequiresAllocation(resultVariable))
{
return(memAddr.CallReadArrayElement(resultVariable, array, index, instructionTranslator));
}
else
{
return(memBCT.CallReadArrayElement(resultVariable, array, index, instructionTranslator));
}
}
public abstract StatementList AllocObject(IVariable var, InstructionTranslator instTranslator);
public abstract StatementList WriteInstanceField(InstanceFieldAccess instanceFieldAccess, Expression value, InstructionTranslator instTranslator);
public abstract StatementList CallReadArrayElement(IVariable resultVariable, Expression array, Expression index, InstructionTranslator instructionTranslator);
