예제 #1
0
        /// <summary>
        /// Populates all pair-wise combinations of defs and uses identified through static analysis
        /// </summary>
        public void PopulateDUCoverTable()
        {
            DUCoverStore dcs = DUCoverStore.GetInstance();

            SafeSet <FieldDefUseStore> allDefs = new SafeSet <FieldDefUseStore>();

            allDefs.AddRange(this.DefDic.Keys);
            allDefs.AddRange(this.DefOrUseSet);

            SafeSet <FieldDefUseStore> allUses = new SafeSet <FieldDefUseStore>();

            allUses.AddRange(this.UseDic.Keys);
            allUses.AddRange(this.DefOrUseSet);
            int numInfeasible = 0;

            //Compute pair-wise combinations
            foreach (var defEntry in allDefs)
            {
                foreach (var useEntry in allUses)
                {
                    //Ignore the trivial entries that involve just a combination of setter and getter methods
                    if (defEntry.Method.ShortName.StartsWith("set_") && useEntry.Method.ShortName.StartsWith("get_"))
                    {
                        continue;
                    }
                    if (!this.IsFeasibleDUCoverEntry(dcs, defEntry, useEntry))
                    {
                        numInfeasible++;
                        continue;
                    }

                    DUCoverStoreEntry dcse = new DUCoverStoreEntry(this.fd, defEntry.Method, defEntry.Offset,
                                                                   useEntry.Method, useEntry.Offset);

                    if (defEntry.UnknownSideEffectMethod != null)
                    {
                        dcse.Def_UnknownSideEffectMethod = defEntry.UnknownSideEffectMethod;
                        dcse.DefUnsure = true;
                    }

                    if (useEntry.UnknownSideEffectMethod != null)
                    {
                        dcse.Use_UnknownSideEffectMethod = useEntry.UnknownSideEffectMethod;
                        dcse.UseUnsure = true;
                    }

                    if (!this.duCoverageTable.ContainsKey(dcse))
                    {
                        this.duCoverageTable[dcse] = 0;
                    }
                }
            }

            //Clear all the cached entries.
            this.feasibilityDicCache.Clear();

            logger.Debug("Detected infeasible du-pairs for field " + this.fd.FullName + "(" + numInfeasible + ")");
        }
예제 #2
0
        /// <summary>
        /// Updates the table
        /// </summary>
        /// <param name="defm"></param>
        /// <param name="defcl"></param>
        /// <param name="usem"></param>
        /// <param name="usecl"></param>
        public bool UpdateDUCoverageTable(Method defmd, int defoffset, Method usemd, int useoffset)
        {
            var dcse        = new DUCoverStoreEntry(this.fd, defmd, defoffset, usemd, useoffset);
            int existingVal = 0;

            if (!this.duCoverageTable.TryGetValue(dcse, out existingVal))
            {
                //Found a new entry in dynamic analysis, not found in static
                //logger.Warn("Dynamic Analysis new entry for field: " + this.fd.FullName + " " + dcse.ToString());
                return(false);
            }
            else
            {
                existingVal++;
                this.duCoverageTable[dcse] = existingVal;
            }

            return(true);
        }
예제 #3
0
        /// <summary>
        /// Updates the table
        /// </summary>
        /// <param name="defm"></param>
        /// <param name="defcl"></param>
        /// <param name="usem"></param>
        /// <param name="usecl"></param>
        public bool UpdateDUCoverageTable(Method defmd, int defoffset, Method usemd, int useoffset)
        {
            var dcse = new DUCoverStoreEntry(this.fd, defmd, defoffset, usemd, useoffset);
            int existingVal = 0;
            if (!this.duCoverageTable.TryGetValue(dcse, out existingVal))
            {
                //Found a new entry in dynamic analysis, not found in static
                //logger.Warn("Dynamic Analysis new entry for field: " + this.fd.FullName + " " + dcse.ToString());
                return false;
            }
            else
            {
                existingVal++;
                this.duCoverageTable[dcse] = existingVal;
            }

            return true;
        }
예제 #4
0
        /// <summary>
        /// Populates all pair-wise combinations of defs and uses identified through static analysis
        /// </summary>
        public void PopulateDUCoverTable()
        {
            DUCoverStore dcs = DUCoverStore.GetInstance();

            SafeSet<FieldDefUseStore> allDefs = new SafeSet<FieldDefUseStore>();
            allDefs.AddRange(this.DefDic.Keys);
            allDefs.AddRange(this.DefOrUseSet);

            SafeSet<FieldDefUseStore> allUses = new SafeSet<FieldDefUseStore>();
            allUses.AddRange(this.UseDic.Keys);
            allUses.AddRange(this.DefOrUseSet);
            int numInfeasible = 0;

            //Compute pair-wise combinations
            foreach (var defEntry in allDefs)
            {
                foreach (var useEntry in allUses)
                {
                    //Ignore the trivial entries that involve just a combination of setter and getter methods
                    if (defEntry.Method.ShortName.StartsWith("set_") && useEntry.Method.ShortName.StartsWith("get_"))
                        continue;
                    if (!this.IsFeasibleDUCoverEntry(dcs, defEntry, useEntry))
                    {
                        numInfeasible++;
                        continue;
                    }

                    DUCoverStoreEntry dcse = new DUCoverStoreEntry(this.fd, defEntry.Method, defEntry.Offset,
                        useEntry.Method, useEntry.Offset);

                    if (defEntry.UnknownSideEffectMethod != null)
                    {
                        dcse.Def_UnknownSideEffectMethod = defEntry.UnknownSideEffectMethod;
                        dcse.DefUnsure = true;
                    }

                    if (useEntry.UnknownSideEffectMethod != null)
                    {
                        dcse.Use_UnknownSideEffectMethod = useEntry.UnknownSideEffectMethod;
                        dcse.UseUnsure = true;
                    }

                    if(!this.duCoverageTable.ContainsKey(dcse))
                        this.duCoverageTable[dcse] = 0;
                }
            }

            //Clear all the cached entries.
            this.feasibilityDicCache.Clear();

            logger.Debug("Detected infeasible du-pairs for field " + this.fd.FullName + "(" + numInfeasible + ")");
        }