def symex_step(self, art): # Pick out src obj gss = art.get_cur_state().get_active_state() src = gss.source # pc becomes an insn number, lookup insns. Select current insn insns = src.prog.get_instructions() localpc = src.pc - insns[0].location_number insn = src.prog.get_instructions()[localpc] normal = True if insn.type == gptypes.FUNCTION_CALL: # Pick out function calls call = esbmc.downcast_expr(insn.code) sym = esbmc.downcast_expr(call.function) # Pick out the desired function if sym.name.as_string() == 'c::foobar': # Build a constant for 'one' bigint = esbmc.BigInt(1) ubv = esbmc.type.unsignedbv.make(32) one = esbmc.expr.constant_int.make(ubv, bigint) # Assign one to the given return symbol exobj.symex_assign_symbol(call.return_sym, one, gss.guard) # Increment the program counter _past_ the call we just # interpreted, set normal to indicate this shouldn't be # interpreted by the usual symex_step operation. src.pc += 1 normal = False if normal: super(ExState2, self).symex_step(art)
def test_iter_detach(self): import esbmc # Build a nontrivial expr foo = self.make_int() ubv = self.make_unsigned() idt = esbmc.irep_idt("fgasfd") lev = esbmc.expr.symbol_renaming.level0 sym = esbmc.expr.symbol.make(ubv, idt, lev, 0, 0, 0, 0) add = esbmc.expr.add.make(ubv, foo, sym) addclone = add.clone() it = iter(addclone) obj1 = next(it) self.assertTrue(obj1 == foo, "Object iterator obj1 not as expected") obj2 = next(it) self.assertTrue(obj2 == sym, "Object iterator obj2 not as expected") try: next(it) self.assertTrue( False, "Object iterator should not have completed 3rd time") except StopIteration: pass obj2 = esbmc.downcast_expr(obj2) self.assertTrue(esbmc.expr.expr_ids.symbol == obj2.expr_id, "Downcasted symbol should be sym id'd") obj2.iknowwhatimdoing_level2_num = 1 self.assertTrue(obj2.level2_num != sym.level2_num, "Iterated object should have detached from original")
def test_iter_detach(self): import esbmc # Build a nontrivial expr foo = self.make_int() ubv = self.make_unsigned() idt = esbmc.irep_idt("fgasfd") lev = esbmc.expr.symbol_renaming.level0 sym = esbmc.expr.symbol.make(ubv, idt, lev, 0, 0, 0, 0) add = esbmc.expr.add.make(ubv, foo, sym) addclone = add.clone() it = iter(addclone) obj1 = next(it) self.assertTrue(obj1 == foo, "Object iterator obj1 not as expected") obj2 = next(it) self.assertTrue(obj2 == sym, "Object iterator obj2 not as expected") try: next(it) self.assertTrue(False, "Object iterator should not have completed 3rd time") except StopIteration: pass obj2 = esbmc.downcast_expr(obj2) self.assertTrue(esbmc.expr.expr_ids.symbol == obj2.expr_id, "Downcasted symbol should be sym id'd") obj2.iknowwhatimdoing_level2_num = 1 self.assertTrue(obj2.level2_num != sym.level2_num, "Iterated object should have detached from original")
def test_first_insn(self): import esbmc theinsn = self.insns[0] self.assertTrue(theinsn.type == esbmc.goto_programs.goto_program_instruction_type.OTHER, "Wrong insn type") code = esbmc.downcast_expr(theinsn.code) self.assertTrue(code.expr_id == esbmc.expr.expr_ids.code_decl, "decl insn has wrong expr type") self.assertTrue(code.value.as_string() == "main::main::1::i", "decl insn has wrong expr value") self.assertTrue(theinsn.function.as_string() == "main", "decl insn has wrong function name")
def test_downcast(self): import esbmc val = self.make_int(1) val1 = self.make_int(2) add = esbmc.expr.add.make(val.type, val, val1) # Fields should all have type expr2t self.assertTrue(type(add.side_1) == esbmc.expr.expr2t, "Wrong field type in expr") downcasted = esbmc.downcast_expr(add.side_1) self.assertTrue(type(downcasted) == esbmc.expr.constant_int, "Downcast failed") # Should be brought into python as a different object self.assertFalse(downcasted is val, "downcasted object should be new pyref")
def test_downcast(self): import esbmc val = self.make_int(1) val1 = self.make_int(2) add = esbmc.expr.add.make(val.type, val, val1) # Fields should all have type expr2t self.assertTrue(type(add.side_1) == esbmc.expr.expr2t, "Wrong field type in expr") downcasted = esbmc.downcast_expr(add.side_1) self.assertTrue(type(downcasted) == esbmc.expr.constant_int, "Downcast failed") # Should be brought into python as a different object self.assertFalse(downcasted is val, "downcasted object should be new pyref")
def test_first_insn(self): import esbmc theinsn = self.insns[0] self.assertTrue( theinsn.type == esbmc.goto_programs.goto_program_instruction_type.OTHER, "Wrong insn type") code = esbmc.downcast_expr(theinsn.code) self.assertTrue(code.expr_id == esbmc.expr.expr_ids.code_decl, "decl insn has wrong expr type") self.assertTrue(code.value.as_string() == "main::main::1::i", "decl insn has wrong expr value") self.assertTrue(theinsn.function.as_string() == "main", "decl insn has wrong function name")
def test_sym_compare(self): import esbmc # Build an expr we indirectly access and a symbol foo = self.make_int() ubv = self.make_unsigned() add = esbmc.expr.add.make(ubv, foo, foo) idt = esbmc.irep_idt("fgasfd") lev = esbmc.expr.symbol_renaming.level0 sym = esbmc.expr.symbol.make(ubv, idt, lev, 0, 0, 0, 0) # Problem: when we downcast this b.p knows that 'sym' is a symbol2tc. # But it doesn't know for some reason that it can just cast that to # a expr2tc, via inheritance. Test for this -- __eq__ returns # NotImplemented when the operator== call construction fails. sym = esbmc.downcast_expr(sym) foo2 = add.side_1 self.assertFalse(foo2.__eq__(sym) == NotImplemented, "Downcasted expr should be castable to expr2tc")
def test_more_fields(self): import esbmc theinsn = self.insns[0] self.assertTrue(esbmc.downcast_expr(theinsn.guard).value == True, "insn guard should be true") # No access to labels field right no # This has the value 99 right now, but we can't really assert that # because it'll change when we edit... anything self.assertTrue(theinsn.location_number > 0, "Wrong insn number") self.assertTrue(theinsn.loop_number == 0, "Loop number doesn't exist?") # This seems to be a useless field self.assertTrue(theinsn.target_number == 4294967295, "Target number doesn't exist?") norm = theinsn.to_string() wloc = theinsn.to_string(True) self.assertTrue(norm != wloc, "var changing flags should change to_string output") self.assertTrue(theinsn.is_other(), "is_other method of insn should work")
def test_sym_compare(self): import esbmc # Build an expr we indirectly access and a symbol foo = self.make_int() ubv = self.make_unsigned() add = esbmc.expr.add.make(ubv, foo, foo) idt = esbmc.irep_idt("fgasfd") lev = esbmc.expr.symbol_renaming.level0 sym = esbmc.expr.symbol.make(ubv, idt, lev, 0, 0, 0, 0) # Problem: when we downcast this b.p knows that 'sym' is a symbol2tc. # But it doesn't know for some reason that it can just cast that to # a expr2tc, via inheritance. Test for this -- __eq__ returns # NotImplemented when the operator== call construction fails. sym = esbmc.downcast_expr(sym) foo2 = add.side_1 self.assertFalse(foo2.__eq__(sym) == NotImplemented, "Downcasted expr should be castable to expr2tc")
def test_more_fields(self): import esbmc theinsn = self.insns[0] self.assertTrue( esbmc.downcast_expr(theinsn.guard).value == True, "insn guard should be true") # No access to labels field right no # This has the value 99 right now, but we can't really assert that # because it'll change when we edit... anything self.assertTrue(theinsn.location_number > 0, "Wrong insn number") self.assertTrue(theinsn.loop_number == 0, "Loop number doesn't exist?") # This seems to be a useless field self.assertTrue(theinsn.target_number == 4294967295, "Target number doesn't exist?") norm = theinsn.to_string() wloc = theinsn.to_string(True) self.assertTrue(norm != wloc, "var changing flags should change to_string output") self.assertTrue(theinsn.is_other(), "is_other method of insn should work")
def test_downcast_none(self): import esbmc downcasted = esbmc.downcast_expr(None) self.assertTrue(downcasted == None, "Downcast of none should be none")
def test_downcast_none(self): import esbmc downcasted = esbmc.downcast_expr(None) self.assertTrue(downcasted == None, "Downcast of none should be none")