def f(n, m, p):
while n > 0:
myjitdriver.can_enter_jit(n=n, p=p, m=m)
myjitdriver.jit_merge_point(n=n, p=p, m=m)
assert p > -1
assert p < 1
n0 = n
n -= jit.conditional_call_elidable(p, externfn, n0)
n -= jit.conditional_call_elidable(p, externfn, n0)
return n
def f(n, m, p):
while n > 0:
myjitdriver.can_enter_jit(n=n, p=p, m=m)
myjitdriver.jit_merge_point(n=n, p=p, m=m)
assert p > -1
assert p < 1
n0 = n
n -= jit.conditional_call_elidable(p, externfn, n0)
n -= jit.conditional_call_elidable(p, externfn, n0)
return n
def f(n, m, p):
while n > 0:
myjitdriver.can_enter_jit(n=n, p=p, m=m)
myjitdriver.jit_merge_point(n=n, p=p, m=m)
p = jit.conditional_call_elidable(p, externfn, m)
n -= p
return n
def main(n):
if n == 10:
l = []
else:
l = None
l = jit.conditional_call_elidable(l, f, n)
return len(l)
def main(n):
if n == 10:
l = []
else:
l = None
l = jit.conditional_call_elidable(l, f, n)
return len(l)
def f(n, m, p):
while n > 0:
myjitdriver.can_enter_jit(n=n, p=p, m=m)
myjitdriver.jit_merge_point(n=n, p=p, m=m)
p = jit.conditional_call_elidable(p, externfn, m)
n -= p
return n
def size(self):
sz = jit.conditional_call_elidable(self._exposed_size,
calculate_exposed_size_for_big_int,
self.value)
if not jit.isconstant(self):
self._exposed_size = sz
return sz
def size(self):
sz = jit.conditional_call_elidable(
self._exposed_size,
calculate_exposed_size_for_big_int,
self.value)
if not jit.isconstant(self):
self._exposed_size = sz
return sz
def f(n, m, p):
while n > 0:
myjitdriver.can_enter_jit(n=n, p=p, m=m)
myjitdriver.jit_merge_point(n=n, p=p, m=m)
if n > 6: # will fail and finish in the blackhole
pass
if jit.we_are_jitted(): # manually inline here
p = jit._jit_conditional_call_value(p, externfn, m)
else:
p = jit.conditional_call_elidable(p, externfn, m)
n -= p
return n
def f(n, m, p):
while n > 0:
myjitdriver.can_enter_jit(n=n, p=p, m=m)
myjitdriver.jit_merge_point(n=n, p=p, m=m)
try:
p = jit.conditional_call_elidable(p, externfn, n, m)
p -= (n + m) # => zero again
except ValueError:
m += 1000
m += 1
n -= 2
return n * m
def f(n, m, p):
while n > 0:
myjitdriver.can_enter_jit(n=n, p=p, m=m)
myjitdriver.jit_merge_point(n=n, p=p, m=m)
try:
p = jit.conditional_call_elidable(p, externfn, n, m)
p -= (n + m) # => zero again
except ValueError:
m += 1000
m += 1
n -= 2
return n * m
def f(n, m, p):
while n > 0:
myjitdriver.can_enter_jit(n=n, p=p, m=m)
myjitdriver.jit_merge_point(n=n, p=p, m=m)
if n > 6: # will fail and finish in the blackhole
pass
if jit.we_are_jitted(): # manually inline here
p = jit._jit_conditional_call_value(p, externfn, m)
else:
p = jit.conditional_call_elidable(p, externfn, m)
n -= p
return n
def text_w(self, space):
try:
identifier = jit.conditional_call_elidable(self._utf8,
g_encode_utf8,
self._value)
except SurrogateError as e:
raise OperationError(
space.w_UnicodeEncodeError,
space.newtuple([
space.newtext('utf-8'), self,
space.newint(e.index - 1),
space.newint(e.index),
space.newtext("surrogates not allowed")
]))
if not jit.isconstant(self):
self._utf8 = identifier
return identifier
def main(n):
# this is completely constant-folded because the arguments
# to f() are constants.
return jit.conditional_call_elidable(n, f, 40, 2)
def f(n, x, y):
return conditional_call_elidable(n, g, x, y)
def main(n, m):
return jit.conditional_call_elidable(n, f, m)
def main(n, m):
return jit.conditional_call_elidable(n, f, m)
def main(n):
# this is completely constant-folded because the arguments
# to f() are constants.
return jit.conditional_call_elidable(n, f, 40, 2)
def getclass(self, space):
return jit.conditional_call_elidable(self.w_class, _initialize_w_class,
self)
def ll_strhash(s):
if s:
return jit.conditional_call_elidable(s.hash,
LLHelpers._ll_strhash, s)
else:
return 0
def f(x, n):
y = conditional_call_elidable(x, g, n)
return y # now, y is known to be non-null, even if x can be
def get_triple(self):
res = jit.conditional_call_elidable(self.triple,
_compute_triple,
self.value)
self.triple = res
return res
def getclass(self, space):
return jit.conditional_call_elidable(
self.w_class, _initialize_w_class, self)
def get_triple(self):
return jit.conditional_call_elidable(self.triple,
X._compute_triple, self)
def f(x, n):
y = conditional_call_elidable(x, g, n)
return y # now, y is known to be non-null, even if x can be
def get_triple(self):
return jit.conditional_call_elidable(self.triple,
X._compute_triple, self)
def f(n, x, y):
return conditional_call_elidable(n, g, x, y)
def get_triple(self):
res = jit.conditional_call_elidable(self.triple,
_compute_triple, self.value)
self.triple = res
return res
def ll_strhash(s):
if s:
return jit.conditional_call_elidable(s.hash, LLHelpers._ll_strhash,
s)
else:
return 0
def gethash(self):
return jit.conditional_call_elidable(self.hash, calculate_and_cache, self)
