public MNemonicCollectionPropertyDescriptor(MNemonicCollection coll, int idx)
     :
     base("#" + idx.ToString(), null)
 {
     this.collection = coll;
     this.index      = idx;
 }
Example #2
0
        public bool DisassembleFile(Trionic7File m_trionicFile, string inputfile, string outputfile, SymbolCollection symbols)
        {
            // recursive method when jsr was found
            mnemonics = new MNemonicCollection();
            labels = new MNemonicCollection();

            findLabels(inputfile);

            _passOne = false;

            uint i, t, seg, adr;
            long addr, endaddr, adrcntr, trgaddr, trgaddr1, trgaddr2, trgaddr3, offaddr;

            byte ch1, ch2, ch3, ch4, ch5, ch6, ch7, ch8, ch9, ch10;
            //byte n1, n2, n3, n4;
            //uint infile = 0, outfile = 0,
            uint addoff = 0;
            string inname, outname, offsetval;
            //byte inname[80], outname[80], offsetval[40];
            //byte str[80],cmd[80];
            string str, cmd;
            str = string.Empty;
            for (int temp = 0; temp < 8; temp++)
            {
                A_reg.SetValue(0, temp);
                D_reg.SetValue(0, temp);
            }
            m_symbols = symbols;
            swap = 0;
            addr = offaddr = 0;

            inname = inputfile;
            //infile = 1;
            //            outname = outputfile;
            //outfile = 1;
            //addr = startaddress;
            /********************* DISASSEMBLY STARTS HERE *********************/
            /* Read all the preceding words first */
            adrcntr = 0L;
            //StreamWriter sw = new StreamWriter(outname, false);
            FileStream fsbr = new FileStream(inname, FileMode.Open, FileAccess.Read);
            if (fsbr == null) return false;
            BinaryReader br = new BinaryReader(fsbr);
            if (br == null)
            {
                fsbr.Close();
                //sw.Close();
                return false;
            }
            //fsbr.Position = addr;
            adrcntr = addr;
            // iterate through all functions
            // first get all the pointers to work from
            func_count = 0;
            FileInfo fi = new FileInfo(inputfile);
            CastProgressEvent("Starting disassembly", 0, ProgressType.DisassemblingVectors);
            long[] vectors = Trionic7File.GetVectorAddresses(inputfile);
            for (int vec = 0; vec < vectors.Length; vec++)
            {
                int percentage = ((vec+1) * 100) / vectors.Length;
                CastProgressEvent("Disassembling vectors", percentage, ProgressType.DisassemblingVectors);
                long vector = Convert.ToInt64(vectors.GetValue(vec));

                if (vector != 0 && vector < fi.Length)
                {
                    try
                    {
                        DisassembleFunction(vector, symbols, fsbr, br, 0);
                    }
                    catch (Exception E)
                    {
                        logger.Debug("Failed to handle vector: " + E.Message);
                    }
                }
            }

            CastProgressEvent("Translating vector labels", 0, ProgressType.TranslatingVectors);
            //logger.Debug("Translating vector labels");

            int lblcount = 0;
            string[] names = Trionic7File.GetVectorNames();
            foreach (MNemonicHelper label in labels)
            {
                //logger.Debug("label: " + label.Address.ToString("X8") + " " + label.Mnemonic);
                int percentage = (lblcount++ * 100) / labels.Count;
                CastProgressEvent("Translating vector labels", percentage, ProgressType.TranslatingVectors);
                for (i = 0; i < vectors.Length; i++)
                {
                    if (label.Address == Convert.ToInt64(vectors.GetValue(i)))
                    {
                        label.Mnemonic = names[i].Replace(" ","_").ToUpper() + ":";
                    }
                }
            }
            /*
            logger.Debug("Translating known functions");
            CastProgressEvent("Translating known functions", 0, ProgressType.TranslatingLabels);
            lblcount = 0;
            foreach (MNemonicHelper label in labels)
            {
                int percentage = (lblcount++ * 100) / labels.Count;
                CastProgressEvent("Translating known functions", percentage, ProgressType.TranslatingLabels);
                foreach (MNemonicHelper mnemonic in mnemonics)
                {
                    if (mnemonic.Mnemonic.Contains("JSR") && mnemonic.Mnemonic.Contains(label.Address.ToString("X8")))
                    {
                        mnemonic.Mnemonic = mnemonic.Mnemonic.Replace(label.Address.ToString("X8"), label.Mnemonic.Replace(":", ""));
                        //    break;
                    }
                    else if (mnemonic.Mnemonic.Contains("BEQ") && mnemonic.Mnemonic.Contains(label.Address.ToString("X8")))
                    {
                        mnemonic.Mnemonic = mnemonic.Mnemonic.Replace(label.Address.ToString("X8"), label.Mnemonic.Replace(":", ""));
                    }
                    else if (mnemonic.Mnemonic.Contains("BRA") && mnemonic.Mnemonic.Contains(label.Address.ToString("X8")))
                    {
                        mnemonic.Mnemonic = mnemonic.Mnemonic.Replace(label.Address.ToString("X8"), label.Mnemonic.Replace(":", ""));
                    }
                    else if (mnemonic.Mnemonic.Contains("BLS") && mnemonic.Mnemonic.Contains(label.Address.ToString("X8")))
                    {
                        mnemonic.Mnemonic = mnemonic.Mnemonic.Replace(label.Address.ToString("X8"), label.Mnemonic.Replace(":", ""));
                    }
                    else if (mnemonic.Mnemonic.Contains("BNE") && mnemonic.Mnemonic.Contains(label.Address.ToString("X8")))
                    {
                        mnemonic.Mnemonic = mnemonic.Mnemonic.Replace(label.Address.ToString("X8"), label.Mnemonic.Replace(":", ""));
                    }
                    else if (mnemonic.Mnemonic.Contains("BHI") && mnemonic.Mnemonic.Contains(label.Address.ToString("X8")))
                    {
                        mnemonic.Mnemonic = mnemonic.Mnemonic.Replace(label.Address.ToString("X8"), label.Mnemonic.Replace(":", ""));
                    }
                    else if (mnemonic.Mnemonic.Contains("BCS") && mnemonic.Mnemonic.Contains(label.Address.ToString("X8")))
                    {
                        mnemonic.Mnemonic = mnemonic.Mnemonic.Replace(label.Address.ToString("X8"), label.Mnemonic.Replace(":", ""));
                    }
                    else if (mnemonic.Mnemonic.Contains("BCC") && mnemonic.Mnemonic.Contains(label.Address.ToString("X8")))
                    {
                        mnemonic.Mnemonic = mnemonic.Mnemonic.Replace(label.Address.ToString("X8"), label.Mnemonic.Replace(":", ""));
                    }
                    else if (mnemonic.Mnemonic.Contains("BGE") && mnemonic.Mnemonic.Contains(label.Address.ToString("X8")))
                    {
                        mnemonic.Mnemonic = mnemonic.Mnemonic.Replace(label.Address.ToString("X8"), label.Mnemonic.Replace(":", ""));
                    }
                    else if (mnemonic.Mnemonic.Contains("BLT") && mnemonic.Mnemonic.Contains(label.Address.ToString("X8")))
                    {
                        mnemonic.Mnemonic = mnemonic.Mnemonic.Replace(label.Address.ToString("X8"), label.Mnemonic.Replace(":", ""));
                    }
                    else if (mnemonic.Mnemonic.Contains("BGT") && mnemonic.Mnemonic.Contains(label.Address.ToString("X8")))
                    {
                        mnemonic.Mnemonic = mnemonic.Mnemonic.Replace(label.Address.ToString("X8"), label.Mnemonic.Replace(":", ""));
                    }
                    else if (mnemonic.Mnemonic.Contains("BLE") && mnemonic.Mnemonic.Contains(label.Address.ToString("X8")))
                    {
                        mnemonic.Mnemonic = mnemonic.Mnemonic.Replace(label.Address.ToString("X8"), label.Mnemonic.Replace(":", ""));
                    }
                }
            }*/
            CastProgressEvent("Adding labels", 0, ProgressType.AddingLabels);
            //logger.Debug("Adding labels");
            lblcount = 0;
            foreach (MNemonicHelper label in labels)
            {
                int percentage = (lblcount++ * 100) / labels.Count;
                CastProgressEvent("Adding labels", percentage, ProgressType.AddingLabels);

                label.Address--; // for sequencing
                mnemonics.Add(label);
            }

            //logger.Debug("Sorting data");
            CastProgressEvent("Sorting mnemonics", 0, ProgressType.SortingData);
            mnemonics.SortColumn = "Address";
            mnemonics.SortingOrder = GenericComparer.SortOrder.Ascending;
            mnemonics.Sort();
            CastProgressEvent("Sorting mnemonics", 100, ProgressType.SortingData);
            return true;
        }
Example #3
0
        private void LoadLabels(long addr, FileStream fs, BinaryReader br, long offset)
        {
            //logger.Debug("Load labels from addr: " + addr.ToString("X8"));
            MNemonicHelper label = new MNemonicHelper();
            MNemonicCollection functionList = new MNemonicCollection();
            label.Mnemonic = "Function_" + addr.ToString("X8") + ":";
            label.Address = addr;

            if (AddressInLabelList(addr))
            {
                return;
            }
            _labels.Add(label);
            //logger.Debug("Added label: " + label.Mnemonic + " " + label.Address.ToString("X8"));

            long offaddr = 0;
            if (addr == 0) return;
            if (addr > offset)
            {
                fs.Position = addr - offset;
            }
            else
            {
                fs.Position = addr;
            }

            bool endsub = false;
            bool issub = false;
            bool isjump = false;
            string str;
            while (!endsub)
            {
                byte ch1 = br.ReadByte();
                byte ch2 = br.ReadByte();
                uint i = (uint)((ch1 << 8) + ch2);
                uint seg = (uint)(((addr + offaddr) & 0xffff0000) >> 16);
                uint adr = (uint)(((addr + offaddr) & 0xffff));
                uint t = disasm(out str, addr, ch1, ch2, offaddr, br, out endsub, out issub, out isjump);
                if (str != "")
                {
                    MNemonicHelper mnhelper = new MNemonicHelper();
                    mnhelper.Mnemonic = str;
                    mnhelper.Address = addr;
                    //realAddr = fs.Position + offset;
                    //mnhelper.Address = realAddr;
                    functionList.Add(mnhelper);
                }
                if (t > 5) t = 5;
                //addr += t;
                switch (t)
                {
                    case 0:
                    case 1:
                        addr += 2L;
                        break;
                    case 2:
                        addr += 4L;
                        break;
                    case 3:
                        addr += 6L;
                        break;
                    case 4:
                        addr += 8L;
                        break;
                    case 5:
                        addr += 10L;
                        break;
                }
                if (issub)
                {
                    if (trgdata != 0)
                    {
                        if (!AddressInLabelList(trgdata))
                        {
                            if (trgdata < 0x00F00000)
                            {
                                long position = fs.Position;
                                LoadLabels(trgdata,  fs, br, offset);
                                fs.Position = position; // reset to previous position
                            }
                        }
                    }
                }
                if (endsub)
                {
                }
            }
        }
Example #4
0
        private MNemonicCollection findLabels(string inputfile)
        {
            _labels = new MNemonicCollection();
            uint i, t, seg, adr;
            long addr, endaddr, adrcntr, trgaddr, trgaddr1, trgaddr2, trgaddr3, offaddr;

            byte ch1, ch2, ch3, ch4, ch5, ch6, ch7, ch8, ch9, ch10;
            //byte n1, n2, n3, n4;
            //uint infile = 0, outfile = 0,
            uint addoff = 0;
            string inname, outname, offsetval;
            //byte inname[80], outname[80], offsetval[40];
            //byte str[80],cmd[80];
            string str, cmd;
            str = string.Empty;
            for (int temp = 0; temp < 8; temp++)
            {
                A_reg.SetValue(0, temp);
                D_reg.SetValue(0, temp);
            }
            swap = 0;
            addr = offaddr = 0;

            inname = inputfile;
            adrcntr = 0L;
            FileStream fsbr = new FileStream(inname, FileMode.Open, FileAccess.Read);
            if (fsbr == null) return _labels;
            BinaryReader br = new BinaryReader(fsbr);
            if (br == null)
            {
                fsbr.Close();
                return _labels;
            }
            fsbr.Position = addr;
            adrcntr = addr;
            // iterate through all functions
            // first get all the pointers to work from
            func_count = 0;
            FileInfo fi = new FileInfo(inputfile);
            CastProgressEvent("Start analyzing", 0, ProgressType.PassOne);
            long[] adresses = Trionic7File.GetVectorAddresses(inputfile);
            for (int vec = 1; vec < adresses.Length; vec++)
            {
                int percentage = (vec * 100) / adresses.Length;
                CastProgressEvent("Analyzing", percentage, ProgressType.PassOne);
                long vector = adresses[vec];

                if (vector != 0 && vector < fi.Length)
                {
                    try
                    {
                        LoadLabels(vector, fsbr, br, 0);
                    }
                    catch (Exception E)
                    {
                        logger.Debug("Failed to handle vector: " + E.Message);
                    }
                }
            }

            logger.Debug("Found " + _labels.Count.ToString() + " in pass one");
            foreach (MNemonicHelper label in _labels)
            {
                if (label.Address == adresses[1]) logger.Debug("Found start pointer!");
            }
            return _labels;
        }
Example #5
0
        private void DisassembleFunction(long addr, SymbolCollection symbols, FileStream fs, BinaryReader br, long offset)
        {
            CastProgressEvent("Disassembling function: " + addr.ToString("X8"), func_count++, ProgressType.DisassemblingFunctions);
            //logger.Debug("DisassembleFunction: " + addr.ToString("X8"));
            MNemonicCollection functionList = new MNemonicCollection();

            MNemonicHelper label = new MNemonicHelper();
            //long realAddr = fs.Position + offset;
            //label.Mnemonic = "Function_" + realAddr.ToString("X8") + ":";
            label.Mnemonic = "Function_" + addr.ToString("X8") +":";
            label.Address = addr;
            if (AddressInMnemonicList(addr))
            {
                //logger.Debug("Already disassembled: " + addr.ToString("X8"));
                return ;
            }
            labels.Add(label);
            functionList.Add(label);
            long offaddr = 0;
            if (addr == 0) return ;
            if (addr > offset)
            {
                fs.Position = addr - offset;
            }
            else
            {
                fs.Position = addr;
            }

            bool endsub = false;
            bool issub = false;
            bool isjump = false;
            string str;
            while (!endsub)
            {
                byte ch1 = br.ReadByte();
                byte ch2 = br.ReadByte();
                uint i = (uint)((ch1 << 8) + ch2);
                uint seg = (uint)(((addr + offaddr) & 0xffff0000) >> 16);
                uint adr = (uint)(((addr + offaddr) & 0xffff));
                /*if (ch1 == 0x58 && ch2 == 0x8F)
                {
                    logger.Debug("break!");
                }*/
                uint t = disasm(out str, addr, ch1, ch2, offaddr, br, out endsub, out issub, out isjump);
                //logger.Debug(str);
                if (str != "")
                {
                    MNemonicHelper mnhelper = new MNemonicHelper();
                    mnhelper.Mnemonic = str;
                    mnhelper.Address = addr;
                    //realAddr = fs.Position + offset;
                    //mnhelper.Address = realAddr;
                    if (!AddressInMnemonicList(addr))
                    {
                        if (isjump)
                        {
                            TranslateLabels(mnhelper);
                        }
                        mnemonics.Add(mnhelper);
                    }
                    functionList.Add(mnhelper);
                }
                if (t > 5) t = 5;
                //addr += t;
                switch (t)
                {
                    case 0:
                    case 1:
                        addr += 2L;
                        break;
                    case 2:
                        addr += 4L;
                        break;
                    case 3:
                        addr += 6L;
                        break;
                    case 4:
                        addr += 8L;
                        break;
                    case 5:
                        addr += 10L;
                        break;
                }
                if (issub)
                {
                    /*if (trgdata == 0)
                    {
                        logger.Debug("break!");
                    }*/

                    // alleen als die nog niet geweest is
                    if (trgdata != 0)
                    {
                        if (!AddressInMnemonicList(trgdata))
                        {
                            if (trgdata < 0x00F00000)
                            {
                                long position = fs.Position;
                                //logger.Debug("recursive: " + trgdata.ToString("X8") + " curr address: " + addr.ToString("X8"));
                                DisassembleFunction(trgdata, symbols, fs, br, offset);
                                //logger.Debug("After recursion: " + addr.ToString("X8"));
                                fs.Position = position; // reset to previous position
                            }
                        }
                    }
                }
                if (endsub)
                {
                }
            }

            //logger.Debug("Done with function: " + mnemonics.Count.ToString());
        }
 public MNemonicCollectionPropertyDescriptor(MNemonicCollection coll, int idx)
     : base("#" + idx.ToString(), null)
 {
     this.collection = coll;
     this.index = idx;
 }