示例#1
0
        /// <summary>
        /// Creates the control-flow graph nodes of the specified method summary.
        /// </summary>
        internal static IControlFlowNode Create(ControlFlowGraph cfg, MethodSummary summary)
        {
            var entryNode = new ControlFlowNode(cfg, summary);

            entryNode.Statements.Add(Statement.Create(summary.Method.ParameterList, entryNode, summary));
            entryNode.Construct(GetStatements(summary.Method.Body), null, null);
            return(entryNode);
        }
示例#2
0
        /// <summary>
        /// Creates the control-flow graph nodes of the specified method summary.
        /// </summary>
        internal static IDataFlowNode Create(DataFlowGraph dfg, MethodSummary summary)
        {
            var entryNode = new DataFlowNode(dfg, summary.ControlFlowGraph.EntryNode, summary);

            entryNode.Construct(summary.ControlFlowGraph.EntryNode, null,
                                new Dictionary <IControlFlowNode, DataFlowNode>());
            return(entryNode);
        }
示例#3
0
        /// <summary>
        /// Resolves the side-effects in the call.
        /// </summary>
        private void ResolveSideEffectsInCall(ExpressionSyntax call, MethodSummary calleeSummary, IDataFlowNode node)
        {
            var invocation  = call as InvocationExpressionSyntax;
            var objCreation = call as ObjectCreationExpressionSyntax;

            if (calleeSummary is null ||
                (invocation is null && objCreation is null))
            {
                return;
            }

            ArgumentListSyntax argumentList;

            if (invocation != null)
            {
                argumentList = invocation.ArgumentList;
            }
            else
            {
                argumentList = objCreation.ArgumentList;
            }

            var sideEffects = this.ResolveSideEffectsInCall(argumentList, calleeSummary, node);

            foreach (var sideEffect in sideEffects)
            {
                node.DataFlowInfo.KillDefinitions(sideEffect.Key);

                SymbolDefinition definition = node.DataFlowInfo.GenerateDefinition(sideEffect.Key);
                DataFlowInfo.AssignTypeToDefinition(sideEffect.Key.Type, definition);
                node.DataFlowInfo.TaintDefinition(definition, definition);

                foreach (var symbol in sideEffect.Value)
                {
                    node.DataFlowInfo.TaintSymbol(symbol, sideEffect.Key);
                }
            }

            for (int index = 0; index < argumentList.Arguments.Count; index++)
            {
                if (!calleeSummary.SideEffectsInfo.ParameterAccesses.ContainsKey(index))
                {
                    continue;
                }

                var argIdentifier = AnalysisContext.GetRootIdentifier(
                    argumentList.Arguments[index].Expression);
                this.ResolveMethodParameterAccesses(argIdentifier, calleeSummary.SideEffectsInfo.ParameterAccesses[index], node);
            }

            foreach (var fieldAccess in calleeSummary.SideEffectsInfo.FieldAccesses)
            {
                foreach (var access in fieldAccess.Value)
                {
                    this.MapFieldAccessInStatement(fieldAccess.Key as IFieldSymbol, access);
                }
            }
        }
示例#4
0
        /// <summary>
        /// Maps the callee summary to the call symbol.
        /// </summary>
        private static void MapCalleeSummaryToCallSymbol(MethodSummary calleeSummary, ISymbol callSymbol, IDataFlowNode node)
        {
            if (!node.MethodSummaryCache.ContainsKey(callSymbol))
            {
                node.MethodSummaryCache.Add(callSymbol, new HashSet <MethodSummary>());
            }

            node.MethodSummaryCache[callSymbol].Add(calleeSummary);
        }
示例#5
0
 /// <summary>
 /// Resolves the gives-up ownership information in the call.
 /// </summary>
 private void ResolveGivesUpOwnershipInCall(ISymbol callSymbol, MethodSummary methodSummary,
                                            ArgumentListSyntax argumentList, IDataFlowNode node)
 {
     foreach (var paramIndex in methodSummary.SideEffectsInfo.GivesUpOwnershipParamIndexes)
     {
         var argExpr = argumentList.Arguments[paramIndex].Expression;
         this.ResolveGivesUpOwnershipInArgument(callSymbol, argExpr, node);
     }
 }
示例#6
0
        /// <summary>
        /// Initializes a new instance of the <see cref="DataFlowGraph"/> class.
        /// </summary>
        internal DataFlowGraph(MethodSummary summary)
            : base()
        {
            this.Summary       = summary;
            this.SemanticModel = summary.SemanticModel;

            this.EntryNode = DataFlowNode.Create(this, summary);
            this.MergeEmptyNodes();
        }
示例#7
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ControlFlowNode"/> class.
 /// </summary>
 protected ControlFlowNode(IGraph <IControlFlowNode> cfg, MethodSummary summary)
 {
     this.Id            = cfg.Nodes.Count;
     this.Graph         = cfg;
     this.Summary       = summary;
     this.Statements    = new List <Statement>();
     this.ISuccessors   = new HashSet <IControlFlowNode>();
     this.IPredecessors = new HashSet <IControlFlowNode>();
     cfg.Nodes.Add(this);
 }
示例#8
0
 /// <summary>
 /// Initializes a new instance of the <see cref="MethodSideEffectsInfo"/> class.
 /// </summary>
 internal MethodSideEffectsInfo(MethodSummary summary)
 {
     this.Summary = summary;
     this.FieldFlowParamIndexes        = new Dictionary <IFieldSymbol, ISet <int> >();
     this.FieldAccesses                = new Dictionary <IFieldSymbol, ISet <Statement> >();
     this.ParameterAccesses            = new Dictionary <int, ISet <Statement> >();
     this.ReturnedFields               = new HashSet <IFieldSymbol>();
     this.ReturnedParameters           = new HashSet <int>();
     this.ReturnTypes                  = new HashSet <ITypeSymbol>();
     this.GivesUpOwnershipParamIndexes = new HashSet <int>();
 }
示例#9
0
        /// <summary>
        /// Creates the summary of the specified method, using the
        /// specified parameter types.
        /// </summary>
        public static MethodSummary Create(AnalysisContext context, BaseMethodDeclarationSyntax method,
                                           IDictionary <int, ISet <ITypeSymbol> > parameterTypes)
        {
            if (method.Body is null)
            {
                return(null);
            }

            var summary = new MethodSummary(context, method, parameterTypes);

            summary.BuildSummary();
            summary.AnalyzeSummary();

            return(summary);
        }
示例#10
0
        /// <summary>
        /// Initializes a new instance of the <see cref="DataFlowNode"/> class.
        /// </summary>
        internal DataFlowNode(IGraph <IDataFlowNode> dfg, IControlFlowNode cfgNode, MethodSummary summary)
        {
            this.Id              = dfg.Nodes.Count;
            this.Graph           = dfg;
            this.ControlFlowNode = cfgNode;
            this.Summary         = summary;

            this.ISuccessors   = new HashSet <IDataFlowNode>();
            this.IPredecessors = new HashSet <IDataFlowNode>();
            dfg.Nodes.Add(this);

            this.DataFlowInfo        = new DataFlowInfo(this, summary.AnalysisContext);
            this.MethodSummaryCache  = new Dictionary <ISymbol, ISet <MethodSummary> >();
            this.GivesUpOwnershipMap = new HashSet <ISymbol>();
        }
示例#11
0
        /// <summary>
        /// Returns all cached method summaries for the specified call.
        /// </summary>
        private static ISet <MethodSummary> ResolveMethodSummaries(ExpressionSyntax call, IDataFlowNode node)
        {
            var summaries = new HashSet <MethodSummary>();

            var invocation  = call as InvocationExpressionSyntax;
            var objCreation = call as ObjectCreationExpressionSyntax;
            var callSymbol  = node.Summary.SemanticModel.GetSymbolInfo(call).Symbol;

            if (callSymbol is null ||
                (invocation is null && objCreation is null))
            {
                return(summaries);
            }

            if (node.MethodSummaryCache.ContainsKey(callSymbol))
            {
                summaries.UnionWith(node.MethodSummaryCache[callSymbol]);
            }
            else if (invocation != null)
            {
                var parameterTypes = GetCandidateParameterTypes(invocation.ArgumentList, node);
                var candidateCalleeDeclarations = ResolveCandidateMethodsAtCallSite(invocation, node);
                foreach (var candidateCalleeDeclaration in candidateCalleeDeclarations)
                {
                    var calleeSummary = MethodSummary.Create(node.Summary.AnalysisContext, candidateCalleeDeclaration, parameterTypes);
                    if (calleeSummary != null)
                    {
                        summaries.Add(calleeSummary);
                    }
                }
            }
            else
            {
                var parameterTypes = GetCandidateParameterTypes(objCreation.ArgumentList, node);
                var constructor    = ResolveMethodDeclaration(objCreation, node) as ConstructorDeclarationSyntax;
                if (constructor != null)
                {
                    var calleeSummary = MethodSummary.Create(node.Summary.AnalysisContext, constructor, parameterTypes);
                    if (calleeSummary != null)
                    {
                        summaries.Add(calleeSummary);
                    }
                }
            }

            return(summaries);
        }
示例#12
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ControlFlowGraph"/> class.
 /// </summary>
 internal ControlFlowGraph(MethodSummary summary)
     : base()
 {
     this.EntryNode = ControlFlowNode.Create(this, summary);
     this.MergeEmptyNodes();
 }
示例#13
0
文件: Statement.cs 项目: p-org/PSharp
 /// <summary>
 /// Creates a new statement.
 /// </summary>
 public static Statement Create(SyntaxNode syntaxNode, IControlFlowNode node, MethodSummary summary)
 {
     return(new Statement(syntaxNode, node, summary));
 }
示例#14
0
文件: Statement.cs 项目: p-org/PSharp
 /// <summary>
 /// Initializes a new instance of the <see cref="Statement"/> class.
 /// </summary>
 private Statement(SyntaxNode syntaxNode, IControlFlowNode node, MethodSummary summary)
 {
     this.SyntaxNode      = syntaxNode;
     this.ControlFlowNode = node;
     this.Summary         = summary;
 }