Esempio n. 1
0
        ///<summary>
        /// Determines the signature of the procedures,
        /// the locations and types of all the values in the program.
        ///</summary>
        public virtual void AnalyzeDataFlow()
        {
            if (project is null)
            {
                return;
            }
            var eventListener = services.RequireService <DecompilerEventListener>();

            foreach (var program in project.Programs)
            {
                if (eventListener.IsCanceled())
                {
                    return;
                }
                var ir  = new DynamicLinker(project, program, eventListener);
                var dfa = new DataFlowAnalysis(program, ir, services);
                dfa.ClearTestFiles();
                if (program.NeedsSsaTransform)
                {
                    eventListener.ShowStatus("Performing interprocedural analysis.");
                    dfa.UntangleProcedures();
                }
                eventListener.ShowStatus("Building complex expressions.");
                dfa.BuildExpressionTrees();
                host.WriteIntermediateCode(program, (name, procs, writer) => { EmitProgram(program, procs, dfa, name, writer); });
            }
            eventListener.ShowStatus("Interprocedural analysis complete.");
        }
Esempio n. 2
0
        public void DynLink_ProcedureByName_NoModule()
        {
            var proj = new Project
            {
                MetadataFiles =
                {
                    new MetadataFile
                    {
                        ModuleName = "foo"
                    }
                },
                Programs =
                {
                    program
                }
            };

            var barSig = new FunctionType(
                new Identifier(
                    "res",
                    PrimitiveType.Word16,
                    new RegisterStorage("ax", 0, 0, PrimitiveType.Word16)
                    ),
                new[] {
                new Identifier(
                    "a",
                    PrimitiveType.Word16,
                    new RegisterStorage("cx", 0, 0, PrimitiveType.Word16)
                    ),
                new Identifier(
                    "b",
                    PrimitiveType.Word16,
                    new RegisterStorage("dx", 0, 0, PrimitiveType.Word16)
                    )
            }
                );

            program.EnvironmentMetadata.Modules.Add("foo", new ModuleDescriptor("foo")
            {
                ServicesByName =
                {
                    { "bar", new SystemService {
                          Name      = "bar",
                          Signature = barSig
                      } }
                }
            });

            var impres = new DynamicLinker(proj, program, new FakeDecompilerEventListener());
            var ep     = impres.ResolveProcedure("foo", "bar", platform.Object);

            Assert.AreEqual("bar", ep.Name);

            var sigExp =
                @"Register word16 bar(Register word16 a, Register word16 b)
// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1
";

            Assert.AreEqual(sigExp, ep.Signature.ToString("bar", FunctionType.EmitFlags.AllDetails));
        }
 public void Constructor_SetsProperties()
 {
     var linker = new DynamicLinker(true);
     Assert.IsTrue(linker.IsBase1);
     linker = new DynamicLinker(false);
     Assert.IsFalse(linker.IsBase1);
 }
Esempio n. 4
0
        protected void RunHexTest(string hexFile, string outputFile)
        {
            var svc           = new ServiceContainer();
            var cfg           = new FakeDecompilerConfiguration();
            var eventListener = new FakeDecompilerEventListener();

            svc.AddService <IConfigurationService>(cfg);
            svc.AddService <DecompilerEventListener>(eventListener);
            svc.AddService <IDecompiledFileService>(new FakeDecompiledFileService());
            ILoader ldr       = new Loader(svc);
            var     imgLoader = new DchexLoader(FileUnitTester.MapTestPath(hexFile), svc, null);
            var     program   = imgLoader.Load(null);
            var     project   = new Project {
                Programs = { program }
            };
            var ep            = ImageSymbol.Procedure(program.Architecture, program.ImageMap.BaseAddress);
            var dynamicLinker = new DynamicLinker(project, program, eventListener);
            var scan          = new Scanner(program, dynamicLinker, svc);

            scan.EnqueueImageSymbol(ep, true);
            scan.ScanImage();

            var dfa = new DataFlowAnalysis(program, null, svc);

            dfa.AnalyzeProgram();
            RunTest(program, outputFile);
        }
Esempio n. 5
0
        public void DynLink_MangledProcedureCharacteristics()
        {
            var chr = new ProcedureCharacteristics
            {
                VarargsParserClass = "FakeParser",
            };

            program.EnvironmentMetadata.Characteristics.Add("foo@mangled", chr);
            platform.Setup(p => p.SignatureFromName(
                               It.Is <string>(n => n == "foo@mangled")))
            .Returns(new Procedure_v1
            {
                Name      = "foo",
                Signature = new SerializedSignature(),
            });

            var eventListener = new FakeDecompilerEventListener();
            var proj          = new Project();
            var impres        = new DynamicLinker(proj, program, eventListener);
            var ep            = impres.ResolveProcedure("", "foo@mangled", platform.Object);

            var expected = @"
void foo()
VarargsParserClass: FakeParser";

            AssertExternalProcedure(expected, ep);
        }
Esempio n. 6
0
        public void Constructor_SetsProperties()
        {
            var linker = new DynamicLinker(true);

            Assert.IsTrue(linker.IsBase1);
            linker = new DynamicLinker(false);
            Assert.IsFalse(linker.IsBase1);
        }
Esempio n. 7
0
        /// <summary>
        /// Creates a dynamic <see cref="T:PageLinker"/> using the specified parameters.
        /// </summary>
        /// <param name="isBase1"><c>true</c> to use base-1 page numbers. Otherwise, <c>false</c>.</param>
        /// <param name="prevText">The text to be displayed for the previous page.</param>
        /// <param name="nextText">The text to be displayed for the next page.</param>
        /// <param name="forcePrevNext"><c>true</c> to always add previous- and next-page links. Otherwise, <c>false</c>.</param>
        /// <returns>A dynamic <see cref="T:PageLinker"/> that will link pages using the specified parameters.</returns>
        public static PageLinker CreateDynamic(bool isBase1, string prevText, string nextText, bool forcePrevNext)
        {
            var baseLinker = new DynamicLinker(isBase1);

            if (string.IsNullOrEmpty(prevText) && string.IsNullOrEmpty(nextText))
            {
                return(baseLinker);
            }
            return(new PrevNextLinker(baseLinker, prevText, nextText, forcePrevNext));
        }
Esempio n. 8
0
        private string TryGetImportName(OrdinalImportReference ord)
        {
            var    dec        = services.RequireService <IDecompilerService>();
            var    project    = dec.Decompiler.Project;
            var    dynLinker  = new DynamicLinker(project, program, new NullDecompilerEventListener());
            var    e          = dynLinker.ResolveService(ord.ModuleName, ord.Ordinal);
            string importName = e?.Name;

            return(importName);
        }
        public void LinkPages_ReturnsLinkedPages()
        {
            var linker = new DynamicLinker(true);

            var request = new Mock<IPageRequestModel>();
            var results = new Mock<IPageResultsModel>();

            request.Setup(r => r.RequestedPage).Returns(1);
            results.Setup(r => r.TotalPageCount).Returns(56);

            var linked = linker.LinkPages(request.Object, results.Object);
            Assert.IsNotNull(linked);

            var p0 = linked.ElementAt(0);
            Assert.AreEqual(0, p0.LinkPage);
            Assert.AreEqual("1", p0.LinkText);
            Assert.AreEqual(p0.LinkPage, p0.LowerPage);
            Assert.AreEqual(p0.LinkPage, p0.UpperPage);
            Assert.IsFalse(p0.IsPageRange);
            Assert.AreSame(request.Object, p0.Request);

            var p1 = linked.ElementAt(1);
            Assert.AreEqual(1, p1.LinkPage);
            Assert.AreEqual("2", p1.LinkText);
            Assert.AreEqual(p1.LinkPage, p1.LowerPage);
            Assert.AreEqual(p1.LinkPage, p1.UpperPage);
            Assert.IsFalse(p1.IsPageRange);
            Assert.AreSame(request.Object, p1.Request);

            var p2 = linked.ElementAt(2);
            Assert.AreEqual(2, p2.LinkPage);
            Assert.AreEqual("3", p2.LinkText);
            Assert.AreEqual(p2.LinkPage, p2.LowerPage);
            Assert.AreEqual(p2.LinkPage, p2.UpperPage);
            Assert.IsFalse(p2.IsPageRange);
            Assert.AreSame(request.Object, p2.Request);

            var p3 = linked.ElementAt(3);
            Assert.AreEqual(3, p3.LinkPage);
            Assert.AreEqual("...", p3.LinkText);
            Assert.AreEqual(3, p3.LowerPage);
            Assert.AreEqual(54, p3.UpperPage);
            Assert.IsTrue(p3.IsPageRange);
            Assert.AreSame(request.Object, p3.Request);

            var p4 = linked.ElementAt(4);
            Assert.AreEqual(55, p4.LinkPage);
            Assert.AreEqual("56", p4.LinkText);
            Assert.AreEqual(p4.LinkPage, p4.LowerPage);
            Assert.AreEqual(p4.LinkPage, p4.UpperPage);
            Assert.IsFalse(p4.IsPageRange);
            Assert.AreSame(request.Object, p4.Request);

            Assert.IsNull(linked.ElementAtOrDefault(5));
        }
Esempio n. 10
0
        DisableEventsImp()
        {
            Utils.AcadUi.PrintToCmdLine("\nDynamic Linker Events Turned Off ...\n");

            DynamicLinker dLinker = SystemObjects.DynamicLinker;

            dLinker.ModuleLoadAborted   -= new ModuleLoadAbortedEventHandler(event_ModuleLoadAborted);
            dLinker.ModuleLoaded        -= new ModuleLoadedEventHandler(event_ModuleLoaded);
            dLinker.ModuleLoading       -= new ModuleLoadingEventHandler(event_ModuleLoading);
            dLinker.ModuleUnloadAborted -= new ModuleUnloadAbortedEventHandler(event_ModuleUnloadAborted);
            dLinker.ModuleUnloaded      -= new ModuleUnloadedEventHandler(event_ModuleUnloaded);
            dLinker.ModuleUnloading     -= new ModuleUnloadingEventHandler(event_ModuleUnloading);
        }
Esempio n. 11
0
        public void DynLink_GlobalByName()
        {
            var proj = new Project
            {
                MetadataFiles =
                {
                    new MetadataFile
                    {
                        ModuleName = "foo"
                    }
                },
                Programs =
                {
                    program
                }
            };

            var module = new ModuleDescriptor("foo")
            {
                GlobalsByName =
                {
                    {
                        "bar",
                        ImageSymbol.DataObject(
                            program.Architecture,
                            null,
                            "bar",
                            new StructureType
                        {
                            Fields =
                            {
                                { 0, new Pointer(PrimitiveType.Char, 32), "name" },
                                { 4, PrimitiveType.Int32,            "age" }
                            }
                        })
                    }
                }
            };

            program.EnvironmentMetadata.Modules.Add(module.ModuleName, module);

            var impres = new DynamicLinker(proj, program, new FakeDecompilerEventListener());
            var dt     = impres.ResolveImport("foo", "bar", platform.Object);

            Assert.AreEqual("&bar", dt.ToString());
        }
Esempio n. 12
0
        public void DynLink_LP32_weirdness()
        {
            var memText = new ByteMemoryArea(Address.Ptr64(0x00123400), new byte[100]);
            var memGot  = new ByteMemoryArea(Address.Ptr64(0x00200000), new byte[100]);
            var wr      = new LeImageWriter(memGot.Bytes);

            wr.WriteLeUInt32(0x00300000);
            wr.WriteLeUInt32(0x00300004);
            var arch = new FakeArchitecture64(new ServiceContainer());
            //var arch = new Mock<IProcessorArchitecture>();
            //arch.Setup(a => a.Endianness).Returns(EndianServices.Little);
            //arch.Setup(a => a.Name).Returns("fakeArch");
            //arch.Setup(a => a.PointerType).Returns(PrimitiveType.Ptr64);
            //arch.Setup(a => a.MakeAddressFromConstant(
            //    It.IsAny<Constant>(),
            //    It.IsAny<bool>())).Returns((Constant c, bool b) =>
            //        Address.Ptr64(c.ToUInt32()));
            var project = new Project();
            var sc      = new ServiceContainer();
            var program = new Program
            {
                Architecture = arch,
                Platform     = new DefaultPlatform(sc, arch),
                SegmentMap   = new SegmentMap(memGot.BaseAddress,
                                              new ImageSegment(".text", memText, AccessMode.ReadExecute),
                                              new ImageSegment(".got", memGot, AccessMode.Read)),
            };

            program.ImportReferences.Add(
                Address.Ptr32(0x00200000),
                new NamedImportReference(
                    Address.Ptr32(0x00200000), null, "my_global_var", SymbolType.Data));

            var dynlink = new DynamicLinker(project, program, new FakeDecompilerEventListener());

            var m     = new ExpressionEmitter();
            var addr  = Address.Ptr64(0x00123000);
            var proc  = program.EnsureProcedure(program.Architecture, addr, "foo_proc");
            var block = new Block(proc, addr, "foo");
            var stm   = new Statement(0x00123400, new Store(m.Word64(0x00123400), Constant.Real32(1.0F)), block);

            var result = dynlink.ResolveToImportedValue(stm, Constant.Word32(0x00200000));

            Assert.AreEqual("0x300000<64>", result.ToString());     //$LIT: pointer? p64?
        }
Esempio n. 13
0
        public void DynLink_VtblFromMsMangledName()
        {
            var proj   = new Project();
            var impres = new DynamicLinker(proj, program, new FakeDecompilerEventListener());

            platform.Setup(p => p.ResolveImportByName(
                               It.IsAny <string>(),
                               It.IsAny <string>()))
            .Returns((Expression)null);
            SerializedType nullType = null;

            platform.Setup(p => p.DataTypeFromImportName("??_7Scope@@6B@")).
            Returns(Tuple.Create("`vftable'", nullType, nullType));

            var id = impres.ResolveImport("foo", "??_7Scope@@6B@", platform.Object);

            Assert.AreEqual("`vftable'", id.ToString());
            Assert.IsInstanceOf <UnknownType>(id.DataType);
        }
Esempio n. 14
0
        protected Program RewriteFile(
            string relativePath,
            Address addrBase,
            Func <IServiceProvider, IProcessorArchitecture, IPlatform> mkPlatform)
        {
            sc = new ServiceContainer();
            var config        = new FakeDecompilerConfiguration();
            var eventListener = new FakeDecompilerEventListener();

            sc.AddService <IConfigurationService>(config);
            sc.AddService <IDecompiledFileService>(new FakeDecompiledFileService());
            sc.AddService <DecompilerEventListener>(eventListener);
            sc.AddService <IFileSystemService>(new FileSystemServiceImpl());
            var     arch    = new X86ArchitectureReal(sc, "x86-real-16");
            ILoader ldr     = new Loader(sc);
            var     program = ldr.AssembleExecutable(
                FileUnitTester.MapTestPath(relativePath),
                new X86TextAssembler(arch),
                null,
                addrBase);

            program.Platform = mkPlatform(sc, program.Architecture);

            var ep      = ImageSymbol.Procedure(arch, program.SegmentMap.BaseAddress);
            var project = new Project {
                Programs = { program }
            };
            var scan = new Scanner(
                program,
                new DynamicLinker(project, program, eventListener),
                sc);

            scan.EnqueueImageSymbol(ep, true);
            scan.ScanImage();

            var dynamicLinker = new DynamicLinker(project, program, eventListener);
            var dfa           = new DataFlowAnalysis(program, dynamicLinker, eventListener);

            dfa.AnalyzeProgram();
            return(program);
        }
Esempio n. 15
0
        public void DynLink_ProcedureByOrdinal()
        {
            var proj = new Project
            {
                MetadataFiles =
                {
                    new MetadataFile
                    {
                        ModuleName = "foo"
                    }
                },
                Programs =
                {
                    program
                }
            };

            var module = new ModuleDescriptor("foo")
            {
                ServicesByOrdinal =
                {
                    {
                        9,
                        new SystemService
                        {
                            Name      = "bar",
                            Signature = new FunctionType()
                        }
                    }
                }
            };

            program.EnvironmentMetadata.Modules.Add(module.ModuleName, module);

            var impres = new DynamicLinker(proj, program, new FakeDecompilerEventListener());
            var ep     = impres.ResolveProcedure("foo", 9, platform.Object);

            Assert.AreEqual("bar", ep.Name);
        }
Esempio n. 16
0
        protected Program RewriteFile(
            string relativePath,
            Address addrBase,
            Func <IServiceProvider, IProcessorArchitecture, IPlatform> mkPlatform)
        {
            var sc = new ServiceContainer();

            PopulateServiceContainer(sc);
            var     arch    = new X86ArchitectureReal(sc, "x86-real-16", new Dictionary <string, object>());
            ILoader ldr     = new Loader(sc);
            var     program = ldr.AssembleExecutable(
                ImageLocation.FromUri(FileUnitTester.MapTestPath(relativePath)),
                new X86TextAssembler(arch),
                null,
                addrBase);

            program.Platform = mkPlatform(sc, program.Architecture);

            var ep      = ImageSymbol.Procedure(arch, program.SegmentMap.BaseAddress);
            var project = new Project {
                Programs = { program }
            };
            var scan = new Scanner(
                program,
                project.LoadedMetadata,
                new DynamicLinker(project, program, eventListener),
                sc);

            scan.EnqueueImageSymbol(ep, true);
            scan.ScanImage();

            var dynamicLinker = new DynamicLinker(project, program, eventListener);
            var dfa           = new DataFlowAnalysis(program, dynamicLinker, sc);

            dfa.AnalyzeProgram();
            return(program);
        }
Esempio n. 17
0
        public void LinkPages_ReturnsLinkedPages()
        {
            var linker = new DynamicLinker(true);

            var request = new Mock <IPageRequestModel>();
            var results = new Mock <IPageResultsModel>();

            request.Setup(r => r.RequestedPage).Returns(1);
            results.Setup(r => r.TotalPageCount).Returns(56);

            var linked = linker.LinkPages(request.Object, results.Object);

            Assert.IsNotNull(linked);

            var p0 = linked.ElementAt(0);

            Assert.AreEqual(0, p0.LinkPage);
            Assert.AreEqual("1", p0.LinkText);
            Assert.AreEqual(p0.LinkPage, p0.LowerPage);
            Assert.AreEqual(p0.LinkPage, p0.UpperPage);
            Assert.IsFalse(p0.IsPageRange);
            Assert.AreSame(request.Object, p0.Request);

            var p1 = linked.ElementAt(1);

            Assert.AreEqual(1, p1.LinkPage);
            Assert.AreEqual("2", p1.LinkText);
            Assert.AreEqual(p1.LinkPage, p1.LowerPage);
            Assert.AreEqual(p1.LinkPage, p1.UpperPage);
            Assert.IsFalse(p1.IsPageRange);
            Assert.AreSame(request.Object, p1.Request);

            var p2 = linked.ElementAt(2);

            Assert.AreEqual(2, p2.LinkPage);
            Assert.AreEqual("3", p2.LinkText);
            Assert.AreEqual(p2.LinkPage, p2.LowerPage);
            Assert.AreEqual(p2.LinkPage, p2.UpperPage);
            Assert.IsFalse(p2.IsPageRange);
            Assert.AreSame(request.Object, p2.Request);

            var p3 = linked.ElementAt(3);

            Assert.AreEqual(3, p3.LinkPage);
            Assert.AreEqual("...", p3.LinkText);
            Assert.AreEqual(3, p3.LowerPage);
            Assert.AreEqual(54, p3.UpperPage);
            Assert.IsTrue(p3.IsPageRange);
            Assert.AreSame(request.Object, p3.Request);

            var p4 = linked.ElementAt(4);

            Assert.AreEqual(55, p4.LinkPage);
            Assert.AreEqual("56", p4.LinkText);
            Assert.AreEqual(p4.LinkPage, p4.LowerPage);
            Assert.AreEqual(p4.LinkPage, p4.UpperPage);
            Assert.IsFalse(p4.IsPageRange);
            Assert.AreSame(request.Object, p4.Request);

            Assert.IsNull(linked.ElementAtOrDefault(5));
        }
Esempio n. 18
0
        void IExtensionApplication.Initialize()
        {
            // Add one time initialization here
            // One common scenario is to setup a callback function here that
            // unmanaged code can call.
            // To do this:
            // 1. Export a function from unmanaged code that takes a function
            //    pointer and stores the passed in value in a global variable.
            // 2. Call this exported function in this function passing delegate.
            // 3. When unmanaged code needs the services of this managed module
            //    you simply call acrxLoadApp() and by the time acrxLoadApp
            //    returns  global function pointer is initialized to point to
            //    the C# delegate.
            // For more info see:
            // http://msdn2.microsoft.com/en-US/library/5zwkzwf4(VS.80).aspx
            // http://msdn2.microsoft.com/en-us/library/44ey4b32(VS.80).aspx
            // http://msdn2.microsoft.com/en-US/library/7esfatk4.aspx
            // as well as some of the existing AutoCAD managed apps.

            // Initialize your plug-in application here
            // Opening the registry key
            Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
            //ed.WriteMessage("\n1");
            RegistryKey rk = Registry.CurrentUser;
            // Open a subKey as read-only
            //Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
            //ed.WriteMessage("\naaaaaaaaaaaaaaaaaaaaa");
            String key = "SOFTWARE\\Autodesk\\AutoCAD\\R24.0\\ACAD-4101:409\\Applications\\CADSees";

            key = key.ToUpper();
            RegistryKey sk1   = rk.OpenSubKey(key);
            string      path  = (string)sk1.GetValue("LOADER");
            int         index = path.LastIndexOf("\\");

            path = path.Remove(index);
            string isFrst = (string)sk1.GetValue("ISFIRSTLOAD");

            //ed.WriteMessage("\n2");
            if (isFrst.Equals("TRUE"))
            {
                String cuiPath     = (string)sk1.GetValue("TOOLFOLDER") + "\\CADSeesToolbar.cuix";
                string mainCuiFile = (string)Application.GetSystemVariable("MENUNAME");
                //Application.GetSystemVariable(

                //ed.WriteMessage("\n3");

                mainCuiFile += ".cuix";
                CustomizationSection cs = new CustomizationSection(mainCuiFile);
                int res2 = cs.PartialCuiFiles.Add(cuiPath);
                //ed.WriteMessage("\n4");
                CustomizationSection myCui = new CustomizationSection(cuiPath);
                //cs.MenuGroup.PopMenus.Add(myCui.MenuGroup.PopMenus[0]);
                //ed.WriteMessage("\n5");
                cs.Save();
                Application.ReloadAllMenus();
                sk1 = rk.CreateSubKey(key);
                sk1.SetValue("ISFIRSTLOAD", "FALSE");
                //string trustedPath = (string)Application.GetSystemVariable("TRUSTEDPATHS");

                //Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
                //ed.WriteMessage("\n quitting\n");
                //Application.Quit();
            }
            //ed.WriteMessage("\n3");
            String        arxPath = path + "\\CADSees.arx";
            String        dbxPath = path + "\\CSSObjects.dbx";
            DynamicLinker DL      = SystemObjects.DynamicLinker;

            DL.LoadModule(dbxPath, false, false);
            //ed.WriteMessage("\n4");
            //ed.WriteMessage("\n5");
            DL.LoadModule(arxPath, false, false);
            //ed.WriteMessage("\n6");
            Welcome form = new Welcome();

            form.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
            form.ShowDialog();
            //System.Threading.Thread.Sleep(1500);
            //form.Dispose();
            //ed.WriteMessage("\naaaaaaaaaaaaaaa");
        }
Esempio n. 19
0
 public DynLinkerEvents()
 {
     m_bDone = false;
     m_dl = SystemObjects.DynamicLinker;
     Do();
 }