예제 #1
0
파일: Program.cs 프로젝트: relaxar/reko
 public Program(SegmentMap segmentMap, IProcessorArchitecture arch, IPlatform platform) : this()
 {
     this.SegmentMap = segmentMap;
     this.ImageMap = segmentMap.CreateImageMap();
     this.Architecture = arch;
     this.Platform = platform;
 }
예제 #2
0
 public void Sm_Overlaps()
 {
     SegmentMap im = new SegmentMap(Address.SegPtr(0x8000, 0));
     var mem = new MemoryArea(im.BaseAddress, new byte[40]);
     var seg = new ImageSegment("8000", Address.SegPtr(0x8000, 10), mem, AccessMode.ReadWrite);
     im.AddSegment(seg);
 }
        public void Setup()
        {
            mr = new MockRepository();
            mockFactory = new MockFactory(mr);
            var platform = mockFactory.CreatePlatform();
            var imageMap = new SegmentMap(Address32.Ptr32(0x05));
            program = new Program(imageMap, platform.Architecture, platform);
            interactor = new CombinedCodeViewInteractor();
            var uiPreferencesSvc = mr.Stub<IUiPreferencesService>();
            var uiSvc = mr.Stub<IDecompilerShellUiService>();

            var styles = new Dictionary<string, UiStyle>()
            {
                {
                    UiStyles.CodeWindow,
                    new UiStyle
                    {
                        Background = new SolidBrush(Color.White),
                    }
                }
            };
            uiPreferencesSvc.Stub(u => u.Styles).Return(styles);
            var sc = new ServiceContainer();
            sc.AddService<IUiPreferencesService>(uiPreferencesSvc);
            sc.AddService<IDecompilerShellUiService>(uiSvc);
            interactor.SetSite(sc);
        }
예제 #4
0
		public void Setup()
		{
            mr = new MockRepository();
            form = new MainForm();
            sc = new ServiceContainer();
            loader = mr.StrictMock<ILoader>();
            dec = mr.StrictMock<IDecompiler>();
            sc = new ServiceContainer();
            uiSvc = new FakeShellUiService();
            host = mr.StrictMock<DecompilerHost>();
            memSvc = mr.StrictMock<ILowLevelViewService>();
            var mem = new MemoryArea(Address.Ptr32(0x10000), new byte[1000]);
            var imageMap = new SegmentMap(
                mem.BaseAddress,
                new ImageSegment("code", mem, AccessMode.ReadWriteExecute));
            var arch = mr.StrictMock<IProcessorArchitecture>();
            var platform = mr.StrictMock<IPlatform>();
            program = new Program(imageMap, arch, platform);
            project = new Project { Programs = { program } };

            browserSvc = mr.StrictMock<IProjectBrowserService>();

            sc.AddService<IDecompilerUIService>(uiSvc);
            sc.AddService(typeof(IDecompilerShellUiService), uiSvc);
            sc.AddService(typeof(IDecompilerService), new DecompilerService());
            sc.AddService(typeof(IWorkerDialogService), new FakeWorkerDialogService());
            sc.AddService(typeof(DecompilerEventListener), new FakeDecompilerEventListener());
            sc.AddService(typeof(IProjectBrowserService), browserSvc);
            sc.AddService(typeof(ILowLevelViewService), memSvc);
            sc.AddService<ILoader>(loader);
            sc.AddService<DecompilerHost>(host);

            i = new TestInitialPageInteractor(sc, dec);

		}
예제 #5
0
파일: X86Emulator.cs 프로젝트: relaxar/reko
 public X86Emulator(IntelArchitecture arch, SegmentMap segmentMap, IPlatformEmulator envEmulator)
 {
     this.arch = arch;
     this.map = segmentMap;
     this.Registers = new ulong[40];
     this.Valid = new bool[40];
     this.envEmulator = envEmulator;
 }
예제 #6
0
 public void Sm_AddSegment()
 {
     var map = new SegmentMap(addrBase);
     var mem = new MemoryArea(addrBase, new byte[0x4000]);
     var seg = new ImageSegment("8100", Address.SegPtr(0x8100, 0), mem, AccessMode.ReadWriteExecute);
     map.AddSegment(seg);
     Assert.AreEqual(0x3000, seg.Size);
 }
예제 #7
0
 public void Setup()
 {
     mr = new MockRepository();
     seg1 = new ImageSegment("seg1", new MemoryArea(Address.Ptr32(0x01000), new byte[0x1000]), AccessMode.Execute);
     seg2 = new ImageSegment("seg2", new MemoryArea(Address.Ptr32(0x02000), new byte[0x1000]), AccessMode.Execute);
     map = new SegmentMap(seg1.Address,
         seg1, seg2);
 }
예제 #8
0
 private ImageWriter Memory(uint address)
 {
     mem = new MemoryArea(Address.Ptr32(address), new byte[1024]);
     imageMap = new SegmentMap(
         mem.BaseAddress,
         new ImageSegment(".data", mem, AccessMode.ReadWrite));
     var writer = new LeImageWriter(mem.Bytes);
     return writer;
 }
예제 #9
0
 public override Program Load(Address addrLoad)
 {
     int iImageStart = (exe.e_cparHeader * 0x10);
     int cbImageSize = exe.e_cpImage * ExeImageLoader.CbPageSize - iImageStart;
     byte[] bytes = new byte[cbImageSize];
     int cbCopy = Math.Min(cbImageSize, RawImage.Length - iImageStart);
     Array.Copy(RawImage, iImageStart, bytes, 0, cbCopy);
     imgLoaded = new MemoryArea(addrLoad, bytes);
     segmentMap = new SegmentMap(addrLoad);
     return new Program(segmentMap, arch, platform);
 }
예제 #10
0
파일: Win32Emulator.cs 프로젝트: uxmal/reko
        public Win32Emulator(SegmentMap map, IPlatform platform, Dictionary<Address, ImportReference> importReferences)
        {
            this.map = map;
            this.platform = platform;
            this.uPseudoFn = 0xDEAD0000u;   // unlikely to be a real pointer to a function
            this.InterceptedCalls = new Dictionary<uint, ExternalProcedure>();

            modules = new Dictionary<string, Module>(StringComparer.InvariantCultureIgnoreCase);
            AddWellKnownProcedures();
            InterceptCallsToImports(importReferences);
        }
예제 #11
0
 private void btnLoad_Click(object sender, EventArgs e)
 {
     var mem = new MemoryArea(Address.Ptr32(0x12312300),new byte[0x1000]);
     var imageMap = new SegmentMap(
             mem.BaseAddress,
             new ImageSegment("code", mem, AccessMode.ReadWriteExecute));
     var arch = new X86ArchitectureFlat32();
     var program = new Core.Program(imageMap, arch, new DefaultPlatform(null, arch));
     var project = new Project { Programs = { program } };
     pbs.Load(project);
 }
예제 #12
0
 public void Setup()
 {
     mr = new MockRepository();
     sc = new ServiceContainer();
     var mem = new MemoryArea(Address.SegPtr(0xC00, 0), Enumerable.Range(0x0, 0x100).Select(b => (byte)b).ToArray());
     var imageMap = new SegmentMap(
             mem.BaseAddress,
             new ImageSegment(
                 "code", mem, AccessMode.ReadWriteExecute));
     var arch = new Mocks.FakeArchitecture();
     this.program = new Program(imageMap, arch, new DefaultPlatform(sc, arch));
 }
예제 #13
0
 private void AssertMap(string sExp, SegmentMap sm)
 {
     var strs = sm.Segments.Values
         .Select(ss => string.Format("{0} {1:X8} {2}{3}{4} {5}",
             ss.Address,
             ss.Size,
             (ss.Access & AccessMode.Read) != 0 ? "r" : "-",
             (ss.Access & AccessMode.Write) != 0 ? "w" : "-",
             (ss.Access & AccessMode.Execute) != 0 ? "x" : "-",
             ss.Name));
     string s = string.Join(Environment.NewLine, strs);
     if (s != sExp)
         Debug.Print(s);
     Assert.AreEqual(sExp, s);
 }
예제 #14
0
 private void Given_Image(uint addr, params byte[] bytes)
 {
     mem = new MemoryArea(Address.Ptr32(addr), bytes);
     imageMap = new SegmentMap(
         mem.BaseAddress,
         new ImageSegment(".text", mem, AccessMode.ReadExecute));
     host.Stub(h => h.SegmentMap).Return(imageMap);
     host.Stub(h => h.TE_GetMemoryInfo(
         Arg<ulong>.Is.Anything,
         out Arg<MEMORY_BASIC_INFORMATION>.Out(new MEMORY_BASIC_INFORMATION
         {
             BaseAddress = mem.BaseAddress.ToLinear(),
             RegionSize = (uint)mem.Length,
             AllocationBase = mem.BaseAddress.ToLinear()
         }).Dummy)).Return(true);
 }
예제 #15
0
        private void Given_Code(Action<X86Assembler> coder)
        {
            var asm = new X86Assembler(sc, new DefaultPlatform(sc, arch), Address.Ptr32(0x00100000), new List<ImageSymbol>());
            coder(asm);
            var program = asm.GetImage();
            this.segmentMap = program.SegmentMap;

            Given_Platform();

            var win32 = new Win32Emulator(program.SegmentMap, platform, importReferences);
            
            emu = new X86Emulator(arch, program.SegmentMap, win32);
            emu.InstructionPointer = program.ImageMap.BaseAddress;
            emu.WriteRegister(Registers.esp, (uint)program.ImageMap.BaseAddress.ToLinear() + 0x0FFC);
            emu.ExceptionRaised += delegate { throw new Exception(); };
        }
예제 #16
0
        public void Sm_Creation()
        {
            SegmentMap sm = new SegmentMap(addrBase,
                new ImageSegment("", new MemoryArea(addrBase, img), AccessMode.ReadWriteExecute));

            sm.AddSegment(Address.SegPtr(0x8000, 2), "", AccessMode.ReadWrite, 10);
            sm.AddSegment(Address.SegPtr(0x8000, 3), "", AccessMode.ReadWrite, 10);
            sm.AddSegment(Address.SegPtr(0x8000, 0), "", AccessMode.ReadWrite, 10);

            // Verify
            var sExp = 
@"8000:0000 00000002 rwx 
8000:0002 00000001 rw- 
8000:0003 0000001D rw- ";
            AssertMap(sExp, sm);
        }
예제 #17
0
 private void DisassemblyControlForm_Load(object sender, EventArgs e)
 {
     var random = new Random(0x4711);
     var mem =   new MemoryArea(Address.Ptr32(0x00100000),
         Enumerable.Range(0, 10000)
         .Select(i => (byte)random.Next(256)).ToArray());
     var seg = new ImageSegment(".text", mem, AccessMode.ReadExecute);
     var segmentMap = new SegmentMap(mem.BaseAddress, seg);
     disassemblyControl1.Model = new DisassemblyTextModel(
         new CoreProgram
         {
             //new Decompiler.Arch.X86.X86ArchitectureFlat32();
             Architecture = new Reko.Arch.PowerPC.PowerPcArchitecture32(),
             SegmentMap = segmentMap
         },
         seg);
     disassemblyControl1.StartAddress = mem.BaseAddress;
 }
예제 #18
0
파일: DmkLoader.cs 프로젝트: relaxar/reko
        public override Program Load(Address addrLoad)
        {
            if (!ParseDMKHeader())
                return null;

            var tracks = BuildTrackList(TrackLength);
            var bytes = tracks.SelectMany(t => t.Sectors)
                .SelectMany(s => s.GetData())
                .ToArray();
            var mem = new MemoryArea(addrLoad, bytes);
            var segmentMap = new SegmentMap(addrLoad,
                new ImageSegment("", mem, AccessMode.ReadWriteExecute));
            return new Program
            {
                Architecture = new Z80ProcessorArchitecture(),
                SegmentMap = segmentMap,
            };
        }
예제 #19
0
        public void Setup()
        {
            mr = new MockRepository();
            sc = new ServiceContainer();
            mem = new MemoryArea(Address.Ptr32(0x00400000), new byte[2000]);
            segmentMap = new SegmentMap(mem.BaseAddress);
            arch = mr.Stub<IProcessorArchitecture>();
            platform = mr.Stub<IPlatform>();
            searchSvc = mr.Stub<ISearchResultService>();

            sc.AddService<ISearchResultService>(searchSvc);

            program = new Program
            {
                Architecture = arch,
                Platform = platform,
                SegmentMap = segmentMap,
            };
        }
예제 #20
0
        private void chkShowData_CheckedChanged(object sender, EventArgs e)
        {
            if (chkShowData.Checked)
            {
                var mem = new MemoryArea(Address.Ptr32(0x00100000), new byte[2560]);
                var segMap = new SegmentMap(mem.BaseAddress,
                    new ImageSegment("", mem, AccessMode.ReadWriteExecute));
                var imgMap = segMap.CreateImageMap();
                imgMap.AddItemWithSize(Address.Ptr32(0x00100000), new ImageMapBlock { Size = 30 });
                imgMap.AddItemWithSize(Address.Ptr32(0x00100100), new ImageMapBlock { Size = 300 });
                imgMap.AddItemWithSize(Address.Ptr32(0x00100500), new ImageMapBlock { Size = 600 });
                memoryControl1.Architecture = new X86ArchitectureFlat32();

                imageMapView1.ImageMap = imgMap;
            }
            else
            {
                memoryControl1.Architecture = null;
            }
        }
예제 #21
0
        public override Program Load(Address addrLoad)
        {
            BinHexDecoder dec = new BinHexDecoder(new StringReader(Encoding.ASCII.GetString(RawImage)));
            IEnumerator<byte> stm = dec.GetBytes().GetEnumerator();
            BinHexHeader hdr = LoadBinHexHeader(stm);
            byte[] dataFork = LoadFork(hdr.DataForkLength, stm);
            byte[] rsrcFork = LoadFork(hdr.ResourceForkLength, stm);

            var arch = new M68kArchitecture();
            var platform = new MacOSClassic(Services, arch);
            if (hdr.FileType == "PACT")
            {
                Cpt.CompactProArchive archive = new Cpt.CompactProArchive();
                List<ArchiveDirectoryEntry> items = archive.Load(new MemoryStream(dataFork));
                IArchiveBrowserService abSvc = Services.GetService<IArchiveBrowserService>();
                if (abSvc != null)
                {
                    var selectedFile = abSvc.UserSelectFileFromArchive(items);
                    if (selectedFile != null)
                    {
                        var image = selectedFile.GetBytes();
                        this.rsrcFork = new ResourceFork(image, arch);
                        this.mem = new MemoryArea(addrLoad, image);
                        this.segmentMap = new SegmentMap(addrLoad,
                            new ImageSegment("", mem, AccessMode.ReadWriteExecute)); 
                        return new Program(this.segmentMap, arch, platform);
                    }
                }
            }

            this.mem = new MemoryArea(addrLoad, dataFork);
            return new Program(
                new SegmentMap(mem.BaseAddress,
                    new ImageSegment("", mem, AccessMode.ReadWriteExecute)),
                arch,
                platform);
        }
예제 #22
0
 public override abstract IEnumerable<Address> CreatePointerScanner(
     SegmentMap map, 
     ImageReader rdr,
     IEnumerable<Address> addrs, 
     PointerScannerFlags flags);
예제 #23
0
파일: Dumper.cs 프로젝트: claunia/reko
 public void DumpData(SegmentMap map, IProcessorArchitecture arch, AddressRange range, Formatter stm)
 {
     DumpData(map, arch, range.Begin, (long)(range.End - range.Begin), stm);
 }
예제 #24
0
파일: Dumper.cs 프로젝트: iTudou2016/reko
 public void DumpData(SegmentMap map, AddressRange range, Formatter stm)
 {
     DumpData(map, range.Begin, (long)(range.End - range.Begin), stm);
 }
예제 #25
0
 public override IEnumerable<Address> CreatePointerScanner(SegmentMap map, ImageReader rdr, IEnumerable<Address> knownAddresses, PointerScannerFlags flags)
 {
     var knownLinAddresses = knownAddresses.Select(a => (uint)a.ToLinear()).ToHashSet();
     return new MipsPointerScanner32(rdr, knownLinAddresses, flags).Select(l => Address.Ptr32(l));
 }
예제 #26
0
 public void Sm_AddNamedSegment()
 {
     var mem = new MemoryArea(Address.SegPtr(0x0B00, 0), new byte[0x2000]);
     SegmentMap segmentMap = new SegmentMap(mem.BaseAddress,
         new ImageSegment("base", mem, AccessMode.ReadWriteExecute));
     segmentMap.AddSegment(Address.SegPtr(0xC00, 0), "0C00", AccessMode.ReadWrite, 6000);
     ImageSegment s = segmentMap.Segments.Values.ElementAt(1);
     Assert.AreEqual("0C00", s.Name);
     Assert.AreEqual(0x1000, s.Size);
 }
예제 #27
0
파일: Dumper.cs 프로젝트: iTudou2016/reko
        public void DumpData(SegmentMap map, Address address, long cbBytes, Formatter stm)
        {
            const int BytesPerLine = 16;
            var       linAddr      = address.ToLinear();
            ulong     cSkip        = linAddr - BytesPerLine * (linAddr / BytesPerLine);

            if (!map.TryFindSegment(address, out var segment) || segment.MemoryArea == null)
            {
                return;
            }
            byte[] prevLine     = null;
            bool   showEllipsis = true;
            var    rdr          = arch.CreateImageReader(segment.MemoryArea, address);

            while (cbBytes > 0)
            {
                StringBuilder sb      = new StringBuilder(0x12);
                var           bytes   = new List <byte>();
                var           sbBytes = new StringBuilder();
                try
                {
                    sbBytes.AppendFormat("{0} ", rdr.Address);
                    for (int i = 0; i < BytesPerLine; ++i)
                    {
                        if (cbBytes > 0 && cSkip == 0)
                        {
                            byte b = rdr.ReadByte();
                            bytes.Add(b);
                            sbBytes.AppendFormat("{0:X2} ", b);
                            sb.Append(0x20 <= b && b < 0x7F
                                                                ? (char)b
                                                                : '.');
                            --cbBytes;
                        }
                        else
                        {
                            sbBytes.Append("   ");
                            if (cSkip > 0)
                            {
                                sb.Append(' ');
                            }
                            --cSkip;
                        }
                    }
                    var ab = bytes.ToArray();
                    if (!HaveSameZeroBytes(prevLine, ab))
                    {
                        stm.Write(sbBytes.ToString());
                        stm.WriteLine(sb.ToString());
                        showEllipsis = true;
                    }
                    else
                    {
                        if (showEllipsis)
                        {
                            stm.WriteLine("; ...");
                            showEllipsis = false;
                        }
                    }
                    prevLine = ab;
                }
                catch
                {
                    stm.WriteLine();
                    stm.WriteLine(";;; ...end of image");
                    return;
                }
            }
        }
예제 #28
0
 public abstract IEnumerable <Address> CreatePointerScanner(SegmentMap map, EndianImageReader rdr, IEnumerable <Address> knownAddresses, PointerScannerFlags flags);
예제 #29
0
파일: MachOLoader.cs 프로젝트: relaxar/reko
            void parseSection64(uint protection, SegmentMap segmentMap)
            {
                var abSectname = rdr.ReadBytes(16);
                var abSegname = rdr.ReadBytes(16);
                ulong addr;
                ulong size;
                uint offset;
                uint align;
                uint reloff;
                uint nreloc;
                uint flags;
                uint reserved1;
                uint reserved2;
                uint reserved3;

                if (!rdr.TryReadUInt64(out addr) ||
                    !rdr.TryReadUInt64(out size) ||
                    !rdr.TryReadUInt32(out offset) ||
                    !rdr.TryReadUInt32(out align) ||
                    !rdr.TryReadUInt32(out reloff) ||
                    !rdr.TryReadUInt32(out nreloc) ||
                    !rdr.TryReadUInt32(out flags) ||
                    !rdr.TryReadUInt32(out reserved1) ||
                    !rdr.TryReadUInt32(out reserved2) ||
                    !rdr.TryReadUInt32(out reserved3))
                {
                    throw new BadImageFormatException("Could not read Mach-O section.");
                }

                var sectionName = GetAsciizString(abSectname);
                var segmentName = GetAsciizString(abSegname);

                Debug.Print("Found section '{0}' in segment '{1}, addr = 0x{2:X}, size = 0x{3:X}.",
                        sectionName,
                        segmentName,
                        addr,
                        size);

                AccessMode am = 0;
                if ((protection & VM_PROT_READ) != 0)
                    am |= AccessMode.Read;
                if ((protection & VM_PROT_WRITE) != 0)
                    am |= AccessMode.Write;
                if ((protection & VM_PROT_EXECUTE) != 0)
                    am |= AccessMode.Execute;

                var bytes = rdr.CreateNew(this.ldr.RawImage, offset);
                var mem = new MemoryArea(
                    Address.Ptr64(addr),
                    bytes.ReadBytes((uint)size));
                var imageSection = new ImageSegment(
                    string.Format("{0},{1}", segmentName, sectionName),
                    mem,
                    am);

                //imageSection.setBss((section.flags & SECTION_TYPE) == S_ZEROFILL);

                //if (!imageSection.isBss()) {
                //    auto pos = source_->pos();
                //    if (!source_->seek(section.offset)) {
                //        throw ParseError("Could not seek to the beginning of the section's content.");
                //    }
                //    auto bytes = source_->read(section.size);
                //    if (checked_cast<uint>(bytes.size()) != section.size) {
                //        log_.warning("Could not read all the section's content.");
                //    } else {
                //        imageSection->setContent(std::move(bytes));
                //    }
                //    source_->seek(pos);
                //}

                //sections_.push_back(imageSection.get());
                //image_->addSection(std::move(imageSection));
                segmentMap.AddSegment(imageSection);
            }
예제 #30
0
파일: MachOLoader.cs 프로젝트: relaxar/reko
            void parseSegmentCommand64(SegmentMap imageMap)
            {
                var abSegname = rdr.ReadBytes(16);
                var cChars = Array.IndexOf<byte>(abSegname, 0);
                if (cChars == -1)
                    cChars = 16;
                string segname = Encoding.ASCII.GetString(abSegname, 0, cChars);
                ulong vmaddr;
                ulong vmsize;
                ulong fileoff;
                ulong filesize;
                uint maxprot;
                uint initprot;
                uint nsects;
                uint flags;
                if (!rdr.TryReadUInt64(out vmaddr) ||
                    !rdr.TryReadUInt64(out vmsize) ||
                    !rdr.TryReadUInt64(out fileoff) ||
                    !rdr.TryReadUInt64(out filesize) ||
                    !rdr.TryReadUInt32(out maxprot) ||
                    !rdr.TryReadUInt32(out initprot) ||
                    !rdr.TryReadUInt32(out nsects) ||
                    !rdr.TryReadUInt32(out flags))
                {
                    throw new BadImageFormatException("Could not read segment command.");
                }
                Debug.Print("Found segment '{0}' with {1} sections.", segname, nsects);

                for (uint i = 0; i < nsects; ++i)
                {
                    Debug.Print("Parsing section number {0}.", i);
                    parseSection64(initprot, imageMap);
                }
            }
예제 #31
0
파일: MachOLoader.cs 프로젝트: relaxar/reko
            public SegmentMap ParseLoadCommands(uint ncmds, Address addrLoad)
            {
                var imageMap = new SegmentMap(addrLoad);
                Debug.Print("Parsing load commands, {0} of them.", ncmds);

                var lookup = GetType()
                    .GetFields(
                        BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)
                    .Where(fi => fi.IsLiteral && !fi.IsInitOnly && fi.Name.StartsWith("LC_"))
                    .ToDictionary(fi => (uint)fi.GetValue(null), fi => fi.Name);

                for (uint i = 0; i < ncmds; ++i)
                {
                    var pos = rdr.Offset;
                    uint cmd;
                    uint cmdsize;
                    if (!rdr.TryReadUInt32(out cmd) ||
                        !rdr.TryReadUInt32(out cmdsize))
                    {
                        throw new BadImageFormatException(string.Format(
                            "Unable to read Mach-O command ({0:X}).",
                            rdr.Offset));
                    }
                    Debug.Print("{0,3}: Read load command 0x{1:X} {2} of size {3}.", i, cmd, lookup.ContainsKey(cmd) ? lookup[cmd] : "", cmdsize);

                    switch (cmd & ~LC_REQ_DYLD)
                    {
                    //case LC_SEGMENT:
                    //    parseSegmentCommand<segment_command, section>();
                    //    break;
                    case LC_SEGMENT_64:
                        parseSegmentCommand64(imageMap);
                        break;
                    //case LC_SYMTAB:
                    //    parseSymtabCommand<Mach>();
                    //    break;
                    case LC_FUNCTION_STARTS:
                        parseFunctionStarts(rdr.Clone());
                        break;
                    }
                    rdr.Offset = pos + cmdsize;
                }
                return imageMap;
            }
예제 #32
0
 public abstract IEnumerable<Address> CreateInstructionScanner(SegmentMap map, ImageReader rdr, IEnumerable<Address> knownAddresses, PointerScannerFlags flags);
예제 #33
0
 public override IEnumerable<Address> CreatePointerScanner(
     SegmentMap map,
     ImageReader rdr,
     IEnumerable<Address> knownAddresses,
     PointerScannerFlags flags)
 {
     var knownLinAddresses = knownAddresses
         .Select(a => a.ToLinear())
         .ToHashSet();
     return new PowerPcPointerScanner64(rdr, knownLinAddresses, flags)
         .Select(u => Address.Ptr64(u));
 }
예제 #34
0
 public override IEnumerable<Address> CreatePointerScanner(SegmentMap map, ImageReader rdr, IEnumerable<Address> knownAddresses, PointerScannerFlags flags)
 {
     throw new NotImplementedException();
 }
예제 #35
0
 private Expression GetMemoryValue(Address addr, DataType dt, SegmentMap segmentMap)
 {
     if (!(dt is PrimitiveType pt))
     {
         return(Constant.Invalid);
     }