Пример #1
0
    internal static void Reachable(
      IMetadataHost host,
      ISlice<MethodReferenceAdaptor, FieldReferenceAdaptor, TypeReferenceAdaptor, IAssemblyReference> slice,
      HashSet<object> thingsToKeep,
      HashSet<uint> methodsWhoseBodiesShouldBeKept,
      out Dictionary<IMethodDefinition, uint> contractOffsets
      ) {

      Contract.Requires(host != null);
      Contract.Requires(slice != null);
      Contract.Requires(thingsToKeep != null);
      Contract.Requires(methodsWhoseBodiesShouldBeKept != null);

      var traverser = new MetadataTraverser();
      var me = new FindReachable(host, traverser, slice, thingsToKeep, methodsWhoseBodiesShouldBeKept);
      traverser.TraverseIntoMethodBodies = true;
      traverser.PreorderVisitor = me;

      var methodsToTraverse = slice.Methods;
      foreach (var m in methodsToTraverse) {
        var methodDefinition = m.reference.ResolvedMethod;
        traverser.Traverse(methodDefinition);
      }

      foreach (var c in slice.Chains) {
        VisitChain(c, traverser);
      }
      contractOffsets = me.contractOffsets;
      return;
    }
Пример #2
0
        internal static void Reachable(
            IMetadataHost host,
            ISlice <MethodReferenceAdaptor, FieldReferenceAdaptor, TypeReferenceAdaptor, IAssemblyReference> slice,
            HashSet <object> thingsToKeep,
            HashSet <uint> methodsWhoseBodiesShouldBeKept,
            out Dictionary <IMethodDefinition, uint> contractOffsets
            )
        {
            Contract.Requires(host != null);
            Contract.Requires(slice != null);
            Contract.Requires(thingsToKeep != null);
            Contract.Requires(methodsWhoseBodiesShouldBeKept != null);

            var traverser = new MetadataTraverser();
            var me        = new FindReachable(host, traverser, slice, thingsToKeep, methodsWhoseBodiesShouldBeKept);

            traverser.TraverseIntoMethodBodies = true;
            traverser.PreorderVisitor          = me;

            var methodsToTraverse = slice.Methods;

            foreach (var m in methodsToTraverse)
            {
                var methodDefinition = m.reference.ResolvedMethod;
                traverser.Traverse(methodDefinition);
            }

            foreach (var c in slice.Chains)
            {
                VisitChain(c, traverser);
            }
            contractOffsets = me.contractOffsets;
            return;
        }
Пример #3
0
 public DynamicLoader(ISourceLocationProvider/*?*/ sourceLocationProvider, ILocalScopeProvider/*?*/ localScopeProvider)
 {
     this.sourceLocationProvider = sourceLocationProvider;
       this.localScopeProvider = localScopeProvider;
       this.emitter = new Emitter(this, sourceLocationProvider, localScopeProvider);
       this.initializingTraverser = new MetadataTraverser() { PostorderVisitor = this.emitter, TraverseIntoMethodBodies = true };
       this.typeBuilderAllocator = new TypeBuilderAllocater(this);
       this.typeCreator = new TypeCreator(this);
       this.memberBuilderAllocator = new MemberBuilderAllocator(this);
       this.mapper = new ReflectionMapper();
       this.builderMap = new Dictionary<object, object>();
 }
Пример #4
0
        static void Main(string[] args)
        {
            if (args == null || args.Length == 0)
            {
                Console.WriteLine("usage: CDFG [path]fileName.ext");
                return;
            }

            using (var host = new DefaultWindowsRuntimeHost())
            {
                //Read the Metadata Model from the PE file
                var module = host.LoadUnitFrom(args[0]) as IModule;
                if (module == null || module is Dummy)
                {
                    Console.WriteLine(args[0] + " is not a PE file containing a CLR module or assembly.");
                    return;
                }

                //Get a PDB reader if there is a PDB file.
                PdbReader /*?*/ pdbReader = null;
                string          pdbFile   = module.DebugInformationLocation;
                if (string.IsNullOrEmpty(pdbFile) || !File.Exists(pdbFile))
                {
                    pdbFile = Path.ChangeExtension(module.Location, "pdb");
                }
                if (File.Exists(pdbFile))
                {
                    using (var pdbStream = File.OpenRead(pdbFile))
                    {
                        pdbReader = new PdbReader(pdbStream, host);
                    }
                }
                using (pdbReader)
                {
                    ISourceLocationProvider sourceLocationProvider = pdbReader;
                    ILocalScopeProvider     localScopeProvider     = pdbReader;

                    var cdfgVisitor = new LoopFinderVisitor(host, pdbReader);
                    var traverser   = new MetadataTraverser();
                    traverser.TraverseIntoMethodBodies = true;
                    traverser.PreorderVisitor          = cdfgVisitor;
                    traverser.Traverse(module);
                }
            }
        }
        public override IEnumerable <ISourceMappedItem> GetSourceInfo(string assemblyPath, string pdbPath, ReportingResult report)
        {
            using (var host = new HostEnvironment())
                using (var pdbFs = File.OpenRead(pdbPath))
                    using (var pdbReader = new PdbReader(pdbFs, host))
                    {
                        var metadataVisitor = new CciMetadataTraverser(report, pdbReader);
                        var traverser       = new MetadataTraverser
                        {
                            PreorderVisitor          = metadataVisitor,
                            TraverseIntoMethodBodies = true
                        };

                        var cciAssembly = host.LoadAssembly(assemblyPath);
                        traverser.Traverse(cciAssembly);

                        return(metadataVisitor.FoundItems);
                    }
        }
Пример #6
0
    private FindReachable(
      IMetadataHost host,
      MetadataTraverser myTraverser, ISlice<MethodReferenceAdaptor, FieldReferenceAdaptor, TypeReferenceAdaptor, IAssemblyReference> slice,
      HashSet<object> thingsToKeep,
      HashSet<uint> methodsWhoseBodiesShouldBeKept
      ) {
      Contract.Requires(host != null);
      Contract.Requires(myTraverser != null);
      Contract.Requires(slice != null);
      Contract.Requires(thingsToKeep != null);
      Contract.Requires(methodsWhoseBodiesShouldBeKept != null);

      this.host = host;
      this.traverser = myTraverser;
      this.unitIdentity = slice.ContainingAssembly.UnitIdentity;
      this.slice = slice;
      this.thingsToKeep = thingsToKeep;
      this.methodsWhoseBodiesShouldBeKept = methodsWhoseBodiesShouldBeKept;
      this.contractOffsets = new Dictionary<IMethodDefinition, uint>();

    }
Пример #7
0
        private FindReachable(
            IMetadataHost host,
            MetadataTraverser myTraverser, ISlice <MethodReferenceAdaptor, FieldReferenceAdaptor, TypeReferenceAdaptor, IAssemblyReference> slice,
            HashSet <object> thingsToKeep,
            HashSet <uint> methodsWhoseBodiesShouldBeKept
            )
        {
            Contract.Requires(host != null);
            Contract.Requires(myTraverser != null);
            Contract.Requires(slice != null);
            Contract.Requires(thingsToKeep != null);
            Contract.Requires(methodsWhoseBodiesShouldBeKept != null);

            this.host         = host;
            this.traverser    = myTraverser;
            this.unitIdentity = slice.ContainingAssembly.UnitIdentity;
            this.slice        = slice;
            this.thingsToKeep = thingsToKeep;
            this.methodsWhoseBodiesShouldBeKept = methodsWhoseBodiesShouldBeKept;
            this.contractOffsets = new Dictionary <IMethodDefinition, uint>();
        }
Пример #8
0
        static void Main(string[] args)
        {
            if (args == null || args.Length == 0)
            {
                Console.WriteLine("usage: PeToPe [path]fileName.ext");
                return;
            }

            using (var host = new PeReader.DefaultHost()) {
                var module = host.LoadUnitFrom(args[0]) as IModule;
                if (module == null || module is Dummy)
                {
                    Console.WriteLine(args[0] + " is not a PE file containing a CLR module or assembly.");
                    return;
                }

                PdbReader /*?*/ pdbReader = null;
                string          pdbFile   = module.DebugInformationLocation;
                if (string.IsNullOrEmpty(pdbFile))
                {
                    pdbFile = Path.ChangeExtension(module.Location, "pdb");
                }
                if (File.Exists(pdbFile))
                {
                    Stream pdbStream = File.OpenRead(pdbFile);
                    pdbReader = new PdbReader(pdbStream, host);
                }

                using (pdbReader) {
                    //Make a mutable copy of the module.
                    var copier        = new MetadataDeepCopier(host);
                    var mutableModule = copier.Copy(module);

                    //Traverse the module. In a real application the MetadataVisitor and/or the MetadataTravers will be subclasses
                    //and the traversal will gather information to use during rewriting.
                    var traverser = new MetadataTraverser()
                    {
                        PreorderVisitor = new MetadataVisitor(), TraverseIntoMethodBodies = true
                    };
                    traverser.Traverse(mutableModule);

                    //Rewrite the mutable copy. In a real application the rewriter would be a subclass of MetadataRewriter that actually does something.
                    var rewriter        = new MetadataRewriter(host);
                    var rewrittenModule = rewriter.Rewrite(mutableModule);

                    //Write out rewritten module.
                    using (var peStream = File.Create(rewrittenModule.Location + ".pe")) {
                        if (pdbReader == null)
                        {
                            PeWriter.WritePeToStream(rewrittenModule, host, peStream);
                        }
                        else
                        {
                            //Note that the default copier and rewriter preserves the locations collections, so the original pdbReader is still a valid ISourceLocationProvider.
                            //However, if IL instructions were rewritten, the pdbReader will no longer be an accurate ILocalScopeProvider
                            using (var pdbWriter = new PdbWriter(pdbFile + ".pdb", pdbReader)) {
                                PeWriter.WritePeToStream(rewrittenModule, host, peStream, pdbReader, pdbReader, pdbWriter);
                            }
                        }
                    }
                }
            }
        }
Пример #9
0
 private static void VisitChain(IChain<MethodReferenceAdaptor, FieldReferenceAdaptor, TypeReferenceAdaptor> c, MetadataTraverser mt) {
   Contract.Requires(c != null);
   Contract.Requires(mt != null);
   switch (c.Tag) {
     case ChainTag.Type:
       {
         Contract.Assume(c.Children != null, "The code makes such an assumption");
         foreach (var child in c.Children)
           VisitChain(child, mt);
       }
       break;
     case ChainTag.Field:
       {
         Contract.Assume(c.Field.reference != null);
         mt.Traverse(c.Field.reference);
       }
       break;
     case ChainTag.Method:
       {
         Contract.Assume(c.Method.reference!= null);
         mt.Traverse(c.Method.reference);
       }
       break;
     default:
       Contract.Assert(false, "switch should be exhaustive");
       break;
   }
 }
Пример #10
0
        private static void VisitChain(IChain <MethodReferenceAdaptor, FieldReferenceAdaptor, TypeReferenceAdaptor> c, MetadataTraverser mt)
        {
            Contract.Requires(c != null);
            Contract.Requires(mt != null);
            switch (c.Tag)
            {
            case ChainTag.Type:
            {
                Contract.Assume(c.Children != null, "The code makes such an assumption");
                foreach (var child in c.Children)
                {
                    VisitChain(child, mt);
                }
            }
            break;

            case ChainTag.Field:
            {
                Contract.Assume(c.Field.reference != null);
                mt.Traverse(c.Field.reference);
            }
            break;

            case ChainTag.Method:
            {
                Contract.Assume(c.Method.reference != null);
                mt.Traverse(c.Method.reference);
            }
            break;

            default:
                Contract.Assert(false, "switch should be exhaustive");
                break;
            }
        }