public void MacsBug_ScanProcedures()
        {
            Given_Link(4);
            Given_Body(3);
            Given_Rts();
            Given_Variable_Length_Symbol("my_printf");
            Given_ProgramData(0);

            var mem     = new ByteMemoryArea(Address.Ptr32(0x00100000), w.ToArray());
            var scan    = new MacsBugSymbolScanner(arch, mem);
            var symbols = scan.ScanForSymbols();

            Assert.AreEqual(1, symbols.Count);
            var sym = symbols[0];

            Assert.AreEqual(SymbolType.Procedure, sym.Type);
            Assert.AreEqual("my_printf", sym.Name);
            Assert.AreEqual(Address.Ptr32(0x00100000), sym.Address);
        }
Пример #2
0
 private void Given_BE32_GOT(params uint[] aPointers)
 {
     var writer = new BeImageWriter();
     foreach (var ptr in aPointers)
     {
         writer.WriteBeUInt32(ptr);
     }
     var mem = new MemoryArea(Address.Ptr32(0x10000000), writer.ToArray());
     program.SegmentMap.AddSegment(mem,  ".got", AccessMode.ReadWriteExecute);
     arch.Setup(a => a.CreateImageReader(
         It.IsNotNull<MemoryArea>(),
         mem.BaseAddress))
         .Returns(new BeImageReader(mem, 0));
 }
Пример #3
0
        private byte[] FlattenSymbolTable()
        {
            var syms = new BeImageWriter();

            foreach (var sym in symbols)
            {
                syms.WriteBeUInt32(sym.st_name);
                syms.WriteBeUInt32(sym.st_value);
                syms.WriteBeUInt32(sym.st_size);
                syms.WriteByte(sym.st_info);
                syms.WriteByte(sym.st_other);
                syms.WriteBeUInt16(sym.st_shndx);
            }
            return(syms.ToArray());
        }
Пример #4
0
        private void Given_Code(params uint [] uInstrs)
        {
            var writer = new BeImageWriter();

            foreach (uint uInstr in uInstrs)
            {
                writer.WriteBeUInt32(uInstr);
            }
            var mem     = new ByteMemoryArea(Address.Ptr64(0x0010_0000), writer.ToArray());
            var seg     = new ImageSegment("code", mem, AccessMode.ReadWriteExecute);
            var segmap  = new SegmentMap(mem.BaseAddress, seg);
            var program = new Program(segmap, arch, new DefaultPlatform(sc, arch));

            var envEmu = new DefaultPlatformEmulator();

            emu = (Reko.Arch.PowerPC.PowerPcEmulator)arch.CreateEmulator(segmap, envEmu);
            emu.InstructionPointer = program.ImageMap.BaseAddress;
            emu.ExceptionRaised   += (sender, e) => { throw e.Exception; };
        }
Пример #5
0
        protected void BuildObjectFile32()
        {
            // Add symbol table
            if (symbols.Count > 0)
            {
                Given_Section(".symtab", SectionHeaderType.SHT_SYMTAB, ElfLoader.SHF_ALLOC, FlattenSymbolTable());
                var os = objectSections[objectSections.Count - 1];
                os.ElementSize = Elf32_Sym.Size;
                os.Link        = (ushort)objectSections.Count;
                Given_Section(".strtab", SectionHeaderType.SHT_STRTAB, ElfLoader.SHF_ALLOC, symbolStringtab.ToArray());
            }

            var bin = new BeImageWriter();

            bin.WriteByte(0x7F);
            bin.WriteBytes(new byte[] { 0x45, 0x4C, 0x46 });
            bin.WriteByte(1);     // 32-bit
            bin.WriteByte(2);     // big-endian
            bin.WriteByte(1);     // ELF version
            bin.WriteByte(0);     // OS ABI
            bin.WriteByte(0);     // OS version
            bin.WriteBytes(0, 7); // pad

            // ELF header

            bin.WriteBeUInt16(1);                            // relocatable
            bin.WriteBeUInt16((ushort)ElfMachine.EM_SPARC);
            bin.WriteBeUInt32(1);                            // version
            bin.WriteBeUInt32(0);                            // entry point (none in reloc file)
            bin.WriteBeUInt32(0);                            // program segment table offset (none in reloc file)
            bin.WriteBeUInt32((uint)bin.Position + 20);      // point to section table.

            bin.WriteBeUInt32(0);                            // e_flags;
            bin.WriteBeUInt16(0);                            // e_ehsize;
            bin.WriteBeUInt16((ushort)Elf32_PHdr.Size);      // e_phentsize;
            bin.WriteBeUInt16((ushort)progHeaders.Count);    // e_phnum;
            bin.WriteBeUInt16(0);                            // e_shentsize;
            bin.WriteBeUInt16((ushort)objectSections.Count); // e_shnum;
            bin.WriteBeUInt16(1);                            // e_shstrndx;

            // Build string table.

            var strtab      = new MemoryStream();
            var mpOsToiName = new Dictionary <ObjectSection, int>();

            foreach (var os in this.objectSections)
            {
                mpOsToiName[os] = (int)strtab.Position;
                var bytes = Encoding.ASCII.GetBytes(os.Name);
                strtab.Write(bytes, 0, bytes.Length);
                strtab.WriteByte(0);
            }

            // Reserve space for program header table and
            // section table.
            var iProgHdrTable = (uint)bin.Position;
            var iShTable      = (uint)bin.Position + (uint)(progHeaders.Count * Elf32_PHdr.Size);
            var iStrTable     = iShTable + (uint)(40 * objectSections.Count);

            // Write string table
            var aStrtable = strtab.ToArray();

            objectSections[1].Content = aStrtable;
            var iContent = iStrTable;

            // Place remaining sections.
            foreach (var section in objectSections.Skip(1))
            {
                section.Offset = iContent;
                iContent       = Align((uint)(iContent + section.Content.Length));
            }

            // Write the program header table
            foreach (var ph in this.progHeaders)
            {
                bin.WriteBeUInt32((uint)ph.Type);
                bin.WriteBeUInt32(ph.Offset);
                bin.WriteBeUInt32(ph.VirtualAddress);
                bin.WriteBeUInt32(0);
                bin.WriteBeUInt32((uint)ph.Content.Length);
                bin.WriteBeUInt32(ph.AllocateSize);
                bin.WriteBeUInt32(ph.Flags);
                bin.WriteBeUInt32(ph.Alignment);
            }

            // Write the section table.
            foreach (var os in this.objectSections)
            {
                bin.WriteBeUInt32((uint)mpOsToiName[os]);
                bin.WriteBeUInt32((uint)os.Type);
                bin.WriteBeUInt32(os.Flags);
                bin.WriteBeUInt32(0);

                bin.WriteBeUInt32(os.Offset);
                bin.WriteBeUInt32(os.Content != null ? (uint)os.Content.Length : 0u);
                bin.WriteBeUInt32(os.Link);
                bin.WriteBeUInt32(0);

                bin.WriteBeUInt32(0);
                bin.WriteBeUInt32(os.ElementSize);
            }

            // write the non-null sections.
            foreach (var section in objectSections.Skip(1))
            {
                bin.WriteBytes(section.Content);
                Align(bin);
            }
            this.rawBytes = bin.ToArray();
        }