private static List <TflField> GetFields(CfgNode process, IEnumerable <Field> fieldDefinitions, ILogger logger, string entityName) { var fields = new List <TflField>(); foreach (var fd in fieldDefinitions) { if (fd.Type.Equals("string")) { logger.EntityInfo(entityName, "Using {0} character string for {1}.", fd.Length, fd.Name); } else { logger.EntityInfo(entityName, "Using {0} for {1}.", fd.Type, fd.Name); } var field = fd; fields.Add(process.GetDefaultOf <TflField>(f => { f.Name = field.Name; f.Length = field.Length; f.Type = field.Type; f.QuotedWith = field.QuotedWith; })); } return(fields); }
protected static void CreateExceptionalEdges(ProgramState state, CfgNode entryNode) { foreach (var node in state.NodesToLinkWithExceptionBlock) { node.ExceptionNodes.Add(entryNode); } state.NodesToLinkWithExceptionBlock = new List <CfgNode>(); }
/// <summary> /// Registers a node in the CFG and set it as the successfor of the previous node. /// </summary> /// <param name="state">Current program state.</param> /// <param name="node">Node to register.</param> protected void RegisterNode(ProgramState state, CfgNode node) { state.Cfg.RegisterNode(node); state.PreviousNode.Successors.Add(node); if (RememberNodeOffset) { state.SaveNodeOffset(node, PreviousProgramStack); RememberNodeOffset = false; } }
private CfgNode AddCfgNode(List <AstNode> nextNodes) { CfgNode cfgNode = new CfgNode(); foreach (var lines in nextNodes) { cfgNode.LineNumbers.Add(lines.LineNumber); } return(cfgNode); }
private void PrintInternal(CfgNode node) { //foreach (var lines in node.LineNumbers) //{ // Console.WriteLine(lines + ","); //} //foreach (var child in node.NextNodes) //{ // foreach (var lines in child.LineNumbers) // { // Console.WriteLine(lines + ","); // } //} //PrintInternal(node.NextNodes.Last()); }
private string InnerSerialize(CfgNode node) { var meta = CfgMetadataCache.GetMetadata(node.GetType()); var builder = new StringBuilder(); if (meta.All(kv => kv.Value.ListType == null)) { builder.Append("{"); SerializeAttributes(meta, node, builder); builder.TrimEnd(", "); builder.Append(" }"); } else { builder.AppendLine("{"); SerializeAttributes(meta, node, builder); SerializeElements(meta, node, builder, 1); builder.AppendLine(); builder.Append("}"); } return builder.ToString(); }
/// <summary> /// Creates a new node to ensure finally instructions aren't attached to a body node. /// </summary> private static CfgNode CreateFinallyHandlerNonExceptionalEntry(ProgramState state, ExceptionHandler handler, Instruction leaveTarget) { CfgNode finallyHandlerStartNode = null; (var nodeOffset, _) = state.GetOffsetNode(handler.HandlerStart.Offset); if (nodeOffset == null) { finallyHandlerStartNode = new StatementNode( location: GetHandlerStartLocation(state, handler), kind: StatementNode.StatementNodeKind.MethodBody, proc: state.ProcDesc); state.Cfg.RegisterNode(finallyHandlerStartNode); state.PreviousNode.Successors.Add(finallyHandlerStartNode); state.AppendToPreviousNode = true; } state.EndfinallyControlFlow = leaveTarget; return(finallyHandlerStartNode); }
/// <summary> /// Registers a node in the CFG and set it as the successor of the previous node. /// </summary> /// <param name="state">Current program state.</param> /// <param name="node">Node to register.</param> protected void RegisterNode(ProgramState state, CfgNode node) { state.Cfg.RegisterNode(node); state.PreviousNode.Successors.Add(node); node.BlockEndOffset = state.MethodExceptionHandlers .GetBlockEndOffsetFromOffset( state.CurrentInstruction.Offset); if (state.MethodExceptionHandlers.GetExceptionHandlerAtInstruction( state.CurrentInstruction) != null) { state.NodesToLinkWithExceptionBlock.Add(node); } if (RememberNodeOffset) { state.SaveNodeOffset(node, PreviousProgramStack, state.PreviousNode.BlockEndOffset); RememberNodeOffset = false; } }
string InnerSerialize(CfgNode node) { var type = node.GetType(); #if NETS var attribute = type.GetTypeInfo().GetCustomAttributes(typeof(CfgAttribute), true).FirstOrDefault() as CfgAttribute; #else var attribute = type.GetCustomAttributes(typeof(CfgAttribute), true).FirstOrDefault() as CfgAttribute; #endif if (attribute != null && !attribute.serialize) { return(string.Empty); } var name = !string.IsNullOrEmpty(attribute?.name) ? attribute.name : type.Name; var meta = CfgMetadataCache.GetMetadata(type); var builder = new StringBuilder(); if (JustAttributes(meta, node)) { builder.Append("<add"); SerializeAttributes(meta, node, builder); builder.Append(" />"); } else { builder.Append("<"); builder.Append(name); SerializeAttributes(meta, node, builder); builder.AppendLine(">"); SerializeElements(meta, node, builder, 1); builder.Append("</"); builder.Append(name); builder.Append(">"); } return(builder.ToString()); }
string InnerSerialize(CfgNode node) { var type = node.GetType(); var meta = CfgMetadataCache.GetMetadata(type); var builder = new StringBuilder(); if (JustAttributes(meta, node)) { builder.Append("<add"); SerializeAttributes(meta, node, builder); builder.Append(" />"); } else { builder.Append("<"); builder.Append(type.Name); SerializeAttributes(meta, node, builder); builder.AppendLine(">"); SerializeElements(meta, node, builder, 1); builder.Append("</"); builder.Append(type.Name); builder.Append(">"); } return builder.ToString(); }
private string InnerSerialize(CfgNode node) { var meta = CfgMetadataCache.GetMetadata(node.GetType()); var builder = new StringBuilder(); if (meta.All(kv => kv.Value.ListType == null)) { builder.Append("{"); SerializeAttributes(meta, node, builder); builder.TrimEnd(", "); builder.Append(" }"); } else { builder.AppendLine("{"); SerializeAttributes(meta, node, builder); SerializeElements(meta, node, builder, 1); builder.TrimEnd(", "); builder.AppendLine(); builder.Append("}"); } return(builder.ToString()); }
void AssertIns(CfgNode node, params string[] regs) { CollectionAssert.AreEquivalent(regs, node.In); }
public string Serialize(CfgNode node) { return JsonConvert.SerializeObject(node, _settings); }
protected static void CreateCatchHandlerEntryBlock(ProgramState state, ExceptionHandlerNode handlerNode, CfgNode handlerEntryPredecessor, Identifier exceptionIdentifier) { (var trueBranch, var falseBranch) = CreateExceptionTypeCheckBranchNodes( state, handlerNode.ExceptionHandler, exceptionIdentifier); handlerEntryPredecessor.Successors.Add(trueBranch); handlerEntryPredecessor.Successors.Add(falseBranch); if (!state.ExceptionHandlerToCatchVarNode.ContainsKey(handlerNode.ExceptionHandler)) { state.ExceptionHandlerToCatchVarNode[handlerNode.ExceptionHandler] = CreateLoadCatchVarNode(state, handlerNode.ExceptionHandler); // The CIL specification dictates that the exception object is on top of // the stack when the catch handler is entered; the first instruction of // the catch handler will handle the object pushed onto the stack. state.PushExpr(new VarExpression(exceptionIdentifier), new Tptr(Tptr.PtrKind.Pk_pointer, new Tstruct("System.Object"))); state.PushInstruction( handlerNode.ExceptionHandler.HandlerStart, state.ExceptionHandlerToCatchVarNode[handlerNode.ExceptionHandler].node); } (var loadCatchVarNode, _) = GetHandlerCatchVarNode( state, handlerNode.ExceptionHandler); trueBranch.Successors.Add(loadCatchVarNode); if (handlerNode.NextCatchBlock != null) { // Continues translation with catch handler's first instruction from // the handler's catch variable load node. CreateCatchHandlerEntryBlock(state, handlerNode.NextCatchBlock, falseBranch, exceptionIdentifier); } // Last catch handler of set; need to route control flow through the false // exception type-matching node. else { if (handlerNode.FinallyBlock != null) { var finallyBranchNode = CreateFinallyExceptionBranchNode( state, handlerNode.ExceptionHandler); falseBranch.Successors .Add(finallyBranchNode); (var finallyLoadCatchVar, _) = GetHandlerCatchVarNode( state, handlerNode.FinallyBlock); finallyBranchNode.Successors.Add(finallyLoadCatchVar); } else { var returnVariable = new LvarExpression( new LocalVariable(Identifier.ReturnIdentifier, state.Method)); var retType = state.Method.ReturnType.GetElementType(); var retInstr = new Store( returnVariable, new ExnExpression(new VarExpression(exceptionIdentifier)), Typ.FromTypeReference(retType), GetHandlerStartLocation(state, handlerNode.ExceptionHandler)); falseBranch.Instructions .Add(retInstr); falseBranch.Successors .Add(state.ProcDesc.ExceptionSinkNode); } } }
private static List<TflField> GetFields(CfgNode process, IEnumerable<Field> fieldDefinitions, ILogger logger, string entityName) { var fields = new List<TflField>(); foreach (var fd in fieldDefinitions) { if (fd.Type.Equals("string")) { logger.EntityInfo(entityName, "Using {0} character string for {1}.", fd.Length, fd.Name); } else { logger.EntityInfo(entityName, "Using {0} for {1}.", fd.Type, fd.Name); } var field = fd; fields.Add(process.GetDefaultOf<TflField>(f => { f.Name = field.Name; f.Length = field.Length; f.Type = field.Type; f.QuotedWith = field.QuotedWith; })); } return fields; }
protected override bool ParseCilInstructionInternal(Instruction instruction, ProgramState state) { int index; CfgNode node = null; switch (instruction.OpCode.Code) { case Code.Ldarg: index = (int)instruction.Operand; break; case Code.Ldarg_0: index = 0; break; case Code.Ldarg_1: index = 1; break; case Code.Ldarg_2: index = 2; break; case Code.Ldarg_3: index = 3; break; case Code.Ldarg_S: case Code.Ldarga: case Code.Ldarga_S: // Sequence accounts for the implict "this" argument, if applicable. index = (instruction.Operand as ParameterDefinition).Sequence; break; default: return(false); } (var argVar, var argType) = CreateArg(index, state.Method); if (instruction.OpCode.Code == Code.Ldarga || instruction.OpCode.Code == Code.Ldarga_S) { var argAddressType = new Address(Tptr.PtrKind.Pk_pointer, argType, argVar, referenceKind: Address.ReferenceKind.Parameter); state.PushExpr(argVar, argAddressType); } else { if (ParameterIsByReference(index, state.Method)) { // Strips out the pointer because the type produced by CreateArg already // carries it. var argAddressType = new Address(Tptr.PtrKind.Pk_pointer, argType.StripPointer(), argVar, referenceKind: Address.ReferenceKind.Parameter); state.PushExpr(argVar, argAddressType); } else { var loadArgument = state.PushAndLoad(argVar, argType); node = AddMethodBodyInstructionsToCfg(state, loadArgument); state.AppendToPreviousNode = true; } } state.PushInstruction(instruction.Next, node); return(true); }
public string Serialize(CfgNode node) { return InnerSerialize(node); }
protected override bool ParseCilInstructionInternal(Instruction instruction, ProgramState state) { int index; CfgNode node = null; switch (instruction.OpCode.Code) { case Code.Stloc_0: index = 0; break; case Code.Stloc_1: index = 1; break; case Code.Stloc_2: index = 2; break; case Code.Stloc_3: index = 3; break; case Code.Stloc_S: index = (instruction.Operand as VariableDefinition).Index; break; case Code.Stloc: index = (int)instruction.Operand; break; default: return(false); } (var value, var type) = state.Pop(); // Records that the variable stores a boxed value. if (type is BoxedValueType boxedValueType) { state.VariableIndexToBoxedValueType[index] = boxedValueType; } // A non-boxed value is being stored at the location, so the corresponding record is // accordingly updated. else if (!(type is BoxedValueType) && state.VariableIndexToBoxedValueType.ContainsKey(index)) { state.VariableIndexToBoxedValueType.Remove(index); } var variable = new LocalVariable(LocalName(index), state.Method); var storeValueIntoVariable = new Store(new LvarExpression(variable), value, type, state.CurrentLocation); node = AddMethodBodyInstructionsToCfg(state, storeValueIntoVariable); RegisterLocalVariable(state, variable, type); state.PushInstruction(instruction.Next, node); return(true); }
public string Serialize(CfgNode node) { return(InnerSerialize(node)); }
public string Serialize(CfgNode node) { return(JsonConvert.SerializeObject(node, _settings)); }
protected override bool ParseCilInstructionInternal(Instruction instruction, ProgramState state) { int index; CfgNode node = null; switch (instruction.OpCode.Code) { case Code.Ldloc: case Code.Ldloca: index = (int)instruction.Operand; break; case Code.Ldloc_0: index = 0; break; case Code.Ldloc_1: index = 1; break; case Code.Ldloc_2: index = 2; break; case Code.Ldloc_3: index = 3; break; case Code.Ldloc_S: case Code.Ldloca_S: index = (instruction.Operand as VariableDefinition).Index; break; default: return(false); } (var variableExpression, var variableType) = CreateLocal(index, state.Method); // Updates the type to the appropriate boxed one if the variable contains a boxed // value. if (state.VariableIndexToBoxedValueType.ContainsKey(index)) { variableType = state.VariableIndexToBoxedValueType[index]; } if (instruction.OpCode.Code == Code.Ldloca || instruction.OpCode.Code == Code.Ldloca_S) { // Stores the variable as the value stored at the address expression. state.PushExpr(variableExpression, new Address(Tptr.PtrKind.Pk_pointer, variableType, variableExpression)); } else { // Loads the value at the heap location onto the stack. var variableInstruction = state.PushAndLoad(variableExpression, variableType); node = AddMethodBodyInstructionsToCfg(state, variableInstruction); state.AppendToPreviousNode = true; } state.PushInstruction(instruction.Next, node); return(true); }
public string Serialize(CfgNode node) { _serializer.Serialize(_writer, node); return(_writer.ToString()); }