Example #1
0
        public void ExdApplication()
        {
            var sig = FunctionType.Action(new[] { Id("r", PrimitiveType.Real32) });
            var ep  = new ExternalProcedure("test", sig);

            RunTest(
                Test(m.Fn(ep, m.Load(PrimitiveType.Word32, m.Word32(0x0300400))), VoidType.Instance));
        }
Example #2
0
        public void ExdApplication()
        {
            var sig = FunctionType.Action(Id("r", PrimitiveType.Real32));
            var ep  = new ExternalProcedure("test", sig);

            RunTest(
                "Typing/ExdApplication.txt",
                Test(m.Fn(ep, m.Mem(PrimitiveType.Word32, m.Word32(0x0300400))), VoidType.Instance));
        }
        public void ExdApplication()
        {
            var arg = Id("arg", PrimitiveType.Word32);
            var sig = new ProcedureSignature(null, Id("r", PrimitiveType.Real32));
            var ep  = new ExternalProcedure("test", sig);

            RunTest(
                Test(m.Fn(ep, m.Load(PrimitiveType.Word32, m.Word32(0x0300400))), VoidType.Instance));
        }
Example #4
0
        public Application Fn(ExternalProcedure ep, params Expression[] args)
        {
            var retType = ep.Signature.ReturnValue != null
                ? ep.Signature.ReturnValue.DataType
                : VoidType.Instance;

            return(new Application(
                       new ProcedureConstant(PrimitiveType.Pointer32, ep),
                       retType,
                       args));
        }
Example #5
0
        private ExternalProcedure CreateExternalProcedure(
            string name,
            int stackDelta,
            Identifier ret,
            params Identifier[] parameters)
        {
            var ep = new ExternalProcedure(name, new FunctionType(ret, parameters));

            ep.Signature.ReturnAddressOnStack = 4;
            ep.Signature.StackDelta           = stackDelta;
            return(ep);
        }
Example #6
0
        private void AssertExternalProcedure(
            string expected,
            ExternalProcedure ep)
        {
            var actual = $@"
{ep}
VarargsParserClass: {ep.Characteristics.VarargsParserClass}";

            if (expected != actual)
            {
                Console.WriteLine(actual);
                Assert.AreEqual(expected, actual);
            }
        }
 public void Setup()
 {
     this.platform      = new Mock <IPlatform>();
     this.arch          = new FakeArchitecture(new ServiceContainer());
     this.builder       = new ProgramBuilder(arch);
     this.dynamicLinker = new Mock <IDynamicLinker>();
     this.sbExpected    = new StringBuilder();
     this.fnExit        = new ExternalProcedure(
         "exit",
         FunctionType.Action(new Identifier("code", PrimitiveType.Int32, new StackArgumentStorage(4, PrimitiveType.Int32))),
         new ProcedureCharacteristics
     {
         Terminates = true,
     });
 }
Example #8
0
        protected bool TryGetNoDecompiledProcedure(Address addr, out ExternalProcedure ep)
        {
            if (!TryGetNoDecompiledParsedProcedure(addr, out Procedure_v1 sProc))
            {
                ep = null;
                return(false);
            }
            var ser = Program.CreateProcedureSerializer();
            var sig = ser.Deserialize(
                sProc.Signature,
                Program.Architecture.CreateFrame());

            ep = new ExternalProcedure(sProc.Name, sig);
            return(true);
        }
        public void TerDeclaration()
        {
            ProgramBuilder pm = new ProgramBuilder();

            pm.Add("proc1", m =>
            {
                var ax   = m.Reg16("ax", 0);
                var rand = new ExternalProcedure(
                    "rand",
                    new FunctionType(
                        new Identifier("ax", PrimitiveType.Int16, ax.Storage),
                        new Identifier[0]));
                m.Declare(ax, m.Fn(rand));
                m.MStore(m.Word16(0x1300), ax);
                m.Return();
            });
            RunTest(pm, "Typing/TerDeclaration.txt");
        }
Example #10
0
        public void TerDeclaration()
        {
            ProgramBuilder pm = new ProgramBuilder();

            pm.Add("proc1", m =>
            {
                var ax   = m.Reg16("ax", 0);
                var rand = new ExternalProcedure(
                    "rand",
                    FunctionType.Func(
                        new Identifier("ax", PrimitiveType.Int16, ax.Storage),
                        new Identifier[0]));
                m.Assign(m.Frame.EnsureRegister(m.Architecture.StackRegister), m.Frame.FramePointer);
                m.Assign(ax, m.Fn(rand));
                m.MStore(m.Word16(0x1300), ax);
                m.Return();
            });
            RunTest(pm, "Typing/TerDeclaration.txt");
        }
Example #11
0
        public void TrcoCallFunctionWithArraySize()
        {
            var m   = new ProcedureBuilder();
            var sig = new ProcedureSignature(null,
                                             m.Frame.EnsureStackArgument(0, PrimitiveType.Word32));
            var ex = new ExternalProcedure("malloc", sig, new ProcedureCharacteristics
            {
                Allocator = true,
                ArraySize = new ArraySizeCharacteristic
                {
                    Argument = "r",
                    Factors  = new ArraySizeFactor[]
                    {
                        new ArraySizeFactor {
                            Constant = "1"
                        }
                    }
                }
            });

            Identifier eax  = m.Local32("eax");
            var        call = m.Assign(eax, m.Fn(new ProcedureConstant(PrimitiveType.Word32, ex), m.Word32(3)));

            coll = CreateCollector();
            call.Accept(eqb);
            call.Accept(coll);
            StringWriter sw = new StringWriter();

            handler.Traits.Write(sw);
            string sExp =
                "T_1 (in malloc : word32)" + nl +
                "\ttrait_func(T_4 -> T_5)" + nl +
                "T_3 (in dwArg00 : word32)" + nl +
                "\ttrait_primitive(word32)" + nl +
                "T_4 (in 0x00000003 : word32)" + nl +
                "\ttrait_primitive(word32)" + nl +
                "\ttrait_equal(T_3)" + nl +
                "T_5 (in malloc(0x00000003) : word32)" + nl +
                "\ttrait_primitive(word32)";

            Console.WriteLine(sw.ToString());
            Assert.AreEqual(sExp, sw.ToString());
        }
Example #12
0
        public void ExtpBind()
        {
            var sig = FunctionType.Func(
                new Identifier(Registers.ax.Name, PrimitiveType.Word16, Registers.ax),
                new Identifier [] {
                new Identifier(Registers.bx.Name, PrimitiveType.Word16, Registers.bx),
                new Identifier(Registers.cl.Name, PrimitiveType.Byte, Registers.cl)
            });
            var ep = new ExternalProcedure("foo", sig);

            Assert.AreEqual("Register word16 foo(Register word16 bx, Register byte cl)", ep.ToString());
            var fn    = new ProcedureConstant(PrimitiveType.Ptr32, ep);
            var arch  = new FakeArchitecture();
            var frame = arch.CreateFrame();
            var ab    = arch.CreateFrameApplicationBuilder(frame, new CallSite(0, 0), fn);
            var instr = ab.CreateInstruction(ep.Signature, ep.Characteristics);

            Assert.AreEqual("ax = foo(bx, cl)", instr.ToString());
        }
Example #13
0
        public void Vafs_X86Sprintf()
        {
            Given_VaScanner(win32);
            Given_StackString(8, "%c");
            Assert.IsTrue(vafs.TryScan(addrInstr, dummyPc, x86SprintfSig, printfChr));
            var ep    = new ExternalProcedure("sprintf", x86SprintfSig);
            var pc    = new ProcedureConstant(new CodeType(), ep);
            var instr = vafs.BuildInstruction(pc, new CallSite(4, 0));

            Assert.AreEqual(
                "sprintf(Mem0[esp:(ptr32 char)], Mem0[esp + 4:(ptr32 char)], " +
                "Mem0[esp + 8:char])",
                instr.ToString());
            var appl = (Application)((SideEffect)instr).Expression;
            var sig  = ((ProcedureConstant)appl.Procedure).Procedure.Signature;

            Assert.AreEqual(
                "(fn void ((ptr32 char), (ptr32 char), char))",
                sig.ToString());
        }
Example #14
0
        private ProcedureBase GivenFunction(string name, RegisterStorage ret, params object [] args)
        {
            var        frame = pb.Program.Architecture.CreateFrame();
            Identifier idRet = null;

            if (ret != null)
            {
                idRet = frame.EnsureRegister(ret);
            }
            List <Identifier> parameters = new List <Identifier>();

            foreach (int offset in args)
            {
                parameters.Add(frame.EnsureStackArgument(offset, pb.Program.Architecture.WordWidth));
            }
            var proc = new ExternalProcedure(name, FunctionType.Func(
                                                 idRet,
                                                 parameters.ToArray()));

            return(proc);
        }
Example #15
0
        public override ExternalProcedure LookupProcedureByName(string moduleName, string procName)
        {
            //$REVIEW: looks a lot like Win32library, perhaps push to parent class?
            EnsureTypeLibraries(PlatformIdentifier);
            var sig = Metadata.Lookup(procName);

            if (sig == null)
            {
                return(null);
            }
            var proc            = new ExternalProcedure(procName, sig);
            var characteristics = CharacteristicsLibs.Select(cl => cl.Lookup(procName))
                                  .Where(c => c != null)
                                  .FirstOrDefault();

            if (characteristics != null)
            {
                proc.Characteristics = characteristics;
            }
            return(proc);
        }
Example #16
0
        public void SsaSwitchWithSharedBranches()
        {
            var m = new ProcedureBuilder("SsaSwitchWithSharedBranches");

            var sp  = m.Frame.EnsureRegister(m.Architecture.StackRegister);
            var r1  = m.Reg32("r1", 1);
            var r2  = m.Reg32("r2", 2);
            var foo = new ExternalProcedure("foo", new FunctionType(
                                                new Identifier("", VoidType.Instance, null),
                                                new Identifier("arg1", PrimitiveType.Int32, new StackArgumentStorage(4, PrimitiveType.Int32))));

            m.Assign(sp, m.Frame.FramePointer);
            m.Assign(r1, m.Mem32(m.IAdd(sp, 4)));
            m.BranchIf(m.Ugt(r1, m.Word32(0x5)), "m4_default");
            m.Label("m1");
            m.Switch(r1,
                     "m2", "m2", "m3", "m3", "m2", "m3");
            m.Label("m2");
            m.Assign(sp, m.ISub(sp, 4));
            m.MStore(sp, m.Word32(0x42));
            m.Call(foo, 4);
            m.Assign(sp, m.IAdd(sp, 4));
            // fall through
            m.Label("m3");
            m.Assign(sp, m.ISub(sp, 4));
            m.MStore(sp, m.Word32(42));
            m.Call(foo, 4);
            m.Assign(sp, m.IAdd(sp, 4));
            // fall through
            m.Label("m4_default");
            m.Assign(sp, m.ISub(sp, 4));
            m.MStore(sp, m.Word32(0));
            m.Call(foo, 4);
            m.Assign(sp, m.IAdd(sp, 4));

            m.Return();

            RunUnitTest(m, "Analysis/SsaSwitchWithSharedBranches.txt");
        }
Example #17
0
        public void StrAnls_Issue_529()
        {
            var m    = new ProcedureBuilder();
            var fp   = m.Frame.FramePointer;
            var sp   = m.Frame.EnsureRegister(m.Architecture.StackRegister);
            var puts = new ExternalProcedure("puts", new FunctionType());

            m.Label("m4E2");
            m.Goto("m4F7");

            m.Label("m4E4");
            m.SideEffect(m.Fn(puts, Constant.String("Hello", StringType.NullTerminated(PrimitiveType.Byte))));
            m.Return();

            m.Label("m4F7");
            m.BranchIf(m.Eq0(m.Mem32(m.Word32(0x0808A0A4))), "m502");
            m.Label("m500");
            m.Goto("m50D");

            m.Label("m502");
            m.BranchIf(m.Eq0(m.Mem32(m.Word32(0x0808A0A8))), "m4E4");
            m.Goto("m50D");
            m.Label("m50D");
            m.SideEffect(m.Fn(puts, Constant.String("Goodbye", StringType.NullTerminated(PrimitiveType.Byte))));
            m.Goto("m4E4");

            var sExp =
                #region Expected
                @"    if (Mem0[0x0808A0A4:word32] != 0x00 || Mem0[0x0808A0A8:word32] != 0x00)
        puts(""Goodbye"");
    puts(""Hello"");
    return;
";

            #endregion
            Given_CompoundConditionCoalescer(m.Procedure);
            RunTest(sExp, m.Procedure);
        }
Example #18
0
        public bool ProcessAlloca(CallSite site, ExternalProcedure impProc)
        {
            if (impProc.Signature == null)
            {
                throw new ApplicationException(string.Format("You must specify a procedure signature for {0} since it has been marked as 'alloca'.", impProc.Name));
            }
            var ab = CreateApplicationBuilder(new ProcedureConstant(program.Platform.PointerType, impProc), impProc.Signature, site);

            if (impProc.Signature.Parameters.Length != 1)
            {
                throw new ApplicationException(string.Format("An alloca function must have exactly one parameter, but {0} has {1}.", impProc.Name, impProc.Signature.Parameters.Length));
            }
            var target = ab.Bind(impProc.Signature.Parameters[0]);
            var id     = target as Identifier;

            if (id == null)
            {
                throw new ApplicationException(string.Format("The parameter of {0} wasn't a register.", impProc.Name));
            }
            if (state.GetValue(id) is Constant c && c.IsValid)
            {
                Emit(new Assignment(stackReg, new BinaryExpression(Operator.ISub, stackReg.DataType, stackReg, c)));
            }
Example #19
0
        private void RewriteJmp()
        {
            if (IsRealModeReboot(instrCur))
            {
                //$BUG: this should really live in MsdosPlatform.
                var reboot = new ExternalProcedure(
                    "__bios_reboot",
                    new FunctionType(
                        new Identifier("", VoidType.Instance, null)))
                {
                    Characteristics = new ProcedureCharacteristics
                    {
                        Terminates = true,
                    }
                };
                m.SideEffect(m.Fn(reboot));
                return;
            }

            rtlc = InstrClass.Transfer;
            if (instrCur.Operands[0] is ImmediateOperand)
            {
                Address addr = OperandAsCodeAddress(instrCur.Operands[0]);
                m.Goto(addr);
                return;
            }
            var target = SrcOp(instrCur.Operands[0]);

            if (target.DataType.Size == 2 && arch.WordWidth.Size > 2)
            {
                rtlc = InstrClass.Invalid;
                m.Invalid();
                return;
            }
            m.Goto(target);
        }
Example #20
0
        public void Jps_CallsApplications()
        {
            var sExpMain =
                "{" +
                "'name':'main','signature':''," +
                "'ids':[{'name':'f1','type':'w64','stg':{'kind':'reg','name':'f1'}}]," +
                "'blocks':[" +
                "{'name':'main_entry'," +
                "'succ':['l0010']}," +
                "{'name':'main_exit','exit':true}," +
                "{'name':'l0010','linaddr':4096,'stms':[" +
                "[0,'call','sub',0,0,['r1','r2']['f1']],[1,'ret','f1']]," +
                "'succ':['main_exit']}]}";

            var sExpSub =
                "{" +
                "'name':'sub','signature':'','ids':[" +
                "{'name':'f1','type':'w64','stg':{'kind':'reg','name':'f1'}}," +
                "{'name':'Mem0','stg':{'kind':'mem'}}," +
                "{'name':'r1','type':'w32','stg':{'kind':'reg','name':'r1'}}," +
                "{'name':'r2','type':'w32','stg':{'kind':'reg','name':'r2'}}]," +
                "'blocks':[" +
                "{'name':'sub_entry','succ':['l1000']}," +
                "{'name':'sub_exit','exit':true}," +
                "{'name':'l1000','linaddr':8192,'stms':[" +
                "[0,'=','f1',['cos',['m','Mem0','r1','r64']]," +
                "[1,'=','f1',['sin',['m','Mem0','r2','r64']]," +
                "[2,'=','f1',['-f','f1','f1']],[3,'ret','f1']]," +
                "'succ':['sub_exit']}]}";

            var sin = new ExternalProcedure("sin", new FunctionType(
                                                new Identifier("", PrimitiveType.Real64, null),
                                                new Identifier("arg", PrimitiveType.Real64, null)));
            var cos = new ExternalProcedure("cos", new FunctionType(
                                                new Identifier("", PrimitiveType.Real64, null),
                                                new Identifier("arg", PrimitiveType.Real64, null)));

            pb.Add("main", m =>
            {
                var r1 = m.Reg32("r1", 1);
                var r2 = m.Reg32("r2", 2);
                var f1 = m.Reg64("f1", 2);
                var f3 = m.Reg64("f3", 3);
                var SZ = m.Flags("SZ");
                m.Label("l0010");
                m.Call("sub", 0, new[] { r1, r2 }, new[] { f1 });
                m.Return(f1);
            });
            pb.Add("sub", m =>
            {
                var r1 = m.Reg32("r1", 1);
                var r2 = m.Reg32("r2", 2);
                var f1 = m.Reg64("f1", 2);
                var f2 = m.Reg64("f1", 2);
                m.Label("l1000");
                m.Assign(f1, m.Fn(cos, m.Load(PrimitiveType.Real64, r1)));
                m.Assign(f2, m.Fn(sin, m.Load(PrimitiveType.Real64, r2)));
                m.Assign(f1, m.FSub(f1, f2));
                m.Return(f1);
            });
            pb.BuildProgram();
            RunTest(sExpMain, pb.Program.Procedures.Values[0]);
            RunTest(sExpSub, pb.Program.Procedures.Values[1]);
        }
Example #21
0
 public Application Fn(ExternalProcedure ep, params Expression[] args)
 {
     return new Application(
         new ProcedureConstant(PrimitiveType.Pointer32, ep), 
         ep.Signature.ReturnValue.DataType,
         args);
 }
Example #22
0
 private void When_Lookup_Procedure(string moduleName, string procName)
 {
     this.extProc = this.win32.LookupProcedureByName(moduleName, procName);
 }
Example #23
0
 public Application Fn(ExternalProcedure ep, params Expression[] args)
 {
     var retType = ep.Signature.ReturnValue != null
         ? ep.Signature.ReturnValue.DataType
         : VoidType.Instance;
     return new Application(
         new ProcedureConstant(PrimitiveType.Pointer32, ep), 
         retType,
         args);
 }