Exemplo n.º 1
0
        void IFR(
            uint addr, uint vanilla_addr, string targetfilename, uint blocksize, uint count
            , string debugInfo)
        {
            uint writeaddr;

            if (!isVanilaExtrendsROMArea(addr + blocksize * count))
            {//非拡張領域
                //そのまま書き換えられる
                writeaddr = addr;
            }
            else
            {//リポイントが必要
                writeaddr = Alloc(blocksize * count, addr);
                uint writeaddr_pointer = U.toPointer(writeaddr);

                //データのコピー
                byte[] bin = U.getBinaryData(this.WriteROMData32MB, vanilla_addr, blocksize * count);
                U.write_range(this.WriteROMData32MB, writeaddr, bin);

                uint vanilla_pointer = U.toPointer(vanilla_addr);

                //IFRの場合 複数のLDRを書き換える必要あり
                //ClearLDRCache();
                CheckLDRCache();
                for (int i = 0; i < this.LDRCache.Count; i++)
                {
                    DisassemblerTrumb.LDRPointer ldr = this.LDRCache[i];
                    if (ldr.ldr_data == vanilla_pointer)
                    {
                        U.write_u32(this.WriteROMData32MB, ldr.ldr_data_address, writeaddr_pointer);
                        ldr.ldr_data = writeaddr_pointer;
                    }
                }
            }

            string[] lines = File.ReadAllLines(targetfilename);
            for (int n = 0; n < lines.Length; n++)
            {
                string   line      = lines[n];
                string[] sp        = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                uint     dataIndex = U.atoh(sp[0].Substring(1));

                uint        pos = writeaddr + (blocksize * dataIndex);
                List <byte> bin = WriteBytes(1, sp, writeaddr, pos, debugInfo);

                U.write_range(this.WriteROMData32MB, pos, bin.ToArray());
            }
            ResolvedPointer(U.toPointer(addr), U.toPointer(writeaddr), debugInfo);
        }
Exemplo n.º 2
0
        bool FindOtherROMDataWithLDR(uint search_address, uint refaddress, int slide
                                     , out uint out_addr, out uint out_ref)
        {
            out_addr = U.NOT_FOUND;
            out_ref  = U.NOT_FOUND;
            if (OtherROMLDRFuncList == null)
            {
                return(false);
            }

            for (int i = 0; i < OtherROMLDRFuncList.Count; i++)
            {
                uint otherrom_addr;
                uint otherrom_ref;

                uint addr = OtherROMLDRFuncList[i].FuncAddr;
                bool r    = FindOtherROMData(addr, slide, out otherrom_addr, out otherrom_ref);
                if (!r)
                {
                    continue;
                }

                otherrom_addr = U.toOffset(otherrom_addr + OtherROMLDRFuncList[i].BackSize);
                for (int n = 0; n < this.OtherLDRMAPs.Count; n++)
                {
                    DisassemblerTrumb.LDRPointer otherldr = this.OtherLDRMAPs[n];
                    if (otherldr.ldr_address != otherrom_addr)
                    {
                        continue;
                    }

                    out_ref  = otherldr.ldr_data_address;
                    out_addr = otherldr.ldr_data;
                    return(true);
                }
            }
            return(false);
        }
Exemplo n.º 3
0
        List <OtherROMLDRFuncSt> MakeOtherROMLDRFuncList(uint search_address)
        {
            List <OtherROMLDRFuncSt> list = new List <OtherROMLDRFuncSt>();

            for (int i = 0; i < this.LDRMAPs.Count; i++)
            {
                DisassemblerTrumb.LDRPointer ldr = this.LDRMAPs[i];
                if (ldr.ldr_data != search_address)
                {
                    continue;
                }
                if (ldr.ldr_address <= SEARCH_PUSH_MAX)
                {
                    continue;
                }

                DisassemblerTrumb    Disassembler = new DisassemblerTrumb();
                DisassemblerTrumb.VM vm           = new DisassemblerTrumb.VM();
                uint limit = ldr.ldr_address - SEARCH_PUSH_MAX;
                for (uint n = ldr.ldr_address - 2; n >= limit; n -= 2)
                {
                    DisassemblerTrumb.Code code =
                        Disassembler.Disassembler(Program.ROM.Data, n, (uint)Program.ROM.Data.Length, vm);
                    if (code.Type == DisassemblerTrumb.CodeType.PUSH)
                    {
                        OtherROMLDRFuncSt pp = new OtherROMLDRFuncSt();
                        pp.FuncAddr = U.toPointer(n);
                        pp.BackSize = ldr.ldr_address - n;
                        list.Add(pp);
                    }
                    else if (code.Type == DisassemblerTrumb.CodeType.BXJMP)
                    {
                        break;
                    }
                }
            }
            return(list);
        }