def symbolic_run(
self, fn: Callable[[TrackingStateSpace], object]
) -> Tuple[object, Optional[BaseException], TrackingStateSpace]:
search_root = SinglePathNode(True)
with Patched(enabled=lambda: True):
for itr in range(1, 200):
debug('iteration', itr)
space = TrackingStateSpace(time.monotonic() + 10.0,
1.0,
search_root=search_root)
try:
with StateSpaceContext(space):
ret = (realize(fn(space)), None, space)
space.check_deferred_assumptions()
return ret
except IgnoreAttempt as e:
debug('ignore iteration attempt: ', str(e))
pass
except BaseException as e:
debug(traceback.format_exc())
return (None, e, space)
top_analysis, space_exhausted = space.bubble_status(
CallAnalysis())
if space_exhausted:
return (
None,
CrosshairInternal(f'exhausted after {itr} iterations'),
space)
return (None,
CrosshairInternal(
'Unable to find a successful symbolic execution'), space)
def symbolic_run(
self, fn: Callable[[TrackingStateSpace], bool]
) -> Tuple[object, Optional[BaseException]]:
search_root = SinglePathNode(True)
patched_builtins = PatchedBuiltins(contracted_builtins.__dict__,
enabled=lambda: True)
with patched_builtins:
for itr in range(1, 200):
debug('iteration', itr)
space = TrackingStateSpace(time.time() + 10.0,
1.0,
search_root=search_root)
try:
return (realize(fn(space)), None)
except IgnoreAttempt as e:
debug('ignore iteration attempt: ', str(e))
pass
except BaseException as e:
#traceback.print_exc()
return (None, e)
top_analysis, space_exhausted = space.bubble_status(
CallAnalysis())
if space_exhausted:
return (
None,
CrosshairInternal(f'exhausted after {itr} iterations'))
return (None,
CrosshairInternal(
'Unable to find a successful symbolic execution'))
def symbolic_run(
self, fn: Callable[[TrackingStateSpace], bool]
) -> Tuple[object, Optional[BaseException]]:
search_root = SinglePathNode(True)
itr = 0
for _ in range(200):
itr += 1
space = TrackingStateSpace(time.time() + 10.0,
1.0,
search_root=search_root)
try:
return (realize(fn(space)), None)
except IgnoreAttempt:
pass
except BaseException as e:
#import traceback
#traceback.print_exc()
return (None, e)
top_analysis, space_exhausted = space.bubble_status(CallAnalysis())
if space_exhausted:
return (None,
CrosshairInternal(f'exhausted after {itr} iterations'))
return (None,
CrosshairInternal(
'Unable to find a successful symbolic execution'))
def symbolic_run(
self,
fn: Callable[[StateSpace, Dict[str, object]], object],
typed_args: Dict[str, type],
) -> Tuple[object, # return value
Optional[Dict[str, object]], # arguments after execution
Optional[BaseException], # exception thrown, if any
StateSpace, ]:
search_root = SinglePathNode(True)
with COMPOSITE_TRACER, Patched():
for itr in range(1, 200):
debug("iteration", itr)
space = StateSpace(time.monotonic() + 10.0,
1.0,
search_root=search_root)
symbolic_args = {}
try:
with StateSpaceContext(space):
symbolic_args = {
name: proxy_for_type(typ, name)
for name, typ in typed_args.items()
}
ret = fn(space, symbolic_args)
ret = (deep_realize(ret), symbolic_args, None, space)
space.check_deferred_assumptions()
return ret
except IgnoreAttempt as e:
debug("ignore iteration attempt: ", str(e))
pass
except BaseException as e:
debug(traceback.format_exc())
return (None, symbolic_args, e, space)
top_analysis, space_exhausted = space.bubble_status(
CallAnalysis())
if space_exhausted:
return (
None,
symbolic_args,
CrosshairInternal(f"exhausted after {itr} iterations"),
space,
)
return (
None,
None,
CrosshairInternal(
"Unable to find a successful symbolic execution"),
space,
)