code stringlengths 1 1.72M | language stringclasses 1
value |
|---|---|
class _R(int):
def __repr__(self):
return "r%s"%(super(_R, self).__repr__(),)
__str__ = __repr__
class _F(int):
def __repr__(self):
return "fr%s"%(super(_F, self).__repr__(),)
__str__ = __repr__
r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, \
r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, \
r23, r24, r25, r26, r27, r28, r29, r30, r31 = map(_R, range(32))
fr0, fr1, fr2, fr3, fr4, fr5, fr6, fr7, fr8, fr9, fr10, fr11, fr12, \
fr13, fr14, fr15, fr16, fr17, fr18, fr19, fr20, fr21, fr22, \
fr23, fr24, fr25, fr26, fr27, fr28, fr29, fr30, fr31 = map(_F, range(32))
crf0, crf1, crf2, crf3, crf4, crf5, crf6, crf7 = range(8)
| Python |
# XXX there is much grot here.
# some of this comes from trying to present a reasonably intuitive and
# useful interface, which implies a certain amount of DWIMmery.
# things surely still could be more transparent.
class FormException(Exception):
pass
class Instruction(object):
def __init__(self, fields):
self.fields = fields
self.lfields = [k for (k,v) in fields.iteritems()
if isinstance(v, str)]
if not self.lfields:
self.assemble() # for error checking only
def assemble(self):
r = 0
for field in self.fields:
r |= field.encode(self.fields[field])
return r
class IBoundDesc(object):
def __init__(self, desc, fieldmap, assembler):
self.fieldmap = fieldmap
self.desc = desc
self.assembler = assembler
def calc_fields(self, args, kw):
fieldsleft = list(self.desc.fields)
fieldvalues = {}
for fname in kw:
kw[fname] = self.fieldmap[fname]
for d in (self.desc.specializations, kw):
for field in d:
fieldsleft.remove(field)
fieldvalues[field] = d[field]
for i in range(min(len(self.desc.defaults), len(fieldsleft) - len(args))):
f, v = self.desc.defaults[i]
fieldvalues[f] = v
fieldsleft.remove(f)
for a in args:
field = fieldsleft.pop(0)
fieldvalues[field] = a
return fieldvalues, fieldsleft
def __call__(self, *args, **kw):
fieldvalues, sparefields = self.calc_fields(args, kw)
if sparefields:
raise FormException, 'fields %s left'%sparefields
self.assembler.insts.append(Instruction(fieldvalues))
class IBoundDupDesc(IBoundDesc):
def calc_fields(self, args, kw):
s = super(IBoundDupDesc, self)
fieldvalues, sparefields = s.calc_fields(args, kw)
for k, v in self.desc.dupfields.iteritems():
fieldvalues[k] = fieldvalues[v]
return fieldvalues, sparefields
class IDesc(object):
boundtype = IBoundDesc
def __init__(self, fieldmap, fields, specializations, boundtype=None):
self.fieldmap = fieldmap
self.fields = fields
self.specializations = specializations
self.defaults = ()
if boundtype is not None:
self.boundtype = boundtype
for field in specializations:
if field not in fields:
raise FormException, field
def __get__(self, ob, cls=None):
if ob is None: return self
return self.boundtype(self, self.fieldmap, ob)
def default(self, **defs):
assert len(defs) == 1
f, v = defs.items()[0]
self.defaults = self.defaults + ((self.fieldmap[f], v),)
return self
def __call__(self, **more_specializatons):
s = self.specializations.copy()
ms = {}
ds = {}
for fname, v in more_specializatons.iteritems():
field = self.fieldmap[fname]
if field not in self.fields:
raise FormException, "don't know about '%s' here"%k
if isinstance(v, str):
ds[field] = self.fieldmap[v]
else:
ms[field] = v
s.update(ms)
if len(s) != len(self.specializations) + len(ms):
raise FormException, "respecialization not currently allowed"
if ds:
fields = list(self.fields)
for field in ds:
fields.remove(field)
return IDupDesc(self.fieldmap, tuple(fields), s, ds)
else:
r = IDesc(self.fieldmap, self.fields, s, self.boundtype)
r.defaults = tuple([(f, d) for (f, d) in self.defaults if f not in s])
return r
def match(self, inst):
c = 0
for field in self.fields:
if field in self.specializations:
if field.decode(inst) != self.specializations[field]:
return 0
else:
c += 1
return c
def __repr__(self):
l = []
for field in self.fields:
if field in self.specializations:
l.append('%s=%r'%(field.name, self.specializations[field]))
else:
l.append(field.name)
r = '%s(%s)'%(self.__class__.__name__, ', '.join(l))
if self.boundtype is not self.__class__.boundtype:
r += ' => ' + self.boundtype.__name__
return r
def disassemble(self, name, inst, labels, pc):
kws = []
for field in self.fields:
if field not in self.specializations:
v = field.decode(inst)
for f, d in self.defaults:
if f is field:
if d == v:
break
else:
kws.append('%s=%s'%(field.name, field.r(inst, labels, pc)))
return "%-5s %s"%(name, ', '.join(kws))
class IDupDesc(IDesc):
boundtype = IBoundDupDesc
def __init__(self, fieldmap, fields, specializations, dupfields):
super(IDupDesc, self).__init__(fieldmap, fields, specializations)
self.dupfields = dupfields
def match(self, inst):
for field in self.dupfields:
df = self.dupfields[field]
if field.decode(inst) != df.decode(inst):
return 0
else:
return super(IDupDesc, self).match(inst)
class Form(object):
fieldmap = None
def __init__(self, *fnames):
self.fields = []
bits = {}
for fname in fnames:
if isinstance(fname, str):
field = self.fieldmap[fname]
else:
field = fname
for b in range(field.left, field.right+1):
if b in bits:
raise FormException, "'%s' and '%s' clash at bit '%s'"%(
bits[b], fname, b)
else:
bits[b] = fname
self.fields.append(field)
def __call__(self, **specializations):
s = {}
for fname in specializations:
field = self.fieldmap[fname]
if field not in self.fields:
raise FormException, "no nothin bout '%s'"%k
s[field] = specializations[fname]
return IDesc(self.fieldmap, self.fields, s)
def __repr__(self):
return '%s(%r)'%(self.__class__.__name__, [f.name for f in self.fields])
| Python |
from pypy.tool.sourcetools import compile2
from pypy.rlib.rarithmetic import r_uint
from pypy.jit.codegen.ppc.ppcgen.form import IDesc, IDupDesc
## "opcode": ( 0, 5),
## "rA": (11, 15, 'unsigned', regname._R),
## "rB": (16, 20, 'unsigned', regname._R),
## "Rc": (31, 31),
## "rD": ( 6, 10, 'unsigned', regname._R),
## "OE": (21, 21),
## "XO2": (22, 30),
## XO = Form("rD", "rA", "rB", "OE", "XO2", "Rc")
## add = XO(31, XO2=266, OE=0, Rc=0)
## def add(rD, rA, rB):
## v = 0
## v |= (31&(2**(5-0+1)-1)) << (32-5-1)
## ...
## return v
def make_func(name, desc):
sig = []
fieldvalues = []
for field in desc.fields:
if field in desc.specializations:
fieldvalues.append((field, desc.specializations[field]))
else:
sig.append(field.name)
fieldvalues.append((field, field.name))
if isinstance(desc, IDupDesc):
for destfield, srcfield in desc.dupfields.iteritems():
fieldvalues.append((destfield, srcfield.name))
body = ['v = r_uint(0)']
assert 'v' not in sig # that wouldn't be funny
#body.append('print %r'%name + ', ' + ', '.join(["'%s:', %s"%(s, s) for s in sig]))
for field, value in fieldvalues:
if field.name == 'spr':
body.append('spr = (%s&31) << 5 | (%s >> 5 & 31)'%(value, value))
value = 'spr'
body.append('v |= (%3s & r_uint(%#05x)) << %d'%(value,
field.mask,
(32 - field.right - 1)))
body.append('self.emit(v)')
src = 'def %s(self, %s):\n %s'%(name, ', '.join(sig), '\n '.join(body))
d = {'r_uint':r_uint}
#print src
exec compile2(src) in d
return d[name]
def make_rassembler(cls):
bases = [make_rassembler(b) for b in cls.__bases__]
ns = {}
for k, v in cls.__dict__.iteritems():
if isinstance(v, IDesc):
v = make_func(k, v)
ns[k] = v
rcls = type('R' + cls.__name__, tuple(bases), ns)
def emit(self, value):
self.insts.append(value)
rcls.emit = emit
return rcls
| Python |
from pypy.jit.codegen.ppc.ppcgen.field import Field
from pypy.jit.codegen.ppc.ppcgen import regname
fields = { # bit margins are *inclusive*! (and bit 0 is
# most-significant, 31 least significant)
"opcode": ( 0, 5),
"AA": (30, 30),
"BD": (16, 29, 'signed'),
"BI": (11, 15),
"BO": ( 6, 10),
"crbA": (11, 15),
"crbB": (16, 20),
"crbD": ( 6, 10),
"crfD": ( 6, 8),
"crfS": (11, 13),
"CRM": (12, 19),
"d": (16, 31, 'signed'),
"FM": ( 7, 14),
"frA": (11, 15, 'unsigned', regname._F),
"frB": (16, 20, 'unsigned', regname._F),
"frC": (21, 25, 'unsigned', regname._F),
"frD": ( 6, 10, 'unsigned', regname._F),
"frS": ( 6, 10, 'unsigned', regname._F),
"IMM": (16, 19),
"L": (10, 10),
"LI": ( 6, 29, 'signed'),
"LK": (31, 31),
"MB": (21, 25),
"ME": (26, 30),
"NB": (16, 20),
"OE": (21, 21),
"rA": (11, 15, 'unsigned', regname._R),
"rB": (16, 20, 'unsigned', regname._R),
"Rc": (31, 31),
"rD": ( 6, 10, 'unsigned', regname._R),
"rS": ( 6, 10, 'unsigned', regname._R),
"SH": (16, 20),
"SIMM": (16, 31, 'signed'),
"SR": (12, 15),
"spr": (11, 20),
"TO": ( 6, 10),
"UIMM": (16, 31),
"XO1": (21, 30),
"XO2": (22, 30),
"XO3": (26, 30),
}
class IField(Field):
def __init__(self, name, left, right, signedness):
assert signedness == 'signed'
super(IField, self).__init__(name, left, right, signedness)
def encode(self, value):
# XXX should check range
value &= self.mask << 2 | 0x3
return value & ~0x3
def decode(self, inst):
mask = self.mask << 2
v = inst & mask
if self.signed and (~mask >> 1) & mask & v:
return ~(~v&self.mask)
else:
return v
def r(self, i, labels, pc):
if not ppc_fields['AA'].decode(i):
v = self.decode(i)
if pc+v in labels:
return "%s (%r)"%(v, ', '.join(labels[pc+v]))
else:
return self.decode(i)
class spr(Field):
def encode(self, value):
value = (value&31) << 5 | (value >> 5 & 31)
return super(spr, self).encode(value)
def decode(self, inst):
value = super(spr, self).decode(inst)
return (value&31) << 5 | (value >> 5 & 31)
# other special fields?
ppc_fields = {
"LI": IField("LI", *fields["LI"]),
"BD": IField("BD", *fields["BD"]),
"spr": spr("spr", *fields["spr"]),
}
for f in fields:
if f not in ppc_fields:
ppc_fields[f] = Field(f, *fields[f])
| Python |
from pypy.jit.codegen.ppc.ppcgen.ppc_form import PPCForm as Form
from pypy.jit.codegen.ppc.ppcgen.ppc_field import ppc_fields
from pypy.jit.codegen.ppc.ppcgen.assembler import Assembler
from pypy.jit.codegen.ppc.ppcgen.symbol_lookup import lookup
A = Form("frD", "frA", "frB", "XO3", "Rc")
A1 = Form("frD", "frB", "XO3", "Rc")
A2 = Form("frD", "frA", "frC", "XO3", "Rc")
A3 = Form("frD", "frA", "frC", "frB", "XO3", "Rc")
I = Form("LI", "AA", "LK")
B = Form("BO", "BI", "BD", "AA", "LK")
SC = Form("AA") # fudge
DD = Form("rD", "rA", "SIMM")
DS = Form("rA", "rS", "UIMM")
X = Form("XO1")
XS = Form("rA", "rS", "rB", "XO1", "Rc")
XSO = Form("rS", "rA", "rB", "XO1")
XD = Form("rD", "rA", "rB", "XO1")
XO = Form("rD", "rA", "rB", "OE", "XO2", "Rc")
XO0 = Form("rD", "rA", "OE", "XO2", "Rc")
XDB = Form("frD", "frB", "XO1", "Rc")
XS0 = Form("rA", "rS", "XO1", "Rc")
X0 = Form("rA", "rB", "XO1")
XcAB = Form("crfD", "rA", "rB", "XO1")
XN = Form("rD", "rA", "NB", "XO1")
XL = Form("crbD", "crbA", "crbB", "XO1")
XL1 = Form("crfD", "crfS")
XL2 = Form("crbD", "XO1", "Rc")
XFL = Form("FM", "frB", "XO1", "Rc")
XFX = Form("CRM", "rS", "XO1")
MI = Form("rA", "rS", "SH", "MB", "ME", "Rc")
MB = Form("rA", "rS", "rB", "MB", "ME", "Rc")
class BasicPPCAssembler(Assembler):
def disassemble(cls, inst, labels={}, pc=0):
cache = cls.__dict__.get('idesc cache')
if cache is None:
idescs = cls.get_idescs()
cache = {}
for n, i in idescs:
cache.setdefault(i.specializations[ppc_fields['opcode']],
[]).append((n,i))
setattr(cls, 'idesc cache', cache)
matches = []
idescs = cache[ppc_fields['opcode'].decode(inst)]
for name, idesc in idescs:
m = idesc.match(inst)
if m > 0:
matches.append((m, idesc, name))
if matches:
score, idesc, name = max(matches)
return idesc.disassemble(name, inst, labels, pc)
disassemble = classmethod(disassemble)
# "basic" means no simplified mnemonics
# I form
b = I(18, AA=0, LK=0)
ba = I(18, AA=1, LK=0)
bl = I(18, AA=0, LK=1)
bla = I(18, AA=1, LK=1)
# B form
bc = B(16, AA=0, LK=0)
bcl = B(16, AA=0, LK=1)
bca = B(16, AA=1, LK=0)
bcla = B(16, AA=1, LK=1)
# SC form
sc = SC(17, AA=1) # it's not really the aa field...
# D form
addi = DD(14)
addic = DD(12)
addicx = DD(13)
addis = DD(15)
andix = DS(28)
andisx = DS(29)
cmpi = Form("crfD", "L", "rA", "SIMM")(11)
cmpi.default(L=0).default(crfD=0)
cmpli = Form("crfD", "L", "rA", "UIMM")(10)
cmpli.default(L=0).default(crfD=0)
lbz = DD(34)
lbzu = DD(35)
lfd = DD(50)
lfdu = DD(51)
lfs = DD(48)
lfsu = DD(49)
lha = DD(42)
lhau = DD(43)
lhz = DD(40)
lhzu = DD(41)
lmw = DD(46)
lwz = DD(32)
lwzu = DD(33)
mulli = DD(7)
ori = DS(24)
oris = DS(25)
stb = DD(38)
stbu = DD(39)
stfd = DD(54)
stfdu = DD(55)
stfs = DD(52)
stfsu = DD(53)
sth = DD(44)
sthu = DD(45)
stmw = DD(47)
stw = DD(36)
stwu = DD(37)
subfic = DD(8)
twi = Form("TO", "rA", "SIMM")(3)
xori = DS(26)
xoris = DS(27)
# X form
and_ = XS(31, XO1=28, Rc=0)
and_x = XS(31, XO1=28, Rc=1)
andc_ = XS(31, XO1=60, Rc=0)
andc_x = XS(31, XO1=60, Rc=1)
# is the L bit for 64 bit compares? hmm
cmp = Form("crfD", "L", "rA", "rB", "XO1")(31, XO1=0)
cmp.default(L=0).default(crfD=0)
cmpl = Form("crfD", "L", "rA", "rB", "XO1")(31, XO1=32)
cmpl.default(L=0).default(crfD=0)
cntlzw = XS0(31, XO1=26, Rc=0)
cntlzwx = XS0(31, XO1=26, Rc=1)
dcba = X0(31, XO1=758)
dcbf = X0(31, XO1=86)
dcbi = X0(31, XO1=470)
dcbst = X0(31, XO1=54)
dcbt = X0(31, XO1=278)
dcbtst = X0(31, XO1=246)
dcbz = X0(31, XO1=1014)
eciwx = XD(31, XO1=310)
ecowx = XS(31, XO1=438, Rc=0)
eieio = X(31, XO1=854)
eqv = XS(31, XO1=284, Rc=0)
eqvx = XS(31, XO1=284, Rc=1)
extsb = XS0(31, XO1=954, Rc=0)
extsbx = XS0(31, XO1=954, Rc=1)
extsh = XS0(31, XO1=922, Rc=0)
extshx = XS0(31, XO1=922, Rc=1)
fabs = XDB(63, XO1=264, Rc=0)
fabsx = XDB(63, XO1=264, Rc=1)
fcmpo = XcAB(63, XO1=32)
fcmpu = XcAB(63, XO1=0)
fctiw = XDB(63, XO1=14, Rc=0)
fctiwx = XDB(63, XO1=14, Rc=1)
fctiwz = XDB(63, XO1=14, Rc=0)
fctiwzx = XDB(63, XO1=14, Rc=1)
fmr = XDB(63, XO1=72, Rc=0)
fmrx = XDB(63, XO1=72, Rc=1)
fnabs = XDB(63, XO1=136, Rc=0)
fnabsx = XDB(63, XO1=136, Rc=1)
fneg = XDB(63, XO1=40, Rc=0)
fnegx = XDB(63, XO1=40, Rc=1)
frsp = XDB(63, XO1=12, Rc=0)
frspx = XDB(63, XO1=12, Rc=1)
fsqrt = XDB(63, XO1=22, Rc=0)
icbi = X0(31, XO1=982)
lbzux = XD(31, XO1=119)
lbzx = XD(31, XO1=87)
lfdux = XD(31, XO1=631)
lfdx = XD(31, XO1=599)
lfsux = XD(31, XO1=567)
lfsx = XD(31, XO1=535)
lhaux = XD(31, XO1=375)
lhax = XD(31, XO1=343)
lhbrx = XD(31, XO1=790)
lhzux = XD(31, XO1=311)
lhzx = XD(31, XO1=279)
lswi = XD(31, XO1=597)
lswx = XD(31, XO1=533)
lwarx = XD(31, XO1=20)
lwbrx = XD(31, XO1=534)
lwzux = XD(31, XO1=55)
lwzx = XD(31, XO1=23)
mcrfs = Form("crfD", "crfS", "XO1")(63, XO1=64)
mcrxr = Form("crfD", "XO1")(31, XO1=512)
mfcr = Form("rD", "XO1")(31, XO1=19)
mffs = Form("frD", "XO1", "Rc")(63, XO1=583, Rc=0)
mffsx = Form("frD", "XO1", "Rc")(63, XO1=583, Rc=1)
mfmsr = Form("rD", "XO1")(31, XO1=83)
mfsr = Form("rD", "SR", "XO1")(31, XO1=595)
mfsrin = XDB(31, XO1=659, Rc=0)
add = XO(31, XO2=266, OE=0, Rc=0)
addx = XO(31, XO2=266, OE=0, Rc=1)
addo = XO(31, XO2=266, OE=1, Rc=0)
addox = XO(31, XO2=266, OE=1, Rc=1)
addc = XO(31, XO2=10, OE=0, Rc=0)
addcx = XO(31, XO2=10, OE=0, Rc=1)
addco = XO(31, XO2=10, OE=1, Rc=0)
addcox = XO(31, XO2=10, OE=1, Rc=1)
adde = XO(31, XO2=138, OE=0, Rc=0)
addex = XO(31, XO2=138, OE=0, Rc=1)
addeo = XO(31, XO2=138, OE=1, Rc=0)
addeox = XO(31, XO2=138, OE=1, Rc=1)
addme = XO(31, rB=0, XO2=234, OE=0, Rc=0)
addmex = XO(31, rB=0, XO2=234, OE=0, Rc=1)
addmeo = XO(31, rB=0, XO2=234, OE=1, Rc=0)
addmeox = XO(31, rB=0, XO2=234, OE=1, Rc=1)
addze = XO(31, rB=0, XO2=202, OE=0, Rc=0)
addzex = XO(31, rB=0, XO2=202, OE=0, Rc=1)
addzeo = XO(31, rB=0, XO2=202, OE=1, Rc=0)
addzeox = XO(31, rB=0, XO2=202, OE=1, Rc=1)
bcctr = Form("BO", "BI", "XO1", "LK")(19, XO1=528, LK=0)
bcctrl = Form("BO", "BI", "XO1", "LK")(19, XO1=528, LK=1)
bclr = Form("BO", "BI", "XO1", "LK")(19, XO1=16, LK=0)
bclrl = Form("BO", "BI", "XO1", "LK")(19, XO1=16, LK=1)
crand = XL(19, XO1=257)
crandc = XL(19, XO1=129)
creqv = XL(19, XO1=289)
crnand = XL(19, XO1=225)
crnor = XL(19, XO1=33)
cror = XL(19, XO1=449)
crorc = XL(19, XO1=417)
crxor = XL(19, XO1=193)
divw = XO(31, XO2=491, OE=0, Rc=0)
divwx = XO(31, XO2=491, OE=0, Rc=1)
divwo = XO(31, XO2=491, OE=1, Rc=0)
divwox = XO(31, XO2=491, OE=1, Rc=1)
divwu = XO(31, XO2=459, OE=0, Rc=0)
divwux = XO(31, XO2=459, OE=0, Rc=1)
divwuo = XO(31, XO2=459, OE=1, Rc=0)
divwuox = XO(31, XO2=459, OE=1, Rc=1)
fadd = A(63, XO3=21, Rc=0)
faddx = A(63, XO3=21, Rc=1)
fadds = A(59, XO3=21, Rc=0)
faddsx = A(59, XO3=21, Rc=1)
fdiv = A(63, XO3=18, Rc=0)
fdivx = A(63, XO3=18, Rc=1)
fdivs = A(59, XO3=18, Rc=0)
fdivsx = A(59, XO3=18, Rc=1)
fmadd = A3(63, XO3=19, Rc=0)
fmaddx = A3(63, XO3=19, Rc=1)
fmadds = A3(59, XO3=19, Rc=0)
fmaddsx = A3(59, XO3=19, Rc=1)
fmsub = A3(63, XO3=28, Rc=0)
fmsubx = A3(63, XO3=28, Rc=1)
fmsubs = A3(59, XO3=28, Rc=0)
fmsubsx = A3(59, XO3=28, Rc=1)
fmul = A2(63, XO3=25, Rc=0)
fmulx = A2(63, XO3=25, Rc=1)
fmuls = A2(59, XO3=25, Rc=0)
fmulsx = A2(59, XO3=25, Rc=1)
fnmadd = A3(63, XO3=31, Rc=0)
fnmaddx = A3(63, XO3=31, Rc=1)
fnmadds = A3(59, XO3=31, Rc=0)
fnmaddsx = A3(59, XO3=31, Rc=1)
fnmsub = A3(63, XO3=30, Rc=0)
fnmsubx = A3(63, XO3=30, Rc=1)
fnmsubs = A3(59, XO3=30, Rc=0)
fnmsubsx = A3(59, XO3=30, Rc=1)
fres = A1(59, XO3=24, Rc=0)
fresx = A1(59, XO3=24, Rc=1)
frsp = A1(63, XO3=12, Rc=0)
frspx = A1(63, XO3=12, Rc=1)
frsqrte = A1(63, XO3=26, Rc=0)
frsqrtex = A1(63, XO3=26, Rc=1)
fsel = A3(63, XO3=23, Rc=0)
fselx = A3(63, XO3=23, Rc=1)
frsqrt = A1(63, XO3=22, Rc=0)
frsqrtx = A1(63, XO3=22, Rc=1)
frsqrts = A1(59, XO3=22, Rc=0)
frsqrtsx = A1(59, XO3=22, Rc=1)
fsub = A(63, XO3=20, Rc=0)
fsubx = A(63, XO3=20, Rc=1)
fsubs = A(59, XO3=20, Rc=0)
fsubsx = A(59, XO3=20, Rc=1)
isync = X(19, XO1=150)
mcrf = XL1(19)
mfspr = Form("rD", "spr", "XO1")(31, XO1=339)
mftb = Form("rD", "spr", "XO1")(31, XO1=371)
mtcrf = XFX(31, XO1=144)
mtfsb0 = XL2(63, XO1=70, Rc=0)
mtfsb0x = XL2(63, XO1=70, Rc=1)
mtfsb1 = XL2(63, XO1=38, Rc=0)
mtfsb1x = XL2(63, XO1=38, Rc=1)
mtfsf = XFL(63, XO1=711, Rc=0)
mtfsfx = XFL(63, XO1=711, Rc=1)
mtfsfi = Form("crfD", "IMM", "XO1", "Rc")(63, XO1=134, Rc=0)
mtfsfix = Form("crfD", "IMM", "XO1", "Rc")(63, XO1=134, Rc=1)
mtmsr = Form("rS", "XO1")(31, XO1=146)
mtspr = Form("rS", "spr", "XO1")(31, XO1=467)
mtsr = Form("rS", "SR", "XO1")(31, XO1=210)
mtsrin = Form("rS", "rB", "XO1")(31, XO1=242)
mulhw = XO(31, OE=0, XO2=75, Rc=0)
mulhwx = XO(31, OE=0, XO2=75, Rc=1)
mulhwu = XO(31, OE=0, XO2=11, Rc=0)
mulhwux = XO(31, OE=0, XO2=11, Rc=1)
mullw = XO(31, OE=0, XO2=235, Rc=0)
mullwx = XO(31, OE=0, XO2=235, Rc=1)
mullwo = XO(31, OE=1, XO2=235, Rc=0)
mullwox = XO(31, OE=1, XO2=235, Rc=1)
nand = XS(31, XO1=476, Rc=0)
nandx = XS(31, XO1=476, Rc=1)
neg = XO0(31, OE=0, XO2=104, Rc=0)
negx = XO0(31, OE=0, XO2=104, Rc=1)
nego = XO0(31, OE=1, XO2=104, Rc=0)
negox = XO0(31, OE=1, XO2=104, Rc=1)
nor = XS(31, XO1=124, Rc=0)
norx = XS(31, XO1=124, Rc=1)
or_ = XS(31, XO1=444, Rc=0)
or_x = XS(31, XO1=444, Rc=1)
orc = XS(31, XO1=412, Rc=0)
orcx = XS(31, XO1=412, Rc=1)
rfi = X(19, XO1=50)
rlwimi = MI(20, Rc=0)
rlwimix = MI(20, Rc=1)
rlwinm = MI(21, Rc=0)
rlwinmx = MI(21, Rc=1)
rlwnm = MB(23, Rc=0)
rlwnmx = MB(23, Rc=1)
slw = XS(31, XO1=24, Rc=0)
slwx = XS(31, XO1=24, Rc=1)
sraw = XS(31, XO1=792, Rc=0)
srawx = XS(31, XO1=792, Rc=1)
srawi = Form("rA", "rS", "SH", "XO1", "Rc")(31, XO1=824, Rc=0)
srawix = Form("rA", "rS", "SH", "XO1", "Rc")(31, XO1=824, Rc=1)
srw = XS(31, XO1=536, Rc=0)
srwx = XS(31, XO1=536, Rc=1)
stbux = XSO(31, XO1=247)
stbx = XSO(31, XO1=215)
stfdux = XSO(31, XO1=759)
stfdx = XSO(31, XO1=727)
stfiwx = XSO(31, XO1=983)
stfsux = XSO(31, XO1=695)
stfsx = XSO(31, XO1=663)
sthbrx = XSO(31, XO1=918)
sthux = XSO(31, XO1=439)
sthx = XSO(31, XO1=407)
stswi = Form("rS", "rA", "NB", "XO1")(31, XO1=725)
stswx = XSO(31, XO1=661)
stwbrx = XSO(31, XO1=662)
stwcxx = Form("rS", "rA", "rB", "XO1", "Rc")(31, XO1=150, Rc=1)
stwux = XSO(31, XO1=183)
stwx = XSO(31, XO1=151)
subf = XO(31, XO2=40, OE=0, Rc=0)
subfx = XO(31, XO2=40, OE=0, Rc=1)
subfo = XO(31, XO2=40, OE=1, Rc=0)
subfox = XO(31, XO2=40, OE=1, Rc=1)
subfc = XO(31, XO2=8, OE=0, Rc=0)
subfcx = XO(31, XO2=8, OE=0, Rc=1)
subfco = XO(31, XO2=8, OE=1, Rc=0)
subfcox = XO(31, XO2=8, OE=1, Rc=1)
subfe = XO(31, XO2=136, OE=0, Rc=0)
subfex = XO(31, XO2=136, OE=0, Rc=1)
subfeo = XO(31, XO2=136, OE=1, Rc=0)
subfeox = XO(31, XO2=136, OE=1, Rc=1)
subfme = XO0(31, OE=0, XO2=232, Rc=0)
subfmex = XO0(31, OE=0, XO2=232, Rc=1)
subfmeo = XO0(31, OE=1, XO2=232, Rc=0)
subfmeox= XO0(31, OE=1, XO2=232, Rc=1)
subfze = XO0(31, OE=0, XO2=200, Rc=0)
subfzex = XO0(31, OE=0, XO2=200, Rc=1)
subfzeo = XO0(31, OE=1, XO2=200, Rc=0)
subfzeox= XO0(31, OE=1, XO2=200, Rc=1)
sync = X(31, XO1=598)
tlbia = X(31, XO1=370)
tlbie = Form("rB", "XO1")(31, XO1=306)
tlbsync = X(31, XO1=566)
tw = Form("TO", "rA", "rB", "XO1")(31, XO1=4)
xor = XS(31, XO1=316, Rc=0)
xorx = XS(31, XO1=316, Rc=1)
class PPCAssembler(BasicPPCAssembler):
BA = BasicPPCAssembler
# awkward mnemonics:
# mftb
# most of the branch mnemonics...
# F.2 Simplified Mnemonics for Subtract Instructions
def subi(self, rD, rA, value):
self.addi(rD, rA, -value)
def subis(self, rD, rA, value):
self.addis(rD, rA, -value)
def subic(self, rD, rA, value):
self.addic(rD, rA, -value)
def subicx(self, rD, rA, value):
self.addicx(rD, rA, -value)
def sub(self, rD, rA, rB):
self.subf(rD, rB, rA)
def subc(self, rD, rA, rB):
self.subfc(rD, rB, rA)
def subx(self, rD, rA, rB):
self.subfx(rD, rB, rA)
def subcx(self, rD, rA, rB):
self.subfcx(rD, rB, rA)
def subo(self, rD, rA, rB):
self.subfo(rD, rB, rA)
def subco(self, rD, rA, rB):
self.subfco(rD, rB, rA)
def subox(self, rD, rA, rB):
self.subfox(rD, rB, rA)
def subcox(self, rD, rA, rB):
self.subfcox(rD, rB, rA)
# F.3 Simplified Mnemonics for Compare Instructions
cmpwi = BA.cmpi(L=0)
cmplwi = BA.cmpli(L=0)
cmpw = BA.cmp(L=0)
cmplw = BA.cmpl(L=0)
# F.4 Simplified Mnemonics for Rotate and Shift Instructions
def extlwi(self, rA, rS, n, b):
self.rlwinm(rA, rS, b, 0, n-1)
def extrwi(self, rA, rS, n, b):
self.rlwinm(rA, rS, b+n, 32-n, 31)
def inslwi(self, rA, rS, n, b):
self.rwlimi(rA, rS, 32-b, b, b + n -1)
def insrwi(self, rA, rS, n, b):
self.rwlimi(rA, rS, 32-(b+n), b, b + n -1)
def rotlwi(self, rA, rS, n):
self.rlwinm(rA, rS, n, 0, 31)
def rotrwi(self, rA, rS, n):
self.rlwinm(rA, rS, 32-n, 0, 31)
def rotlw(self, rA, rS, rB):
self.rlwnm(rA, rS, rB, 0, 31)
def slwi(self, rA, rS, n):
self.rlwinm(rA, rS, n, 0, 31-n)
def srwi(self, rA, rS, n):
self.rlwinm(rA, rS, 32-n, n, 31)
# F.5 Simplified Mnemonics for Branch Instructions
# there's a lot of these!
bt = BA.bc(BO=12)
bf = BA.bc(BO=4)
bdnz = BA.bc(BO=16, BI=0)
bdnzt = BA.bc(BO=8)
bdnzf = BA.bc(BO=0)
bdz = BA.bc(BO=18)
bdzt = BA.bc(BO=10)
bdzf = BA.bc(BO=2)
bta = BA.bca(BO=12)
bfa = BA.bca(BO=4)
bdnza = BA.bca(BO=16, BI=0)
bdnzta = BA.bca(BO=8)
bdnzfa = BA.bca(BO=0)
bdza = BA.bca(BO=18)
bdzta = BA.bca(BO=10)
bdzfa = BA.bca(BO=2)
btl = BA.bcl(BO=12)
bfl = BA.bcl(BO=4)
bdnzl = BA.bcl(BO=16, BI=0)
bdnztl = BA.bcl(BO=8)
bdnzfl = BA.bcl(BO=0)
bdzl = BA.bcl(BO=18)
bdztl = BA.bcl(BO=10)
bdzfl = BA.bcl(BO=2)
btla = BA.bcla(BO=12)
bfla = BA.bcla(BO=4)
bdnzla = BA.bcla(BO=16, BI=0)
bdnztla = BA.bcla(BO=8)
bdnzfla = BA.bcla(BO=0)
bdzla = BA.bcla(BO=18)
bdztla = BA.bcla(BO=10)
bdzfla = BA.bcla(BO=2)
blr = BA.bclr(BO=20, BI=0)
btlr = BA.bclr(BO=12)
bflr = BA.bclr(BO=4)
bdnzlr = BA.bclr(BO=16, BI=0)
bdnztlr = BA.bclr(BO=8)
bdnzflr = BA.bclr(BO=0)
bdzlr = BA.bclr(BO=18, BI=0)
bdztlr = BA.bclr(BO=10)
bdzflr = BA.bclr(BO=2)
bctr = BA.bcctr(BO=20, BI=0)
btctr = BA.bcctr(BO=12)
bfctr = BA.bcctr(BO=4)
blrl = BA.bclrl(BO=20, BI=0)
btlrl = BA.bclrl(BO=12)
bflrl = BA.bclrl(BO=4)
bdnzlrl = BA.bclrl(BO=16, BI=0)
bdnztlrl = BA.bclrl(BO=8)
bdnzflrl = BA.bclrl(BO=0)
bdzlrl = BA.bclrl(BO=18, BI=0)
bdztlrl = BA.bclrl(BO=10)
bdzflrl = BA.bclrl(BO=2)
bctrl = BA.bcctrl(BO=20, BI=0)
btctrl = BA.bcctrl(BO=12)
bfctrl = BA.bcctrl(BO=4)
# these should/could take a[n optional] crf argument, but it's a
# bit hard to see how to arrange that.
blt = BA.bc(BO=12, BI=0)
ble = BA.bc(BO=4, BI=1)
beq = BA.bc(BO=12, BI=2)
bge = BA.bc(BO=4, BI=0)
bgt = BA.bc(BO=12, BI=1)
bnl = BA.bc(BO=4, BI=0)
bne = BA.bc(BO=4, BI=2)
bng = BA.bc(BO=4, BI=1)
bso = BA.bc(BO=12, BI=3)
bns = BA.bc(BO=4, BI=3)
bun = BA.bc(BO=12, BI=3)
bnu = BA.bc(BO=4, BI=3)
blta = BA.bca(BO=12, BI=0)
blea = BA.bca(BO=4, BI=1)
beqa = BA.bca(BO=12, BI=2)
bgea = BA.bca(BO=4, BI=0)
bgta = BA.bca(BO=12, BI=1)
bnla = BA.bca(BO=4, BI=0)
bnea = BA.bca(BO=4, BI=2)
bnga = BA.bca(BO=4, BI=1)
bsoa = BA.bca(BO=12, BI=3)
bnsa = BA.bca(BO=4, BI=3)
buna = BA.bca(BO=12, BI=3)
bnua = BA.bca(BO=4, BI=3)
bltl = BA.bcl(BO=12, BI=0)
blel = BA.bcl(BO=4, BI=1)
beql = BA.bcl(BO=12, BI=2)
bgel = BA.bcl(BO=4, BI=0)
bgtl = BA.bcl(BO=12, BI=1)
bnll = BA.bcl(BO=4, BI=0)
bnel = BA.bcl(BO=4, BI=2)
bngl = BA.bcl(BO=4, BI=1)
bsol = BA.bcl(BO=12, BI=3)
bnsl = BA.bcl(BO=4, BI=3)
bunl = BA.bcl(BO=12, BI=3)
bnul = BA.bcl(BO=4, BI=3)
bltla = BA.bcla(BO=12, BI=0)
blela = BA.bcla(BO=4, BI=1)
beqla = BA.bcla(BO=12, BI=2)
bgela = BA.bcla(BO=4, BI=0)
bgtla = BA.bcla(BO=12, BI=1)
bnlla = BA.bcla(BO=4, BI=0)
bnela = BA.bcla(BO=4, BI=2)
bngla = BA.bcla(BO=4, BI=1)
bsola = BA.bcla(BO=12, BI=3)
bnsla = BA.bcla(BO=4, BI=3)
bunla = BA.bcla(BO=12, BI=3)
bnula = BA.bcla(BO=4, BI=3)
bltlr = BA.bclr(BO=12, BI=0)
blelr = BA.bclr(BO=4, BI=1)
beqlr = BA.bclr(BO=12, BI=2)
bgelr = BA.bclr(BO=4, BI=0)
bgtlr = BA.bclr(BO=12, BI=1)
bnllr = BA.bclr(BO=4, BI=0)
bnelr = BA.bclr(BO=4, BI=2)
bnglr = BA.bclr(BO=4, BI=1)
bsolr = BA.bclr(BO=12, BI=3)
bnslr = BA.bclr(BO=4, BI=3)
bunlr = BA.bclr(BO=12, BI=3)
bnulr = BA.bclr(BO=4, BI=3)
bltctr = BA.bcctr(BO=12, BI=0)
blectr = BA.bcctr(BO=4, BI=1)
beqctr = BA.bcctr(BO=12, BI=2)
bgectr = BA.bcctr(BO=4, BI=0)
bgtctr = BA.bcctr(BO=12, BI=1)
bnlctr = BA.bcctr(BO=4, BI=0)
bnectr = BA.bcctr(BO=4, BI=2)
bngctr = BA.bcctr(BO=4, BI=1)
bsoctr = BA.bcctr(BO=12, BI=3)
bnsctr = BA.bcctr(BO=4, BI=3)
bunctr = BA.bcctr(BO=12, BI=3)
bnuctr = BA.bcctr(BO=4, BI=3)
bltlrl = BA.bclrl(BO=12, BI=0)
blelrl = BA.bclrl(BO=4, BI=1)
beqlrl = BA.bclrl(BO=12, BI=2)
bgelrl = BA.bclrl(BO=4, BI=0)
bgtlrl = BA.bclrl(BO=12, BI=1)
bnllrl = BA.bclrl(BO=4, BI=0)
bnelrl = BA.bclrl(BO=4, BI=2)
bnglrl = BA.bclrl(BO=4, BI=1)
bsolrl = BA.bclrl(BO=12, BI=3)
bnslrl = BA.bclrl(BO=4, BI=3)
bunlrl = BA.bclrl(BO=12, BI=3)
bnulrl = BA.bclrl(BO=4, BI=3)
bltctrl = BA.bcctrl(BO=12, BI=0)
blectrl = BA.bcctrl(BO=4, BI=1)
beqctrl = BA.bcctrl(BO=12, BI=2)
bgectrl = BA.bcctrl(BO=4, BI=0)
bgtctrl = BA.bcctrl(BO=12, BI=1)
bnlctrl = BA.bcctrl(BO=4, BI=0)
bnectrl = BA.bcctrl(BO=4, BI=2)
bngctrl = BA.bcctrl(BO=4, BI=1)
bsoctrl = BA.bcctrl(BO=12, BI=3)
bnsctrl = BA.bcctrl(BO=4, BI=3)
bunctrl = BA.bcctrl(BO=12, BI=3)
bnuctrl = BA.bcctrl(BO=4, BI=3)
# whew! and we haven't even begun the predicted versions...
# F.6 Simplified Mnemonics for Condition Register
# Logical Instructions
crset = BA.creqv(crbA="crbD", crbB="crbD")
crclr = BA.crxor(crbA="crbD", crbB="crbD")
crmove = BA.cror(crbA="crbB")
crnot = BA.crnor(crbA="crbB")
# F.7 Simplified Mnemonics for Trap Instructions
trap = BA.tw(TO=31, rA=0, rB=0)
twlt = BA.tw(TO=16)
twle = BA.tw(TO=20)
tweq = BA.tw(TO=4)
twge = BA.tw(TO=12)
twgt = BA.tw(TO=8)
twnl = BA.tw(TO=12)
twng = BA.tw(TO=24)
twllt = BA.tw(TO=2)
twlle = BA.tw(TO=6)
twlge = BA.tw(TO=5)
twlgt = BA.tw(TO=1)
twlnl = BA.tw(TO=5)
twlng = BA.tw(TO=6)
twlti = BA.twi(TO=16)
twlei = BA.twi(TO=20)
tweqi = BA.twi(TO=4)
twgei = BA.twi(TO=12)
twgti = BA.twi(TO=8)
twnli = BA.twi(TO=12)
twnei = BA.twi(TO=24)
twngi = BA.twi(TO=20)
twllti = BA.twi(TO=2)
twllei = BA.twi(TO=6)
twlgei = BA.twi(TO=5)
twlgti = BA.twi(TO=1)
twlnli = BA.twi(TO=5)
twlngi = BA.twi(TO=6)
# F.8 Simplified Mnemonics for Special-Purpose
# Registers
mfctr = BA.mfspr(spr=9)
mflr = BA.mfspr(spr=8)
mftbl = BA.mftb(spr=268)
mftbu = BA.mftb(spr=269)
mfxer = BA.mfspr(spr=1)
mtctr = BA.mtspr(spr=9)
mtlr = BA.mtspr(spr=8)
mtxer = BA.mtspr(spr=1)
# F.9 Recommended Simplified Mnemonics
nop = BA.ori(rS=0, rA=0, UIMM=0)
li = BA.addi(rA=0)
lis = BA.addis(rA=0)
mr = BA.or_(rB="rS")
mrx = BA.or_x(rB="rS")
not_ = BA.nor(rB="rS")
not_x = BA.norx(rB="rS")
mtcr = BA.mtcrf(CRM=0xFF)
def hi(w):
return w >> 16
def ha(w):
if (w >> 15) & 1:
return (w >> 16) + 1
else:
return w >> 16
def lo(w):
return w & 0x0000FFFF
def la(w):
v = w & 0x0000FFFF
if v & 0x8000:
return -((v ^ 0xFFFF) + 1) # "sign extend" to 32 bits
return v
class MyPPCAssembler(PPCAssembler):
def load_word(self, rD, word):
self.addis(rD, 0, hi(word))
self.ori(rD, rD, lo(word))
def load_from(self, rD, addr):
self.addis(rD, 0, ha(addr))
self.lwz(rD, rD, la(addr))
def b(n):
r = []
for i in range(32):
r.append(n&1)
n >>= 1
r.reverse()
return ''.join(map(str, r))
from pypy.jit.codegen.ppc.ppcgen.regname import *
def main():
a = MyPPCAssembler()
a.lwz(r5, r4, 12)
a.lwz(r6, r4, 16)
a.lwz(r7, r5, 8)
a.lwz(r8, r6, 8)
a.add(r3, r7, r8)
a.load_word(r4, lookup("PyInt_FromLong"))
a.mtctr(r4)
a.bctr()
f = a.assemble(True)
print f(12,3)
a = MyPPCAssembler()
a.label("loop")
a.mftbu(r3)
a.mftbl(r4)
a.mftbu(r5)
a.cmpw(r5, r3)
a.bne(-16)
a.load_word(r5, lookup("PyLong_FromUnsignedLongLong"))
a.mtctr(r5)
a.bctr()
tb = a.assemble(True)
t0 = tb()
print [tb() - t0 for i in range(10)]
if __name__ == '__main__':
main()
| Python |
from pypy.jit.codegen.ppc.ppcgen.ppc_assembler import MyPPCAssembler
from pypy.jit.codegen.ppc.ppcgen.func_builder import make_func
from regname import *
def access_at():
a = MyPPCAssembler()
a.lwzx(r3, r3, r4)
a.blr()
return make_func(a, "i", "ii")
access_at = access_at()
def itoO():
a = MyPPCAssembler()
a.blr()
return make_func(a, "O", "i")
itoO = itoO()
| Python |
"""
self cloning, automatic path configuration
copy this into any subdirectory of pypy from which scripts need
to be run, typically all of the test subdirs.
The idea is that any such script simply issues
import autopath
and this will make sure that the parent directory containing "pypy"
is in sys.path.
If you modify the master "autopath.py" version (in pypy/tool/autopath.py)
you can directly run it which will copy itself on all autopath.py files
it finds under the pypy root directory.
This module always provides these attributes:
pypydir pypy root directory path
this_dir directory where this autopath.py resides
"""
def __dirinfo(part):
""" return (partdir, this_dir) and insert parent of partdir
into sys.path. If the parent directories don't have the part
an EnvironmentError is raised."""
import sys, os
try:
head = this_dir = os.path.realpath(os.path.dirname(__file__))
except NameError:
head = this_dir = os.path.realpath(os.path.dirname(sys.argv[0]))
while head:
partdir = head
head, tail = os.path.split(head)
if tail == part:
break
else:
raise EnvironmentError, "'%s' missing in '%r'" % (partdir, this_dir)
pypy_root = os.path.join(head, '')
try:
sys.path.remove(head)
except ValueError:
pass
sys.path.insert(0, head)
munged = {}
for name, mod in sys.modules.items():
if '.' in name:
continue
fn = getattr(mod, '__file__', None)
if not isinstance(fn, str):
continue
newname = os.path.splitext(os.path.basename(fn))[0]
if not newname.startswith(part + '.'):
continue
path = os.path.join(os.path.dirname(os.path.realpath(fn)), '')
if path.startswith(pypy_root) and newname != part:
modpaths = os.path.normpath(path[len(pypy_root):]).split(os.sep)
if newname != '__init__':
modpaths.append(newname)
modpath = '.'.join(modpaths)
if modpath not in sys.modules:
munged[modpath] = mod
for name, mod in munged.iteritems():
if name not in sys.modules:
sys.modules[name] = mod
if '.' in name:
prename = name[:name.rfind('.')]
postname = name[len(prename)+1:]
if prename not in sys.modules:
__import__(prename)
if not hasattr(sys.modules[prename], postname):
setattr(sys.modules[prename], postname, mod)
return partdir, this_dir
def __clone():
""" clone master version of autopath.py into all subdirs """
from os.path import join, walk
if not this_dir.endswith(join('pypy','tool')):
raise EnvironmentError("can only clone master version "
"'%s'" % join(pypydir, 'tool',_myname))
def sync_walker(arg, dirname, fnames):
if _myname in fnames:
fn = join(dirname, _myname)
f = open(fn, 'rwb+')
try:
if f.read() == arg:
print "checkok", fn
else:
print "syncing", fn
f = open(fn, 'w')
f.write(arg)
finally:
f.close()
s = open(join(pypydir, 'tool', _myname), 'rb').read()
walk(pypydir, sync_walker, s)
_myname = 'autopath.py'
# set guaranteed attributes
pypydir, this_dir = __dirinfo('pypy')
if __name__ == '__main__':
__clone()
| Python |
class PyVarObject(object):
ob_size = 8
class PyObject(object):
ob_refcnt = 0
ob_type = 4
class PyTupleObject(object):
ob_item = 12
class PyTypeObject(object):
tp_name = 12
tp_basicsize = 16
tp_itemsize = 20
tp_dealloc = 24
class PyFloatObject(object):
ob_fval = 8
class PyIntObject(object):
ob_ival = 8
| Python |
from pypy.jit.codegen.ppc.ppcgen.form import Form
from pypy.jit.codegen.ppc.ppcgen.ppc_field import ppc_fields
class PPCForm(Form):
fieldmap = ppc_fields
def __init__(self, *fnames):
super(PPCForm, self).__init__(*("opcode",) + fnames)
def __call__(self, opcode, **specializations):
specializations['opcode'] = opcode
return super(PPCForm, self).__call__(**specializations)
| Python |
"""
self cloning, automatic path configuration
copy this into any subdirectory of pypy from which scripts need
to be run, typically all of the test subdirs.
The idea is that any such script simply issues
import autopath
and this will make sure that the parent directory containing "pypy"
is in sys.path.
If you modify the master "autopath.py" version (in pypy/tool/autopath.py)
you can directly run it which will copy itself on all autopath.py files
it finds under the pypy root directory.
This module always provides these attributes:
pypydir pypy root directory path
this_dir directory where this autopath.py resides
"""
def __dirinfo(part):
""" return (partdir, this_dir) and insert parent of partdir
into sys.path. If the parent directories don't have the part
an EnvironmentError is raised."""
import sys, os
try:
head = this_dir = os.path.realpath(os.path.dirname(__file__))
except NameError:
head = this_dir = os.path.realpath(os.path.dirname(sys.argv[0]))
while head:
partdir = head
head, tail = os.path.split(head)
if tail == part:
break
else:
raise EnvironmentError, "'%s' missing in '%r'" % (partdir, this_dir)
pypy_root = os.path.join(head, '')
try:
sys.path.remove(head)
except ValueError:
pass
sys.path.insert(0, head)
munged = {}
for name, mod in sys.modules.items():
if '.' in name:
continue
fn = getattr(mod, '__file__', None)
if not isinstance(fn, str):
continue
newname = os.path.splitext(os.path.basename(fn))[0]
if not newname.startswith(part + '.'):
continue
path = os.path.join(os.path.dirname(os.path.realpath(fn)), '')
if path.startswith(pypy_root) and newname != part:
modpaths = os.path.normpath(path[len(pypy_root):]).split(os.sep)
if newname != '__init__':
modpaths.append(newname)
modpath = '.'.join(modpaths)
if modpath not in sys.modules:
munged[modpath] = mod
for name, mod in munged.iteritems():
if name not in sys.modules:
sys.modules[name] = mod
if '.' in name:
prename = name[:name.rfind('.')]
postname = name[len(prename)+1:]
if prename not in sys.modules:
__import__(prename)
if not hasattr(sys.modules[prename], postname):
setattr(sys.modules[prename], postname, mod)
return partdir, this_dir
def __clone():
""" clone master version of autopath.py into all subdirs """
from os.path import join, walk
if not this_dir.endswith(join('pypy','tool')):
raise EnvironmentError("can only clone master version "
"'%s'" % join(pypydir, 'tool',_myname))
def sync_walker(arg, dirname, fnames):
if _myname in fnames:
fn = join(dirname, _myname)
f = open(fn, 'rwb+')
try:
if f.read() == arg:
print "checkok", fn
else:
print "syncing", fn
f = open(fn, 'w')
f.write(arg)
finally:
f.close()
s = open(join(pypydir, 'tool', _myname), 'rb').read()
walk(pypydir, sync_walker, s)
_myname = 'autopath.py'
# set guaranteed attributes
pypydir, this_dir = __dirinfo('pypy')
if __name__ == '__main__':
__clone()
| Python |
import py
from pypy.jit.codegen import detect_cpu
class Directory(py.test.collect.Directory):
def run(self):
try:
processor = detect_cpu.autodetect()
except detect_cpu.ProcessorAutodetectError, e:
py.test.skip(str(e))
else:
if processor != 'ppc':
py.test.skip('detected a %r CPU' % (processor,))
return super(Directory, self).run()
Option = py.test.config.Option
option = py.test.config.addoptions("ppc options",
Option('--run-interp-tests', action="store_true", default=False,
dest="run_interp_tests",
help=""),
Option('--debug-scribble', action="store_true", default=False,
dest="debug_scribble",
help="write junk into unused registers and regions of the stack"),
Option('--debug-print', action="store_true", default=False,
dest="debug_print",
help=""))
| Python |
import pypy.rpython.rctypes.implementation # register rctypes types
from pypy.rpython.rctypes.tool import ctypes_platform
from pypy.rpython.rctypes.tool.libc import libc
from ctypes import POINTER, cast, c_void_p, c_int, c_char
class CConfig:
_includes_ = ("sys/types.h", "sys/mman.h")
size_t = ctypes_platform.SimpleType("size_t", c_int)
off_t = ctypes_platform.SimpleType("off_t", c_int)
MAP_PRIVATE = ctypes_platform.DefinedConstantInteger("MAP_PRIVATE")
MAP_ANON = ctypes_platform.DefinedConstantInteger("MAP_ANON")
MAP_ANONYMOUS = ctypes_platform.DefinedConstantInteger("MAP_ANONYMOUS")
PROT_READ = ctypes_platform.DefinedConstantInteger("PROT_READ")
PROT_WRITE = ctypes_platform.DefinedConstantInteger("PROT_WRITE")
PROT_EXEC = ctypes_platform.DefinedConstantInteger("PROT_EXEC")
globals().update(ctypes_platform.configure(CConfig))
if MAP_ANONYMOUS is None:
MAP_ANONYMOUS = MAP_ANON
assert MAP_ANONYMOUS is not None
del MAP_ANON
# ____________________________________________________________
PTR = POINTER(c_char) # cannot use c_void_p as return value of functions :-(
mmap_ = libc.mmap
mmap_.argtypes = [PTR, size_t, c_int, c_int, c_int, off_t]
mmap_.restype = PTR
mmap_.includes = ("sys/mman.h",)
munmap_ = libc.munmap
munmap_.argtypes = [PTR, size_t]
munmap_.restype = c_int
munmap_.includes = ("sys/mman.h",)
def alloc(map_size):
flags = MAP_PRIVATE | MAP_ANONYMOUS
prot = PROT_EXEC | PROT_READ | PROT_WRITE
res = mmap_(PTR(), map_size, prot, flags, -1, 0)
if not res:
raise MemoryError
return res
free = munmap_
class CodeBlockOverflow(Exception):
pass
class MachineCodeBlock:
def __init__(self, _data, _size, _pos):
self._size = _size
self._data = _data
self._pos = _pos
def write(self, data):
p = self._pos
if p >= self._size:
raise CodeBlockOverflow
self._data.contents[p] = data
self._pos = p + 1
def getpos(self):
return self._pos
def setpos(self, _pos):
assert _pos >=0
self._pos = _pos
def tell(self):
baseaddr = cast(self._data, c_void_p).value
return baseaddr + self._pos * 4
def reserve(self, _size):
r = MachineCodeBlock(self._data, self._pos + _size, self._pos)
for i in range(_size):
self.write(0)
return r
class ExistingCodeBlock(MachineCodeBlock):
def __init__(self, start, end):
_size = (end-start)/4
_data = cast(c_void_p(start), POINTER(c_int * _size))
MachineCodeBlock.__init__(self, _data, _size, 0)
class OwningMachineCodeBlock(MachineCodeBlock):
def __init__(self, size_in_bytes):
assert size_in_bytes % 4 == 0
res = alloc(size_in_bytes)
_size = size_in_bytes/4
_data = cast(res, POINTER(c_int * _size))
MachineCodeBlock.__init__(self, _data, _size, 0)
def __del__(self):
free(cast(self._data, PTR), self._size * 4)
# ------------------------------------------------------------
class LLTypeMachineCodeBlock(MachineCodeBlock):
class State:
pass
state = State()
state.base = 1
def __init__(self, map_size):
self._size = map_size/4
self._pos = 0
self._base = LLTypeMachineCodeBlock.state.base
LLTypeMachineCodeBlock.state.base += 2 * map_size
def write(self, data):
if self._pos + 1 > self._size:
raise CodeBlockOverflow
self._pos += 1
def tell(self):
return self._base + 4 * self._pos
def reserve(self, _size):
return LLTypeMachineCodeBlock(_size)
class LLTypeExistingCodeBlock(LLTypeMachineCodeBlock):
def __init__(self, start, end):
_size = (end-start)
LLTypeMachineCodeBlock.__init__(self, _size)
| Python |
#
| Python |
r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, \
r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, \
r23, r24, r25, r26, r27, r28, r29, r30, r31 = range(32)
rSCRATCH = r0
rSP = r1
rFP = r2 # the ABI doesn't specify a frame pointer. however, we want one
class AllocationSlot(object):
offset = 0
number = 0
def __init__(self):
# The field alloc points to a singleton used by the register
# allocator to detect conflicts. No two AllocationSlot
# instances with the same value in self.alloc can be used at
# once.
self.alloc = self
def make_loc(self):
""" When we assign a variable to one of these registers, we
call make_loc() to get the actual location instance; that
instance will have its alloc field set to self. For
everything but condition registers, this is self."""
return self
class _StackSlot(AllocationSlot):
is_register = False
def __init__(self, offset):
AllocationSlot.__init__(self)
self.offset = offset
def __repr__(self):
return "stack@%s"%(self.offset,)
_stack_slot_cache = {}
def stack_slot(offset):
# because stack slots are put into dictionaries which compare by
# identity, it is important that there's a unique _StackSlot
# object for each offset, at least per function generated or
# something. doing the caching here is easier, though.
if offset in _stack_slot_cache:
return _stack_slot_cache[offset]
_stack_slot_cache[offset] = res = _StackSlot(offset)
return res
NO_REGISTER = -1
GP_REGISTER = 0
FP_REGISTER = 1
CR_FIELD = 2
CT_REGISTER = 3
class Register(AllocationSlot):
is_register = True
def __init__(self):
AllocationSlot.__init__(self)
class GPR(Register):
regclass = GP_REGISTER
def __init__(self, number):
Register.__init__(self)
self.number = number
def __repr__(self):
return 'r' + str(self.number)
gprs = map(GPR, range(32))
class FPR(Register):
regclass = FP_REGISTER
def __init__(self, number):
Register.__init__(self)
self.number = number
fprs = map(FPR, range(32))
class BaseCRF(Register):
""" These represent condition registers; however, we never actually
use these as the location of something in the register allocator.
Instead, we place it in an instance of CRF which indicates which
bits are required to extract the value. Note that CRF().alloc will
always be an instance of this. """
regclass = CR_FIELD
def __init__(self, number):
self.number = number
self.alloc = self
def make_loc(self):
return CRF(self)
crfs = map(BaseCRF, range(8))
class CRF(Register):
regclass = CR_FIELD
def __init__(self, crf):
Register.__init__(self)
self.alloc = crf
self.number = crf.number
self.info = (-1,-1) # (bit, negated)
def set_info(self, info):
assert len(info) == 2
self.info = info
def make_loc(self):
# should never call this on a CRF, only a BaseCRF
raise NotImplementedError
def move_to_gpr(self, gpr):
bit, negated = self.info
return _CRF2GPR(gpr, self.alloc.number*4 + bit, negated)
def move_from_gpr(self, gpr):
# cmp2info['ne']
self.set_info((2, 1))
return _GPR2CRF(self, gpr)
def __repr__(self):
return 'crf' + str(self.number) + str(self.info)
class CTR(Register):
regclass = CT_REGISTER
def move_from_gpr(self, gpr):
return _GPR2CTR(gpr)
ctr = CTR()
_insn_index = [0]
class Insn(object):
'''
result is the Var instance that holds the result, or None
result_regclass is the class of the register the result goes into
reg_args is the vars that need to have registers allocated for them
reg_arg_regclasses is the type of register that needs to be allocated
'''
def __init__(self):
self._magic_index = _insn_index[0]
_insn_index[0] += 1
def __repr__(self):
return "<%s %d>" % (self.__class__.__name__, self._magic_index)
def emit(self, asm):
pass
class Insn_GPR__GPR_GPR(Insn):
def __init__(self, methptr, result, args):
Insn.__init__(self)
self.methptr = methptr
self.result = result
self.result_regclass = GP_REGISTER
self.reg_args = args
self.reg_arg_regclasses = [GP_REGISTER, GP_REGISTER]
self.result_reg = None
self.arg_reg1 = None
self.arg_reg2 = None
def allocate(self, allocator):
self.result_reg = allocator.loc_of(self.result)
self.arg_reg1 = allocator.loc_of(self.reg_args[0])
self.arg_reg2 = allocator.loc_of(self.reg_args[1])
def __repr__(self):
if self.result_reg:
r = "%s@%s"%(self.result, self.result_reg)
else:
r = str(self.result)
if self.arg_reg1:
a1 = "%s@%s"%(self.reg_args[0], self.arg_reg1)
else:
a1 = str(self.reg_args[0])
if self.arg_reg2:
a2 = "%s@%s"%(self.reg_args[1], self.arg_reg2)
else:
a2 = str(self.reg_args[1])
return "<%s-%s %s %s, %s, %s>" % (self.__class__.__name__, self._magic_index,
self.methptr.im_func.func_name,
r, a1, a2)
def emit(self, asm):
self.methptr(asm,
self.result_reg.number,
self.arg_reg1.number,
self.arg_reg2.number)
class Insn_GPR__GPR_IMM(Insn):
def __init__(self, methptr, result, args):
Insn.__init__(self)
self.methptr = methptr
self.imm = args[1]
self.result = result
self.result_regclass = GP_REGISTER
self.reg_args = [args[0]]
self.reg_arg_regclasses = [GP_REGISTER]
self.result_reg = None
self.arg_reg = None
def allocate(self, allocator):
self.result_reg = allocator.loc_of(self.result)
self.arg_reg = allocator.loc_of(self.reg_args[0])
def __repr__(self):
if self.result_reg:
r = "%s@%s"%(self.result, self.result_reg)
else:
r = str(self.result)
if self.arg_reg:
a = "%s@%s"%(self.reg_args[0], self.arg_reg)
else:
a = str(self.reg_args[0])
return "<%s-%d %s %s, %s, (%s)>" % (self.__class__.__name__, self._magic_index,
self.methptr.im_func.func_name,
r, a, self.imm.value)
def emit(self, asm):
self.methptr(asm,
self.result_reg.number,
self.arg_reg.number,
self.imm.value)
class Insn_GPR__GPR(Insn):
def __init__(self, methptr, result, arg):
Insn.__init__(self)
self.methptr = methptr
self.result = result
self.result_regclass = GP_REGISTER
self.reg_args = [arg]
self.reg_arg_regclasses = [GP_REGISTER]
self.result_reg = None
self.arg_reg = None
def allocate(self, allocator):
self.result_reg = allocator.loc_of(self.result)
self.arg_reg = allocator.loc_of(self.reg_args[0])
def __repr__(self):
if self.result_reg:
r = "%s@%s"%(self.result, self.result_reg)
else:
r = str(self.result)
if self.arg_reg:
a = "%s@%s"%(self.reg_args[0], self.arg_reg)
else:
a = str(self.reg_args[0])
return "<%s-%d %s %s, %s>" % (self.__class__.__name__, self._magic_index,
self.methptr.im_func.func_name, r, a)
def emit(self, asm):
self.methptr(asm,
self.result_reg.number,
self.arg_reg.number)
class Insn_GPR(Insn):
def __init__(self, methptr, result):
Insn.__init__(self)
self.methptr = methptr
self.result = result
self.result_regclass = GP_REGISTER
self.reg_args = []
self.reg_arg_regclasses = []
self.result_reg = None
def allocate(self, allocator):
self.result_reg = allocator.loc_of(self.result)
def __repr__(self):
if self.result_reg:
r = "%s@%s"%(self.result, self.result_reg)
else:
r = str(self.result)
return "<%s-%d %s %s>" % (self.__class__.__name__, self._magic_index,
self.methptr.im_func.func_name, r)
def emit(self, asm):
self.methptr(asm,
self.result_reg.number)
class Insn_GPR__IMM(Insn):
def __init__(self, methptr, result, args):
Insn.__init__(self)
self.methptr = methptr
self.imm = args[0]
self.result = result
self.result_regclass = GP_REGISTER
self.reg_args = []
self.reg_arg_regclasses = []
self.result_reg = None
def allocate(self, allocator):
self.result_reg = allocator.loc_of(self.result)
def __repr__(self):
if self.result_reg:
r = "%s@%s"%(self.result, self.result_reg)
else:
r = str(self.result)
return "<%s-%d %s %s, (%s)>" % (self.__class__.__name__, self._magic_index,
self.methptr.im_func.func_name, r,
self.imm.value)
def emit(self, asm):
self.methptr(asm,
self.result_reg.number,
self.imm.value)
class MoveCRB2GPR(Insn):
def __init__(self, result, gv_condition):
Insn.__init__(self)
self.result = result
self.result_regclass = GP_REGISTER
self.reg_args = [gv_condition]
self.reg_arg_regclasses = [CR_FIELD]
def allocate(self, allocator):
self.targetreg = allocator.loc_of(self.result)
self.crf = allocator.loc_of(self.reg_args[0])
def emit(self, asm):
assert isinstance(self.crf, CRF)
bit, negated = self.crf.info
asm.mfcr(self.targetreg.number)
asm.extrwi(self.targetreg.number, self.targetreg.number, 1, self.crf.number*4+bit)
if negated:
asm.xori(self.targetreg.number, self.targetreg.number, 1)
class Insn_None__GPR_GPR_IMM(Insn):
def __init__(self, methptr, args):
Insn.__init__(self)
self.methptr = methptr
self.imm = args[2]
self.result = None
self.result_regclass = NO_REGISTER
self.reg_args = args[:2]
self.reg_arg_regclasses = [GP_REGISTER, GP_REGISTER]
def allocate(self, allocator):
self.reg1 = allocator.loc_of(self.reg_args[0])
self.reg2 = allocator.loc_of(self.reg_args[1])
def __repr__(self):
return "<%s %s %d>" % (self.__class__.__name__, self.methptr.im_func.func_name, self._magic_index)
def emit(self, asm):
self.methptr(asm,
self.reg1.number,
self.reg2.number,
self.imm.value)
class Insn_None__GPR_GPR_GPR(Insn):
def __init__(self, methptr, args):
Insn.__init__(self)
self.methptr = methptr
self.result = None
self.result_regclass = NO_REGISTER
self.reg_args = args
self.reg_arg_regclasses = [GP_REGISTER, GP_REGISTER, GP_REGISTER]
def allocate(self, allocator):
self.reg1 = allocator.loc_of(self.reg_args[0])
self.reg2 = allocator.loc_of(self.reg_args[1])
self.reg3 = allocator.loc_of(self.reg_args[2])
def __repr__(self):
return "<%s %s %d>" % (self.__class__.__name__, self.methptr.im_func.func_name, self._magic_index)
def emit(self, asm):
self.methptr(asm,
self.reg1.number,
self.reg2.number,
self.reg3.number)
class Extrwi(Insn):
def __init__(self, result, source, size, bit):
Insn.__init__(self)
self.result = result
self.result_regclass = GP_REGISTER
self.reg_args = [source]
self.reg_arg_regclasses = [GP_REGISTER]
self.result_reg = None
self.arg_reg = None
self.size = size
self.bit = bit
def allocate(self, allocator):
self.result_reg = allocator.loc_of(self.result)
self.arg_reg = allocator.loc_of(self.reg_args[0])
def __repr__(self):
if self.result_reg:
r = "%s@%s"%(self.result, self.result_reg)
else:
r = str(self.result)
if self.arg_reg:
a = "%s@%s"%(self.reg_args[0], self.arg_reg)
else:
a = str(self.reg_args[0])
return "<%s-%d extrwi %s, %s, %s, %s>" % (self.__class__.__name__, self._magic_index,
r, a, self.size, self.bit)
def emit(self, asm):
asm.extrwi(self.result_reg.number,
self.arg_reg.number,
self.size, self.bit)
class CMPInsn(Insn):
def __init__(self, info, result):
Insn.__init__(self)
self.info = info
self.result = result
self.result_reg = None
def allocate(self, allocator):
self.result_reg = allocator.loc_of(self.result)
assert isinstance(self.result_reg, CRF)
self.result_reg.set_info(self.info)
class CMPW(CMPInsn):
def __init__(self, info, result, args):
CMPInsn.__init__(self, info, result)
self.result_regclass = CR_FIELD
self.reg_args = args
self.reg_arg_regclasses = [GP_REGISTER, GP_REGISTER]
self.arg_reg1 = None
self.arg_reg2 = None
def allocate(self, allocator):
CMPInsn.allocate(self, allocator)
self.arg_reg1 = allocator.loc_of(self.reg_args[0])
self.arg_reg2 = allocator.loc_of(self.reg_args[1])
def __repr__(self):
if self.result_reg:
r = "%s@%s"%(self.result, self.result_reg)
else:
r = str(self.result)
if self.arg_reg1:
a1 = "%s@%s"%(self.reg_args[0], self.arg_reg1)
else:
a1 = str(self.reg_args[0])
if self.arg_reg2:
a2 = "%s@%s"%(self.reg_args[1], self.arg_reg2)
else:
a2 = str(self.reg_args[1])
return "<%s-%d %s %s, %s, %s>"%(self.__class__.__name__, self._magic_index,
self.__class__.__name__.lower(),
r, a1, a2)
def emit(self, asm):
asm.cmpw(self.result_reg.number, self.arg_reg1.number, self.arg_reg2.number)
class CMPWL(CMPW):
def emit(self, asm):
asm.cmplw(self.result_reg.number, self.arg_reg1.number, self.arg_reg2.number)
class CMPWI(CMPInsn):
def __init__(self, info, result, args):
CMPInsn.__init__(self, info, result)
self.imm = args[1]
self.result_regclass = CR_FIELD
self.reg_args = [args[0]]
self.reg_arg_regclasses = [GP_REGISTER]
self.arg_reg = None
def allocate(self, allocator):
CMPInsn.allocate(self, allocator)
self.arg_reg = allocator.loc_of(self.reg_args[0])
def __repr__(self):
if self.result_reg:
r = "%s@%s"%(self.result, self.result_reg)
else:
r = str(self.result)
if self.arg_reg:
a = "%s@%s"%(self.reg_args[0], self.arg_reg)
else:
a = str(self.reg_args[0])
return "<%s-%d %s %s, %s, (%s)>"%(self.__class__.__name__, self._magic_index,
self.__class__.__name__.lower(),
r, a, self.imm.value)
def emit(self, asm):
#print "CMPWI", asm.mc.tell()
asm.cmpwi(self.result_reg.number, self.arg_reg.number, self.imm.value)
class CMPWLI(CMPWI):
def emit(self, asm):
asm.cmplwi(self.result_reg.number, self.arg_reg.number, self.imm.value)
## class MTCTR(Insn):
## def __init__(self, result, args):
## Insn.__init__(self)
## self.result = result
## self.result_regclass = CT_REGISTER
## self.reg_args = args
## self.reg_arg_regclasses = [GP_REGISTER]
## def allocate(self, allocator):
## self.arg_reg = allocator.loc_of(self.reg_args[0])
## def emit(self, asm):
## asm.mtctr(self.arg_reg.number)
class Jump(Insn):
def __init__(self, gv_cond, targetbuilder, jump_if_true, jump_args_gv):
Insn.__init__(self)
self.gv_cond = gv_cond
self.jump_if_true = jump_if_true
self.result = None
self.result_regclass = NO_REGISTER
self.reg_args = [gv_cond]
self.reg_arg_regclasses = [CR_FIELD]
self.crf = None
self.jump_args_gv = jump_args_gv
self.targetbuilder = targetbuilder
def allocate(self, allocator):
self.crf = allocator.loc_of(self.reg_args[0])
assert self.crf.info[0] != -1
assert self.targetbuilder.initial_var2loc is None
self.targetbuilder.initial_var2loc = {}
from pypy.jit.codegen.ppc.rgenop import Var
for gv_arg in self.jump_args_gv:
if isinstance(gv_arg, Var):
self.targetbuilder.initial_var2loc[gv_arg] = allocator.var2loc[gv_arg]
allocator.builders_to_tell_spill_offset_to.append(self.targetbuilder)
def __repr__(self):
if self.jump_if_true:
op = 'if_true'
else:
op = 'if_false'
if self.crf:
a = '%s@%s'%(self.reg_args[0], self.crf)
else:
a = self.reg_args[0]
return '<%s-%d %s %s>'%(self.__class__.__name__, self._magic_index,
op, a)
def emit(self, asm):
if self.targetbuilder.start:
asm.load_word(rSCRATCH, self.targetbuilder.start)
else:
self.targetbuilder.patch_start_here = asm.mc.tell()
asm.load_word(rSCRATCH, 0)
asm.mtctr(rSCRATCH)
bit, negated = self.crf.info
assert bit != -1
if negated ^ self.jump_if_true:
BO = 12 # jump if relavent bit is set in the CR
else:
BO = 4 # jump if relavent bit is NOT set in the CR
asm.bcctr(BO, self.crf.number*4 + bit)
class Label(Insn):
def __init__(self, label):
Insn.__init__(self)
self.reg_args = []
self.reg_arg_regclasses = []
self.result_regclass = NO_REGISTER
self.result = None
self.label = label
def allocate(self, allocator):
for gv in self.label.args_gv:
loc = allocator.loc_of(gv)
if isinstance(loc, CRF):
allocator.forget(gv, loc)
allocator.lru.remove(gv)
allocator.freeregs[loc.regclass].append(loc.alloc)
new_loc = allocator._allocate_reg(GP_REGISTER, gv)
allocator.lru.append(gv)
allocator.insns.append(loc.move_to_gpr(new_loc.number))
loc = new_loc
self.label.arg_locations = []
for gv in self.label.args_gv:
loc = allocator.loc_of(gv)
self.label.arg_locations.append(loc)
allocator.labels_to_tell_spill_offset_to.append(self.label)
def __repr__(self):
if hasattr(self.label, 'arg_locations'):
arg_locations = '[' + ', '.join(
['%s@%s'%(gv, loc) for gv, loc in
zip(self.label.args_gv, self.label.arg_locations)]) + ']'
else:
arg_locations = str(self.label.args_gv)
return '<Label-%s %s>'%(self._magic_index,
arg_locations)
def emit(self, asm):
self.label.startaddr = asm.mc.tell()
class LoadFramePointer(Insn):
def __init__(self, result):
Insn.__init__(self)
self.reg_args = []
self.reg_arg_regclasses = []
self.result = result
self.result_regclass = GP_REGISTER
def allocate(self, allocator):
self.result_reg = allocator.loc_of(self.result)
def emit(self, asm):
asm.mr(self.result_reg.number, rFP)
class CopyIntoStack(Insn):
def __init__(self, place, v):
Insn.__init__(self)
self.reg_args = [v]
self.reg_arg_regclasses = [GP_REGISTER]
self.result = None
self.result_regclass = NO_REGISTER
self.place = place
def allocate(self, allocator):
self.arg_reg = allocator.loc_of(self.reg_args[0])
self.target_slot = allocator.spill_slot()
self.place.offset = self.target_slot.offset
def emit(self, asm):
asm.stw(self.arg_reg.number, rFP, self.target_slot.offset)
class CopyOffStack(Insn):
def __init__(self, v, place):
Insn.__init__(self)
self.reg_args = []
self.reg_arg_regclasses = []
self.result = v
self.result_regclass = GP_REGISTER
self.place = place
def allocate(self, allocator):
self.result_reg = allocator.loc_of(self.result)
allocator.free_stack_slots.append(stack_slot(self.place.offset))
def emit(self, asm):
asm.lwz(self.result_reg.number, rFP, self.place.offset)
class SpillCalleeSaves(Insn):
def __init__(self):
Insn.__init__(self)
self.reg_args = []
self.reg_arg_regclasses = []
self.result = None
self.result_regclass = NO_REGISTER
def allocate(self, allocator):
# cough cough cough
callersave = gprs[3:13]
for v in allocator.var2loc:
loc = allocator.loc_of(v)
if loc in callersave:
allocator.spill(loc, v)
allocator.freeregs[GP_REGISTER].append(loc)
def emit(self, asm):
pass
class LoadArg(Insn):
def __init__(self, argnumber, arg):
Insn.__init__(self)
self.reg_args = []
self.reg_arg_regclasses = []
self.result = None
self.result_regclass = NO_REGISTER
self.argnumber = argnumber
self.arg = arg
def allocate(self, allocator):
from pypy.jit.codegen.ppc.rgenop import Var
if isinstance(self.arg, Var):
self.loc = allocator.loc_of(self.arg)
else:
self.loc = None
def emit(self, asm):
if self.argnumber < 8: # magic numbers 'r' us
targetreg = 3+self.argnumber
if self.loc is None:
self.arg.load_now(asm, gprs[targetreg])
elif self.loc.is_register:
asm.mr(targetreg, self.loc.number)
else:
asm.lwz(targetreg, rFP, self.loc.offset)
else:
targetoffset = 24+self.argnumber*4
if self.loc is None:
self.arg.load_now(asm, gprs[0])
asm.stw(r0, r1, targetoffset)
elif self.loc.is_register:
asm.stw(self.loc.number, r1, targetoffset)
else:
asm.lwz(r0, rFP, self.loc.offset)
asm.stw(r0, r1, targetoffset)
class CALL(Insn):
def __init__(self, result, target):
Insn.__init__(self)
from pypy.jit.codegen.ppc.rgenop import Var
if isinstance(target, Var):
self.reg_args = [target]
self.reg_arg_regclasses = [CT_REGISTER]
else:
self.reg_args = []
self.reg_arg_regclasses = []
self.target = target
self.result = result
self.result_regclass = GP_REGISTER
def allocate(self, allocator):
if self.reg_args:
assert allocator.loc_of(self.reg_args[0]) is ctr
self.resultreg = allocator.loc_of(self.result)
def emit(self, asm):
if not self.reg_args:
self.target.load_now(asm, gprs[0])
asm.mtctr(0)
asm.bctrl()
asm.lwz(rFP, rSP, 0)
if self.resultreg != gprs[3]:
asm.mr(self.resultreg.number, 3)
class AllocTimeInsn(Insn):
def __init__(self):
Insn.__init__(self)
self.reg_args = []
self.reg_arg_regclasses = []
self.result_regclass = NO_REGISTER
self.result = None
class Move(AllocTimeInsn):
def __init__(self, dest, src):
AllocTimeInsn.__init__(self)
self.dest = dest
self.src = src
def emit(self, asm):
asm.mr(self.dest.number, self.src.number)
class Load(AllocTimeInsn):
def __init__(self, dest, const):
AllocTimeInsn.__init__(self)
self.dest = dest
self.const = const
def __repr__(self):
return "<Load-%d %s, (%s)>"%(self._magic_index, self.dest, self.const)
def emit(self, asm):
self.const.load_now(asm, self.dest)
class Unspill(AllocTimeInsn):
""" A special instruction inserted by our register "allocator." It
indicates that we need to load a value from the stack into a register
because we spilled a particular value. """
def __init__(self, var, reg, stack):
"""
var --- the var we spilled (a Var)
reg --- the reg we spilled it from (an integer)
offset --- the offset on the stack we spilled it to (an integer)
"""
AllocTimeInsn.__init__(self)
self.var = var
self.reg = reg
self.stack = stack
if not isinstance(self.reg, GPR):
assert isinstance(self.reg, CRF) or isinstance(self.reg, CTR)
self.moveinsn = self.reg.move_from_gpr(0)
else:
self.moveinsn = None
def __repr__(self):
return '<Unspill-%d %s: %s, %s>'%(self._magic_index, self.var, self.reg, self.stack)
def emit(self, asm):
if isinstance(self.reg, GPR):
r = self.reg.number
else:
r = 0
asm.lwz(r, rFP, self.stack.offset)
if self.moveinsn:
self.moveinsn.emit(asm)
class Spill(AllocTimeInsn):
""" A special instruction inserted by our register "allocator."
It indicates that we need to store a value from the register into
the stack because we spilled a particular value."""
def __init__(self, var, reg, stack):
"""
var --- the var we are spilling (a Var)
reg --- the reg we are spilling it from (an integer)
offset --- the offset on the stack we are spilling it to (an integer)
"""
AllocTimeInsn.__init__(self)
self.var = var
self.reg = reg
self.stack = stack
def __repr__(self):
return '<Spill-%d %s: %s, %s>'%(self._magic_index, self.var, self.stack, self.reg)
def emit(self, asm):
if isinstance(self.reg, GPR):
r = self.reg.number
else:
assert isinstance(self.reg, CRF)
self.reg.move_to_gpr(0).emit(asm)
r = 0
#print 'spilling to', self.stack.offset
asm.stw(r, rFP, self.stack.offset)
class _CRF2GPR(AllocTimeInsn):
def __init__(self, targetreg, bit, negated):
AllocTimeInsn.__init__(self)
self.targetreg = targetreg
self.bit = bit
self.negated = negated
def __repr__(self):
number = self.bit // 4
bit = self.bit % 4
return '<CRF2GPR-%d r%s, crf%s(%s, %s)>' % (
self._magic_index, self.targetreg, number, bit, self.negated)
def emit(self, asm):
asm.mfcr(self.targetreg)
asm.extrwi(self.targetreg, self.targetreg, 1, self.bit)
if self.negated:
asm.xori(self.targetreg, self.targetreg, 1)
class _GPR2CRF(AllocTimeInsn):
def __init__(self, targetreg, fromreg):
AllocTimeInsn.__init__(self)
self.targetreg = targetreg
self.fromreg = fromreg
def __repr__(self):
return '<GPR2CRF-%d %s, r%s>' % (
self._magic_index, self.targetreg, self.fromreg)
def emit(self, asm):
asm.cmpwi(self.targetreg.number, self.fromreg, 0)
class _GPR2CTR(AllocTimeInsn):
def __init__(self, fromreg):
AllocTimeInsn.__init__(self)
self.fromreg = fromreg
def emit(self, asm):
asm.mtctr(self.fromreg)
class Return(Insn):
""" Ensures the return value is in r3 """
def __init__(self, var):
Insn.__init__(self)
self.var = var
self.reg_args = [self.var]
self.reg_arg_regclasses = [GP_REGISTER]
self.result = None
self.result_regclass = NO_REGISTER
self.reg = None
def allocate(self, allocator):
self.reg = allocator.loc_of(self.reg_args[0])
def emit(self, asm):
if self.reg.number != 3:
asm.mr(r3, self.reg.number)
class FakeUse(Insn):
""" A fake use of a var to get it into a register. And reserving
a condition register field."""
def __init__(self, rvar, var):
Insn.__init__(self)
self.var = var
self.reg_args = [self.var]
self.reg_arg_regclasses = [GP_REGISTER]
self.result = rvar
self.result_regclass = CR_FIELD
def allocate(self, allocator):
pass
def emit(self, asm):
pass
| Python |
class CycleData:
# tar2src -> map target var to source var
# src2tar -> map source var to target var (!)
# tar2loc -> map target var to location
# src2loc -> map source var to location
# loc2src -> map location to source var
# srcstack -> list of source vars
# freshctr -> how many fresh locations have we made so far
# emitted -> list of emitted targets
pass
def emit_moves(gen, tarvars, tar2src, tar2loc, src2loc):
# Basic idea:
#
# Construct a dependency graph, with a node for each move (Ti <-
# Si). Add an edge between two nodes i and j if loc[Ti] ==
# loc[Sj]. (If executing the node's move would overwrite the
# source for another move). If there are no cycles, then a
# simple tree walk will suffice. If there *ARE* cycles, however,
# something more is needed.
#
# In a nutshell, the algorithm is to walk the tree, and whenever
# a backedge is detected break the cycle by creating a fresh
# location and remapping the source of the node so that it no
# longer conflicts. So, if you are in node i, and you detect a
# cycle involving node j (so, Ti and Sj are the same location),
# then you create a fresh location Sn. You move Sj to Sn, and
# remap node j so that instead of being Tj <- Sj it is Tj <- Sn.
# Now there is no need for the backedge, so you can continue.
# Whenever you have visited every edge going out from a node, all of
# its dependent moves have been performed, so you can emit the
# node's move and return.
data = CycleData()
data.tar2src = tar2src
data.src2tar = {}
data.tar2loc = tar2loc
data.src2loc = src2loc
data.loc2src = {}
data.srcstack = []
data.freshctr = 0
data.emitted = []
for tar, src in tar2src.items():
data.src2tar.setdefault(src, []).append(tar)
for src, loc in src2loc.items():
if src in data.src2tar:
data.loc2src[loc] = src
for tarvar in tarvars:
if data.tar2loc[tarvar] != data.src2loc[data.tar2src[tarvar]]:
_cycle_walk(gen, tarvar, data)
return data
def _cycle_walk(gen, tarvar, data):
if tarvar in data.emitted: return
tarloc = data.tar2loc[tarvar]
srcvar = data.tar2src[tarvar]
srcloc = data.src2loc[srcvar]
# if location we are about to write to is not going to be read
# by anyone, we are safe
if tarloc not in data.loc2src:
gen.emit_move(tarloc, srcloc)
data.emitted.append(tarvar)
return
# Find source node that conflicts with us
conflictsrcvar = data.loc2src[tarloc]
if conflictsrcvar not in data.srcstack:
# No cycle on our stack yet
data.srcstack.append(srcvar)
for tar in data.src2tar[conflictsrcvar]:
_cycle_walk(gen, tar, data)
srcloc = data.src2loc[srcvar] # warning: may have changed, so reload
gen.emit_move(tarloc, srcloc)
data.emitted.append(tarvar)
return
# Cycle detected, break it by moving the other node's source data
# somewhere else so we can overwrite it
freshloc = gen.create_fresh_location()
conflictsrcloc = data.src2loc[conflictsrcvar]
gen.emit_move(freshloc, conflictsrcloc)
data.src2loc[conflictsrcvar] = freshloc
gen.emit_move(tarloc, srcloc) # now safe to do our move
data.emitted.append(tarvar)
return
def emit_moves_safe(gen, tarvars, tar2src, tar2loc, src2loc):
second_moves = []
for tarvar in tarvars:
srcvar = tar2src[tarvar]
srcloc = src2loc[srcvar]
freshloc = gen.create_fresh_location()
gen.emit_move(freshloc, srcloc)
second_moves.append((tar2loc[tarvar], freshloc))
for tarloc, freshloc in second_moves:
gen.emit_move(tarloc, freshloc)
| Python |
#
| Python |
"""
This backend records all operations that the JIT front-end tries to do,
and writes them as pseudo-Python source in
/tmp/usession-<yourname>/rdumpgenop.py.
"""
import os
from pypy.rlib.objectmodel import specialize, we_are_translated
from pypy.rpython.lltypesystem import lltype, llmemory
from pypy.jit.codegen.model import GenBuilder, CodeGenSwitch
from pypy.jit.codegen.llgraph import rgenop as llrgenop
from pypy.tool.udir import udir
LOGFILE = str(udir.join('rdumpgenop.py'))
class FlexSwitch(CodeGenSwitch):
def __init__(self, rgenop, fs):
self.rgenop = rgenop
self.fs = fs
self.name = rgenop.count('flexswitch')
self.dump = rgenop.dump
def add_case(self, gv_case):
b = self.fs.add_case(gv_case)
b = Builder(self.rgenop, b)
self.dump("%s = %s.add_case(%s)" % (b.name,
self.name,
self.rgenop.vname(gv_case)))
return b
class Builder(GenBuilder):
def __init__(self, rgenop, llbuilder):
self.rgenop = rgenop
self.llbuilder = llbuilder
self.name = rgenop.count('builder')
self.dump = rgenop.dump
def start_writing(self):
self.dump("%s.start_writing()" % self.name)
self.llbuilder.start_writing()
def enter_next_block(self, kinds, args_gv):
self.dump("args_gv = [%s]" % self.rgenop.vlistname(args_gv))
lbl = self.llbuilder.enter_next_block(kinds, args_gv)
self.dump("%s = %s.enter_next_block([%s], args_gv)" % (
self.rgenop.lblname(lbl),
self.name,
self.rgenop.kindtokensname(kinds)))
self.dump("%s = args_gv" % self.rgenop.vlistassname(args_gv))
return lbl
def jump_if_false(self, gv_condition, args_for_jump_gv):
b = self.llbuilder.jump_if_false(gv_condition, args_for_jump_gv)
b = Builder(self.rgenop, b)
self.dump("%s = %s.jump_if_false(%s, [%s])" % (
b.name,
self.name,
self.rgenop.vname(gv_condition),
self.rgenop.vlistname(args_for_jump_gv)))
return b
def jump_if_true(self, gv_condition, args_for_jump_gv):
b = self.llbuilder.jump_if_true(gv_condition, args_for_jump_gv)
b = Builder(self.rgenop, b)
self.dump("%s = %s.jump_if_true(%s, [%s])" % (
b.name,
self.name,
self.rgenop.vname(gv_condition),
self.rgenop.vlistname(args_for_jump_gv)))
return b
def finish_and_goto(self, outputargs_gv, targetlbl):
self.dump("%s.finish_and_goto([%s], %s)" % (
self.name,
self.rgenop.vlistname(outputargs_gv),
self.rgenop.lblname(targetlbl)))
self.llbuilder.finish_and_goto(outputargs_gv, targetlbl)
def finish_and_return(self, sigtoken, gv_returnvar):
self.dump("%s.finish_and_return(%s, %s)" % (
self.name,
self.rgenop.sigtokenname(sigtoken),
self.rgenop.vname(gv_returnvar)))
self.llbuilder.finish_and_return(sigtoken, gv_returnvar)
def pause_writing(self, alive_gv):
b = self.llbuilder.pause_writing(alive_gv)
b = Builder(self.rgenop, b)
self.dump("%s = %s.pause_writing([%s])" % (
b.name,
self.name,
self.rgenop.vlistname(alive_gv)))
return b
def end(self):
self.dump("%s.end()" % (self.name,))
self.llbuilder.end()
@specialize.arg(1)
def genop1(self, opname, gv_arg):
v = self.llbuilder.genop1(opname, gv_arg)
self.dump("%s = %s.genop1('%s', %s)" % (
self.rgenop.vname(v),
self.name,
opname,
self.rgenop.vname(gv_arg)))
return v
@specialize.arg(1)
def genraisingop1(self, opname, gv_arg):
v1, v2 = self.llbuilder.genraisingop1(opname, gv_arg)
self.dump("%s, %s = %s.genraisingop1('%s', %s)" % (
self.rgenop.vname(v1),
self.rgenop.vname(v2),
self.name,
opname,
self.rgenop.vname(gv_arg)))
return v1, v2
@specialize.arg(1)
def genop2(self, opname, gv_arg1, gv_arg2):
v = self.llbuilder.genop2(opname, gv_arg1, gv_arg2)
self.dump("%s = %s.genop2('%s', %s, %s)" % (
self.rgenop.vname(v),
self.name,
opname,
self.rgenop.vname(gv_arg1),
self.rgenop.vname(gv_arg2)))
return v
@specialize.arg(1)
def genraisingop2(self, opname, gv_arg1, gv_arg2):
v1, v2 = self.llbuilder.genraisingop2(opname, gv_arg1, gv_arg2)
self.dump("%s, %s = %s.genraisingop2('%s', %s, %s)" % (
self.rgenop.vname(v1),
self.rgenop.vname(v2),
self.name,
opname,
self.rgenop.vname(gv_arg1),
self.rgenop.vname(gv_arg2)))
return v1, v2
def genop_ptr_iszero(self, kind, gv_ptr):
v = self.llbuilder.genop_ptr_iszero(kind, gv_ptr)
self.dump("%s = %s.genop_ptr_iszero(%s, %s)" % (
self.rgenop.vname(v),
self.name,
self.rgenop.kindtokenname(kind),
self.rgenop.vname(gv_ptr)))
return v
def genop_ptr_nonzero(self, kind, gv_ptr):
v = self.llbuilder.genop_ptr_nonzero(kind, gv_ptr)
self.dump("%s = %s.genop_ptr_nonzero(%s, %s)" % (
self.rgenop.vname(v),
self.name,
self.rgenop.kindtokenname(kind),
self.rgenop.vname(gv_ptr)))
return v
def genop_ptr_eq(self, kind, gv_ptr1, gv_ptr2):
v = self.llbuilder.genop_ptr_eq(kind, gv_ptr1, gv_ptr2)
self.dump("%s = %s.genop_ptr_eq(%s, %s, %s)" % (
self.rgenop.vname(v),
self.name,
self.rgenop.kindtokenname(kind),
self.rgenop.vname(gv_ptr1),
self.rgenop.vname(gv_ptr2)))
return v
def genop_ptr_ne(self, kind, gv_ptr1, gv_ptr2):
v = self.llbuilder.genop_ptr_ne(kind, gv_ptr1, gv_ptr2)
self.dump("%s = %s.genop_ptr_ne(%s, %s, %s)" % (
self.rgenop.vname(v),
self.name,
self.rgenop.kindtokenname(kind),
self.rgenop.vname(gv_ptr1),
self.rgenop.vname(gv_ptr2)))
return v
def genop_cast_int_to_ptr(self, kind, gv_int):
v = self.llbuilder.genop_cast_int_to_ptr(kind, gv_int)
self.dump("%s = %s.genop_cast_int_to_ptr(%s, %s)" % (
self.rgenop.vname(v),
self.name,
self.rgenop.kindtokenname(kind),
self.rgenop.vname(gv_int)))
return v
def genop_same_as(self, kind, gv_x):
v = self.llbuilder.genop_same_as(kind, gv_x)
self.dump("%s = %s.genop_same_as(%s, %s)" % (
self.rgenop.vname(v),
self.name,
self.rgenop.kindtokenname(kind),
self.rgenop.vname(gv_x)))
return v
def genop_call(self, sigtoken, gv_fnptr, args_gv):
v = self.llbuilder.genop_call(sigtoken, gv_fnptr, args_gv)
self.dump("%s = %s.genop_call(%s, %s, [%s])" % (
self.rgenop.vname(v),
self.name,
self.rgenop.sigtokenname(sigtoken),
self.rgenop.vname(gv_fnptr),
self.rgenop.vlistname(args_gv)))
return v
def genop_malloc_fixedsize(self, alloctoken):
v = self.llbuilder.genop_malloc_fixedsize(alloctoken)
self.dump("%s = %s.genop_malloc_fixedsize(%s)" % (
self.rgenop.vname(v),
self.name,
self.rgenop.alloctokenname(alloctoken)))
return v
def genop_malloc_varsize(self, varsizealloctoken, gv_size):
v = self.llbuilder.genop_malloc_varsize(varsizealloctoken, gv_size)
self.dump("%s = %s.genop_malloc_varsize(%s, %s)" % (
self.rgenop.vname(v),
self.name,
self.rgenop.varsizealloctokenname(varsizealloctoken),
self.rgenop.vname(gv_size)))
return v
def genop_getfield(self, fieldtoken, gv_ptr):
v = self.llbuilder.genop_getfield(fieldtoken, gv_ptr)
self.dump("%s = %s.genop_getfield(%s, %s)" % (
self.rgenop.vname(v),
self.name,
self.rgenop.fieldtokenname(fieldtoken),
self.rgenop.vname(gv_ptr)))
return v
def genop_setfield(self, fieldtoken, gv_ptr, gv_value):
self.dump("%s.genop_setfield(%s, %s, %s)" % (
self.name,
self.rgenop.fieldtokenname(fieldtoken),
self.rgenop.vname(gv_ptr),
self.rgenop.vname(gv_value)))
self.llbuilder.genop_setfield(fieldtoken, gv_ptr, gv_value)
def genop_getsubstruct(self, fieldtoken, gv_ptr):
v = self.llbuilder.genop_getsubstruct(fieldtoken, gv_ptr)
self.dump("%s = %s.genop_getsubstruct(%s, %s)" % (
self.rgenop.vname(v),
self.name,
self.rgenop.fieldtokenname(fieldtoken),
self.rgenop.vname(gv_ptr)))
return v
def genop_getarrayitem(self, arraytoken, gv_array, gv_index):
v = self.llbuilder.genop_getarrayitem(arraytoken, gv_array, gv_index)
self.dump("%s = %s.genop_getarrayitem(%s, %s, %s)" % (
self.rgenop.vname(v),
self.name,
self.rgenop.arraytokenname(arraytoken),
self.rgenop.vname(gv_array),
self.rgenop.vname(gv_index)))
return v
def genop_setarrayitem(self, arraytoken, gv_array, gv_index, gv_value):
self.dump("%s.genop_setarrayitem(%s, %s, %s, %s)" % (
self.name,
self.rgenop.arraytokenname(arraytoken),
self.rgenop.vname(gv_array),
self.rgenop.vname(gv_index),
self.rgenop.vname(gv_value)))
self.llbuilder.genop_setarrayitem(arraytoken, gv_array,
gv_index, gv_value)
def genop_getarraysubstruct(self, arraytoken, gv_array, gv_index):
v = self.llbuilder.genop_getarraysubstruct(arraytoken, gv_array,
gv_index)
self.dump("%s = %s.genop_getarraysubstruct(%s, %s, %s)" % (
self.rgenop.vname(v),
self.name,
self.rgenop.arraytokenname(arraytoken),
self.rgenop.vname(gv_array),
self.rgenop.vname(gv_index)))
return v
def genop_getarraysize(self, arraytoken, gv_array):
v = self.llbuilder.genop_getarraysize(arraytoken, gv_array)
self.dump("%s = %s.genop_getarraysize(%s, %s)" % (
self.rgenop.vname(v),
self.name,
self.rgenop.arraytokenname(arraytoken),
self.rgenop.vname(gv_array)))
return v
def flexswitch(self, gv_exitswitch, args_gv):
fs, b = self.llbuilder.flexswitch(gv_exitswitch, args_gv)
fs = FlexSwitch(self.rgenop, fs)
b = Builder(self.rgenop, b)
self.dump("%s, %s = %s.flexswitch(%s, [%s])" % (
fs.name,
b.name,
self.name,
self.rgenop.vname(gv_exitswitch),
self.rgenop.vlistname(args_gv)))
return fs, b
def show_incremental_progress(self):
self.llbuilder.show_incremental_progress()
def log(self, msg):
self.rgenop.dump('# log: %s' % (msg,))
def genop_get_frame_base(self):
v = self.llbuilder.genop_get_frame_base()
self.dump("%s = %s.genop_get_frame_base()" % (
self.rgenop.vname(v),
self.name))
return v
def get_frame_info(self, vars_gv):
info = self.llbuilder.get_frame_info(vars_gv)
self.dump("%s = %s.get_frame_info([%s])" % (
info,
self.name,
self.rgenop.vlistname(vars_gv)))
return info
def alloc_frame_place(self, kind, gv_initial_value=None):
place = self.llbuilder.alloc_frame_place(kind, gv_initial_value)
if gv_initial_value is None:
s = 'None'
else:
s = self.rgenop.vname(gv_initial_value)
self.dump("%s = %s.alloc_frame_place(%s, %s)" % (
place,
self.name,
self.rgenop.kindtokenname(kind),
s))
return place
def genop_absorb_place(self, kind, place):
v = self.llbuilder.genop_absorb_place(kind, place)
self.dump("%s = %s.genop_absorb_place(%s, %s)" % (
self.rgenop.vname(v),
self.name,
self.rgenop.kindtokenname(kind),
place))
return v
class RDumpGenOp(llrgenop.RGenOp):
def __init__(self):
self.keepalive_gc_refs = []
self.counters = {}
self.vnames = {}
self.lblnames = {}
self.dump("# ------------------------------------------------------------")
def count(self, prefix):
count = self.counters.get(prefix, 0)
self.counters[prefix] = count + 1
return '%s%d' % (prefix, count)
def vname(self, gv):
try:
return self.vnames[gv]
except KeyError:
if not gv.is_const:
name = self.count('v')
else:
name = 'rgenop.genconst(%s)' % gv.revealconstrepr()
self.vnames[gv] = name
return name
def vlistname(self, list_gv):
return ', '.join([self.vname(v) for v in list_gv])
def vlistassname(self, list_gv):
# [] = x => SyntaxError, grumble
if list_gv:
return '[%s]' % self.vlistname(list_gv)
else:
return '_'
def lblname(self, lbl):
try:
return self.lblnames[lbl]
except KeyError:
name = self.count('label')
self.lblnames[lbl] = name
return name
def kindtokenname(self, kindtoken):
return kindtokennames.get(kindtoken, 'kindtoken')
def kindtokensname(self, kindtokens):
return ', '.join([self.kindtokenname(k) for k in kindtokens])
def sigtokenname(self, sigtoken):
numargs = len(sigtoken[0])
return 'rgenop.sigToken(FUNC%d)' % numargs
def alloctokenname(self, alloctoken):
return 'alloctoken'
def varsizealloctokenname(self, varsizealloctoken):
return 'varsizealloctoken'
def fieldtokenname(self, fieldtoken):
return 'fieldtoken'
def arraytokenname(self, arraytoken):
return 'arraytoken'
@staticmethod
@specialize.memo()
def kindToken(T):
result = llrgenop.rgenop.kindToken(T)
kindtokennames[result] = str(T).lower() + '_kind'
return result
@staticmethod
def dump(text):
print text
text += '\n'
fd = os.open(LOGFILE, os.O_WRONLY|os.O_CREAT, 0666)
os.lseek(fd, 0, 2)
while text:
count = os.write(fd, text)
if count == 0:
raise IOError
text = text[count:]
os.close(fd)
def newgraph(self, sigtoken, name):
builder, gv_callable, inputargs_gv = llrgenop.RGenOp.newgraph(
self, sigtoken, name)
builder = Builder(self, builder)
self.dump("# new graph %s" % self.vname(gv_callable))
self.dump("%s, gv_callable, %s = rgenop.newgraph(%s, '%s')" % (
builder.name,
self.vlistassname(inputargs_gv),
self.sigtokenname(sigtoken),
name))
return builder, gv_callable, inputargs_gv
def replay(self, label, kinds):
self.dump("# replay")
b, args_gv = llrgenop.RGenOp.replay(self, label, kinds)
b = Builder(self, b)
self.dump("%s, %s = rgenop.replay(%s, [%s])" % (
b.name,
self.vlistassname(args_gv),
self.lblname(label),
self.kindtokensname(kinds)))
return b, args_gv
@staticmethod
@specialize.arg(0)
def read_frame_var(T, base, info, index):
RDumpGenOp.dump("# read_frame_var(info=%s, index=%d)" % (info, index))
return llrgenop.RGenOp.read_frame_var(T, base, info, index)
@staticmethod
@specialize.arg(0)
def write_frame_place(T, base, place, value):
RDumpGenOp.dump("# write_frame_place(place=%s)" % (place,))
llrgenop.RGenOp.write_frame_place(T, base, place, value)
@staticmethod
@specialize.arg(0)
def read_frame_place(T, base, place):
RDumpGenOp.dump("# read_frame_place(place=%s)" % (place,))
return llrgenop.RGenOp.read_frame_place(T, base, place)
kindtokennames = {}
| Python |
#
| Python |
class HighLevelJITInfo:
"""
A singleton class for the RPython-level JITed program to push information
that the backend can use or log.
"""
sys_executable = None
highleveljitinfo = HighLevelJITInfo()
| Python |
import ctypes
import pypy.rpython.rctypes.implementation
from pypy.rpython.rctypes.tool import ctypes_platform
from pypy.rpython.rctypes.tool.ctypes_platform import ConstantInteger
from pypy.rpython.rctypes.tool.ctypes_platform import SimpleType
class CConfig:
_header_ = '#include <Windows.h>'
SIZE_T = SimpleType('SIZE_T', ctypes.c_long)
DWORD = SimpleType('DWORD', ctypes.c_long)
BOOL = SimpleType('BOOL', ctypes.c_int)
MEM_COMMIT = ConstantInteger('MEM_COMMIT')
MEM_RESERVE = ConstantInteger('MEM_RESERVE')
MEM_RELEASE = ConstantInteger('MEM_RELEASE')
PAGE_EXECUTE_READWRITE = ConstantInteger('PAGE_EXECUTE_READWRITE')
globals().update(ctypes_platform.configure(CConfig))
# cannot use c_void_p as return value of functions :-(
PTR = ctypes.POINTER(ctypes.c_char)
VirtualAlloc = ctypes.windll.kernel32.VirtualAlloc
VirtualAlloc.argtypes = [PTR, SIZE_T, DWORD, DWORD]
VirtualAlloc.restype = PTR
VirtualProtect = ctypes.windll.kernel32.VirtualProtect
VirtualProtect.argtypes = [PTR, SIZE_T, DWORD, ctypes.POINTER(DWORD)]
VirtualProtect.restype = BOOL
VirtualFree = ctypes.windll.kernel32.VirtualFree
VirtualFree.argtypes = [PTR, SIZE_T, DWORD]
VirtualFree.restype = BOOL
# ____________________________________________________________
def alloc(map_size):
res = VirtualAlloc(PTR(), map_size, MEM_COMMIT|MEM_RESERVE,
PAGE_EXECUTE_READWRITE)
if not res:
raise MemoryError
old = DWORD()
VirtualProtect(res, map_size, PAGE_EXECUTE_READWRITE, ctypes.byref(old))
# ignore errors, just try
return res
def free(ptr, map_size):
VirtualFree(ptr, 0, MEM_RELEASE)
| Python |
"""
List of i386 instructions.
This module contains the logic to set up the I386CodeBuilder multimethods.
Not for direct importing.
"""
from ri386 import *
from pypy.objspace.std.multimethod import MultiMethodTable, InstallerVersion2
from pypy.tool.sourcetools import compile2
def reg2modrm(builder, reg):
return memregister(reg)
def reg2modrm8(builder, reg):
return memregister8(reg)
type_order = {
EAX: [(EAX, None), (REG, None), (MODRM, reg2modrm)],
ECX: [(ECX, None), (REG, None), (MODRM, reg2modrm)],
EDX: [(EDX, None), (REG, None), (MODRM, reg2modrm)],
EBX: [(EBX, None), (REG, None), (MODRM, reg2modrm)],
ESP: [(ESP, None), (REG, None), (MODRM, reg2modrm)],
EBP: [(EBP, None), (REG, None), (MODRM, reg2modrm)],
ESI: [(ESI, None), (REG, None), (MODRM, reg2modrm)],
EDI: [(EDI, None), (REG, None), (MODRM, reg2modrm)],
AL: [(AL, None), (REG8, None), (MODRM8, reg2modrm8)],
CL: [(CL, None), (REG8, None), (MODRM8, reg2modrm8)],
DL: [(DL, None), (REG8, None), (MODRM8, reg2modrm8)],
BL: [(BL, None), (REG8, None), (MODRM8, reg2modrm8)],
AH: [(AH, None), (REG8, None), (MODRM8, reg2modrm8)],
CH: [(CH, None), (REG8, None), (MODRM8, reg2modrm8)],
DH: [(DH, None), (REG8, None), (MODRM8, reg2modrm8)],
BH: [(BH, None), (REG8, None), (MODRM8, reg2modrm8)],
REG: [(REG, None), (MODRM, reg2modrm)],
REG8: [(REG8, None), (MODRM8, reg2modrm8)],
IMM32: [(IMM32, None)],
IMM16: [(IMM16, None)], # only for RET
IMM8: [(IMM8, None), (IMM32, None)],
REL32: [(REL32, None)],
MODRM: [(MODRM, None)],
MODRM8: [(MODRM8, None)],
MISSING: [(MISSING, None)], # missing operands
}
class operand:
def __init__(self, op, width='i'):
self.op = op
self.width = width
class orbyte(operand):
def __init__(self, value):
self.value = value
def eval(self, lines, has_orbyte):
if has_orbyte:
lines.append('orbyte |= %d' % self.value)
else:
lines.append('orbyte = %d' % self.value)
return True
class register(operand):
def __init__(self, op, factor=1, width='i'):
self.op = op
self.factor = factor
self.width = width
def eval(self, lines, has_orbyte):
value = 'arg%d.op' % self.op
if self.factor != 1:
value = '%s * %d' % (value, self.factor)
if has_orbyte:
lines.append('orbyte |= %s' % value)
else:
lines.append('orbyte = %s' % value)
return True
class modrm(operand):
def eval(self, lines, has_orbyte):
expr = 'arg%d.byte' % self.op
if has_orbyte:
expr = 'orbyte | %s' % expr
lines.append('builder.write(chr(%s))' % expr)
lines.append('builder.write(arg%d.extradata)' % self.op)
return False
class immediate(operand):
def eval(self, lines, has_orbyte):
assert not has_orbyte, "malformed bytecode"
if self.width == 'i':
packer = 'packimm32'
elif self.width == 'b':
packer = 'packimm8'
elif self.width == 'h':
packer = 'packimm16'
else:
raise AssertionError, "invalid width %r" % (self.width,)
lines.append('builder.write(%s(arg%d.value))' % (packer, self.op))
return False
class relative(operand):
def eval(self, lines, has_orbyte):
assert not has_orbyte, "malformed bytecode"
assert self.width == 'i', "only REL32 supported at the moment"
lines.append('offset = arg%d.absolute_target - (builder.tell()+4)' % (
self.op,))
lines.append('builder.write(packimm32(offset))')
return False
##class conditioncode(operand):
## def __init__(self):
## pass
## def eval(self, lines, has_orbyte):
## assert not has_orbyte, "malformed bytecode"
## lines.append('orbyte = arg1.value')
## return True
def consolidate(code1):
for i in range(len(code1)-1, 0, -1):
curop = code1[i]
prevop = code1[i-1]
if isinstance(curop, str):
if not curop:
del code1[i]
continue
if isinstance(prevop, str):
code1[i-1] = prevop + curop
del code1[i]
continue
if isinstance(prevop, orbyte):
code1[i-1] = chr(prevop.value | ord(curop[0])) + curop[1:]
del code1[i]
continue
elif isinstance(curop, orbyte):
if not curop.value:
del code1[i]
continue
if isinstance(prevop, orbyte):
code1[i-1] = orbyte(curop.value | prevop.value)
del code1[i]
continue
def generate_function(sig, opcodes):
consolidate(opcodes)
lines = []
has_orbyte = False
for op in opcodes:
if isinstance(op, str):
if has_orbyte:
nextbyte = ord(op[0])
if nextbyte:
lines.append('orbyte |= %d' % nextbyte)
lines.append('builder.write(chr(orbyte))')
has_orbyte = False
op = op[1:]
if op:
lines.append('builder.write(%r)' % (op,))
else:
has_orbyte = op.eval(lines, has_orbyte)
assert not has_orbyte, "malformed bytecode"
if not lines:
lines.append('pass')
args = ', '.join(['builder'] + ['arg%d'%i for i in range(1, len(sig)+1)])
lines.insert(0, 'def encode(%s):' % args)
source = '\n '.join(lines) + '\n'
miniglobals = {
'packimm32': packimm32,
'packimm8': packimm8,
'packimm16': packimm16,
}
exec compile2(source) in miniglobals
return miniglobals['encode']
class Instruction:
indirect = 0
as_all_suffixes = 0
as_alias = None
name = '???' # initialized by setup()
def __init__(self):
self.modes = {}
def setup(self, name):
self.name = name
arity = max([len(mm) for mm in self.modes])
if arity == 0:
encoder = generate_function([], self.modes[()])
else:
table = MultiMethodTable(arity, root_class=OPERAND,
argnames_before=['builder'])
for mm, opcodes in self.modes.items():
sig = list(mm) + [MISSING] * (arity - len(mm))
for cls in sig:
assert issubclass(cls, OPERAND)
encoder1 = generate_function(sig, opcodes)
table.register(encoder1, *sig)
# always use the InstallerVersion2, including for testing,
# because it produces code that is more sensitive to
# registration errors
encoder = table.install('__encode' + name, [type_order] * arity,
installercls = InstallerVersion2)
mmmin = min([len(mm) for mm in self.modes])
if mmmin < arity:
encoder.func_defaults = (missing,) * (arity - mmmin)
setattr(I386CodeBuilder, name, encoder)
def __repr__(self):
return '<%s>' % self.name
def mode0(self, code):
self._mode((), code)
def mode1(self, m1, code):
self._mode((m1,), code)
def mode2(self, m1, m2, code):
self._mode((m1, m2), code)
def mode3(self, m1, m2, m3, code):
self._mode((m1, m2, m3), code)
def _mode(self, mm, code):
self.modes[mm] = code
def common_modes(self, group):
base = group * 8
self.mode2(EAX, IMM8, ['\x83', orbyte(group<<3), '\xC0',
immediate(2,'b')])
self.mode2(MODRM, IMM8, ['\x83', orbyte(group<<3), modrm(1),
immediate(2,'b')])
self.mode2(EAX, IMM32, [chr(base+5), immediate(2)])
self.mode2(MODRM, IMM32, ['\x81', orbyte(group<<3), modrm(1),
immediate(2)])
self.mode2(REG, REG, [chr(base+1), register(2,8), register(1,1),
'\xC0'])
self.mode2(MODRM, REG, [chr(base+1), register(2,8), modrm(1)])
self.mode2(REG, MODRM, [chr(base+3), register(1,8), modrm(2)])
self.mode2(AL, IMM8, [chr(base+4), immediate(2,'b')])
self.mode2(MODRM8,IMM8, ['\x80', orbyte(group<<3), modrm(1,'b'),
immediate(2,'b')])
self.mode2(REG8, REG8, [chr(base+0), register(2,8,'b'),
register(1,1,'b'), '\xC0'])
self.mode2(MODRM8,REG8, [chr(base+0), register(2,8,'b'), modrm(1,'b')])
self.mode2(REG8, MODRM8,[chr(base+2), register(1,8,'b'), modrm(2,'b')])
MOV = Instruction()
##for e in [EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI,
## AL, CL, DL, BL, AH, CH, DH, BH]:
## MOV.mode2(e, e, []) # 'MOV <register>, <same register>'
##del e
#MOV.mode2(EAX, MEMABS,['\xA1', memabsolute(2)])
#MOV.mode2(MEMABS,EAX, ['\xA3', memabsolute(1)])
MOV.mode2(REG, IMM32, [register(1), '\xB8', immediate(2)])
MOV.mode2(MODRM, IMM32, ['\xC7', orbyte(0<<3), modrm(1), immediate(2)])
MOV.mode2(REG, REG, ['\x89', register(2,8), register(1), '\xC0'])
MOV.mode2(MODRM, REG, ['\x89', register(2,8), modrm(1)])
MOV.mode2(REG, MODRM, ['\x8B', register(1,8), modrm(2)])
#MOV.mode2(AL, MEMABS,['\xA0', memabsolute(2,'b')])
#MOV.mode2(MEMABS,AL, ['\xA2', memabsolute(1,'b')])
MOV.mode2(REG8, IMM8, [register(1,1,'b'), '\xB0', immediate(2,'b')])
MOV.mode2(MODRM8,IMM8, ['\xC6', orbyte(0<<3), modrm(1,'b'), immediate(2,'b')])
MOV.mode2(REG8, REG8, ['\x88', register(2,8,'b'), register(1,1,'b'), '\xC0'])
MOV.mode2(MODRM8,REG8, ['\x88', register(2,8,'b'), modrm(1,'b')])
MOV.mode2(REG8, MODRM8,['\x8A', register(1,8,'b'), modrm(2,'b')])
# special modes for writing explicit 16-bit immediates (must also use o16!)
MOV.mode2(REG, IMM16, [register(1), '\xB8', immediate(2,'h')])
MOV.mode2(MODRM, IMM16, ['\xC7', orbyte(0<<3), modrm(1), immediate(2,'h')])
ADD = Instruction()
ADD.common_modes(0)
OR = Instruction()
OR.common_modes(1)
ADC = Instruction()
ADC.common_modes(2)
SBB = Instruction()
SBB.common_modes(3)
AND = Instruction()
AND.common_modes(4)
SUB = Instruction()
SUB.common_modes(5)
XOR = Instruction()
XOR.common_modes(6)
CMP = Instruction()
CMP.common_modes(7)
NOP = Instruction()
NOP.mode0(['\x90'])
RET = Instruction()
RET.mode0(['\xC3'])
RET.mode1(IMM16, ['\xC2', immediate(1,'h')])
CALL = Instruction()
CALL.mode1(REL32, ['\xE8', relative(1)])
CALL.mode1(MODRM, ['\xFF', orbyte(2<<3), modrm(1)])
CALL.indirect = 1
JMP = Instruction()
#JMP.mode1(REL8, ['\xEB', immediate(1,'b')])
JMP.mode1(REL32, ['\xE9', relative(1)])
JMP.mode1(MODRM, ['\xFF', orbyte(4<<3), modrm(1)])
JMP.indirect = 1
PUSH = Instruction()
PUSH.mode1(IMM8, ['\x6A', immediate(1,'b')])
PUSH.mode1(IMM32, ['\x68', immediate(1)])
PUSH.mode1(REG, [register(1), '\x50'])
PUSH.mode1(MODRM, ['\xFF', orbyte(6<<3), modrm(1)])
PUSHF = Instruction()
PUSHF.mode0(['\x9C'])
POP = Instruction()
POP.mode1(REG, [register(1), '\x58'])
POP.mode1(MODRM, ['\x8F', orbyte(0<<3), modrm(1)])
POPF = Instruction()
POPF.mode0(['\x9D'])
IMUL = Instruction()
IMUL.mode1(MODRM, ['\xF7', orbyte(5<<3), modrm(1)])
IMUL.mode1(MODRM8, ['\xF6', orbyte(5<<3), modrm(1)])
IMUL.mode3(REG, MODRM, IMM8, ['\x6B', register(1,8), modrm(2), immediate(3,'b')])
IMUL.mode3(REG, MODRM, IMM32,['\x69', register(1,8), modrm(2), immediate(3)])
IMUL.mode2(REG, IMM8, ['\x6B', register(1,9), '\xC0', immediate(2,'b')])
IMUL.mode2(REG, IMM32, ['\x69', register(1,9), '\xC0', immediate(2)])
IMUL.mode2(REG, MODRM, ['\x0F\xAF', register(1,8), modrm(2)])
IDIV = Instruction()
IDIV.mode1(MODRM, ['\xF7', orbyte(7<<3), modrm(1)])
IDIV.mode1(MODRM8, ['\xF6', orbyte(7<<3), modrm(1)])
MUL = Instruction()
MUL.mode1(MODRM, ['\xF7', orbyte(4<<3), modrm(1)])
MUL.mode1(MODRM8, ['\xF6', orbyte(4<<3), modrm(1)])
DIV = Instruction()
DIV.mode1(MODRM, ['\xF7', orbyte(6<<3), modrm(1)])
DIV.mode1(MODRM8, ['\xF6', orbyte(6<<3), modrm(1)])
NEG = Instruction()
NEG.mode1(MODRM, ['\xF7', orbyte(3<<3), modrm(1)])
NEG.mode1(MODRM8, ['\xF6', orbyte(3<<3), modrm(1)])
NOT = Instruction()
NOT.mode1(MODRM, ['\xF7', orbyte(2<<3), modrm(1)])
NOT.mode1(MODRM8, ['\xF6', orbyte(2<<3), modrm(1)])
CDQ = Instruction()
CDQ.mode0(['\x99'])
MOVSX = Instruction()
MOVSX.mode2(REG, MODRM8, ['\x0F\xBE', register(1,8), modrm(2,'b')])
MOVSX.as_all_suffixes = 1
MOVSX.as_alias = "MOVS"
MOVZX = Instruction()
MOVZX.mode2(REG, MODRM8, ['\x0F\xB6', register(1,8), modrm(2,'b')])
MOVZX.mode2(REG, MODRM, ['\x0F\xB7', register(1,8), modrm(2)])
# ^^^ but this only reads the 16 lower bits of the source
MOVZX.as_all_suffixes = 1
MOVZX.as_alias = "MOVZ"
INC = Instruction()
INC.mode1(REG, [register(1), '\x40'])
INC.mode1(MODRM, ['\xFF', orbyte(0<<3), modrm(1)])
INC.mode1(MODRM8,['\xFE', orbyte(0<<3), modrm(1,'b')])
DEC = Instruction()
DEC.mode1(REG, [register(1), '\x48'])
DEC.mode1(MODRM, ['\xFF', orbyte(1<<3), modrm(1)])
DEC.mode1(MODRM8,['\xFE', orbyte(1<<3), modrm(1,'b')])
XCHG = Instruction()
XCHG.mode2(EAX, REG, [register(2), '\x90'])
XCHG.mode2(REG, EAX, [register(1), '\x90'])
XCHG.mode2(REG, REG, ['\x87', register(2,8), register(1), '\xC0'])
XCHG.mode2(MODRM, REG, ['\x87', register(2,8), modrm(1)])
XCHG.mode2(REG, MODRM, ['\x87', register(1,8), modrm(2)])
XCHG.mode2(REG8, REG8, ['\x86', register(2,8,'b'), register(1,1,'b'),'\xC0'])
XCHG.mode2(MODRM8, REG8, ['\x86', register(2,8,'b'), modrm(1,'b')])
XCHG.mode2(REG8, MODRM8, ['\x86', register(1,8,'b'), modrm(2,'b')])
LEA = Instruction()
LEA.mode2(REG, MODRM, ['\x8D', register(1,8), modrm(2)])
LEA.mode2(REG, MODRM8, ['\x8D', register(1,8), modrm(2)])
# some cases produce a MODRM8, but the result is always a 32-bit REG
# and the encoding is the same
SHL = Instruction()
SHL.mode2(MODRM, IMM8, ['\xC1', orbyte(4<<3), modrm(1), immediate(2,'b')])
SHL.mode2(MODRM, CL, ['\xD3', orbyte(4<<3), modrm(1)])
SHR = Instruction()
SHR.mode2(MODRM, IMM8, ['\xC1', orbyte(5<<3), modrm(1), immediate(2,'b')])
SHR.mode2(MODRM, CL, ['\xD3', orbyte(5<<3), modrm(1)])
SAR = Instruction()
SAR.mode2(MODRM, IMM8, ['\xC1', orbyte(7<<3), modrm(1), immediate(2,'b')])
SAR.mode2(MODRM, CL, ['\xD3', orbyte(7<<3), modrm(1)])
TEST = Instruction()
TEST.mode2(REG, MODRM, ['\x85', register(1,8), modrm(2)])
TEST.mode2(MODRM, REG, ['\x85', register(2,8), modrm(1)])
TEST.mode2(EAX, IMM32, ['\xA9', immediate(2)])
TEST.mode2(MODRM, IMM32, ['\xF7', orbyte(0<<3), modrm(1), immediate(2)])
INT = Instruction()
INT.mode1(IMM8, ['\xCD', immediate(1, 'b')])
INTO = Instruction()
INTO.mode0(['\xCE'])
BREAKPOINT = Instruction() # INT 3
BREAKPOINT.mode0(['\xCC'])
BREAKPOINT.as_alias = "INT3"
UD2 = Instruction() # reserved as an illegal instruction
UD2.mode0(['\x0F\x0B'])
o16 = Instruction() # 16-bits instruction prefix (name from 'nasm')
o16.mode0(['\x66'])
Conditions = {
'O': 0,
'NO': 1,
'C': 2, 'B': 2, 'NAE': 2,
'NC': 3, 'NB': 3, 'AE': 3,
'Z': 4, 'E': 4,
'NZ': 5, 'NE': 5,
'BE': 6, 'NA': 6,
'NBE': 7, 'A': 7,
'S': 8,
'NS': 9,
'P': 10, 'PE': 10,
'NP': 11, 'PO': 11,
'L': 12, 'NGE': 12,
'NL': 13, 'GE': 13,
'LE': 14, 'NG': 14,
'NLE': 15, 'G': 15,
}
def define_cond(prefix, indirect, modes, code):
idx = code.index(None)
for key, value in Conditions.items():
name = prefix + key
instr = globals().setdefault(name, Instruction())
code1 = code[:]
code1[idx] = orbyte(value)
instr._mode(modes, code1)
instr.indirect = indirect
#define_cond('J', 1, (REL8,), [None,'\x70', immediate(1,'b')])
define_cond('J', 1, (REL32,), ['\x0F', None,'\x80', relative(1)])
define_cond('SET', 0, (MODRM8,), ['\x0F', None,'\x90',orbyte(0<<3),modrm(1,'b')])
define_cond('CMOV',0,(REG,MODRM),['\x0F', None,'\x40', register(1,8), modrm(2)])
# note: CMOVxx are Pentium-class instructions, unknown to the 386 and 486
##Jcond = Instruction()
##Jcond.mode2( IMM8, REL32, ['\x0F', conditioncode(),'\x80', relative(2)])
##SETcond = Instruction()
##SETcond.mode2(IMM8, MODRM8, ['\x0F', conditioncode(),'\x90', orbyte(0<<3),
## modrm(2,'b')])
##CMOVcond = Instruction()
##CMOVcond.mode3(IMM8,REG,MODRM, ['\x0F', conditioncode(),'\x40', register(2,8),
## modrm(3)])
all_instructions = {}
for key, value in globals().items():
if isinstance(value, Instruction):
value.setup(key)
all_instructions[key] = value
| Python |
import pypy.rpython.rctypes.implementation # register rctypes types
from pypy.rpython.rctypes.tool import ctypes_platform
from pypy.rpython.rctypes.tool.libc import libc
from ctypes import POINTER, c_char, c_int, cast, c_void_p
class CConfig:
_includes_ = ("sys/types.h", "sys/mman.h")
size_t = ctypes_platform.SimpleType("size_t", c_int)
off_t = ctypes_platform.SimpleType("off_t", c_int)
MAP_PRIVATE = ctypes_platform.DefinedConstantInteger("MAP_PRIVATE")
MAP_ANON = ctypes_platform.DefinedConstantInteger("MAP_ANON")
MAP_ANONYMOUS = ctypes_platform.DefinedConstantInteger("MAP_ANONYMOUS")
PROT_READ = ctypes_platform.DefinedConstantInteger("PROT_READ")
PROT_WRITE = ctypes_platform.DefinedConstantInteger("PROT_WRITE")
PROT_EXEC = ctypes_platform.DefinedConstantInteger("PROT_EXEC")
globals().update(ctypes_platform.configure(CConfig))
if MAP_ANONYMOUS is None:
MAP_ANONYMOUS = MAP_ANON
assert MAP_ANONYMOUS is not None
del MAP_ANON
# ____________________________________________________________
PTR = POINTER(c_char) # cannot use c_void_p as return value of functions :-(
mmap_ = libc.mmap
mmap_.argtypes = [PTR, size_t, c_int, c_int, c_int, off_t]
mmap_.restype = PTR
mmap_.includes = ("sys/mman.h",)
munmap_ = libc.munmap
munmap_.argtypes = [PTR, size_t]
munmap_.restype = c_int
munmap_.includes = ("sys/mman.h",)
class Hint:
pos = -0x4fff0000 # for reproducible results
hint = Hint()
def alloc(map_size):
flags = MAP_PRIVATE | MAP_ANONYMOUS
prot = PROT_EXEC | PROT_READ | PROT_WRITE
res = mmap_(cast(c_void_p(hint.pos), PTR), map_size, prot, flags, -1, 0)
if cast(res, c_void_p).value == -1:
raise MemoryError
hint.pos += map_size
return res
free = munmap_
| Python |
import py
from pypy.rlib.objectmodel import specialize, we_are_translated
from pypy.rpython.lltypesystem import lltype, llmemory
from pypy.jit.codegen.model import AbstractRGenOp, GenLabel, GenBuilder
from pypy.jit.codegen.model import GenVar, GenConst, CodeGenSwitch
from pypy.jit.codegen.model import ReplayBuilder, dummy_var
from pypy.jit.codegen.i386.codebuf import CodeBlockOverflow
from pypy.jit.codegen.i386.operation import *
from pypy.jit.codegen.i386.regalloc import RegAllocator, DEBUG_STACK
from pypy.jit.codegen.i386.regalloc import gv_frame_base, StorageInStack
from pypy.jit.codegen.i386.regalloc import Place, OpAbsorbPlace, OpTouch
from pypy.jit.codegen.i386.regalloc import write_stack_reserve, write_stack_adj
from pypy.jit.codegen import conftest
from pypy.rpython.annlowlevel import llhelper
DEBUG_TRAP = conftest.option.trap
# ____________________________________________________________
class IntConst(GenConst):
def __init__(self, value):
self.value = value
@specialize.arg(1)
def revealconst(self, T):
return cast_int_to_whatever(T, self.value)
def __repr__(self):
"NOT_RPYTHON"
try:
return "const=%s" % (imm(self.value).assembler(),)
except TypeError: # from Symbolics
return "const=%r" % (self.value,)
def repr(self):
return "const=$%s" % (self.value,)
class AddrConst(GenConst):
def __init__(self, addr):
self.addr = addr
@specialize.arg(1)
def revealconst(self, T):
return cast_adr_to_whatever(T, self.addr)
def __repr__(self):
"NOT_RPYTHON"
return "const=%r" % (self.addr,)
def repr(self):
return "const=<0x%x>" % (llmemory.cast_adr_to_int(self.addr),)
@specialize.arg(0)
def cast_int_to_whatever(T, value):
if isinstance(T, lltype.Ptr):
return lltype.cast_int_to_ptr(T, value)
elif T is llmemory.Address:
return llmemory.cast_int_to_adr(value)
else:
return lltype.cast_primitive(T, value)
@specialize.arg(0)
def cast_whatever_to_int(T, value):
if isinstance(T, lltype.Ptr):
return lltype.cast_ptr_to_int(value)
elif T is llmemory.Address:
return llmemory.cast_adr_to_int(value)
else:
return lltype.cast_primitive(lltype.Signed, value)
@specialize.arg(0)
def cast_adr_to_whatever(T, addr):
if T is llmemory.Address:
return addr
elif isinstance(T, lltype.Ptr):
return llmemory.cast_adr_to_ptr(addr, T)
elif T is lltype.Signed:
return llmemory.cast_adr_to_int(addr)
else:
assert 0, "XXX not implemented"
# ____________________________________________________________
class FlexSwitch(CodeGenSwitch):
def __init__(self, rgenop, graphctx, reg, inputargs_gv, inputoperands):
self.rgenop = rgenop
self.graphctx = graphctx
self.reg = reg
self.inputargs_gv = inputargs_gv
self.inputoperands = inputoperands
self.defaultcaseaddr = 0
def initialize(self, mc):
self.graphctx.write_stack_adj(mc, initial=False)
self._reserve(mc)
default_builder = Builder(self.rgenop, self.graphctx,
self.inputargs_gv, self.inputoperands)
start = self.nextfreepos
end = self.endfreepos
fullmc = self.rgenop.InMemoryCodeBuilder(start, end)
default_builder.set_coming_from(fullmc)
fullmc.done()
default_builder.update_defaultcaseaddr_of = self
default_builder.start_writing()
return default_builder
def _reserve(self, mc):
RESERVED = 11*4+5 # XXX quite a lot for now :-/
pos = mc.tell()
mc.UD2()
mc.write('\x00' * (RESERVED-1))
self.nextfreepos = pos
self.endfreepos = pos + RESERVED
def _reserve_more(self):
start = self.nextfreepos
end = self.endfreepos
newmc = self.rgenop.open_mc()
self._reserve(newmc)
self.rgenop.close_mc(newmc)
fullmc = self.rgenop.InMemoryCodeBuilder(start, end)
fullmc.JMP(rel32(self.nextfreepos))
fullmc.done()
def add_case(self, gv_case):
rgenop = self.rgenop
targetbuilder = Builder(self.rgenop, self.graphctx,
self.inputargs_gv, self.inputoperands)
try:
self._add_case(gv_case, targetbuilder)
except CodeBlockOverflow:
self._reserve_more()
self._add_case(gv_case, targetbuilder)
targetbuilder.start_writing()
return targetbuilder
def _add_case(self, gv_case, targetbuilder):
start = self.nextfreepos
end = self.endfreepos
mc = self.rgenop.InMemoryCodeBuilder(start, end)
value = gv_case.revealconst(lltype.Signed)
mc.CMP(self.reg, imm(value))
targetbuilder.set_coming_from(mc, Conditions['E'])
pos = mc.tell()
assert self.defaultcaseaddr != 0
mc.JMP(rel32(self.defaultcaseaddr))
mc.done()
self.nextfreepos = pos
# ____________________________________________________________
GC_MALLOC = lltype.Ptr(lltype.FuncType([lltype.Signed], llmemory.Address))
def gc_malloc(size):
from pypy.rpython.lltypesystem.lloperation import llop
return llop.call_boehm_gc_alloc(llmemory.Address, size)
def gc_malloc_fnaddr():
"""Returns the address of the Boehm 'malloc' function."""
if we_are_translated():
gc_malloc_ptr = llhelper(GC_MALLOC, gc_malloc)
return lltype.cast_ptr_to_int(gc_malloc_ptr)
else:
# <pedronis> don't do this at home
import threading
if not isinstance(threading.currentThread(), threading._MainThread):
import py
py.test.skip("must run in the main thread")
try:
from ctypes import cast, c_void_p
from pypy.rpython.rctypes.tool import util
path = util.find_library('gc')
if path is None:
raise ImportError("Boehm (libgc) not found")
boehmlib = util.load_library(path)
except ImportError, e:
import py
py.test.skip(str(e))
else:
GC_malloc = boehmlib.GC_malloc
return cast(GC_malloc, c_void_p).value
def peek_word_at(addr):
# now the Very Obscure Bit: when translated, 'addr' is an
# address. When not, it's an integer. It just happens to
# make the test pass, but that's probably going to change.
if we_are_translated():
return addr.signed[0]
else:
from ctypes import cast, c_void_p, c_int, POINTER
p = cast(c_void_p(addr), POINTER(c_int))
return p[0]
def poke_word_into(addr, value):
# now the Very Obscure Bit: when translated, 'addr' is an
# address. When not, it's an integer. It just happens to
# make the test pass, but that's probably going to change.
if we_are_translated():
addr.signed[0] = value
else:
from ctypes import cast, c_void_p, c_int, POINTER
p = cast(c_void_p(addr), POINTER(c_int))
p[0] = value
# ____________________________________________________________
class Builder(GenBuilder):
coming_from = 0
update_defaultcaseaddr_of = None
paused_alive_gv = None
order_dependency = None
keepalives_gv = None
def __init__(self, rgenop, graphctx, inputargs_gv, inputoperands):
self.rgenop = rgenop
self.graphctx = graphctx
self.inputargs_gv = inputargs_gv
self.inputoperands = inputoperands
self.operations = []
def start_writing(self):
self.paused_alive_gv = None
def generate_block_code(self, final_vars_gv, final_operands=None,
renaming=True):
self.insert_keepalives()
if self.order_dependency is not None:
self.order_dependency.force_generate_code()
self.order_dependency = None
allocator = RegAllocator(self.operations)
allocator.set_final(final_vars_gv, final_operands)
if not renaming:
assert final_operands is None
final_vars_gv = allocator.varsused() # unique final vars
allocator.compute_lifetimes()
allocator.init_reg_alloc(self.inputargs_gv, self.inputoperands)
mc = self.start_mc()
allocator.generate_operations(mc)
if final_operands is not None:
allocator.generate_final_moves(final_vars_gv, final_operands)
#print 'NSTACKMAX==============>', allocator.nstackmax
self.graphctx.ensure_stack_vars(allocator.nstackmax)
del self.operations[:]
if renaming:
self.inputargs_gv = [GenVar() for v in final_vars_gv]
else:
# just keep one copy of each Variable that is alive
self.inputargs_gv = final_vars_gv
self.inputoperands = [allocator.get_operand(v) for v in final_vars_gv]
return mc
def insert_keepalives(self):
if self.keepalives_gv is not None:
self.operations.append(OpTouch(self.keepalives_gv))
self.keepalives_gv = None
def enter_next_block(self, kinds, args_gv):
# we get better register allocation if we write a single large mc block
self.insert_keepalives()
for i in range(len(args_gv)):
op = OpSameAs(args_gv[i])
args_gv[i] = op
self.operations.append(op)
lbl = Label(self)
lblop = OpLabel(lbl, args_gv)
self.operations.append(lblop)
return lbl
def set_coming_from(self, mc, insncond=INSN_JMP):
self.coming_from_cond = insncond
self.coming_from = mc.tell()
insnemit = EMIT_JCOND[insncond]
insnemit(mc, rel32(-1))
self.coming_from_end = mc.tell()
def start_mc(self):
mc = self.rgenop.open_mc()
# update the coming_from instruction
start = self.coming_from
if start:
targetaddr = mc.tell()
end = self.coming_from_end
fallthrough = targetaddr == end
if self.update_defaultcaseaddr_of: # hack for FlexSwitch
self.update_defaultcaseaddr_of.defaultcaseaddr = targetaddr
fallthrough = False
if fallthrough:
# the jump would be with an offset 0, i.e. it would go
# exactly after itself, so we don't really need the jump
# instruction at all and we can overwrite it and continue.
mc.seekback(end - start)
targetaddr = start
else:
# normal case: patch the old jump to go to targetaddr
oldmc = self.rgenop.InMemoryCodeBuilder(start, end)
insn = EMIT_JCOND[self.coming_from_cond]
insn(oldmc, rel32(targetaddr))
oldmc.done()
self.coming_from = 0
return mc
def _jump_if(self, cls, gv_condition, args_for_jump_gv):
newbuilder = Builder(self.rgenop, self.graphctx,
list(args_for_jump_gv), None)
newbuilder.order_dependency = self
self.operations.append(cls(gv_condition, newbuilder))
return newbuilder
def jump_if_false(self, gv_condition, args_for_jump_gv):
return self._jump_if(JumpIfNot, gv_condition, args_for_jump_gv)
def jump_if_true(self, gv_condition, args_for_jump_gv):
return self._jump_if(JumpIf, gv_condition, args_for_jump_gv)
def finish_and_goto(self, outputargs_gv, targetlbl):
operands = targetlbl.inputoperands
if operands is None:
# jumping to a label in a builder whose code has not been
# generated yet - this builder could be 'self', in the case
# of a tight loop
self.pause_writing(outputargs_gv)
targetlbl.targetbuilder.force_generate_code()
self.start_writing()
operands = targetlbl.inputoperands
assert operands is not None
mc = self.generate_block_code(outputargs_gv, operands)
mc.JMP(rel32(targetlbl.targetaddr))
mc.done()
self.rgenop.close_mc(mc)
def finish_and_return(self, sigtoken, gv_returnvar):
gvs = [gv_returnvar]
mc = self.generate_block_code(gvs, [eax])
# --- epilogue ---
mc.MOV(esp, ebp)
mc.POP(ebp)
mc.POP(edi)
mc.POP(esi)
mc.POP(ebx)
mc.RET()
# ----------------
mc.done()
self.rgenop.close_mc(mc)
def pause_writing(self, alive_gv):
self.paused_alive_gv = alive_gv
return self
def force_generate_code(self):
alive_gv = self.paused_alive_gv
if alive_gv is not None:
self.paused_alive_gv = None
mc = self.generate_block_code(alive_gv, renaming=False)
self.set_coming_from(mc)
mc.done()
self.rgenop.close_mc(mc)
def end(self):
pass
@specialize.arg(1)
def genop1(self, opname, gv_arg):
cls = getopclass1(opname)
if cls is None: # identity
return gv_arg
op = cls(gv_arg)
self.operations.append(op)
return op
@specialize.arg(1)
def genraisingop1(self, opname, gv_arg):
cls = getopclass1(opname)
op = cls(gv_arg)
self.operations.append(op)
op_excflag = OpFetchCC(op.ccexcflag)
self.operations.append(op_excflag)
return op, op_excflag
@specialize.arg(1)
def genop2(self, opname, gv_arg1, gv_arg2):
cls = getopclass2(opname)
op = cls(gv_arg1, gv_arg2)
self.operations.append(op)
return op
@specialize.arg(1)
def genraisingop2(self, opname, gv_arg1, gv_arg2):
cls = getopclass2(opname)
op = cls(gv_arg1, gv_arg2)
self.operations.append(op)
op_excflag = OpFetchCC(op.ccexcflag)
self.operations.append(op_excflag)
return op, op_excflag
def genop_ptr_iszero(self, kind, gv_ptr):
cls = getopclass1('ptr_iszero')
op = cls(gv_ptr)
self.operations.append(op)
return op
def genop_ptr_nonzero(self, kind, gv_ptr):
cls = getopclass1('ptr_nonzero')
op = cls(gv_ptr)
self.operations.append(op)
return op
def genop_ptr_eq(self, kind, gv_ptr1, gv_ptr2):
cls = getopclass2('ptr_eq')
op = cls(gv_ptr1, gv_ptr2)
self.operations.append(op)
return op
def genop_ptr_ne(self, kind, gv_ptr1, gv_ptr2):
cls = getopclass2('ptr_ne')
op = cls(gv_ptr1, gv_ptr2)
self.operations.append(op)
return op
def genop_cast_int_to_ptr(self, kind, gv_int):
return gv_int # identity
def genop_same_as(self, kind, gv_x):
if gv_x.is_const: # must always return a var
op = OpSameAs(gv_x)
self.operations.append(op)
return op
else:
return gv_x
def genop_call(self, sigtoken, gv_fnptr, args_gv):
op = OpCall(sigtoken, gv_fnptr, list(args_gv))
self.operations.append(op)
return op
def genop_malloc_fixedsize(self, size):
# XXX boehm only, no atomic/non atomic distinction for now
op = OpCall(MALLOC_SIGTOKEN,
IntConst(gc_malloc_fnaddr()),
[IntConst(size)])
self.operations.append(op)
return op
def genop_malloc_varsize(self, varsizealloctoken, gv_size):
# XXX boehm only, no atomic/non atomic distinction for now
# XXX no overflow checking for now
opsz = OpComputeSize(varsizealloctoken, gv_size)
self.operations.append(opsz)
opmalloc = OpCall(MALLOC_SIGTOKEN,
IntConst(gc_malloc_fnaddr()),
[opsz])
self.operations.append(opmalloc)
lengthtoken, _, _ = varsizealloctoken
self.operations.append(OpSetField(lengthtoken, opmalloc, gv_size))
return opmalloc
def genop_getfield(self, fieldtoken, gv_ptr):
op = OpGetField(fieldtoken, gv_ptr)
self.operations.append(op)
return op
def genop_setfield(self, fieldtoken, gv_ptr, gv_value):
self.operations.append(OpSetField(fieldtoken, gv_ptr, gv_value))
def genop_getsubstruct(self, (offset, fieldsize), gv_ptr):
op = OpIntAdd(gv_ptr, IntConst(offset))
self.operations.append(op)
return op
def genop_getarrayitem(self, arraytoken, gv_array, gv_index):
op = OpGetArrayItem(arraytoken, gv_array, gv_index)
self.operations.append(op)
return op
def genop_setarrayitem(self, arraytoken, gv_array, gv_index, gv_value):
self.operations.append(OpSetArrayItem(arraytoken, gv_array,
gv_index, gv_value))
def genop_getarraysubstruct(self, arraytoken, gv_array, gv_index):
op = OpGetArraySubstruct(arraytoken, gv_array, gv_index)
self.operations.append(op)
return op
def genop_getarraysize(self, arraytoken, gv_array):
lengthtoken, _, _ = arraytoken
op = OpGetField(lengthtoken, gv_array)
self.operations.append(op)
return op
def flexswitch(self, gv_exitswitch, args_gv):
op = OpGetExitSwitch(gv_exitswitch)
self.operations.append(op)
mc = self.generate_block_code(args_gv, renaming=False)
result = FlexSwitch(self.rgenop, self.graphctx, op.reg,
self.inputargs_gv, self.inputoperands)
default_builder = result.initialize(mc)
mc.done()
self.rgenop.close_mc(mc)
return result, default_builder
def show_incremental_progress(self):
pass
def log(self, msg):
pass # self.mc.log(msg)
# XXX re-do this somehow...
def genop_get_frame_base(self):
return gv_frame_base
def get_frame_info(self, vars_gv):
result = []
for v in vars_gv:
if not v.is_const:
if self.keepalives_gv is None:
self.keepalives_gv = []
self.keepalives_gv.append(v)
sis = StorageInStack(v)
self.operations.append(sis)
v = sis
result.append(v)
return result
def alloc_frame_place(self, kind, gv_initial_value=None):
place = Place(gv_initial_value)
self.operations.append(place)
return place
def genop_absorb_place(self, kind, place):
v = OpAbsorbPlace(place)
self.operations.append(v)
return v
class Label(GenLabel):
targetaddr = 0
inputoperands = None
def __init__(self, targetbuilder):
self.targetbuilder = targetbuilder
class GraphCtx:
# keep this in sync with the generated function prologue:
# how many extra words are initially pushed (including the
# return value, pushed by the caller)
PROLOGUE_FIXED_WORDS = 5
def __init__(self, rgenop):
self.rgenop = rgenop
self.initial_addr = 0 # position where there is the initial ADD ESP
self.adj_addrs = [] # list of positions where there is a LEA ESP
self.reserved_stack_vars = 0
def write_stack_adj(self, mc, initial):
if initial:
addr = write_stack_reserve(mc, self.reserved_stack_vars)
self.initial_addr = addr
else:
addr = write_stack_adj(mc, self.reserved_stack_vars)
self.adj_addrs.append(addr)
def ensure_stack_vars(self, n):
if CALL_ALIGN > 1:
# align the stack to a multiple of CALL_ALIGN words
stack_words = GraphCtx.PROLOGUE_FIXED_WORDS + n
stack_words = (stack_words + CALL_ALIGN-1) & ~ (CALL_ALIGN-1)
n = stack_words - GraphCtx.PROLOGUE_FIXED_WORDS
# patch all the LEA ESP if the requested amount has grown
if n > self.reserved_stack_vars:
addr = self.initial_addr
patchmc = self.rgenop.InMemoryCodeBuilder(addr, addr+99)
write_stack_reserve(patchmc, n)
patchmc.done()
for addr in self.adj_addrs:
patchmc = self.rgenop.InMemoryCodeBuilder(addr, addr+99)
write_stack_adj(patchmc, n)
patchmc.done()
self.reserved_stack_vars = n
# ____________________________________________________________
class RI386GenOp(AbstractRGenOp):
from pypy.jit.codegen.i386.codebuf import MachineCodeBlock
from pypy.jit.codegen.i386.codebuf import InMemoryCodeBuilder
MC_SIZE = 65536
if DEBUG_STACK:
MC_SIZE *= 16
def __init__(self):
self.allocated_mc = None
self.keepalive_gc_refs = []
def open_mc(self):
# XXX supposed infinite for now
mc = self.allocated_mc
if mc is None:
return self.MachineCodeBlock(self.MC_SIZE)
else:
self.allocated_mc = None
return mc
def close_mc(self, mc):
assert self.allocated_mc is None
self.allocated_mc = mc
def check_no_open_mc(self):
pass
def newgraph(self, sigtoken, name):
graphctx = GraphCtx(self)
# --- prologue ---
mc = self.open_mc()
entrypoint = mc.tell()
if DEBUG_TRAP:
mc.BREAKPOINT()
mc.PUSH(ebx)
mc.PUSH(esi)
mc.PUSH(edi)
mc.PUSH(ebp)
mc.MOV(ebp, esp)
graphctx.write_stack_adj(mc, initial=True)
# ^^^ pushed 5 words including the retval ( == PROLOGUE_FIXED_WORDS)
# ----------------
numargs = sigtoken # for now
inputargs_gv = []
inputoperands = []
for i in range(numargs):
inputargs_gv.append(GenVar())
ofs = WORD * (GraphCtx.PROLOGUE_FIXED_WORDS+i)
inputoperands.append(mem(ebp, ofs))
builder = Builder(self, graphctx, inputargs_gv, inputoperands)
# XXX this makes the code layout in memory a bit obscure: we have the
# prologue of the new graph somewhere in the middle of its first
# caller, all alone...
builder.set_coming_from(mc)
mc.done()
self.close_mc(mc)
#ops = [OpSameAs(v) for v in inputargs_gv]
#builder.operations.extend(ops)
#inputargs_gv = ops
return builder, IntConst(entrypoint), inputargs_gv[:]
def replay(self, label, kinds):
return ReplayBuilder(self), [dummy_var] * len(kinds)
@specialize.genconst(1)
def genconst(self, llvalue):
T = lltype.typeOf(llvalue)
if T is llmemory.Address:
return AddrConst(llvalue)
elif isinstance(T, lltype.Primitive):
return IntConst(lltype.cast_primitive(lltype.Signed, llvalue))
elif isinstance(T, lltype.Ptr):
lladdr = llmemory.cast_ptr_to_adr(llvalue)
if T.TO._gckind == 'gc':
self.keepalive_gc_refs.append(lltype.cast_opaque_ptr(llmemory.GCREF, llvalue))
return AddrConst(lladdr)
else:
assert 0, "XXX not implemented"
# attached later constPrebuiltGlobal = global_rgenop.genconst
@staticmethod
def genzeroconst(kind):
return zero_const
@staticmethod
@specialize.memo()
def fieldToken(T, name):
FIELD = getattr(T, name)
if isinstance(FIELD, lltype.ContainerType):
fieldsize = 0 # not useful for getsubstruct
else:
fieldsize = llmemory.sizeof(FIELD)
return (llmemory.offsetof(T, name), fieldsize)
@staticmethod
@specialize.memo()
def allocToken(T):
return llmemory.sizeof(T)
@staticmethod
@specialize.memo()
def varsizeAllocToken(T):
if isinstance(T, lltype.Array):
return RI386GenOp.arrayToken(T)
else:
# var-sized structs
arrayfield = T._arrayfld
ARRAYFIELD = getattr(T, arrayfield)
arraytoken = RI386GenOp.arrayToken(ARRAYFIELD)
(lengthoffset, lengthsize), itemsoffset, itemsize = arraytoken
arrayfield_offset = llmemory.offsetof(T, arrayfield)
return ((arrayfield_offset+lengthoffset, lengthsize),
arrayfield_offset+itemsoffset,
itemsize)
@staticmethod
@specialize.memo()
def arrayToken(A):
return ((llmemory.ArrayLengthOffset(A), WORD),
llmemory.ArrayItemsOffset(A),
llmemory.ItemOffset(A.OF))
@staticmethod
@specialize.memo()
def kindToken(T):
if T is lltype.Float:
py.test.skip("not implemented: floats in the i386 back-end")
return None # for now
@staticmethod
@specialize.memo()
def sigToken(FUNCTYPE):
numargs = 0
for ARG in FUNCTYPE.ARGS:
if ARG is not lltype.Void:
numargs += 1
return numargs # for now
@staticmethod
def erasedType(T):
if T is llmemory.Address:
return llmemory.Address
if isinstance(T, lltype.Primitive):
return lltype.Signed
elif isinstance(T, lltype.Ptr):
return llmemory.GCREF
else:
assert 0, "XXX not implemented"
@staticmethod
@specialize.arg(0)
def read_frame_var(T, base, info, index):
v = info[index]
if isinstance(v, StorageInStack):
value = peek_word_at(base + v.get_offset())
return cast_int_to_whatever(T, value)
else:
assert isinstance(v, GenConst)
return v.revealconst(T)
@staticmethod
@specialize.arg(0)
def write_frame_place(T, base, place, value):
value = cast_whatever_to_int(T, value)
poke_word_into(base + place.get_offset(), value)
@staticmethod
@specialize.arg(0)
def read_frame_place(T, base, place):
value = peek_word_at(base + place.get_offset())
return cast_int_to_whatever(T, value)
global_rgenop = RI386GenOp()
RI386GenOp.constPrebuiltGlobal = global_rgenop.genconst
zero_const = AddrConst(llmemory.NULL)
MALLOC_SIGTOKEN = RI386GenOp.sigToken(GC_MALLOC.TO)
| Python |
"""Register allocation.
"""
import sys
from pypy.rlib.objectmodel import we_are_translated
from pypy.rpython.lltypesystem import lltype
from pypy.jit.codegen.i386.operation import *
DEBUG_STACK = False
class StackOpCache:
INITIAL_STACK_EBP_OFS = -1
stack_op_cache = StackOpCache()
stack_op_cache.lst = []
def stack_op(n):
"Return the mem operand that designates the nth stack-spilled location"
assert n >= 0
lst = stack_op_cache.lst
while len(lst) <= n:
ofs = WORD * (StackOpCache.INITIAL_STACK_EBP_OFS - len(lst))
lst.append(mem(ebp, ofs))
return lst[n]
def stack_n_from_op(op):
ofs = op.ofs_relative_to_ebp()
return StackOpCache.INITIAL_STACK_EBP_OFS - ofs / WORD
def write_stack_reserve(mc, stackn):
addr = mc.tell()
mc.SUB(esp, IMM32(WORD * stackn)) # always encode offset on 32 bits
return addr
def write_stack_adj(mc, stackn):
addr = mc.tell()
# always encode offset on 32 bits
mc.LEA(esp, fixedsize_ebp_ofs(-WORD * stackn))
return addr
class RegAllocator(object):
def __init__(self, operations):
self.operations = operations
self.operationindex = len(operations)
self.lifetime = {} # {variable: operation_index}
self.suggested_location = {} # {variable: location}
self.var2loc = {gv_frame_base: ebp}
# ----------
def set_final(self, final_vars_gv, locations=None):
for i in range(len(final_vars_gv)):
v = final_vars_gv[i]
self.using(v)
if locations is not None:
self.suggested_location[v] = locations[i]
def compute_lifetimes(self):
for i in range(len(self.operations)-1, -1, -1):
self.operationindex = i
op = self.operations[i]
if not op.side_effects and op not in self.lifetime:
self.operations[i] = dead_operation # operation not used
else:
op.mark_used_vars(self)
def using(self, v):
if v.is_const or v in self.lifetime:
return False
else:
self.lifetime[v] = self.operationindex
return True # variable is dying here
def using_inplace(self, v, vtarget):
if self.using(v):
# this operation 'vtarget' can modify its argument 'v'
# in-place, and 'v' is not alive after the operation.
# Propagate the suggested location for 'vtarget' backwards to 'v'.
try:
self.suggested_location[v] = self.suggested_location[vtarget]
return True # got a suggestion
except KeyError:
pass
return False # got no suggestion
def suggests(self, v, loc):
self.suggested_location[v] = loc
def varsused(self):
return self.lifetime.keys()
# ----------
AVAILABLE_REGS = (eax.bitmask |
edx.bitmask |
ecx.bitmask |
ebx.bitmask |
esi.bitmask |
edi.bitmask)
def init_reg_alloc(self, inputvars_gv, inputlocations):
self.registers_free = self.AVAILABLE_REGS # bitmask
self.cc_used_by = None
self.stack_op_used = {}
self.nstackidx = 0
self.nstackmax = 0
self.vars_in_use = {} # {variable: dying_operation_index}
self.operationindex = 0
self.inputvars_gv = inputvars_gv
self.inputlocations = inputlocations
def force_loc_used(self, v, loc):
ok = self.consume_loc(v, loc)
assert ok
def consume_loc(self, v, loc):
if isinstance(loc, MODRM):
if loc not in self.stack_op_used:
self.stack_op_used[loc] = None
n = stack_n_from_op(loc)
if n >= self.nstackmax:
self.nstackmax = n + 1
return True
elif isinstance(loc, REG):
if self.registers_free & loc.bitmask:
self.registers_free &= ~loc.bitmask
return True
elif isinstance(loc, CCFLAG):
if self.cc_used_by is None:
self.cc_used_by = v
return True
return False
def _no_longer_in_use(self, v):
del self.vars_in_use[v]
loc = self.var2loc[v]
if isinstance(loc, CCFLAG):
assert self.cc_used_by is v
self._mark_loc_as_free(loc)
def _mark_loc_as_free(self, loc):
if isinstance(loc, MODRM):
del self.stack_op_used[loc]
elif isinstance(loc, REG):
self.registers_free |= loc.bitmask
elif isinstance(loc, CCFLAG):
self.cc_used_by = None
def generate_operations(self, mc):
if not we_are_translated():
print
# reserve locations for the inputvars
for i in range(len(self.inputvars_gv)):
v = self.inputvars_gv[i]
if v in self.lifetime: # else: input argument is not used
loc = self.inputlocations[i]
if v in self.var2loc: # duplicate inputvars_gv, which is ok
assert self.var2loc[v] == loc
else:
self.var2loc[v] = loc
self.vars_in_use[v] = self.lifetime[v]
self.force_loc_used(v, loc)
if not we_are_translated():
print 'in %20s: %s' % (loc, short(v))
self._check()
self.mc = mc
# Generate all operations.
# Actual registers or stack locations are allocated as we go.
for i in range(len(self.operations)):
self.registers_pinned = 0 # bitmask
op = self.operations[i]
if op.clobbers_cc:
self.clobber_cc()
self._check()
op.generate(self)
if not we_are_translated():
self._showprogress()
self.operationindex = i + 1
def _showprogress(self):
class Collector:
def __init__(self):
self.lst = []
self.using = self.lst.append
def using_inplace(self, v, _):
self.lst.append(v)
def suggests(self, v, loc):
pass
col = Collector()
i = self.operationindex
op = self.operations[i]
op.mark_used_vars(col)
args = [short(v) for v in col.lst]
args = ', '.join(args)
print ' | %20s: %s (%s)' % (self.var2loc.get(op, ''),
short(op), args)
for v, endtime in self.vars_in_use.items():
assert endtime > i
self._check()
def _use_another_stack_loc(self):
for i in range(self.nstackidx, self.nstackmax):
loc = stack_op(i)
if loc not in self.stack_op_used:
self.nstackidx = i + 1
break
else:
for i in range(self.nstackidx):
loc = stack_op(i)
if loc not in self.stack_op_used:
self.nstackidx = i + 1
break
else:
i = self.nstackidx = self.nstackmax
self.nstackmax = i + 1
loc = stack_op(i)
assert loc not in self.stack_op_used
self.stack_op_used[loc] = None
return loc
def reserve_extra_stack(self, extra):
max = self.nstackmax
base = max - extra
if base < 0:
base = 0
while max > base and stack_op(max-1) not in self.stack_op_used:
max -= 1
self.nstackmax = max + extra
def get_operand(self, v):
if v.is_const:
return imm(v.revealconst(lltype.Signed))
else:
return self.var2loc[v]
def grab_operand(self, v):
"""Like get_operand() but if the result is in a register, it won't
be spilled before the end of the current instruction."""
loc = self.get_operand(v)
if isinstance(loc, REG):
self.registers_pinned |= loc.bitmask
return loc
def _use_next_modrm(self, v, regnum_must_be_before=8):
"""Select the next mod/rm location to use for the new operation 'v'.
If 'v' is None, this will always return a register; else it might
decide to immediately create 'v' in a stack location.
"""
#print self.registers_free
if self.registers_free:
for i in range(regnum_must_be_before-1, -1, -1):
if self.registers_free & (1 << i):
self.registers_free &= ~ (1 << i)
return registers[i]
# spill the register holding the variable that has the longest
# time remaining to live (it may be our 'v' itself)
if v is None:
dyinglimit = self.operationindex # must pick vars dying after that
spillvar = None
else:
dyinglimit = self.lifetime[v]
spillvar = v # initial guess, can be overridden in the loop below
regloc = None
for v1, dying in self.vars_in_use.iteritems():
if dying > dyinglimit:
loc = self.var2loc[v1]
if not isinstance(loc, REG):
continue
if loc.op >= regnum_must_be_before:
continue # never reached if regnum_must_be_before == 8
if loc.bitmask & self.registers_pinned:
continue # don't spill this register
regloc = loc
dyinglimit = dying
spillvar = v1
if spillvar is None:
raise OutOfRegistersError
#print 'time span of %s: now is %d, lives until %d' % (
# v, self.operationindex, self.lifetime[v])
if spillvar is v:
return self._use_another_stack_loc()
else:
assert regloc is not None
self._spill(spillvar, regloc)
return regloc
def _spill(self, spillvar, oldloc):
spillloc = self._use_another_stack_loc()
if not we_are_translated():
print ' # %20s: SPILL %s' % (spillloc, oldloc)
self.mc.MOV(spillloc, oldloc)
self.var2loc[spillvar] = spillloc
return spillloc
def _use_next_reg(self):
return self._use_next_modrm(None)
def _use_next_reg_abcd(self):
return self._use_next_modrm(None, regnum_must_be_before=4)
def _created(self, v, loc):
assert v not in self.var2loc
assert loc is not None
self.vars_in_use[v] = ltime = self.lifetime[v]
assert ltime > self.operationindex
self.var2loc[v] = loc
if isinstance(loc, REG):
self.registers_pinned |= loc.bitmask
def release(self, v):
"""Stop using argument 'v'. Must be called for each used argument.
Warning: if an operation uses v1 and v2, and if v1 could be equal to
v2, then calling release(v1) will also immediately release(v2)...
The best is to call release() on all operands at once.
"""
ok = self.lastuse(v) and v in self.vars_in_use
if ok:
self._no_longer_in_use(v)
return ok
def lastuse(self, v):
"""Is this the last time the argument 'v' is used?"""
if v.is_const:
return False
else:
endtime = self.lifetime[v]
assert endtime >= self.operationindex
return endtime == self.operationindex
def create(self, v, suggested_loc=None):
"""Create the result of the operation 'v', possibly at the
suggested location. CAN SPILL ONE REGISTER."""
if suggested_loc is not None and self.consume_loc(v, suggested_loc):
self._created(v, suggested_loc)
return suggested_loc
suggested_loc = self.suggested_location.get(v, None)
if suggested_loc is not None and self.consume_loc(v, suggested_loc):
self._created(v, suggested_loc)
return suggested_loc
loc = self._use_next_modrm(v)
self._created(v, loc)
return loc
def create_reg(self, v, srcloc=None):
"""Create the result of the operation 'v' in any register
currently available. CAN SPILL ONE REGISTER."""
suggested_loc = self.suggested_location.get(v, None)
if (isinstance(suggested_loc, REG) and
self.consume_loc(v, suggested_loc)):
loc = suggested_loc
else:
loc = self._use_next_reg()
self._created(v, loc)
if srcloc is not None and loc is not srcloc:
# if srcop was spilled, srcloc still contains its value right now
# and then it's possible that srcop == dstop (no MOV needed then)
self.mc.MOV(loc, srcloc)
return loc
def create_exactly_at(self, v, loc):
"""Create the result of the operation 'v' at 'loc'."""
ok = self.consume_loc(v, loc)
assert ok
self._created(v, loc)
def create_in_cc(self, v, ccloc):
"""Create the result of the operation 'v' in the given cc flags.
Doesn't move stuff around."""
assert self.cc_used_by is None
self._created(v, ccloc)
self.cc_used_by = v
def create_scratch_reg(self, srcloc=None):
"""Return a scratch register for the current operation.
Warning, this might be the same register as one of the input args.
CAN SPILL ONE REGISTER. You must eventually call end_clobber()."""
reg = self._use_next_reg()
if srcloc is not None and reg is not srcloc:
self.mc.MOV(reg, srcloc)
return reg
def create_scratch_reg8(self, srcloc=None):
reg32 = self._use_next_reg_abcd()
reg8 = reg32.lowest8bits()
if srcloc is not None and reg8 is not srcloc and reg32 is not srcloc:
if srcloc.width == 1:
self.mc.MOV(reg8, srcloc)
else:
self.mc.MOV(reg32, srcloc)
return reg8
def operation_result_is_used(self, v):
return v in self.lifetime
def clobber(self, reg):
"""Clobbers a register, i.e. move away a value that would be there.
It might go to a different register or to the stack.
You must eventually call end_clobber()."""
assert isinstance(reg, REG)
if not self.registers_free & reg.bitmask:
assert not (reg.bitmask & self.registers_pinned)
for v1 in self.vars_in_use:
if self.var2loc[v1] == reg:
self._move_away(v1)
break
assert self.registers_free & reg.bitmask
self.registers_free &= ~reg.bitmask
def clobber2(self, reg1, reg2):
"""Clobbers two registers. Unlike two individual clobber() calls,
where the first call might overwrite the other reg, this one
preserves the current content of both 'reg1' and 'reg2'.
You must eventually call end_clobber() twice."""
if not self.registers_free & reg2.bitmask:
# order trick: if reg2 is free but reg1 used, doing clobber() in
# the following order could first move reg1 to reg2, and then
# immediately away from reg2.
self.clobber(reg1) # <- here reg1 cannot go to reg2
self.clobber(reg2)
else:
self.clobber(reg2) # reg2 is free, so it doesn't go anywhere
self.clobber(reg1)
def clobber3(self, reg1, reg2, reg3):
if not self.registers_free & reg3.bitmask:
self.clobber2(reg1, reg2) # they cannot go to reg3
self.clobber(reg3)
else:
self.clobber(reg3) # free, so doesn't go anywhere
self.clobber2(reg1, reg2)
def end_clobber(self, reg):
if isinstance(reg, REG):
bitmask = reg.bitmask
else:
assert isinstance(reg, REG8)
assert reg.op < 4
bitmask = reg.bitmask
self.registers_free |= bitmask
def clobber_cc(self):
v = self.cc_used_by
if v is not None:
self.cc_used_by = None
# pick a newloc that is either one of [eax, ecx, edx, ebx]
# or a stack location
oldloc = self.var2loc[v]
newloc = self._use_next_modrm(v, regnum_must_be_before=4)
if not we_are_translated():
print ' # %20s: MOVE AWAY FROM %s' % (newloc, oldloc)
assert isinstance(oldloc, CCFLAG)
mc = self.mc
newloc8 = newloc.lowest8bits()
if isinstance(newloc, REG):
oldloc.SETCOND(mc, newloc8)
mc.MOVZX(newloc, newloc8)
else:
mc.MOV(newloc, imm8(0))
oldloc.SETCOND(mc, newloc8)
self._mark_loc_as_free(oldloc)
self.var2loc[v] = newloc
def lock(self, loc):
"""Temporarily prevent 'loc' from being overwritten by the
functions marked as 'moves stuff around'. Return True if the
lock is sucessful, False if the location was not free in the
first place."""
return self.consume_loc(None, loc)
def unlock(self, loc):
"""Call sometime after a lock() that returned True."""
self._mark_loc_as_free(loc)
def _move_away(self, v):
# move 'v' away, into a newly allocated register or stack location,
# possibly spilling another register
oldloc = self.var2loc[v]
newloc = self._use_next_modrm(v)
if not we_are_translated():
print ' # %20s: MOVE AWAY FROM %s' % (newloc, oldloc)
self.mc.MOV(newloc, oldloc)
self._mark_loc_as_free(oldloc)
self.var2loc[v] = newloc
return newloc
def _check(self):
if not we_are_translated():
def unpackbitmask(x):
return dict.fromkeys([r for r in registers if x & r.bitmask])
rf = unpackbitmask(self.AVAILABLE_REGS)
locs_seen = {}
for v in self.vars_in_use:
loc = self.var2loc[v]
assert loc not in locs_seen
locs_seen[loc] = v
if isinstance(loc, REG):
del rf[loc]
assert unpackbitmask(self.registers_free) == rf
# ----------
def generate_final_moves(self, final_vars_gv, locations):
# XXX naive algo for now
pops = []
for i in range(len(final_vars_gv)):
v = final_vars_gv[i]
if not v.is_const:
srcloc = self.var2loc[v]
dstloc = locations[i]
if srcloc != dstloc:
if not we_are_translated():
print ' > %20s--->->->---%s' % (srcloc, dstloc)
if isinstance(srcloc, CCFLAG):
self.mc.PUSH(imm8(0))
srcloc.SETCOND(self.mc, mem8(esp))
else:
self.mc.PUSH(srcloc)
pops.append(dstloc)
while pops:
dstloc = pops.pop()
self.mc.POP(dstloc)
for i in range(len(final_vars_gv)):
v = final_vars_gv[i]
if v.is_const:
dstloc = locations[i]
self.mc.MOV(dstloc, imm(v.revealconst(lltype.Signed)))
class OutOfRegistersError(Exception):
pass
def short(op, memo={}):
key = op.__class__.__name__
d = memo.setdefault(key, {})
try:
n = d[op]
except KeyError:
n = d[op] = len(d)
return '%s-%d' % (key, n)
# ____________________________________________________________
class DeadOperation(Operation):
clobbers_cc = False
side_effects = False
def mark_used_vars(self, allocator):
pass
def generate(self, allocator):
pass
dead_operation = DeadOperation()
gv_frame_base = GenVar()
class Place(Operation):
"""Place of a variable that must live in the stack. Its position is
choosen by the register allocator and put in the 'offset' attribute."""
def __init__(self, x):
self.x = x
def mark_used_vars(self, allocator):
if self.x is not None:
allocator.using(self.x)
def get_offset(self):
return self.offset
def generate(self, allocator):
assert allocator.operation_result_is_used(self), "place not absorbed!"
loc = allocator._use_another_stack_loc()
allocator._created(self, loc)
if self.x is not None:
srcop = allocator.get_operand(self.x)
try:
allocator.mc.MOV(loc, srcop)
except FailedToImplement:
# loc and srcop are both in the stack - need a temporary reg
tmpop = allocator.create_scratch_reg(srcop)
# loc and srcop still valid, as they are already in the stack
# so cannot have been spilled by create_scratch_reg()
allocator.mc.MOV(loc, tmpop)
allocator.end_clobber(tmpop)
allocator.release(self.x)
self.x = None # hack to avoid that the Place keeps a lot of
# memory around
self.offset = loc.ofs_relative_to_ebp()
class OpAbsorbPlace(Op1):
clobbers_cc = False
def generate(self, allocator):
allocator.release(self.x)
if allocator.operation_result_is_used(self):
loc = allocator.get_operand(self.x)
allocator.create_exactly_at(self, loc)
class StorageInStack(Place):
def generate(self, allocator):
# force the variable to be in the stack
srcop = allocator.get_operand(self.x)
if not isinstance(srcop, MODRM):
oldop = srcop
srcop = allocator._spill(self.x, srcop)
allocator._mark_loc_as_free(oldop)
# record its location
self.offset = srcop.ofs_relative_to_ebp()
# hack to avoid this instance keeping a lot of memory around
self.x = None
class OpTouch(Operation):
side_effects = True # don't remove me!
def __init__(self, args_gv):
self.args_gv = args_gv
def mark_used_vars(self, allocator):
for v in self.args_gv:
allocator.using(v)
def generate(self, allocator):
for v in self.args_gv:
allocator.release(v)
| Python |
import py
from pypy.jit.codegen import detect_cpu
class Directory(py.test.collect.Directory):
def run(self):
try:
processor = detect_cpu.autodetect()
except detect_cpu.ProcessorAutodetectError, e:
py.test.skip(str(e))
else:
if processor != 'i386':
py.test.skip('detected a %r CPU' % (processor,))
return super(Directory, self).run()
Option = py.test.config.Option
option = py.test.config.addoptions("i386 options",
Option('--interp', action="store_true", default=False,
dest="interp",
help="run the very slow genc_interp_* tests"),
)
| Python |
#! /usr/bin/env python
"""
Viewer for the CODE_DUMP output of compiled programs generating code.
Try:
./viewcode.py dumpfile.txt
or
/tmp/usession-xxx/testing_1/testing_1 -var 4 2>&1 | ./viewcode.py
"""
import autopath
import operator, sys, os, re, py, new
from bisect import bisect_left
# don't use pypy.tool.udir here to avoid removing old usessions which
# might still contain interesting executables
udir = py.path.local.make_numbered_dir(prefix='viewcode-', keep=2)
tmpfile = str(udir.join('dump.tmp'))
# hack hack
import pypy.tool
mod = new.module('pypy.tool.udir')
mod.udir = udir
sys.modules['pypy.tool.udir'] = mod
pypy.tool.udir = mod
# ____________________________________________________________
# Some support code from Psyco. There is more over there,
# I am porting it in a lazy fashion... See py-utils/xam.py
if sys.platform == "win32":
XXX # lots more in Psyco
def machine_code_dump(data, originaddr):
# the disassembler to use. 'objdump' writes GNU-style instructions.
# 'ndisasm' would use Intel syntax, but you need to fix the output parsing.
objdump = 'objdump -b binary -m i386 --adjust-vma=%(origin)d -D %(file)s'
#
f = open(tmpfile, 'wb')
f.write(data)
f.close()
g = os.popen(objdump % {'file': tmpfile, 'origin': originaddr}, 'r')
result = g.readlines()
g.close()
return result[6:] # drop some objdump cruft
def load_symbols(filename):
# the program that lists symbols, and the output it gives
symbollister = 'nm %s'
re_symbolentry = re.compile(r'([0-9a-fA-F]+)\s\w\s(.*)')
#
print 'loading symbols from %s...' % (filename,)
symbols = {}
g = os.popen(symbollister % filename, "r")
for line in g:
match = re_symbolentry.match(line)
if match:
addr = long(match.group(1), 16)
name = match.group(2)
if name.startswith('pypy_g_'):
name = '\xb7' + name[7:]
symbols[addr] = name
g.close()
print '%d symbols found' % (len(symbols),)
return symbols
re_addr = re.compile(r'[\s,$]0x([0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]+)')
re_lineaddr = re.compile(r'\s*0?x?([0-9a-fA-F]+)')
def lineaddresses(line):
result = []
i = 0
while 1:
match = re_addr.search(line, i)
if not match:
break
i = match.end()
addr = long(match.group(1), 16)
result.append(addr)
return result
# ____________________________________________________________
class CodeRange(object):
fallthrough = False
def __init__(self, world, addr, data):
self.world = world
self.addr = addr
self.data = data
def __repr__(self):
return '<CodeRange %s length %d>' % (hex(self.addr), len(self.data))
def touches(self, other):
return (self .addr < other.addr + len(other.data) and
other.addr < self .addr + len(self.data))
def update_from_old(self, other):
if other.addr < self.addr:
delta = self.addr - other.addr
assert delta <= len(other.data)
self.addr -= delta
self.data = other.data[:delta] + self.data
self_end = self .addr + len(self .data)
other_end = other.addr + len(other.data)
if other_end > self_end:
extra = other_end - self_end
assert extra <= len(other.data)
self.data += other.data[-extra:]
def cmpop(op):
def _cmp(self, other):
if not isinstance(other, CodeRange):
return NotImplemented
return op((self.addr, self.data), (other.addr, other.data))
return _cmp
__lt__ = cmpop(operator.lt)
__le__ = cmpop(operator.le)
__eq__ = cmpop(operator.eq)
__ne__ = cmpop(operator.ne)
__gt__ = cmpop(operator.gt)
__ge__ = cmpop(operator.ge)
del cmpop
def disassemble(self):
if not hasattr(self, 'text'):
lines = machine_code_dump(self.data, self.addr)
# instead of adding symbol names in the dumps we could
# also make the 0xNNNNNNNN addresses be red and show the
# symbol name when the mouse is over them
logentries = self.world.logentries
symbols = self.world.symbols
for i, line in enumerate(lines):
match = re_lineaddr.match(line)
if match:
addr = long(match.group(1), 16)
logentry = logentries.get(addr)
if logentry:
lines[i] = '\n%s\n%s' % (logentry, lines[i])
for addr in lineaddresses(line):
sym = symbols.get(addr)
if sym:
lines[i] = '%s\t%s\n' % (lines[i].rstrip(), sym)
self.text = ''.join(lines)
return self.text
def findjumps(self):
text = self.disassemble()
lines = text.splitlines()
for i, line in enumerate(lines):
if '\tj' not in line: # poor heuristic to recognize lines that
continue # could be jump instructions
addrs = list(lineaddresses(line))
if not addrs:
continue
addr = addrs[-1]
final = '\tjmp' in line
yield i, addr, final
if self.fallthrough:
yield len(lines), self.addr + len(self.data), True
class World(object):
def __init__(self):
self.ranges = []
self.labeltargets = {}
self.jumps = {}
self.symbols = {}
self.logentries = {}
def parse(self, f):
for line in f:
if line.startswith('CODE_DUMP '):
pieces = line.split()
assert pieces[1].startswith('@')
assert pieces[2].startswith('+')
baseaddr = long(pieces[1][1:], 16) & 0xFFFFFFFFL
offset = int(pieces[2][1:])
addr = baseaddr + offset
data = pieces[3].replace(':', '').decode('hex')
coderange = CodeRange(self, addr, data)
i = bisect_left(self.ranges, coderange)
j = i
while i>0 and coderange.touches(self.ranges[i-1]):
coderange.update_from_old(self.ranges[i-1])
i -= 1
while j<len(self.ranges) and coderange.touches(self.ranges[j]):
coderange.update_from_old(self.ranges[j])
j += 1
self.ranges[i:j] = [coderange]
elif line.startswith('LOG '):
pieces = line.split(None, 3)
assert pieces[1].startswith('@')
assert pieces[2].startswith('+')
baseaddr = long(pieces[1][1:], 16) & 0xFFFFFFFFL
offset = int(pieces[2][1:])
addr = baseaddr + offset
self.logentries[addr] = pieces[3]
elif line.startswith('SYS_EXECUTABLE '):
filename = line[len('SYS_EXECUTABLE '):].strip()
self.symbols.update(load_symbols(filename))
# find cross-references between blocks
fnext = 0.1
for i, r in enumerate(self.ranges):
for lineno, targetaddr, _ in r.findjumps():
self.labeltargets[targetaddr] = True
if i % 100 == 99:
f = float(i) / len(self.ranges)
if f >= fnext:
sys.stderr.write("%d%%" % int(f*100.0))
fnext += 0.1
sys.stderr.write(".")
sys.stderr.write("100%\n")
# split blocks at labeltargets
t = self.labeltargets
#print t
for r in self.ranges:
#print r.addr, r.addr + len(r.data)
for i in range(r.addr + 1, r.addr + len(r.data)):
if i in t:
#print i
ofs = i - r.addr
self.ranges.append(CodeRange(self, i, r.data[ofs:]))
r.data = r.data[:ofs]
r.fallthrough = True
try:
del r.text
except AttributeError:
pass
break
# hack hack hacked
def show(self, showtext=True, showgraph=True):
if showgraph:
g1 = Graph('codedump')
self.ranges.sort()
for r in self.ranges:
disassembled = r.disassemble()
if showtext:
print disassembled
if showgraph:
text, width = tab2columns(disassembled)
text = '0x%x\n\n%s' % (r.addr, text)
g1.emit_node('N_%x' % r.addr, shape="box", label=text,
width=str(width*0.1125))
for lineno, targetaddr, final in r.findjumps():
if final:
color = "black"
else:
color = "red"
g1.emit_edge('N_%x' % r.addr, 'N_%x' % targetaddr,
color=color)
sys.stdout.flush()
if showgraph:
g1.display()
def tab2columns(text):
lines = text.split('\n')
columnwidth = []
for line in lines:
columns = line.split('\t')[:-1]
while len(columnwidth) < len(columns):
columnwidth.append(0)
for i, s in enumerate(columns):
width = len(s.strip())
if not s.endswith(':'):
width += 2
columnwidth[i] = max(columnwidth[i], width)
columnwidth.append(1)
result = []
for line in lines:
columns = line.split('\t')
text = []
for width, s in zip(columnwidth, columns):
text.append(s.strip().ljust(width))
result.append(' '.join(text))
lengths = [len(line) for line in result]
lengths.append(1)
totalwidth = max(lengths)
return '\\l'.join(result), totalwidth
# ____________________________________________________________
# XXX pasted from
# http://codespeak.net/svn/user/arigo/hack/misc/graphlib.py
# but needs to be a bit more subtle later
from pypy.translator.tool.make_dot import DotGen
from dotviewer.graphclient import display_page
class Graph(DotGen):
def highlight(self, word, text, linked_to=None):
if not hasattr(self, '_links'):
self._links = {}
self._links_to = {}
self._links[word] = text
if linked_to:
self._links_to[word] = linked_to
def display(self):
"Display a graph page locally."
display_page(_Page(self))
class NoGraph(Exception):
pass
class _Page:
def __init__(self, graph_builder):
if callable(graph_builder):
graph = graph_builder()
else:
graph = graph_builder
if graph is None:
raise NoGraph
self.graph_builder = graph_builder
def content(self):
return _PageContent(self.graph_builder)
class _PageContent:
fixedfont = True
def __init__(self, graph_builder):
if callable(graph_builder):
graph = graph_builder()
else:
graph = graph_builder
assert graph is not None
self.graph_builder = graph_builder
self.graph = graph
self.links = getattr(graph, '_links', {})
if not hasattr(graph, '_source'):
graph._source = graph.generate(target=None)
self.source = graph._source
def followlink(self, link):
try:
return _Page(self.graph._links_to[link])
except NoGraph:
return _Page(self.graph_builder)
# ____________________________________________________________
if __name__ == '__main__':
if '--text' in sys.argv:
sys.argv.remove('--text')
showgraph = False
else:
showgraph = True
if len(sys.argv) == 1:
f = sys.stdin
else:
f = open(sys.argv[1], 'r')
world = World()
world.parse(f)
world.show(showtext=True, showgraph=showgraph)
| Python |
import os
from ctypes import POINTER, cast, c_char, c_void_p, CFUNCTYPE, c_int
from ri386 import I386CodeBuilder
# ____________________________________________________________
modname = 'pypy.jit.codegen.i386.codebuf_' + os.name
memhandler = __import__(modname, globals(), locals(), ['__doc__'])
PTR = memhandler.PTR
class CodeBlockOverflow(Exception):
pass
class InMemoryCodeBuilder(I386CodeBuilder):
_last_dump_start = 0
def __init__(self, start, end):
map_size = end - start
res = c_void_p(start)
data = cast(res, POINTER(c_char * map_size))
self._init(data, map_size)
def _init(self, data, map_size):
self._data = data
self._size = map_size
self._pos = 0
def write(self, data):
p = self._pos
if p + len(data) > self._size:
raise CodeBlockOverflow
for c in data:
self._data.contents[p] = c
p += 1
self._pos = p
def tell(self):
baseaddr = cast(self._data, c_void_p).value
return baseaddr + self._pos
def seekback(self, count):
pos = self._pos - count
self._pos = pos
self._last_dump_start = pos
def execute(self, arg1, arg2):
# XXX old testing stuff
fnptr = cast(self._data, binaryfn)
return fnptr(arg1, arg2)
def done(self):
# normally, no special action is needed here
if machine_code_dumper.enabled:
machine_code_dumper.dump_range(self, self._last_dump_start,
self._pos)
self._last_dump_start = self._pos
def log(self, msg):
if machine_code_dumper.enabled:
machine_code_dumper.dump(self, 'LOG', self._pos, msg)
class MachineCodeDumper:
enabled = True
log_fd = -1
sys_executable = None
def _freeze_(self):
# reset the machine_code_dumper global instance to its default state
if self.log_fd >= 0:
os.close(self.log_fd)
self.__dict__.clear()
return False
def open(self):
if self.log_fd < 0:
# check the environment for a file name
from pypy.rlib.ros import getenv
s = getenv('PYPYJITLOG')
if not s:
self.enabled = False
return False
try:
flags = os.O_WRONLY|os.O_CREAT|os.O_TRUNC
self.log_fd = os.open(s, flags, 0666)
except OSError:
os.write(2, "could not create log file\n")
self.enabled = False
return False
# log the executable name
from pypy.jit.codegen.hlinfo import highleveljitinfo
os.write(self.log_fd, 'BACKEND i386\n')
if highleveljitinfo.sys_executable:
os.write(self.log_fd, 'SYS_EXECUTABLE %s\n' % (
highleveljitinfo.sys_executable,))
return True
def dump(self, cb, tag, pos, msg):
if not self.open():
return
line = '%s @%x +%d %s\n' % (tag, cb.tell() - cb._pos, pos, msg)
os.write(self.log_fd, line)
def dump_range(self, cb, start, end):
HEX = '0123456789ABCDEF'
dump = []
for p in range(start, end):
o = ord(cb._data.contents[p])
dump.append(HEX[o >> 4])
dump.append(HEX[o & 15])
if (p & 3) == 3:
dump.append(':')
self.dump(cb, 'CODE_DUMP', start, ''.join(dump))
machine_code_dumper = MachineCodeDumper()
class MachineCodeBlock(InMemoryCodeBuilder):
def __init__(self, map_size):
res = memhandler.alloc(map_size)
data = cast(res, POINTER(c_char * map_size))
self._init(data, map_size)
def __del__(self):
memhandler.free(cast(self._data, PTR), self._size)
binaryfn = CFUNCTYPE(c_int, c_int, c_int) # for testing
# ____________________________________________________________
from pypy.rpython.lltypesystem import lltype
BUF = lltype.GcArray(lltype.Char)
class LLTypeMachineCodeBlock(I386CodeBuilder):
# for testing only
class State:
pass
state = State()
state.base = 1
def __init__(self, map_size):
self._size = map_size
self._pos = 0
self._base = LLTypeMachineCodeBlock.state.base
LLTypeMachineCodeBlock.state.base += map_size
def write(self, data):
p = self._pos
if p + len(data) > self._size:
raise CodeBlockOverflow
self._pos += len(data)
return
def tell(self):
return self._base + self._pos
def seekback(self, count):
self._pos -= count
def done(self):
pass
class LLTypeInMemoryCodeBuilder(LLTypeMachineCodeBlock):
_last_dump_start = 0
def __init__(self, start, end):
self._size = end - start
self._pos = 0
self._base = start
| Python |
"""
self cloning, automatic path configuration
copy this into any subdirectory of pypy from which scripts need
to be run, typically all of the test subdirs.
The idea is that any such script simply issues
import autopath
and this will make sure that the parent directory containing "pypy"
is in sys.path.
If you modify the master "autopath.py" version (in pypy/tool/autopath.py)
you can directly run it which will copy itself on all autopath.py files
it finds under the pypy root directory.
This module always provides these attributes:
pypydir pypy root directory path
this_dir directory where this autopath.py resides
"""
def __dirinfo(part):
""" return (partdir, this_dir) and insert parent of partdir
into sys.path. If the parent directories don't have the part
an EnvironmentError is raised."""
import sys, os
try:
head = this_dir = os.path.realpath(os.path.dirname(__file__))
except NameError:
head = this_dir = os.path.realpath(os.path.dirname(sys.argv[0]))
while head:
partdir = head
head, tail = os.path.split(head)
if tail == part:
break
else:
raise EnvironmentError, "'%s' missing in '%r'" % (partdir, this_dir)
pypy_root = os.path.join(head, '')
try:
sys.path.remove(head)
except ValueError:
pass
sys.path.insert(0, head)
munged = {}
for name, mod in sys.modules.items():
if '.' in name:
continue
fn = getattr(mod, '__file__', None)
if not isinstance(fn, str):
continue
newname = os.path.splitext(os.path.basename(fn))[0]
if not newname.startswith(part + '.'):
continue
path = os.path.join(os.path.dirname(os.path.realpath(fn)), '')
if path.startswith(pypy_root) and newname != part:
modpaths = os.path.normpath(path[len(pypy_root):]).split(os.sep)
if newname != '__init__':
modpaths.append(newname)
modpath = '.'.join(modpaths)
if modpath not in sys.modules:
munged[modpath] = mod
for name, mod in munged.iteritems():
if name not in sys.modules:
sys.modules[name] = mod
if '.' in name:
prename = name[:name.rfind('.')]
postname = name[len(prename)+1:]
if prename not in sys.modules:
__import__(prename)
if not hasattr(sys.modules[prename], postname):
setattr(sys.modules[prename], postname, mod)
return partdir, this_dir
def __clone():
""" clone master version of autopath.py into all subdirs """
from os.path import join, walk
if not this_dir.endswith(join('pypy','tool')):
raise EnvironmentError("can only clone master version "
"'%s'" % join(pypydir, 'tool',_myname))
def sync_walker(arg, dirname, fnames):
if _myname in fnames:
fn = join(dirname, _myname)
f = open(fn, 'rwb+')
try:
if f.read() == arg:
print "checkok", fn
else:
print "syncing", fn
f = open(fn, 'w')
f.write(arg)
finally:
f.close()
s = open(join(pypydir, 'tool', _myname), 'rb').read()
walk(pypydir, sync_walker, s)
_myname = 'autopath.py'
# set guaranteed attributes
pypydir, this_dir = __dirinfo('pypy')
if __name__ == '__main__':
__clone()
| Python |
#! /usr/bin/env python
"""
Viewer for the CODE_DUMP output of compiled programs generating code.
Try:
./viewcode.py dumpfile.txt
or
/tmp/usession-xxx/testing_1/testing_1 -var 4 2>&1 | ./viewcode.py
"""
import autopath
import operator, sys, os, re, py, new
from bisect import bisect_left
# don't use pypy.tool.udir here to avoid removing old usessions which
# might still contain interesting executables
udir = py.path.local.make_numbered_dir(prefix='viewcode-', keep=2)
tmpfile = str(udir.join('dump.tmp'))
# hack hack
import pypy.tool
mod = new.module('pypy.tool.udir')
mod.udir = udir
sys.modules['pypy.tool.udir'] = mod
pypy.tool.udir = mod
# ____________________________________________________________
# Some support code from Psyco. There is more over there,
# I am porting it in a lazy fashion... See py-utils/xam.py
if sys.platform == "win32":
XXX # lots more in Psyco
def machine_code_dump(data, originaddr):
# the disassembler to use. 'objdump' writes GNU-style instructions.
# 'ndisasm' would use Intel syntax, but you need to fix the output parsing.
objdump = 'objdump -b binary -m i386 --adjust-vma=%(origin)d -D %(file)s'
#
f = open(tmpfile, 'wb')
f.write(data)
f.close()
g = os.popen(objdump % {'file': tmpfile, 'origin': originaddr}, 'r')
result = g.readlines()
g.close()
return result[6:] # drop some objdump cruft
def load_symbols(filename):
# the program that lists symbols, and the output it gives
symbollister = 'nm %s'
re_symbolentry = re.compile(r'([0-9a-fA-F]+)\s\w\s(.*)')
#
print 'loading symbols from %s...' % (filename,)
symbols = {}
g = os.popen(symbollister % filename, "r")
for line in g:
match = re_symbolentry.match(line)
if match:
addr = long(match.group(1), 16)
name = match.group(2)
if name.startswith('pypy_g_'):
name = '\xb7' + name[7:]
symbols[addr] = name
g.close()
print '%d symbols found' % (len(symbols),)
return symbols
re_addr = re.compile(r'[\s,$]0x([0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]+)')
re_lineaddr = re.compile(r'\s*0?x?([0-9a-fA-F]+)')
def lineaddresses(line):
result = []
i = 0
while 1:
match = re_addr.search(line, i)
if not match:
break
i = match.end()
addr = long(match.group(1), 16)
result.append(addr)
return result
# ____________________________________________________________
class CodeRange(object):
fallthrough = False
def __init__(self, world, addr, data):
self.world = world
self.addr = addr
self.data = data
def __repr__(self):
return '<CodeRange %s length %d>' % (hex(self.addr), len(self.data))
def touches(self, other):
return (self .addr < other.addr + len(other.data) and
other.addr < self .addr + len(self.data))
def update_from_old(self, other):
if other.addr < self.addr:
delta = self.addr - other.addr
assert delta <= len(other.data)
self.addr -= delta
self.data = other.data[:delta] + self.data
self_end = self .addr + len(self .data)
other_end = other.addr + len(other.data)
if other_end > self_end:
extra = other_end - self_end
assert extra <= len(other.data)
self.data += other.data[-extra:]
def cmpop(op):
def _cmp(self, other):
if not isinstance(other, CodeRange):
return NotImplemented
return op((self.addr, self.data), (other.addr, other.data))
return _cmp
__lt__ = cmpop(operator.lt)
__le__ = cmpop(operator.le)
__eq__ = cmpop(operator.eq)
__ne__ = cmpop(operator.ne)
__gt__ = cmpop(operator.gt)
__ge__ = cmpop(operator.ge)
del cmpop
def disassemble(self):
if not hasattr(self, 'text'):
lines = machine_code_dump(self.data, self.addr)
# instead of adding symbol names in the dumps we could
# also make the 0xNNNNNNNN addresses be red and show the
# symbol name when the mouse is over them
logentries = self.world.logentries
symbols = self.world.symbols
for i, line in enumerate(lines):
match = re_lineaddr.match(line)
if match:
addr = long(match.group(1), 16)
logentry = logentries.get(addr)
if logentry:
lines[i] = '\n%s\n%s' % (logentry, lines[i])
for addr in lineaddresses(line):
sym = symbols.get(addr)
if sym:
lines[i] = '%s\t%s\n' % (lines[i].rstrip(), sym)
self.text = ''.join(lines)
return self.text
def findjumps(self):
text = self.disassemble()
lines = text.splitlines()
for i, line in enumerate(lines):
if '\tj' not in line: # poor heuristic to recognize lines that
continue # could be jump instructions
addrs = list(lineaddresses(line))
if not addrs:
continue
addr = addrs[-1]
final = '\tjmp' in line
yield i, addr, final
if self.fallthrough:
yield len(lines), self.addr + len(self.data), True
class World(object):
def __init__(self):
self.ranges = []
self.labeltargets = {}
self.jumps = {}
self.symbols = {}
self.logentries = {}
def parse(self, f):
for line in f:
if line.startswith('CODE_DUMP '):
pieces = line.split()
assert pieces[1].startswith('@')
assert pieces[2].startswith('+')
baseaddr = long(pieces[1][1:], 16) & 0xFFFFFFFFL
offset = int(pieces[2][1:])
addr = baseaddr + offset
data = pieces[3].replace(':', '').decode('hex')
coderange = CodeRange(self, addr, data)
i = bisect_left(self.ranges, coderange)
j = i
while i>0 and coderange.touches(self.ranges[i-1]):
coderange.update_from_old(self.ranges[i-1])
i -= 1
while j<len(self.ranges) and coderange.touches(self.ranges[j]):
coderange.update_from_old(self.ranges[j])
j += 1
self.ranges[i:j] = [coderange]
elif line.startswith('LOG '):
pieces = line.split(None, 3)
assert pieces[1].startswith('@')
assert pieces[2].startswith('+')
baseaddr = long(pieces[1][1:], 16) & 0xFFFFFFFFL
offset = int(pieces[2][1:])
addr = baseaddr + offset
self.logentries[addr] = pieces[3]
elif line.startswith('SYS_EXECUTABLE '):
filename = line[len('SYS_EXECUTABLE '):].strip()
self.symbols.update(load_symbols(filename))
# find cross-references between blocks
fnext = 0.1
for i, r in enumerate(self.ranges):
for lineno, targetaddr, _ in r.findjumps():
self.labeltargets[targetaddr] = True
if i % 100 == 99:
f = float(i) / len(self.ranges)
if f >= fnext:
sys.stderr.write("%d%%" % int(f*100.0))
fnext += 0.1
sys.stderr.write(".")
sys.stderr.write("100%\n")
# split blocks at labeltargets
t = self.labeltargets
#print t
for r in self.ranges:
#print r.addr, r.addr + len(r.data)
for i in range(r.addr + 1, r.addr + len(r.data)):
if i in t:
#print i
ofs = i - r.addr
self.ranges.append(CodeRange(self, i, r.data[ofs:]))
r.data = r.data[:ofs]
r.fallthrough = True
try:
del r.text
except AttributeError:
pass
break
# hack hack hacked
def show(self, showtext=True, showgraph=True):
if showgraph:
g1 = Graph('codedump')
self.ranges.sort()
for r in self.ranges:
disassembled = r.disassemble()
if showtext:
print disassembled
if showgraph:
text, width = tab2columns(disassembled)
text = '0x%x\n\n%s' % (r.addr, text)
g1.emit_node('N_%x' % r.addr, shape="box", label=text,
width=str(width*0.1125))
for lineno, targetaddr, final in r.findjumps():
if final:
color = "black"
else:
color = "red"
g1.emit_edge('N_%x' % r.addr, 'N_%x' % targetaddr,
color=color)
sys.stdout.flush()
if showgraph:
g1.display()
def tab2columns(text):
lines = text.split('\n')
columnwidth = []
for line in lines:
columns = line.split('\t')[:-1]
while len(columnwidth) < len(columns):
columnwidth.append(0)
for i, s in enumerate(columns):
width = len(s.strip())
if not s.endswith(':'):
width += 2
columnwidth[i] = max(columnwidth[i], width)
columnwidth.append(1)
result = []
for line in lines:
columns = line.split('\t')
text = []
for width, s in zip(columnwidth, columns):
text.append(s.strip().ljust(width))
result.append(' '.join(text))
lengths = [len(line) for line in result]
lengths.append(1)
totalwidth = max(lengths)
return '\\l'.join(result), totalwidth
# ____________________________________________________________
# XXX pasted from
# http://codespeak.net/svn/user/arigo/hack/misc/graphlib.py
# but needs to be a bit more subtle later
from pypy.translator.tool.make_dot import DotGen
from dotviewer.graphclient import display_page
class Graph(DotGen):
def highlight(self, word, text, linked_to=None):
if not hasattr(self, '_links'):
self._links = {}
self._links_to = {}
self._links[word] = text
if linked_to:
self._links_to[word] = linked_to
def display(self):
"Display a graph page locally."
display_page(_Page(self))
class NoGraph(Exception):
pass
class _Page:
def __init__(self, graph_builder):
if callable(graph_builder):
graph = graph_builder()
else:
graph = graph_builder
if graph is None:
raise NoGraph
self.graph_builder = graph_builder
def content(self):
return _PageContent(self.graph_builder)
class _PageContent:
fixedfont = True
def __init__(self, graph_builder):
if callable(graph_builder):
graph = graph_builder()
else:
graph = graph_builder
assert graph is not None
self.graph_builder = graph_builder
self.graph = graph
self.links = getattr(graph, '_links', {})
if not hasattr(graph, '_source'):
graph._source = graph.generate(target=None)
self.source = graph._source
def followlink(self, link):
try:
return _Page(self.graph._links_to[link])
except NoGraph:
return _Page(self.graph_builder)
# ____________________________________________________________
if __name__ == '__main__':
if '--text' in sys.argv:
sys.argv.remove('--text')
showgraph = False
else:
showgraph = True
if len(sys.argv) == 1:
f = sys.stdin
else:
f = open(sys.argv[1], 'r')
world = World()
world.parse(f)
world.show(showtext=True, showgraph=showgraph)
| Python |
"""Operations.
In the spirit of LLVM, operations are also variables themselves: they
are their own result variable.
"""
import sys
from pypy.rlib.objectmodel import specialize
from pypy.objspace.std.multimethod import FailedToImplement
from pypy.jit.codegen.i386.ri386 import *
from pypy.jit.codegen.i386.ri386setup import Conditions
from pypy.jit.codegen.model import GenVar
WORD = 4 # bytes
if sys.platform == 'darwin':
CALL_ALIGN = 4
else:
CALL_ALIGN = 1
class Operation(GenVar):
clobbers_cc = True
side_effects = True
def mark_used_vars(self, allocator):
raise NotImplementedError
def generate(self, allocator):
raise NotImplementedError
class Op1(Operation):
def __init__(self, x):
self.x = x
def mark_used_vars(self, allocator):
allocator.using(self.x)
class UnaryOp(Op1):
side_effects = False
def mark_used_vars(self, allocator):
allocator.using_inplace(self.x, self)
def generate(self, allocator):
srcop = allocator.get_operand(self.x)
if allocator.release(self.x):
# in-place operation
dstop = srcop
allocator.create_exactly_at(self, dstop)
else:
# make a copy in a new register
dstop = allocator.create_reg(self, srcop)
self.emit(allocator.mc, dstop)
class OpIntNeg(UnaryOp):
opname = 'int_neg', 'int_neg_ovf'
emit = staticmethod(I386CodeBuilder.NEG)
ccexcflag = Conditions['O']
class OpIntInvert(UnaryOp):
opname = 'int_invert', 'uint_invert'
emit = staticmethod(I386CodeBuilder.NOT)
class OpIntAbs(Op1):
opname = 'int_abs', 'int_abs_ovf'
side_effects = False
ccexcflag = Conditions['L']
def mark_used_vars(self, allocator):
allocator.using(self.x)
def generate(self, allocator):
srcop = allocator.grab_operand(self.x)
dstop = allocator.create_reg(self, srcop)
# ABS-computing code from Psyco, found by exhaustive search
# on *all* short sequences of operations :-)
mc = allocator.mc
mc.SHL(dstop, imm8(1))
mc.SBB(dstop, srcop)
allocator.release(self.x)
tmpop = allocator.create_scratch_reg()
mc.SBB(tmpop, tmpop)
mc.XOR(dstop, tmpop)
allocator.end_clobber(tmpop)
class OpSameAs(Op1):
clobbers_cc = False # special handling of the cc
side_effects = False
def mark_used_vars(self, allocator):
allocator.using_inplace(self.x, self)
def generate(self, allocator):
srcop = allocator.get_operand(self.x)
if allocator.lastuse(self.x):
allocator.release(self.x)
if isinstance(srcop, CCFLAG):
allocator.create_in_cc(self, srcop)
else:
allocator.create_exactly_at(self, srcop)
else:
if isinstance(srcop, CCFLAG):
allocator.clobber_cc() # which doesn't itself clobber cc,
# so we can reuse it for us
allocator.create_in_cc(self, srcop)
else:
if isinstance(srcop, MODRM):
dstop = allocator.create_reg(self) # no stack->stack copy
else:
dstop = allocator.create(self)
if srcop != dstop: # else srcop spilled, but still in place
allocator.mc.MOV(dstop, srcop)
allocator.release(self.x)
class OpCompare1(Op1):
clobbers_cc = False # special handling of the cc
side_effects = False
def generate(self, allocator):
mc = allocator.mc
srcop = allocator.grab_operand(self.x)
if isinstance(srcop, CCFLAG):
ccop = srcop
allocator.release(self.x)
allocator.clobber_cc()
# the flags are still valid through a clobber_cc
if self.inverted:
ccop = ccflags[cond_negate(ccop.cc)]
else:
allocator.clobber_cc()
mc.CMP(srcop, imm8(0))
allocator.release(self.x)
ccop = ccflags[self.suggested_cc]
allocator.create_in_cc(self, ccop)
class OpIntIsTrue(OpCompare1):
opname = 'int_is_true', 'ptr_nonzero', 'uint_is_true'
suggested_cc = Conditions['NE']
inverted = False
class OpIntIsZero(OpIntIsTrue):
opname = 'ptr_iszero', 'bool_not'
suggested_cc = Conditions['E']
inverted = True
class OpFetchCC(Operation):
clobbers_cc = False
side_effects = False
def __init__(self, cc):
self.cc = cc
def mark_used_vars(self, allocator):
pass
def generate(self, allocator):
ccop = ccflags[self.cc]
allocator.create_in_cc(self, ccop)
class Op2(Operation):
def __init__(self, x, y):
self.x = x
self.y = y
def mark_used_vars(self, allocator):
allocator.using(self.x)
allocator.using(self.y)
class BinaryOp(Op2):
side_effects = False
commutative = False
def mark_used_vars(self, allocator):
inplace_ok = allocator.using_inplace(self.x, self)
if not inplace_ok and self.commutative:
allocator.using_inplace(self.y, self)
else:
allocator.using(self.y)
def generate(self, allocator):
# warning, subtleties about using get_operand() instead
# of grab_operand() for the best possible results
x, y = self.x, self.y
op1 = allocator.get_operand(x)
op2 = allocator.get_operand(y)
xlast = allocator.lastuse(x)
if self.commutative and not xlast and allocator.lastuse(y):
# reverse arguments, then it's an in-place operation
x, y = y, x
op1, op2 = op2, op1
xlast = True
if xlast:
dstop = op1 # in-place operation
# op1 and op2 must not be both in a stack location
if isinstance(op1, MODRM) and isinstance(op2, MODRM):
tmpop = allocator.create_scratch_reg(op2)
# neither op1 nor op2 can have been spilled here, as
# they are already in the stack
op2 = tmpop
allocator.end_clobber(tmpop)
allocator.release(x)
allocator.release(y)
allocator.create_exactly_at(self, op1)
else:
dstop = allocator.create_reg(self, op1)
op2 = allocator.get_operand(y)
allocator.release(y)
self.emit(allocator.mc, dstop, op2)
class OpIntAdd(BinaryOp):
opname = 'int_add', 'uint_add', 'int_add_ovf'
emit = staticmethod(I386CodeBuilder.ADD)
commutative = True
ccexcflag = Conditions['O']
class OpIntSub(BinaryOp):
opname = 'int_sub', 'uint_sub', 'int_sub_ovf'
emit = staticmethod(I386CodeBuilder.SUB)
ccexcflag = Conditions['O']
class OpIntAnd(BinaryOp):
opname = 'int_and', 'uint_and'
emit = staticmethod(I386CodeBuilder.AND)
class OpIntOr(BinaryOp):
opname = 'int_or', 'uint_or'
emit = staticmethod(I386CodeBuilder.OR)
class OpIntXor(BinaryOp):
opname = 'int_xor', 'uint_xor'
emit = staticmethod(I386CodeBuilder.XOR)
class OpIntMul(Op2):
opname = 'int_mul', 'int_mul_ovf'
side_effects = False
ccexcflag = Conditions['O']
def generate(self, allocator):
op1 = allocator.get_operand(self.x)
op2 = allocator.get_operand(self.y)
if isinstance(op1, REG) and allocator.lastuse(self.x):
allocator.release(self.x)
allocator.release(self.y)
allocator.create_exactly_at(self, op1)
dstop = op1
elif isinstance(op2, REG) and allocator.lastuse(self.y):
allocator.release(self.x)
allocator.release(self.y)
allocator.create_exactly_at(self, op2)
dstop = op2
else:
dstop = allocator.create_reg(self)
allocator.release(self.x)
allocator.release(self.y)
mc = allocator.mc
if isinstance(op2, IMM32):
mc.IMUL(dstop, op1, op2)
elif isinstance(op1, IMM32):
mc.IMUL(dstop, op2, op1)
elif dstop == op1:
mc.IMUL(dstop, op2)
elif dstop == op2:
mc.IMUL(dstop, op1)
else:
mc.MOV(dstop, op1)
mc.IMUL(dstop, op2)
class MulOrDivOp(Op2):
side_effects = False
def generate(self, allocator):
# XXX not very efficient but not very common operations either
allocator.clobber2(eax, edx)
mc = allocator.mc
op1 = allocator.get_operand(self.x)
if op1 != eax:
mc.MOV(eax, op1)
if self.input_is_64bits:
if self.unsigned:
mc.XOR(edx, edx)
else:
mc.CDQ()
op2 = allocator.grab_operand(self.y)
try:
self.generate2(allocator, op2)
except FailedToImplement:
tmp = allocator.create_scratch_reg(op2)
self.generate2(allocator, tmp)
allocator.end_clobber(tmp)
allocator.end_clobber(eax)
allocator.end_clobber(edx)
allocator.release(self.x)
allocator.release(self.y)
# the target register should still be free, see clobber2()
allocator.create_exactly_at(self, self.reg_containing_result)
## __________ logic for Python-like division and modulo _________
##
## (disabled for now, as int_floordiv and int_mod have CPU-like
## semantics at the moment)
##class OpIntFloorDiv(MulOrDivOp):
## opname = 'int_floordiv'
## input_is_64bits = True
## reg_containing_result = eax
## unsigned = False
## def generate2(self, allocator, op2):
## # from the PPC backend which has the same problem:
## #
## # grumble, the powerpc handles division when the signs of x
## # and y differ the other way to how cpython wants it. this
## # crawling horror is a branch-free way of computing the right
## # remainder in all cases. it's probably not optimal.
## #
## # we need to adjust the result iff the remainder is non-zero
## # and the signs of x and y differ. in the standard-ish PPC
## # way, we compute boolean values as either all-bits-0 or
## # all-bits-1 and "and" them together, resulting in either
## # adding 0 or -1 as needed in the final step.
## #
## # Python i386
## # 20/3 = 6, 2 6, 2
## # (-20)/3 = -7, 1 -6,-2 # operand signs differ
## # 20/(-3) = -7,-1 -6, 2 # operand signs differ
## # (-20)/(-3) = 6,-2 6,-2
## #
## tmp = allocator.create_scratch_reg()
## mc = allocator.mc
## if isinstance(op2, IMM32): XXX
## # if op2 is an immediate, we do an initial adjustment of operand 1
## # so that we get directly the correct answer
## if op2.value >= 0:
## # if op1 is negative, subtract (op2-1)
## mc.MOV(tmp, edx) # -1 if op1 is negative, 0 otherwise
## mc.AND(tmp, imm(op2.value-1))
## mc.SUB(eax, tmp)
## mc.SBB(edx, imm8(0))
## else:
## # if op1 is positive (or null), add (|op2|-1)
## mc.MOV(tmp, edx)
## mc.NOT(tmp) # -1 if op1 is positive, 0 otherwise
## mc.AND(tmp, imm(-op2.value-1))
## mc.ADD(eax, tmp)
## mc.ADC(edx, imm8(0))
## mc.MOV(tmp, op2)
## mc.IDIV(tmp)
## else:
## # subtract 1 to the result if the operand signs differ and
## # the remainder is not zero
## mc.MOV(tmp, eax)
## mc.IDIV(op2)
## mc.XOR(tmp, op2)
## mc.SAR(tmp, imm8(31)) # -1 if signs differ, 0 otherwise
## mc.AND(tmp, edx) # nonnull if signs differ and edx != 0
## mc.CMP(tmp, imm8(1)) # no carry flag iff signs differ and edx != 0
## mc.ADC(eax, imm8(-1)) # subtract 1 iff no carry flag
## allocator.end_clobber(tmp)
##class OpIntMod(MulOrDivOp):
## opname = 'int_mod'
## input_is_64bits = True
## reg_containing_result = edx
## unsigned = False
## def generate2(self, allocator, op2):
## # Python i386
## # 20/3 = 6, 2 6, 2
## # (-20)/3 = -7, 1 -6,-2 # operand signs differ
## # 20/(-3) = -7,-1 -6, 2 # operand signs differ
## # (-20)/(-3) = 6,-2 6,-2
## #
## tmp = allocator.create_scratch_reg()
## mc = allocator.mc
## if isinstance(op2, IMM32): XXX
## mc.MOV(tmp, op2)
## mc.IDIV(tmp)
## # adjustment needed:
## # if op2 > 0: if the result is negative, add op2 to it
## # if op2 < 0: if the result is > 0, subtract |op2| from it
## mc.MOV(tmp, edx)
## if op2.value < 0:
## mc.NEG(tmp)
## mc.SAR(tmp, imm8(31))
## mc.AND(tmp, imm(op2.value))
## mc.ADD(edx, tmp)
## else:
## # if the operand signs differ and the remainder is not zero,
## # add operand2 to the result
## mc.MOV(tmp, eax)
## mc.IDIV(op2)
## mc.XOR(tmp, op2)
## mc.SAR(tmp, imm8(31)) # -1 if signs differ, 0 otherwise
## mc.AND(tmp, edx) # nonnull if signs differ and edx != 0
## mc.CMOVNZ(tmp, op2) # == op2 if signs differ and edx != 0
## mc.ADD(edx, tmp)
## allocator.end_clobber(tmp)
class OpUIntMul(MulOrDivOp):
opname = 'uint_mul'
input_is_64bits = False
reg_containing_result = eax
unsigned = True
def generate2(self, allocator, op2):
allocator.mc.MUL(op2)
class OpUIntFloorDiv(MulOrDivOp):
opname = 'uint_floordiv'
input_is_64bits = True
reg_containing_result = eax
unsigned = True
def generate2(self, allocator, op2):
allocator.mc.DIV(op2)
class OpUIntMod(MulOrDivOp):
opname = 'uint_mod'
input_is_64bits = True
reg_containing_result = edx
unsigned = True
def generate2(self, allocator, op2):
allocator.mc.DIV(op2)
class OpIntFloorDiv(MulOrDivOp):
opname = 'int_floordiv'
input_is_64bits = True
reg_containing_result = eax
unsigned = False
def generate2(self, allocator, op2):
allocator.mc.IDIV(op2)
class OpIntMod(MulOrDivOp):
opname = 'int_mod'
input_is_64bits = True
reg_containing_result = edx
unsigned = False
def generate2(self, allocator, op2):
allocator.mc.IDIV(op2)
class OpShift(Op2):
side_effects = False
countmax31 = False
def mark_used_vars(self, allocator):
allocator.using_inplace(self.x, self)
allocator.using(self.y)
if not self.countmax31:
allocator.suggests(self.y, ecx)
def generate(self, allocator):
op2 = allocator.get_operand(self.y)
mc = allocator.mc
if isinstance(op2, IMM32):
n = op2.value
if n < 0 or n >= 32:
# shift out of range
if self.countmax31:
n = 31 # case in which it's equivalent to a shift by 31
else:
# case in which the result is always zero
allocator.release(self.x)
allocator.release(self.y)
dstop = allocator.create_reg(self)
mc.XOR(dstop, dstop)
return
count = imm8(n)
else:
if self.countmax31:
allocator.clobber(ecx)
op2 = allocator.get_operand(self.y)
mc.MOV(ecx, imm8(31))
mc.CMP(op2, ecx)
mc.CMOVBE(ecx, op2)
allocator.release(self.y)
elif op2 != ecx:
allocator.clobber(ecx)
op2 = allocator.get_operand(self.y)
mc.MOV(ecx, op2)
allocator.release(self.y)
else:
allocator.release(self.y)
allocator.clobber(ecx) # but self.y is still in there
count = cl
srcop = allocator.get_operand(self.x)
if allocator.release(self.x):
dstop = srcop # in-place operation
allocator.create_exactly_at(self, dstop)
else:
# make a copy in a new register
dstop = allocator.create_reg(self, srcop)
self.emit(mc, dstop, count)
if count is cl:
if not self.countmax31:
mc.CMP(ecx, imm8(32))
mc.SBB(ecx, ecx)
mc.AND(dstop, ecx)
allocator.end_clobber(ecx)
class OpIntLShift(OpShift):
opname = 'int_lshift', 'uint_lshift'
emit = staticmethod(I386CodeBuilder.SHL)
class OpUIntRShift(OpShift):
opname = 'uint_rshift'
emit = staticmethod(I386CodeBuilder.SHR)
class OpIntRShift(OpShift):
opname = 'int_rshift'
emit = staticmethod(I386CodeBuilder.SAR)
countmax31 = True
class OpCompare2(Op2):
side_effects = False
def generate(self, allocator):
op1 = allocator.get_operand(self.x)
op2 = allocator.get_operand(self.y)
mc = allocator.mc
cond = self.suggested_cc
try:
mc.CMP(op1, op2)
except FailedToImplement:
# try reversing the arguments, for CMP(immed, reg-or-modrm)
try:
mc.CMP(op2, op1)
except FailedToImplement:
# CMP(stack, stack)
reg = allocator.create_scratch_reg(op1)
op2 = allocator.get_operand(self.y)
mc.CMP(reg, op2)
allocator.end_clobber(reg)
else:
cond = cond_swapargs(cond) # worked with arguments reversed
allocator.release(self.x)
allocator.release(self.y)
allocator.create_in_cc(self, ccflags[cond])
class OpIntLt(OpCompare2):
opname = 'int_lt', 'char_lt'
suggested_cc = Conditions['L']
class OpIntLe(OpCompare2):
opname = 'int_le', 'char_le'
suggested_cc = Conditions['LE']
class OpIntEq(OpCompare2):
opname = 'int_eq', 'char_eq', 'unichar_eq', 'ptr_eq', 'uint_eq'
suggested_cc = Conditions['E']
class OpIntNe(OpCompare2):
opname = 'int_ne', 'char_ne', 'unichar_ne', 'ptr_ne', 'uint_ne'
suggested_cc = Conditions['NE']
class OpIntGt(OpCompare2):
opname = 'int_gt', 'char_gt'
suggested_cc = Conditions['G']
class OpIntGe(OpCompare2):
opname = 'int_ge', 'char_ge'
suggested_cc = Conditions['GE']
class OpUIntLt(OpCompare2):
opname = 'uint_lt'
suggested_cc = Conditions['B']
class OpUIntLe(OpCompare2):
opname = 'uint_le'
suggested_cc = Conditions['BE']
class OpUIntGt(OpCompare2):
opname = 'uint_gt'
suggested_cc = Conditions['A']
class OpUIntGe(OpCompare2):
opname = 'uint_ge'
suggested_cc = Conditions['AE']
class JumpIf(Operation):
clobbers_cc = False
negate = False
def __init__(self, gv_condition, targetbuilder):
self.gv_condition = gv_condition
self.targetbuilder = targetbuilder
def mark_used_vars(self, allocator):
allocator.using(self.gv_condition)
for gv in self.targetbuilder.inputargs_gv:
allocator.using(gv)
def generate(self, allocator):
targetbuilder = self.targetbuilder
op = allocator.get_operand(self.gv_condition)
mc = allocator.mc
if isinstance(op, CCFLAG):
cc = op.cc
else:
allocator.clobber_cc()
op = allocator.get_operand(self.gv_condition)
mc.CMP(op, imm(0))
cc = Conditions['NE']
operands = []
for gv in targetbuilder.inputargs_gv:
operands.append(allocator.get_operand(gv))
allocator.release(self.gv_condition)
for gv in targetbuilder.inputargs_gv:
allocator.release(gv)
if self.negate:
cc = cond_negate(cc)
targetbuilder.set_coming_from(mc, insncond=cc)
targetbuilder.inputoperands = operands
#assert targetbuilder.inputoperands.count(ebx) <= 1
class JumpIfNot(JumpIf):
negate = True
class OpLabel(Operation):
# NB. this is marked to clobber the CC, because it cannot easily
# be saved/restored across a label. The problem is that someone
# might later try to jump to this label with a new value for
# the variable that is different from 0 or 1, i.e. which cannot
# be represented in the CC at all.
def __init__(self, lbl, args_gv):
self.lbl = lbl
self.args_gv = args_gv
def mark_used_vars(self, allocator):
for v in self.args_gv:
allocator.using(v)
def generate(self, allocator):
operands = []
for v in self.args_gv:
operands.append(allocator.get_operand(v))
for v in self.args_gv:
allocator.release(v)
lbl = self.lbl
lbl.targetaddr = allocator.mc.tell()
lbl.inputoperands = operands
lbl.targetbuilder = None # done generating
class OpCall(Operation):
def __init__(self, sigtoken, gv_fnptr, args_gv):
self.sigtoken = sigtoken
self.gv_fnptr = gv_fnptr
self.args_gv = args_gv
def mark_used_vars(self, allocator):
allocator.using(self.gv_fnptr)
for v in self.args_gv:
allocator.using(v)
def generate(self, allocator):
mc = allocator.mc
args_gv = self.args_gv
stackargs_i = []
for i in range(len(args_gv)):
srcop = allocator.get_operand(args_gv[i])
if isinstance(srcop, MODRM):
stackargs_i.append(i)
else:
mc.MOV(mem(esp, WORD * i), srcop)
allocator.clobber3(eax, edx, ecx)
allocator.reserve_extra_stack(len(args_gv))
if len(stackargs_i) > 0:
tmp = eax
for i in stackargs_i:
srcop = allocator.get_operand(args_gv[i])
mc.MOV(tmp, srcop)
mc.MOV(mem(esp, WORD * i), tmp)
fnop = allocator.get_operand(self.gv_fnptr)
if isinstance(fnop, IMM32):
mc.CALL(rel32(fnop.value))
else:
mc.CALL(fnop)
allocator.release(self.gv_fnptr)
for v in args_gv:
allocator.release(v)
allocator.end_clobber(eax)
allocator.end_clobber(edx)
allocator.end_clobber(ecx)
if allocator.operation_result_is_used(self):
allocator.create_exactly_at(self, eax)
def field_operand(allocator, gv_base, fieldtoken):
fieldoffset, fieldsize = fieldtoken
base = allocator.get_operand(gv_base)
if isinstance(base, MODRM):
tmp = allocator.create_scratch_reg(base)
allocator.end_clobber(tmp)
base = tmp
elif isinstance(base, IMM32):
fieldoffset += base.value
base = None
allocator.release(gv_base)
if fieldsize == 1:
return mem8(base, fieldoffset)
else:
return mem (base, fieldoffset)
def array_item_operand(allocator, gv_base, arraytoken, gv_opindex):
tmp = None
_, startoffset, itemoffset = arraytoken
opindex = allocator.get_operand(gv_opindex)
if isinstance(opindex, IMM32):
startoffset += itemoffset * opindex.value
opindex = None
indexshift = 0
elif itemoffset in SIZE2SHIFT:
if not isinstance(opindex, REG):
tmp = allocator.create_scratch_reg(opindex)
opindex = tmp
indexshift = SIZE2SHIFT[itemoffset]
else:
tmp = allocator.create_scratch_reg()
allocator.mc.IMUL(tmp, opindex, imm(itemoffset))
opindex = tmp
indexshift = 0
if gv_base is None:
base = None
else:
base = allocator.get_operand(gv_base)
if isinstance(base, MODRM):
if tmp is None:
tmp = allocator.create_scratch_reg(base)
else: # let's avoid using two scratch registers
opindex = None
if indexshift > 0:
allocator.mc.SHL(tmp, imm8(indexshift))
allocator.mc.ADD(tmp, base)
base = tmp
elif isinstance(base, IMM32):
startoffset += base.value
base = None
allocator.release(gv_base)
if tmp is not None:
allocator.end_clobber(tmp)
allocator.release(gv_opindex)
if itemoffset == 1:
return memSIB8(base, opindex, indexshift, startoffset)
else:
return memSIB (base, opindex, indexshift, startoffset)
class OpComputeSize(Operation):
clobbers_cc = False
side_effects = False
def __init__(self, varsizealloctoken, gv_length):
self.varsizealloctoken = varsizealloctoken
self.gv_length = gv_length
def mark_used_vars(self, allocator):
allocator.using(self.gv_length)
def generate(self, allocator):
op_size = array_item_operand(allocator, None,
self.varsizealloctoken, self.gv_length)
dstop = allocator.create_reg(self)
allocator.mc.LEA(dstop, op_size)
class OpGetter(Operation):
side_effects = False
def generate(self, allocator):
opsource = self.generate_opsource(allocator)
dstop = allocator.create_reg(self)
if self.getwidth() == WORD:
allocator.mc.MOV(dstop, opsource)
else:
allocator.mc.MOVZX(dstop, opsource)
class OpSetter(Operation):
def generate(self, allocator):
tmpval = None
width = self.getwidth()
opvalue = allocator.grab_operand(self.gv_value)
if width == 1:
try:
opvalue = opvalue.lowest8bits()
except ValueError:
tmpval = allocator.create_scratch_reg8(opvalue)
opvalue = tmpval
else:
if isinstance(opvalue, MODRM8):
tmpval = allocator.create_scratch_reg8(opvalue)
opvalue = tmpval
else:
if isinstance(opvalue, MODRM):
tmpval = allocator.create_scratch_reg(opvalue)
opvalue = tmpval
optarget = self.generate_optarget(allocator)
if width == 2:
if isinstance(opvalue, IMM32):
opvalue = IMM16(opvalue.value)
allocator.mc.o16()
allocator.mc.MOV(optarget, opvalue)
if tmpval is not None:
allocator.end_clobber(tmpval)
class OpGetField(OpGetter):
clobbers_cc = False
def __init__(self, fieldtoken, gv_ptr):
self.fieldtoken = fieldtoken
self.gv_ptr = gv_ptr
def getwidth(self):
_, fieldsize = self.fieldtoken
return fieldsize
def mark_used_vars(self, allocator):
allocator.using(self.gv_ptr)
def generate_opsource(self, allocator):
opsource = field_operand(allocator, self.gv_ptr, self.fieldtoken)
return opsource
class OpSetField(OpSetter):
clobbers_cc = False
def __init__(self, fieldtoken, gv_ptr, gv_value):
self.fieldtoken = fieldtoken
self.gv_ptr = gv_ptr
self.gv_value = gv_value
def getwidth(self):
_, fieldsize = self.fieldtoken
return fieldsize
def mark_used_vars(self, allocator):
allocator.using(self.gv_ptr)
allocator.using(self.gv_value)
def generate_optarget(self, allocator):
optarget = field_operand(allocator, self.gv_ptr, self.fieldtoken)
allocator.release(self.gv_value)
return optarget
class OpGetArrayItem(OpGetter):
def __init__(self, arraytoken, gv_array, gv_index):
self.arraytoken = arraytoken
self.gv_array = gv_array
self.gv_index = gv_index
def getwidth(self):
_, _, itemsize = self.arraytoken
return itemsize
def mark_used_vars(self, allocator):
allocator.using(self.gv_array)
allocator.using(self.gv_index)
def generate_opsource(self, allocator):
opsource = array_item_operand(allocator, self.gv_array,
self.arraytoken, self.gv_index)
return opsource
class OpGetArraySubstruct(OpGetArrayItem):
def generate(self, allocator):
opsource = self.generate_opsource(allocator)
dstop = allocator.create_reg(self)
allocator.mc.LEA(dstop, opsource)
class OpSetArrayItem(OpSetter):
def __init__(self, arraytoken, gv_array, gv_index, gv_value):
self.arraytoken = arraytoken
self.gv_array = gv_array
self.gv_index = gv_index
self.gv_value = gv_value
def getwidth(self):
_, _, itemsize = self.arraytoken
return itemsize
def mark_used_vars(self, allocator):
allocator.using(self.gv_array)
allocator.using(self.gv_index)
allocator.using(self.gv_value)
def generate_optarget(self, allocator):
opsource = array_item_operand(allocator, self.gv_array,
self.arraytoken, self.gv_index)
allocator.release(self.gv_value)
return opsource
class OpGetExitSwitch(Op1):
# a bit of a hack: to put last in a block ending in a flexswitch,
# to load the switch value into a register and remember which
# register it is.
def generate(self, allocator):
op = allocator.get_operand(self.x)
if isinstance(op, REG):
self.reg = op
else:
self.reg = allocator.create_scratch_reg(op)
allocator.end_clobber(self.reg)
allocator.release(self.x)
# ____________________________________________________________
def setup_opclasses(base):
d = {}
for name, value in globals().items():
if type(value) is type(base) and issubclass(value, base):
opnames = getattr(value, 'opname', ())
if isinstance(opnames, str):
opnames = (opnames,)
for opname in opnames:
assert opname not in d
d[opname] = value
return d
OPCLASSES1 = setup_opclasses(Op1)
OPCLASSES2 = setup_opclasses(Op2)
del setup_opclasses
# identity operations
OPCLASSES1['cast_bool_to_int'] = None
OPCLASSES1['cast_char_to_int'] = None
OPCLASSES1['cast_unichar_to_int'] = None
OPCLASSES1['cast_int_to_char'] = None
OPCLASSES1['cast_int_to_unichar'] = None
OPCLASSES1['cast_ptr_to_int'] = None
OPCLASSES1['cast_int_to_ptr'] = None
OPCLASSES1['cast_uint_to_int'] = None
OPCLASSES1['cast_bool_to_uint'] = None
OPCLASSES1['cast_int_to_uint'] = None
# special cases
#OPCLASSES1['bool_not'] = genop_bool_not XXX do something about it
@specialize.memo()
def getopclass1(opname):
try:
return OPCLASSES1[opname]
except KeyError:
raise MissingBackendOperation(opname)
@specialize.memo()
def getopclass2(opname):
try:
return OPCLASSES2[opname]
except KeyError:
raise MissingBackendOperation(opname)
class MissingBackendOperation(Exception):
pass
def setup_conditions():
result1 = [None] * 16
result2 = [None] * 16
for key, value in Conditions.items():
result1[value] = getattr(I386CodeBuilder, 'J'+key)
result2[value] = getattr(I386CodeBuilder, 'SET'+key)
return result1, result2
EMIT_JCOND, EMIT_SETCOND = setup_conditions()
INSN_JMP = len(EMIT_JCOND)
EMIT_JCOND.append(I386CodeBuilder.JMP) # not really a conditional jump
del setup_conditions
def cond_negate(cond):
assert 0 <= cond < INSN_JMP
return cond ^ 1
def cond_swapargs(cond):
return COND_SWAPARGS[cond]
COND_SWAPARGS = range(16)
COND_SWAPARGS[Conditions['L']] = Conditions['G']
COND_SWAPARGS[Conditions['G']] = Conditions['L']
COND_SWAPARGS[Conditions['NL']] = Conditions['NG']
COND_SWAPARGS[Conditions['NG']] = Conditions['NL']
COND_SWAPARGS[Conditions['B']] = Conditions['A']
COND_SWAPARGS[Conditions['A']] = Conditions['B']
COND_SWAPARGS[Conditions['NB']] = Conditions['NA']
COND_SWAPARGS[Conditions['NA']] = Conditions['NB']
SIZE2SHIFT = {1: 0,
2: 1,
4: 2,
8: 3}
# ____________________________________________________________
class CCFLAG(OPERAND):
_attrs_ = ['cc', 'SETCOND', 'load_into_cc']
def __init__(self, cond, load_into_cc):
self.cond = cond
self.cc = Conditions[cond]
self.SETCOND = getattr(I386CodeBuilder, 'SET' + cond)
self.load_into_cc = load_into_cc
def assembler(self):
return self.cond
def load_into_cc_o(mc, srcop):
mc.MOV(ecx, srcop)
mc.ADD(ecx, imm(sys.maxint))
def load_into_cc_no(self, srcop):
mc.MOV(ecx, imm(-sys.maxint-1))
mc.ADD(ecx, srcop)
mc.DEC(ecx)
def load_into_cc_lt(mc, srcop):
mc.XOR(ecx, ecx)
mc.CMP(ecx, srcop)
def load_into_cc_le(mc, srcop):
mc.MOV(ecx, imm8(1))
mc.CMP(ecx, srcop)
def load_into_cc_eq(mc, srcop):
mc.CMP(srcop, imm8(1))
def load_into_cc_ne(mc, srcop):
mc.CMP(srcop, imm8(0))
load_into_cc_gt = load_into_cc_ne
load_into_cc_ge = load_into_cc_eq
ccflag_o = CCFLAG('O', load_into_cc_o)
ccflag_no = CCFLAG('NO', load_into_cc_no)
ccflag_lt = CCFLAG('L', load_into_cc_lt)
ccflag_le = CCFLAG('LE', load_into_cc_le)
ccflag_eq = CCFLAG('E', load_into_cc_eq)
ccflag_ne = CCFLAG('NE', load_into_cc_ne)
ccflag_gt = CCFLAG('G', load_into_cc_gt)
ccflag_ge = CCFLAG('GE', load_into_cc_ge)
ccflag_ult = CCFLAG('B', load_into_cc_lt)
ccflag_ule = CCFLAG('BE', load_into_cc_le)
ccflag_ugt = CCFLAG('A', load_into_cc_gt)
ccflag_uge = CCFLAG('AE', load_into_cc_ge)
ccflags = [None] * 16
ccflags[Conditions['O']] = ccflag_o
ccflags[Conditions['NO']] = ccflag_no
ccflags[Conditions['L']] = ccflag_lt
ccflags[Conditions['LE']] = ccflag_le
ccflags[Conditions['E']] = ccflag_eq
ccflags[Conditions['NE']] = ccflag_ne
ccflags[Conditions['G']] = ccflag_gt
ccflags[Conditions['GE']] = ccflag_ge
ccflags[Conditions['B']] = ccflag_ult
ccflags[Conditions['BE']] = ccflag_ule
ccflags[Conditions['A']] = ccflag_ugt
ccflags[Conditions['AE']] = ccflag_uge
##def ccmov(mc, dstop, ccop):
## XXX
## if dstop != ccop:
## ccop.SETCOND(mc, cl)
## if isinstance(dstop, CCFLAG):
## dstop.load_into_cc(mc, cl)
## else:
## try:
## mc.MOVZX(dstop, cl)
## except FailedToImplement:
## mc.MOVZX(ecx, cl)
## mc.MOV(dstop, ecx)
| Python |
from pypy.rlib.rarithmetic import intmask
class OPERAND(object):
_attrs_ = []
def __repr__(self):
return '<%s %s>' % (self.__class__.__name__, self.assembler())
class REG(OPERAND):
width = 4
def __repr__(self):
return '<%s>' % self.__class__.__name__.lower()
def assembler(self):
return '%' + self.__class__.__name__.lower()
def lowest8bits(self):
if self.op < 4:
return registers8[self.op]
else:
raise ValueError
class REG8(OPERAND):
width = 1
def __repr__(self):
return '<%s>' % self.__class__.__name__.lower()
def assembler(self):
return '%' + self.__class__.__name__.lower()
class EAX(REG): op=0
class ECX(REG): op=1
class EDX(REG): op=2
class EBX(REG): op=3
class ESP(REG): op=4
class EBP(REG): op=5
class ESI(REG): op=6
class EDI(REG): op=7
class AL(REG8): op=0
class CL(REG8): op=1
class DL(REG8): op=2
class BL(REG8): op=3
class AH(REG8): op=4
class CH(REG8): op=5
class DH(REG8): op=6
class BH(REG8): op=7
class IMM32(OPERAND):
width = 4
value = 0 # annotator hack
def __init__(self, value):
self.value = value
def assembler(self):
return '$%d' % (self.value,)
def lowest8bits(self):
val = self.value & 0xFF
if val > 0x7F:
val -= 0x100
return IMM8(val)
class IMM8(IMM32):
width = 1
class IMM16(OPERAND): # only for RET
width = 2
value = 0 # annotator hack
def __init__(self, value):
self.value = value
def assembler(self):
return '$%d' % (self.value,)
class MODRM(OPERAND):
width = 4
def __init__(self, byte, extradata):
self.byte = byte
self.extradata = extradata
def lowest8bits(self):
return MODRM8(self.byte, self.extradata)
def assembler(self):
mod = self.byte & 0xC0
rm = self.byte & 0x07
if mod == 0xC0:
return registers[rm].assembler()
if self.byte == 0x05:
return '%d' % (unpack(self.extradata),)
if mod == 0x00:
offset_bytes = 0
elif mod == 0x40:
offset_bytes = 1
else:
offset_bytes = 4
if rm == 4:
SIB = ord(self.extradata[0])
scale = (SIB & 0xC0) >> 6
index = (SIB & 0x38) >> 3
base = (SIB & 0x07)
if base == 5 and mod == 0x00:
offset_bytes = 4
basename = ''
else:
basename = registers[base].assembler()
if index == 4:
# no index
s = '(%s)' % (basename,)
else:
indexname = registers[index].assembler()
s = '(%s,%s,%d)' % (basename, indexname, 1 << scale)
offset = self.extradata[1:]
else:
s = '(%s)' % (registers[rm].assembler(),)
offset = self.extradata
assert len(offset) == offset_bytes
if offset_bytes > 0:
s = '%d%s' % (unpack(offset), s)
return s
def is_register(self):
mod = self.byte & 0xC0
return mod == 0xC0
def ofs_relative_to_ebp(self):
# very custom: if self is a mem(ebp, ofs) then return ofs
# otherwise raise ValueError
mod = self.byte & 0xC0
rm = self.byte & 0x07
if mod == 0xC0:
raise ValueError # self is just a register
if self.byte == 0x05:
raise ValueError # self is just an [immediate]
if rm != 5:
raise ValueError # not a simple [ebp+ofs]
offset = self.extradata
if not offset:
return 0
else:
return unpack(offset)
def is_relative_to_ebp(self):
try:
self.ofs_relative_to_ebp()
except ValueError:
return False
else:
return True
def involves_ecx(self):
# very custom: is ecx present in this mod/rm?
mod = self.byte & 0xC0
rm = self.byte & 0x07
if mod != 0xC0 and rm == 4:
SIB = ord(self.extradata[0])
index = (SIB & 0x38) >> 3
base = (SIB & 0x07)
return base == ECX.op or index == ECX.op
else:
return rm == ECX.op
class MODRM8(MODRM):
width = 1
class REL32(OPERAND):
width = 4
def __init__(self, absolute_target):
self.absolute_target = absolute_target
def assembler(self):
return '%d' % (self.absolute_target,)
class MISSING(OPERAND):
def __repr__(self):
return '<MISSING>'
# ____________________________________________________________
# Public interface: the concrete operands to instructions
#
# NB.: UPPERCASE names represent classes of operands (the same
# instruction can have multiple modes, depending on these
# classes), while lowercase names are concrete operands.
eax = EAX()
ecx = ECX()
edx = EDX()
ebx = EBX()
esp = ESP()
ebp = EBP()
esi = ESI()
edi = EDI()
al = AL()
cl = CL()
dl = DL()
bl = BL()
ah = AH()
ch = CH()
dh = DH()
bh = BH()
registers = [eax, ecx, edx, ebx, esp, ebp, esi, edi]
registers8 = [al, cl, dl, bl, ah, ch, dh, bh]
for r in registers + registers8:
r.bitmask = 1 << r.op
del r
imm32 = IMM32
imm8 = IMM8
imm16 = IMM16
rel32 = REL32
def imm(value):
if single_byte(value):
return imm8(value)
else:
return imm32(value)
def memregister(register):
assert register.width == 4
return MODRM(0xC0 | register.op, '')
def mem(basereg, offset=0):
return memSIB(basereg, None, 0, offset)
def memSIB(base, index, scaleshift, offset):
return _SIBencode(MODRM, base, index, scaleshift, offset)
def memregister8(register):
assert register.width == 1
return MODRM8(0xC0 | register.op, '')
def mem8(basereg, offset=0):
return memSIB8(basereg, None, 0, offset)
def memSIB8(base, index, scaleshift, offset):
return _SIBencode(MODRM8, base, index, scaleshift, offset)
def _SIBencode(cls, base, index, scaleshift, offset):
assert base is None or isinstance(base, REG)
assert index is None or (isinstance(index, REG) and index is not esp)
assert 0<=scaleshift<4
if base is None:
if index is None:
return cls(0x05, packimm32(offset))
if scaleshift > 0:
return cls(0x04, chr((scaleshift<<6) | (index.op<<3) | 0x05) +
packimm32(offset))
base = index
index = None
if index is not None:
SIB = chr((scaleshift<<6) | (index.op<<3) | base.op)
elif base is esp:
SIB = '\x24'
elif offset == 0 and base is not ebp:
return cls(base.op, '')
elif single_byte(offset):
return cls(0x40 | base.op, packimm8(offset))
else:
return cls(0x80 | base.op, packimm32(offset))
if offset == 0 and base is not ebp:
return cls(0x04, SIB)
elif single_byte(offset):
return cls(0x44, SIB + packimm8(offset))
else:
return cls(0x84, SIB + packimm32(offset))
def fixedsize_ebp_ofs(offset):
return MODRM(0x80 | EBP.op, packimm32(offset))
def single_byte(value):
return -128 <= value < 128
def packimm32(i):
return (chr(i & 0xFF) +
chr((i >> 8) & 0xFF) +
chr((i >> 16) & 0xFF) +
chr((i >> 24) & 0xFF))
def packimm8(i):
if i < 0:
i += 256
return chr(i)
def packimm16(i):
return (chr(i & 0xFF) +
chr((i >> 8) & 0xFF))
def unpack(s):
assert len(s) in (1, 2, 4)
if len(s) == 1:
a = ord(s[0])
if a > 0x7f:
a -= 0x100
else:
a = ord(s[0]) | (ord(s[1]) << 8)
if len(s) == 2:
if a > 0x7fff:
a -= 0x10000
else:
a |= (ord(s[2]) << 16) | (ord(s[3]) << 24)
a = intmask(a)
return a
missing = MISSING()
# __________________________________________________________
# Abstract base class, with methods like NOP(), ADD(x, y), etc.
class I386CodeBuilder(object):
def write(self, data):
raise NotImplementedError
def tell(self):
raise NotImplementedError
import ri386setup # side-effect: add methods to I386CodeBuilder
| Python |
"""
For testing purposes. Turns *simple enough* low-level graphs
into machine code by calling the rgenop interface.
"""
from pypy.rpython.lltypesystem import lltype
from pypy.objspace.flow import model as flowmodel
import random
def rcompile(rgenop, entrypoint, argtypes, random_seed=0):
from pypy.translator.translator import TranslationContext
from pypy.annotation.policy import AnnotatorPolicy
from pypy import conftest
t = TranslationContext()
policy = AnnotatorPolicy()
policy.allow_someobjects = False
t.buildannotator(policy=policy).build_types(entrypoint, argtypes)
t.buildrtyper().specialize()
# note that backend optimizations will constant-fold simple operations,
# which is required by some backends that don't accept calls like
# genop1("add", constant, constant).
from pypy.translator.backendopt.all import backend_optimizations
backend_optimizations(t)
if conftest.option.view:
t.view()
entrygraph = t._graphof(entrypoint)
return compile_graph(rgenop, entrygraph, random_seed=random_seed)
def compile_graph(rgenop, graph, random_seed=0):
FUNC = lltype.FuncType([v.concretetype for v in graph.getargs()],
graph.getreturnvar().concretetype)
sigtoken = rgenop.sigToken(FUNC)
builder, gv_entrypoint, args_gv = rgenop.newgraph(sigtoken,
"compiled_%s" % (graph.name,))
def varkind(v):
return rgenop.kindToken(v.concretetype)
def var2gv(v):
if isinstance(v, flowmodel.Variable):
return varmap[v]
else:
return rgenop.genconst(v.value)
map(varkind, graph.getargs()) # for the py.test.skip() in some backends
pending_blocks = [(graph.startblock, builder, args_gv)]
more_pending_blocks = []
entrymap = flowmodel.mkentrymap(graph)
entrymap[graph.returnblock] = "force a label"
labels = {graph.returnblock: None}
r = random.Random(random_seed)
while pending_blocks or more_pending_blocks:
if not pending_blocks:
r.shuffle(more_pending_blocks)
pending_blocks = more_pending_blocks
more_pending_blocks = []
block, builder, args_gv = pending_blocks.pop()
builder.start_writing()
# the following loop generates a chain of blocks
# (a branch in the graph)
while True:
assert len(args_gv) == len(block.inputargs)
if len(entrymap[block]) > 1:
# need a label at the start of this block
if block in labels:
# already got one, jump to it
label = labels[block]
if label is not None:
builder.finish_and_goto(args_gv, labels[block])
else:
[retvar] = args_gv
builder.finish_and_return(sigtoken, retvar)
break # done along this branch
else:
# create a label and proceed
kinds = map(varkind, block.inputargs)
labels[block] = builder.enter_next_block(kinds, args_gv)
# generate the operations
varmap = dict(zip(block.inputargs, args_gv))
for op in block.operations:
gv_result = generate_operation(rgenop, builder, op, var2gv)
varmap[op.result] = gv_result
if block.exitswitch is None:
[link] = block.exits
else:
if block.exitswitch.concretetype is not lltype.Bool:
raise NotImplementedError("XXX switches")
i = r.randrange(0, 2)
jumplink = block.exits[i]
args_gv = map(var2gv, jumplink.args)
if jumplink.exitcase:
meth = builder.jump_if_true
else:
meth = builder.jump_if_false
vars_gv = {}
for v in args_gv:
if not v.is_const:
vars_gv[v] = True
newbuilder = meth(varmap[block.exitswitch], vars_gv.keys())
more_pending_blocks.append((jumplink.target,
newbuilder,
args_gv))
link = block.exits[1-i]
args_gv = map(var2gv, link.args)
block = link.target
builder.end()
return gv_entrypoint
def generate_operation(rgenop, builder, op, var2gv):
# XXX only supports some operations for now
if op.opname == 'malloc':
token = rgenop.allocToken(op.args[0].value)
gv_result = builder.genop_malloc_fixedsize(token)
elif op.opname == 'getfield':
token = rgenop.fieldToken(op.args[0].concretetype.TO,
op.args[1].value)
gv_result = builder.genop_getfield(token,
var2gv(op.args[0]))
elif op.opname == 'setfield':
token = rgenop.fieldToken(op.args[0].concretetype.TO,
op.args[1].value)
gv_result = builder.genop_setfield(token,
var2gv(op.args[0]),
var2gv(op.args[2]))
elif op.opname == 'malloc_varsize':
token = rgenop.varsizeAllocToken(op.args[0].value)
gv_result = builder.genop_malloc_varsize(token,
var2gv(op.args[1]))
elif op.opname == 'getarrayitem':
token = rgenop.arrayToken(op.args[0].concretetype.TO)
gv_result = builder.genop_getarrayitem(token,
var2gv(op.args[0]),
var2gv(op.args[1]))
elif op.opname == 'setarrayitem':
token = rgenop.arrayToken(op.args[0].concretetype.TO)
gv_result = builder.genop_setarrayitem(token,
var2gv(op.args[0]),
var2gv(op.args[1]),
var2gv(op.args[2]))
elif op.opname == 'same_as':
token = rgenop.kindToken(op.args[0].concretetype)
gv_result = builder.genop_same_as(token, var2gv(op.args[0]))
elif op.opname == 'ptr_iszero':
token = rgenop.kindToken(op.args[0].concretetype)
gv_result = builder.genop_ptr_iszero(token, var2gv(op.args[0]))
elif op.opname == 'ptr_nonzero':
token = rgenop.kindToken(op.args[0].concretetype)
gv_result = builder.genop_ptr_nonzero(token, var2gv(op.args[0]))
elif op.opname == 'ptr_eq':
token = rgenop.kindToken(op.args[0].concretetype)
gv_result = builder.genop_ptr_eq(token,
var2gv(op.args[0]),
var2gv(op.args[1]))
elif op.opname == 'ptr_ne':
token = rgenop.kindToken(op.args[0].concretetype)
gv_result = builder.genop_ptr_ne(token,
var2gv(op.args[0]),
var2gv(op.args[1]))
elif op.opname == 'cast_int_to_ptr':
token = rgenop.kindToken(op.result.concretetype)
gv_result = builder.genop_cast_int_to_ptr(token,
var2gv(op.args[0]))
elif len(op.args) == 1:
gv_result = builder.genop1(op.opname, var2gv(op.args[0]))
elif len(op.args) == 2:
gv_result = builder.genop2(op.opname, var2gv(op.args[0]),
var2gv(op.args[1]))
else:
raise NotImplementedError(op.opname)
return gv_result
| Python |
"""
Awful code here. Paste your example in "lines". Change headers and
footers if necessary below. The script tries to reduce it by removing
lines matching 'r' and changing lines matching 'rif' to 'if True' or 'if
False'. The smallest failing example found so far gets written to
zsample.py.
"""
import autopath
import os
import re
r = re.compile(r" \w = ")
rif = re.compile(r" if \w:")
SEED = 73595
ITERATIONS = 10
ARGS=[-27, -38, -33, -53, 16, -28, 13, 11, 11, -46, -34, 57, -11, 80, 15, 49, -37, -43, -73, -62, -31, -21, -36, 17, 97, -53]
BACKEND = 'i386'
lines = """
if goto == 0:
u = n != e
k = intmask(v + z)
b = not f
w = intmask(l % ((a & 0xfffff) + 1))
h = a or y
e = intmask(z + z)
m = c != a
a = intmask(v + g)
n = intmask(c - x)
n = intmask(o % ((y & 0xfffff) + 1))
o = -7035
h = m >= a
s = f != g
e = intmask(~w)
if f:
goto = 4
else:
goto = 3
if goto == 1:
n = intmask(h - c)
x = t == b
a = 7744
if g:
goto = 2
else:
goto = 2
if goto == 2:
i = intmask(i - v)
o = -6878346
f = intmask(i ^ n)
i = 1261729270
q = s or u
z = t >= b
u = bool(u)
w = intmask(e << (c & 0x0000067f))
if w:
goto = 13
else:
goto = 14
if goto == 3:
y = intmask(w >> (e & 0x1234567f))
d = intmask(o & j)
r = r != n
a = intmask(b & u)
b = -11216
v = intmask(g // (-((g & 0xfffff) + 2)))
x = 6697939
d = intmask(abs(q))
i = intmask(i % (-((c & 0xfffff) + 2)))
w = 23593
u = n and a
d = intmask(q << (y & 0x0000067f))
o = intmask(w // (-((i & 0xfffff) + 2)))
l = intmask(e + n)
if j:
counter -= 1
if not counter: break
goto = 2
else:
goto = 14
if goto == 4:
f = intmask(e * n)
l = intmask(k >> (e & 0x1234567f))
l = intmask(u // ((p & 0xfffff) + 1))
d = bool(m)
d = 7364461
g = 1410833768
g = y <= d
s = l == d
e = intmask(k - z)
o = -6669177
c = intmask(-o)
q = intmask(-o)
m = intmask(u - j)
q = intmask(a - s)
m = intmask(a | n)
c = q and a
t = intmask(b // (-((p & 0xfffff) + 2)))
if r:
goto = 5
else:
goto = 12
if goto == 5:
c = intmask(i * q)
q = intmask(-q)
c = intmask(a // (-((a & 0xfffff) + 2)))
u = k >= i
m = -34
z = intmask(o - i)
x = x and l
w = o < n
x = n != w
m = 92
h = 27
x = intmask(~u)
i = not o
q = intmask(c & q)
y = x or g
if z:
goto = 10
else:
counter -= 1
if not counter: break
goto = 1
if goto == 6:
u = intmask(l // (-((g & 0xfffff) + 2)))
m = intmask(l // ((h & 0xfffff) + 1))
a = 3949664
c = intmask(v - u)
w = k and r
q = -1898584839
k = a > o
if d:
goto = 7
else:
goto = 8
if goto == 7:
j = not f
s = n == h
t = x > n
z = intmask(e & f)
q = intmask(v + k)
o = not a
v = 2876355
h = intmask(w % ((p & 0xfffff) + 1))
c = e and b
k = intmask(f // (-((u & 0xfffff) + 2)))
m = 4882866
if h:
counter -= 1
if not counter: break
goto = 0
else:
counter -= 1
if not counter: break
goto = 4
if goto == 8:
w = intmask(g & n)
d = -31404
s = intmask(abs(e))
j = intmask(g << (w & 0x0000067f))
r = -26
b = -13356
o = p < m
c = 438000325
t = intmask(~g)
i = intmask(-e)
a = intmask(c - x)
v = intmask(v >> (f & 0x1234567f))
if o:
counter -= 1
if not counter: break
goto = 6
else:
goto = 12
if goto == 9:
l = x <= h
z = not w
f = intmask(u ^ r)
if m:
counter -= 1
if not counter: break
goto = 7
else:
goto = 11
if goto == 10:
o = intmask(t // ((e & 0xfffff) + 1))
w = c == v
if h:
counter -= 1
if not counter: break
goto = 5
else:
counter -= 1
if not counter: break
goto = 3
if goto == 11:
z = i != c
t = d != w
v = intmask(r - f)
u = 6813995
z = c < f
r = intmask(c + i)
z = intmask(o - s)
p = intmask(i // (-((n & 0xfffff) + 2)))
v = intmask(p | h)
if a:
counter -= 1
if not counter: break
goto = 3
else:
counter -= 1
if not counter: break
goto = 0
if goto == 12:
b = intmask(l % ((a & 0xfffff) + 1))
d = intmask(abs(y))
c = intmask(~w)
a = bool(v)
d = not a
v = intmask(s ^ u)
if m:
counter -= 1
if not counter: break
goto = 4
else:
counter -= 1
if not counter: break
goto = 8
if goto == 13:
c = 13780
e = n != i
x = 912031708
i = intmask(p ^ j)
k = not s
p = c > b
o = intmask(~j)
t = intmask(-k)
v = y <= v
v = m <= a
w = a < u
z = p == v
if g:
counter -= 1
if not counter: break
goto = 7
else:
counter -= 1
if not counter: break
goto = 13
if goto == 14:
if p:
counter -= 1
if not counter: break
goto = 8
else:
counter -= 1
if not counter: break
goto = 13
""".splitlines()
lines = [s.rstrip() for s in lines]
lines = [s for s in lines if s]
def accept(lines):
g = open('zgen.py', 'w')
print >> g, '''from pypy.rlib.rarithmetic import intmask
def dummyfn(counter, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z):
goto = 0
while True:
'''
for line in lines:
print >> g, line
print >> g, '''
return intmask(a*-468864544+b*-340864157+c*-212863774+d*-84863387+e*43136996+f*171137383+g*299137766+h*427138153+i*555138536+j*683138923+k*811139306+l*939139693+m*1067140076+n*1195140463+o*1323140846+p*1451141233+q*1579141616+r*1707142003+s*1835142386+t*1963142773+u*2091143156+v*-2075823753+w*-1947823370+x*-1819822983+y*-1691822600+z*-1563822213)
'''
g.close()
#ok = os.system("py.test zgen.py --seed=6661 -s") == 0
from pypy.jit.codegen.demo import conftest as demo_conftest
demo_conftest.option.randomseed = SEED
demo_conftest.option.backend = BACKEND
from pypy.jit.codegen.demo.support import rundemo
d = {}
execfile('zgen.py', d)
dummyfn = d['dummyfn']
childpid = os.fork()
if childpid == 0: # in child
rundemo(dummyfn, ITERATIONS, *ARGS)
os._exit(0)
_, status = os.waitpid(childpid, 0)
ok = status == 0
if ok:
return True # accept
else:
os.system("cp -f zgen.py zsample.py")
global progress
progress = True
globals()['lines'][:] = lines
return False
assert not accept(lines)
progress = True
while progress:
progress = False
i = 0
while i < len(lines):
lines1 = lines[:]
if r.match(lines[i]):
del lines1[i]
if not accept(lines1):
continue
elif rif.match(lines[i]):
# try if 1: / if 0:
lines1[i] = " if True:"
if not accept(lines1):
continue
lines1[i] = " if False:"
if not accept(lines1):
continue
i += 1
print
print
print
print
print '\n'.join(lines)
#import pdb; pdb.set_trace()
| Python |
import random
from pypy.jit.codegen.demo import test_random
from pypy.jit.codegen.demo import conftest as demo_conftest
# each iteration of test_many_times leaks memory, so we can't run
# it forever. If you want that result, use a bash command like:
#
# while py.test autorun.py --pdb; do echo "again"; done
def test_many_times():
for i in range(80):
yield run_test_once, random.randrange(0, 100000)
def run_test_once(seed):
demo_conftest.option.randomseed = seed
test_random.test_random_function()
| Python |
import py, random
from pypy.jit.codegen.ppc import conftest
Option = py.test.config.Option
option = py.test.config.addoptions("demo options",
Option('--seed', action="store", type="int",
default=random.randrange(0, 10000),
dest="randomseed",
help="choose a fixed random seed"),
Option('--backend', action="store",
default='llgraph',
choices=['llgraph', 'dump', 'ppc', 'i386', 'llvm', 'ppcfew'],
dest="backend",
help="select the backend to run the functions with"),
Option('--nb-blocks', action="store", type="int",
default=15,
dest="nb_blocks",
help="how many blocks to include in the random function"),
Option('--max-block-length', action="store", type="int",
default=20,
dest="max_block_length",
help="insert up to this many operations in each block"),
Option('--n-vars', action="store", type="int",
default=26,
dest="n_vars",
help="supply this many randomly-valued arguments to the function"),
Option('--iterations', action="store", type="int",
default=0,
dest="iterations",
help="run the loop of the generated function this many times - "
"the default is backend dependent"),
)
very_slow_backends = {'llgraph': True,
'dump': True}
| Python |
"""
self cloning, automatic path configuration
copy this into any subdirectory of pypy from which scripts need
to be run, typically all of the test subdirs.
The idea is that any such script simply issues
import autopath
and this will make sure that the parent directory containing "pypy"
is in sys.path.
If you modify the master "autopath.py" version (in pypy/tool/autopath.py)
you can directly run it which will copy itself on all autopath.py files
it finds under the pypy root directory.
This module always provides these attributes:
pypydir pypy root directory path
this_dir directory where this autopath.py resides
"""
def __dirinfo(part):
""" return (partdir, this_dir) and insert parent of partdir
into sys.path. If the parent directories don't have the part
an EnvironmentError is raised."""
import sys, os
try:
head = this_dir = os.path.realpath(os.path.dirname(__file__))
except NameError:
head = this_dir = os.path.realpath(os.path.dirname(sys.argv[0]))
while head:
partdir = head
head, tail = os.path.split(head)
if tail == part:
break
else:
raise EnvironmentError, "'%s' missing in '%r'" % (partdir, this_dir)
pypy_root = os.path.join(head, '')
try:
sys.path.remove(head)
except ValueError:
pass
sys.path.insert(0, head)
munged = {}
for name, mod in sys.modules.items():
if '.' in name:
continue
fn = getattr(mod, '__file__', None)
if not isinstance(fn, str):
continue
newname = os.path.splitext(os.path.basename(fn))[0]
if not newname.startswith(part + '.'):
continue
path = os.path.join(os.path.dirname(os.path.realpath(fn)), '')
if path.startswith(pypy_root) and newname != part:
modpaths = os.path.normpath(path[len(pypy_root):]).split(os.sep)
if newname != '__init__':
modpaths.append(newname)
modpath = '.'.join(modpaths)
if modpath not in sys.modules:
munged[modpath] = mod
for name, mod in munged.iteritems():
if name not in sys.modules:
sys.modules[name] = mod
if '.' in name:
prename = name[:name.rfind('.')]
postname = name[len(prename)+1:]
if prename not in sys.modules:
__import__(prename)
if not hasattr(sys.modules[prename], postname):
setattr(sys.modules[prename], postname, mod)
return partdir, this_dir
def __clone():
""" clone master version of autopath.py into all subdirs """
from os.path import join, walk
if not this_dir.endswith(join('pypy','tool')):
raise EnvironmentError("can only clone master version "
"'%s'" % join(pypydir, 'tool',_myname))
def sync_walker(arg, dirname, fnames):
if _myname in fnames:
fn = join(dirname, _myname)
f = open(fn, 'rwb+')
try:
if f.read() == arg:
print "checkok", fn
else:
print "syncing", fn
f = open(fn, 'w')
f.write(arg)
finally:
f.close()
s = open(join(pypydir, 'tool', _myname), 'rb').read()
walk(pypydir, sync_walker, s)
_myname = 'autopath.py'
# set guaranteed attributes
pypydir, this_dir = __dirinfo('pypy')
if __name__ == '__main__':
__clone()
| Python |
from pypy.jit.codegen.demo import test_random
from pypy.jit.codegen.demo import conftest as demo_conftest
def rerun(seed, *args):
prevseed = demo_conftest.option.randomseed
try:
demo_conftest.option.randomseed = seed
test_random.test_random_function(*args)
finally:
demo_conftest.option.randomseed = prevseed
# ____________________________________________________________
# These are tests that failed at some point on intel. Run
# them all with py.test rerun_failures.py.
def test_4327406(): rerun(4327406)
def test_9473(): rerun(9473)
def test_3888(): rerun(3888)
def test_2307(): rerun(2307)
def test_9792(): rerun(9792)
def test_37(): rerun(37)
def test_2871_1_100(): rerun(2871, 1, 100)
def test_6294(): rerun(6294)
# here's a ppcfew failure or two:
def test_39263(): rerun(39263)
def test_33851(): rerun(33851)
def test_20202(): rerun(20202)
| Python |
import os, sys
import py
from pypy.tool.udir import udir
from pypy.rlib.ros import putenv
from pypy.jit.codegen.graph2rgenop import rcompile
from pypy.rpython.lltypesystem import lltype
from pypy import conftest
from pypy.jit import conftest as bench_conftest
from pypy.jit.codegen.demo import conftest as demo_conftest
from pypy.jit.codegen import conftest as codegen_conftest
machine_code_dumper = None
run_in_subprocess = False
if demo_conftest.option.backend == 'llgraph':
from pypy.jit.codegen.llgraph.rgenop import RGenOp
elif demo_conftest.option.backend == 'dump':
from pypy.jit.codegen.dump.rgenop import RDumpGenOp as RGenOp
elif demo_conftest.option.backend == 'i386':
from pypy.jit.codegen.i386.rgenop import RI386GenOp as RGenOp
from pypy.jit.codegen.i386.codebuf import machine_code_dumper
run_in_subprocess = True
elif demo_conftest.option.backend == 'ppc':
from pypy.jit.codegen.ppc.rgenop import RPPCGenOp as RGenOp
run_in_subprocess = True
elif demo_conftest.option.backend == 'ppcfew':
from pypy.jit.codegen.ppc.test.test_rgenop import FewRegisters as RGenOp
run_in_subprocess = True
elif demo_conftest.option.backend == 'llvm':
from pypy.jit.codegen.llvm.rgenop import RLLVMGenOp as RGenOp
else:
assert 0, "unknown backend %r"%demo_conftest.option.backend
if codegen_conftest.option.trap:
run_in_subprocess = False
def Random():
import random
seed = demo_conftest.option.randomseed
print
print 'Random seed value is %d.' % (seed,)
print
return random.Random(seed)
if run_in_subprocess:
def runfp(fp, *args):
import signal, os
sigs = dict([(value, name) for name, value in signal.__dict__.items()
if name.startswith('SIG')])
p2cread, p2cwrite = os.pipe()
pid = os.fork()
if not pid:
signal.alarm(3)
res = fp(*args)
os.write(p2cwrite, str(res) + "\n")
os.close(p2cwrite)
os._exit(0)
else:
_, status = os.waitpid(pid, 0)
if status == 0:
res = os.read(p2cread, 10000)
return int(res)
else:
signalled = os.WIFSIGNALED(status)
if signalled:
sig = os.WTERMSIG(status)
if sig == signal.SIGALRM:
return "HUNG?"
else:
return "CRASHED (caught %s)"%(sigs.get(sig, sig),)
else:
def runfp(fp, *args):
return fp(*args)
def rundemo(entrypoint, *args):
view = conftest.option.view
seed = demo_conftest.option.randomseed
benchmark = bench_conftest.option.benchmark
logfile = str(udir.join('%s.log' % (entrypoint.__name__,)))
try:
os.unlink(logfile)
except OSError:
pass
putenv('PYPYJITLOG=' + logfile)
if benchmark:
py.test.skip("benchmarking: working in progress")
arglist = ', '.join(['a%d' % i for i in range(len(args))])
miniglobals = {'Benchmark': bench_conftest.Benchmark,
'original_entrypoint': entrypoint}
exec py.code.Source("""
def benchmark_runner(%s):
bench = Benchmark()
while 1:
res = original_entrypoint(%s)
if bench.stop():
break
return res
""" % (arglist, arglist)).compile() in miniglobals
entrypoint = miniglobals['benchmark_runner']
nb_args = len(args) # XXX ints only for now
if machine_code_dumper:
machine_code_dumper._freeze_() # clean up state
rgenop = RGenOp()
gv_entrypoint = rcompile(rgenop, entrypoint, [int]*nb_args,
random_seed=seed)
if machine_code_dumper:
machine_code_dumper._freeze_() # clean up state
print
print 'Random seed value: %d' % (seed,)
print
print 'Running %s(%s)...' % (entrypoint.__name__,
', '.join(map(repr, args)))
expected = entrypoint(*args)
print 'Python ===>', expected
F1 = lltype.FuncType([lltype.Signed] * nb_args, lltype.Signed)
fp = RGenOp.get_python_callable(lltype.Ptr(F1), gv_entrypoint)
res = runfp(fp, *args)
print '%-6s ===>' % RGenOp.__name__, res
print
if res != expected:
raise AssertionError(
"expected return value is %s, got %s\nseed = %s" % (
expected, res, seed))
if view and machine_code_dumper:
from pypy.jit.codegen.i386.viewcode import World
world = World()
world.parse(open(logfile))
world.show()
| Python |
import random, sys
from pypy.rpython.annlowlevel import MixLevelAnnotatorPolicy, llhelper
from pypy.rlib.rarithmetic import intmask, r_uint
from pypy.rlib.objectmodel import keepalive_until_here
from pypy.rpython.lltypesystem import lltype, llmemory
from pypy.translator.c.test import test_boehm
from ctypes import c_void_p, cast, CFUNCTYPE, c_int
class PseudoAnnhelper(object):
rtyper = None
GENOP_POLICY = MixLevelAnnotatorPolicy(PseudoAnnhelper())
FUNC = lltype.FuncType([lltype.Signed], lltype.Signed)
FUNC2 = lltype.FuncType([lltype.Signed]*2, lltype.Signed)
FUNC3 = lltype.FuncType([lltype.Signed]*3, lltype.Signed)
FUNC5 = lltype.FuncType([lltype.Signed]*5, lltype.Signed)
FUNC27= lltype.FuncType([lltype.Signed]*27, lltype.Signed)
def make_adder(rgenop, n):
# 'return x+n'
sigtoken = rgenop.sigToken(FUNC)
builder, gv_add_one, [gv_x] = rgenop.newgraph(sigtoken, "adder")
builder.start_writing()
gv_result = builder.genop2("int_add", gv_x, rgenop.genconst(n))
builder.finish_and_return(sigtoken, gv_result)
builder.end()
return gv_add_one
def get_adder_runner(RGenOp):
def runner(x, y):
rgenop = RGenOp()
gv_add_x = make_adder(rgenop, x)
add_x = gv_add_x.revealconst(lltype.Ptr(FUNC))
res = add_x(y)
keepalive_until_here(rgenop) # to keep the code blocks alive
return res
return runner
def make_dummy(rgenop):
# 'return x - (y - (x-1))'
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC2)
builder, gv_dummyfn, [gv_x, gv_y] = rgenop.newgraph(sigtoken, "dummy")
builder.start_writing()
gv_z = builder.genop2("int_sub", gv_x, rgenop.genconst(1))
args_gv = [gv_y, gv_z, gv_x]
builder.enter_next_block([signed_kind, signed_kind, signed_kind], args_gv)
[gv_y2, gv_z2, gv_x2] = args_gv
gv_s2 = builder.genop2("int_sub", gv_y2, gv_z2)
gv_t2 = builder.genop2("int_sub", gv_x2, gv_s2)
builder.finish_and_return(sigtoken, gv_t2)
builder.end()
return gv_dummyfn
def get_dummy_runner(RGenOp):
def dummy_runner(x, y):
rgenop = RGenOp()
gv_dummyfn = make_dummy(rgenop)
dummyfn = gv_dummyfn.revealconst(lltype.Ptr(FUNC2))
res = dummyfn(x, y)
keepalive_until_here(rgenop) # to keep the code blocks alive
return res
return dummy_runner
FUNC100 = lltype.FuncType([lltype.Signed]*100, lltype.Signed)
def largedummy_example():
args = [random.randrange(-10, 50) for i in range(100)]
total = 0
for i in range(0, 100, 2):
total += args[i] - args[i+1]
return args, total
def make_largedummy(rgenop):
# 'return v0-v1+v2-v3+v4-v5...+v98-v99'
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC100)
builder, gv_largedummyfn, gvs = rgenop.newgraph(sigtoken, "largedummy")
builder.start_writing()
for i in range(0, 100, 2):
gvs.append(builder.genop2("int_sub", gvs[i], gvs[i+1]))
builder.enter_next_block([signed_kind] * 150, gvs)
while len(gvs) > 101:
gv_sum = builder.genop2("int_add", gvs.pop(), gvs.pop())
gvs.append(gv_sum)
builder.finish_and_return(sigtoken, gvs.pop())
builder.end()
return gv_largedummyfn
def get_largedummy_runner(RGenOp):
def largedummy_runner(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9,
v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
v20, v21, v22, v23, v24, v25, v26, v27, v28, v29,
v30, v31, v32, v33, v34, v35, v36, v37, v38, v39,
v40, v41, v42, v43, v44, v45, v46, v47, v48, v49,
v50, v51, v52, v53, v54, v55, v56, v57, v58, v59,
v60, v61, v62, v63, v64, v65, v66, v67, v68, v69,
v70, v71, v72, v73, v74, v75, v76, v77, v78, v79,
v80, v81, v82, v83, v84, v85, v86, v87, v88, v89,
v90, v91, v92, v93, v94, v95, v96, v97, v98, v99):
rgenop = RGenOp()
gv_largedummyfn = make_largedummy(rgenop)
largedummyfn = gv_largedummyfn.revealconst(lltype.Ptr(FUNC100))
res = largedummyfn(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9,
v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
v20, v21, v22, v23, v24, v25, v26, v27, v28, v29,
v30, v31, v32, v33, v34, v35, v36, v37, v38, v39,
v40, v41, v42, v43, v44, v45, v46, v47, v48, v49,
v50, v51, v52, v53, v54, v55, v56, v57, v58, v59,
v60, v61, v62, v63, v64, v65, v66, v67, v68, v69,
v70, v71, v72, v73, v74, v75, v76, v77, v78, v79,
v80, v81, v82, v83, v84, v85, v86, v87, v88, v89,
v90, v91, v92, v93, v94, v95, v96, v97, v98, v99)
keepalive_until_here(rgenop) # to keep the code blocks alive
return res
return largedummy_runner
def make_branching(rgenop):
# 'if x > 5: return x-1
# else: return y'
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC2)
builder, gv_branchingfn, [gv_x, gv_y] = rgenop.newgraph(sigtoken,
"branching")
builder.start_writing()
gv_cond = builder.genop2("int_gt", gv_x, rgenop.genconst(5))
false_builder = builder.jump_if_false(gv_cond, [gv_y])
# true path
args_gv = [rgenop.genconst(1), gv_x, gv_y]
builder.enter_next_block([signed_kind, signed_kind, signed_kind], args_gv)
[gv_one, gv_x2, gv_y2] = args_gv
gv_s2 = builder.genop2("int_sub", gv_x2, gv_one)
builder.finish_and_return(sigtoken, gv_s2)
# false path
false_builder.start_writing()
false_builder.finish_and_return(sigtoken, gv_y)
# done
builder.end()
return gv_branchingfn
def get_branching_runner(RGenOp):
def branching_runner(x, y):
rgenop = RGenOp()
gv_branchingfn = make_branching(rgenop)
branchingfn = gv_branchingfn.revealconst(lltype.Ptr(FUNC2))
res = branchingfn(x, y)
keepalive_until_here(rgenop) # to keep the code blocks alive
return res
return branching_runner
# loop start block
def loop_start(rgenop, builder, signed_kind, gv_x, gv_y):
args_gv = [gv_x, gv_y, rgenop.genconst(1)]
loopblock = builder.enter_next_block(
[signed_kind, signed_kind, signed_kind], args_gv)
[gv_x, gv_y, gv_z] = args_gv
gv_cond = builder.genop2("int_gt", gv_x, rgenop.genconst(0))
bodybuilder = builder.jump_if_true(gv_cond, args_gv)
return args_gv, loopblock, bodybuilder
# loop exit
def loop_exit(builder, sigtoken, signed_kind, gv_y, gv_z):
args_gv = [gv_y, gv_z]
builder.enter_next_block(
[signed_kind, signed_kind], args_gv)
[gv_y, gv_z] = args_gv
gv_y3 = builder.genop2("int_add", gv_y, gv_z)
builder.finish_and_return(sigtoken, gv_y3)
# loop body
def loop_body(rgenop, loopblock, bodybuilder, signed_kind, gv_x, gv_y, gv_z):
bodybuilder.start_writing()
gv_z2 = bodybuilder.genop2("int_mul", gv_x, gv_z)
gv_y2 = bodybuilder.genop2("int_add", gv_x, gv_y)
gv_x2 = bodybuilder.genop2("int_sub", gv_x, rgenop.genconst(1))
bodybuilder.finish_and_goto([gv_x2, gv_y2, gv_z2], loopblock)
def make_goto(rgenop):
# z = 1
# while x > 0:
# z = x * z
# y = x + y
# x = x - 1
# y += z
# return y
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC2)
builder, gv_gotofn, [gv_x, gv_y] = rgenop.newgraph(sigtoken, "goto")
builder.start_writing()
[gv_x, gv_y, gv_z],loopblock,bodybuilder = loop_start(
rgenop, builder, signed_kind, gv_x, gv_y)
loop_exit(
builder, sigtoken, signed_kind, gv_y, gv_z)
loop_body(
rgenop, loopblock, bodybuilder, signed_kind, gv_x, gv_y, gv_z)
# done
builder.end()
return gv_gotofn
def get_goto_runner(RGenOp):
def goto_runner(x, y):
rgenop = RGenOp()
gv_gotofn = make_goto(rgenop)
gotofn = gv_gotofn.revealconst(lltype.Ptr(FUNC2))
res = gotofn(x, y)
keepalive_until_here(rgenop) # to keep the code blocks alive
return res
return goto_runner
def make_if(rgenop):
# a = x
# if x > 5:
# x //= 2
# return x + a
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC2)
builder, gv_gotofn, [gv_x1, gv_unused] = rgenop.newgraph(sigtoken, "if")
builder.start_writing()
# check
args_gv = [gv_x1, gv_unused]
builder.enter_next_block([signed_kind, signed_kind], args_gv)
[gv_x1, gv_unused] = args_gv
gv_cond = builder.genop2("int_gt", gv_x1, rgenop.genconst(5))
elsebuilder = builder.jump_if_false(gv_cond, [gv_x1])
# 'then' block
gv_x2 = builder.genop2("int_floordiv", gv_x1, rgenop.genconst(2))
# end block
args_gv = [gv_x2, gv_x1]
label = builder.enter_next_block([signed_kind, signed_kind], args_gv)
[gv_x2, gv_a] = args_gv
gv_res = builder.genop2("int_add", gv_x2, gv_a)
builder.finish_and_return(sigtoken, gv_res)
# now the else branch
elsebuilder.start_writing()
elsebuilder.finish_and_goto([gv_x1, gv_x1], label)
# done
builder.end()
return gv_gotofn
def get_if_runner(RGenOp):
def if_runner(x, y):
rgenop = RGenOp()
gv_iffn = make_if(rgenop)
iffn = gv_iffn.revealconst(lltype.Ptr(FUNC2))
res = iffn(x, y)
keepalive_until_here(rgenop) # to keep the code blocks alive
return res
return if_runner
def make_switch(rgenop):
"""
def f(v0, v1):
if v0 == 0: # switch
return 21*v1
elif v0 == 1:
return 21+v1
else:
return v1
"""
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC2)
builder, gv_switch, [gv0, gv1] = rgenop.newgraph(sigtoken, "switch")
builder.start_writing()
flexswitch, default_builder = builder.flexswitch(gv0, [gv1])
const21 = rgenop.genconst(21)
# default
default_builder.finish_and_return(sigtoken, gv1)
# case == 0
const0 = rgenop.genconst(0)
case_builder = flexswitch.add_case(const0)
gv_res_case0 = case_builder.genop2('int_mul', const21, gv1)
case_builder.finish_and_return(sigtoken, gv_res_case0)
# case == 1
const1 = rgenop.genconst(1)
case_builder = flexswitch.add_case(const1)
gv_res_case1 = case_builder.genop2('int_add', const21, gv1)
case_builder.finish_and_return(sigtoken, gv_res_case1)
builder.end()
return gv_switch
def get_switch_runner(RGenOp):
def switch_runner(x, y):
rgenop = RGenOp()
gv_switchfn = make_switch(rgenop)
switchfn = gv_switchfn.revealconst(lltype.Ptr(FUNC2))
res = switchfn(x, y)
keepalive_until_here(rgenop) # to keep the code blocks alive
return res
return switch_runner
def make_large_switch(rgenop):
"""
def f(v0, v1):
if v0 == 0: # switch
return 21*v1
elif v0 == 1:
return 2+v1
elif v0 == 2:
return 4+v1
...
elif v0 == 10:
return 2**10+v1
else:
return v1
"""
signed_tok = rgenop.kindToken(lltype.Signed)
f2_token = rgenop.sigToken(FUNC2)
builder, gv_switch, (gv0, gv1) = rgenop.newgraph(f2_token, "large_switch")
builder.start_writing()
flexswitch, default_builder = builder.flexswitch(gv0, [gv1])
const21 = rgenop.genconst(21)
# default
default_builder.finish_and_return(f2_token, gv1)
# case == 0
const0 = rgenop.genconst(0)
case_builder = flexswitch.add_case(const0)
gv_res_case0 = case_builder.genop2('int_mul', const21, gv1)
case_builder.finish_and_return(f2_token, gv_res_case0)
# case == x
for x in range(1,11):
constx = rgenop.genconst(x)
case_builder = flexswitch.add_case(constx)
const2px = rgenop.genconst(1<<x)
gv_res_casex = case_builder.genop2('int_add', const2px, gv1)
case_builder.finish_and_return(f2_token, gv_res_casex)
builder.end()
return gv_switch
def get_large_switch_runner(RGenOp):
def large_switch_runner(x, y):
rgenop = RGenOp()
gv_large_switchfn = make_large_switch(rgenop)
largeswitchfn = gv_large_switchfn.revealconst(lltype.Ptr(FUNC2))
res = largeswitchfn(x, y)
keepalive_until_here(rgenop) # to keep the code blocks alive
return res
return large_switch_runner
def make_fact(rgenop):
# def fact(x):
# if x:
# y = x-1
# z = fact(y)
# w = x*z
# return w
# return 1
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC)
builder, gv_fact, [gv_x] = rgenop.newgraph(sigtoken, "fact")
builder.start_writing()
gv_cond = builder.genop1("int_is_true", gv_x)
true_builder = builder.jump_if_true(gv_cond, [gv_x])
builder.enter_next_block([], [])
builder.finish_and_return(sigtoken, rgenop.genconst(1))
true_builder.start_writing()
gv_y = true_builder.genop2("int_sub", gv_x, rgenop.genconst(1))
gv_z = true_builder.genop_call(sigtoken, gv_fact, [gv_y])
gv_w = true_builder.genop2("int_mul", gv_x, gv_z)
true_builder.finish_and_return(sigtoken, gv_w)
builder.end()
return gv_fact
def get_fact_runner(RGenOp):
def fact_runner(x):
rgenop = RGenOp()
gv_large_switchfn = make_fact(rgenop)
largeswitchfn = gv_large_switchfn.revealconst(lltype.Ptr(FUNC))
res = largeswitchfn(x)
keepalive_until_here(rgenop) # to keep the code blocks alive
return res
return fact_runner
def make_func_calling_pause(rgenop):
# def f(x):
# if x > 0:
# return x
# else:
# return -x
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC)
builder, gv_f, [gv_x] = rgenop.newgraph(sigtoken, "abs")
builder.start_writing()
gv_cond = builder.genop2("int_gt", gv_x, rgenop.genconst(0))
# this also tests duplicates in the lists of live vars
targetbuilder = builder.jump_if_false(gv_cond, [gv_x, gv_x])
builder = builder.pause_writing([gv_x, gv_x, gv_x])
targetbuilder.start_writing()
gv_negated = targetbuilder.genop1("int_neg", gv_x)
targetbuilder.finish_and_return(sigtoken, gv_negated)
builder.start_writing()
builder.finish_and_return(sigtoken, gv_x)
builder.end()
return gv_f
def get_func_calling_pause_runner(RGenOp):
def runner(x):
rgenop = RGenOp()
gv_abs = make_func_calling_pause(rgenop)
myabs = gv_abs.revealconst(lltype.Ptr(FUNC))
res = myabs(x)
keepalive_until_here(rgenop) # to keep the code blocks alive
return res
return runner
def make_longwinded_and(rgenop):
# def f(y): return 2 <= y <= 4
# but more like this:
# def f(y)
# x = 2 <= y
# if x:
# x = y <= 4
# if x:
# return 1
# else:
# return 0
bool_kind = rgenop.kindToken(lltype.Bool)
sigtoken = rgenop.sigToken(FUNC)
builder, gv_f, [gv_y] = rgenop.newgraph(sigtoken, "abs")
builder.start_writing()
gv_x = builder.genop2("int_le", rgenop.genconst(2), gv_y)
false_builder = builder.jump_if_false(gv_x, [gv_x])
gv_x2 = builder.genop2("int_le", gv_y, rgenop.genconst(4))
args_gv = [gv_x2]
label = builder.enter_next_block([bool_kind], args_gv)
[gv_x2] = args_gv
return_false_builder = builder.jump_if_false(gv_x2, [])
builder.finish_and_return(sigtoken, rgenop.genconst(1))
false_builder.start_writing()
false_builder.finish_and_goto([gv_x], label)
return_false_builder.start_writing()
return_false_builder.finish_and_return(sigtoken, rgenop.genconst(0))
builder.end()
return gv_f
def make_condition_result_cross_link(rgenop):
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC)
builder, gv_f, [gv_y] = rgenop.newgraph(sigtoken, "foo")
builder.start_writing()
gv_result = builder.genop2("int_eq", gv_y, rgenop.genconst(0))
target1 = builder.jump_if_false(gv_result, [gv_result])
builder.finish_and_return(sigtoken, rgenop.genconst(1))
target1.start_writing()
target2 = target1.jump_if_false(gv_result, [])
# this return should be unreachable:
target1.finish_and_return(sigtoken, rgenop.genconst(2))
target2.start_writing()
target2.finish_and_return(sigtoken, rgenop.genconst(3))
builder.end()
return gv_f
def make_pause_and_resume(rgenop):
# def f(x):
# y = x + 1
# # pause/resume here
# z = x - 1
# w = y*z
# return w
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC)
builder, gv_callable, [gv_x] = rgenop.newgraph(sigtoken, "f")
builder.start_writing()
gv_one = rgenop.genconst(1)
gv_y = builder.genop2("int_add", gv_x, gv_one)
builder = builder.pause_writing([gv_x, gv_y])
builder.start_writing()
gv_z = builder.genop2("int_sub", gv_x, gv_one)
gv_w = builder.genop2("int_mul", gv_y, gv_z)
builder.finish_and_return(sigtoken, gv_w)
builder.end()
return gv_callable
def get_pause_and_resume_runner(RGenOp):
def runner(x):
rgenop = RGenOp()
gv_f = make_pause_and_resume(rgenop)
f = gv_f.revealconst(lltype.Ptr(FUNC))
res = f(x)
keepalive_until_here(rgenop) # to keep the code blocks alive
return res
return runner
def make_something_a_bit_like_residual_red_call_with_exc(rgenop):
# def f(x, y):
# if x:
# z = 1
# w = 2
# else:
# z = y+1
# w = y
# return add1(z*w)
# but more obfuscated, more like:
# def f(x, y)
# c = x != 0
# jump_if_true c, [] ---> finish_and_goto([1, 2])
# y = add1(y) |
# [z, w] = enter_next_block([y, x]) <----'
# pause/resume here
# z2 = z * w
# u = add1(z2)
# v = u * z
# return add1(u)
gv_add1 = make_adder(rgenop, 1)
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC2)
builder, gv_f, [gv_x, gv_y] = rgenop.newgraph(sigtoken, "f")
builder.start_writing()
gv_c = builder.genop2("int_ne", gv_x, rgenop.genconst(0))
true_builder = builder.jump_if_true(gv_c, [])
gv_y2 = builder.genop_call(rgenop.sigToken(FUNC), gv_add1, [gv_y])
args_gv = [gv_y2, gv_y]
label = builder.enter_next_block([signed_kind, signed_kind], args_gv)
[gv_z, gv_w] = args_gv
builder = builder.pause_writing(args_gv)
builder.start_writing()
gv_z2 = builder.genop2("int_mul", gv_z, gv_w)
gv_u = builder.genop_call(rgenop.sigToken(FUNC), gv_add1, [gv_z2])
gv_v = builder.genop2("int_mul", gv_u, gv_z)
gv_result = builder.genop_call(rgenop.sigToken(FUNC), gv_add1, [gv_u])
builder.finish_and_return(sigtoken, gv_result)
true_builder.start_writing()
true_builder.finish_and_goto([rgenop.genconst(1), rgenop.genconst(2)], label)
builder.end()
return gv_f
def make_call_functions_with_different_signatures(rgenop):
# this also tests calling functions with enormous numbers of
# parameters, something not tested yet.
# def f(x, y):
# z = largedummy(*((y,)*100))
# w = add1(x)
# return z+w
gv_largedummy = make_largedummy(rgenop)
gv_add1 = make_adder(rgenop, 1)
sig2token = rgenop.sigToken(FUNC2)
sig1token = rgenop.sigToken(FUNC)
sig100token = rgenop.sigToken(FUNC100)
builder, gv_callable, [gv_x, gv_y] = rgenop.newgraph(sig2token, "f")
builder.start_writing()
gv_z = builder.genop_call(sig100token, gv_largedummy, [gv_y]*100)
gv_w = builder.genop_call(sig1token, gv_add1, [gv_x])
gv_result = builder.genop2("int_add", gv_z, gv_w)
builder.finish_and_return(sig2token, gv_result)
builder.end()
return gv_callable
class FrameVarReader:
FUNC = lltype.Ptr(lltype.FuncType([llmemory.Address], lltype.Signed))
def __init__(self, RGenOp):
def reader(base):
return RGenOp.read_frame_var(lltype.Signed, base,
self.frameinfo, 0)
self.reader = reader
def get_reader(self, info):
self.frameinfo = info
return llhelper(self.FUNC, self.reader)
def make_read_frame_var(rgenop, get_reader):
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC)
readertoken = rgenop.sigToken(FrameVarReader.FUNC.TO)
builder, gv_f, [gv_x] = rgenop.newgraph(sigtoken, "f")
builder.start_writing()
gv_y = builder.genop2("int_mul", gv_x, rgenop.genconst(2))
gv_base = builder.genop_get_frame_base()
info = builder.get_frame_info([gv_y])
gv_reader = rgenop.constPrebuiltGlobal(get_reader(info))
gv_z = builder.genop_call(readertoken, gv_reader, [gv_base])
args_gv = [gv_y, gv_z]
builder.enter_next_block([signed_kind]*2, args_gv)
[gv_y, gv_z] = args_gv
builder.finish_and_return(sigtoken, gv_z)
builder.end()
return gv_f
def get_read_frame_var_runner(RGenOp):
fvr = FrameVarReader(RGenOp)
def read_frame_var_runner(x):
rgenop = RGenOp()
gv_f = make_read_frame_var(rgenop, fvr.get_reader)
fn = gv_f.revealconst(lltype.Ptr(FUNC))
res = fn(x)
keepalive_until_here(rgenop) # to keep the code blocks alive
return res
return read_frame_var_runner
class FramePlaceWriter:
FUNC = lltype.Ptr(lltype.FuncType([llmemory.Address, lltype.Signed],
lltype.Void))
def __init__(self, RGenOp):
def writer(base, value):
if value > 5:
RGenOp.write_frame_place(lltype.Signed, base,
self.place1, value * 7)
RGenOp.write_frame_place(lltype.Signed, base,
self.place2, value * 10)
self.writer = writer
def get_writer(self, place1, place2):
self.place1 = place1
self.place2 = place2
return llhelper(self.FUNC, self.writer)
def make_write_frame_place(rgenop, get_writer):
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC)
writertoken = rgenop.sigToken(FramePlaceWriter.FUNC.TO)
builder, gv_f, [gv_x] = rgenop.newgraph(sigtoken, "f")
builder.start_writing()
gv_base = builder.genop_get_frame_base()
gv_k = rgenop.genconst(-100)
place1 = builder.alloc_frame_place(signed_kind, gv_initial_value=gv_k)
place2 = builder.alloc_frame_place(signed_kind)
gv_writer = rgenop.constPrebuiltGlobal(get_writer(place1, place2))
builder.genop_call(writertoken, gv_writer, [gv_base, gv_x])
gv_y = builder.genop_absorb_place(signed_kind, place1)
gv_z = builder.genop_absorb_place(signed_kind, place2)
gv_diff = builder.genop2("int_sub", gv_y, gv_z)
builder.finish_and_return(sigtoken, gv_diff)
builder.end()
return gv_f
def get_write_frame_place_runner(RGenOp):
fvw = FramePlaceWriter(RGenOp)
def write_frame_place_runner(x):
rgenop = RGenOp()
gv_f = make_write_frame_place(rgenop, fvw.get_writer)
fn = gv_f.revealconst(lltype.Ptr(FUNC))
res = fn(x)
keepalive_until_here(rgenop) # to keep the code blocks alive
return res
return write_frame_place_runner
class ManyFramePlaceWriter:
FUNC = lltype.Ptr(lltype.FuncType([llmemory.Address, lltype.Signed],
lltype.Void))
def __init__(self, RGenOp):
def writer(base, value):
i = 0
places = self.places
n = len(places)
while i < n:
p = places[i]
RGenOp.write_frame_place(lltype.Signed, base, p, value + i)
i += 1
self.writer = writer
def get_writer(self, places):
self.places = places
return llhelper(self.FUNC, self.writer)
def make_write_lots_of_frame_places(rgenop, get_writer):
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC)
writertoken = rgenop.sigToken(FramePlaceWriter.FUNC.TO)
builder, gv_f, [gv_x] = rgenop.newgraph(sigtoken, "f")
builder.start_writing()
gv_base = builder.genop_get_frame_base()
gv_sources = [builder.genop2('int_add', gv_x, rgenop.genconst(i)) for i in range(100)]
places = [builder.alloc_frame_place(signed_kind, gv_s) for gv_s in gv_sources]
gv_writer = rgenop.constPrebuiltGlobal(get_writer(places))
builder.genop_call(writertoken, gv_writer, [gv_base, gv_x])
gv_sum = rgenop.genconst(0)
for p in places:
gv_i = builder.genop_absorb_place(signed_kind, p)
gv_sum = builder.genop2("int_add", gv_sum, gv_i)
builder.finish_and_return(sigtoken, gv_sum)
builder.end()
return gv_f
def get_write_lots_of_frame_places_runner(RGenOp):
fvw = ManyFramePlaceWriter(RGenOp)
def write_lots_of_frame_places_runner(x):
rgenop = RGenOp()
gv_f = make_write_lots_of_frame_places(rgenop, fvw.get_writer)
fn = gv_f.revealconst(lltype.Ptr(FUNC))
res = fn(x)
keepalive_until_here(rgenop) # to keep the code blocks alive
return res
return write_lots_of_frame_places_runner
class FramePlaceReader:
FUNC = lltype.Ptr(lltype.FuncType([llmemory.Address], lltype.Signed))
def __init__(self, RGenOp):
def reader(base):
return RGenOp.read_frame_place(lltype.Signed, base,
self.place)
self.reader = reader
def get_reader(self, place):
self.place = place
return llhelper(self.FUNC, self.reader)
def make_read_frame_place(rgenop, get_reader):
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC)
readertoken = rgenop.sigToken(FramePlaceReader.FUNC.TO)
builder, gv_f, [gv_x] = rgenop.newgraph(sigtoken, "f")
builder.start_writing()
place = builder.alloc_frame_place(signed_kind,
rgenop.genconst(42))
gv_base = builder.genop_get_frame_base()
gv_reader = rgenop.constPrebuiltGlobal(get_reader(place))
gv_z = builder.genop_call(readertoken, gv_reader, [gv_base])
builder.genop_absorb_place(signed_kind, place) # mark end of use
builder.finish_and_return(sigtoken, gv_z)
builder.end()
return gv_f
def get_read_frame_place_runner(RGenOp):
fpr = FramePlaceReader(RGenOp)
def read_frame_place_runner(x):
rgenop = RGenOp()
gv_f = make_read_frame_place(rgenop, fpr.get_reader)
fn = gv_f.revealconst(lltype.Ptr(FUNC))
res = fn(x)
keepalive_until_here(rgenop) # to keep the code blocks alive
return res
return read_frame_place_runner
def make_ovfcheck_adder(rgenop, n):
sigtoken = rgenop.sigToken(FUNC)
builder, gv_fn, [gv_x] = rgenop.newgraph(sigtoken, "ovfcheck_adder")
builder.start_writing()
gv_result, gv_flag = builder.genraisingop2("int_add_ovf", gv_x,
rgenop.genconst(n))
gv_flag = builder.genop1("cast_bool_to_int", gv_flag)
gv_result = builder.genop2("int_lshift", gv_result, rgenop.genconst(1))
gv_result = builder.genop2("int_or", gv_result, gv_flag)
builder.finish_and_return(sigtoken, gv_result)
builder.end()
return gv_fn
def get_ovfcheck_adder_runner(RGenOp):
def runner(x, y):
rgenop = RGenOp()
gv_add_x = make_ovfcheck_adder(rgenop, x)
add_x = gv_add_x.revealconst(lltype.Ptr(FUNC))
res = add_x(y)
keepalive_until_here(rgenop) # to keep the code blocks alive
return res
return runner
class AbstractRGenOpTests(test_boehm.AbstractGCTestClass):
RGenOp = None
def compile(self, runner, argtypes):
return self.getcompiled(runner, argtypes,
annotatorpolicy = GENOP_POLICY)
def cast(self, gv, nb_args):
F1 = lltype.FuncType([lltype.Signed] * nb_args, lltype.Signed)
return self.RGenOp.get_python_callable(lltype.Ptr(F1), gv)
def directtesthelper(self, FUNCTYPE, func):
# for machine code backends: build a ctypes function pointer
# (with a real physical address) that will call back our 'func'
nb_args = len(FUNCTYPE.TO.ARGS)
callback = CFUNCTYPE(c_int, *[c_int]*nb_args)(func)
keepalive = self.__dict__.setdefault('_keepalive', [])
keepalive.append((callback, func))
return cast(callback, c_void_p).value
# NB. returns the address as an integer
def test_directtesthelper_direct(self):
# def callable(x, y):
# return f(x) + x + y
rgenop = self.RGenOp()
def f(x):
return x + 1
gv_f = rgenop.genconst(self.directtesthelper(lltype.Ptr(FUNC), f))
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken1 = rgenop.sigToken(FUNC)
sigtoken2 = rgenop.sigToken(FUNC2)
builder, gv_callable, [gv_x, gv_y] = rgenop.newgraph(sigtoken2, "callable")
builder.start_writing()
gv_t1 = builder.genop_call(sigtoken1, gv_f, [gv_x])
gv_t2 = builder.genop2("int_add", gv_t1, gv_x)
gv_result = builder.genop2("int_add", gv_t2, gv_y)
builder.finish_and_return(sigtoken2, gv_result)
builder.end()
fnptr = self.cast(gv_callable, 2)
res = fnptr(10, 5)
assert res == 11 + 10 + 5
def test_adder_direct(self):
rgenop = self.RGenOp()
gv_add_5 = make_adder(rgenop, 5)
fnptr = self.cast(gv_add_5, 1)
res = fnptr(37)
assert res == 42
def test_adder_compile(self):
fn = self.compile(get_adder_runner(self.RGenOp), [int, int])
res = fn(9080983, -9080941)
assert res == 42
def test_dummy_direct(self):
rgenop = self.RGenOp()
gv_dummyfn = make_dummy(rgenop)
fnptr = self.cast(gv_dummyfn, 2)
res = fnptr(30, 17)
assert res == 42
def test_dummy_compile(self):
fn = self.compile(get_dummy_runner(self.RGenOp), [int, int])
res = fn(40, 37)
assert res == 42
def test_hide_and_reveal(self):
RGenOp = self.RGenOp
def hide_and_reveal(v):
rgenop = RGenOp()
gv = rgenop.genconst(v)
res = gv.revealconst(lltype.Signed)
keepalive_until_here(rgenop)
return res
res = hide_and_reveal(42)
assert res == 42
fn = self.compile(hide_and_reveal, [int])
res = fn(42)
assert res == 42
def test_hide_and_reveal_p(self):
RGenOp = self.RGenOp
S = lltype.GcStruct('s', ('x', lltype.Signed))
S_PTR = lltype.Ptr(S)
s1 = lltype.malloc(S)
s1.x = 8111
s2 = lltype.malloc(S)
s2.x = 8222
def hide_and_reveal_p(n):
rgenop = RGenOp()
if n == 1:
s = s1
else:
s = s2
gv = rgenop.genconst(s)
s_res = gv.revealconst(S_PTR)
keepalive_until_here(rgenop)
return s_res.x
res = hide_and_reveal_p(1)
assert res == 8111
res = hide_and_reveal_p(2)
assert res == 8222
fn = self.compile(hide_and_reveal_p, [int])
res = fn(1)
assert res == 8111
res = fn(2)
assert res == 8222
def test_largedummy_direct(self):
rgenop = self.RGenOp()
gv_largedummyfn = make_largedummy(rgenop)
fnptr = self.cast(gv_largedummyfn, 100)
args, expected = largedummy_example()
res = fnptr(*args)
assert res == expected
def test_largedummy_compile(self):
fn = self.compile(get_largedummy_runner(self.RGenOp), [int] * 100)
args, expected = largedummy_example()
res = fn(*args)
assert res == expected
def test_branching_direct(self):
rgenop = self.RGenOp()
gv_branchingfn = make_branching(rgenop)
fnptr = self.cast(gv_branchingfn, 2)
res = fnptr(30, 17)
assert res == 29
res = fnptr(3, 17)
assert res == 17
def test_branching_compile(self):
fn = self.compile(get_branching_runner(self.RGenOp), [int, int])
res = fn(30, 17)
assert res == 29
res = fn(3, 17)
assert res == 17
def test_goto_direct(self):
rgenop = self.RGenOp()
gv_gotofn = make_goto(rgenop)
fnptr = self.cast(gv_gotofn, 2)
res = fnptr(10, 17) # <== the segfault is here
assert res == 3628872
res = fnptr(3, 17) # <== or here
assert res == 29
def test_goto_compile(self):
fn = self.compile(get_goto_runner(self.RGenOp), [int, int])
res = fn(10, 17)
assert res == 3628872
res = fn(3, 17)
assert res == 29
def test_if_direct(self):
rgenop = self.RGenOp()
gv_iffn = make_if(rgenop)
fnptr = self.cast(gv_iffn, 2)
res = fnptr(30, 0)
assert res == 45
res = fnptr(3, 0)
assert res == 6
def test_if_compile(self):
fn = self.compile(get_if_runner(self.RGenOp), [int, int])
res = fn(30, 0)
assert res == 45
res = fn(3, 0)
assert res == 6
def test_switch_direct(self):
rgenop = self.RGenOp()
gv_switchfn = make_switch(rgenop)
fnptr = self.cast(gv_switchfn, 2)
res = fnptr(0, 2)
assert res == 42
res = fnptr(1, 16)
assert res == 37
res = fnptr(42, 16)
assert res == 16
def test_switch_compile(self):
fn = self.compile(get_switch_runner(self.RGenOp), [int, int])
res = fn(0, 2)
assert res == 42
res = fn(1, 17)
assert res == 38
res = fn(42, 18)
assert res == 18
def test_large_switch_direct(self):
rgenop = self.RGenOp()
gv_switchfn = make_large_switch(rgenop)
fnptr = self.cast(gv_switchfn, 2)
res = fnptr(0, 2)
assert res == 42
for x in range(1,11):
res = fnptr(x, 5)
assert res == 2**x+5
res = fnptr(42, 16)
assert res == 16
def test_large_switch_compile(self):
fn = self.compile(get_large_switch_runner(self.RGenOp), [int, int])
res = fn(0, 2)
assert res == 42
for x in range(1,11):
res = fn(x, 7)
assert res == 2**x+7
res = fn(42, 18)
assert res == 18
def test_fact_direct(self):
rgenop = self.RGenOp()
gv_fact = make_fact(rgenop)
fnptr = self.cast(gv_fact, 1)
res = fnptr(2)
assert res == 2
res = fnptr(10)
assert res == 3628800
def test_fact_compile(self):
fn = self.compile(get_fact_runner(self.RGenOp), [int])
res = fn(2)
assert res == 2
res = fn(11)
assert res == 39916800
def test_calling_pause_direct(self):
rgenop = self.RGenOp()
gv_abs = make_func_calling_pause(rgenop)
fnptr = self.cast(gv_abs, 1)
res = fnptr(2)
assert res == 2
res = fnptr(-42)
assert res == 42
def test_calling_pause_compile(self):
fn = self.compile(get_func_calling_pause_runner(self.RGenOp), [int])
res = fn(2)
assert res == 2
res = fn(-72)
assert res == 72
def test_longwinded_and_direct(self):
rgenop = self.RGenOp()
gv_fn = make_longwinded_and(rgenop)
fnptr = self.cast(gv_fn, 1)
res = fnptr(1)
assert res == 0
res = fnptr(2)
assert res == 1
res = fnptr(3)
assert res == 1
res = fnptr(4)
assert res == 1
res = fnptr(5)
assert res == 0
def test_condition_result_cross_link_direct(self):
rgenop = self.RGenOp()
gv_fn = make_condition_result_cross_link(rgenop)
fnptr = self.cast(gv_fn, 1)
res = fnptr(-1)
assert res == 3
res = fnptr(0)
assert res == 1
res = fnptr(1)
assert res == 3
def test_multiple_cmps(self):
# return x>y + 10*x<y + 100*x<=y + 1000*x>=y + 10000*x==y + 100000*x!=y
rgenop = self.RGenOp()
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC2)
builder, gv_callable, [gv_x, gv_y] = rgenop.newgraph(sigtoken,
"multicmp")
builder.start_writing()
args_gv = [gv_x, gv_y]
builder.enter_next_block([signed_kind, signed_kind], args_gv)
[gv_x, gv_y] = args_gv
gv_gt = builder.genop2("int_gt", gv_x, gv_y)
gv_lt = builder.genop2("int_lt", gv_x, gv_y)
gv_ge = builder.genop2("int_ge", gv_x, gv_y)
gv_le = builder.genop2("int_le", gv_x, gv_y)
gv_eq = builder.genop2("int_eq", gv_x, gv_y)
gv_ne = builder.genop2("int_ne", gv_x, gv_y)
gv_gt1 = builder.genop1("cast_bool_to_int", gv_gt)
gv_lt1 = builder.genop1("cast_bool_to_int", gv_lt)
gv_ge1 = builder.genop1("cast_bool_to_int", gv_ge)
gv_le1 = builder.genop1("cast_bool_to_int", gv_le)
gv_eq1 = builder.genop1("cast_bool_to_int", gv_eq)
gv_ne1 = builder.genop1("cast_bool_to_int", gv_ne)
gv_gt2 = gv_gt1
gv_lt2 = builder.genop2("int_mul", rgenop.genconst(10), gv_lt1)
gv_ge2 = builder.genop2("int_mul", rgenop.genconst(100), gv_ge1)
gv_le2 = builder.genop2("int_mul", rgenop.genconst(1000), gv_le1)
gv_eq2 = builder.genop2("int_mul", rgenop.genconst(10000), gv_eq1)
gv_ne2 = builder.genop2("int_mul", rgenop.genconst(100000), gv_ne1)
gv_r0 = gv_gt2
gv_r1 = builder.genop2("int_add", gv_r0, gv_lt2)
gv_r2 = builder.genop2("int_add", gv_r1, gv_ge2)
gv_r3 = builder.genop2("int_add", gv_r2, gv_le2)
gv_r4 = builder.genop2("int_add", gv_r3, gv_eq2)
gv_r5 = builder.genop2("int_add", gv_r4, gv_ne2)
builder.finish_and_return(sigtoken, gv_r5)
builder.end()
fnptr = self.cast(gv_callable, 2)
res = fnptr(1, 2)
assert res == 101010
res = fnptr(1, 1)
assert res == 11100
res = fnptr(2, 1)
assert res == 100101
def test_flipped_cmp_with_immediate(self):
# return
# 1>x + 10*(1<x) + 100*(1>=x) + 1000*(1<=x) + 10000*(1==x) + 100000*(1!=x)
rgenop = self.RGenOp()
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC)
builder, gv_callable, [gv_x] = rgenop.newgraph(sigtoken,
"multicmp")
builder.start_writing()
gv_one = rgenop.genconst(1)
gv_gt = builder.genop2("int_gt", gv_one, gv_x)
gv_lt = builder.genop2("int_lt", gv_one, gv_x)
gv_ge = builder.genop2("int_ge", gv_one, gv_x)
gv_le = builder.genop2("int_le", gv_one, gv_x)
gv_eq = builder.genop2("int_eq", gv_one, gv_x)
gv_ne = builder.genop2("int_ne", gv_one, gv_x)
gv_gt1 = builder.genop1("cast_bool_to_int", gv_gt)
gv_lt1 = builder.genop1("cast_bool_to_int", gv_lt)
gv_ge1 = builder.genop1("cast_bool_to_int", gv_ge)
gv_le1 = builder.genop1("cast_bool_to_int", gv_le)
gv_eq1 = builder.genop1("cast_bool_to_int", gv_eq)
gv_ne1 = builder.genop1("cast_bool_to_int", gv_ne)
gv_gt2 = gv_gt1
gv_lt2 = builder.genop2("int_mul", rgenop.genconst(10), gv_lt1)
gv_ge2 = builder.genop2("int_mul", rgenop.genconst(100), gv_ge1)
gv_le2 = builder.genop2("int_mul", rgenop.genconst(1000), gv_le1)
gv_eq2 = builder.genop2("int_mul", rgenop.genconst(10000), gv_eq1)
gv_ne2 = builder.genop2("int_mul", rgenop.genconst(100000), gv_ne1)
gv_r0 = gv_gt2
gv_r1 = builder.genop2("int_add", gv_r0, gv_lt2)
gv_r2 = builder.genop2("int_add", gv_r1, gv_ge2)
gv_r3 = builder.genop2("int_add", gv_r2, gv_le2)
gv_r4 = builder.genop2("int_add", gv_r3, gv_eq2)
gv_r5 = builder.genop2("int_add", gv_r4, gv_ne2)
builder.finish_and_return(sigtoken, gv_r5)
builder.end()
fnptr = self.cast(gv_callable, 1)
res = fnptr(0)
assert res == 100101
res = fnptr(1)
assert res == 11100
res = fnptr(2)
assert res == 101010
def test_tight_loop(self):
# while 1:
# y = x - 7
# if y < 0: break
# x = y
# return x
rgenop = self.RGenOp()
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC)
builder, gv_callable, [gv_x] = rgenop.newgraph(sigtoken,
"tightloop")
builder.start_writing()
args_gv = [gv_x]
loopstart = builder.enter_next_block([signed_kind], args_gv)
[gv_x] = args_gv
gv_y = builder.genop2("int_sub", gv_x, rgenop.genconst(7))
gv_cond = builder.genop2("int_lt", gv_y, rgenop.genconst(0))
end_builder = builder.jump_if_true(gv_cond, [gv_x])
builder.finish_and_goto([gv_y], loopstart)
end_builder.start_writing()
end_builder.finish_and_return(sigtoken, gv_x)
builder.end()
fnptr = self.cast(gv_callable, 1)
res = fnptr(5)
assert res == 5
res = fnptr(44)
assert res == 2
def test_jump_to_block_with_many_vars(self):
rgenop = self.RGenOp()
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC)
builder, gv_verysmall_callable, [gv_x] = rgenop.newgraph(sigtoken,
"verysmall")
builder.start_writing()
builder.finish_and_return(sigtoken, rgenop.genconst(17))
builder.end()
builder, gv_callable, [gv_x] = rgenop.newgraph(sigtoken,
"jtbwmv")
builder.start_writing()
gv_cond = builder.genop1("int_is_true", gv_x)
builder2 = builder.jump_if_false(gv_cond, [gv_x])
builder = builder.pause_writing([gv_x])
builder2.start_writing()
args_gv = [gv_x]
label = builder2.enter_next_block([signed_kind], args_gv)
[gv_x2] = args_gv
gvs = []
for i in range(50):
gvs.append(builder2.genop2("int_mul", gv_x2, rgenop.genconst(i)))
gvs.append(builder2.genop_call(sigtoken, gv_verysmall_callable,
[gv_x2]))
while len(gvs) > 1:
gvs.append(builder2.genop2("int_add", gvs.pop(), gvs.pop()))
builder2.finish_and_return(sigtoken, gvs.pop())
builder.start_writing()
builder.finish_and_goto([gv_x], label)
builder.end()
fnptr = self.cast(gv_callable, 1)
res = fnptr(1291)
assert res == 1291 * (49*50/2) + 17
def test_same_as(self):
rgenop = self.RGenOp()
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC)
builder, gv_callable, [gv_x] = rgenop.newgraph(sigtoken, "sameas")
builder.start_writing()
gv_nineteen = builder.genop_same_as(signed_kind, rgenop.genconst(19))
assert not gv_nineteen.is_const # 'same_as' must return a variable
builder.finish_and_return(sigtoken, gv_nineteen)
builder.end()
fnptr = self.cast(gv_callable, 1)
res = fnptr(17)
assert res == 19
def test_pause_and_resume_direct(self):
rgenop = self.RGenOp()
gv_callable = make_pause_and_resume(rgenop)
fnptr = self.cast(gv_callable, 1)
res = fnptr(1)
assert res == 0
res = fnptr(2)
assert res == 3
res = fnptr(3)
assert res == 8
def test_pause_and_resume_compile(self):
fn = self.compile(get_pause_and_resume_runner(self.RGenOp), [int])
res = fn(1)
assert res == 0
res = fn(2)
assert res == 3
res = fn(3)
assert res == 8
def test_like_residual_red_call_with_exc_direct(self):
rgenop = self.RGenOp()
gv_callable = make_something_a_bit_like_residual_red_call_with_exc(rgenop)
fnptr = self.cast(gv_callable, 2)
res = fnptr(1, 3)
assert res == 4
res = fnptr(0, 3)
assert res == 14
def test_call_functions_with_different_signatures_direct(self):
rgenop = self.RGenOp()
gv_callable = make_call_functions_with_different_signatures(rgenop)
fnptr = self.cast(gv_callable, 2)
res = fnptr(1, 3)
assert res == 2
res = fnptr(0, 3)
assert res == 1
def test_defaultonly_switch(self):
rgenop = self.RGenOp()
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC)
builder, gv_callable, [gv_x] = rgenop.newgraph(sigtoken, "defaultonly")
builder.start_writing()
flexswitch, default_builder = builder.flexswitch(gv_x, [gv_x])
default_builder.finish_and_return(sigtoken, gv_x)
builder.end()
fnptr = self.cast(gv_callable, 1)
res = fnptr(17)
assert res == 17
def test_bool_not_direct(self):
rgenop = self.RGenOp()
signed_kind = rgenop.kindToken(lltype.Signed)
bool_kind = rgenop.kindToken(lltype.Bool)
sigtoken = rgenop.sigToken(FUNC)
builder, gv_callable, [gv_x] = rgenop.newgraph(sigtoken, "bool_not")
builder.start_writing()
gv_cond = builder.genop2("int_lt", gv_x, rgenop.genconst(10))
gv_neg = builder.genop1("bool_not", gv_cond)
builder2 = builder.jump_if_true(gv_neg, [])
builder.finish_and_return(sigtoken, rgenop.genconst(111))
builder2.start_writing()
builder2.finish_and_return(sigtoken, rgenop.genconst(168))
builder.end()
fnptr = self.cast(gv_callable, 1)
res = fnptr(17)
assert res == 168
res = fnptr(7)
assert res == 111
def test_read_frame_var_direct(self):
def get_reader(info):
fvr = FrameVarReader(self.RGenOp)
fvr.frameinfo = info
reader_ptr = self.directtesthelper(fvr.FUNC, fvr.reader)
return reader_ptr
rgenop = self.RGenOp()
gv_callable = make_read_frame_var(rgenop, get_reader)
fnptr = self.cast(gv_callable, 1)
res = fnptr(20)
assert res == 40
def test_read_frame_var_compile(self):
fn = self.compile(get_read_frame_var_runner(self.RGenOp), [int])
res = fn(30)
assert res == 60
def test_write_frame_place_direct(self):
def get_writer(place1, place2):
fvw = FramePlaceWriter(self.RGenOp)
fvw.place1 = place1
fvw.place2 = place2
writer_ptr = self.directtesthelper(fvw.FUNC, fvw.writer)
return writer_ptr
rgenop = self.RGenOp()
gv_callable = make_write_frame_place(rgenop, get_writer)
fnptr = self.cast(gv_callable, 1)
res = fnptr(3)
assert res == -100 - 30
res = fnptr(6)
assert res == 42 - 60
def test_write_frame_place_compile(self):
fn = self.compile(get_write_frame_place_runner(self.RGenOp), [int])
res = fn(-42)
assert res == -100 - (-420)
res = fn(606)
assert res == 4242 - 6060
def test_write_lots_of_frame_places_direct(self):
def get_writer(places):
fvw = ManyFramePlaceWriter(self.RGenOp)
fvw.places = places
writer_ptr = self.directtesthelper(fvw.FUNC, fvw.writer)
return writer_ptr
rgenop = self.RGenOp()
gv_callable = make_write_lots_of_frame_places(rgenop, get_writer)
fnptr = self.cast(gv_callable, 1)
res = fnptr(3)
assert res == sum(range(3, 103))
res = fnptr(6)
assert res == sum(range(6, 106))
def test_read_frame_place_direct(self):
def get_reader(place):
fpr = FramePlaceReader(self.RGenOp)
fpr.place = place
reader_ptr = self.directtesthelper(fpr.FUNC, fpr.reader)
return reader_ptr
rgenop = self.RGenOp()
gv_callable = make_read_frame_place(rgenop, get_reader)
fnptr = self.cast(gv_callable, 1)
res = fnptr(-1)
assert res == 42
def test_read_frame_place_compile(self):
fn = self.compile(get_read_frame_place_runner(self.RGenOp), [int])
res = fn(-1)
assert res == 42
def test_frame_vars_like_the_frontend_direct(self):
rgenop = self.RGenOp()
sigtoken = rgenop.sigToken(FUNC3)
signed_kind = rgenop.kindToken(lltype.Signed)
# ------------------------------------------
builder0, gv_callable, [v0, v1, v2] = rgenop.newgraph(sigtoken,
'fvltf')
builder0.start_writing()
builder1 = builder0.pause_writing([v1, v0, v2])
builder1.start_writing()
args_gv = [v1, v0, v2]
label0 = builder1.enter_next_block([signed_kind]*3, args_gv)
[v3, v4, v5] = args_gv
place = builder1.alloc_frame_place(signed_kind, rgenop.genconst(0))
v6 = builder1.genop_get_frame_base()
c_seven = rgenop.genconst(7)
frameinfo = builder1.get_frame_info([v3, v4, c_seven, v5])
# here would be a call
v8 = builder1.genop_absorb_place(signed_kind, place)
args_gv = [v3, v4, v5, v8]
label1 = builder1.enter_next_block([signed_kind]*4, args_gv)
[v9, v10, v11, v12] = args_gv
# test duplicates in live vars while we're at it
flexswitch0, builder2 = builder1.flexswitch(v12, [v9, v10, v12, v10])
v13 = builder2.genop2("int_add", v9, v10)
v14 = builder2.genop2("int_add", v13, v12)
builder2.finish_and_return(sigtoken, v14)
builder0.end()
fnptr = self.cast(gv_callable, 3)
res = fnptr(40, 2, 8168126)
assert res == 42
def test_unaliasing_variables_direct(self):
# def f(x, y):
# if x:
# a = b = y
# else:
# a = 2
# b = 1
# return a+b
rgenop = self.RGenOp()
signed_kind = rgenop.kindToken(lltype.Signed)
sigtoken = rgenop.sigToken(FUNC2)
builder, gv_callable, [gv_x, gv_y] = rgenop.newgraph(sigtoken, "f")
builder.start_writing()
gv_cond = builder.genop1("int_is_true", gv_x)
false_builder = builder.jump_if_false(gv_cond, [])
args_gv = [gv_y, gv_y]
label = builder.enter_next_block([signed_kind, signed_kind], args_gv)
[gv_a, gv_b] = args_gv
gv_result = builder.genop2("int_add", gv_a, gv_b)
builder.finish_and_return(sigtoken, gv_result)
false_builder.start_writing()
false_builder.finish_and_goto([rgenop.genconst(2), rgenop.genconst(1)], label)
builder.end()
fnptr = self.cast(gv_callable, 2)
res = fnptr(20, 2)
assert res == 4
res = fnptr(0, 2)
assert res == 3
def test_from_random_direct(self):
#def dummyfn(counter, a, b):
# goto = 0
# while True:
# if goto == 0:
# b = not a
# if a:
# counter -= 1
# if not counter: break
# goto = 0
# else:
# counter -= 1
# if not counter: break
# goto = 0
# return intmask(a*-468864544+b*-340864157)
rgenop = self.RGenOp()
signed_kind = rgenop.kindToken(lltype.Signed)
bool_kind = rgenop.kindToken(lltype.Bool)
builder0, gv_callable, [v0, v1, v2] = rgenop.newgraph(rgenop.sigToken(FUNC3), 'compiled_dummyfn')
builder0.start_writing()
args_gv = [v0, v1]
label0 = builder0.enter_next_block([signed_kind, signed_kind], args_gv)
[v3, v4] = args_gv
v5 = builder0.genop1('int_is_true', v4)
builder1 = builder0.jump_if_true(v5, [v3, v4])
args_gv = [v3, v4, rgenop.genconst(True)]
label1 = builder0.enter_next_block([signed_kind, signed_kind, bool_kind], args_gv)
[v6, v7, v8] = args_gv
v9 = builder0.genop1('int_is_true', v7)
builder2 = builder0.jump_if_true(v9, [v7, v8, v6])
v10 = builder0.genop2('int_sub', v6, rgenop.genconst(1))
v11 = builder0.genop1('int_is_true', v10)
builder3 = builder0.jump_if_false(v11, [v8, v7])
builder0.finish_and_goto([v10, v7], label0)
builder2.start_writing()
v12 = builder2.genop2('int_sub', v6, rgenop.genconst(1))
v13 = builder2.genop1('int_is_true', v12)
builder4 = builder2.jump_if_false(v13, [v8, v7])
builder2.finish_and_goto([v12, v7], label0)
builder3.start_writing()
args_gv = [v8, v7]
label2 = builder3.enter_next_block([bool_kind, signed_kind], args_gv)
[v14, v15] = args_gv
v16 = builder3.genop2('int_mul', v15, rgenop.genconst(-468864544))
v17 = builder3.genop1('cast_bool_to_int', v14)
v18 = builder3.genop2('int_mul', v17, rgenop.genconst(-340864157))
v19 = builder3.genop2('int_add', v16, v18)
builder3.finish_and_return(rgenop.sigToken(FUNC3), v19)
builder1.start_writing()
builder1.finish_and_goto([v3, v4, rgenop.genconst(False)], label1)
builder4.start_writing()
builder4.finish_and_goto([v8, v7], label2)
builder4.end()
fnptr = self.cast(gv_callable, 3)
res = fnptr(1, -58, -50)
assert res == 1424339776
def test_from_random_2_direct(self):
# def dummyfn(counter, d, e):
# a = not d
# while counter:
# d = a and e
# counter -= 1
# return intmask(d)
rgenop = self.RGenOp()
signed_kind = rgenop.kindToken(lltype.Signed)
bool_kind = rgenop.kindToken(lltype.Bool)
builder0, gv_callable, [v0, v1, v2] = rgenop.newgraph(rgenop.sigToken(FUNC3), 'compiled_dummyfn')
builder0.start_writing()
v3 = builder0.genop1('int_is_true', v1)
builder1 = builder0.jump_if_true(v3, [v0, v1, v2])
args_gv = [v0, v1, v2, rgenop.genconst(True)]
label0 = builder0.enter_next_block([signed_kind, signed_kind, signed_kind, bool_kind], args_gv)
[v4, v5, v6, v7] = args_gv
v8 = builder0.genop1('int_is_true', v4)
builder2 = builder0.jump_if_false(v8, [v5])
builder3 = builder0.jump_if_false(v7, [v7, v6, v4])
args_gv = [v6, v6, v7, v4]
label1 = builder0.enter_next_block([signed_kind, signed_kind, bool_kind, signed_kind], args_gv)
[v9, v10, v11, v12] = args_gv
v13 = builder0.genop2('int_sub', v12, rgenop.genconst(1))
builder0.finish_and_goto([v13, v9, v10, v11], label0)
builder1.start_writing()
builder1.finish_and_goto([v0, v1, v2, rgenop.genconst(False)], label0)
builder3.start_writing()
v14 = builder3.genop1('cast_bool_to_int', v7)
builder3.finish_and_goto([v14, v6, v7, v4], label1)
builder2.start_writing()
builder2.finish_and_return(rgenop.sigToken(FUNC3), v5)
builder2.end()
fnptr = self.cast(gv_callable, 3)
res = fnptr(2, -89, -99)
assert res == 0
def test_from_random_3_direct(self):
# def dummyfn(counter, g, l, w, x):
# b = y = 0
# if not counter: return 0
#
# while counter:
# y = not l
# b = w and g
# g = y and w
# counter -= 1
#
# return intmask(b+g+2*y)
rgenop = self.RGenOp()
signed_kind = rgenop.kindToken(lltype.Signed)
bool_kind = rgenop.kindToken(lltype.Bool)
builder0, gv_callable, [v0, v1, v2, v3, v4] = rgenop.newgraph(rgenop.sigToken(FUNC5), 'compiled_dummyfn')
builder0.start_writing()
v5 = builder0.genop1('int_is_true', v0)
builder1 = builder0.jump_if_true(v5, [v0, v1, v3, v2])
builder0.finish_and_return(rgenop.sigToken(FUNC5), rgenop.genconst(0))
builder1.start_writing()
args_gv = [v0, v1, v2, v3]
label0 = builder1.enter_next_block([signed_kind, signed_kind, signed_kind, signed_kind], args_gv)
[v6, v7, v8, v9] = args_gv
v10 = builder1.genop1('int_is_true', v8)
builder2 = builder1.jump_if_false(v10, [v6, v7, v9, v8])
args_gv = [v6, v7, v8, v9, rgenop.genconst(False)]
label1 = builder1.enter_next_block(
[signed_kind, signed_kind, signed_kind, signed_kind, bool_kind], args_gv)
[v11, v12, v13, v14, v15] = args_gv
v16 = builder1.genop1('int_is_true', v14)
builder3 = builder1.jump_if_true(v16, [v11, v13, v15, v14, v12])
args_gv = [v11, v13, v14, v14, v15]
label2 = builder1.enter_next_block(
[signed_kind, signed_kind, signed_kind, signed_kind, bool_kind], args_gv)
[v17, v18, v19, v20, v21] = args_gv
builder4 = builder1.jump_if_false(v21, [v17, v18, v19, v20, v21])
args_gv = [v19, v18, v19, v20, v21, v17]
label3 = builder1.enter_next_block(
[signed_kind, signed_kind, signed_kind, signed_kind, bool_kind, signed_kind], args_gv)
[v22, v23, v24, v25, v26, v27] = args_gv
v28 = builder1.genop2('int_sub', v27, rgenop.genconst(1))
v29 = builder1.genop1('int_is_true', v28)
builder5 = builder1.jump_if_false(v29, [v26, v25, v22])
builder1.finish_and_goto([v28, v22, v23, v24], label0)
builder4.start_writing()
v30 = builder4.genop1('cast_bool_to_int', v21)
builder4.finish_and_goto([v30, v18, v19, v20, v21, v17], label3)
builder2.start_writing()
builder2.finish_and_goto([v6, v7, v8, v9, rgenop.genconst(True)], label1)
builder3.start_writing()
builder3.finish_and_goto([v11, v13, v14, v12, v15], label2)
builder5.start_writing()
v31 = builder5.genop2('int_add', v25, v22)
v32 = builder5.genop1('cast_bool_to_int', v26)
v33 = builder5.genop2('int_mul', rgenop.genconst(2), v32)
v34 = builder5.genop2('int_add', v31, v33)
builder5.finish_and_return(rgenop.sigToken(FUNC5), v34)
builder5.end()
fnptr = self.cast(gv_callable, 5)
res = fnptr(2, 10, 10, 400, 0)
assert res == 0
def test_from_random_4_direct(self):
rgenop = self.RGenOp()
signed_kind = rgenop.kindToken(lltype.Signed)
bool_kind = rgenop.kindToken(lltype.Bool)
builder0, gv_callable, [v0, v1, v2] = rgenop.newgraph(
rgenop.sigToken(FUNC3), 'compiled_dummyfn')
builder0.start_writing()
args_gv = [v0, v1, v2]
label0 = builder0.enter_next_block([signed_kind, signed_kind, signed_kind], args_gv)
[v3, v4, v5] = args_gv
v6 = builder0.genop2('int_add', v5, v4)
v7 = builder0.genop1('int_is_true', v4)
builder1 = builder0.jump_if_false(v7, [v4, v5, v3, v6])
args_gv = [v3, v4, v5]
label1 = builder0.enter_next_block([signed_kind, signed_kind, signed_kind], args_gv)
[v8, v9, v10] = args_gv
v11 = builder0.genop1('int_is_true', v10)
builder2 = builder0.jump_if_true(v11, [v9, v10, v8])
builder0.finish_and_goto([v8, v9, v10], label1)
builder1.start_writing()
v24 = builder1.genop2('int_sub', v3, rgenop.genconst(1))
v25 = builder1.genop1('int_is_true', v24)
builder7 = builder1.jump_if_true(v25, [v24, v4, v5])
args_gv = [v5, v6, v4]
label4 = builder1.enter_next_block([signed_kind, signed_kind, signed_kind], args_gv)
[v26, v27, v28] = args_gv
builder1.finish_and_return(rgenop.sigToken(FUNC3), v27)
builder2.start_writing()
v33 = builder2.genop2('int_sub', v8, rgenop.genconst(1))
v34 = builder2.genop1('int_is_true', v33)
builder8 = builder2.jump_if_false(v34, [v10, v9])
builder2.finish_and_goto([v33, v9, v10], label1)
print 'waatch!'
builder8.start_writing()
builder8.finish_and_goto([v10, v9, v9], label4)
print 'stop!'
builder7.start_writing()
builder7.finish_and_goto([v24, v4, v5], label0)
builder7.end()
fnptr = self.cast(gv_callable, 3)
res = fnptr(10, 29, 12)
assert res == 29
def test_from_random_5_direct(self):
## def dummyfn(counter, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z):
## while True:
## if b:
## pass
## g = q and j
## d = intmask(s - y) # d <esi>
## # t <0x64(%ebp)>
## e = y != f # e <ebx>
## j = c or j
## o = d or t # d <edx> o <esi>
## t = l > o # t <ecx>
## if e:
## pass
## counter -= 1
## if not counter: break
## return intmask(a*-468864544+b*-340864157+c*-212863774+d*-84863387+e*43136996+f*171137383+g*299137766+h*427138153+i*555138536+j*683138923+k*811139306+l*939139693+m*1067140076+n*1195140463+o*1323140846+p*1451141233+q*1579141616+r*1707142003+s*1835142386+t*1963142773+u*2091143156+v*-2075823753+w*-1947823370+x*-1819822983+y*-1691822600+z*-1563822213)
rgenop = self.RGenOp()
signed_kind = rgenop.kindToken(lltype.Signed)
bool_kind = rgenop.kindToken(lltype.Bool)
builder0, gv_callable, [v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26] = rgenop.newgraph(rgenop.sigToken(FUNC27), 'compiled_dummyfn')
builder0.start_writing()
args_gv = [v0, v1, v2, v3, v6, v8, v9, v10, v11, v12, v13, v14, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26]
label0 = builder0.enter_next_block([signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind], args_gv)
[v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49] = args_gv
v50 = builder0.genop1('int_is_true', v29)
builder1 = builder0.jump_if_true(v50, [v48, v38, v27, v30, v32, v34, v47, v40, v28, v41, v43, v45, v37, v46, v31, v33, v35, v39, v36, v42, v49, v44, v29])
args_gv = [v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49]
label1 = builder0.enter_next_block([signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind], args_gv)
[v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73] = args_gv
v74 = builder0.genop1('int_is_true', v64)
builder2 = builder0.jump_if_true(v74, [v54, v52, v65, v58, v60, v62, v64, v68, v56, v69, v71, v51, v73, v53, v67, v57, v55, v59, v61, v63, v66, v70, v72])
args_gv = [v51, v52, v53, v54, v55, v64, v56, v57, v58, v59, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73]
label2 = builder0.enter_next_block([signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind], args_gv)
[v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98] = args_gv
v99 = builder0.genop2('int_sub', v91, v97)
v100 = builder0.genop2('int_ne', v97, v79)
v101 = builder0.genop1('int_is_true', v78)
builder3 = builder0.jump_if_true(v101, [v85, v93, v94, v87, v91, v97, v89, v98, v80, v82, v78, v86, v84, v99, v88, v100, v90, v92, v96, v75, v95, v76, v77, v79, v81])
args_gv = [v75, v76, v77, v78, v99, v100, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98]
label3 = builder0.enter_next_block([signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, bool_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind], args_gv)
[v102, v103, v104, v105, v106, v107, v108, v109, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v120, v121, v122, v123, v124, v125, v126, v127] = args_gv
v128 = builder0.genop1('int_is_true', v106)
builder4 = builder0.jump_if_false(v128, [v114, v111, v116, v113, v118, v122, v110, v124, v103, v125, v105, v127, v107, v112, v121, v109, v115, v117, v119, v123, v102, v120, v104, v126, v106, v108])
args_gv = [v102, v103, v104, v105, v106, v107, v108, v109, v110, v111, v112, v113, v114, v115, v116, v106, v117, v118, v119, v120, v122, v123, v124, v125, v126, v127]
label4 = builder0.enter_next_block([signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, bool_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind], args_gv)
[v129, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v150, v151, v152, v153, v154] = args_gv
v155 = builder0.genop2('int_gt', v141, v144)
builder5 = builder0.jump_if_false(v134, [v149, v148, v141, v143, v145, v147, v151, v139, v152, v132, v154, v134, v136, v130, v140, v138, v142, v155, v144, v146, v150, v129, v137, v131, v153, v133, v135])
args_gv = [v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v140, v141, v142, v143, v144, v145, v146, v147, v148, v155, v149, v150, v151, v152, v153, v154, v129]
label5 = builder0.enter_next_block([signed_kind, signed_kind, signed_kind, signed_kind, bool_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, bool_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind, signed_kind], args_gv)
[v156, v157, v158, v159, v160, v161, v162, v163, v164, v165, v166, v167, v168, v169, v170, v171, v172, v173, v174, v175, v176, v177, v178, v179, v180, v181, v182] = args_gv
v183 = builder0.genop2('int_sub', v182, rgenop.genconst(1))
v184 = builder0.genop1('int_is_true', v183)
builder6 = builder0.jump_if_true(v184, [v177, v166, v169, v171, v183, v173, v156, v165, v179, v158, v180, v168, v164, v178, v176, v172, v174, v167, v157, v175, v181, v161, v163])
v185 = builder0.genop2('int_mul', v156, rgenop.genconst(-468864544))
v186 = builder0.genop2('int_mul', v157, rgenop.genconst(-340864157))
v187 = builder0.genop2('int_add', v185, v186)
v188 = builder0.genop2('int_mul', v158, rgenop.genconst(-212863774))
v189 = builder0.genop2('int_add', v187, v188)
v190 = builder0.genop2('int_mul', v159, rgenop.genconst(-84863387))
v191 = builder0.genop2('int_add', v189, v190)
v192 = builder0.genop1('cast_bool_to_int', v160)
v193 = builder0.genop2('int_mul', v192, rgenop.genconst(43136996))
v194 = builder0.genop2('int_add', v191, v193)
v195 = builder0.genop2('int_mul', v161, rgenop.genconst(171137383))
v196 = builder0.genop2('int_add', v194, v195)
v197 = builder0.genop2('int_mul', v162, rgenop.genconst(299137766))
v198 = builder0.genop2('int_add', v196, v197)
v199 = builder0.genop2('int_mul', v163, rgenop.genconst(427138153))
v200 = builder0.genop2('int_add', v198, v199)
v201 = builder0.genop2('int_mul', v164, rgenop.genconst(555138536))
v202 = builder0.genop2('int_add', v200, v201)
v203 = builder0.genop2('int_mul', v165, rgenop.genconst(683138923))
v204 = builder0.genop2('int_add', v202, v203)
v205 = builder0.genop2('int_mul', v166, rgenop.genconst(811139306))
v206 = builder0.genop2('int_add', v204, v205)
v207 = builder0.genop2('int_mul', v167, rgenop.genconst(939139693))
v208 = builder0.genop2('int_add', v206, v207)
v209 = builder0.genop2('int_mul', v168, rgenop.genconst(1067140076))
v210 = builder0.genop2('int_add', v208, v209)
v211 = builder0.genop2('int_mul', v169, rgenop.genconst(1195140463))
v212 = builder0.genop2('int_add', v210, v211)
v213 = builder0.genop2('int_mul', v170, rgenop.genconst(1323140846))
v214 = builder0.genop2('int_add', v212, v213)
v215 = builder0.genop2('int_mul', v171, rgenop.genconst(1451141233))
v216 = builder0.genop2('int_add', v214, v215)
v217 = builder0.genop2('int_mul', v172, rgenop.genconst(1579141616))
v218 = builder0.genop2('int_add', v216, v217)
v219 = builder0.genop2('int_mul', v173, rgenop.genconst(1707142003))
v220 = builder0.genop2('int_add', v218, v219)
v221 = builder0.genop2('int_mul', v174, rgenop.genconst(1835142386))
v222 = builder0.genop2('int_add', v220, v221)
v223 = builder0.genop1('cast_bool_to_int', v175)
v224 = builder0.genop2('int_mul', v223, rgenop.genconst(1963142773))
v225 = builder0.genop2('int_add', v222, v224)
v226 = builder0.genop2('int_mul', v176, rgenop.genconst(2091143156))
v227 = builder0.genop2('int_add', v225, v226)
v228 = builder0.genop2('int_mul', v177, rgenop.genconst(-2075823753))
v229 = builder0.genop2('int_add', v227, v228)
v230 = builder0.genop2('int_mul', v178, rgenop.genconst(-1947823370))
v231 = builder0.genop2('int_add', v229, v230)
v232 = builder0.genop2('int_mul', v179, rgenop.genconst(-1819822983))
v233 = builder0.genop2('int_add', v231, v232)
v234 = builder0.genop2('int_mul', v180, rgenop.genconst(-1691822600))
v235 = builder0.genop2('int_add', v233, v234)
v236 = builder0.genop2('int_mul', v181, rgenop.genconst(-1563822213))
v237 = builder0.genop2('int_add', v235, v236)
builder0.finish_and_return(rgenop.sigToken(FUNC27), v237)
builder2.start_writing()
builder2.finish_and_goto([v51, v52, v53, v54, v55, v58, v56, v57, v58, v59, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73], label2)
builder4.start_writing()
builder4.finish_and_goto([v102, v103, v104, v105, v106, v107, v108, v109, v110, v111, v112, v113, v114, v115, v116, v121, v117, v118, v119, v120, v122, v123, v124, v125, v126, v127], label4)
builder3.start_writing()
builder3.finish_and_goto([v75, v76, v77, v78, v99, v100, v79, v80, v81, v82, v78, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98], label3)
builder1.start_writing()
builder1.finish_and_goto([v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49], label1)
builder5.start_writing()
builder5.finish_and_goto([v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v140, v141, v142, v143, v144, v145, v146, v147, v148, v155, v149, v150, v151, v152, v153, v154, v129], label5)
builder6.start_writing()
v238 = builder6.genop1('cast_bool_to_int', v175)
builder6.finish_and_goto([v183, v156, v157, v158, v161, v163, v164, v165, v166, v167, v168, v169, v171, v172, v173, v174, v238, v176, v177, v178, v179, v180, v181], label0)
builder6.end()
fnptr = self.cast(gv_callable, 27)
res = fnptr(*([5]*27))
assert res == 967746338
def test_genzeroconst(self):
RGenOp = self.RGenOp
gv = RGenOp.genzeroconst(RGenOp.kindToken(lltype.Signed))
assert gv.revealconst(lltype.Signed) == 0
P = lltype.Ptr(lltype.Struct('S'))
gv = RGenOp.genzeroconst(RGenOp.kindToken(P))
assert gv.revealconst(llmemory.Address) == llmemory.NULL
def test_ovfcheck_adder_direct(self):
rgenop = self.RGenOp()
gv_add_5 = make_ovfcheck_adder(rgenop, 5)
fnptr = self.cast(gv_add_5, 1)
res = fnptr(37)
assert res == (42 << 1) | 0
res = fnptr(sys.maxint-2)
assert (res & 1) == 1
def test_ovfcheck_adder_compile(self):
fn = self.compile(get_ovfcheck_adder_runner(self.RGenOp), [int, int])
res = fn(9080983, -9080941)
assert res == (42 << 1) | 0
res = fn(-sys.maxint, -10)
assert (res & 1) == 1
def test_ovfcheck1_direct(self):
yield self.ovfcheck1_direct, "int_neg_ovf", [(18, -18),
(-18, 18),
(sys.maxint, -sys.maxint),
(-sys.maxint, sys.maxint),
(-sys.maxint-1, None)]
yield self.ovfcheck1_direct, "int_abs_ovf", [(18, 18),
(-18, 18),
(sys.maxint, sys.maxint),
(-sys.maxint, sys.maxint),
(-sys.maxint-1, None)]
def ovfcheck1_direct(self, opname, testcases):
rgenop = self.RGenOp()
sigtoken = rgenop.sigToken(FUNC)
builder, gv_fn, [gv_x] = rgenop.newgraph(sigtoken, "ovfcheck1")
builder.start_writing()
gv_result, gv_flag = builder.genraisingop1(opname, gv_x)
gv_flag = builder.genop1("cast_bool_to_int", gv_flag)
gv_result = builder.genop2("int_lshift", gv_result, rgenop.genconst(1))
gv_result = builder.genop2("int_or", gv_result, gv_flag)
builder.finish_and_return(sigtoken, gv_result)
builder.end()
fnptr = self.cast(gv_fn, 1)
for x, expected in testcases:
res = fnptr(x)
if expected is None:
assert (res & 1) == 1
else:
assert res == intmask(expected << 1) | 0
def test_ovfcheck2_direct(self):
yield self.ovfcheck2_direct, "int_sub_ovf", [(18, 25, -7),
(sys.maxint, -1, None),
(-2, sys.maxint, None)]
yield self.ovfcheck2_direct, "int_mul_ovf", [(6, 7, 42),
(sys.maxint-100, 2, None),
(-2, sys.maxint-100, None)]
# XXX the rest in-progress
# XXX also missing the _zer versions
## yield self.ovfcheck2_direct, "int_mod_ovf", [
## (100, 8, 4),
## (-sys.maxint-1, 1, 0),
## (-sys.maxint-1, -1, None)]
## yield self.ovfcheck2_direct, "int_floordiv_ovf", [
## (100, 2, 50),
## (-sys.maxint-1, 1, -sys.maxint-1),
## (-sys.maxint-1, -1, None)]
## yield self.ovfcheck2_direct, "int_lshift_ovf", [
## (1, 30, 1<<30),
## (1, 31, None),
## (0xf23c, 14, 0xf23c << 14),
## (0xf23c, 15, None),
## (-1, 31, (-1) << 31),
## (-2, 31, None),
## (-3, 31, None),
## (-sys.maxint-1, 0, -sys.maxint-1)]
def ovfcheck2_direct(self, opname, testcases):
rgenop = self.RGenOp()
sigtoken = rgenop.sigToken(FUNC2)
builder, gv_fn, [gv_x, gv_y] = rgenop.newgraph(sigtoken, "ovfcheck2")
builder.start_writing()
gv_result, gv_flag = builder.genraisingop2(opname, gv_x, gv_y)
gv_flag = builder.genop1("cast_bool_to_int", gv_flag)
gv_result = builder.genop2("int_lshift", gv_result, rgenop.genconst(1))
gv_result = builder.genop2("int_or", gv_result, gv_flag)
builder.finish_and_return(sigtoken, gv_result)
builder.end()
fnptr = self.cast(gv_fn, 2)
for x, y, expected in testcases:
res = fnptr(x, y)
if expected is None:
assert (res & 1) == 1
else:
assert res == intmask(expected << 1) | 0
def test_cast_direct(self):
yield self.cast_direct, ["int_is_true", "cast_bool_to_int"], bool
yield self.cast_direct, ["int_is_true",
"cast_bool_to_uint",
"cast_uint_to_int"], bool
yield self.cast_direct, ["cast_int_to_char",
"cast_char_to_int"], int, 255
yield self.cast_direct, ["cast_int_to_unichar",
"cast_unichar_to_int"], int, sys.maxunicode
yield self.cast_direct, ["cast_int_to_uint", "cast_uint_to_int"], int
yield self.cast_direct, ["cast_int_to_ptr", "cast_ptr_to_int"], int
def cast_direct(self, operations, expected, max=r_uint(-1)):
need_odd_integer = False
rgenop = self.RGenOp()
sigtoken = rgenop.sigToken(FUNC)
builder, gv_fn, [gv_x] = rgenop.newgraph(sigtoken, "cast")
builder.start_writing()
for opname in operations:
if opname == "cast_int_to_ptr":
S = lltype.GcStruct('s', ('x', lltype.Signed))
ptrkind = rgenop.kindToken(lltype.Ptr(S))
gv_x = builder.genop_cast_int_to_ptr(ptrkind, gv_x)
need_odd_integer = True
else:
gv_x = builder.genop1(opname, gv_x)
builder.finish_and_return(sigtoken, gv_x)
builder.end()
fnptr = self.cast(gv_fn, 1)
for x in [0, 1, max // 6, max // 2, max - 1, max]:
x = intmask(x)
if need_odd_integer:
x |= 1
result = fnptr(x)
assert result == expected(x)
| Python |
import py, os, sys
from pypy.annotation import model as annmodel
from pypy.annotation.listdef import s_list_of_strings
from pypy.rlib.objectmodel import keepalive_until_here
from pypy.jit.timeshifter.test import test_timeshift
from pypy.translator.c.genc import CStandaloneBuilder
from pypy.rlib.unroll import unrolling_iterable
from pypy.jit.conftest import Benchmark
class CodeGeneratingTestMixin(object):
RGenOp = None
SEPLINE = 'running residual graph...\n'
def annotate_interface_functions(self):
annhelper = self.hrtyper.annhelper
RGenOp = self.RGenOp
SEPLINE = self.SEPLINE
ml_generate_code = self.ml_generate_code
argcolors = list(self.argcolors)
if hasattr(self.ll_function, 'convert_arguments'):
decoders = self.ll_function.convert_arguments
assert len(decoders) == len(argcolors)
else:
decoders = [int] * len(argcolors)
argcolors_decoders = zip(argcolors, decoders)
argcolors_decoders = unrolling_iterable(argcolors_decoders)
convert_result = getattr(self.ll_function, 'convert_result', str)
def ll_main(argv):
i = 1
mainargs = ()
residualargs = ()
if len(argv) == 2 and argv[1] == '--help':
os.write(1, 'usage: ' + argv[0])
for color, decoder in argcolors_decoders:
os.write(1, ' ')
if color == 'green':
os.write(1, decoder.__name__)
else:
os.write(1, "-const|-var "+decoder.__name__)
os.write(1, '\n')
return 0
for color, decoder in argcolors_decoders:
try:
if color == 'green':
llvalue = decoder(argv[i])
mainargs += (llvalue,)
i = i + 1
else:
if argv[i] == '-const':
is_const = True
elif argv[i] == '-var':
is_const = False
else:
raise ValueError()
i += 1
llvalue = decoder(argv[i])
mainargs += (is_const, llvalue)
residualargs += (llvalue,)
i += 1
except (ValueError, IndexError):
j = 1
while j < len(argv):
arg = argv[j]
if j == i:
os.write(1, '--> ')
else:
os.write(1, ' ')
os.write(1, arg+'\n')
j += 1
if j == i:
os.write(1, '-->\n')
return 1
rgenop = RGenOp()
generated = ml_generate_code(rgenop, *mainargs)
os.write(1, SEPLINE)
bench = Benchmark()
while 1:
try:
res = generated(*residualargs)
except Exception, e:
os.write(1, 'EXCEPTION: %s\n' % (e,))
return 0
if bench.stop():
break
os.write(1, convert_result(res) + '\n')
rgenop.check_no_open_mc()
keepalive_until_here(rgenop) # to keep the code blocks alive
return 0
annhelper.getgraph(ll_main, [s_list_of_strings],
annmodel.SomeInteger())
annhelper.finish()
t = self.rtyper.annotator.translator
t.config.translation.gc = 'boehm'
cbuilder = CStandaloneBuilder(t, ll_main, config=t.config)
cbuilder.generate_source()
cbuilder.compile()
self.main_cbuilder= cbuilder
def timeshift(self, ll_function, values, opt_consts=[], *args, **kwds):
self.ll_function = ll_function
self.timeshift_cached(ll_function, values, *args, **kwds)
mainargs = []
for i, (color, strvalue) in enumerate(zip(self.argcolors, values)):
if color == "green":
mainargs.append(strvalue)
else:
if i in opt_consts:
mainargs.append('-const')
else:
mainargs.append('-var')
mainargs.append(strvalue)
mainargs = ' '.join([str(arg) for arg in mainargs])
output = self.main_cbuilder.cmdexec(mainargs)
lines = output.splitlines()
assert lines[0] == self.SEPLINE[:-1]
if (lines[1].startswith('{') and
lines[1].endswith('iterations/second}')):
testname = sys._getframe(1).f_code.co_name
os.write(2, '{%s: %s\n' % (testname, lines.pop(1)[1:]))
assert len(lines) == 2
lastline = lines[1]
if 'check_raises' in kwds:
exc_name = kwds['check_raises'].__name__
assert lastline.startswith('EXCEPTION: ') # else DID NOT RAISE
assert exc_name in lastline
return True
if hasattr(ll_function, 'convert_result'):
return lastline
else:
return int(lastline) # assume an int
def check_insns(self, expected=None, **counts):
"Cannot check instructions in the generated assembler."
def check_flexswitches(self, expected_count):
"Cannot check instructions in the generated assembler."
| Python |
#
| Python |
from pypy.annotation import model as annmodel
from pypy.translator.translator import TranslationContext, graphof
from pypy.jit.codegen import graph2rgenop
from pypy.rpython.lltypesystem import lltype
from pypy.rpython.lltypesystem.lloperation import llop
from pypy.rlib.rarithmetic import r_uint, intmask, ovfcheck
from ctypes import cast, c_void_p, CFUNCTYPE, c_int, c_float
from pypy import conftest
class OperationTests(object):
@staticmethod
def _to_ctypes(t): #limited type support for now
if t is float:
return c_float
return c_int
def rgen(self, ll_function, argtypes, rettype=int): #XXX get rettype from annotation
t = TranslationContext()
t.buildannotator().build_types(ll_function, argtypes)
t.buildrtyper().specialize()
graph = graphof(t, ll_function)
if conftest.option.view:
graph.show()
rgenop = self.RGenOp()
self.rgenop = rgenop # keep this alive!
gv_generated = graph2rgenop.compile_graph(rgenop, graph)
ctypestypes = [OperationTests._to_ctypes(t) for t in argtypes]
fp = cast(c_void_p(gv_generated.value),
CFUNCTYPE(OperationTests._to_ctypes(rettype), *ctypestypes))
return fp
def test_arithmetic(self):
for op in ['x + y',
'x - y',
'x * y',
'x // y',
'x % y',
'x << y',
'x >> y',
'x ^ y',
'x & y',
'x | y',
'-y',
'~y',
'abs(y)',
'abs(-x)',
# and now for aliasing issues:
'x + x',
'x - x',
'x * x',
'y // y',
'y % y',
'y << y',
'y >> y',
'x ^ x',
'x & x',
'x | x',
# and some constant cases:
'17 + x',
'x + (-21)',
'(-17) - x',
'x - 21',
# '*' see below
'101 // y',
'(-983) // y',
'2121 % y',
'(-69) % y',
# '// constant' and '% constant' see below
'(-934831) << y',
'111 << y',
'y << 0',
'y << 1',
'y << 31',
'y << 32',
'y << 45',
'(-934831) >> y',
'111 >> y',
'y >> 0',
'y >> 1',
'y >> 31',
'y >> 32',
'y >> 45',
'(-123) ^ x',
'x ^ 644',
'123 & x',
'x & (-77)',
'(-145) | x',
'x | 598',
]:
fn = eval("lambda x, y: %s" % (op,))
fp = self.rgen(fn, [int, int])
print op
assert fp(40, 2) == intmask(fn(40, 2))
assert fp(25, 3) == intmask(fn(25, 3))
assert fp(149, 32) == intmask(fn(149, 32))
assert fp(149, 33) == intmask(fn(149, 33))
assert fp(149, 65) == intmask(fn(149, 65))
assert fp(149, 150) == intmask(fn(149, 150))
assert fp(-40, 2) == intmask(fn(-40, 2))
assert fp(-25, 3) == intmask(fn(-25, 3))
assert fp(-149, 32) == intmask(fn(-149, 32))
assert fp(-149, 33) == intmask(fn(-149, 33))
assert fp(-149, 65) == intmask(fn(-149, 65))
assert fp(-149, 150) == intmask(fn(-149, 150))
try:
fn(40, -2)
except ValueError:
# the shift tests with negative y are invalid
continue
else:
assert fp(40, -2) == intmask(fn(40, -2))
assert fp(25, -3) == intmask(fn(25, -3))
assert fp(149, -32) == intmask(fn(149, -32))
assert fp(149, -33) == intmask(fn(149, -33))
assert fp(149, -150) == intmask(fn(149, -150))
assert fp(-40, -2) == intmask(fn(-40, -2))
assert fp(-25, -3) == intmask(fn(-25, -3))
assert fp(-149, -32) == intmask(fn(-149, -32))
assert fp(-149, -33) == intmask(fn(-149, -33))
assert fp(-149, -150) == intmask(fn(-149, -150))
def test_comparison(self):
for op, fn in [('int(x < y)', lambda x, y: int(x < y)),
('int(x <= y)', lambda x, y: int(x <= y)),
('int(x == y)', lambda x, y: int(x == y)),
('int(x != y)', lambda x, y: int(x != y)),
('int(x > y)', lambda x, y: int(x > y)),
('int(x >= y)', lambda x, y: int(x >= y)),
]:
fp = self.rgen(fn, [int, int])
assert fp(12, 11) == fn(12, 11), op
assert fp(12, 12) == fn(12, 12), op
assert fp(12, 13) == fn(12, 13), op
assert fp(-12, 11) == fn(-12, 11), op
assert fp(-12, 12) == fn(-12, 12), op
assert fp(-12, 13) == fn(-12, 13), op
assert fp(12, -11) == fn(12, -11), op
assert fp(12, -12) == fn(12, -12), op
assert fp(12, -13) == fn(12, -13), op
assert fp(-12, -11) == fn(-12, -11), op
assert fp(-12, -12) == fn(-12, -12), op
assert fp(-12, -13) == fn(-12, -13), op
def test_unsigned_comparison(self):
for op, fn in [('int(x < y)', lambda x, y: int(x < y)),
('int(x <= y)', lambda x, y: int(x <= y)),
('int(x == y)', lambda x, y: int(x == y)),
('int(x != y)', lambda x, y: int(x != y)),
('int(x > y)', lambda x, y: int(x > y)),
('int(x >= y)', lambda x, y: int(x >= y)),
('int(12 < y)', lambda x, y: int(12 < y)),
('int(12 <= y)', lambda x, y: int(12 <= y)),
('int(12 == y)', lambda x, y: int(12 == y)),
('int(12 != y)', lambda x, y: int(12 != y)),
('int(12 > y)', lambda x, y: int(12 > y)),
('int(12 >= y)', lambda x, y: int(12 >= y)),
]:
fp = self.rgen(fn, [r_uint, r_uint])
print op
assert fp(r_uint(12), r_uint(11)) == fn(r_uint(12), r_uint(11))
assert fp(r_uint(12), r_uint(12)) == fn(r_uint(12), r_uint(12))
assert fp(r_uint(12), r_uint(13)) == fn(r_uint(12), r_uint(13))
assert fp(r_uint(-12), r_uint(11)) == fn(r_uint(-12), r_uint(11))
assert fp(r_uint(-12), r_uint(12)) == fn(r_uint(-12), r_uint(12))
assert fp(r_uint(-12), r_uint(13)) == fn(r_uint(-12), r_uint(13))
assert fp(r_uint(12), r_uint(-11)) == fn(r_uint(12), r_uint(-11))
assert fp(r_uint(12), r_uint(-12)) == fn(r_uint(12), r_uint(-12))
assert fp(r_uint(12), r_uint(-13)) == fn(r_uint(12), r_uint(-13))
assert fp(r_uint(-12), r_uint(-11)) == fn(r_uint(-12), r_uint(-11))
assert fp(r_uint(-12), r_uint(-12)) == fn(r_uint(-12), r_uint(-12))
assert fp(r_uint(-12), r_uint(-13)) == fn(r_uint(-12), r_uint(-13))
def test_char_comparison(self):
for op, fn in [('int(chr(x) < chr(y))', lambda x, y: int(chr(x) < chr(y))),
('int(chr(x) <= chr(y))', lambda x, y: int(chr(x) <= chr(y))),
('int(chr(x) == chr(y))', lambda x, y: int(chr(x) == chr(y))),
('int(chr(x) != chr(y))', lambda x, y: int(chr(x) != chr(y))),
('int(chr(x) > chr(y))', lambda x, y: int(chr(x) > chr(y))),
('int(chr(x) >= chr(y))', lambda x, y: int(chr(x) >= chr(y))),
]:
fp = self.rgen(fn, [int, int])
assert fp(12, 11) == fn(12, 11), op
assert fp(12, 12) == fn(12, 12), op
assert fp(12, 13) == fn(12, 13), op
assert fp(182, 11) == fn(182, 11), op
assert fp(182, 12) == fn(182, 12), op
assert fp(182, 13) == fn(182, 13), op
assert fp(12, 181) == fn(12, 181), op
assert fp(12, 182) == fn(12, 182), op
assert fp(12, 183) == fn(12, 183), op
assert fp(182, 181) == fn(182, 181), op
assert fp(182, 182) == fn(182, 182), op
assert fp(182, 183) == fn(182, 183), op
def test_unichar_comparison(self):
for op, fn in [('int(unichr(x) == unichr(y))', lambda x, y: int(unichr(x) == unichr(y))),
('int(unichr(x) != unichr(y))', lambda x, y: int(unichr(x) != unichr(y))),
]:
fp = self.rgen(fn, [int, int])
assert fp(12, 11) == fn(12, 11), op
assert fp(12, 12) == fn(12, 12), op
assert fp(12, 13) == fn(12, 13), op
assert fp(53182, 11) == fn(53182, 11), op
assert fp(53182, 12) == fn(53182, 12), op
assert fp(53182, 13) == fn(53182, 13), op
assert fp(12, 53181) == fn(12, 53181), op
assert fp(12, 53182) == fn(12, 53182), op
assert fp(12, 53183) == fn(12, 53183), op
assert fp(53182, 53181) == fn(53182, 53181), op
assert fp(53182, 53182) == fn(53182, 53182), op
assert fp(53182, 53183) == fn(53182, 53183), op
def test_char_array(self):
A = lltype.GcArray(lltype.Char)
def fn(n):
a = lltype.malloc(A, 5) #XXX this boils down to rgenop.genop_malloc_varsize() ?
a[4] = 'H'
a[3] = 'e'
a[2] = 'l'
a[1] = 'l'
a[0] = 'o'
return ord(a[n])
fp = self.rgen(fn, [int])
for i in range(5):
assert fp(i) == fn(i)
def test_char_varsize_array(self):
A = lltype.GcArray(lltype.Char)
def fn(n):
a = lltype.malloc(A, n)
a[4] = 'H'
a[3] = 'e'
a[2] = 'l'
a[1] = 'l'
a[0] = 'o'
return ord(a[n-1])
fp = self.rgen(fn, [int])
assert fp(5) == fn(5)
def test_unichar_array(self):
A = lltype.GcArray(lltype.UniChar)
def fn(n):
a = lltype.malloc(A, 5)
a[4] = u'H'
a[3] = u'e'
a[2] = u'l'
a[1] = u'l'
a[0] = u'o'
return ord(a[n])
fp = self.rgen(fn, [int])
for i in range(5):
assert fp(i) == fn(i)
def test_char_unichar_fields(self):
S = lltype.GcStruct('S', ('a', lltype.Char),
('b', lltype.Char),
('c', lltype.UniChar),
('d', lltype.UniChar),
('e', lltype.Signed))
def fn():
s = lltype.malloc(S)
s.a = 'A'
s.b = 'b'
s.c = unichr(0x5a6b)
s.d = unichr(0x7c8d)
s.e = -1612
return ((s.a == 'A') +
(s.b == 'b') +
(s.c == unichr(0x5a6b)) +
(s.d == unichr(0x7c8d)) +
(s.e == -1612))
fp = self.rgen(fn, [])
res = fp()
assert res == 5
def test_unsigned(self):
for op, fn in [('x + y', lambda x, y: x + y),
('x - y', lambda x, y: x - y),
('x * y', lambda x, y: x * y),
('x // y', lambda x, y: x // y),
('x % y', lambda x, y: x % y),
('x << y', lambda x, y: x << y),
('x >> y', lambda x, y: x >> y),
('x ^ y', lambda x, y: x ^ y),
('x & y', lambda x, y: x & y),
('x | y', lambda x, y: x | y),
('-y', lambda x, y: -y),
('~y', lambda x, y: ~y),
]:
fp = self.rgen(fn, [r_uint, r_uint])
print op
fn1 = lambda x, y: fn(r_uint(x), r_uint(y))
fp1 = lambda x, y: r_uint(fp(x, y))
assert fp1(40, 2) == fn1(40, 2)
assert fp1(25, 3) == fn1(25, 3)
assert fp1(40, 2) == fn1(40, 2)
assert fp1(25, 3) == fn1(25, 3)
assert fp1(149, 32) == fn1(149, 32)
assert fp1(149, 33) == fn1(149, 33)
assert fp1(149, 65) == fn1(149, 65)
assert fp1(149, 150) == fn1(149, 150)
big = r_uint(-42)
assert fp1(big, 3) == fn1(big, 3)
if op not in ('x << y', 'x >> y'):
assert fp1(38, big) == fn1(38, big)
assert fp1(big-5, big-12) == fn1(big-5, big-12)
def test_float_arithmetic(self):
for op, fn in [('x + y', lambda x, y: x + y),
('x - y', lambda x, y: x - y),
('x * y', lambda x, y: x * y),
('x / y', lambda x, y: x / y),
#('x % y', lambda x, y: x % y), #not used?
('-y', lambda x, y: -y),
#('~y', lambda x, y: ~y), #TypeError: bad operand type for unary ~
('abs(y)', lambda x, y: abs(y)),
('abs(-x)', lambda x, y: abs(-x)),
]:
fp = self.rgen(fn, [float, float], float)
assert fp(40.0, 2.0) == fn(40.0, 2.0), op
assert fp(25.125, 1.5) == fn(25.125, 1.5), op
def test_float_pow(self): #harder test for llvm
for op, fn in [('x ** y', lambda x, y: x ** y), #not supported in llvm backend
]:
fp = self.rgen(fn, [float, float], float)
assert fp(40.0, 2.0) == fn(40.0, 2.0), op
assert fp(25.125, 1.5) == fn(25.125, 1.5), op
def test_float_cast(self): #because of different rettype
for op, fn in [('bool(x)', lambda x: bool(x)),
('bool(2.0 - x)', lambda x: bool(x - 2.0)),
]:
fp = self.rgen(fn, [float], bool)
assert fp(6.0) == fn(6.0), op
assert fp(2.0) == fn(2.0), op
assert fp(0.0) == fn(0.0), op
assert fp(-2.0) == fn(-2.0), op
def test_constants_in_mul(self):
for op in ['x * y', 'y * x']:
for constant in range(-33, 34):
fn = eval("lambda x: " + op, {'y': constant})
fp = self.rgen(fn, [int], int)
for operand1 in range(-33, 34):
res = fp(operand1)
assert res == eval(op, {'x': operand1, 'y': constant})
fp = self.rgen(fn, [r_uint], r_uint)
for operand1 in range(-33, 34):
res = r_uint(fp(r_uint(operand1)))
assert res == eval(op, {'x': r_uint(operand1),
'y': r_uint(constant)})
def test_constants_in_divmod(self):
for op in ['x // y', 'x % y']:
for constant in range(1, 20) + range(-1, -20, -1):
fn = eval("lambda x: " + op, {'y': constant})
fp = self.rgen(fn, [int], int)
for operand1 in range(-32, 33):
res = fp(operand1)
assert res == eval(op, {'x': operand1, 'y': constant})
fp = self.rgen(fn, [r_uint], r_uint)
for operand1 in range(-32, 33):
res = r_uint(fp(r_uint(operand1)))
assert res == eval(op, {'x': r_uint(operand1),
'y': r_uint(constant)})
def test_ptr_comparison(self):
S = lltype.GcStruct('S')
T = lltype.GcStruct('T', ('s', lltype.Ptr(S)))
def fn():
s1 = lltype.malloc(S)
s2 = lltype.malloc(S)
return bool(s1) + bool(s2)*10 + (s1==s2)*100 + (s1!=s2)*1000
fp = self.rgen(fn, [])
assert fp() == 1011
def fn():
s1 = lltype.malloc(S)
s2 = lltype.malloc(T).s # null
return bool(s1) + bool(s2)*10 + (s1==s2)*100 + (s1!=s2)*1000
fp = self.rgen(fn, [])
assert fp() == 1001
def fn():
s1 = lltype.malloc(S)
s2 = s1
return bool(s1) + bool(s2)*10 + (s1==s2)*100 + (s1!=s2)*1000
fp = self.rgen(fn, [])
assert fp() == 111
def test_is_true(self):
for op, fn in [('bool(x)', lambda x: bool(x)),
('not x', lambda x: llop.bool_not(lltype.Bool,
bool(x))),
]:
for typ in [int, r_uint, bool]:
fp = self.rgen(fn, [typ], bool)
assert fp(typ(12)) == fn(typ(12)), (op, typ)
assert fp(typ(0)) == fn(typ(0)), (op, typ)
assert fp(typ(-1)) == fn(typ(-1)), (op, typ)
| Python |
import py, time, os
# Usage: py.test --benchmark
#
# This module provides an RPython class to use as follows:
#
# bench = Benchmark()
# while 1:
# do_something
# if bench.stop():
# break
Option = py.test.config.Option
option = py.test.config.addoptions("pypy options",
Option('--benchmark', action="store_true",
dest="benchmark", default=False,
help="give benchmarks in tests that support it"),
)
class Benchmark(object):
RUN_TIME = 2.0 # repeat the benchmarked loop for two seconds
class __metaclass__(type):
def ENABLED(cls):
return option.benchmark
ENABLED = property(ENABLED)
def __init__(self, name=''):
self.name = name
self.iterations = 0
self.million_iterations = 0
self.nextcheck = 0
self.starttime = time.time()
def stop(self):
iterations = self.iterations = self.iterations + 1
if not Benchmark.ENABLED: # only run once if not benchmarking
return True
if iterations < self.nextcheck:
return False # continue, don't call time.time() too often
now = time.time()
if now - self.starttime < self.RUN_TIME:
if iterations > 1000000: # avoid wrap-around trouble
self.million_iterations += 1
self.iterations -= 1000000
self.nextcheck = 200000
else:
self.nextcheck = iterations * 5 // 4
return False # continue looping
self.endtime = now
self.print_report()
return True
def print_report(self):
elapsed = self.endtime - self.starttime
iterations = float(self.million_iterations) * 1000000.0
iterations += self.iterations
prefix = self.name
if prefix:
prefix += ': '
result = iterations / elapsed
if result <= 1000:
s = '%f' % result
else:
s = '%d' % int(result)
i = len(s)-3
while i > 0:
s = s[:i] + "'" + s[i:]
i -= 3
os.write(1, '{%s%s iterations/second}\n' % (prefix, s))
| Python |
from pypy.annotation import model as annmodel
from pypy.annotation.pairtype import pair, pairtype
from pypy.jit.hintannotator.bookkeeper import getbookkeeper
from pypy.rpython.lltypesystem import lltype, lloperation
UNARY_OPERATIONS = """same_as hint getfield setfield getsubstruct getarraysize
cast_pointer
direct_call
indirect_call
int_is_true int_neg int_abs int_invert bool_not
int_neg_ovf int_abs_ovf
uint_is_true
cast_int_to_char
cast_int_to_uint
cast_uint_to_int
cast_char_to_int
cast_bool_to_int
cast_ptr_to_int
ptr_nonzero
ptr_iszero
is_early_constant
""".split()
BINARY_OPERATIONS = """int_add int_sub int_mul int_mod int_and int_rshift
int_lshift int_floordiv int_xor int_or
int_add_ovf int_sub_ovf int_mul_ovf int_mod_ovf
int_floordiv_ovf int_lshift_ovf
uint_add uint_sub uint_mul uint_mod uint_and
uint_lshift uint_rshift uint_floordiv
char_gt char_lt char_le char_ge char_eq char_ne
int_gt int_lt int_le int_ge int_eq int_ne
uint_gt uint_lt uint_le uint_ge uint_eq uint_ne
getarrayitem setarrayitem
getarraysubstruct
ptr_eq ptr_ne""".split()
class HintError(Exception):
pass
class OriginFlags(object):
fixed = False
read_positions = None
greenargs = False
def __init__(self, bookkeeper=None, spaceop=None):
self.bookkeeper = bookkeeper
self.spaceop = spaceop
def __repr__(self):
return '<%s %s>' % (getattr(self.spaceop, 'result', '?'),
self.reprstate())
def reprstate(self):
if self.fixed:
s = "fixed "
elif self.greenargs:
s = "green"
else:
s = ""
return "%sorigin" % (s,)
def read_fixed(self):
if self.read_positions is None:
self.read_positions = {}
self.read_positions[getbookkeeper().position_key] = True
return self.fixed
def set_fixed(self):
if not self.fixed:
self.fixed = True
if self.read_positions:
annotator = getbookkeeper().annotator
for p in self.read_positions:
annotator.reflowfromposition(p)
def record_dependencies(self, greenorigindependencies,
callreturndependencies):
deps = greenorigindependencies.setdefault(self, [])
deps.extend(self.spaceop.args)
class CallOpOriginFlags(OriginFlags):
def record_dependencies(self, greenorigindependencies,
callreturndependencies):
bk = self.bookkeeper
if self.spaceop.opname in ('direct_call', 'ts_metacall'):
args = self.spaceop.args[1:]
elif self.spaceop.opname == 'indirect_call':
args = self.spaceop.args[1:-1]
# indirect_call with a red callable must return a red
# (see test_indirect_yellow_call)
v_callable = self.spaceop.args[0]
retdeps = greenorigindependencies.setdefault(self, [])
retdeps.append(v_callable)
else:
raise AssertionError(self.spaceop.opname)
graph = self.any_called_graph
call_families = bk.tsgraph_maximal_call_families
_, repgraph, callfamily = call_families.find(graph)
# record the argument and return value dependencies
retdeps = callreturndependencies.setdefault(self, [])
for graph in callfamily.tsgraphs:
retdeps.append(graph)
for i, v in enumerate(args):
argorigin = bk.myinputargorigin(graph, i)
deps = greenorigindependencies.setdefault(argorigin, [])
deps.append(v)
class InputArgOriginFlags(OriginFlags):
def __init__(self, bookkeeper, graph, i):
OriginFlags.__init__(self, bookkeeper)
self.graph = graph
self.i = i
def getarg(self):
return self.graph.getargs()[self.i]
def __repr__(self):
return '<%s %s>' % (self.getarg(), self.reprstate())
def record_dependencies(self, greenorigindependencies,
callreturndependencies):
bk = self.bookkeeper
call_families = bk.tsgraph_maximal_call_families
_, repgraph, callfamily = call_families.find(self.graph)
# record the fact that each graph's input args should be as red
# as each other's
if self.graph is repgraph:
deps = greenorigindependencies.setdefault(self, [])
v = self.getarg()
for othergraph in callfamily.tsgraphs:
if othergraph is not repgraph:
deps.append(othergraph.getargs()[self.i])
otherorigin = bk.myinputargorigin(othergraph, self.i)
otherdeps = greenorigindependencies.setdefault(otherorigin,
[])
otherdeps.append(v)
# ____________________________________________________________
class SomeLLAbstractValue(annmodel.SomeObject):
def __init__(self, T, deepfrozen=False):
self.concretetype = T
assert self.__class__ != SomeLLAbstractValue
self.deepfrozen = deepfrozen
def is_green(self):
return False
def clone(self):
c = object.__new__(self.__class__)
c.__dict__.update(self.__dict__)
return c
class SomeLLAbstractConstant(SomeLLAbstractValue):
" color: dont know yet.. "
def __init__(self, T, origins, eager_concrete=False, myorigin=None,
deepfrozen=False):
SomeLLAbstractValue.__init__(self, T, deepfrozen)
self.origins = origins
self.eager_concrete = eager_concrete
self.myorigin = myorigin
def fmt_origins(self, origins):
counts = {}
for o in origins:
x = o.reprstate()
counts[x] = counts.get(x, 0) + 1
items = counts.items()
items.sort()
lst = []
for key, count in items:
s = ''
if count > 1:
s += '%d*' % count
s += key
lst.append(s)
return '<%s>' % (', '.join(lst),)
def fmt_myorigin(self, myorigin):
if myorigin is None:
return None
else:
return repr(myorigin)
def is_fixed(self):
for o in self.origins:
if not o.fixed:
return False
return self.concretetype is not lltype.Void
def is_green(self):
return (self.concretetype is lltype.Void or
self.is_fixed() or self.eager_concrete or
(self.myorigin is not None and self.myorigin.greenargs))
def annotationcolor(self):
"""Compute the color of the variables with this annotation
for the pygame viewer
"""
try:
if self.concretetype is lltype.Void:
return annmodel.s_ImpossibleValue.annotationcolor
elif self.eager_concrete:
return (0,100,0) # green
elif self.is_green():
return (50,140,0) # green-dark-cyan
else:
return None
except KeyError: # can occur in is_green() if annotation crashed
return (0,200,200)
annotationcolor = property(annotationcolor)
class SomeLLAbstractVariable(SomeLLAbstractValue):
" color: hopelessly red"
def __init__(self, T, deepfrozen=False):
SomeLLAbstractValue.__init__(self, T, deepfrozen)
assert T is not lltype.Void # use bookkeeper.valueoftype()
def variableoftype(TYPE, deepfrozen=False):
# the union of all annotations of the given TYPE - that's a
# SomeLLAbstractVariable, unless TYPE is Void
if TYPE is lltype.Void:
return s_void
else:
return SomeLLAbstractVariable(TYPE, deepfrozen=deepfrozen)
class SomeLLAbstractContainer(SomeLLAbstractValue):
deepfrozen = False # XXX for now
def __init__(self, contentdef):
self.contentdef = contentdef
self.concretetype = lltype.Ptr(contentdef.T)
def annotationcolor(self):
"""Compute the color of the variables with this annotation
for the pygame viewer
"""
if getattr(self.contentdef, 'degenerated', False):
return None
else:
return (0,60,160) # blue
annotationcolor = property(annotationcolor)
s_void = SomeLLAbstractConstant(lltype.Void, {})
setunion = annmodel.setunion
def setadd(set, newitem):
if newitem not in set:
set = set.copy()
set[newitem] = True
return set
def newset(set, *sets):
set = set.copy()
for s2 in sets:
set.update(s2)
return set
def reorigin(hs_v1, *deps_hs):
"""Make a copy of hs_v1 with its origins removed and replaced by myorigin().
Optionally, the origins of other annotations can also be added.
"""
if isinstance(hs_v1, SomeLLAbstractConstant):
deps_origins = [hs_dep.origins for hs_dep in deps_hs
if isinstance(hs_dep, SomeLLAbstractConstant)]
d = newset({getbookkeeper().myorigin(): True},
*deps_origins)
return SomeLLAbstractConstant(hs_v1.concretetype, d,
eager_concrete=hs_v1.eager_concrete,
deepfrozen=hs_v1.deepfrozen)
else:
return hs_v1
def originalconcretetype(hs):
if isinstance(hs, annmodel.SomeImpossibleValue):
return lltype.Void
else:
return hs.concretetype
def deepunfreeze(hs):
if hs.deepfrozen:
hs = hs.clone()
hs.deepfrozen = False
return hs
# ____________________________________________________________
# operations
class __extend__(SomeLLAbstractValue):
def same_as(hs_v1):
return hs_v1
def hint(hs_v1, hs_flags):
if hs_flags.const.get('variable', False): # only for testing purposes!!!
return SomeLLAbstractVariable(hs_v1.concretetype)
if hs_flags.const.get('forget', False):
# turn a variable to a constant
origin = getbookkeeper().myorigin()
return SomeLLAbstractConstant(hs_v1.concretetype, {origin: True})
if hs_flags.const.get('promote', False):
hs_concrete = SomeLLAbstractConstant(hs_v1.concretetype, {})
#hs_concrete.eager_concrete = True
return hs_concrete
if hs_flags.const.get('deepfreeze', False):
hs_clone = hs_v1.clone()
hs_clone.deepfrozen = True
return hs_clone
for name in ["reverse_split_queue", "global_merge_point",
"access_directly"]:
if hs_flags.const.get(name, False):
return
raise HintError("hint %s makes no sense on %r" % (hs_flags.const,
hs_v1))
def is_early_constant(hs_v1):
return SomeLLAbstractConstant(lltype.Bool, {})
def getfield(hs_v1, hs_fieldname):
S = hs_v1.concretetype.TO
FIELD_TYPE = getattr(S, hs_fieldname.const)
return variableoftype(FIELD_TYPE, hs_v1.deepfrozen)
def setfield(hs_v1, hs_fieldname, hs_value):
pass
def getsubstruct(hs_v1, hs_fieldname):
S = hs_v1.concretetype.TO
FIELD_TYPE = getattr(S, hs_fieldname.const)
return SomeLLAbstractVariable(lltype.Ptr(FIELD_TYPE), hs_v1.deepfrozen)
def cast_pointer(hs_v1):
RESTYPE = getbookkeeper().current_op_concretetype()
return SomeLLAbstractVariable(RESTYPE, hs_v1.deepfrozen)
def indirect_call(hs_v1, *args_hs):
hs_graph_list = args_hs[-1]
args_hs = args_hs[:-1]
assert hs_graph_list.is_constant()
graph_list = hs_graph_list.const
if graph_list is None:
# cannot follow indirect calls to unknown targets
return variableoftype(hs_v1.concretetype.TO.RESULT)
bookkeeper = getbookkeeper()
myorigin = bookkeeper.myorigin()
myorigin.__class__ = CallOpOriginFlags # thud
fixed = myorigin.read_fixed()
tsgraphs_accum = []
hs_res = bookkeeper.graph_family_call(graph_list, fixed, args_hs,
tsgraphs_accum, hs_v1)
myorigin.any_called_graph = tsgraphs_accum[0]
if isinstance(hs_res, SomeLLAbstractConstant):
hs_res.myorigin = myorigin
# we need to make sure that hs_res does not become temporarily less
# general as a result of calling another specialized version of the
# function
return annmodel.unionof(hs_res, bookkeeper.current_op_binding())
class __extend__(SomeLLAbstractConstant):
def same_as(hs_c1):
# this is here to prevent setup() below from adding a different
# version of same_as()
return hs_c1
def hint(hs_c1, hs_flags):
if hs_flags.const.get('concrete', False):
for o in hs_c1.origins:
o.set_fixed()
hs_concrete = reorigin(hs_c1)
hs_concrete.eager_concrete = True
return hs_concrete
if hs_flags.const.get('forget', False):
assert isinstance(hs_c1, SomeLLAbstractConstant)
return reorigin(hs_c1)
return SomeLLAbstractValue.hint(hs_c1, hs_flags)
def direct_call(hs_f1, *args_hs):
bookkeeper = getbookkeeper()
fnobj = hs_f1.const._obj
if (bookkeeper.annotator.policy.oopspec and
hasattr(fnobj._callable, 'oopspec')):
# try to handle the call as a high-level operation
try:
return handle_highlevel_operation(bookkeeper, fnobj._callable,
*args_hs)
except NotImplementedError:
pass
# don't try to annotate suggested_primitive graphs
if getattr(getattr(fnobj, '_callable', None), 'suggested_primitive', False):
return variableoftype(lltype.typeOf(fnobj).RESULT)
# normal call
if not hasattr(fnobj, 'graph'):
raise NotImplementedError("XXX call to externals or primitives")
if not bookkeeper.annotator.policy.look_inside_graph(fnobj.graph):
return cannot_follow_call(bookkeeper, fnobj.graph, args_hs,
lltype.typeOf(fnobj).RESULT)
# recursive call from the entry point to itself: ignore them and
# just hope the annotations are correct
if (bookkeeper.getdesc(fnobj.graph)._cache.get(None, None) is
bookkeeper.annotator.translator.graphs[0]):
return variableoftype(lltype.typeOf(fnobj).RESULT)
myorigin = bookkeeper.myorigin()
myorigin.__class__ = CallOpOriginFlags # thud
fixed = myorigin.read_fixed()
tsgraphs_accum = []
hs_res = bookkeeper.graph_call(fnobj.graph, fixed, args_hs,
tsgraphs_accum)
myorigin.any_called_graph = tsgraphs_accum[0]
if isinstance(hs_res, SomeLLAbstractConstant):
hs_res.myorigin = myorigin
## elif fnobj.graph.name.startswith('ll_stritem'):
## if isinstance(hs_res, SomeLLAbstractVariable):
## print hs_res
## import pdb; pdb.set_trace()
# we need to make sure that hs_res does not become temporarily less
# general as a result of calling another specialized version of the
# function
return annmodel.unionof(hs_res, bookkeeper.current_op_binding())
def getfield(hs_c1, hs_fieldname):
S = hs_c1.concretetype.TO
FIELD_TYPE = getattr(S, hs_fieldname.const)
if S._hints.get('immutable', False) or hs_c1.deepfrozen:
origin = getbookkeeper().myorigin()
d = setadd(hs_c1.origins, origin)
return SomeLLAbstractConstant(FIELD_TYPE, d,
eager_concrete=hs_c1.eager_concrete,
myorigin=origin,
deepfrozen=hs_c1.deepfrozen)
else:
return variableoftype(FIELD_TYPE)
def getsubstruct(hs_c1, hs_fieldname):
S = hs_c1.concretetype.TO
SUB_TYPE = getattr(S, hs_fieldname.const)
origin = getbookkeeper().myorigin()
d = setadd(hs_c1.origins, origin)
return SomeLLAbstractConstant(lltype.Ptr(SUB_TYPE), d,
myorigin=origin,
deepfrozen=hs_c1.deepfrozen)
def cast_pointer(hs_c1):
bk = getbookkeeper()
origin = bk.myorigin()
d = setadd(hs_c1.origins, origin)
RESTYPE = bk.current_op_concretetype()
return SomeLLAbstractConstant(RESTYPE, d,
eager_concrete = hs_c1.eager_concrete,
myorigin = origin,
deepfrozen = hs_c1.deepfrozen)
class __extend__(SomeLLAbstractContainer):
def setfield(hs_s1, hs_fieldname, hs_value):
hs_s1.contentdef.generalize_field(hs_fieldname.const, hs_value)
def getfield(hs_s1, hs_fieldname):
return hs_s1.contentdef.read_field(hs_fieldname.const)
getsubstruct = getfield
def setarrayitem(hs_a1, hs_index, hs_value):
hs_a1.contentdef.generalize_item(hs_value)
def getarraysize(hs_a1):
origin = getbookkeeper().myorigin()
return SomeLLAbstractConstant(lltype.Signed, {origin: True})
def cast_pointer(hs_s1):
TO = getbookkeeper().current_op_concretetype()
res_vstruct =hs_s1.contentdef.cast(TO)
return SomeLLAbstractContainer(res_vstruct)
def ptr_nonzero(hs_s1):
return getbookkeeper().immutablevalue(True)
def ptr_iszero(hs_s1):
return getbookkeeper().immutablevalue(False)
# ____________________________________________________________
# binary
class __extend__(pairtype(SomeLLAbstractValue, SomeLLAbstractValue)):
def getarrayitem((hs_v1, hs_v2)):
return variableoftype(hs_v1.concretetype.TO.OF, hs_v1.deepfrozen)
def setarrayitem((hs_v1, hs_v2), hs_v3):
pass
def getarraysubstruct((hs_v1, hs_v2)):
return SomeLLAbstractVariable(lltype.Ptr(hs_v1.concretetype.TO.OF),
hs_v1.deepfrozen)
def union((hs_v1, hs_v2)):
if hs_v1.deepfrozen != hs_v2.deepfrozen:
hs_v1 = deepunfreeze(hs_v1)
hs_v2 = deepunfreeze(hs_v2)
if hs_v1 == hs_v2:
return hs_v1
return pair(hs_v1, hs_v2).union_frozen_equal()
def invalid_union((hs_v1, hs_v2)):
raise annmodel.UnionError("%s %s don't mix" % (hs_v1, hs_v2))
union_frozen_equal = invalid_union
class __extend__(pairtype(SomeLLAbstractVariable, SomeLLAbstractConstant),
pairtype(SomeLLAbstractConstant, SomeLLAbstractVariable)):
def union_frozen_equal((hs_v1, hs_v2)):
assert hs_v1.concretetype == hs_v2.concretetype
if (getattr(hs_v1, 'eager_concrete', False) or
getattr(hs_v2, 'eager_concrete', False)):
pair(hs_v1, hs_v2).invalid_union()
return variableoftype(hs_v1.concretetype, hs_v1.deepfrozen)
class __extend__(pairtype(SomeLLAbstractConstant, SomeLLAbstractConstant)):
def union_frozen_equal((hs_c1, hs_c2)):
assert hs_c1.concretetype == hs_c2.concretetype
d = newset(hs_c1.origins, hs_c2.origins)
if hs_c1.myorigin is hs_c2.myorigin:
myorigin = hs_c1.myorigin
else:
myorigin = None
return SomeLLAbstractConstant(hs_c1.concretetype, d,
eager_concrete = hs_c1.eager_concrete and
hs_c2.eager_concrete,
myorigin = myorigin,
deepfrozen = hs_c1.deepfrozen)
def getarrayitem((hs_c1, hs_index)):
A = hs_c1.concretetype.TO
READ_TYPE = A.OF
if A._hints.get('immutable', False) or hs_c1.deepfrozen:
origin = getbookkeeper().myorigin()
d = newset(hs_c1.origins, hs_index.origins, {origin: True})
return SomeLLAbstractConstant(READ_TYPE, d,
eager_concrete=hs_c1.eager_concrete,
myorigin=origin,
deepfrozen=hs_c1.deepfrozen)
else:
return variableoftype(READ_TYPE)
def getarraysubstruct((hs_c1, hs_index)):
A = hs_c1.concretetype.TO
SUB_TYPE = A.OF
origin = getbookkeeper().myorigin()
d = newset(hs_c1.origins, hs_index.origins, {origin: True})
return SomeLLAbstractConstant(lltype.Ptr(SUB_TYPE), d,
myorigin=origin,
deepfrozen=hs_c1.deepfrozen)
class __extend__(pairtype(SomeLLAbstractContainer, SomeLLAbstractContainer)):
def union_frozen_equal((hs_cont1, hs_cont2)):
contentdef = hs_cont1.contentdef.union(hs_cont2.contentdef)
return SomeLLAbstractContainer(contentdef) # XXX deepfrozen?
def ptr_eq((hs_cont1, hs_cont2)):
return SomeLLAbstractConstant(lltype.Bool, {})
def ptr_ne((hs_cont1, hs_cont2)):
return SomeLLAbstractConstant(lltype.Bool, {})
class __extend__(pairtype(SomeLLAbstractContainer, SomeLLAbstractValue)):
def union_frozen_equal((hs_cont1, hs_val2)):
hs_cont1.contentdef.mark_degenerated()
assert hs_cont1.concretetype == hs_val2.concretetype
return SomeLLAbstractVariable(hs_cont1.concretetype) # XXX deepfrozen?
class __extend__(pairtype(SomeLLAbstractValue, SomeLLAbstractContainer)):
def union_frozen_equal((hs_val1, hs_cont2)):
return pair(hs_cont2, hs_val1).union_frozen_equal()
class __extend__(pairtype(SomeLLAbstractContainer, SomeLLAbstractValue),
pairtype(SomeLLAbstractValue, SomeLLAbstractContainer)):
def ptr_eq(_):
return getbookkeeper().immutablevalue(False)
def ptr_ne(_):
return getbookkeeper().immutablevalue(True)
class __extend__(pairtype(SomeLLAbstractContainer, SomeLLAbstractConstant)):
def getarrayitem((hs_a1, hs_index)):
hs_res = hs_a1.contentdef.read_item()
return reorigin(hs_res, hs_res, hs_index)
# ____________________________________________________________
def handle_highlevel_operation(bookkeeper, ll_func, *args_hs):
# parse the oopspec and fill in the arguments
operation_name, args = ll_func.oopspec.split('(', 1)
assert args.endswith(')')
args = args[:-1] + ',' # trailing comma to force tuple syntax
if args.strip() == ',':
args = '()'
argnames = ll_func.func_code.co_varnames[:len(args_hs)]
d = dict(zip(argnames, args_hs))
argtuple = eval(args, d)
args_hs = []
for hs in argtuple:
if not isinstance(hs, SomeLLAbstractValue):
hs = bookkeeper.immutablevalue(hs)
args_hs.append(hs)
# end of rather XXX'edly hackish parsing
if bookkeeper.annotator.policy.novirtualcontainer:
# "blue variables" disabled, we just return a red var all the time.
# Exception: an operation on a frozen container is constant-foldable.
RESULT = bookkeeper.current_op_concretetype()
if '.' in operation_name and args_hs[0].deepfrozen:
for hs_v in args_hs:
if not isinstance(hs_v, SomeLLAbstractConstant):
break
else:
myorigin = bookkeeper.myorigin()
d = newset({myorigin: True}, *[hs_c.origins
for hs_c in args_hs])
return SomeLLAbstractConstant(RESULT, d,
eager_concrete = False, # probably
myorigin = myorigin)
return variableoftype(RESULT)
# --- the code below is not used any more except by test_annotator.py ---
if operation_name == 'newlist':
from pypy.jit.hintannotator.vlist import oop_newlist
handler = oop_newlist
else:
# dispatch on the 'self' argument if it is virtual
hs_self = args_hs[0]
args_hs = args_hs[1:]
type_name, operation_name = operation_name.split('.')
if not isinstance(hs_self, SomeLLAbstractContainer):
raise NotImplementedError
if getattr(hs_self.contentdef, 'type_name', None) != type_name:
raise NotImplementedError
try:
handler = getattr(hs_self.contentdef, 'oop_' + operation_name)
except AttributeError:
bookkeeper.warning('missing handler: oop_%s' % (operation_name,))
raise NotImplementedError
hs_result = handler(*args_hs) # which may raise NotImplementedError
return hs_result
def cannot_follow_call(bookkeeper, graph, args_hs, RESTYPE):
# the policy prevents us from following the call
pure_call = bookkeeper.is_pure_graph(graph)
# when calling pure graphs, consider the call as an operation.
for hs in args_hs:
if not isinstance(hs, SomeLLAbstractConstant):
pure_call = False
break
if pure_call:
# if all arguments are SomeLLAbstractConstant, so can the result be.
myorigin = bookkeeper.myorigin()
d = newset({myorigin: True}, *[hs_c.origins for hs_c in args_hs])
h_res = SomeLLAbstractConstant(RESTYPE, d,
eager_concrete = False, # probably
myorigin = myorigin)
else:
h_res = variableoftype(RESTYPE)
return h_res
# ____________________________________________________________
#
# Register automatically simple operations
def var_unary(hs_v, *rest_hs):
RESTYPE = getbookkeeper().current_op_concretetype()
return SomeLLAbstractVariable(RESTYPE)
def var_binary((hs_v1, hs_v2), *rest_hs):
RESTYPE = getbookkeeper().current_op_concretetype()
return SomeLLAbstractVariable(RESTYPE)
def const_unary(llop, hs_c1):
#XXX unsure hacks
bk = getbookkeeper()
origin = bk.myorigin()
d = setadd(hs_c1.origins, origin)
RESTYPE = bk.current_op_concretetype()
hs_res = SomeLLAbstractConstant(RESTYPE, d,
eager_concrete = hs_c1.eager_concrete,
myorigin = origin)
if hs_c1.is_constant():
try:
hs_res.const = llop(RESTYPE, hs_c1.const)
except Exception: # XXX not too nice
pass
return hs_res
def const_binary(llop, (hs_c1, hs_c2)):
#XXX unsure hacks
bk = getbookkeeper()
origin = bk.myorigin()
d = newset(hs_c1.origins, hs_c2.origins, {origin: True})
RESTYPE = bk.current_op_concretetype()
hs_res = SomeLLAbstractConstant(RESTYPE, d,
eager_concrete = hs_c1.eager_concrete or
hs_c2.eager_concrete,
myorigin = origin)
if hs_c1.is_constant() and hs_c2.is_constant():
try:
hs_res.const = llop(RESTYPE, hs_c1.const, hs_c2.const)
except Exception: # XXX not too nice
pass
return hs_res
def setup(oplist, ValueCls, var_fn, ConstantCls, const_fn):
for name in oplist:
llop = getattr(lloperation.llop, name)
if not llop.sideeffects or llop.tryfold:
if name not in ValueCls.__dict__:
setattr(ValueCls, name, var_fn)
if llop.canfold or llop.tryfold:
if name not in ConstantCls.__dict__:
setattr(ConstantCls, name,
lambda s, llop=llop: const_fn(llop, s))
setup(UNARY_OPERATIONS,
SomeLLAbstractValue, var_unary,
SomeLLAbstractConstant, const_unary)
setup(BINARY_OPERATIONS,
pairtype(SomeLLAbstractValue, SomeLLAbstractValue), var_binary,
pairtype(SomeLLAbstractConstant, SomeLLAbstractConstant), const_binary)
del setup
| Python |
import py
from pypy.tool.tls import tlsobject
from pypy.tool.ansi_print import ansi_log
from pypy.rlib import jit
from pypy.objspace.flow.model import copygraph, SpaceOperation, Constant
from pypy.objspace.flow.model import Variable, Block, Link, FunctionGraph
from pypy.annotation import model as annmodel
from pypy.rpython.lltypesystem import lltype, lloperation
from pypy.tool.algo.unionfind import UnionFind
from pypy.translator.backendopt import graphanalyze
from pypy.translator.unsimplify import copyvar
TLS = tlsobject()
log = py.log.Producer("hintannotate")
py.log.setconsumer("hintannotate", ansi_log)
TIMESHIFTMAP = {Constant(jit._we_are_jitted):
Constant(1, lltype.Signed)}
class GraphDesc(object):
def __init__(self, bookkeeper, origgraph):
self.bookkeeper = bookkeeper
self.origgraph = origgraph
self._cache = {}
def specialize(self, input_args_hs, key=None, alt_name=None):
# get the specialized graph -- for now, no specialization
graph = self.cachedgraph(key, alt_name)
# modify input_args_hs in-place to change their origin
for i in range(len(input_args_hs)):
hs_v1 = input_args_hs[i]
if isinstance(hs_v1, hintmodel.SomeLLAbstractConstant):
myorigin = self.bookkeeper.myinputargorigin(graph, i)
hs_v1 = hintmodel.SomeLLAbstractConstant(
hs_v1.concretetype, {myorigin: True},
eager_concrete = hs_v1.eager_concrete,
deepfrozen = hs_v1.deepfrozen,
myorigin = myorigin)
input_args_hs[i] = hs_v1
return graph
def cachedgraph(self, key, alt_name=None):
verbose = self.bookkeeper.annotator.translator.config.translation.verbose
try:
return self._cache[key]
except KeyError:
bk = self.bookkeeper
look = bk.annotator.policy.look_inside_graph(self.origgraph)
if look and not callable(look):
# normal case
graph = copygraph(self.origgraph, varmap=TIMESHIFTMAP)
if not self._cache:
bk.nonstuboriggraphcount += 1
if verbose:
log(str(graph))
else:
log.dot()
else:
graph = self.build_callback_graph(self.origgraph, look)
if not self._cache:
bk.stuboriggraphcount += 1
if verbose:
log.stub(str(graph))
else:
log.stub.dot()
graph.tag = 'timeshifted'
try:
etrafo = bk.annotator.exceptiontransformer
except AttributeError:
pass
else:
# except transform the copied graph before its hint-annotation
etrafo.create_exception_handling(graph, always_exc_clear=True)
if alt_name is not None:
graph.name = alt_name
self._cache[key] = graph
self.bookkeeper.annotator.translator.graphs.append(graph)
return graph
def build_callback_graph(self, graph, metadesccls=False):
args_v = [copyvar(None, v) for v in graph.getargs()]
v_res = copyvar(None, graph.getreturnvar())
rtyper = self.bookkeeper.annotator.base_translator.rtyper # fish
fnptr = rtyper.getcallable(graph)
v_ptr = Constant(fnptr, lltype.typeOf(fnptr))
newstartblock = Block(args_v)
if metadesccls:
v_metadesccls = Constant(metadesccls, lltype.Void)
args_v = [v_metadesccls] + args_v
opname = 'ts_metacall'
suffix = 'ts_metacall'
else:
opname = 'direct_call'
suffix = 'ts_stub'
newstartblock.operations.append(
SpaceOperation(opname, [v_ptr] + args_v, v_res))
newgraph = FunctionGraph('%s_%s' % (graph.name, suffix), newstartblock)
newgraph.getreturnvar().concretetype = v_res.concretetype
newstartblock.closeblock(Link([v_res], newgraph.returnblock))
return newgraph
class TsGraphCallFamily:
def __init__(self, tsgraph):
self.tsgraphs = {tsgraph: True}
def update(self, other):
self.tsgraphs.update(other.tsgraphs)
class ImpurityAnalyzer(graphanalyze.GraphAnalyzer):
"""An impure graph has side-effects or depends on state that
can be mutated. A pure graph always gives the same answer for
given arguments."""
def analyze_exceptblock(self, block, seen=None):
return True # for now, we simplify and say that functions
# raising exceptions cannot be pure
def operation_is_true(self, op):
operation = lloperation.LL_OPERATIONS[op.opname]
ARGTYPES = [v.concretetype for v in op.args]
return not operation.is_pure(*ARGTYPES)
def analyze_direct_call(self, graph, seen=None):
try:
func = graph.func
if getattr(func, "_pure_function_", False):
return False
except AttributeError:
pass
return graphanalyze.GraphAnalyzer.analyze_direct_call(self, graph, seen)
class HintBookkeeper(object):
def __init__(self, hannotator):
self.pending_specializations = []
self.originflags = {}
self.virtual_containers = {}
self.descs = {}
self.tsgraph_maximal_call_families = UnionFind(TsGraphCallFamily)
self.annotator = hannotator
self.tsgraphsigs = {}
self.nonstuboriggraphcount = 0
self.stuboriggraphcount = 0
if hannotator is not None: # for tests
t = hannotator.base_translator
self.impurity_analyzer = ImpurityAnalyzer(t)
# circular imports hack
global hintmodel
from pypy.jit.hintannotator import model as hintmodel
def getdesc(self, graph):
try:
return self.descs[graph]
except KeyError:
self.descs[graph] = desc = GraphDesc(self, graph)
return desc
def enter(self, position_key):
"""Start of an operation.
The operation is uniquely identified by the given key."""
res = getattr(self, 'position_key', None)
self.position_key = position_key
TLS.bookkeeper = self
return res
def leave(self, old=None):
"""End of an operation."""
if old is None:
del TLS.bookkeeper
del self.position_key
else:
self.position_key = old
def myinputargorigin(self, graph, i):
try:
origin = self.originflags[graph, i]
except KeyError:
origin = hintmodel.InputArgOriginFlags(self, graph, i)
self.originflags[graph, i] = origin
return origin
def myorigin(self):
try:
origin = self.originflags[self.position_key]
except KeyError:
assert len(self.position_key) == 3
graph, block, i = self.position_key
spaceop = block.operations[i]
spaceop = SpaceOperation(spaceop.opname,
list(spaceop.args),
spaceop.result)
origin = hintmodel.OriginFlags(self, spaceop)
self.originflags[self.position_key] = origin
return origin
def compute_at_fixpoint(self):
binding = self.annotator.binding
# for the entry point, we need to remove the 'myorigin' of
# the input arguments (otherwise they will always be green,
# as there is no call to the entry point to make them red)
tsgraph = self.annotator.translator.graphs[0]
for v in tsgraph.getargs():
hs_arg = binding(v)
if isinstance(hs_arg, hintmodel.SomeLLAbstractConstant):
hs_arg.myorigin = None
# for convenience, force the return var to be red too, as
# the timeshifter doesn't support anything else
if self.annotator.policy.entrypoint_returns_red:
v = tsgraph.getreturnvar()
hs_red = hintmodel.variableoftype(v.concretetype)
self.annotator.setbinding(v, hs_red)
# propagate the green/red constraints
log.event("Computing maximal green set...")
greenorigindependencies = {}
callreturndependencies = {}
for origin in self.originflags.values():
origin.greenargs = True
origin.record_dependencies(greenorigindependencies,
callreturndependencies)
while True:
progress = False
# check all calls to see if they are green calls or not
for origin, graphs in callreturndependencies.items():
if self.is_green_call(origin.spaceop):
pass # green call => don't force spaceop.result to red
else:
# non-green calls: replace the dependency with a regular
# dependency from graph.getreturnvar() to spaceop.result
del callreturndependencies[origin]
retdeps = greenorigindependencies.setdefault(origin, [])
for graph in graphs:
retdeps.append(graph.getreturnvar())
# propagate normal dependencies
for origin, deps in greenorigindependencies.items():
for v in deps:
if not binding(v).is_green():
# not green => force the origin to be red too
origin.greenargs = False
del greenorigindependencies[origin]
progress = True
break
if not progress:
break
for callfamily in self.tsgraph_maximal_call_families.infos():
if len(callfamily.tsgraphs) > 1:
# if at least one graph in the family returns a red,
# we force a red as the return of all of them
returns_red = False
for graph in callfamily.tsgraphs:
if not binding(graph.getreturnvar()).is_green():
returns_red = True
if returns_red:
for graph in callfamily.tsgraphs:
v = graph.getreturnvar()
hs_red = hintmodel.variableoftype(v.concretetype)
self.annotator.setbinding(v, hs_red)
# compute and cache the signature of the graphs before they are
# modified by further code
ha = self.annotator
for tsgraph in ha.translator.graphs:
sig_hs = ([ha.binding(v) for v in tsgraph.getargs()],
ha.binding(tsgraph.getreturnvar()))
self.tsgraphsigs[tsgraph] = sig_hs
def is_pure_graph(self, graph):
impure = self.impurity_analyzer.analyze_direct_call(graph)
return not impure
def is_green_call(self, callop):
"Is the given call operation completely computable at compile-time?"
for v in callop.args:
hs_arg = self.annotator.binding(v)
if not hs_arg.is_green():
return False
# all-green arguments. Note that we can return True even if the
# result appears to be red; it's not a real red result then.
impure = self.impurity_analyzer.analyze(callop)
return not impure
def immutableconstant(self, const):
res = hintmodel.SomeLLAbstractConstant(const.concretetype, {})
res.const = const.value
# we want null pointers to be deepfrozen!
if isinstance(const.concretetype, lltype.Ptr):
if not const.value:
res.deepfrozen = True
return res
def immutablevalue(self, value):
return self.immutableconstant(Constant(value, lltype.typeOf(value)))
def current_op_concretetype(self):
_, block, i = self.position_key
op = block.operations[i]
return op.result.concretetype
def current_op_binding(self):
_, block, i = self.position_key
op = block.operations[i]
hs_res = self.annotator.binding(op.result, annmodel.s_ImpossibleValue)
return hs_res
def getvirtualcontainerdef(self, TYPE, constructor=None):
try:
res = self.virtual_containers[self.position_key]
assert res.T == TYPE
except KeyError:
if constructor is None:
from pypy.jit.hintannotator.container import virtualcontainerdef
constructor = virtualcontainerdef
res = constructor(self, TYPE)
self.virtual_containers[self.position_key] = res
return res
def warning(self, msg):
return self.annotator.warning(msg)
def specialization_key(self, fixed, args_hs):
if fixed:
return 'fixed'
else:
key = []
specialize = False
for i, arg_hs in enumerate(args_hs):
if isinstance(arg_hs, hintmodel.SomeLLAbstractVariable):
key.append('v')
specialize = True
continue
if (isinstance(arg_hs, hintmodel.SomeLLAbstractConstant)
and arg_hs.eager_concrete):
key.append('E')
specialize = True
else:
key.append('x')
if (isinstance(arg_hs, hintmodel.SomeLLAbstractConstant)
and arg_hs.deepfrozen):
key.append('D')
specialize = True
else:
key.append('x')
if specialize:
return ''.join(key)
else:
return None
def get_graph_by_key(self, graph, specialization_key):
desc = self.getdesc(graph)
return desc._cache[specialization_key]
def get_graph_for_call(self, graph, fixed, args_hs):
# this can modify args_hs in-place!
key = self.specialization_key(fixed, args_hs)
if key is None:
alt_name = None
else:
alt_name = graph.name + '_H'+key
desc = self.getdesc(graph)
graph = desc.specialize(args_hs, key=key, alt_name=alt_name)
return graph
def graph_call(self, graph, fixed, args_hs,
tsgraph_accum=None, hs_callable=None):
input_args_hs = list(args_hs)
graph = self.get_graph_for_call(graph, fixed, input_args_hs)
if tsgraph_accum is not None:
tsgraph_accum.append(graph) # save this if the caller cares
# propagate fixing of arguments in the function to the caller
for inp_arg_hs, arg_hs in zip(input_args_hs, args_hs):
if isinstance(arg_hs, hintmodel.SomeLLAbstractConstant):
assert len(inp_arg_hs.origins) == 1
[o] = inp_arg_hs.origins.keys()
if o.read_fixed():
for o in arg_hs.origins:
o.set_fixed()
hs_res = self.annotator.recursivecall(graph,
self.position_key,
input_args_hs)
# look on which input args the hs_res result depends on
if isinstance(hs_res, hintmodel.SomeLLAbstractConstant):
if (hs_callable is not None and
not isinstance(hs_callable, hintmodel.SomeLLAbstractConstant)):
hs_res = hintmodel.variableoftype(hs_res.concretetype,
hs_res.deepfrozen)
else:
deps_hs = []
for hs_inputarg, hs_arg in zip(input_args_hs, args_hs):
if isinstance(hs_inputarg,
hintmodel.SomeLLAbstractConstant):
assert len(hs_inputarg.origins) == 1
[o] = hs_inputarg.origins.keys()
if o in hs_res.origins:
deps_hs.append(hs_arg)
if fixed:
deps_hs.append(hs_res)
hs_res = hintmodel.reorigin(hs_res, hs_callable, *deps_hs)
return hs_res
def graph_family_call(self, graph_list, fixed, args_hs,
tsgraphs_accum=None, hs_callable=None):
if tsgraphs_accum is None:
tsgraphs = []
else:
tsgraphs = tsgraphs_accum
results_hs = []
for graph in graph_list:
results_hs.append(self.graph_call(graph, fixed, args_hs,
tsgraphs, hs_callable))
# put the tsgraphs in the same call family
call_families = self.tsgraph_maximal_call_families
_, rep, callfamily = call_families.find(tsgraphs[0])
for tsgraph in tsgraphs[1:]:
_, rep, callfamily = call_families.union(rep, tsgraph)
return annmodel.unionof(*results_hs)
# get current bookkeeper
def getbookkeeper():
"""Get the current Bookkeeper.
Only works during the analysis of an operation."""
try:
return TLS.bookkeeper
except AttributeError:
return None
| Python |
from pypy.annotation import policy
from pypy.annotation.specialize import getuniquenondirectgraph
from pypy.translator.translator import graphof
class HintAnnotatorPolicy(policy.AnnotatorPolicy):
novirtualcontainer = False
oopspec = False
entrypoint_returns_red = True
def __init__(self, novirtualcontainer = None,
oopspec = None,
entrypoint_returns_red = None):
if novirtualcontainer is not None:
self.novirtualcontainer = novirtualcontainer
if oopspec is not None:
self.oopspec = oopspec
if entrypoint_returns_red is not None:
self.entrypoint_returns_red = entrypoint_returns_red
def look_inside_graph(self, graph):
return True
class StopAtXPolicy(HintAnnotatorPolicy):
"""Useful for tests."""
novirtualcontainer = True
oopspec = True
def __init__(self, *funcs):
self.funcs = funcs
def look_inside_graph(self, graph):
try:
if graph.func in self.funcs:
return False
except AttributeError:
pass
return True
class ManualGraphPolicy(HintAnnotatorPolicy):
novirtualcontainer = True
oopspec = True
opaquepurefunctions = False
def seetranslator(self, t):
if self.opaquepurefunctions:
from pypy.jit.hintannotator.bookkeeper import ImpurityAnalyzer
self.analyzer = ImpurityAnalyzer(t)
self.translator = t
self.bookkeeper = t.annotator.bookkeeper
self.timeshift_graphs = {}
portal = getattr(self.PORTAL, 'im_func', self.PORTAL)
portal_graph = graphof(t, portal)
self.fill_timeshift_graphs(portal_graph)
def look_inside_graph(self, graph):
if graph in self.timeshift_graphs:
return self.timeshift_graphs[graph]
# don't look into pure functions
if (self.opaquepurefunctions and
not self.analyzer.analyze_direct_call(graph)):
return False
try:
func = graph.func
except AttributeError:
return True
if hasattr(func, '_look_inside_me_'):
return func._look_inside_me_
# explicitly pure functions are always opaque
if getattr(func, '_pure_function_', False):
return False
mod = func.__module__ or '?'
return self.look_inside_graph_of_module(graph, func, mod)
def look_inside_graph_of_module(self, graph, func, mod):
return True
def fill_timeshift_graphs(self, portal_graph):
# subclasses should have their own
pass
def _graph(self, func):
func = getattr(func, 'im_func', func)
desc = self.bookkeeper.getdesc(func)
return getuniquenondirectgraph(desc)
def seefunc(self, fromfunc, *tofuncs):
targetgraphs = {}
for tofunc in tofuncs:
targetgraphs[self._graph(tofunc)] = True
graphs = graphs_on_the_path_to(self.translator, self._graph(fromfunc),
targetgraphs)
for graph in graphs:
self.timeshift_graphs[graph] = True
def seepath(self, *path):
for i in range(1, len(path)):
self.seefunc(path[i-1], path[i])
def seegraph(self, func, look=True):
graph = self._graph(func)
self.timeshift_graphs[graph] = look
def enumerate_reachable_graphs(translator, startgraph):
from pypy.translator.backendopt.support import find_calls_from
pending = [(startgraph, None)]
yield pending[0]
seen = {startgraph: True}
while pending:
yield None # hack: a separator meaning "length increases now"
nextlengthlist = []
nextseen = {}
for node in pending:
head, tail = node
for block, callee in find_calls_from(translator, head):
if callee not in seen:
newnode = callee, node
yield newnode
nextlengthlist.append(newnode)
nextseen[callee] = True
pending = nextlengthlist
seen.update(nextseen)
yield None
def graphs_on_the_path_to(translator, startgraph, targetgraphs):
targetgraphs = targetgraphs.copy()
result = {}
found = {}
for node in enumerate_reachable_graphs(translator, startgraph):
if node is None: # hack: a separator meaning "length increases now"
for graph in found:
del targetgraphs[graph]
found.clear()
if not targetgraphs:
return result
elif node[0] in targetgraphs:
found[node[0]] = True
while node is not None:
head, tail = node
result[head] = True
node = tail
raise Exception("did not reach all targets:\nmissing %r" % (
targetgraphs.keys(),))
| Python |
import weakref, itertools
from pypy.annotation.listdef import ListItem
from pypy.annotation import model as annmodel
from pypy.jit.hintannotator import model as hintmodel
from pypy.rpython.lltypesystem import lltype
class AbstractContainerDef(object):
__counter = itertools.count()
__cache = {}
def __init__(self, bookkeeper, TYPE):
self.T = TYPE
self.bookkeeper = bookkeeper
# if a virtual container "escapes" control in some way, e.g. by
# being unified with a SomeLLAbstractVariable, the ContainerDef
# becomes 'degenerated'. For the hintrtyper, degenerated
# SomeLLAbstractContainers should roughly be equivalent to
# SomeLLAbstractVariables.
self.degenerated = False
# hack to try to produce a repr that shows identifications
key = (self.__class__, TYPE)
weakdict = AbstractContainerDef.__cache.setdefault(key,
weakref.WeakValueDictionary())
weakdict[AbstractContainerDef.__counter.next()] = self
def __repr__(self):
items = AbstractContainerDef.__cache[self.__class__, self.T].items()
keys = [key for key, containerdef in items if containerdef.same_as(self)]
tag = min(keys)
if self.degenerated:
degen = 'degen '
else:
degen = ''
return "<%s%s #%d>" % (degen, self.__class__.__name__, tag)
# ____________________________________________________________
def virtualcontainerdef(bookkeeper, T, vparent=None, vparentindex=0):
"""Build and return a VirtualXxxDef() corresponding to a
freshly allocated virtual container.
"""
if isinstance(T, lltype.Struct):
return VirtualStructDef(bookkeeper, T, vparent, vparentindex)
elif isinstance(T, lltype.Array):
return VirtualArrayDef(bookkeeper, T, vparent)
raise TypeError("unsupported container type %r" % (T,))
def make_item_annotation(bookkeeper, TYPE, vparent=None, vparentindex=0):
if isinstance(TYPE, lltype.ContainerType):
vdef = virtualcontainerdef(bookkeeper, TYPE, vparent, vparentindex)
return hintmodel.SomeLLAbstractContainer(vdef)
elif isinstance(TYPE, lltype.Ptr):
return annmodel.s_ImpossibleValue
else:
hs_c = hintmodel.SomeLLAbstractConstant(TYPE, {})
hs_c.const = TYPE._defl()
return hs_c
def degenerate_item(item, ITEM_TYPE):
if isinstance(ITEM_TYPE, lltype.ContainerType):
hs = item.s_value
assert isinstance(hs, hintmodel.SomeLLAbstractContainer)
hs.contentdef.mark_degenerated()
else:
item.generalize(hintmodel.SomeLLAbstractVariable(ITEM_TYPE))
# ____________________________________________________________
class FieldValue(ListItem):
def __init__(self, bookkeeper, name, hs_value):
ListItem.__init__(self, bookkeeper, hs_value)
self.name = name
def patch(self):
for vstructdef in self.itemof:
vstructdef.fields[self.name] = self
class VirtualStructDef(AbstractContainerDef):
def __init__(self, bookkeeper, TYPE, vparent=None, vparentindex=0):
AbstractContainerDef.__init__(self, bookkeeper, TYPE)
self.fields = {}
self.names = TYPE._names
for index, name in enumerate(self.names):
FIELD_TYPE = self.fieldtype(name)
hs = make_item_annotation(bookkeeper, FIELD_TYPE, vparent=self, vparentindex=index)
fv = self.fields[name] = FieldValue(bookkeeper, name, hs)
fv.itemof[self] = True
self.vparent = vparent
self.vparentindex = vparentindex
def cast(self, TO):
down_or_up = lltype.castable(TO,
lltype.Ptr(self.T))
# the following works because if a structure is virtual, then
# all its parent and inlined substructures are also virtual
vstruct = self
if down_or_up >= 0:
for n in range(down_or_up):
vstruct = vstruct.read_field(vstruct.T._names[0]).contentdef
else:
for n in range(-down_or_up):
vstruct = vstruct.vparent
assert vstruct
return vstruct
def fieldtype(self, name):
return getattr(self.T, name)
def read_field(self, name):
fv = self.fields[name]
fv.read_locations[self.bookkeeper.position_key] = True
return fv.s_value
def same_as(self, other):
return self.fields == other.fields
def union(self, other):
assert self.T == other.T
for name in self.names:
self.fields[name].merge(other.fields[name])
incompatible = False
if self.vparent is not None:
if other.vparent is not None:
if self.vparent.T != other.vparent.T or self.vparentindex != other.vparentindex:
incompatible = True
else:
self.vparent.union(other.vparent)
else:
incompatible = True
elif other.vparent is not None:
incompatible = True
if incompatible or self.degenerated or other.degenerated:
self.mark_degenerated()
other.mark_degenerated()
return self
def generalize_field(self, name, hs_value):
self.fields[name].generalize(hs_value)
def mark_degenerated(self):
if self.degenerated:
return
self.degenerated = True
for name in self.names:
degenerate_item(self.fields[name], self.fieldtype(name))
if self.vparent is not None:
self.vparent.mark_degenerated()
# ____________________________________________________________
class ArrayItem(ListItem):
def patch(self):
for varraydef in self.itemof:
varraydef.arrayitem = self
# this may need to really be used only for fixed size cases
class VirtualArrayDef(AbstractContainerDef):
def __init__(self, bookkeeper, TYPE, vparent=None):
AbstractContainerDef.__init__(self, bookkeeper, TYPE)
hs = make_item_annotation(bookkeeper, TYPE.OF, vparent=self) # xxx vparentindex?
self.arrayitem = ArrayItem(bookkeeper, hs)
self.arrayitem.itemof[self] = True
self.vparent = vparent
def read_item(self):
self.arrayitem.read_locations[self.bookkeeper.position_key] = True
return self.arrayitem.s_value
def same_as(self, other):
return self.arrayitem is other.arrayitem
def union(self, other):
assert self.T == other.T
self.arrayitem.merge(other.arrayitem)
return self
def generalize_item(self, hs_value):
self.arrayitem.generalize(hs_value)
def mark_degenerated(self):
self.degenerated = True
degenerate_item(self.arrayitem, self.T.OF)
| Python |
from pypy.annotation import model as annmodel
from pypy.annotation.annrpython import RPythonAnnotator, BlockedInference
from pypy.annotation.annrpython import raise_nicer_exception
from pypy.objspace.flow.model import Variable
from pypy.jit.hintannotator import model as hintmodel
from pypy.jit.hintannotator.bookkeeper import HintBookkeeper
from pypy.jit.hintannotator.policy import HintAnnotatorPolicy
from pypy.rpython.lltypesystem import lltype
class HintAnnotator(RPythonAnnotator):
def __init__(self, translator=None, base_translator=None, policy=None):
if policy is None:
policy = HintAnnotatorPolicy()
self.base_translator = base_translator
assert base_translator is not None # None not supported any more
bookkeeper = HintBookkeeper(self)
RPythonAnnotator.__init__(self, translator, policy=policy,
bookkeeper=bookkeeper)
self.exceptiontransformer = base_translator.getexceptiontransformer()
def build_types(self, origgraph, input_args_hs):
desc = self.bookkeeper.getdesc(origgraph)
flowgraph = desc.specialize(input_args_hs)
return self.build_graph_types(flowgraph, input_args_hs)
def getuserclassdefinitions(self):
return []
def consider_op_malloc(self, hs_TYPE):
TYPE = hs_TYPE.const
if self.policy.novirtualcontainer:
return hintmodel.SomeLLAbstractVariable(lltype.Ptr(TYPE))
else:
vstructdef = self.bookkeeper.getvirtualcontainerdef(TYPE)
return hintmodel.SomeLLAbstractContainer(vstructdef)
consider_op_zero_malloc = consider_op_malloc
def consider_op_malloc_varsize(self, hs_TYPE, hs_length):
TYPE = hs_TYPE.const
if self.policy.novirtualcontainer:
return hintmodel.SomeLLAbstractVariable(lltype.Ptr(TYPE))
else:
vcontainerdef = self.bookkeeper.getvirtualcontainerdef(TYPE)
return hintmodel.SomeLLAbstractContainer(vcontainerdef)
consider_op_zero_malloc_varsize = consider_op_malloc_varsize
def consider_op_zero_gc_pointers_inside(self, hs_v):
pass
def consider_op_keepalive(self, hs_v):
pass
def consider_op_debug_log_exc(self, hs_v):
pass
def consider_op_debug_assert(self, hs_v, *args_hs):
pass
def consider_op_resume_point(self, hs_v, *args_hs):
pass
def consider_op_ts_metacall(self, hs_f1, hs_metadesccls, *args_hs):
bookkeeper = self.bookkeeper
fnobj = hs_f1.const._obj
return hintmodel.cannot_follow_call(bookkeeper, fnobj.graph, args_hs,
lltype.typeOf(fnobj).RESULT)
def simplify(self):
RPythonAnnotator.simplify(self, extra_passes=[])
def noreturnvalue(self, op):
assert op.result.concretetype is lltype.Void, (
"missing annotation for the return variable of %s" % (op,))
return hintmodel.s_void
HintAnnotator._registeroperations(hintmodel)
| Python |
from pypy.annotation.listdef import ListItem
from pypy.jit.hintannotator.model import SomeLLAbstractConstant
from pypy.jit.hintannotator.model import SomeLLAbstractContainer, reorigin
from pypy.jit.hintannotator.bookkeeper import getbookkeeper
from pypy.jit.hintannotator.container import AbstractContainerDef
from pypy.jit.hintannotator.container import make_item_annotation
from pypy.rpython.lltypesystem import lltype
class VirtualListDef(AbstractContainerDef):
type_name = 'list'
def __init__(self, bookkeeper, LIST):
AbstractContainerDef.__init__(self, bookkeeper, LIST)
hs = make_item_annotation(bookkeeper, LIST.ITEM)
self.listitem = ListItem(bookkeeper, hs)
self.listitem.itemof[self] = True
def read_item(self):
self.listitem.read_locations[self.bookkeeper.position_key] = True
return self.listitem.s_value
def same_as(self, other):
return self.listitem == other.listitem
def union(self, other):
assert self.T == other.T
self.listitem.merge(other.listitem)
return self
def generalize_item(self, hs_value):
assert hs_value.concretetype == self.T.ITEM
self.listitem.generalize(hs_value)
# ________________________________________
# OOP high-level operations
def oop_len(self):
origin = getbookkeeper().myorigin()
return SomeLLAbstractConstant(lltype.Signed, {origin: True})
def oop_nonzero(self):
origin = getbookkeeper().myorigin()
return SomeLLAbstractConstant(lltype.Bool, {origin: True})
def oop_getitem(self, hs_index):
assert hs_index.concretetype == lltype.Signed
hs_res = self.read_item()
return reorigin(hs_res, hs_res, hs_index)
def oop_setitem(self, hs_index, hs_value):
assert hs_index.concretetype == lltype.Signed
self.generalize_item(hs_value)
def oop_delitem(self, hs_index):
assert hs_index.concretetype == lltype.Signed
def oop_append(self, hs_value):
self.generalize_item(hs_value)
def oop_insert(self, hs_index, hs_value):
assert hs_index.concretetype == lltype.Signed
self.generalize_item(hs_value)
def oop_pop(self, hs_index=None):
assert hs_index is None or hs_index.concretetype == lltype.Signed
hs_res = self.read_item()
return reorigin(hs_res, hs_res, hs_index)
def oop_reverse(self):
pass
def oop_copy(self):
bk = self.bookkeeper
vlistdef = bk.getvirtualcontainerdef(self.T, VirtualListDef)
vlistdef.generalize_item(self.read_item())
return SomeLLAbstractContainer(vlistdef)
def oop_concat(self, hs_other):
assert isinstance(hs_other, SomeLLAbstractContainer) # for now
assert hs_other.contentdef.T == self.T
return self.oop_copy()
# ____________________________________________________________
def oop_newlist(hs_numitems, hs_item=None):
bk = getbookkeeper()
LIST = bk.current_op_concretetype().TO
vlistdef = bk.getvirtualcontainerdef(LIST, VirtualListDef)
return SomeLLAbstractContainer(vlistdef)
| Python |
from pypy.rpython.lltypesystem import lltype, llmemory, lloperation
from pypy.rpython.annlowlevel import cachedtype
from pypy.rpython.annlowlevel import cast_base_ptr_to_instance
from pypy.rpython.annlowlevel import cast_instance_to_base_ptr
from pypy.rlib.unroll import unrolling_iterable
debug_print = lloperation.llop.debug_print
debug_pdb = lloperation.llop.debug_pdb
def define_touch_update(TOPPTR, redirected_fielddescs, access_touched):
redirected_fielddescs = unrolling_iterable(redirected_fielddescs)
def touch_update(strucref):
struc = lltype.cast_opaque_ptr(TOPPTR, strucref)
vable_rti = struc.vable_rti
vable_rti = cast_base_ptr_to_instance(VirtualizableRTI, vable_rti)
vable_rti.touch(struc.vable_base)
vable_base = struc.vable_base
j = -1
for fielddesc, _ in redirected_fielddescs:
j += 1
if fielddesc.canbevirtual and fielddesc.gcref:
if vable_rti.is_field_virtual(vable_base, j):
continue
v = vable_rti.read_field(fielddesc, vable_base, j)
tgt = lltype.cast_pointer(fielddesc.PTRTYPE, struc)
setattr(tgt, fielddesc.fieldname, v)
ACCESSPTR = TOPPTR.TO.vable_access
struc.vable_access = lltype.cast_pointer(ACCESSPTR, access_touched)
return touch_update
def define_getset_field_ptrs(fielddesc, j):
def set_field_touched(struc, value):
T = fielddesc.RESTYPE
if fielddesc.canbevirtual and fielddesc.gcref:
vable_rti = struc.vable_rti
vable_rti = cast_base_ptr_to_instance(VirtualizableRTI, vable_rti)
vable_rti.touched_ptr_field(struc.vable_base, j)
struc = lltype.cast_pointer(fielddesc.PTRTYPE, struc)
setattr(struc, fielddesc.fieldname, value)
def get_field_touched(struc):
T = fielddesc.RESTYPE
tgt = lltype.cast_pointer(fielddesc.PTRTYPE, struc)
if fielddesc.canbevirtual and fielddesc.gcref:
vable_rti = struc.vable_rti
vable_rti = cast_base_ptr_to_instance(VirtualizableRTI, vable_rti)
vable_base = struc.vable_base
if vable_rti.is_field_virtual(vable_base, j):
# this will force
s = vable_rti.read_field(fielddesc, vable_base, j)
setattr(tgt, fielddesc.fieldname, s)
return s
return getattr(tgt, fielddesc.fieldname)
def set_field_untouched(struc, value):
vable_rti = struc.vable_rti
vable_rti = cast_base_ptr_to_instance(VirtualizableRTI, vable_rti)
vable_rti.touch_update(lltype.cast_opaque_ptr(llmemory.GCREF, struc))
set_field_touched(struc, value)
def get_field_untouched(struc):
vable_rti = struc.vable_rti
vable_rti = cast_base_ptr_to_instance(VirtualizableRTI, vable_rti)
return vable_rti.read_field(fielddesc, struc.vable_base, j)
return ((get_field_untouched, set_field_untouched),
(get_field_touched, set_field_touched))
class RTI(object):
_attrs_ = 'rgenop varindexes vrtis bitmask'.split()
def __init__(self, rgenop, bitmask):
self.rgenop = rgenop
self.varindexes = []
self.vrtis = []
self.bitmask = bitmask
def _read_field(self, vablerti, fielddesc, base, index):
T = fielddesc.RESTYPE
frameindex = self.varindexes[index]
if frameindex >= 0:
return vablerti.read_frame_var(T, base, frameindex)
index = -frameindex-1
assert index >= 0
vrti = self.vrtis[index]
assert fielddesc.canbevirtual
assert fielddesc.gcref
assert isinstance(vrti, VirtualRTI)
return vrti._get_forced(vablerti, fielddesc, base)
_read_field._annspecialcase_ = "specialize:arg(2)"
class VirtualizableRTI(RTI):
_attrs_ = "frameinfo touch_update shape_place".split()
def is_field_virtual(self, base, index):
frameindex = self.varindexes[index]
if frameindex >= 0:
return False
index = -frameindex-1
assert index >= 0
vrti = self.vrtis[index]
assert isinstance(vrti, VirtualRTI)
return vrti._is_virtual(self.get_shape(base))
def read_frame_var(self, T, base, frameindex):
return self.rgenop.read_frame_var(T, base, self.frameinfo, frameindex)
read_frame_var._annspecialcase_ = "specialize:arg(1)"
def read_field(self, fielddesc, base, index):
return self._read_field(self, fielddesc, base, index)
read_field._annspecialcase_ = "specialize:arg(1)"
def touch(self, base):
self.set_shape_bits(base, self.bitmask)
def touched_ptr_field(self, base, index):
frameindex = self.varindexes[index]
if frameindex >= 0:
return
posshift = -frameindex
assert posshift > 0
self.set_shape_bits(base, self.bitmask << posshift)
def get_shape(self, base):
return self.rgenop.read_frame_place(lltype.Signed, base,
self.shape_place)
def set_shape(self, base, shapemask):
return self.rgenop.write_frame_place(lltype.Signed, base,
self.shape_place, shapemask)
def set_shape_bits(self, base, bitmask):
self.set_shape(base, bitmask | self.get_shape(base))
class VirtualRTI(RTI):
_attrs_ = "forced_place devirtualize".split()
def _get_forced(self, vablerti, elemdesc, base):
T = elemdesc.RESTYPE
assert isinstance(T, lltype.Ptr)
shapemask = vablerti.get_shape(base)
bitmask = self.bitmask
if bitmask & shapemask:
return self.rgenop.read_frame_place(T, base, self.forced_place)
make, fill_into = self.devirtualize
cref = make(self)
c = lltype.cast_opaque_ptr(T, cref)
self.rgenop.write_frame_place(T, base, self.forced_place, c)
vablerti.set_shape(base, shapemask| bitmask)
fill_into(vablerti, cref, base, self)
return c
_get_forced._annspecialcase_ = "specialize:arg(2)"
def _is_virtual(self, shapemask):
return bool(self.bitmask & shapemask)
| Python |
import sys
from pypy.objspace.flow.model import Variable, Constant, Block, Link
from pypy.objspace.flow.model import SpaceOperation, mkentrymap
from pypy.annotation import model as annmodel
from pypy.jit.hintannotator import model as hintmodel
from pypy.jit.hintannotator.model import originalconcretetype
from pypy.rpython.lltypesystem import lltype, llmemory, lloperation
from pypy.rpython.rmodel import inputconst
from pypy.translator.unsimplify import varoftype, copyvar
from pypy.translator.unsimplify import split_block, split_block_at_start
from pypy.translator.backendopt.ssa import SSA_to_SSI
class MergePointFamily(object):
def __init__(self, tsgraph):
self.tsgraph = tsgraph
self.count = 0
self.resumepoint_after_mergepoint = {}
self.localmergepoints = []
def add(self, kind):
result = self.count
self.count += 1
attrname = 'mp%d' % result
if kind == 'local':
self.localmergepoints.append(attrname)
return attrname
def getlocalattrnames(self):
return self.localmergepoints
def has_global_mergepoints(self):
return bool(self.resumepoint_after_mergepoint)
class HintGraphTransformer(object):
c_dummy = inputconst(lltype.Void, None)
contains_promotion = False
def __init__(self, hannotator, graph, is_portal=False):
self.hannotator = hannotator
self.graph = graph
self.is_portal = is_portal
self.graphcolor = self.graph_calling_color(graph)
self.resumepoints = {}
self.mergepoint_set = {} # set of blocks
self.mergepointfamily = MergePointFamily(graph)
self.c_mpfamily = inputconst(lltype.Void, self.mergepointfamily)
self.tsgraphs_seen = []
self.raise_analyzer = hannotator.exceptiontransformer.raise_analyzer
def can_raise(self, op):
return self.raise_analyzer.analyze(op)
def transform(self):
self.simplify_operations()
self.compute_merge_points()
self.insert_save_return()
self.insert_splits()
self.split_after_calls()
self.split_after_raisingop()
self.handle_hints()
self.insert_merge_points()
self.insert_enter_frame()
self.insert_dispatcher()
self.insert_ensure_queue()
self.insert_leave_graph()
def compute_merge_points(self):
entrymap = mkentrymap(self.graph)
startblock = self.graph.startblock
global_merge_blocks = {}
for block in self.graph.iterblocks():
if not block.operations:
continue
op = block.operations[0]
hashint = False
cand = 0
if (op.opname == 'hint' and
op.args[1].value == {'global_merge_point': True}):
hashint = True
if block is startblock or len(entrymap[block]) > 1:
global_merge_blocks[block] = True
cand += 1
else:
prevblock = entrymap[block][0].prevblock
if len(entrymap[prevblock]) > 1:
global_merge_blocks[prevblock] = True
cand += 1
#op = block.operations[-1]
#if (op.opname == 'hint' and
# op.args[1].value == {'global_merge_point': True}):
# hashint = True
# for link in block.exits:
# if len(entrymap[link.target]) > 1:
# global_merge_blocks[link.target] = True
# cand += 1
assert not hashint or cand==1, (
"ambigous global merge point hint: %r" % block)
for op in block.operations[1:]:
assert not (op.opname == 'hint' and
op.args[1].value == {'global_merge_point': True}), (
"stranded global merge point hint: %r" % block)
for block, links in entrymap.items():
if len(links) > 1 and block is not self.graph.returnblock:
if block in global_merge_blocks:
self.mergepoint_set[block] = 'global'
else:
self.mergepoint_set[block] = 'local'
if startblock in global_merge_blocks:
self.mergepoint_set[startblock] = 'global'
def simplify_operations(self):
# ptr_eq(x, 0) => ptr_iszero
# ptr_ne(x, 0) => ptr_nonzero
replace = {'ptr_eq': 'ptr_iszero',
'ptr_ne': 'ptr_nonzero'}
for block in self.graph.iterblocks():
for op in block.operations:
if op.opname in replace:
srcargs = op.args
for v1, v2 in [(srcargs[0], srcargs[1]),
(srcargs[1], srcargs[0])]:
if isinstance(v2, Constant):
if not v2.value:
op.opname = replace[op.opname]
op.args = [v1]
break
# debug_assert(ptr_iszero(p)) => debug_assert_ptr_iszero(p)
# debug_assert(ptr_nonzero(p)) => debug_assert_ptr_nonzero(p)
for block in self.graph.iterblocks():
for op in block.operations:
if op.opname == 'debug_assert':
v = op.args[0]
srcopname, srcargs = self.trace_back_bool_var(block, v)
if srcopname in ('ptr_iszero', 'ptr_nonzero'):
op.opname += '_' + srcopname
op.args[0] = srcargs[0]
def graph_calling_color(self, tsgraph):
args_hs, hs_res = self.hannotator.bookkeeper.tsgraphsigs[tsgraph]
if originalconcretetype(hs_res) is lltype.Void:
c = 'gray'
elif hs_res.is_green():
c = 'yellow'
else:
c = 'red'
return c
def timeshifted_graph_of(self, graph, args_v, v_result):
bk = self.hannotator.bookkeeper
args_hs = [self.hannotator.binding(v) for v in args_v]
hs_result = self.hannotator.binding(v_result)
if isinstance(hs_result, hintmodel.SomeLLAbstractConstant):
fixed = hs_result.is_fixed()
else:
fixed = False
specialization_key = bk.specialization_key(fixed, args_hs)
tsgraph = bk.get_graph_by_key(graph, specialization_key)
self.tsgraphs_seen.append(tsgraph)
return tsgraph
# __________ helpers __________
def genop(self, block, opname, args, resulttype=None, result_like=None, red=False):
# 'result_like' can be a template variable whose hintannotation is
# copied
if resulttype is not None:
v_res = varoftype(resulttype)
if red:
hs = hintmodel.SomeLLAbstractVariable(resulttype)
else:
hs = hintmodel.SomeLLAbstractConstant(resulttype, {})
self.hannotator.setbinding(v_res, hs)
elif result_like is not None:
v_res = copyvar(self.hannotator, result_like)
else:
v_res = self.new_void_var()
spaceop = SpaceOperation(opname, args, v_res)
if isinstance(block, list):
block.append(spaceop)
else:
block.operations.append(spaceop)
return v_res
def genswitch(self, block, v_exitswitch, false, true):
block.exitswitch = v_exitswitch
link_f = Link([], false)
link_f.exitcase = False
link_t = Link([], true)
link_t.exitcase = True
block.recloseblock(link_f, link_t)
def new_void_var(self, name=None):
v_res = varoftype(lltype.Void, name)
self.hannotator.setbinding(v_res, annmodel.s_ImpossibleValue)
return v_res
def new_block_before(self, block):
newinputargs = [copyvar(self.hannotator, var)
for var in block.inputargs]
newblock = Block(newinputargs)
bridge = Link(newinputargs, block)
newblock.closeblock(bridge)
return newblock
def naive_split_block(self, block, position):
newblock = Block([])
newblock.operations = block.operations[position:]
del block.operations[position:]
newblock.exitswitch = block.exitswitch
block.exitswitch = None
newblock.recloseblock(*block.exits)
block.recloseblock(Link([], newblock))
return newblock
def variables_alive(self, block, before_position):
created_before = dict.fromkeys(block.inputargs)
for op in block.operations[:before_position]:
created_before[op.result] = True
used = {}
for op in block.operations[before_position:]:
for v in op.args:
used[v] = True
for link in block.exits:
for v in link.args:
used[v] = True
return [v for v in used if v in created_before]
def sort_by_color(self, vars, by_color_of_vars=None):
reds = []
greens = []
if by_color_of_vars is None:
by_color_of_vars = vars
for v, bcv in zip(vars, by_color_of_vars):
if v.concretetype is lltype.Void:
continue
if self.hannotator.binding(bcv).is_green():
greens.append(v)
else:
reds.append(v)
return reds, greens
def before_start_block(self):
entryblock = self.new_block_before(self.graph.startblock)
entryblock.isstartblock = True
self.graph.startblock.isstartblock = False
self.graph.startblock = entryblock
return entryblock
def before_return_block(self):
block = self.graph.returnblock
block.operations = []
split_block(self.hannotator, block, 0)
[link] = block.exits
assert len(link.args) == 0
link.args = [self.c_dummy]
link.target.inputargs = [self.new_void_var('dummy')]
self.graph.returnblock = link.target
self.graph.returnblock.operations = ()
return block
# __________ transformation steps __________
def insert_splits(self):
hannotator = self.hannotator
retry = True
while retry:
retry = False
for block in list(self.graph.iterblocks()):
if block.exitswitch is not None:
assert isinstance(block.exitswitch, Variable)
hs_switch = hannotator.binding(block.exitswitch)
if not hs_switch.is_green():
if block.exitswitch.concretetype is lltype.Bool:
self.insert_split_handling(block)
else:
self.insert_switch_handling(block)
retry = True
def trace_back_bool_var(self, block, v):
"""Return the (opname, arguments) that created the exitswitch of
the block. The opname is None if not found.
"""
inverted = False
for i in range(len(block.operations)-1, -1, -1):
op = block.operations[i]
if op.result is v:
if op.opname == 'bool_not':
inverted = not inverted
[v] = op.args
elif op.opname == 'same_as':
[v] = op.args
else:
opname = op.opname
opargs = op.args
if inverted:
opname = {'ptr_nonzero': 'ptr_iszero',
'ptr_iszero' : 'ptr_nonzero'}.get(opname)
return opname, opargs # found
# not found, comes from earlier block - give up
return None, None
def insert_split_handling(self, block):
v_redswitch = block.exitswitch
# try to look where the v_redswitch comes from
split_variant = ''
split_extras = []
srcopname, srcargs = self.trace_back_bool_var(block, block.exitswitch)
if srcopname == 'ptr_nonzero':
split_variant = '_ptr_nonzero'
split_extras = srcargs
elif srcopname == 'ptr_iszero':
split_variant = '_ptr_iszero'
split_extras = srcargs
link_f, link_t = block.exits
if link_f.exitcase:
link_f, link_t = link_t, link_f
assert link_f.exitcase is False
assert link_t.exitcase is True
reds, greens = self.sort_by_color(link_f.args, link_f.target.inputargs)
self.genop(block, 'save_locals', reds)
resumepoint = self.get_resume_point(link_f.target)
c_resumepoint = inputconst(lltype.Signed, resumepoint)
v_flag = self.genop(block, 'split' + split_variant,
[v_redswitch, c_resumepoint] + split_extras + greens,
resulttype = lltype.Bool)
block.exitswitch = v_flag
def insert_switch_handling(self, block):
v_redswitch = block.exitswitch
T = v_redswitch.concretetype
range_start = -sys.maxint-1
range_stop = sys.maxint+1
if T is not lltype.Signed:
if T is lltype.Char:
opcast = 'cast_char_to_int'
range_start = 0
range_stop = 256
elif T is lltype.UniChar:
opcast = 'cast_unichar_to_int'
range_start = 0
elif T is lltype.Unsigned:
opcast = 'cast_uint_to_int'
else:
raise AssertionError(T)
v_redswitch = self.genop(block, opcast, [v_redswitch],
resulttype=lltype.Signed, red=True)
block.exitswitch = v_redswitch
# for now, we always turn the switch back into a chain of tests
# that perform a binary search
blockset = {block: True} # reachable from outside
cases = {}
defaultlink = None
for link in block.exits:
if link.exitcase == 'default':
defaultlink = link
blockset[link.target] = False # not reachable from outside
else:
assert lltype.typeOf(link.exitcase) == T
intval = lltype.cast_primitive(lltype.Signed, link.exitcase)
cases[intval] = link
link.exitcase = None
link.llexitcase = None
self.insert_integer_search(block, cases, defaultlink, blockset,
range_start, range_stop)
SSA_to_SSI(blockset, self.hannotator)
def insert_integer_search(self, block, cases, defaultlink, blockset,
range_start, range_stop):
# fix the exit of the 'block' to check for the given remaining
# 'cases', knowing that if we get there then the value must
# be contained in range(range_start, range_stop).
if not cases:
assert defaultlink is not None
block.exitswitch = None
block.recloseblock(Link(defaultlink.args, defaultlink.target))
elif len(cases) == 1 and (defaultlink is None or
range_start == range_stop-1):
block.exitswitch = None
block.recloseblock(cases.values()[0])
else:
intvalues = cases.keys()
intvalues.sort()
if len(intvalues) <= 3:
# not much point in being clever with no more than 3 cases
intval = intvalues[-1]
remainingcases = cases.copy()
link = remainingcases.pop(intval)
c_intval = inputconst(lltype.Signed, intval)
v = self.genop(block, 'int_eq', [block.exitswitch, c_intval],
resulttype=lltype.Bool, red=True)
link.exitcase = True
link.llexitcase = True
falseblock = Block([])
falseblock.exitswitch = block.exitswitch
blockset[falseblock] = False
falselink = Link([], falseblock)
falselink.exitcase = False
falselink.llexitcase = False
block.exitswitch = v
block.recloseblock(falselink, link)
if defaultlink is None or intval == range_stop-1:
range_stop = intval
self.insert_integer_search(falseblock, remainingcases,
defaultlink, blockset,
range_start, range_stop)
else:
intval = intvalues[len(intvalues) // 2]
c_intval = inputconst(lltype.Signed, intval)
v = self.genop(block, 'int_ge', [block.exitswitch, c_intval],
resulttype=lltype.Bool, red=True)
falseblock = Block([])
falseblock.exitswitch = block.exitswitch
trueblock = Block([])
trueblock.exitswitch = block.exitswitch
blockset[falseblock] = False
blockset[trueblock] = False
falselink = Link([], falseblock)
falselink.exitcase = False
falselink.llexitcase = False
truelink = Link([], trueblock)
truelink.exitcase = True
truelink.llexitcase = True
block.exitswitch = v
block.recloseblock(falselink, truelink)
falsecases = {}
truecases = {}
for intval1, link1 in cases.items():
if intval1 < intval:
falsecases[intval1] = link1
else:
truecases[intval1] = link1
self.insert_integer_search(falseblock, falsecases,
defaultlink, blockset,
range_start, intval)
self.insert_integer_search(trueblock, truecases,
defaultlink, blockset,
intval, range_stop)
def get_resume_point_link(self, block):
try:
return self.resumepoints[block]
except KeyError:
resumeblock = Block([])
redcount = 0
greencount = 0
newvars = []
for v in block.inputargs:
if v.concretetype is lltype.Void:
v1 = self.c_dummy
elif self.hannotator.binding(v).is_green():
c = inputconst(lltype.Signed, greencount)
v1 = self.genop(resumeblock, 'restore_green', [c],
result_like = v)
greencount += 1
else:
c = inputconst(lltype.Signed, redcount)
v1 = self.genop(resumeblock, 'restore_local', [c],
result_like = v)
redcount += 1
newvars.append(v1)
resumeblock.closeblock(Link(newvars, block))
reenter_link = Link([], resumeblock)
N = len(self.resumepoints)
reenter_link.exitcase = N
self.resumepoints[block] = reenter_link
return reenter_link
def get_resume_point(self, block):
return self.get_resume_point_link(block).exitcase
def go_to_if(self, block, target, v_finished_flag):
block.exitswitch = v_finished_flag
[link_f] = block.exits
link_t = Link([self.c_dummy], target)
link_f.exitcase = False
link_t.exitcase = True
block.recloseblock(link_f, link_t)
def go_to_dispatcher_if(self, block, v_finished_flag):
self.go_to_if(block, self.graph.returnblock, v_finished_flag)
def insert_merge_points(self):
for block, kind in self.mergepoint_set.items():
self.insert_merge(block, kind)
def insert_merge(self, block, kind):
allvars = block.inputargs[:]
block.inputargs[:] = [copyvar(self.hannotator, v) for v in allvars]
reds1, greens1 = self.sort_by_color(block.inputargs)
reds3, greens3 = self.sort_by_color(allvars)
nextblock = self.naive_split_block(block, 0)
self.genop(block, 'save_locals', reds1)
mp = self.mergepointfamily.add(kind)
c_mp = inputconst(lltype.Void, mp)
if kind == 'global':
prefix = 'global_'
greens2 = [copyvar(self.hannotator, v) for v in greens1]
mergeblock = self.naive_split_block(block, len(block.operations))
mergeblock.inputargs[:] = greens2
self.genop(block, 'save_greens', greens1)
block.recloseblock(Link([self.c_dummy], self.graph.returnblock))
N = self.get_resume_point(mergeblock)
c_resumeindex = inputconst(lltype.Signed, N)
self.genop(block, 'guard_global_merge', [c_resumeindex])
# Note: the jitstate.greens list will contain the correct
# green gv's for the following global_merge_point, because
# the green values have just been restored by the resume
# point logic here
else:
mergeblock = block
greens2 = greens1
prefix = ''
mergeblock.exits[0].args[:] = greens2
nextblock.inputargs[:] = greens3
v_finished_flag = self.genop(mergeblock, '%smerge_point' % (prefix,),
[self.c_mpfamily, c_mp] + greens2,
resulttype = lltype.Bool)
self.go_to_dispatcher_if(mergeblock, v_finished_flag)
restoreops = []
for i, v in enumerate(reds3):
c = inputconst(lltype.Signed, i)
restoreops.append(SpaceOperation('restore_local', [c], v))
nextblock.operations[:0] = restoreops
if kind == 'global':
N = self.get_resume_point(nextblock)
self.mergepointfamily.resumepoint_after_mergepoint[mp] = N
def insert_dispatcher(self):
if self.resumepoints:
block = self.before_return_block()
self.genop(block, 'dispatch_next', [])
if self.mergepointfamily.has_global_mergepoints():
block = self.before_return_block()
entryblock = self.before_start_block()
v_rp = self.genop(entryblock, 'getresumepoint', [],
resulttype = lltype.Signed)
c_zero = inputconst(lltype.Signed, 0)
v_abnormal_entry = self.genop(entryblock, 'int_ge',
[v_rp, c_zero],
resulttype = lltype.Bool)
self.go_to_if(entryblock, block, v_abnormal_entry)
v_switchcase = self.genop(block, 'getresumepoint', [],
resulttype = lltype.Signed)
block.exitswitch = v_switchcase
defaultlink = block.exits[0]
defaultlink.exitcase = 'default'
links = self.resumepoints.values()
links.sort(lambda l, r: cmp(l.exitcase, r.exitcase))
links.append(defaultlink)
block.recloseblock(*links)
def insert_save_return(self):
block = self.before_return_block()
[v_retbox] = block.inputargs
if self.graphcolor == 'gray':
self.genop(block, 'save_locals', [])
elif self.graphcolor == 'yellow':
self.genop(block, 'save_locals', [])
self.genop(block, 'save_greens', [v_retbox])
elif self.graphcolor == 'red':
self.genop(block, 'save_locals', [v_retbox])
else:
raise AssertionError(self.graph, self.graphcolor)
self.genop(block, 'save_return', [])
def insert_ensure_queue(self):
entryblock = self.before_start_block()
if self.mergepointfamily.has_global_mergepoints():
prefix = 'replayable_'
else:
prefix = ''
self.genop(entryblock, prefix+'ensure_queue', [self.c_mpfamily])
def insert_enter_frame(self):
entryblock = self.before_start_block()
self.genop(entryblock, 'enter_frame', [])
def insert_leave_graph(self):
block = self.before_return_block()
if self.is_portal:
assert self.graphcolor == 'red'
self.genop(block, 'leave_graph_portal', [])
else:
self.genop(block, 'leave_graph_%s' % (self.graphcolor,), [])
# __________ handling of the various kinds of calls __________
def graphs_from(self, spaceop):
if spaceop.opname == 'direct_call':
c_func = spaceop.args[0]
fnobj = c_func.value._obj
graphs = [fnobj.graph]
args_v = spaceop.args[1:]
elif spaceop.opname == 'indirect_call':
graphs = spaceop.args[-1].value
if graphs is None:
return # cannot follow at all
args_v = spaceop.args[1:-1]
else:
raise AssertionError(spaceop.opname)
# if the graph - or all the called graphs - are marked as "don't
# follow", directly return None as a special case. (This is only
# an optimization for the indirect_call case.)
for graph in graphs:
if self.hannotator.policy.look_inside_graph(graph):
break
else:
return
for graph in graphs:
tsgraph = self.timeshifted_graph_of(graph, args_v, spaceop.result)
yield graph, tsgraph
def guess_call_kind(self, spaceop):
if spaceop.opname == 'direct_call':
c_func = spaceop.args[0]
fnobj = c_func.value._obj
if hasattr(fnobj, 'jitcallkind'):
return fnobj.jitcallkind, None
if (hasattr(fnobj._callable, 'oopspec') and
self.hannotator.policy.oopspec):
if fnobj._callable.oopspec.startswith('vable.'):
return 'vable', None
hs_result = self.hannotator.binding(spaceop.result)
if (hs_result.is_green() and
hs_result.concretetype is not lltype.Void):
return 'green', self.can_raise(spaceop)
return 'oopspec', self.can_raise(spaceop)
if self.hannotator.bookkeeper.is_green_call(spaceop):
return 'green', None
withexc = self.can_raise(spaceop)
colors = {}
for graph, tsgraph in self.graphs_from(spaceop):
color = self.graph_calling_color(tsgraph)
colors[color] = tsgraph
if not colors: # cannot follow this call
return 'residual', withexc
assert len(colors) == 1, colors # buggy normalization?
return color, withexc
def split_after_calls(self):
for block in list(self.graph.iterblocks()):
for i in range(len(block.operations)-1, -1, -1):
op = block.operations[i]
if op.opname in ('direct_call', 'indirect_call'):
call_kind, withexc = self.guess_call_kind(op)
handler = getattr(self, 'handle_%s_call' % (call_kind,))
if withexc is None:
handler(block, i)
else:
handler(block, i, withexc)
def make_call(self, block, op, save_locals_vars, color='red'):
# the 'save_locals' pseudo-operation is used to save all
# alive local variables into the current JITState
self.genop(block, 'save_locals', save_locals_vars)
targets = dict(self.graphs_from(op))
#for tsgraph in targets.values():
# if self.graph_global_mps(tsgraph):
# # make sure jitstate.resumepoint is set to zero
# self.genop(block, 'resetresumepoint', [])
# break
# XXX do the right thing for call to portals
#
args_v = op.args[1:]
if op.opname == 'indirect_call':
del args_v[-1]
if len(targets) == 1:
[tsgraph] = targets.values()
c_tsgraph = inputconst(lltype.Void, tsgraph)
v_finished = self.genop(block, '%s_call' % (color,),
[c_tsgraph] + args_v,
resulttype = lltype.Bool)
# Void result, because the call doesn't return its redbox result,
# but only has the hidden side-effect of putting it in the jitstate
else:
c_targets = inputconst(lltype.Void, targets)
args_v = op.args[:1] + args_v + [c_targets]
hs_func = self.hannotator.binding(args_v[0])
if not hs_func.is_green():
# handle_red_call() has checked with is_constant that
# the hs_func is actually a constant red box
v_greenfunc = self.genop(block, 'revealconst', [args_v[0]],
resulttype = originalconcretetype(hs_func))
args_v[0] = v_greenfunc
v_finished = self.genop(block, 'indirect_%s_call' % (color,),
args_v,
resulttype = lltype.Bool)
self.go_to_dispatcher_if(block, v_finished)
def handle_red_call(self, block, pos, withexc, color='red'):
link = split_block(self.hannotator, block, pos+1)
op = block.operations.pop(pos)
#if op.opname == 'direct_call':
# f = open('LOG', 'a')
# print >> f, color, op.args[0].value
# f.close()
assert len(block.operations) == pos
nextblock = link.target
linkargs = link.args
varsalive = list(linkargs)
if color != 'gray':
# the result will be either passed as an extra local 0
# by the caller, or restored by a restore_local
try:
index = varsalive.index(op.result)
except ValueError:
linkargs.insert(0, op.result)
v_result = copyvar(self.hannotator, op.result)
nextblock.inputargs.insert(0, v_result)
else:
del varsalive[index]
old_v_result = linkargs.pop(index)
linkargs.insert(0, old_v_result)
v_result = nextblock.inputargs.pop(index)
nextblock.inputargs.insert(0, v_result)
else:
if op.result in varsalive:
index = varsalive.index(op.result)
del varsalive[index]
linkargs.pop(index)
c_void = Constant(None, lltype.Void)
linkargs.insert(0, c_void)
v_result = nextblock.inputargs.pop(index)
nextblock.inputargs.insert(0, v_result)
reds, greens = self.sort_by_color(varsalive)
blockset = {}
blockset[block] = True # reachable from outside
blockset[nextblock] = False
v_func = op.args[0]
hs_func = self.hannotator.binding(v_func)
if hs_func.is_green():
constantblock = block
nonconstantblock = None
else:
constantblock = Block([])
nonconstantblock = Block([])
blockset[constantblock] = False
blockset[nonconstantblock] = False
v_is_constant = self.genop(block, 'is_constant', [v_func],
resulttype = lltype.Bool)
self.genswitch(block, v_is_constant, true = constantblock,
false = nonconstantblock)
postconstantblock = self.naive_split_block(constantblock,
len(constantblock.operations))
blockset[postconstantblock] = False
self.make_call(constantblock, op, reds, color)
conversionblock = nextblock
if color == 'red':
assert not self.hannotator.binding(op.result).is_green()
elif color == 'yellow':
conversionblock = Block([copyvar(self.hannotator, v)
for v in nextblock.inputargs])
v0 = conversionblock.inputargs[0]
already_green = self.hannotator.binding(op.result).is_green()
assert already_green == self.hannotator.binding(v0).is_green()
if not already_green:
RESULT = self.hannotator.binding(v0).concretetype
hs = hintmodel.SomeLLAbstractConstant(RESULT, {})
self.hannotator.bindings[v0] = hs
conversionblock.closeblock(Link(conversionblock.inputargs,
nextblock))
blockset[conversionblock] = False
# to merge some of the possibly many return jitstates
self.mergepoint_set[nextblock] = 'local'
resumepoint = self.get_resume_point(conversionblock)
c_resumepoint = inputconst(lltype.Signed, resumepoint)
self.genop(postconstantblock, 'collect_split', [c_resumepoint] + greens)
resumeblock = self.get_resume_point_link(conversionblock).target
postconstantblock.recloseblock(Link([], resumeblock))
blockset[resumeblock] = True # reachable from outside
if nonconstantblock is not None:
nonconstantblock.recloseblock(Link(linkargs, nextblock))
v_res = self.handle_residual_call_details(
nonconstantblock, 0, op,
color, blockset, preserve_res =
(color != 'gray'),
withexc=withexc)
SSA_to_SSI(blockset, self.hannotator)
def handle_gray_call(self, block, pos, withexc):
self.handle_red_call(block, pos, color='gray', withexc=withexc)
def handle_oopspec_call(self, block, pos, withexc):
op = block.operations[pos]
assert op.opname == 'direct_call'
if withexc:
op.opname = 'oopspec_call'
else:
op.opname = 'oopspec_call_noexc'
if withexc:
link = split_block(self.hannotator, block, pos+1)
nextblock = link.target
linkargs = link.args
v_residual =self.genop(block, 'oopspec_was_residual', [],
resulttype = lltype.Bool)
residualblock = Block([])
self.genswitch(block, v_residual, true = residualblock,
false = None)
link_f = block.exits[0]
link_f.args = linkargs
link_f.target = nextblock
residualblock.closeblock(Link(linkargs, nextblock))
blockset = { block: True,
nextblock: False,
residualblock: False }
self.handle_after_residual_call_details(
residualblock, 0, [], blockset, oop=True,
withexc=True)
SSA_to_SSI(blockset, self.hannotator)
def handle_vable_call(self, block, pos):
op = block.operations[pos]
assert op.opname == 'direct_call'
oopspec = op.args[0].value._obj._callable.oopspec
name, _ = oopspec.split('(')
kind, name = name.split('_', 1)
if kind == 'vable.get':
opname = 'getfield'
else:
assert kind == 'vable.set'
opname = 'setfield'
args = op.args[1:]
args.insert(1, Constant(name, lltype.Void))
block.operations[pos] = SpaceOperation(opname, args, op.result)
def handle_rpyexc_raise_call(self, block, pos):
op = block.operations[pos]
assert op.opname == 'direct_call'
op.opname = 'rpyexc_raise'
op.args = op.args[1:]
def handle_green_call(self, block, pos, withexc=False):
# an all-green function that we can just call
op = block.operations[pos]
if op.opname == 'indirect_call':
if withexc:
op.args.pop() # remove the graph list
op.opname = 'green_call'
else:
op.opname = 'green_indirect_call_noexc'
else:
if withexc:
op.opname = 'green_call'
else:
op.opname = 'green_call_noexc'
def handle_yellow_call(self, block, pos, withexc):
self.handle_red_call(block, pos, color='yellow', withexc=withexc)
def handle_residual_call(self, block, pos, withexc):
op = block.operations[pos]
if op.result.concretetype is lltype.Void:
color = 'gray'
else:
color = 'red'
blockset = {block: True}
v_res = self.handle_residual_call_details(block, pos, op, color,
blockset, withexc)
SSA_to_SSI(blockset, self.hannotator)
return v_res
def handle_residual_call_details(self, block, pos, op, color,
blockset, withexc,
preserve_res=True):
if op.opname == 'direct_call':
args_v = op.args[1:]
elif op.opname == 'indirect_call':
args_v = op.args[1:-1]
else:
raise AssertionError(op.opname)
newops = []
# pseudo-obscure: the arguments for the call go in save_locals
args_v = [v for v in args_v if v.concretetype is not lltype.Void]
self.genop(newops, 'save_locals', args_v)
call_index = len(newops)
v_res = self.genop(newops, 'residual_%s_call' % (color,),
[op.args[0]], result_like = op.result)
if preserve_res:
v_res = newops[call_index].result = op.result
self.handle_after_residual_call_details(block, pos,
newops, blockset,
withexc)
return v_res
def handle_after_residual_call_details(self, block, pos, newops, blockset,
withexc, oop = False):
dopts = {'withexc': withexc, 'oop': oop }
copts = Constant(dopts, lltype.Void)
v_flags = self.genop(newops, 'after_residual_call', [copts],
resulttype=lltype.Signed, red=True)
residual_fetch_index = len(newops)
self.genop(newops, 'residual_fetch', [v_flags, copts])
residual_fetch_pos = pos+residual_fetch_index
block.operations[pos:pos+1] = newops
link_t = split_block(self.hannotator, block, residual_fetch_pos)
nextblock = link_t.target
blockset[nextblock] = False
i_flags = link_t.args.index(v_flags)
reds, greens = self.sort_by_color(link_t.args)
self.genop(block, 'save_locals', reds)
SPLIT_FOR_ZERO = False
if SPLIT_FOR_ZERO:
promoteblock = Block([copyvar(self.hannotator, v)
for v in link_t.args])
link_f = Link(link_t.args, promoteblock)
promoteblock.recloseblock(Link(promoteblock.inputargs, nextblock))
blockset[promoteblock] = False
v_flags2 = promoteblock.inputargs[i_flags]
else:
promoteblock = block
v_flags2 = v_flags
# if there is no global merge point, this 'promote' will actually
# always see a constant red box
v_finished_flag = self.genop(promoteblock, 'promote', [v_flags2],
resulttype = lltype.Bool)
self.go_to_dispatcher_if(promoteblock, v_finished_flag)
if SPLIT_FOR_ZERO:
c_zero = inputconst(lltype.Signed, 0)
link_t.args = link_t.args[:]
link_t.args[i_flags] = c_zero
resumepoint = self.get_resume_point(promoteblock)
c_resumepoint = inputconst(lltype.Signed, resumepoint)
v_is_zero = self.genop(block, 'int_eq', [v_flags, c_zero],
resulttype=lltype.Bool, red=True)
v_is_zero = self.genop(block, 'split',
[v_is_zero, c_resumepoint] + greens,
resulttype = lltype.Bool)
block.exitswitch = v_is_zero
link_t.exitcase = True
link_f.exitcase = False
block.recloseblock(link_f, link_t)
# __________ raising ops (xxx_ovf & co) __________
def split_after_raisingop(self):
for block in list(self.graph.iterblocks()):
for i in range(len(block.operations)-1, -1, -1):
op = block.operations[i]
try:
opdesc = getattr(lloperation.llop, op.opname)
except AttributeError:
continue
if opdesc.tryfold and not opdesc.canfold and opdesc.canraise:
self.handle_raisingop(block, i, opdesc)
def handle_raisingop(self, block, i, opdesc):
op = block.operations[i]
if self.hannotator.binding(op.result).is_green():
# case not really well supported
v_red = Variable(op.result)
v_red.concretetype = op.result.concretetype
hs_red = hintmodel.SomeLLAbstractVariable(op.result.concretetype)
self.hannotator.setbinding(v_red, hs_red)
spaceop = SpaceOperation('revealconst', [v_red], op.result)
op.result = v_red
i += 1
block.operations.insert(i, spaceop)
link = split_block(self.hannotator, block, i+1)
reds, greens = self.sort_by_color(link.args)
self.genop(block, 'save_locals', reds)
resumepoint = self.get_resume_point(link.target)
c_resumepoint = inputconst(lltype.Signed, resumepoint)
assert len(opdesc.canraise) == 1 # for now
c_canraise = inputconst(lltype.Void, opdesc.canraise[0])
self.genop(block, 'split_raisingop',
[self.c_dummy, c_resumepoint, c_canraise] + greens)
# __________ hints __________
def handle_hints(self):
for block in list(self.graph.iterblocks()):
for i in range(len(block.operations)-1, -1, -1):
op = block.operations[i]
if op.opname == 'hint':
hints = op.args[1].value
for key, value in hints.items():
if value == True:
methname = 'handle_%s_hint' % (key,)
if hasattr(self, methname):
handler = getattr(self, methname)
break
else:
handler = self.handle_default_hint
handler(block, i)
def handle_default_hint(self, block, i):
# just discard the hint by default
op = block.operations[i]
newop = SpaceOperation('same_as', [op.args[0]], op.result)
block.operations[i] = newop
def handle_reverse_split_queue_hint(self, block, i):
op = block.operations[i]
newop = SpaceOperation('reverse_split_queue', [], op.result)
block.operations[i] = newop
def handle_forget_hint(self, block, i):
# a hint for testing only
op = block.operations[i]
assert self.hannotator.binding(op.result).is_green()
assert not self.hannotator.binding(op.args[0]).is_green()
newop = SpaceOperation('revealconst', [op.args[0]], op.result)
block.operations[i] = newop
def handle_promote_hint(self, block, i):
self.contains_promotion = True
op = block.operations[i]
v_promote = op.args[0]
newop = SpaceOperation('revealconst', [v_promote], op.result)
block.operations[i] = newop
link = split_block(self.hannotator, block, i)
reds, greens = self.sort_by_color(link.args)
self.genop(block, 'save_locals', reds)
v_finished_flag = self.genop(block, 'promote', [v_promote],
resulttype = lltype.Bool)
self.go_to_dispatcher_if(block, v_finished_flag)
| Python |
import operator
from pypy.rpython.lltypesystem import lltype
from pypy.rpython.lltypesystem import rdict
from pypy.jit.timeshifter.rcontainer import VirtualContainer, FrozenContainer
from pypy.jit.timeshifter.rcontainer import cachedtype
from pypy.jit.timeshifter import rvalue
from pypy.rlib.objectmodel import r_dict
HASH = lltype.Signed
# XXXXXXXXXX! ARGH.
# cannot use a dictionary as the item_boxes at all, because of order issues
class LLEqDesc(object):
__metaclass__ = cachedtype
def __init__(self, KEY, keyeq, keyhash):
# this makes one version of the following function per KEY,
# which is supposed to be the ll type of x and y
def lleq(x, y):
return keyeq(x, y)
def llhash(x):
return keyhash(x)
class VirtualDict(AbstractVirtualDict):
def make_item_boxes(self):
self.item_boxes = r_dict(lleq, llhash)
def getboxes(self):
return self.item_boxes.values()
def getitems_and_makeempty(self, rgenop):
result = [(rgenop.genconst(key), box, llhash(key))
for key, box in self.item_boxes.iteritems()]
self.item_boxes = None
return result
def getitem(self, keybox):
key = rvalue.ll_getvalue(keybox, KEY)
return self.item_boxes[key]
def setitem(self, keybox, valuebox):
key = rvalue.ll_getvalue(keybox, KEY)
self.item_boxes[key] = valuebox
def copy_from(self, other, memo):
assert isinstance(other, VirtualDict)
self.make_item_boxes()
for key, valuebox in other.item_boxes.iteritems():
self.item_boxes[key] = valuebox.copy(memo)
def internal_replace(self, memo):
changes = []
for key, valuebox in self.item_boxes.iteritems():
newbox = valuebox.replace(memo)
if newbox is not valuebox:
changes.append((key, newbox))
for key, newbox in changes:
self.item_boxes[key] = newbox
class FrozenVirtualDict(AbstractFrozenVirtualDict):
def freeze_from(self, vdict, memo):
assert isinstance(vdict, VirtualDict)
frozens = []
for key, valuebox in vdict.item_boxes.iteritems():
frozens.append((key, valuebox.freeze(memo)))
self.fz_item_boxes = frozens
def same_keys_as(self, vdict, boxes):
assert isinstance(vdict, VirtualDict)
self_boxes = self.fz_item_boxes
vdict_boxes = vdict.item_boxes
if len(self_boxes) != len(vdict_boxes):
return False
for key, selfbox in self_boxes:
try:
vdictbox = vdict_boxes[key]
except KeyError:
return False
boxes.append((selfbox, vdictbox))
return True
self.VirtualDict = VirtualDict
self.FrozenVirtualDict = FrozenVirtualDict
VirtualDict.FrozenVirtualDict = FrozenVirtualDict
class DictTypeDesc(object):
__metaclass__ = cachedtype
def __init__(self, hrtyper, DICT):
RGenOp = hrtyper.RGenOp
rtyper = hrtyper.rtyper
bk = rtyper.annotator.bookkeeper
self.DICT = DICT
self.DICTPTR = lltype.Ptr(DICT)
self.ptrkind = RGenOp.kindToken(self.DICTPTR)
argtypes = [bk.immutablevalue(DICT)]
ll_newdict_ptr = rtyper.annotate_helper_fn(rdict.ll_newdict,
argtypes)
self.gv_ll_newdict = RGenOp.constPrebuiltGlobal(ll_newdict_ptr)
self.tok_ll_newdict = RGenOp.sigToken(lltype.typeOf(ll_newdict_ptr).TO)
argtypes = [self.DICTPTR, DICT.KEY, DICT.VALUE, HASH]
ll_insertclean = rtyper.annotate_helper_fn(rdict.ll_dict_insertclean,
argtypes)
self.gv_ll_insertclean = RGenOp.constPrebuiltGlobal(ll_insertclean)
self.tok_ll_insertclean = RGenOp.sigToken(
lltype.typeOf(ll_insertclean).TO)
# XXX some fishing that only works if the DICT does not come from
# an r_dict
if DICT.keyeq is None:
keyeq = operator.eq
else:
assert isinstance(DICT.keyeq, lltype.staticAdtMethod)
keyeq = DICT.keyeq.__get__(42)
assert isinstance(DICT.keyhash, lltype.staticAdtMethod)
keyhash = DICT.keyhash.__get__(42)
keydesc = LLEqDesc(DICT.KEY, keyeq, keyhash)
self.VirtualDict = keydesc.VirtualDict
def _freeze_(self):
return True
def factory(self):
vdict = self.VirtualDict(self)
box = rvalue.PtrRedBox(self.ptrkind, known_nonzero=True)
box.content = vdict
vdict.ownbox = box
return box
TypeDesc = DictTypeDesc
class AbstractFrozenVirtualDict(FrozenContainer):
_attrs_ = ('typedesc',)
def __init__(self, typedesc):
self.typedesc = typedesc
#self.fz_item_boxes initialized later
def exactmatch(self, vdict, outgoingvarboxes, memo):
assert isinstance(vdict, AbstractVirtualDict)
contmemo = memo.containers
if self in contmemo:
ok = vdict is contmemo[self]
if not ok:
outgoingvarboxes.append(vdict.ownbox)
return ok
if vdict in contmemo:
assert contmemo[vdict] is not self
outgoingvarboxes.append(vdict.ownbox)
return False
assert self.typedesc is vdict.typedesc
boxes = []
if not self.same_keys_as(vdict, boxes):
outgoingvarboxes.append(vdict.ownbox)
return False
contmemo[self] = vdict
contmemo[vdict] = self
fullmatch = True
for selfbox, vdictbox in boxes:
if not selfbox.exactmatch(vdictbox,
outgoingvarboxes,
memo):
fullmatch = False
return fullmatch
def freeze_from(self, vdict, memo):
raise NotImplementedError
def same_keys_as(self, vdict, boxes):
raise NotImplementedError
class AbstractVirtualDict(VirtualContainer):
_attrs_ = ('typedesc',) # and no item_boxes
FrozenVirtualDict = AbstractFrozenVirtualDict # overridden in subclasses
def __init__(self, typedesc):
self.typedesc = typedesc
self.make_item_boxes()
# self.ownbox = ... set in factory()
def enter_block(self, incoming, memo):
contmemo = memo.containers
if self not in contmemo:
contmemo[self] = None
for box in self.getboxes():
box.enter_block(incoming, memo)
def force_runtime_container(self, jitstate):
typedesc = self.typedesc
builder = jitstate.curbuilder
items = self.getitems_and_makeempty(builder.rgenop)
args_gv = []
gv_dict = builder.genop_call(typedesc.tok_ll_newdict,
typedesc.gv_ll_newdict,
args_gv)
self.ownbox.setgenvar_hint(gv_dict, known_nonzero=True)
self.ownbox.content = None
for gv_key, valuebox, hash in items:
gv_hash = builder.rgenop.genconst(hash)
gv_value = valuebox.getgenvar(jitstate)
args_gv = [gv_dict, gv_key, gv_value, gv_hash]
builder.genop_call(typedesc.tok_ll_insertclean,
typedesc.gv_ll_insertclean,
args_gv)
def freeze(self, memo):
contmemo = memo.containers
try:
return contmemo[self]
except KeyError:
result = contmemo[self] = self.FrozenVirtualDict(self.typedesc)
result.freeze_from(self, memo)
return result
def copy(self, memo):
contmemo = memo.containers
try:
return contmemo[self]
except KeyError:
result = contmemo[self] = self.__class__(self.typedesc)
result.copy_from(self, memo)
result.ownbox = self.ownbox.copy(memo)
return result
def replace(self, memo):
contmemo = memo.containers
if self not in contmemo:
contmemo[self] = None
self.internal_replace(memo)
self.ownbox = self.ownbox.replace(memo)
def make_item_boxes(self):
raise NotImplementedError
def getboxes(self):
raise NotImplementedError
def getitems_and_makeempty(self, rgenop):
raise NotImplementedError
def getitem(self, keybox):
raise NotImplementedError
def setitem(self, keybox, valuebox):
raise NotImplementedError
def copy_from(self, other, memo):
raise NotImplementedError
def internal_replace(self, memo):
raise NotImplementedError
def oop_newdict(jitstate, oopspecdesc):
return oopspecdesc.typedesc.factory()
def oop_dict_setitem(jitstate, oopspecdesc, selfbox, keybox, valuebox):
content = selfbox.content
if isinstance(content, AbstractVirtualDict) and keybox.is_constant():
content.setitem(keybox, valuebox)
else:
oopspecdesc.residual_call(jitstate, [selfbox, keybox, valuebox])
def oop_dict_getitem(jitstate, oopspecdesc, deepfrozen, selfbox, keybox):
content = selfbox.content
if isinstance(content, AbstractVirtualDict) and keybox.is_constant():
try:
return content.getitem(keybox)
except KeyError:
return oopspecdesc.residual_exception(jitstate, KeyError)
else:
return oopspecdesc.residual_call(jitstate, [selfbox, keybox],
deepfrozen=deepfrozen)
oop_dict_getitem.couldfold = True
def oop_dict_contains(jitstate, oopspecdesc, deepfrozen, selfbox, keybox):
content = selfbox.content
if isinstance(content, AbstractVirtualDict) and keybox.is_constant():
try:
content.getitem(keybox)
res = True
except KeyError:
res = False
return rvalue.ll_fromvalue(jitstate, res)
else:
return oopspecdesc.residual_call(jitstate, [selfbox, keybox],
deepfrozen=deepfrozen)
oop_dict_contains.couldfold = True
| Python |
from pypy.rpython.lltypesystem import lltype, llmemory
from pypy.jit.timeshifter import rvalue, rtimeshift
class ExceptionDesc:
def __init__(self, hrtyper, lazy_exception_path):
RGenOp = hrtyper.RGenOp
self.etrafo = hrtyper.annotator.exceptiontransformer
self.cexcdata = self.etrafo.cexcdata
self.exc_data_ptr = self.cexcdata.value
self.gv_excdata = RGenOp.constPrebuiltGlobal(self.exc_data_ptr)
EXCDATA = self.etrafo.EXCDATA
self.exc_type_token = RGenOp.fieldToken(EXCDATA, 'exc_type')
self.exc_value_token = RGenOp.fieldToken(EXCDATA, 'exc_value')
self.exc_type_kind = RGenOp.kindToken(EXCDATA.exc_type)
self.exc_value_kind = RGenOp.kindToken(EXCDATA.exc_value)
LL_EXC_TYPE = EXCDATA.exc_type
LL_EXC_VALUE = EXCDATA.exc_value
self.gv_null_exc_type = RGenOp.constPrebuiltGlobal(
lltype.nullptr(LL_EXC_TYPE.TO))
self.gv_null_exc_value = RGenOp.constPrebuiltGlobal(
lltype.nullptr(LL_EXC_VALUE.TO))
self.null_exc_type_box = rvalue.PtrRedBox(self.exc_type_kind,
self.gv_null_exc_type)
self.null_exc_value_box = rvalue.PtrRedBox(self.exc_value_kind,
self.gv_null_exc_value)
self.lazy_exception_path = lazy_exception_path
def _freeze_(self):
return True
def genop_get_exc_type(self, builder):
return builder.genop_getfield(self.exc_type_token, self.gv_excdata)
def genop_get_exc_value(self, builder):
return builder.genop_getfield(self.exc_value_token, self.gv_excdata)
def genop_set_exc_type(self, builder, gv_value):
builder.genop_setfield(self.exc_type_token, self.gv_excdata, gv_value)
def genop_set_exc_value(self, builder, gv_value):
builder.genop_setfield(self.exc_value_token, self.gv_excdata, gv_value)
def fetch_global_excdata(self, jitstate, known_occurred=False):
builder = jitstate.curbuilder
gv_etype = self.genop_get_exc_type (builder)
gv_evalue = self.genop_get_exc_value(builder)
self.genop_set_exc_type (builder, self.gv_null_exc_type )
self.genop_set_exc_value(builder, self.gv_null_exc_value)
etypebox = rvalue.PtrRedBox(self.exc_type_kind, gv_etype )
evaluebox = rvalue.PtrRedBox(self.exc_value_kind, gv_evalue)
etypebox .known_nonzero = known_occurred
evaluebox.known_nonzero = known_occurred
rtimeshift.setexctypebox (jitstate, etypebox)
rtimeshift.setexcvaluebox(jitstate, evaluebox)
def store_global_excdata(self, jitstate):
builder = jitstate.curbuilder
etypebox = jitstate.exc_type_box
if etypebox.is_constant():
ll_etype = rvalue.ll_getvalue(etypebox, llmemory.Address)
if not ll_etype:
return # we know there is no exception set
evaluebox = jitstate.exc_value_box
gv_etype = etypebox .getgenvar(jitstate)
gv_evalue = evaluebox.getgenvar(jitstate)
self.genop_set_exc_type (builder, gv_etype )
self.genop_set_exc_value(builder, gv_evalue)
def gen_exc_occurred(self, builder):
gv_etype = self.genop_get_exc_type(builder)
return builder.genop_ptr_nonzero(self.exc_type_kind, gv_etype)
| Python |
import operator, weakref
from pypy.annotation import model as annmodel
from pypy.rpython.lltypesystem import lltype, lloperation, llmemory
from pypy.jit.hintannotator.model import originalconcretetype
from pypy.jit.timeshifter import rvalue, rcontainer, rvirtualizable
from pypy.rlib.unroll import unrolling_iterable
from pypy.rpython.annlowlevel import cachedtype, base_ptr_lltype
from pypy.rpython.annlowlevel import cast_instance_to_base_ptr
from pypy.rpython.annlowlevel import cast_base_ptr_to_instance
FOLDABLE_GREEN_OPS = dict.fromkeys(lloperation.enum_foldable_ops())
FOLDABLE_GREEN_OPS['getfield'] = None
FOLDABLE_GREEN_OPS['getarrayitem'] = None
NULL_OBJECT = base_ptr_lltype()._defl()
debug_view = lloperation.llop.debug_view
debug_print = lloperation.llop.debug_print
debug_pdb = lloperation.llop.debug_pdb
# ____________________________________________________________
# emit ops
class OpDesc(object):
"""
Description of a low-level operation
that can be passed around to low level helpers
to inform op generation
"""
canraise = False
def _freeze_(self):
return True
def __init__(self, RGenOp, opname, ARGS, RESULT):
self.RGenOp = RGenOp
self.opname = opname
self.llop = lloperation.LL_OPERATIONS[opname]
self.nb_args = len(ARGS)
self.ARGS = ARGS
self.RESULT = RESULT
self.result_kind = RGenOp.kindToken(RESULT)
self.whatever_result = RESULT._defl()
self.redboxcls = rvalue.ll_redboxcls(RESULT)
self.canfold = self.llop.canfold
self.tryfold = self.llop.tryfold
if self.tryfold and self.llop.canraise:
self.canraise = True
self.gv_True = RGenOp.constPrebuiltGlobal(True)
self.gv_False = RGenOp.constPrebuiltGlobal(False)
def __getattr__(self, name): # .ARGx -> .ARGS[x]
if name.startswith('ARG'):
index = int(name[3:])
return self.ARGS[index]
else:
raise AttributeError("don't know about %r in OpDesc" % name)
def compact_repr(self): # goes in ll helper names
return self.opname.upper()
_opdesc_cache = {}
def make_opdesc(hop):
hrtyper = hop.rtyper
op_key = (hrtyper.RGenOp, hop.spaceop.opname,
tuple([originalconcretetype(s_arg) for s_arg in hop.args_s]),
originalconcretetype(hop.s_result))
try:
return _opdesc_cache[op_key]
except KeyError:
opdesc = OpDesc(*op_key)
_opdesc_cache[op_key] = opdesc
return opdesc
def ll_gen1(opdesc, jitstate, argbox):
ARG0 = opdesc.ARG0
RESULT = opdesc.RESULT
opname = opdesc.name
if opdesc.tryfold and argbox.is_constant():
arg = rvalue.ll_getvalue(argbox, ARG0)
if not opdesc.canraise:
res = opdesc.llop(RESULT, arg)
else:
try:
res = opdesc.llop(RESULT, arg)
except Exception: # shouldn't raise anything unexpected
res = opdesc.whatever_result
gv_flag = opdesc.gv_True
else:
gv_flag = opdesc.gv_False
jitstate.greens.append(gv_flag)
return rvalue.ll_fromvalue(jitstate, res)
gv_arg = argbox.getgenvar(jitstate)
if not opdesc.canraise:
genvar = jitstate.curbuilder.genop1(opdesc.opname, gv_arg)
else:
genvar, gv_raised = jitstate.curbuilder.genraisingop1(opdesc.opname,
gv_arg)
jitstate.greens.append(gv_raised) # for split_raisingop()
return opdesc.redboxcls(opdesc.result_kind, genvar)
def ll_gen2(opdesc, jitstate, argbox0, argbox1):
ARG0 = opdesc.ARG0
ARG1 = opdesc.ARG1
RESULT = opdesc.RESULT
opname = opdesc.name
if opdesc.tryfold and argbox0.is_constant() and argbox1.is_constant():
# const propagate
arg0 = rvalue.ll_getvalue(argbox0, ARG0)
arg1 = rvalue.ll_getvalue(argbox1, ARG1)
if not opdesc.canraise:
res = opdesc.llop(RESULT, arg0, arg1)
else:
try:
res = opdesc.llop(RESULT, arg0, arg1)
except Exception: # shouldn't raise anything unexpected
res = opdesc.whatever_result
gv_flag = opdesc.gv_True
else:
gv_flag = opdesc.gv_False
jitstate.greens.append(gv_flag)
return rvalue.ll_fromvalue(jitstate, res)
gv_arg0 = argbox0.getgenvar(jitstate)
gv_arg1 = argbox1.getgenvar(jitstate)
if not opdesc.canraise:
genvar = jitstate.curbuilder.genop2(opdesc.opname, gv_arg0, gv_arg1)
else:
genvar, gv_raised = jitstate.curbuilder.genraisingop2(opdesc.opname,
gv_arg0, gv_arg1)
jitstate.greens.append(gv_raised) # for split_raisingop()
return opdesc.redboxcls(opdesc.result_kind, genvar)
def ll_genmalloc_varsize(jitstate, contdesc, sizebox):
# the specialized by contdesc is not useful, unify paths
return genmalloc_varsize(jitstate, contdesc, sizebox)
def genmalloc_varsize(jitstate, contdesc, sizebox):
gv_size = sizebox.getgenvar(jitstate)
alloctoken = contdesc.varsizealloctoken
genvar = jitstate.curbuilder.genop_malloc_varsize(alloctoken, gv_size)
# XXX MemoryError handling
return rvalue.PtrRedBox(contdesc.ptrkind, genvar, known_nonzero=True)
def ll_gengetfield(jitstate, deepfrozen, fielddesc, argbox):
if (fielddesc.immutable or deepfrozen) and argbox.is_constant():
ptr = rvalue.ll_getvalue(argbox, fielddesc.PTRTYPE)
if ptr: # else don't constant-fold the segfault...
res = getattr(ptr, fielddesc.fieldname)
return rvalue.ll_fromvalue(jitstate, res)
return argbox.op_getfield(jitstate, fielddesc)
def ll_gensetfield(jitstate, fielddesc, destbox, valuebox):
destbox.op_setfield(jitstate, fielddesc, valuebox)
def ll_gengetsubstruct(jitstate, fielddesc, argbox):
if argbox.is_constant():
ptr = rvalue.ll_getvalue(argbox, fielddesc.PTRTYPE)
if ptr: # else don't constant-fold - we'd get a bogus pointer
res = getattr(ptr, fielddesc.fieldname)
return rvalue.ll_fromvalue(jitstate, res)
return argbox.op_getsubstruct(jitstate, fielddesc)
def ll_gengetarrayitem(jitstate, deepfrozen, fielddesc, argbox, indexbox):
if ((fielddesc.immutable or deepfrozen) and argbox.is_constant()
and indexbox.is_constant()):
array = rvalue.ll_getvalue(argbox, fielddesc.PTRTYPE)
index = rvalue.ll_getvalue(indexbox, lltype.Signed)
if array and 0 <= index < len(array): # else don't constant-fold
res = array[index]
return rvalue.ll_fromvalue(jitstate, res)
genvar = jitstate.curbuilder.genop_getarrayitem(
fielddesc.arraytoken,
argbox.getgenvar(jitstate),
indexbox.getgenvar(jitstate))
return fielddesc.makebox(jitstate, genvar)
def ll_gengetarraysubstruct(jitstate, fielddesc, argbox, indexbox):
if argbox.is_constant() and indexbox.is_constant():
array = rvalue.ll_getvalue(argbox, fielddesc.PTRTYPE)
index = rvalue.ll_getvalue(indexbox, lltype.Signed)
if array and 0 <= index < len(array): # else don't constant-fold
res = array[index]
return rvalue.ll_fromvalue(jitstate, res)
genvar = jitstate.curbuilder.genop_getarraysubstruct(
fielddesc.arraytoken,
argbox.getgenvar(jitstate),
indexbox.getgenvar(jitstate))
return fielddesc.makebox(jitstate, genvar)
def ll_gensetarrayitem(jitstate, fielddesc, destbox, indexbox, valuebox):
genvar = jitstate.curbuilder.genop_setarrayitem(
fielddesc.arraytoken,
destbox.getgenvar(jitstate),
indexbox.getgenvar(jitstate),
valuebox.getgenvar(jitstate)
)
def ll_gengetarraysize(jitstate, fielddesc, argbox):
if argbox.is_constant():
array = rvalue.ll_getvalue(argbox, fielddesc.PTRTYPE)
if array: # else don't constant-fold the segfault...
res = len(array)
return rvalue.ll_fromvalue(jitstate, res)
genvar = jitstate.curbuilder.genop_getarraysize(
fielddesc.arraytoken,
argbox.getgenvar(jitstate))
return rvalue.IntRedBox(fielddesc.indexkind, genvar)
def ll_genptrnonzero(jitstate, argbox, reverse):
if argbox.is_constant():
addr = rvalue.ll_getvalue(argbox, llmemory.Address)
return rvalue.ll_fromvalue(jitstate, bool(addr) ^ reverse)
builder = jitstate.curbuilder
if argbox.known_nonzero:
gv_res = builder.rgenop.genconst(True ^ reverse)
else:
gv_addr = argbox.getgenvar(jitstate)
if reverse:
gv_res = builder.genop_ptr_iszero(argbox.kind, gv_addr)
else:
gv_res = builder.genop_ptr_nonzero(argbox.kind, gv_addr)
return rvalue.IntRedBox(builder.rgenop.kindToken(lltype.Bool), gv_res)
def ll_genptreq(jitstate, argbox0, argbox1, reverse):
builder = jitstate.curbuilder
if argbox0.is_constant() and argbox1.is_constant():
addr0 = rvalue.ll_getvalue(argbox0, llmemory.Address)
addr1 = rvalue.ll_getvalue(argbox1, llmemory.Address)
return rvalue.ll_fromvalue(jitstate, (addr0 == addr1) ^ reverse)
if argbox0.content is not None:
resultbox = argbox0.content.op_ptreq(jitstate, argbox1, reverse)
if resultbox is not None:
return resultbox
if argbox1.content is not None:
resultbox = argbox1.content.op_ptreq(jitstate, argbox0, reverse)
if resultbox is not None:
return resultbox
gv_addr0 = argbox0.getgenvar(jitstate)
gv_addr1 = argbox1.getgenvar(jitstate)
if reverse:
gv_res = builder.genop_ptr_ne(argbox0.kind, gv_addr0, gv_addr1)
else:
gv_res = builder.genop_ptr_eq(argbox0.kind, gv_addr0, gv_addr1)
return rvalue.IntRedBox(builder.rgenop.kindToken(lltype.Bool), gv_res)
# ____________________________________________________________
# other jitstate/graph level operations
def enter_next_block(jitstate, incoming):
linkargs = []
kinds = []
for redbox in incoming:
assert not redbox.genvar.is_const
linkargs.append(redbox.genvar)
kinds.append(redbox.kind)
newblock = jitstate.curbuilder.enter_next_block(kinds, linkargs)
for i in range(len(incoming)):
incoming[i].genvar = linkargs[i]
return newblock
def return_marker(jitstate, resuming):
raise AssertionError("shouldn't get here")
def start_new_block(states_dic, jitstate, key, global_resumer, index=-1):
memo = rvalue.freeze_memo()
frozen = jitstate.freeze(memo)
memo = rvalue.exactmatch_memo()
outgoingvarboxes = []
res = frozen.exactmatch(jitstate, outgoingvarboxes, memo)
assert res, "exactmatch() failed"
cleanup_partial_data(memo.partialdatamatch)
newblock = enter_next_block(jitstate, outgoingvarboxes)
if index < 0:
states_dic[key].append((frozen, newblock))
else:
states_dic[key][index] = (frozen, newblock)
if global_resumer is not None and global_resumer is not return_marker:
assert jitstate.get_resuming() is None
jitstate.curbuilder.log('start_new_block %s' % (key,))
greens_gv = jitstate.greens
rgenop = jitstate.curbuilder.rgenop
node = PromotionPathRoot(greens_gv, rgenop,
frozen, newblock,
global_resumer)
dispatchqueue = jitstate.frame.dispatchqueue
assert dispatchqueue.split_chain is None
dispatchqueue.clearlocalcaches()
jitstate.promotion_path = PromotionPathMergesToSee(node, 0)
#debug_print(lltype.Void, "PROMOTION ROOT")
start_new_block._annspecialcase_ = "specialize:arglltype(2)"
def retrieve_jitstate_for_merge(states_dic, jitstate, key, global_resumer,
force_merge=False):
if jitstate.virtualizables:
jitstate.enter_block_sweep_virtualizables()
if key not in states_dic:
states_dic[key] = []
start_new_block(states_dic, jitstate, key, global_resumer)
return False # continue
states = states_dic[key]
for i in range(len(states) -1, -1, -1):
frozen, oldblock = states[i]
memo = rvalue.exactmatch_memo(force_merge)
outgoingvarboxes = []
try:
match = frozen.exactmatch(jitstate, outgoingvarboxes, memo)
except rvalue.DontMerge:
continue
if match:
linkargs = []
for box in outgoingvarboxes:
linkargs.append(box.getgenvar(jitstate))
jitstate.curbuilder.finish_and_goto(linkargs, oldblock)
return True # finished
# A mergable blook found
# We need a more general block. Do it by generalizing all the
# redboxes from outgoingvarboxes, by making them variables.
# Then we make a new block based on this new state.
cleanup_partial_data(memo.partialdatamatch)
forget_nonzeroness = memo.forget_nonzeroness
replace_memo = rvalue.copy_memo()
for box in outgoingvarboxes:
box.forcevar(jitstate, replace_memo, box in forget_nonzeroness)
if replace_memo.boxes:
jitstate.replace(replace_memo)
start_new_block(states_dic, jitstate, key, global_resumer, index=i)
if global_resumer is None:
merge_generalized(jitstate)
return False # continue
# No mergable states found, make a new.
start_new_block(states_dic, jitstate, key, global_resumer)
return False
retrieve_jitstate_for_merge._annspecialcase_ = "specialize:arglltype(2)"
def cleanup_partial_data(partialdatamatch):
# remove entries from PartialDataStruct unless they matched
# their frozen equivalent
for box, keep in partialdatamatch.iteritems():
content = box.content
if isinstance(content, rcontainer.PartialDataStruct):
box.content = content.cleanup_partial_data(keep)
def merge_generalized(jitstate):
resuming = jitstate.get_resuming()
if resuming is None:
node = jitstate.promotion_path
while not node.cut_limit:
node = node.next
dispatchqueue = jitstate.frame.dispatchqueue
count = dispatchqueue.mergecounter + 1
dispatchqueue.mergecounter = count
node = PromotionPathMergesToSee(node, count)
#debug_print(lltype.Void, "MERGE", count)
jitstate.promotion_path = node
else:
if resuming.mergesleft != MC_IGNORE_UNTIL_RETURN:
assert resuming.mergesleft > 0
resuming.mergesleft -= 1
def guard_global_merge(jitstate, resumepoint):
jitstate.pause()
dispatchqueue = jitstate.frame.dispatchqueue
jitstate.next = dispatchqueue.global_merge_chain
dispatchqueue.global_merge_chain = jitstate
jitstate.resumepoint = resumepoint
def split(jitstate, switchredbox, resumepoint, *greens_gv):
exitgvar = switchredbox.getgenvar(jitstate)
if exitgvar.is_const:
return exitgvar.revealconst(lltype.Bool)
else:
return split_nonconstantcase(jitstate, exitgvar, resumepoint,
switchredbox, False, list(greens_gv))
def split_ptr_nonzero(jitstate, switchredbox, resumepoint,
ptrbox, reverse, *greens_gv):
exitgvar = switchredbox.getgenvar(jitstate)
if exitgvar.is_const:
return exitgvar.revealconst(lltype.Bool)
else:
return split_nonconstantcase(jitstate, exitgvar, resumepoint,
ptrbox, reverse, list(greens_gv))
def split_nonconstantcase(jitstate, exitgvar, resumepoint,
condbox, reverse, greens_gv, ll_evalue=NULL_OBJECT):
resuming = jitstate.get_resuming()
if resuming is not None and resuming.mergesleft == 0:
node = resuming.path.pop()
assert isinstance(node, PromotionPathSplit)
if condbox is not None:
ok = condbox.learn_boolvalue(jitstate, node.answer ^ reverse)
assert ok
return node.answer
later_gv = jitstate.get_locals_gv() # alive gvs on the later path
if ll_evalue: # special case - we want jump_if_true in split_raisingop
later_builder = jitstate.curbuilder.jump_if_true(exitgvar, later_gv)
else:
later_builder = jitstate.curbuilder.jump_if_false(exitgvar, later_gv)
memo = rvalue.copy_memo()
jitstate2 = jitstate.split(later_builder, resumepoint, greens_gv, memo)
if condbox is not None:
ok = condbox.learn_boolvalue(jitstate, True ^ reverse)
assert ok
try:
copybox = memo.boxes[condbox]
except KeyError:
pass
else:
ok = copybox.learn_boolvalue(jitstate2, reverse)
assert ok
if ll_evalue:
jitstate2.residual_ll_exception(ll_evalue)
if resuming is None:
node = jitstate.promotion_path
jitstate2.promotion_path = PromotionPathNo(node)
jitstate .promotion_path = PromotionPathYes(node)
return True
def split_raisingop(jitstate, resumepoint, ll_evalue, *greens_gv):
exitgvar = jitstate.greens.pop() # pushed here by the raising op
if exitgvar.is_const:
gotexc = exitgvar.revealconst(lltype.Bool)
else:
gotexc = not split_nonconstantcase(jitstate, exitgvar, resumepoint,
None, False, list(greens_gv),
ll_evalue)
if gotexc:
jitstate.residual_ll_exception(ll_evalue)
def collect_split(jitstate_chain, resumepoint, *greens_gv):
# YYY split to avoid over-specialization
# assumes that the head of the jitstate_chain is ready for writing,
# and all the other jitstates in the chain are paused
greens_gv = list(greens_gv)
pending = jitstate_chain
resuming = jitstate_chain.get_resuming()
if resuming is not None and resuming.mergesleft == 0:
node = resuming.path.pop()
assert isinstance(node, PromotionPathCollectSplit)
for i in range(node.n):
pending = pending.next
pending.greens.extend(greens_gv)
if pending.returnbox is not None:
pending.frame.local_boxes.insert(0, getreturnbox(pending))
pending.next = None
start_writing(pending, jitstate_chain)
return pending
n = 0
while True:
jitstate = pending
pending = pending.next
jitstate.greens.extend(greens_gv) # item 0 is the return value
if jitstate.returnbox is not None:
jitstate.frame.local_boxes.insert(0, getreturnbox(jitstate))
jitstate.resumepoint = resumepoint
if resuming is None:
node = jitstate.promotion_path
jitstate.promotion_path = PromotionPathCollectSplit(node, n)
n += 1
if pending is None:
break
dispatchqueue = jitstate_chain.frame.dispatchqueue
jitstate.next = dispatchqueue.split_chain
dispatchqueue.split_chain = jitstate_chain.next
jitstate_chain.next = None
return jitstate_chain
# XXX obscurity++ above
def reverse_split_queue(dispatchqueue):
newchain = None
while dispatchqueue.split_chain:
jitstate = dispatchqueue.split_chain
dispatchqueue.split_chain = jitstate.next
jitstate.next = newchain
newchain = jitstate
dispatchqueue.split_chain = newchain
def dispatch_next(dispatchqueue):
if dispatchqueue.split_chain is not None:
jitstate = dispatchqueue.split_chain
dispatchqueue.split_chain = jitstate.next
jitstate.curbuilder.start_writing()
return jitstate
elif dispatchqueue.global_merge_chain is not None:
jitstate = dispatchqueue.global_merge_chain
dispatchqueue.global_merge_chain = jitstate.next
jitstate.curbuilder.start_writing()
return jitstate
else:
return None
def getresumepoint(jitstate):
if jitstate is None:
return -1 # done
else:
return jitstate.resumepoint
def save_locals(jitstate, *redboxes):
redboxes = list(redboxes)
assert None not in redboxes
jitstate.frame.local_boxes = redboxes
def save_greens(jitstate, *greens_gv):
jitstate.greens = list(greens_gv)
def getlocalbox(jitstate, i):
return jitstate.frame.local_boxes[i]
def ll_getgreenbox(jitstate, i, T):
return jitstate.greens[i].revealconst(T)
def getreturnbox(jitstate):
retbox = jitstate.returnbox
jitstate.returnbox = None
return retbox
def getexctypebox(jitstate):
return jitstate.exc_type_box
def getexcvaluebox(jitstate):
return jitstate.exc_value_box
def setexctypebox(jitstate, box):
jitstate.exc_type_box = box
def setexcvaluebox(jitstate, box):
jitstate.exc_value_box = box
def setexception(jitstate, typebox, valuebox):
ok1 = typebox .learn_nonzeroness(jitstate, True)
ok2 = valuebox.learn_nonzeroness(jitstate, True)
assert ok1 & ok2 # probably... maybe it's false but it would be
# nice to see what kind of contrieved code can
# make this fail :-)
jitstate.exc_type_box = typebox
jitstate.exc_value_box = valuebox
def save_return(jitstate):
# add 'jitstate' to the chain of return-jitstates
jitstate.pause()
dispatchqueue = jitstate.frame.dispatchqueue
jitstate.next = dispatchqueue.return_chain
dispatchqueue.return_chain = jitstate
def ll_learn_nonzeroness(jitstate, ptrbox, nonzeroness):
ptrbox.learn_nonzeroness(jitstate, nonzeroness)
##def ll_gvar_from_redbox(jitstate, redbox):
## return redbox.getgenvar(jitstate)
##def ll_gvar_from_constant(jitstate, ll_value):
## return jitstate.curbuilder.rgenop.genconst(ll_value)
class CallDesc:
__metaclass__ = cachedtype
def __init__(self, RGenOp, FUNCTYPE):
self.sigtoken = RGenOp.sigToken(FUNCTYPE)
self.result_kind = RGenOp.kindToken(FUNCTYPE.RESULT)
# xxx what if the result is virtualizable?
self.redboxbuilder = rvalue.ll_redboxbuilder(FUNCTYPE.RESULT)
whatever_return_value = FUNCTYPE.RESULT._defl()
def green_call(jitstate, fnptr, *args):
try:
result = fnptr(*args)
except Exception, e:
jitstate.residual_exception(e)
result = whatever_return_value
return result
self.green_call = green_call
def _freeze_(self):
return True
def ll_gen_residual_call(jitstate, calldesc, funcbox):
# specialization is not useful here, we can unify the calldescs
return gen_residual_call(jitstate, calldesc, funcbox)
def gen_residual_call(jitstate, calldesc, funcbox):
builder = jitstate.curbuilder
gv_funcbox = funcbox.getgenvar(jitstate)
argboxes = jitstate.frame.local_boxes
args_gv = [argbox.getgenvar(jitstate) for argbox in argboxes]
jitstate.prepare_for_residual_call()
gv_result = builder.genop_call(calldesc.sigtoken, gv_funcbox, args_gv)
return calldesc.redboxbuilder(calldesc.result_kind, gv_result)
def ll_after_residual_call(jitstate, exceptiondesc, check_forced):
builder = jitstate.curbuilder
if check_forced:
gv_flags = jitstate.check_forced_after_residual_call()
else:
gv_flags = None
if exceptiondesc:
if exceptiondesc.lazy_exception_path:
gv_occurred = exceptiondesc.gen_exc_occurred(builder)
gv_flag = builder.genop1("cast_bool_to_int", gv_occurred)
if gv_flags is None:
gv_flags = gv_flag
else:
gv_flags = builder.genop2("int_or", gv_flags, gv_flag)
else:
assert gv_flags is None
exceptiondesc.fetch_global_excdata(jitstate)
if gv_flags is None:
gv_flags = builder.rgenop.constPrebuiltGlobal(0)
return rvalue.IntRedBox(builder.rgenop.kindToken(lltype.Signed), gv_flags)
def residual_fetch(jitstate, exceptiondesc, check_forced, flagsbox):
flags = rvalue.ll_getvalue(flagsbox, lltype.Signed)
if flags & 1: # an exception occurred
exceptiondesc.fetch_global_excdata(jitstate, known_occurred=True)
if check_forced:
shapemask = flags & ~ 1
jitstate.reshape(shapemask)
def oopspec_was_residual(jitstate):
res = jitstate.generated_oop_residual_can_raise
jitstate.generated_oop_residual_can_raise = False
return res
class ResumingInfo(object):
def __init__(self, promotion_point, gv_value, path):
node = PromotionPathPromote(promotion_point.promotion_path,
promotion_point, gv_value)
path[0] = node
self.promotion_point = promotion_point
self.path = path
self.mergesleft = 0
def merges_to_see(self):
node = self.path[-1]
if isinstance(node, PromotionPathMergesToSee):
self.mergesleft = node.count
del self.path[-1]
else:
self.mergesleft = MC_IGNORE_UNTIL_RETURN
def leave_call(self, dispatchqueue):
parent_mergesleft = dispatchqueue.mergecounter
if parent_mergesleft == 0:
node = self.path.pop()
assert isinstance(node, PromotionPathBackFromReturn)
self.merges_to_see()
elif parent_mergesleft == MC_CALL_NOT_TAKEN:
self.mergesleft = 0
else:
self.mergesleft = parent_mergesleft
class PromotionPoint(object):
def __init__(self, flexswitch, incoming_gv, promotion_path):
assert promotion_path is not None
self.flexswitch = flexswitch
self.incoming_gv = incoming_gv
self.promotion_path = promotion_path
class AbstractPromotionPath(object):
cut_limit = False
class PromotionPathRoot(AbstractPromotionPath):
cut_limit = True
def __init__(self, greens_gv, rgenop, frozen, replayableblock, global_resumer):
self.greens_gv = greens_gv
self.rgenop = rgenop
self.frozen = frozen
self.replayableblock = replayableblock
self.global_resumer = global_resumer
def follow_path(self, path):
return self
def continue_compilation(self, resuminginfo):
incoming = []
memo = rvalue.unfreeze_memo()
jitstate = self.frozen.unfreeze(incoming, memo)
kinds = [box.kind for box in incoming]
builder, vars_gv = self.rgenop.replay(self.replayableblock, kinds)
for i in range(len(incoming)):
assert incoming[i].genvar is None
incoming[i].genvar = vars_gv[i]
jitstate.curbuilder = builder
jitstate.greens = self.greens_gv
assert jitstate.frame.backframe is None
resuminginfo.merges_to_see()
self.global_resumer(jitstate, resuminginfo)
builder.show_incremental_progress()
class PromotionPathNode(AbstractPromotionPath):
def __init__(self, next):
self.next = next
def follow_path(self, path):
path.append(self)
return self.next.follow_path(path)
class PromotionPathSplit(PromotionPathNode):
pass
class PromotionPathYes(PromotionPathSplit):
answer = True
class PromotionPathNo(PromotionPathSplit):
answer = False
class PromotionPathCollectSplit(PromotionPathNode):
def __init__(self, next, n):
self.next = next
self.n = n
class PromotionPathCallNotTaken(PromotionPathNode):
pass
class PromotionPathPromote(PromotionPathNode):
cut_limit = True
def __init__(self, next, promotion_point, gv_value):
self.next = next
self.promotion_point = promotion_point
self.gv_value = gv_value
class PromotionPathCall(PromotionPathNode):
cut_limit = True
class PromotionPathBackFromReturn(PromotionPathNode):
cut_limit = True
class PromotionPathMergesToSee(PromotionPathNode):
def __init__(self, next, count):
self.next = next
self.count = count
MC_IGNORE_UNTIL_RETURN = -1
MC_CALL_NOT_TAKEN = -2
class PromotionDesc:
__metaclass__ = cachedtype
def __init__(self, ERASED, hrtyper):
state = hrtyper.portalstate
def ll_continue_compilation(promotion_point_ptr, value):
try:
promotion_point = cast_base_ptr_to_instance(
PromotionPoint, promotion_point_ptr)
path = [None]
root = promotion_point.promotion_path.follow_path(path)
gv_value = root.rgenop.genconst(value)
resuminginfo = ResumingInfo(promotion_point, gv_value, path)
root.continue_compilation(resuminginfo)
state.compile_more_functions()
except Exception, e:
lloperation.llop.debug_fatalerror(
lltype.Void, "compilation-time error %s" % e)
fnptr = hrtyper.annhelper.delayedfunction(
ll_continue_compilation,
[annmodel.SomePtr(base_ptr_lltype()),
annmodel.lltype_to_annotation(ERASED)],
annmodel.s_None, needtype=True)
RGenOp = hrtyper.RGenOp
self.exceptiondesc = hrtyper.exceptiondesc
self.gv_continue_compilation = RGenOp.constPrebuiltGlobal(fnptr)
self.sigtoken = RGenOp.sigToken(lltype.typeOf(fnptr).TO)
## self.PROMOTION_POINT = r_PromotionPoint.lowleveltype
def _freeze_(self):
return True
def ll_promote(jitstate, promotebox, promotiondesc):
# the specialization by promotiondesc is not useful here, so unify paths
return promote(jitstate, promotebox, promotiondesc)
def promote(jitstate, promotebox, promotiondesc):
builder = jitstate.curbuilder
gv_switchvar = promotebox.getgenvar(jitstate)
if gv_switchvar.is_const:
return False
else:
incoming = jitstate.enter_block_sweep_virtualizables()
switchblock = enter_next_block(jitstate, incoming)
gv_switchvar = promotebox.genvar
incoming_gv = [box.genvar for box in incoming]
flexswitch, default_builder = builder.flexswitch(gv_switchvar,
incoming_gv)
resuming = jitstate.get_resuming()
if resuming is None:
jitstate.curbuilder = default_builder
# default case of the switch:
pm = PromotionPoint(flexswitch, incoming_gv,
jitstate.promotion_path)
#debug_print(lltype.Void, "PROMOTE")
ll_pm = cast_instance_to_base_ptr(pm)
gv_pm = default_builder.rgenop.genconst(ll_pm)
gv_switchvar = promotebox.genvar
exceptiondesc = promotiondesc.exceptiondesc
gv_exc_type = exceptiondesc.genop_get_exc_type (default_builder)
gv_exc_value = exceptiondesc.genop_get_exc_value(default_builder)
exceptiondesc.genop_set_exc_type (default_builder,
exceptiondesc.gv_null_exc_type )
exceptiondesc.genop_set_exc_value(default_builder,
exceptiondesc.gv_null_exc_value)
default_builder.genop_call(promotiondesc.sigtoken,
promotiondesc.gv_continue_compilation,
[gv_pm, gv_switchvar])
exceptiondesc.genop_set_exc_type (default_builder, gv_exc_type )
exceptiondesc.genop_set_exc_value(default_builder, gv_exc_value)
linkargs = []
for box in incoming:
linkargs.append(box.getgenvar(jitstate))
default_builder.finish_and_goto(linkargs, switchblock)
return True
else:
assert jitstate.promotion_path is None
if resuming.mergesleft != 0:
default_builder.pause_writing([])
return True
promotenode = resuming.path.pop()
assert isinstance(promotenode, PromotionPathPromote)
#debug_view(lltype.Void, promotenode, resuming, incoming)
pm = promotenode.promotion_point
assert pm.promotion_path is promotenode.next
# clear the complete state of dispatch queues
f = jitstate.frame
while f is not None:
f.dispatchqueue.clear()
f = f.backframe
if len(resuming.path) == 0:
incoming_gv = pm.incoming_gv
for i in range(len(incoming)):
assert not incoming[i].genvar.is_const
incoming[i].genvar = incoming_gv[i]
flexswitch = pm.flexswitch
promotebox.setgenvar(promotenode.gv_value)
jitstate.clear_resuming()
node = PromotionPathMergesToSee(promotenode, 0)
jitstate.promotion_path = node
else:
resuming.merges_to_see()
promotebox.setgenvar(promotenode.gv_value)
newbuilder = flexswitch.add_case(promotenode.gv_value)
jitstate.curbuilder = newbuilder
return False
# ____________________________________________________________
class BaseDispatchQueue(object):
resuming = None
def __init__(self):
self.split_chain = None
self.global_merge_chain = None
self.return_chain = None
self.clearlocalcaches()
def clearlocalcaches(self):
self.mergecounter = 0
def clear(self):
self.__init__()
def build_dispatch_subclass(attrnames):
if len(attrnames) == 0:
return BaseDispatchQueue
attrnames = unrolling_iterable(attrnames)
class DispatchQueue(BaseDispatchQueue):
def clearlocalcaches(self):
BaseDispatchQueue.clearlocalcaches(self)
for name in attrnames:
setattr(self, name, {}) # the new dicts have various types!
return DispatchQueue
class FrozenVirtualFrame(object):
fz_backframe = None
#fz_local_boxes = ... set by freeze()
def exactmatch(self, vframe, outgoingvarboxes, memo):
self_boxes = self.fz_local_boxes
live_boxes = vframe.local_boxes
fullmatch = True
for i in range(len(self_boxes)):
if not self_boxes[i].exactmatch(live_boxes[i],
outgoingvarboxes,
memo):
fullmatch = False
if self.fz_backframe is not None:
assert vframe.backframe is not None
if not self.fz_backframe.exactmatch(vframe.backframe,
outgoingvarboxes,
memo):
fullmatch = False
else:
assert vframe.backframe is None
return fullmatch
def unfreeze(self, incomingvarboxes, memo):
local_boxes = []
for fzbox in self.fz_local_boxes:
local_boxes.append(fzbox.unfreeze(incomingvarboxes, memo))
if self.fz_backframe is not None:
backframe = self.fz_backframe.unfreeze(incomingvarboxes, memo)
else:
backframe = None
vframe = VirtualFrame(backframe, None) # dispatch queue to be patched
vframe.local_boxes = local_boxes
return vframe
class FrozenJITState(object):
#fz_frame = ... set by freeze()
#fz_exc_type_box = ... set by freeze()
#fz_exc_value_box = ... set by freeze()
#fz_virtualizables = ... set by freeze()
def exactmatch(self, jitstate, outgoingvarboxes, memo):
if not memo.force_merge:
null1 = self.fz_exc_type_box.is_constant_nullptr()
box = jitstate.exc_type_box
null2 = (box.is_constant() and
not rvalue.ll_getvalue(box, llmemory.Address))
if null1 != null2:
raise rvalue.DontMerge # a jit-with-exc. and a jit-without-exc.
fullmatch = True
if not self.fz_frame.exactmatch(jitstate.frame,
outgoingvarboxes,
memo):
fullmatch = False
if not self.fz_exc_type_box.exactmatch(jitstate.exc_type_box,
outgoingvarboxes,
memo):
fullmatch = False
if not self.fz_exc_value_box.exactmatch(jitstate.exc_value_box,
outgoingvarboxes,
memo):
fullmatch = False
return fullmatch
def unfreeze(self, incomingvarboxes, memo):
frame = self.fz_frame .unfreeze(incomingvarboxes, memo)
exc_type_box = self.fz_exc_type_box .unfreeze(incomingvarboxes, memo)
exc_value_box = self.fz_exc_value_box.unfreeze(incomingvarboxes, memo)
virtualizables = []
for fz_virtualizable_box in self.fz_virtualizables:
virtualizable_box = fz_virtualizable_box.unfreeze(incomingvarboxes,
memo)
assert isinstance(virtualizable_box, rvalue.PtrRedBox)
virtualizables.append(virtualizable_box)
return JITState(None, frame, exc_type_box, exc_value_box,
virtualizables=virtualizables)
class VirtualFrame(object):
def __init__(self, backframe, dispatchqueue):
self.backframe = backframe
self.dispatchqueue = dispatchqueue
#self.local_boxes = ... set by callers
def enter_block(self, incoming, memo):
for box in self.local_boxes:
box.enter_block(incoming, memo)
if self.backframe is not None:
self.backframe.enter_block(incoming, memo)
def freeze(self, memo):
result = FrozenVirtualFrame()
frozens = [box.freeze(memo) for box in self.local_boxes]
result.fz_local_boxes = frozens
if self.backframe is not None:
result.fz_backframe = self.backframe.freeze(memo)
return result
def copy(self, memo):
if self.backframe is None:
newbackframe = None
else:
newbackframe = self.backframe.copy(memo)
result = VirtualFrame(newbackframe, self.dispatchqueue)
result.local_boxes = [box.copy(memo) for box in self.local_boxes]
return result
def replace(self, memo):
local_boxes = self.local_boxes
for i in range(len(local_boxes)):
local_boxes[i] = local_boxes[i].replace(memo)
if self.backframe is not None:
self.backframe.replace(memo)
class JITState(object):
_attrs_ = """curbuilder frame
exc_type_box exc_value_box
greens
returnbox
promotion_path
resumepoint resuming
next
virtualizables
shape_place
forced_boxes
generated_oop_residual_can_raise
""".split()
returnbox = None
next = None # for linked lists
promotion_path = None
generated_oop_residual_can_raise = False
def __init__(self, builder, frame, exc_type_box, exc_value_box,
resumepoint=-1, newgreens=[], virtualizables=None):
self.curbuilder = builder
self.frame = frame
self.exc_type_box = exc_type_box
self.exc_value_box = exc_value_box
self.resumepoint = resumepoint
self.greens = newgreens
# XXX can not be adictionary
# it needs to be iterated in a deterministic order.
if virtualizables is None:
virtualizables = []
self.virtualizables = virtualizables
def add_virtualizable(self, virtualizable_box):
assert isinstance(virtualizable_box, rvalue.PtrRedBox)
if virtualizable_box not in self.virtualizables:
self.virtualizables.append(virtualizable_box)
def split(self, newbuilder, newresumepoint, newgreens, memo):
virtualizables = []
for virtualizable_box in self.virtualizables:
new_virtualizable_box = virtualizable_box.copy(memo)
assert isinstance(new_virtualizable_box, rvalue.PtrRedBox)
virtualizables.append(new_virtualizable_box)
later_jitstate = JITState(newbuilder,
self.frame.copy(memo),
self.exc_type_box .copy(memo),
self.exc_value_box.copy(memo),
newresumepoint,
newgreens,
virtualizables)
# add the later_jitstate to the chain of pending-for-dispatch_next()
dispatchqueue = self.frame.dispatchqueue
later_jitstate.next = dispatchqueue.split_chain
dispatchqueue.split_chain = later_jitstate
return later_jitstate
def _enter_block(self, incoming, memo):
self.frame.enter_block(incoming, memo)
self.exc_type_box .enter_block(incoming, memo)
self.exc_value_box.enter_block(incoming, memo)
def enter_block_sweep_virtualizables(self):
incoming = []
memo = rvalue.enter_block_memo()
self._enter_block(incoming, memo)
virtualizables = self.virtualizables
builder = self.curbuilder
self.virtualizables = []
for virtualizable_box in virtualizables:
if virtualizable_box.content in memo.containers:
self.virtualizables.append(virtualizable_box)
else:
content = virtualizable_box.content
assert isinstance(content, rcontainer.VirtualizableStruct)
content.store_back(self)
return incoming
def prepare_for_residual_call(self):
virtualizables = self.virtualizables
if virtualizables:
builder = self.curbuilder
memo = rvalue.make_vrti_memo()
memo.bitcount = 1
memo.frameindex = 0
memo.framevars_gv = []
memo.forced_boxes = forced_boxes = []
shape_kind = builder.rgenop.kindToken(lltype.Signed)
gv_zero = builder.rgenop.genconst(0)
self.shape_place = builder.alloc_frame_place(shape_kind, gv_zero)
self.forced_boxes = forced_boxes
vable_rtis = []
for virtualizable_box in virtualizables:
content = virtualizable_box.content
assert isinstance(content, rcontainer.VirtualizableStruct)
vable_rtis.append(content.make_rti(self, memo))
assert memo.bitcount < 32
gv_base = builder.genop_get_frame_base()
frameinfo = builder.get_frame_info(memo.framevars_gv)
for i in range(len(virtualizables)):
vable_rti = vable_rtis[i]
if vable_rti is None:
continue
assert isinstance(vable_rti, rvirtualizable.VirtualizableRTI)
vable_rti.frameinfo = frameinfo
virtualizable_box = virtualizables[i]
content = virtualizable_box.content
assert isinstance(content, rcontainer.VirtualizableStruct)
content.prepare_for_residual_call(self, gv_base, vable_rti)
def check_forced_after_residual_call(self):
virtualizables = self.virtualizables
builder = self.curbuilder
if virtualizables:
for virtualizable_box in virtualizables:
content = virtualizable_box.content
assert isinstance(content, rcontainer.VirtualizableStruct)
content.check_forced_after_residual_call(self)
shape_kind = builder.rgenop.kindToken(lltype.Signed)
for forced_box, forced_place in self.forced_boxes:
gv_forced = builder.genop_absorb_place(forced_box.kind, forced_place)
forced_box.setgenvar(gv_forced)
self.forced_boxes = None
gv_shape = builder.genop_absorb_place(shape_kind,
self.shape_place)
self.shape_place = None
return gv_shape
else:
return None
def reshape(self, shapemask):
virtualizables = self.virtualizables
builder = self.curbuilder
if virtualizables:
memo = rvalue.make_vrti_memo()
memo.bitcount = 1
if shapemask:
memo.forced = []
else:
memo.forced = None
for virtualizable_box in virtualizables:
content = virtualizable_box.content
assert isinstance(content, rcontainer.VirtualizableStruct)
content.reshape(self, shapemask, memo)
if shapemask:
for vcontainer, gv_ptr in memo.forced:
vcontainer.setforced(gv_ptr)
def freeze(self, memo):
result = FrozenJITState()
result.fz_frame = self.frame.freeze(memo)
result.fz_exc_type_box = self.exc_type_box .freeze(memo)
result.fz_exc_value_box = self.exc_value_box.freeze(memo)
fz_virtualizables = result.fz_virtualizables = []
for virtualizable_box in self.virtualizables:
assert virtualizable_box in memo.boxes
fz_virtualizables.append(virtualizable_box.freeze(memo))
return result
def replace(self, memo):
self.frame.replace(memo)
self.exc_type_box = self.exc_type_box .replace(memo)
self.exc_value_box = self.exc_value_box.replace(memo)
virtualizables = []
for i in range(len(self.virtualizables)):
virtualizable_box = self.virtualizables[i]
new_virtualizable_box = virtualizable_box.replace(memo)
assert isinstance(new_virtualizable_box, rvalue.PtrRedBox)
self.virtualizables[i] = new_virtualizable_box
def get_locals_gv(self):
# get all the genvars that are "alive", i.e. stored in the JITState
# or the VirtualFrames
incoming = []
memo = rvalue.enter_block_memo()
self._enter_block(incoming, memo)
for virtualizable_box in self.virtualizables:
virtualizable_box.enter_block(incoming, memo)
locals_gv = [redbox.genvar for redbox in incoming]
return locals_gv
def pause(self):
locals_gv = self.get_locals_gv()
self.curbuilder = self.curbuilder.pause_writing(locals_gv)
def residual_ll_exception(self, ll_evalue):
ll_etype = ll_evalue.typeptr
etypebox = rvalue.ll_fromvalue(self, ll_etype)
evaluebox = rvalue.ll_fromvalue(self, ll_evalue)
setexctypebox (self, etypebox )
setexcvaluebox(self, evaluebox)
def residual_exception(self, e):
self.residual_ll_exception(cast_instance_to_base_ptr(e))
def get_resuming(self):
return self.frame.dispatchqueue.resuming
def clear_resuming(self):
f = self.frame
while f is not None:
f.dispatchqueue.resuming = None
f = f.backframe
def start_writing(jitstate=None, prevopen=None):
if jitstate is not prevopen:
if prevopen is not None:
prevopen.pause()
jitstate.curbuilder.start_writing()
return jitstate
def ensure_queue(jitstate, DispatchQueueClass):
return DispatchQueueClass()
ensure_queue._annspecialcase_ = 'specialize:arg(1)'
def replayable_ensure_queue(jitstate, DispatchQueueClass):
if jitstate.frame is None: # common case
return DispatchQueueClass()
else:
# replaying
dispatchqueue = jitstate.frame.dispatchqueue
assert isinstance(dispatchqueue, DispatchQueueClass)
return dispatchqueue
replayable_ensure_queue._annspecialcase_ = 'specialize:arg(1)'
def enter_frame(jitstate, dispatchqueue):
if jitstate.frame:
resuming = jitstate.get_resuming()
dispatchqueue.resuming = resuming
else:
resuming = None
jitstate.frame = VirtualFrame(jitstate.frame, dispatchqueue)
if resuming is None:
node = PromotionPathCall(jitstate.promotion_path)
node = PromotionPathMergesToSee(node, 0)
jitstate.promotion_path = node
else:
parent_mergesleft = resuming.mergesleft
resuming.mergesleft = MC_IGNORE_UNTIL_RETURN
if parent_mergesleft == 0:
node = resuming.path.pop()
if isinstance(node, PromotionPathCall):
resuming.merges_to_see()
else:
assert isinstance(node, PromotionPathCallNotTaken)
parent_mergesleft = MC_CALL_NOT_TAKEN
dispatchqueue.mergecounter = parent_mergesleft
def merge_returning_jitstates(dispatchqueue, force_merge=False):
return_chain = dispatchqueue.return_chain
return_cache = {}
still_pending = None
opened = None
while return_chain is not None:
jitstate = return_chain
return_chain = return_chain.next
opened = start_writing(jitstate, opened)
res = retrieve_jitstate_for_merge(return_cache, jitstate, (),
return_marker,
force_merge=force_merge)
if res is False: # not finished
jitstate.next = still_pending
still_pending = jitstate
else:
opened = None
# Of the jitstates we have left some may be mergable to a later
# more general one.
return_chain = still_pending
if return_chain is not None:
return_cache = {}
still_pending = None
while return_chain is not None:
jitstate = return_chain
return_chain = return_chain.next
opened = start_writing(jitstate, opened)
res = retrieve_jitstate_for_merge(return_cache, jitstate, (),
return_marker,
force_merge=force_merge)
if res is False: # not finished
jitstate.next = still_pending
still_pending = jitstate
else:
opened = None
start_writing(still_pending, opened)
return still_pending
def leave_graph_red(dispatchqueue, is_portal):
resuming = dispatchqueue.resuming
return_chain = merge_returning_jitstates(dispatchqueue,
force_merge=is_portal)
if is_portal:
assert return_chain is None or return_chain.next is None
if resuming is not None:
resuming.leave_call(dispatchqueue)
jitstate = return_chain
while jitstate is not None:
myframe = jitstate.frame
leave_frame(jitstate)
jitstate.greens = []
jitstate.returnbox = myframe.local_boxes[0]
jitstate = jitstate.next
return return_chain
def leave_graph_gray(dispatchqueue):
resuming = dispatchqueue.resuming
return_chain = merge_returning_jitstates(dispatchqueue)
if resuming is not None:
resuming.leave_call(dispatchqueue)
jitstate = return_chain
while jitstate is not None:
leave_frame(jitstate)
jitstate.greens = []
jitstate.returnbox = None
jitstate = jitstate.next
return return_chain
def leave_frame(jitstate):
resuming = jitstate.get_resuming()
myframe = jitstate.frame
backframe = myframe.backframe
jitstate.frame = backframe
if resuming is None:
#debug_view(jitstate)
node = jitstate.promotion_path
while not node.cut_limit:
node = node.next
if isinstance(node, PromotionPathCall):
node = PromotionPathCallNotTaken(node.next)
else:
node = PromotionPathBackFromReturn(node)
node = PromotionPathMergesToSee(node, 0)
jitstate.promotion_path = node
def leave_graph_yellow(mydispatchqueue):
resuming = mydispatchqueue.resuming
if resuming is not None:
resuming.leave_call(mydispatchqueue)
return_chain = mydispatchqueue.return_chain
if return_chain is not None:
jitstate = return_chain
while jitstate is not None:
leave_frame(jitstate)
jitstate = jitstate.next
# return the jitstate which is the head of the chain,
# ready for further writing
return_chain.curbuilder.start_writing()
return return_chain
| Python |
import types
import py
from pypy.tool.ansi_print import ansi_log
from pypy.objspace.flow import model as flowmodel
from pypy.translator.unsimplify import varoftype
from pypy.translator.backendopt.ssa import SSA_to_SSI
from pypy.annotation import model as annmodel
from pypy.annotation import listdef
from pypy.annotation.pairtype import pair, pairtype
from pypy.rpython.annlowlevel import PseudoHighLevelCallable
from pypy.rpython.annlowlevel import cast_instance_to_base_ptr
from pypy.rpython.annlowlevel import cast_base_ptr_to_instance
from pypy.rlib.unroll import unrolling_iterable
from pypy.rpython import annlowlevel
from pypy.rpython.rtyper import RPythonTyper, LowLevelOpList, TyperError
from pypy.rpython.rmodel import Repr, inputconst
from pypy.rpython.lltypesystem.rstr import string_repr
from pypy.rpython.typesystem import LowLevelTypeSystem
from pypy.rpython.lltypesystem import lltype, llmemory
from pypy.jit.hintannotator import model as hintmodel
from pypy.jit.hintannotator import container as hintcontainer
from pypy.jit.hintannotator.model import originalconcretetype
from pypy.jit.timeshifter import rtimeshift, rvalue, rcontainer, oop
from pypy.jit.timeshifter.exception import ExceptionDesc
from pypy.jit.codegen import model as cgmodel
class HintTypeSystem(LowLevelTypeSystem):
name = "hinttypesystem"
offers_exceptiondata = False
def perform_normalizations(self, hrtyper):
from pypy.rpython import normalizecalls
hannotator = hrtyper.annotator
call_families = hannotator.bookkeeper.tsgraph_maximal_call_families
while True:
progress = False
for callfamily in call_families.infos():
graphs = callfamily.tsgraphs.keys()
progress |= normalizecalls.normalize_calltable_row_annotation(
hannotator,
graphs)
if not progress:
break # done
HintTypeSystem.instance = HintTypeSystem()
# ___________________________________________________________
class HintRTyper(RPythonTyper):
log = py.log.Producer("timeshifter")
py.log.setconsumer("timeshifter", ansi_log)
def __init__(self, hannotator, rtyper, RGenOp):
RPythonTyper.__init__(self, hannotator,
type_system=HintTypeSystem.instance)
self.rtyper = rtyper
self.RGenOp = RGenOp
self.green_reprs = PRECOMPUTED_GREEN_REPRS.copy()
self.red_reprs = {}
#self.color_cache = {}
self.annhelper = annlowlevel.MixLevelHelperAnnotator(rtyper)
self.timeshift_mapping = {}
self.sigs = {}
self.dispatchsubclasses = {}
self.old_percentage = 0
(self.s_JITState,
self.r_JITState) = self.s_r_instanceof(rtimeshift.JITState)
(self.s_RedBox,
self.r_RedBox) = self.s_r_instanceof(rvalue.RedBox)
(self.s_PtrRedBox,
self.r_PtrRedBox) = self.s_r_instanceof(rvalue.PtrRedBox)
(self.s_ConstOrVar,
self.r_ConstOrVar) = self.s_r_instanceof(cgmodel.GenVarOrConst)
(self.s_Queue,
self.r_Queue) = self.s_r_instanceof(rtimeshift.BaseDispatchQueue)
def ll_fresh_jitstate(builder, exceptiondesc):
return rtimeshift.JITState(builder, None,
exceptiondesc.null_exc_type_box,
exceptiondesc.null_exc_value_box)
self.ll_fresh_jitstate = ll_fresh_jitstate
def ll_finish_jitstate(jitstate, exceptiondesc, graphsigtoken):
returnbox = rtimeshift.getreturnbox(jitstate)
gv_ret = returnbox.getgenvar(jitstate)
builder = jitstate.curbuilder
for virtualizable_box in jitstate.virtualizables:
assert isinstance(virtualizable_box, rvalue.PtrRedBox)
content = virtualizable_box.content
assert isinstance(content, rcontainer.VirtualizableStruct)
content.store_back(jitstate)
exceptiondesc.store_global_excdata(jitstate)
jitstate.curbuilder.finish_and_return(graphsigtoken, gv_ret)
self.ll_finish_jitstate = ll_finish_jitstate
self.v_queue = varoftype(self.r_Queue.lowleveltype, 'queue')
#self.void_red_repr = VoidRedRepr(self)
# global state for the portal corresponding to this timeshifted world
class PortalState(object):
pass
def compile_more_functions():
"Empty by default; overridden in rewire_portal()"
self.portalstate = PortalState()
self.portalstate.compile_more_functions = compile_more_functions
def specialize(self, origportalgraph=None, view=False,
dont_simplify_again=False):
"""
Driver for running the timeshifter.
"""
if not dont_simplify_again:
self.annotator.simplify()
## self.type_system.perform_normalizations(self)
bk = self.annotator.bookkeeper
## bk.compute_after_normalization()
entrygraph = self.annotator.translator.graphs[0]
self.origportalgraph = origportalgraph
if origportalgraph:
self.portalgraph = bk.get_graph_by_key(origportalgraph, None)
leaveportalgraph = self.portalgraph
else:
self.portalgraph = None
# in the case of tests not specifying a portal
# we still need to force merges when entry
# returns
leaveportalgraph = entrygraph
self.contains_promotion = False
self.portal_contains_global_mp = False
pending = [entrygraph]
seen = {entrygraph: True}
while pending:
graph = pending.pop()
for nextgraph in self.timeshift_cflow(graph,
is_portal=graph is leaveportalgraph):
if nextgraph not in seen:
pending.append(nextgraph)
seen[nextgraph] = True
if self.contains_promotion:
assert self.portal_contains_global_mp, (
"No global merge point found. "
"Forgot 'hint(None, global_merge_point=True)'?")
self.log.event("Timeshifted control flow of %d graphs." % (len(seen),))
self.exceptiondesc = ExceptionDesc(self,
self.portal_contains_global_mp)
#import pdb; pdb.set_trace()
# only keep the hint-annotated graphs that are really useful
self.annotator.translator.graphs = [graph
for graph in self.annotator.translator.graphs
if graph in seen]
if view:
self.annotator.translator.view() # in the middle
self.blockcount = 0
self.graphcount = 0
self.ngraphs = len(seen)
for graph in seen:
self.timeshift_ops(graph)
self.log.event("Completed timeshifting of %d graphs." % (len(seen),))
if origportalgraph:
n = len(list(self.portalgraph.iterblocks()))
self.log.event("portal has now %d blocks" % n)
self.rewire_portal()
# move the timeshifted graphs into the original translator
base_translator = self.annotator.base_translator
for graph in self.annotator.translator.graphs:
flowmodel.checkgraph(graph)
base_translator.graphs.append(graph)
# remember a shared pointer for the portal graph,
# so that it can be later patched by rewire_portal.
# this pointer is going to be used by the resuming logic
# and portal (re)entry.
def naked_tsfnptr(self, tsgraph):
if tsgraph is self.portalgraph:
try:
return self.portal_tsfnptr
except AttributeError:
self.portal_tsfnptr = self.gettscallable(tsgraph)
return self.portal_tsfnptr
return self.gettscallable(tsgraph)
def rewire_portal(self):
origportalgraph = self.origportalgraph
portalgraph = self.portalgraph
annhelper = self.annhelper
rgenop = self.RGenOp()
args_specification = []
portal_args_s = []
for v in portalgraph.getargs()[1:]:
r = self.bindingrepr(v)
if isinstance(r, GreenRepr):
arg_spec = "green", None, None
portal_args_s.append(annmodel.lltype_to_annotation(
r.lowleveltype))
else:
arg_spec = "red", r.residual_args_collector(), r.arg_redbox_maker()
portal_args_s.append(self.s_RedBox)
args_specification.append(arg_spec)
tsportalgraph = portalgraph
# patch the shared portal pointer
portalgraph = flowmodel.copygraph(tsportalgraph, shallow=True)
portalgraph.tag = 'portal'
self.annotator.translator.graphs.append(portalgraph)
portal_fnptr = self.naked_tsfnptr(self.portalgraph)
portal_fnptr._obj.graph = portalgraph
portal_fn = PseudoHighLevelCallable(
portal_fnptr,
[self.s_JITState] + portal_args_s,
self.s_JITState)
FUNC = self.get_residual_functype(portalgraph)
RESTYPE = FUNC.RESULT
reskind = rgenop.kindToken(RESTYPE)
boxbuilder = rvalue.ll_redboxbuilder(RESTYPE)
args_specification = unrolling_iterable(args_specification)
fresh_jitstate = self.ll_fresh_jitstate
finish_jitstate = self.ll_finish_jitstate
exceptiondesc = self.exceptiondesc
sigtoken = rgenop.sigToken(FUNC)
# debug helper
def readportal(*args):
i = 0
key = ()
for color, _, _ in args_specification:
if color == "green":
x = args[i]
if isinstance(lltype.typeOf(x), lltype.Ptr):
x = llmemory.cast_ptr_to_adr(x)
key = key + (x,)
i = i + 1
cache = state.cache
try:
gv_generated = cache[key]
except KeyError:
return lltype.nullptr(FUNC)
fn = gv_generated.revealconst(lltype.Ptr(FUNC))
return fn
def readallportals():
return [gv_gen.revealconst(lltype.Ptr(FUNC))
for gv_gen in state.cache.values()]
def portalentry(*args):
i = 0
key = ()
residualargs = ()
for color, collect_residual_args, _ in args_specification:
if color == "green":
x = args[i]
if isinstance(lltype.typeOf(x), lltype.Ptr):
x = llmemory.cast_ptr_to_adr(x)
key = key + (x,)
else:
residualargs = residualargs + collect_residual_args(args[i])
i = i + 1
cache = state.cache
try:
gv_generated = cache[key]
except KeyError:
portal_ts_args = ()
builder, gv_generated, inputargs_gv = rgenop.newgraph(sigtoken,
"generated")
cache[key] = gv_generated
top_jitstate = fresh_jitstate(builder, exceptiondesc)
i = 0
for color, _, make_arg_redbox in args_specification:
if color == "green":
llvalue = args[0]
args = args[1:]
portal_ts_args += (llvalue,)
else:
llvalue = args[0]
args = args[1:]
box = make_arg_redbox(top_jitstate, inputargs_gv, i)
i += make_arg_redbox.consumes
portal_ts_args += (box,)
state.graph_compilation_queue.append((top_jitstate, portal_ts_args))
compile_more_functions()
fn = gv_generated.revealconst(lltype.Ptr(FUNC))
return fn(*residualargs)
def compile_more_functions():
while state.graph_compilation_queue:
top_jitstate, portal_ts_args = state.graph_compilation_queue.pop()
builder = top_jitstate.curbuilder
builder.start_writing()
top_jitstate = portal_fn(top_jitstate, *portal_ts_args)
if top_jitstate is not None:
finish_jitstate(top_jitstate, exceptiondesc, sigtoken)
builder.end()
builder.show_incremental_progress()
state = self.portalstate
state.cache = {}
state.graph_compilation_queue = []
state.compile_more_functions = compile_more_functions
args_s = [annmodel.lltype_to_annotation(v.concretetype) for
v in origportalgraph.getargs()]
s_result = annmodel.lltype_to_annotation(
origportalgraph.getreturnvar().concretetype)
portalentrygraph = annhelper.getgraph(portalentry, args_s, s_result)
x = self.annotator.base_translator.graphs.pop()
assert portalentrygraph is x
s_funcptr = annmodel.SomePtr(lltype.Ptr(FUNC))
self.readportalgraph = annhelper.getgraph(readportal, args_s,
s_funcptr)
s_funcptrlist = annmodel.SomeList(listdef.ListDef(None, s_funcptr,
resized=True))
self.readallportalsgraph = annhelper.getgraph(readallportals, [],
s_funcptrlist)
TYPES = [v.concretetype for v in origportalgraph.getargs()]
argspecandtypes = unrolling_iterable(zip(args_specification,
TYPES))
fetch_global_excdata = self.exceptiondesc.fetch_global_excdata
def portalreentry(jitstate, *args): # xxx virtualizables?
i = 0
key = ()
curbuilder = jitstate.curbuilder
args_gv = []
for color, _, _ in args_specification:
if color == "green":
x = args[i]
if isinstance(lltype.typeOf(x), lltype.Ptr):
x = llmemory.cast_ptr_to_adr(x)
key = key + (x,)
else:
box = args[i]
args_gv.append(box.getgenvar(jitstate))
i = i + 1
cache = state.cache
try:
gv_generated = cache[key]
except KeyError:
portal_ts_args = ()
builder, gv_generated, inputargs_gv = rgenop.newgraph(sigtoken,
"generated")
cache[key] = gv_generated
i = 0
for (color, _, _), T in argspecandtypes:
if color == "green":
llvalue = args[0]
args = args[1:]
portal_ts_args += (llvalue,)
else:
args = args[1:]
kind = rgenop.kindToken(T)
boxcls = rvalue.ll_redboxcls(T)
gv_arg = inputargs_gv[i]
box = boxcls(kind, gv_arg)
i += 1
portal_ts_args += (box,)
top_jitstate = fresh_jitstate(builder, exceptiondesc)
state.graph_compilation_queue.append((top_jitstate, portal_ts_args))
gv_res = curbuilder.genop_call(sigtoken, gv_generated, args_gv)
fetch_global_excdata(jitstate)
if RESTYPE == lltype.Void:
retbox = None
else:
retbox = boxbuilder(reskind, gv_res)
jitstate.returnbox = retbox
assert jitstate.next is None
return jitstate
portalreentrygraph = annhelper.getgraph(portalreentry,
[self.s_JITState] + portal_args_s, self.s_JITState)
x = self.annotator.base_translator.graphs.pop()
assert portalreentrygraph is x
annhelper.finish()
origportalgraph.startblock = portalentrygraph.startblock
origportalgraph.returnblock = portalentrygraph.returnblock
origportalgraph.exceptblock = portalentrygraph.exceptblock
origportalgraph.tag = "PortalEntry"
origportalgraph.name += '_portal_entry'
tsportalgraph.startblock = portalreentrygraph.startblock
tsportalgraph.returnblock = portalreentrygraph.returnblock
tsportalgraph.exceptblock = portalreentrygraph.exceptblock
tsportalgraph.tag = "PortalReentry"
tsportalgraph.name += '_portal_reentry'
def timeshift_cflow(self, graph, is_portal=False):
# prepare the graphs by inserting all bookkeeping/dispatching logic
# as special operations
from pypy.jit.timeshifter.transform import HintGraphTransformer
assert graph.startblock in self.annotator.annotated
transformer = HintGraphTransformer(self.annotator, graph,
is_portal=is_portal)
transformer.transform()
flowmodel.checkgraph(graph) # for now
self.contains_promotion |= transformer.contains_promotion
global_mp = transformer.mergepointfamily.has_global_mergepoints()
if is_portal:
self.portal_contains_global_mp = global_mp
else:
assert not global_mp, ("global_merge_point only allowed in portal"
" - found one in %s" % (graph,))
return transformer.tsgraphs_seen
def timeshift_ops(self, graph):
# specialize all blocks of this graph
for block in list(graph.iterblocks()):
self.annotator.annotated[block] = graph
self.specialize_block(block)
self.blockcount += 1
if self.blockcount % 100 == 0:
percentage = 100 * self.graphcount / self.ngraphs
if percentage >= self.old_percentage + 5:
self.old_percentage = percentage
self.log.event("Timeshifted ops in %d blocks, %d/%d graphs (%d %%)" %
(self.blockcount, self.graphcount,
self.ngraphs, percentage))
self.graphcount += 1
# "normalize" the graphs by putting an explicit v_jitstate variable
# everywhere
self.insert_v_jitstate_everywhere(graph)
SSA_to_SSI(graph, annotator=self.annotator)
# the graph is now timeshifted, so it is *itself* no longer
# exception-transformed...
del graph.exceptiontransformed
# ____________________________________________________________
def s_r_instanceof(self, cls, can_be_None=True):
# Return a SomeInstance / InstanceRepr pair correspnding to the specified class.
return self.annhelper.s_r_instanceof(cls, can_be_None=can_be_None)
def get_sig_hs(self, tsgraph):
# the signature annotations are cached on the HintBookkeeper because
# the graph is transformed already
return self.annotator.bookkeeper.tsgraphsigs[tsgraph]
def get_residual_functype(self, tsgraph):
ha = self.annotator
args_hs, hs_res = self.get_sig_hs(ha.translator.graphs[0])
RESTYPE = originalconcretetype(hs_res)
args_r = [self.getrepr(hs_arg) for hs_arg in args_hs
if not hs_arg.is_green()]
ARGS = []
for r_arg in args_r:
ARGS += r_arg.residual_argtypes()
return lltype.FuncType(ARGS, RESTYPE)
def make_new_lloplist(self, block):
return HintLowLevelOpList(self)
def translate_no_return_value(self, hop):
op = hop.spaceop
if op.result.concretetype is not lltype.Void:
raise TyperError("the hint-annotator doesn't agree that '%s' "
"returns a Void" % op.opname)
# try to avoid a same_as in common cases
if (len(hop.llops) > 0
and hop.llops[-1].result.concretetype is lltype.Void):
hop.llops[-1].result = op.result
else:
hop.llops.append(flowmodel.SpaceOperation('same_as',
[c_void],
op.result))
def getgreenrepr(self, lowleveltype):
try:
return self.green_reprs[lowleveltype]
except KeyError:
r = GreenRepr(lowleveltype)
self.green_reprs[lowleveltype] = r
return r
def getredrepr(self, lowleveltype):
try:
return self.red_reprs[lowleveltype]
except KeyError:
assert not isinstance(lowleveltype, lltype.ContainerType)
redreprcls = RedRepr
if isinstance(lowleveltype, lltype.Ptr):
if isinstance(lowleveltype.TO, lltype.Struct):
if lowleveltype.TO._hints.get('virtualizable', False):
redreprcls = RedVirtualizableStructRepr
else:
redreprcls = RedStructRepr
r = redreprcls(lowleveltype, self)
self.red_reprs[lowleveltype] = r
return r
## def getredrepr_or_none(self, lowleveltype):
## if lowleveltype is lltype.Void:
## return self.void_red_repr
## else:
## return self.getredrepr(lowleveltype)
## def gethscolor(self, hs):
## try:
## return self.color_cache[id(hs)]
## except KeyError:
## if hs.is_green():
## color = "green"
## else:
## color = "red"
## self.color_cache[id(hs)] = color
## return color
def get_dispatch_subclass(self, mergepointfamily):
try:
return self.dispatchsubclasses[mergepointfamily]
except KeyError:
attrnames = mergepointfamily.getlocalattrnames()
subclass = rtimeshift.build_dispatch_subclass(attrnames)
self.dispatchsubclasses[mergepointfamily] = subclass
return subclass
def get_args_r(self, tsgraph):
args_hs, hs_res = self.get_sig_hs(tsgraph)
return [self.getrepr(hs_arg) for hs_arg in args_hs]
def gettscallable(self, tsgraph):
args_r = self.get_args_r(tsgraph)
ARGS = [self.r_JITState.lowleveltype]
ARGS += [r.lowleveltype for r in args_r]
RESULT = self.r_JITState.lowleveltype
return lltype.functionptr(lltype.FuncType(ARGS, RESULT),
tsgraph.name,
graph=tsgraph)
def get_timeshift_mapper(self, graph2ts):
# XXX try to share the results between "similar enough" graph2ts'es
key = graph2ts.items()
key.sort()
key = tuple(key)
try:
return self.timeshift_mapping[key]
except KeyError:
pass
bk = self.annotator.bookkeeper
keys = []
values = []
common_args_r = None
COMMON_TS_FUNC = None
for graph, tsgraph in graph2ts.items():
fnptr = self.rtyper.getcallable(graph)
ts_fnptr = self.gettscallable(tsgraph)
args_r = self.get_args_r(tsgraph)
TS_FUNC = lltype.typeOf(ts_fnptr)
if common_args_r is None:
common_args_r = args_r
COMMON_TS_FUNC = TS_FUNC
else:
# should be ensured by normalization
assert COMMON_TS_FUNC == TS_FUNC
assert common_args_r == args_r
keys.append(fnptr)
values.append(ts_fnptr)
fnptrmap = {}
def getter(fnptrmap, fnptr):
# indirection needed to defeat the flow object space
return fnptrmap[llmemory.cast_ptr_to_adr(fnptr)]
def fill_dict(fnptrmap, values, keys):
for i in range(len(values)):
fnptrmap[llmemory.cast_ptr_to_adr(keys[i])] = values[i]
def timeshift_mapper(fnptr):
try:
return getter(fnptrmap, fnptr)
except KeyError:
fill_dict(fnptrmap, values, keys)
return getter(fnptrmap, fnptr) # try again
result = timeshift_mapper, COMMON_TS_FUNC, common_args_r
self.timeshift_mapping[key] = result
return result
def insert_v_jitstate_everywhere(self, graph):
for block in graph.iterblocks():
v_jitstate = varoftype(self.r_JITState.lowleveltype, 'jitstate')
if block is graph.returnblock:
assert block.inputargs[0].concretetype is lltype.Void
del block.inputargs[0]
block.inputargs = [v_jitstate] + block.inputargs
for op in block.operations:
if op.opname == 'getjitstate':
op.opname = 'same_as'
op.args = [v_jitstate]
elif op.opname == 'setjitstate':
[v_jitstate] = op.args
for i in range(len(block.operations)-1, -1, -1):
if block.operations[i].opname == 'setjitstate':
del block.operations[i]
for link in block.exits:
if link.target is graph.returnblock:
del link.args[0] # Void
link.args = [v_jitstate] + link.args
def generic_translate_operation(self, hop):
# detect constant-foldable all-green operations
if hop.spaceop.opname not in rtimeshift.FOLDABLE_GREEN_OPS:
return None
green = True
for r_arg in hop.args_r:
green = green and isinstance(r_arg, GreenRepr)
if green and isinstance(hop.r_result, GreenRepr):
# Just generate the same operation in the timeshifted graph.
hop.llops.append(hop.spaceop)
return hop.spaceop.result
else:
#print "RED op", hop.spaceop
return None
def default_translate_operation(self, hop):
# by default, a red operation converts all its arguments to
# genop variables, and emits a call to a helper that will generate
# the same operation at run-time
opdesc = rtimeshift.make_opdesc(hop)
if opdesc.nb_args == 1:
ll_generate = rtimeshift.ll_gen1
elif opdesc.nb_args == 2:
ll_generate = rtimeshift.ll_gen2
ts = self
c_opdesc = inputconst(lltype.Void, opdesc)
s_opdesc = ts.rtyper.annotator.bookkeeper.immutablevalue(opdesc)
v_jitstate = hop.llops.getjitstate()
args_v = hop.inputargs(*[self.getredrepr(originalconcretetype(hs))
for hs in hop.args_s])
args_s = [ts.s_RedBox] * len(args_v)
return hop.llops.genmixlevelhelpercall(ll_generate,
[s_opdesc, ts.s_JITState] + args_s,
[c_opdesc, v_jitstate] + args_v,
ts.s_RedBox)
def translate_op_debug_assert(self, hop):
pass
def translate_op_debug_assert_ptr_nonzero(self, hop, nonzeroness=True):
hs = hop.args_s[0]
if hs.is_green():
return
v_box = hop.inputarg(self.getredrepr(originalconcretetype(hs)), arg=0)
v_box = hop.llops.as_ptrredbox(v_box)
c_nonzeroness = hop.inputconst(lltype.Bool, nonzeroness)
v_jitstate = hop.llops.getjitstate()
hop.llops.genmixlevelhelpercall(rtimeshift.ll_learn_nonzeroness,
[self.s_JITState, self.s_PtrRedBox, annmodel.s_Bool],
[v_jitstate, v_box , c_nonzeroness ],
annmodel.s_None)
def translate_op_debug_assert_ptr_iszero(self, hop):
self.translate_op_debug_assert_ptr_nonzero(hop, nonzeroness=False)
def translate_op_resume_point(self, hop):
pass
def translate_op_keepalive(self,hop):
pass
def translate_op_same_as(self, hop):
[v] = hop.inputargs(hop.r_result)
return v
def translate_op_ts_metacall(self, hop):
# note that if the ts_metacall operation is pure and green, then
# we don't even get there because the original graph in which
# it is will just be green_call'ed by the caller.
args_r = []
args_s = []
for hs in hop.args_s[2:]:
T = originalconcretetype(hs)
if T is lltype.Void:
args_r.append(lltype.Void)
args_s.append(annmodel.s_None)
else:
args_r.append(self.getredrepr(T))
args_s.append(self.s_RedBox)
vlist = hop.inputargs(lltype.Void, lltype.Void, *args_r)
metadesccls = vlist[1].value
metadesc = metadesccls(self)
metafunc = metadesc.metafunc
v_jitstate = hop.llops.getjitstate()
return hop.llops.genmixlevelhelpercall(metafunc,
[self.s_JITState] + args_s,
[v_jitstate] + vlist[2:],
self.s_RedBox)
def translate_op_getfield(self, hop):
if isinstance(hop.args_r[0], BlueRepr):
return hop.args_r[0].timeshift_getfield(hop)
ts = self
if hop.args_v[0] == ts.exceptiondesc.cexcdata:
# reading one of the exception boxes (exc_type or exc_value)
fieldname = hop.args_v[1].value
if fieldname == 'exc_type':
reader = rtimeshift.getexctypebox
elif fieldname == 'exc_value':
reader = rtimeshift.getexcvaluebox
else:
raise Exception("getfield(exc_data, %r)" % (fieldname,))
v_jitstate = hop.llops.getjitstate()
return hop.llops.genmixlevelhelpercall(reader,
[ts.s_JITState],
[v_jitstate ],
ts.s_RedBox)
# virtualizable access read
PTRTYPE = originalconcretetype(hop.args_s[0])
if PTRTYPE.TO._hints.get('virtualizable', False):
assert hop.args_v[1].value != 'vable_access'
# non virtual case
v_argbox, c_fieldname = hop.inputargs(self.getredrepr(PTRTYPE),
green_void_repr)
v_argbox = hop.llops.as_ptrredbox(v_argbox)
c_deepfrozen = inputconst(lltype.Bool, hop.args_s[0].deepfrozen)
structdesc = rcontainer.StructTypeDesc(self, PTRTYPE.TO)
fielddesc = structdesc.getfielddesc(c_fieldname.value)
if fielddesc is None: # Void field
return
c_fielddesc = inputconst(lltype.Void, fielddesc)
s_fielddesc = ts.rtyper.annotator.bookkeeper.immutablevalue(fielddesc)
v_jitstate = hop.llops.getjitstate()
return hop.llops.genmixlevelhelpercall(rtimeshift.ll_gengetfield,
[ts.s_JITState, annmodel.s_Bool, s_fielddesc, ts.s_PtrRedBox],
[v_jitstate , c_deepfrozen , c_fielddesc, v_argbox ],
ts.s_RedBox)
def translate_op_getarrayitem(self, hop):
PTRTYPE = originalconcretetype(hop.args_s[0])
if PTRTYPE.TO.OF is lltype.Void:
return
ts = self
v_argbox, v_index = hop.inputargs(self.getredrepr(PTRTYPE),
self.getredrepr(lltype.Signed))
c_deepfrozen = inputconst(lltype.Bool, hop.args_s[0].deepfrozen)
fielddesc = rcontainer.ArrayFieldDesc(self, PTRTYPE.TO)
c_fielddesc = inputconst(lltype.Void, fielddesc)
s_fielddesc = ts.rtyper.annotator.bookkeeper.immutablevalue(fielddesc)
v_jitstate = hop.llops.getjitstate()
return hop.llops.genmixlevelhelpercall(
rtimeshift.ll_gengetarrayitem,
[ts.s_JITState, annmodel.s_Bool, s_fielddesc,
ts.s_RedBox, ts.s_RedBox],
[v_jitstate, c_deepfrozen, c_fielddesc,
v_argbox, v_index ],
ts.s_RedBox)
def translate_op_getarraysize(self, hop):
PTRTYPE = originalconcretetype(hop.args_s[0])
ts = self
[v_argbox] = hop.inputargs(self.getredrepr(PTRTYPE))
fielddesc = rcontainer.ArrayFieldDesc(self, PTRTYPE.TO)
c_fielddesc = inputconst(lltype.Void, fielddesc)
s_fielddesc = ts.rtyper.annotator.bookkeeper.immutablevalue(fielddesc)
v_jitstate = hop.llops.getjitstate()
return hop.llops.genmixlevelhelpercall(
rtimeshift.ll_gengetarraysize,
[ts.s_JITState, s_fielddesc, ts.s_RedBox],
[v_jitstate, c_fielddesc, v_argbox ],
ts.s_RedBox)
def translate_op_setfield(self, hop):
if isinstance(hop.args_r[0], BlueRepr):
return hop.args_r[0].timeshift_setfield(hop)
ts = self
PTRTYPE = originalconcretetype(hop.args_s[0])
VALUETYPE = originalconcretetype(hop.args_s[2])
if VALUETYPE is lltype.Void:
return
if hop.args_v[0] == ts.exceptiondesc.cexcdata:
# reading one of the exception boxes (exc_type or exc_value)
fieldname = hop.args_v[1].value
if fieldname == 'exc_type':
writer = rtimeshift.setexctypebox
elif fieldname == 'exc_value':
writer = rtimeshift.setexcvaluebox
else:
raise Exception("setfield(exc_data, %r)" % (fieldname,))
v_valuebox = hop.inputarg(self.getredrepr(VALUETYPE), arg=2)
v_jitstate = hop.llops.getjitstate()
hop.llops.genmixlevelhelpercall(writer,
[ts.s_JITState, ts.s_RedBox],
[v_jitstate, v_valuebox ],
annmodel.s_None)
return
# non virtual case ...
v_destbox, c_fieldname, v_valuebox = hop.inputargs(self.getredrepr(PTRTYPE),
green_void_repr,
self.getredrepr(VALUETYPE)
)
v_destbox = hop.llops.as_ptrredbox(v_destbox)
structdesc = rcontainer.StructTypeDesc(self, PTRTYPE.TO)
fielddesc = structdesc.getfielddesc(c_fieldname.value)
assert fielddesc is not None # skipped above
c_fielddesc = inputconst(lltype.Void, fielddesc)
s_fielddesc = ts.rtyper.annotator.bookkeeper.immutablevalue(fielddesc)
v_jitstate = hop.llops.getjitstate()
return hop.llops.genmixlevelhelpercall(rtimeshift.ll_gensetfield,
[ts.s_JITState, s_fielddesc, ts.s_PtrRedBox, ts.s_RedBox],
[v_jitstate, c_fielddesc, v_destbox, v_valuebox],
annmodel.s_None)
def translate_op_setarrayitem(self, hop):
PTRTYPE = originalconcretetype(hop.args_s[0])
VALUETYPE = PTRTYPE.TO.OF
if VALUETYPE is lltype.Void:
return
ts = self
v_argbox, v_index, v_valuebox= hop.inputargs(self.getredrepr(PTRTYPE),
self.getredrepr(lltype.Signed),
self.getredrepr(VALUETYPE))
fielddesc = rcontainer.ArrayFieldDesc(self, PTRTYPE.TO)
c_fielddesc = inputconst(lltype.Void, fielddesc)
s_fielddesc = ts.rtyper.annotator.bookkeeper.immutablevalue(fielddesc)
v_jitstate = hop.llops.getjitstate()
hop.llops.genmixlevelhelpercall(rtimeshift.ll_gensetarrayitem,
[ts.s_JITState, s_fielddesc, ts.s_RedBox, ts.s_RedBox, ts.s_RedBox],
[v_jitstate, c_fielddesc, v_argbox, v_index , v_valuebox ],
ts.s_RedBox)
def translate_op_getsubstruct(self, hop):
##if isinstance(hop.args_r[0], BlueRepr):
## return hop.args_r[0].timeshift_getsubstruct(hop)
ts = self
PTRTYPE = originalconcretetype(hop.args_s[0])
v_argbox, c_fieldname = hop.inputargs(self.getredrepr(PTRTYPE),
green_void_repr)
v_argbox = hop.llops.as_ptrredbox(v_argbox)
fielddesc = rcontainer.NamedFieldDesc(self, PTRTYPE, c_fieldname.value)
c_fielddesc = inputconst(lltype.Void, fielddesc)
s_fielddesc = ts.rtyper.annotator.bookkeeper.immutablevalue(fielddesc)
v_jitstate = hop.llops.getjitstate()
return hop.llops.genmixlevelhelpercall(rtimeshift.ll_gengetsubstruct,
[ts.s_JITState, s_fielddesc, ts.s_PtrRedBox],
[v_jitstate, c_fielddesc, v_argbox ],
ts.s_RedBox)
def translate_op_getarraysubstruct(self, hop):
PTRTYPE = originalconcretetype(hop.args_s[0])
ts = self
v_argbox, v_index = hop.inputargs(self.getredrepr(PTRTYPE),
self.getredrepr(lltype.Signed))
fielddesc = rcontainer.ArrayFieldDesc(self, PTRTYPE.TO)
c_fielddesc = inputconst(lltype.Void, fielddesc)
s_fielddesc = ts.rtyper.annotator.bookkeeper.immutablevalue(fielddesc)
v_jitstate = hop.llops.getjitstate()
return hop.llops.genmixlevelhelpercall(
rtimeshift.ll_gengetarraysubstruct,
[ts.s_JITState, s_fielddesc, ts.s_RedBox, ts.s_RedBox],
[v_jitstate, c_fielddesc, v_argbox, v_index ],
ts.s_RedBox)
def translate_op_cast_pointer(self, hop):
FROM_TYPE = originalconcretetype(hop.args_s[0])
[v_argbox] = hop.inputargs(self.getredrepr(FROM_TYPE))
return v_argbox
def translate_op_malloc(self, hop):
r_result = hop.r_result
return r_result.create(hop)
def translate_op_malloc_varsize(self, hop):
ts = self
assert isinstance(hop.r_result, RedRepr)
PTRTYPE = originalconcretetype(hop.s_result)
TYPE = PTRTYPE.TO
v_size = hop.inputarg(self.getredrepr(lltype.Signed), arg=1)
if isinstance(TYPE, lltype.Struct):
return hop.r_result.create_varsize(hop, v_size)
contdesc = rcontainer.ArrayFieldDesc(self, TYPE)
c_contdesc = inputconst(lltype.Void, contdesc)
s_contdesc = ts.rtyper.annotator.bookkeeper.immutablevalue(contdesc)
v_jitstate = hop.llops.getjitstate()
return hop.llops.genmixlevelhelpercall(rtimeshift.ll_genmalloc_varsize,
[ts.s_JITState, s_contdesc, ts.s_RedBox],
[v_jitstate, c_contdesc, v_size ], ts.s_RedBox)
def translate_op_zero_gc_pointers_inside(self, hop):
pass
def translate_op_ptr_nonzero(self, hop, reverse=False):
ts = self
PTRTYPE = originalconcretetype(hop.args_s[0])
v_argbox, = hop.inputargs(self.getredrepr(PTRTYPE))
v_argbox = hop.llops.as_ptrredbox(v_argbox)
v_jitstate = hop.llops.getjitstate()
c_reverse = hop.inputconst(lltype.Bool, reverse)
return hop.llops.genmixlevelhelpercall(rtimeshift.ll_genptrnonzero,
[ts.s_JITState, ts.s_PtrRedBox, annmodel.s_Bool],
[v_jitstate , v_argbox , c_reverse ],
ts.s_RedBox)
def translate_op_ptr_iszero(self, hop):
return self.translate_op_ptr_nonzero(hop, reverse=True)
def translate_op_ptr_eq(self, hop, reverse=False):
ts = self
PTRTYPE = originalconcretetype(hop.args_s[0])
r_ptr = self.getredrepr(PTRTYPE)
v_argbox0, v_argbox1 = hop.inputargs(r_ptr, r_ptr)
v_argbox0 = hop.llops.as_ptrredbox(v_argbox0)
v_argbox1 = hop.llops.as_ptrredbox(v_argbox1)
v_jitstate = hop.llops.getjitstate()
c_reverse = hop.inputconst(lltype.Bool, reverse)
return hop.llops.genmixlevelhelpercall(rtimeshift.ll_genptreq,
[ts.s_JITState, ts.s_PtrRedBox, ts.s_PtrRedBox, annmodel.s_Bool],
[v_jitstate , v_argbox0 , v_argbox1 , c_reverse ],
ts.s_RedBox)
def translate_op_ptr_ne(self, hop):
return self.translate_op_ptr_eq(hop, reverse=True)
# special operations inserted by the HintGraphTransformer
def translate_op_ensure_queue(self, hop, prefix=''):
mpfamily = hop.args_v[0].value
subclass = self.get_dispatch_subclass(mpfamily)
s_subclass = self.rtyper.annotator.bookkeeper.immutablevalue(subclass)
c_subclass = inputconst(lltype.Void, subclass)
v_jitstate = hop.llops.getjitstate()
ensure_queue = getattr(rtimeshift, prefix+'ensure_queue')
v_queue = hop.llops.genmixlevelhelpercall(ensure_queue,
[self.s_JITState, s_subclass],
[v_jitstate , c_subclass],
self.s_Queue)
hop.llops.append(flowmodel.SpaceOperation('same_as', [v_queue],
self.v_queue))
def translate_op_replayable_ensure_queue(self, hop):
return self.translate_op_ensure_queue(hop, prefix='replayable_')
def translate_op_enter_frame(self, hop):
v_jitstate = hop.llops.getjitstate()
hop.llops.genmixlevelhelpercall(rtimeshift.enter_frame,
[self.s_JITState, self.s_Queue],
[v_jitstate , self.v_queue],
annmodel.s_None)
def translate_op_leave_graph_red(self, hop, is_portal=False):
c_is_portal = inputconst(lltype.Bool, is_portal)
v_newjs = hop.llops.genmixlevelhelpercall(rtimeshift.leave_graph_red,
[self.s_Queue, annmodel.s_Bool],
[self.v_queue, c_is_portal],
self.s_JITState)
hop.llops.setjitstate(v_newjs)
def translate_op_leave_graph_portal(self, hop):
self.translate_op_leave_graph_red(hop, is_portal=True)
def translate_op_leave_graph_gray(self, hop):
v_newjs = hop.llops.genmixlevelhelpercall(rtimeshift.leave_graph_gray,
[self.s_Queue],
[self.v_queue],
self.s_JITState)
hop.llops.setjitstate(v_newjs)
def translate_op_leave_graph_yellow(self, hop):
v_newjs = hop.llops.genmixlevelhelpercall(
rtimeshift.leave_graph_yellow,
[self.s_Queue],
[self.v_queue],
self.s_JITState)
hop.llops.setjitstate(v_newjs)
def translate_op_save_locals(self, hop):
v_jitstate = hop.llops.getjitstate()
boxes_r = [self.getredrepr(originalconcretetype(hs))
for hs in hop.args_s]
boxes_v = hop.inputargs(*boxes_r)
boxes_s = [self.s_RedBox] * len(hop.args_v)
hop.llops.genmixlevelhelpercall(rtimeshift.save_locals,
[self.s_JITState] + boxes_s,
[v_jitstate ] + boxes_v,
annmodel.s_None)
def translate_op_save_greens(self, hop):
v_jitstate = hop.llops.getjitstate()
greens_v = list(self.wrap_green_vars(hop.llops, hop.args_v))
greens_s = [self.s_ConstOrVar] * len(greens_v)
return hop.llops.genmixlevelhelpercall(rtimeshift.save_greens,
[self.s_JITState] + greens_s,
[v_jitstate ] + greens_v,
annmodel.s_None)
def translate_op_enter_block(self, hop):
v_jitstate = hop.llops.getjitstate()
hop.llops.genmixlevelhelpercall(rtimeshift.enter_block,
[self.s_JITState],
[v_jitstate ],
annmodel.s_None)
def translate_op_restore_local(self, hop):
assert isinstance(hop.args_v[0], flowmodel.Constant)
index = hop.args_v[0].value
c_index = hop.inputconst(lltype.Signed, index)
v_jitstate = hop.llops.getjitstate()
return hop.llops.genmixlevelhelpercall(rtimeshift.getlocalbox,
[self.s_JITState, annmodel.SomeInteger(nonneg=True)],
[v_jitstate , c_index ],
self.s_RedBox)
def translate_op_restore_green(self, hop):
assert isinstance(hop.args_v[0], flowmodel.Constant)
index = hop.args_v[0].value
c_index = hop.inputconst(lltype.Signed, index)
TYPE = originalconcretetype(hop.s_result)
s_TYPE = self.rtyper.annotator.bookkeeper.immutablevalue(TYPE)
c_TYPE = hop.inputconst(lltype.Void, TYPE)
s_result = annmodel.lltype_to_annotation(TYPE)
v_jitstate = hop.llops.getjitstate()
return hop.llops.genmixlevelhelpercall(rtimeshift.ll_getgreenbox,
[self.s_JITState, annmodel.SomeInteger(nonneg=True), s_TYPE],
[v_jitstate , c_index , c_TYPE],
s_result)
def translate_op_is_early_constant(self, hop):
hs = hop.args_s[0]
if hs.is_green():
return hop.inputconst(lltype.Bool, True)
return self.translate_op_is_constant(hop)
def translate_op_is_constant(self, hop):
hs = hop.args_s[0]
r_arg = self.getredrepr(originalconcretetype(hs))
[v_arg] = hop.inputargs(r_arg)
return hop.llops.genmixlevelhelpercall(rvalue.ll_is_constant,
[self.s_RedBox],
[v_arg ],
annmodel.SomeBool())
def translate_op_revealconst(self, hop):
hs = hop.args_s[0]
TYPE = originalconcretetype(hs)
r_arg = self.getredrepr(TYPE)
[v_arg] = hop.inputargs(r_arg)
s_TYPE = self.rtyper.annotator.bookkeeper.immutablevalue(TYPE)
c_TYPE = hop.inputconst(lltype.Void, TYPE)
s_result = annmodel.lltype_to_annotation(TYPE)
return hop.llops.genmixlevelhelpercall(rvalue.ll_getvalue,
[self.s_RedBox, s_TYPE],
[v_arg , c_TYPE],
s_result)
def wrap_green_vars(self, llops, vars):
v_jitstate = llops.getjitstate()
for var in vars:
s_var = annmodel.lltype_to_annotation(var.concretetype)
yield llops.genmixlevelhelpercall(rvalue.ll_gv_fromvalue,
[self.s_JITState, s_var],
[v_jitstate, var ],
self.s_ConstOrVar)
def translate_op_split(self, hop, splitfn=rtimeshift.split,
reverse=False,
s_result=annmodel.s_Bool):
if splitfn is rtimeshift.split:
nb_fixed_args = 2
else:
nb_fixed_args = 3
r_switch = self.getredrepr(lltype.Bool)
GREENS = [v.concretetype for v in hop.args_v[nb_fixed_args:]]
extra_r = [self.getgreenrepr(TYPE) for TYPE in GREENS]
if splitfn is rtimeshift.split_raisingop:
r_switch = lltype.Void
extra_r.insert(0, lltype.Void)
elif splitfn is not rtimeshift.split:
TYPE = originalconcretetype(hop.args_s[2])
r_ptrbox = self.getredrepr(TYPE)
extra_r.insert(0, r_ptrbox)
vlist = hop.inputargs(r_switch, lltype.Signed, *extra_r)
v_jitstate = hop.llops.getjitstate()
v_switch = vlist[0]
c_resumepoint = vlist[1]
greens_v = list(self.wrap_green_vars(hop.llops,
vlist[nb_fixed_args:]))
s_Int = annmodel.SomeInteger(nonneg=True)
args_s = [self.s_JITState, self.s_RedBox, s_Int]
args_v = [v_jitstate, v_switch, c_resumepoint]
if splitfn is rtimeshift.split_raisingop:
bk = self.rtyper.annotator.bookkeeper
excclass = vlist[2].value
exccdef = bk.getuniqueclassdef(excclass)
ll_exc = self.rtyper.exceptiondata.get_standard_ll_exc_instance(
self.rtyper, exccdef)
LL_EXC = lltype.typeOf(ll_exc)
c_excinstance = hop.inputconst(LL_EXC, ll_exc)
s_excinstance = annmodel.lltype_to_annotation(LL_EXC)
del args_s[1] # no v_switch in this case
del args_v[1]
args_s += [s_excinstance]
args_v += [c_excinstance]
elif splitfn is not rtimeshift.split:
v_ptrbox = vlist[2]
c_reverse = hop.inputconst(lltype.Bool, reverse)
args_s += [self.s_PtrRedBox, annmodel.s_Bool]
args_v += [hop.llops.as_ptrredbox(v_ptrbox), c_reverse ]
args_s += [self.s_ConstOrVar] * len(greens_v)
args_v += greens_v
return hop.llops.genmixlevelhelpercall(splitfn,
args_s, args_v,
s_result)
def translate_op_split_ptr_nonzero(self, hop):
return self.translate_op_split(hop, rtimeshift.split_ptr_nonzero,
reverse=False)
def translate_op_split_ptr_iszero(self, hop):
return self.translate_op_split(hop, rtimeshift.split_ptr_nonzero,
reverse=True)
def translate_op_split_raisingop(self, hop):
self.translate_op_split(hop, rtimeshift.split_raisingop,
s_result=annmodel.s_None)
def translate_op_collect_split(self, hop):
GREENS = [v.concretetype for v in hop.args_v[1:]]
greens_r = [self.getgreenrepr(TYPE) for TYPE in GREENS]
vlist = hop.inputargs(lltype.Signed, *greens_r)
v_jitstate = hop.llops.getjitstate()
c_resumepoint = vlist[0]
greens_v = list(self.wrap_green_vars(hop.llops, vlist[1:]))
s_Int = annmodel.SomeInteger(nonneg=True)
args_s = [self.s_JITState, s_Int]
args_s += [self.s_ConstOrVar] * len(greens_v)
args_v = [v_jitstate, c_resumepoint]
args_v += greens_v
v_newjs = hop.llops.genmixlevelhelpercall(rtimeshift.collect_split,
args_s, args_v,
self.s_JITState)
hop.llops.setjitstate(v_newjs)
def translate_op_merge_point(self, hop, global_resumer=None):
mpfamily = hop.args_v[0].value
attrname = hop.args_v[1].value
DispatchQueueSubclass = self.get_dispatch_subclass(mpfamily)
if global_resumer is not None:
states_dic = {}
def merge_point(jitstate, *key):
return rtimeshift.retrieve_jitstate_for_merge(states_dic,
jitstate, key,
global_resumer)
else:
def merge_point(jitstate, *key):
dispatchqueue = jitstate.frame.dispatchqueue
assert isinstance(dispatchqueue, DispatchQueueSubclass)
states_dic = getattr(dispatchqueue, attrname)
return rtimeshift.retrieve_jitstate_for_merge(states_dic,
jitstate, key,
global_resumer)
greens_v = []
greens_s = []
for r, v in zip(hop.args_r[2:], hop.args_v[2:]):
s_precise_type = r.annotation()
s_erased_type = r.erased_annotation()
r_precise_type = self.rtyper.getrepr(s_precise_type)
r_erased_type = self.rtyper.getrepr(s_erased_type)
if r_precise_type.lowleveltype == lltype.Char:
v_green = hop.llops.genop('cast_char_to_int', [v],
resulttype = lltype.Signed)
else:
v_green = hop.llops.convertvar(v, r_precise_type, r_erased_type)
greens_v.append(v_green)
greens_s.append(s_erased_type)
# YYY possibly reorder the variables to avoid too many
# specialized versions of retrieve_jitstate_for_merge
v_jitstate = hop.llops.getjitstate()
return hop.llops.genmixlevelhelpercall(merge_point,
[self.s_JITState] + greens_s,
[v_jitstate ] + greens_v,
annmodel.SomeBool())
def translate_op_guard_global_merge(self, hop):
[c_resumepoint] = hop.inputargs(lltype.Signed)
v_jitstate = hop.llops.getjitstate()
s_Int = annmodel.SomeInteger(nonneg=True)
return hop.llops.genmixlevelhelpercall(rtimeshift.guard_global_merge,
[self.s_JITState, s_Int],
[v_jitstate , c_resumepoint],
annmodel.s_None)
def translate_op_global_merge_point(self, hop):
mpfamily = hop.args_v[0].value
attrname = hop.args_v[1].value
N = mpfamily.resumepoint_after_mergepoint[attrname]
tsgraph = mpfamily.tsgraph
ts_fnptr = self.naked_tsfnptr(tsgraph)
TS_FUNC = lltype.typeOf(ts_fnptr)
dummy_args = [ARG._defl() for ARG in TS_FUNC.TO.ARGS[1:]]
dummy_args = tuple(dummy_args)
JITSTATE = self.r_JITState.lowleveltype
RESIDUAL_FUNCTYPE = self.get_residual_functype(tsgraph)
residualSigToken = self.RGenOp.sigToken(RESIDUAL_FUNCTYPE)
ll_finish_jitstate = self.ll_finish_jitstate
exceptiondesc = self.exceptiondesc
args_s = [self.s_JITState] + [annmodel.lltype_to_annotation(ARG)
for ARG in TS_FUNC.TO.ARGS[1:]]
s_res = self.s_JITState
tsfn = annlowlevel.PseudoHighLevelCallable(ts_fnptr, args_s, s_res)
DispatchQueueSubclass = self.get_dispatch_subclass(mpfamily)
def call_for_global_resuming(jitstate, resuming):
dispatchqueue = DispatchQueueSubclass()
dispatchqueue.resuming = resuming
jitstate.frame.dispatchqueue = dispatchqueue
jitstate.resumepoint = N
finaljitstate = tsfn(jitstate, *dummy_args)
if finaljitstate is not None:
ll_finish_jitstate(finaljitstate, exceptiondesc,
residualSigToken)
return self.translate_op_merge_point(hop,
global_resumer = call_for_global_resuming)
def translate_op_save_return(self, hop):
v_jitstate = hop.llops.getjitstate()
return hop.llops.genmixlevelhelpercall(rtimeshift.save_return,
[self.s_JITState],
[v_jitstate ],
annmodel.s_None)
def translate_op_dispatch_next(self, hop):
v_newjs = hop.llops.genmixlevelhelpercall(rtimeshift.dispatch_next,
[self.s_Queue],
[self.v_queue],
self.s_JITState)
hop.llops.setjitstate(v_newjs)
def translate_op_getresumepoint(self, hop):
v_jitstate = hop.llops.getjitstate()
return hop.llops.genmixlevelhelpercall(rtimeshift.getresumepoint,
[self.s_JITState],
[v_jitstate ],
annmodel.SomeInteger())
def translate_op_promote(self, hop):
TYPE = originalconcretetype(hop.args_s[0])
r_arg = self.getredrepr(TYPE)
[v_box] = hop.inputargs(r_arg)
ERASED = self.RGenOp.erasedType(TYPE)
desc = rtimeshift.PromotionDesc(ERASED, self)
s_desc = self.rtyper.annotator.bookkeeper.immutablevalue(desc)
c_desc = hop.inputconst(lltype.Void, desc)
v_jitstate = hop.llops.getjitstate()
return hop.llops.genmixlevelhelpercall(rtimeshift.ll_promote,
[self.s_JITState, self.s_RedBox, s_desc],
[v_jitstate , v_box , c_desc],
annmodel.SomeBool())
def translate_op_rpyexc_raise(self, hop):
EXCTYPE = originalconcretetype(hop.args_s[0])
EXCVALUE = originalconcretetype(hop.args_s[1])
[v_exctype, v_excvalue] = hop.inputargs(self.getredrepr(EXCTYPE),
self.getredrepr(EXCVALUE))
v_exctype = hop.llops.as_ptrredbox(v_exctype)
v_excvalue = hop.llops.as_ptrredbox(v_excvalue)
v_jitstate = hop.llops.getjitstate()
return hop.llops.genmixlevelhelpercall(rtimeshift.setexception,
[self.s_JITState, self.s_PtrRedBox, self.s_PtrRedBox],
[v_jitstate , v_exctype , v_excvalue ],
annmodel.s_None)
# handling of the various kinds of calls
def translate_op_oopspec_was_residual(self, hop):
v_jitstate = hop.llops.getjitstate()
return hop.llops.genmixlevelhelpercall(rtimeshift.oopspec_was_residual,
[self.s_JITState],
[v_jitstate ],
annmodel.s_Bool)
def translate_op_oopspec_call(self, hop, can_raise=True):
# special-cased call, for things like list methods
from pypy.jit.timeshifter.oop import OopSpecDesc, Index
c_func = hop.args_v[0]
fnobj = c_func.value._obj
oopspecdesc = OopSpecDesc(self, fnobj, can_raise)
hop.r_s_popfirstarg()
args_v = []
for obj in oopspecdesc.argtuple:
if isinstance(obj, Index):
hs = hop.args_s[obj.n]
r_arg = self.getredrepr(originalconcretetype(hs))
v = hop.inputarg(r_arg, arg=obj.n)
else:
v = hop.inputconst(self.getredrepr(lltype.typeOf(obj)), obj)
args_v.append(v)
# if the ll_handler() takes more arguments, it must be 'None' defaults.
# Pass them as constant Nones.
ts = self
ll_handler = oopspecdesc.ll_handler
couldfold = oopspecdesc.couldfold
missing_args = ((ll_handler.func_code.co_argcount - 2 - couldfold) -
len(oopspecdesc.argtuple))
assert missing_args >= 0
if missing_args > 0:
assert (ll_handler.func_defaults[-missing_args:] ==
(None,) * missing_args)
ll_None = lltype.nullptr(ts.r_RedBox.lowleveltype.TO)
args_v.extend([hop.llops.genconst(ll_None)] * missing_args)
args_s = [ts.s_RedBox] * len(args_v)
if oopspecdesc.is_method:
args_s[0] = ts.s_PtrRedBox # for more precise annotations
args_v[0] = hop.llops.as_ptrredbox(args_v[0])
if couldfold:
args_s.insert(0, annmodel.s_Bool)
hs_self = hop.args_s[oopspecdesc.argtuple[0].n]
c_deepfrozen = inputconst(lltype.Bool, hs_self.deepfrozen)
args_v.insert(0, c_deepfrozen)
RESULT = originalconcretetype(hop.s_result)
if RESULT is lltype.Void:
s_result = annmodel.s_None
else:
s_result = ts.s_RedBox
(s_oopspecdesc,
r_oopspecdesc) = self.s_r_instanceof(oopspecdesc.__class__)
ll_oopspecdesc = ts.annhelper.delayedconst(r_oopspecdesc,
oopspecdesc)
c_oopspecdesc = hop.llops.genconst(ll_oopspecdesc)
v_jitstate = hop.llops.getjitstate()
return hop.llops.genmixlevelhelpercall(ll_handler,
[ts.s_JITState, s_oopspecdesc] + args_s,
[v_jitstate, c_oopspecdesc] + args_v,
s_result)
def translate_op_oopspec_call_noexc(self, hop):
return self.translate_op_oopspec_call(hop, False)
def translate_op_green_call(self, hop):
for r_arg in hop.args_r:
assert isinstance(r_arg, GreenRepr)
assert isinstance(hop.r_result, GreenRepr)
FUNC = hop.args_v[0].concretetype
calldesc = rtimeshift.CallDesc(self.RGenOp, FUNC.TO)
args_v = hop.args_v
args_s = [annmodel.lltype_to_annotation(v.concretetype)
for v in args_v]
s_result = annmodel.lltype_to_annotation(FUNC.TO.RESULT)
v_jitstate = hop.llops.getjitstate()
return hop.llops.genmixlevelhelpercall(calldesc.green_call,
[self.s_JITState] + args_s,
[v_jitstate ] + args_v,
s_result)
def translate_op_green_call_noexc(self, hop):
for r_arg in hop.args_r:
assert isinstance(r_arg, GreenRepr)
assert isinstance(hop.r_result, GreenRepr)
v = hop.genop('direct_call', hop.args_v, hop.r_result.lowleveltype)
return v
def translate_op_green_indirect_call_noexc(self, hop):
for r_arg in hop.args_r[:-1]:
assert isinstance(r_arg, GreenRepr)
assert isinstance(hop.r_result, GreenRepr)
v = hop.genop('indirect_call', hop.args_v, hop.r_result.lowleveltype)
return v
def translate_op_red_call(self, hop):
bk = self.annotator.bookkeeper
v_jitstate = hop.llops.getjitstate()
tsgraph = hop.args_v[0].value
hop.r_s_popfirstarg()
args_v = hop.inputargs(*self.get_args_r(tsgraph))
fnptr = self.gettscallable(tsgraph)
args_v[:0] = [hop.llops.genconst(fnptr), v_jitstate]
RESULT = lltype.typeOf(fnptr).TO.RESULT
v_newjitstate = hop.genop('direct_call', args_v, RESULT)
hop.llops.setjitstate(v_newjitstate)
return hop.genop('ptr_iszero', [v_newjitstate],
resulttype = lltype.Bool)
def translate_op_indirect_red_call(self, hop):
v_jitstate = hop.llops.getjitstate()
FUNC = originalconcretetype(hop.args_s[0])
v_func = hop.inputarg(self.getgreenrepr(FUNC), arg=0)
graph2ts = hop.args_v[-1].value
hop.r_s_pop(0)
hop.r_s_pop()
mapper, TS_FUNC, args_r = self.get_timeshift_mapper(graph2ts)
v_tsfunc = hop.llops.genmixlevelhelpercall(mapper,
[annmodel.SomePtr(FUNC)],
[v_func ],
annmodel.SomePtr(TS_FUNC))
args_v = [v_tsfunc, v_jitstate] + hop.inputargs(*args_r)
RESULT = v_tsfunc.concretetype.TO.RESULT
args_v.append(hop.inputconst(lltype.Void, graph2ts.values()))
v_newjitstate = hop.genop('indirect_call', args_v, RESULT)
hop.llops.setjitstate(v_newjitstate)
return hop.genop('ptr_iszero', [v_newjitstate],
resulttype = lltype.Bool)
translate_op_gray_call = translate_op_red_call
translate_op_indirect_gray_call = translate_op_indirect_red_call
translate_op_yellow_call = translate_op_red_call
translate_op_indirect_yellow_call = translate_op_indirect_red_call
def translate_op_residual_red_call(self, hop, color='red'):
FUNC = originalconcretetype(hop.args_s[0])
[v_funcbox] = hop.inputargs(self.getredrepr(FUNC))
calldesc = rtimeshift.CallDesc(self.RGenOp, FUNC.TO)
c_calldesc = inputconst(lltype.Void, calldesc)
s_calldesc = self.rtyper.annotator.bookkeeper.immutablevalue(calldesc)
v_jitstate = hop.llops.getjitstate()
v_res = hop.llops.genmixlevelhelpercall(
rtimeshift.ll_gen_residual_call,
[self.s_JITState, s_calldesc, self.s_RedBox],
[v_jitstate, c_calldesc, v_funcbox ],
self.s_RedBox)
return v_res
def translate_op_residual_gray_call(self, hop):
self.translate_op_residual_red_call(hop, color='gray')
translate_op_residual_yellow_call = translate_op_residual_red_call
def translate_op_after_residual_call(self, hop):
dopts = hop.args_v[0].value
withexc = dopts['withexc']
oop = dopts['oop']
v_jitstate = hop.llops.getjitstate()
if withexc:
c_exception_desc = hop.inputconst(lltype.Void, self.exceptiondesc)
else:
c_exception_desc = hop.inputconst(lltype.Void, None)
bk = self.rtyper.annotator.bookkeeper
s_exception_desc = bk.immutablevalue(c_exception_desc.value)
c_check_forced = hop.inputconst(lltype.Bool, not oop)
v_after = hop.llops.genmixlevelhelpercall(
rtimeshift.ll_after_residual_call,
[self.s_JITState, s_exception_desc, annmodel.s_Bool],
[v_jitstate , c_exception_desc, c_check_forced ],
self.s_RedBox)
return v_after
def translate_op_residual_fetch(self, hop):
dopts = hop.args_v[1].value
oop = dopts['oop']
v_jitstate = hop.llops.getjitstate()
v_flags = hop.inputarg(self.getredrepr(lltype.Signed), arg=0)
bk = self.rtyper.annotator.bookkeeper
c_exception_desc = hop.inputconst(lltype.Void, self.exceptiondesc)
s_exception_desc = bk.immutablevalue(c_exception_desc.value)
c_check_forced = hop.inputconst(lltype.Bool, not oop)
return hop.llops.genmixlevelhelpercall(rtimeshift.residual_fetch,
[self.s_JITState, s_exception_desc, annmodel.s_Bool, self.s_RedBox],
[v_jitstate , c_exception_desc, c_check_forced , v_flags ],
annmodel.s_None)
def translate_op_reverse_split_queue(self, hop):
hop.llops.genmixlevelhelpercall(rtimeshift.reverse_split_queue,
[self.s_Queue],
[self.v_queue],
annmodel.s_None)
class HintLowLevelOpList(LowLevelOpList):
"""Warning: the HintLowLevelOpList's rtyper is the *original*
rtyper, while the HighLevelOp's rtyper is actually our HintRTyper...
"""
def __init__(self, hrtyper):
LowLevelOpList.__init__(self, hrtyper.rtyper)
self.hrtyper = hrtyper
def hasparentgraph(self):
return False # for now
def genmixlevelhelpercall(self, function, args_s, args_v, s_result):
# XXX first approximation, will likely need some fine controlled
# specialisation for these helpers too
if isinstance(function, types.MethodType):
if function.im_self is not None:
# bound method => function and an extra first argument
bk = self.rtyper.annotator.bookkeeper
s_self = bk.immutablevalue(function.im_self)
r_self = self.rtyper.getrepr(s_self)
v_self = inputconst(r_self.lowleveltype,
r_self.convert_const(function.im_self))
args_s = [s_self] + args_s
args_v = [v_self] + args_v
function = function.im_func
assert len(args_s) == len(args_v)
graph = self.hrtyper.annhelper.getgraph(function, args_s, s_result)
self.record_extra_call(graph) # xxx
c = self.hrtyper.annhelper.graph2const(graph)
# build the 'direct_call' operation
try:
RESULT = annmodel.annotation_to_lltype(s_result)
except ValueError:
RESULT = self.rtyper.getrepr(s_result).lowleveltype
return self.genop('direct_call', [c]+args_v,
resulttype = RESULT)
def getjitstate(self):
return self.genop('getjitstate', [],
resulttype = self.hrtyper.r_JITState)
def setjitstate(self, v_newjitstate):
self.genop('setjitstate', [v_newjitstate])
def as_redbox(self, v_ptrredbox):
return self.genop('cast_pointer', [v_ptrredbox],
resulttype = self.hrtyper.r_RedBox)
def as_ptrredbox(self, v_redbox):
return self.genop('cast_pointer', [v_redbox],
resulttype = self.hrtyper.r_PtrRedBox)
# ____________________________________________________________
class __extend__(pairtype(HintTypeSystem, hintmodel.SomeLLAbstractValue)):
def rtyper_makerepr((ts, hs_c), hrtyper):
if hs_c.is_green():
return hrtyper.getgreenrepr(hs_c.concretetype)
else:
return hrtyper.getredrepr(hs_c.concretetype)
def rtyper_makekey((ts, hs_c), hrtyper):
is_green = hs_c.is_green()
return hs_c.__class__, is_green, hs_c.concretetype
class __extend__(pairtype(HintTypeSystem, hintmodel.SomeLLAbstractContainer)):
def rtyper_makerepr((ts, hs_container), hrtyper):
vstructdef = hs_container.contentdef
assert isinstance(vstructdef, hintcontainer.VirtualStructDef)
if vstructdef.degenerated:
# fall back to a red repr
return hrtyper.getredrepr(hs_container.concretetype)
return BlueStructRepr(hs_container.concretetype, vstructdef,
hrtyper)
def rtyper_makekey((ts, hs_container), hrtyper):
vstructdef = hs_container.contentdef
assert isinstance(vstructdef, hintcontainer.VirtualStructDef)
if vstructdef.degenerated:
# fall back to a red repr
return hs_container.__class__, "red", hs_container.concretetype
T = None
if vstructdef.vparent is not None:
T = vstructdef.vparent.T
key = [hs_container.__class__, vstructdef.T, T, vstructdef.vparentindex]
for name in vstructdef.names:
fielditem = vstructdef.fields[name]
key.append(fielditem)
return tuple(key)
class __extend__(pairtype(HintTypeSystem, annmodel.SomeImpossibleValue)):
def rtyper_makerepr((ts, hs_c), hrtyper):
return green_void_repr
def rtyper_makekey((ts, hs_c), hrtyper):
return hs_c.__class__,
class RedRepr(Repr):
def __init__(self, original_concretetype, hrtyper):
assert original_concretetype is not lltype.Void, (
"cannot make red boxes for the lltype Void")
self.original_concretetype = original_concretetype
self.lowleveltype = hrtyper.r_RedBox.lowleveltype
self.hrtyper = hrtyper
self.build_portal_arg_helpers()
def build_portal_arg_helpers(self):
def collect_residual_args(v):
return (v,)
self.collect_residual_args = collect_residual_args
TYPE = self.original_concretetype
kind = self.hrtyper.RGenOp.kindToken(TYPE)
boxcls = rvalue.ll_redboxcls(TYPE)
def make_arg_redbox(jitstate, inputargs_gv, i):
gv_arg = inputargs_gv[i]
box = boxcls(kind, gv_arg)
return box
self.make_arg_redbox = make_arg_redbox
make_arg_redbox.consumes = 1
## def get_genop_var(self, v, llops):
## ts = self.hrtyper
## v_jitstate = hop.llops.getjitstate()
## return llops.genmixlevelhelpercall(rtimeshift.ll_gvar_from_redbox,
## [ts.s_JITState, llops.hrtyper.s_RedBox],
## [v_jitstate, v],
## ts.s_ConstOrVar)
def convert_const(self, ll_value):
RGenOp = self.hrtyper.RGenOp
redbox = rvalue.redbox_from_prebuilt_value(RGenOp, ll_value)
hrtyper = self.hrtyper
return hrtyper.annhelper.delayedconst(hrtyper.r_RedBox, redbox)
def residual_values(self, ll_value):
return [ll_value]
def residual_argtypes(self):
return [self.original_concretetype]
def residual_args_collector(self):
return self.collect_residual_args
def arg_redbox_maker(self):
return self.make_arg_redbox
class RedStructRepr(RedRepr):
typedesc = None
_s_c_typedesc = None
def gettypedesc(self):
if self.typedesc is None:
hrtyper = self.hrtyper
T = self.original_concretetype.TO
self.typedesc = rcontainer.StructTypeDesc(hrtyper, T)
return self.typedesc
def s_c_typedesc(self):
if self._s_c_typedesc is not None:
return self._s_c_typedesc
ts = self.hrtyper
typedesc = self.gettypedesc()
annhelper = ts.annhelper
s_r = annhelper.s_r_instanceof(rcontainer.StructTypeDesc)
s_typedesc, r_typedesc = s_r
typedesc_ptr = ts.annhelper.delayedconst(r_typedesc, typedesc)
ctypedesc = inputconst(lltype.typeOf(typedesc_ptr), typedesc_ptr)
self._s_c_typedesc = s_typedesc, ctypedesc
return self._s_c_typedesc
def create(self, hop):
ts = self.hrtyper
s_typedesc, ctypedesc = self.s_c_typedesc()
v_jitstate = hop.llops.getjitstate()
v_ptrbox = hop.llops.genmixlevelhelpercall(rcontainer.create,
[ts.s_JITState, s_typedesc], [v_jitstate, ctypedesc],
ts.s_PtrRedBox)
return hop.llops.as_redbox(v_ptrbox)
def create_varsize(self, hop, v_size):
ts = self.hrtyper
s_typedesc, ctypedesc = self.s_c_typedesc()
v_jitstate = hop.llops.getjitstate()
v_ptrbox = hop.llops.genmixlevelhelpercall(rcontainer.create_varsize,
[ts.s_JITState, s_typedesc, ts.s_RedBox],
[v_jitstate, ctypedesc, v_size ], ts.s_PtrRedBox)
return hop.llops.as_redbox(v_ptrbox)
class RedVirtualizableStructRepr(RedStructRepr):
def build_portal_arg_helpers(self):
typedesc = self.gettypedesc()
redirected_fielddescs = unrolling_iterable(
typedesc.redirected_fielddescs)
TYPE = self.original_concretetype
kind = self.hrtyper.RGenOp.kindToken(TYPE)
def make_arg_redbox(jitstate, inputargs_gv, i):
box = typedesc.factory()
jitstate.add_virtualizable(box)
content = box.content
assert isinstance(content, rcontainer.VirtualizableStruct)
content_boxes = content.content_boxes
gv_outside = inputargs_gv[i]
i += 1
for fieldesc, j in redirected_fielddescs:
content_boxes[j] = fieldesc.makebox(None, inputargs_gv[i])
i += 1
content_boxes[-1] = rvalue.PtrRedBox(content_boxes[-1].kind,
gv_outside,
known_nonzero = True)
return box
self.make_arg_redbox = make_arg_redbox
make_arg_redbox.consumes = len(typedesc.redirected_fielddescs)+1
def residual_argtypes(self):
argtypes = [self.original_concretetype]
getredrepr = self.hrtyper.getredrepr
typedesc = self.gettypedesc()
for fielddesc, _ in typedesc.redirected_fielddescs:
FIELDTYPE = fielddesc.RESTYPE
argtypes.append(FIELDTYPE)
return argtypes
def residual_args_collector(self):
typedesc = self.gettypedesc()
return typedesc.collect_residual_args
##class VoidRedRepr(Repr):
## def __init__(self, hrtyper):
## self.lowleveltype = hrtyper.r_RedBox.lowleveltype
## def convert_const(self, ll_value):
## return lltype.nullptr(self.lowleveltype.TO)
class BlueRepr(Repr):
# XXX todo
pass
class GreenRepr(Repr):
def __init__(self, lowleveltype):
self.lowleveltype = lowleveltype
self.original_concretetype = lowleveltype
def annotation(self):
return annmodel.lltype_to_annotation(self.lowleveltype)
def erased_annotation(self):
T = self.lowleveltype
if isinstance(T, lltype.Ptr):
return annmodel.SomeAddress()
elif T is lltype.Float:
return annmodel.SomeFloat()
elif T is lltype.Void:
return annmodel.s_ImpossibleValue
else:
return annmodel.SomeInteger()
## def get_genop_var(self, v, llops):
## ts = self.hrtyper
## v_jitstate = hop.llops.getjitstate()
## return llops.genmixlevelhelpercall(rtimeshift.ll_gvar_from_constant,
## [ts.s_JITState, self.annotation()],
## [v_jitstate, v],
## ts.s_ConstOrVar)
def convert_const(self, ll_value):
return ll_value
def residual_values(self, ll_value):
return []
#def timeshift_getsubstruct(self, hop):
# ...
green_signed_repr = GreenRepr(lltype.Signed)
green_void_repr = GreenRepr(lltype.Void)
# collect the global precomputed reprs
PRECOMPUTED_GREEN_REPRS = {}
for _r in globals().values():
if isinstance(_r, GreenRepr):
PRECOMPUTED_GREEN_REPRS[_r.lowleveltype] = _r
class __extend__(pairtype(GreenRepr, RedRepr)):
def convert_from_to((r_from, r_to), v, llops):
assert r_from.lowleveltype == r_to.original_concretetype
ts = llops.hrtyper
v_jitstate = llops.getjitstate()
return llops.genmixlevelhelpercall(rvalue.ll_fromvalue,
[ts.s_JITState, r_from.annotation()],
[v_jitstate, v],
ts.s_RedBox)
c_void = flowmodel.Constant(None, concretetype=lltype.Void)
# ____________________________________________________________
def opname2vstr(name):
lls = string_repr.convert_const(name)
return inputconst(string_repr.lowleveltype, lls)
| Python |
import operator
from pypy.rpython.lltypesystem import lltype, llmemory
from pypy.rpython.annlowlevel import cachedtype, cast_base_ptr_to_instance
from pypy.rpython.annlowlevel import base_ptr_lltype, cast_instance_to_base_ptr
from pypy.jit.timeshifter import rvalue
from pypy.rlib.unroll import unrolling_iterable
from pypy.jit.timeshifter import rvirtualizable
from pypy.annotation import model as annmodel
from pypy.rpython.lltypesystem import lloperation
debug_print = lloperation.llop.debug_print
debug_pdb = lloperation.llop.debug_pdb
class AbstractContainer(object):
_attrs_ = []
def op_getfield(self, jitstate, fielddesc):
raise NotImplementedError
def op_setfield(self, jitstate, fielddesc, valuebox):
raise NotImplementedError
def op_getsubstruct(self, jitstate, fielddesc):
raise NotImplementedError
class VirtualContainer(AbstractContainer):
_attrs_ = ('ownbox',)
allowed_in_virtualizable = False
def setforced(self, _):
raise NotImplementedError
def op_ptreq(self, jitstate, otherbox, reverse):
equal = self is otherbox.content
return rvalue.ll_fromvalue(jitstate, equal ^ reverse)
class FrozenContainer(AbstractContainer):
_attrs_ = []
def exactmatch(self, vstruct, outgoingvarboxes, memo):
raise NotImplementedError
def unfreeze(self, incomingvarboxes, memo):
raise NotImplementedError
# ____________________________________________________________
class StructTypeDesc(object):
__metaclass__ = cachedtype
VirtualStructCls = None # patched later with VirtualStruct
_attrs_ = """TYPE PTRTYPE
firstsubstructdesc arrayfielddesc
innermostdesc
ptrkind
alloctoken varsizealloctoken
null gv_null
fielddescs fielddesc_by_name
immutable noidentity
materialize
devirtualize
""".split()
firstsubstructdesc = None
materialize = None
def __new__(cls, hrtyper, TYPE):
if TYPE._hints.get('virtualizable', False):
return object.__new__(VirtualizableStructTypeDesc)
else:
return object.__new__(StructTypeDesc)
def __init__(self, hrtyper, TYPE):
RGenOp = hrtyper.RGenOp
self.TYPE = TYPE
self.PTRTYPE = lltype.Ptr(TYPE)
self.ptrkind = RGenOp.kindToken(self.PTRTYPE)
self.immutable = TYPE._hints.get('immutable', False)
self.noidentity = TYPE._hints.get('noidentity', False)
fixsize = not TYPE._is_varsize()
if fixsize:
self.alloctoken = RGenOp.allocToken(TYPE)
self.null = self.PTRTYPE._defl()
self.gv_null = RGenOp.constPrebuiltGlobal(self.null)
self._compute_fielddescs(hrtyper)
if self.immutable and self.noidentity:
self._define_materialize()
if fixsize:
self._define_devirtualize()
def _compute_fielddescs(self, hrtyper):
RGenOp = hrtyper.RGenOp
TYPE = self.TYPE
innermostdesc = self
fielddescs = []
fielddesc_by_name = {}
for name in TYPE._names:
FIELDTYPE = getattr(TYPE, name)
if isinstance(FIELDTYPE, lltype.ContainerType):
if isinstance(FIELDTYPE, lltype.Array):
self.arrayfielddesc = ArrayFieldDesc(hrtyper, FIELDTYPE)
self.varsizealloctoken = RGenOp.varsizeAllocToken(TYPE)
continue
substructdesc = StructTypeDesc(hrtyper, FIELDTYPE)
assert name == TYPE._names[0], (
"unsupported: inlined substructures not as first field")
fielddescs.extend(substructdesc.fielddescs)
self.firstsubstructdesc = substructdesc
innermostdesc = substructdesc.innermostdesc
else:
index = len(fielddescs)
if FIELDTYPE is lltype.Void:
desc = None
else:
desc = StructFieldDesc(hrtyper, self.PTRTYPE, name, index)
fielddescs.append(desc)
fielddesc_by_name[name] = desc
self.fielddescs = fielddescs
self.fielddesc_by_name = fielddesc_by_name
self.innermostdesc = innermostdesc
def _define_devirtualize(self):
TYPE = self.TYPE
PTRTYPE = self.PTRTYPE
descs = unrolling_iterable(self.fielddescs)
def make(vrti):
s = lltype.malloc(TYPE)
s = lltype.cast_opaque_ptr(llmemory.GCREF, s)
return s
def fill_into(vablerti, s, base, vrti):
s = lltype.cast_opaque_ptr(PTRTYPE, s)
i = 0
for desc in descs:
v = vrti._read_field(vablerti, desc, base, i)
tgt = lltype.cast_pointer(desc.PTRTYPE, s)
setattr(tgt, desc.fieldname, v)
i = i + 1
self.devirtualize = make, fill_into
def _define_materialize(self):
TYPE = self.TYPE
descs = unrolling_iterable(self.fielddescs)
def materialize(rgenop, boxes):
s = lltype.malloc(TYPE)
i = 0
for desc in descs:
v = rvalue.ll_getvalue(boxes[i], desc.RESTYPE)
tgt = lltype.cast_pointer(desc.PTRTYPE, s)
setattr(tgt, desc.fieldname, v)
i = i + 1
return rgenop.genconst(s)
self.materialize = materialize
def getfielddesc(self, name):
try:
return self.fielddesc_by_name[name]
except KeyError:
return self.firstsubstructdesc.getfielddesc(name)
def factory(self):
vstruct = self.VirtualStructCls(self)
vstruct.content_boxes = [desc.makedefaultbox()
for desc in self.fielddescs]
box = rvalue.PtrRedBox(self.innermostdesc.ptrkind, known_nonzero=True)
box.content = vstruct
vstruct.ownbox = box
return box
def create(jitstate, typedesc):
return typedesc.factory()
def create_varsize(jitstate, contdesc, sizebox):
gv_size = sizebox.getgenvar(jitstate)
alloctoken = contdesc.varsizealloctoken
genvar = jitstate.curbuilder.genop_malloc_varsize(alloctoken, gv_size)
# XXX MemoryError checking
return rvalue.PtrRedBox(contdesc.ptrkind, genvar, known_nonzero=True)
class VirtualizableStructTypeDesc(StructTypeDesc):
VirtualStructCls = None # patched later with VirtualizableStruct
_attrs_ = """redirected_fielddescs
redirected
base_desc rti_desc access_desc
gv_access
touch_update
gv_access_is_null_ptr access_is_null_token
get_rti set_rti
""".split()
def __init__(self, hrtyper, TYPE):
RGenOp = hrtyper.RGenOp
StructTypeDesc.__init__(self, hrtyper, TYPE)
ACCESS = self.TYPE.ACCESS
redirected_fields = ACCESS.redirected_fields
self.redirected_fielddescs = []
self.redirected = {}
i = 0
for fielddesc in self.fielddescs:
if fielddesc.fieldname in redirected_fields:
self.redirected_fielddescs.append((fielddesc, i))
self.redirected[i] = None
i += 1
self.base_desc = self.getfielddesc('vable_base')
self.rti_desc = self.getfielddesc('vable_rti')
self.access_desc = self.getfielddesc('vable_access')
TOPPTR = self.access_desc.PTRTYPE
self.s_structtype = annmodel.lltype_to_annotation(TOPPTR)
annhelper = hrtyper.annhelper
self.my_redirected_getsetters_untouched = {}
self.my_redirected_getsetters_touched = {}
self.my_redirected_names = my_redirected_names = []
j = -1
for fielddesc, _ in self.redirected_fielddescs:
j += 1
if fielddesc.PTRTYPE != self.PTRTYPE:
continue
my_redirected_names.append(fielddesc.fieldname)
self._define_getset_field_ptr(hrtyper, fielddesc, j)
access_untouched = lltype.malloc(ACCESS, immortal=True)
access_touched = lltype.malloc(ACCESS, immortal=True)
self._fill_access('untouched', access_untouched)
self._fill_access('touched', access_touched)
self.gv_access = RGenOp.constPrebuiltGlobal(access_untouched)
self.touch_update = rvirtualizable.define_touch_update(TOPPTR,
self.redirected_fielddescs,
access_touched)
self._define_collect_residual_args()
self._define_access_is_null(hrtyper)
def _define_virtual_desc(self):
pass
def _define_getset_field_ptr(self, hrtyper, fielddesc, j):
annhelper = hrtyper.annhelper
s_lltype = annmodel.lltype_to_annotation(fielddesc.RESTYPE)
untouched = self.my_redirected_getsetters_untouched
touched = self.my_redirected_getsetters_touched
mkptr = annhelper.delayedfunction
fnpairs = rvirtualizable.define_getset_field_ptrs(fielddesc, j)
name = fielddesc.fieldname
for getsetters, (get_field, set_field) in zip((untouched, touched),
fnpairs):
get_field_ptr = mkptr(get_field, [self.s_structtype], s_lltype,
needtype = True)
set_field_ptr = mkptr(set_field, [self.s_structtype, s_lltype],
annmodel.s_None, needtype=True)
getsetters[name] = get_field_ptr, set_field_ptr
def _fill_access(self, which, access):
firstsubstructdesc = self.firstsubstructdesc
if (firstsubstructdesc is not None and
isinstance(firstsubstructdesc, VirtualizableStructTypeDesc)):
firstsubstructdesc._fill_access(which, access.parent)
getsetters = getattr(self, 'my_redirected_getsetters_'+which)
for name, (get_field_ptr, set_field_ptr) in getsetters.iteritems():
setattr(access, 'get_'+name, get_field_ptr)
setattr(access, 'set_'+name, set_field_ptr)
def _define_collect_residual_args(self):
my_redirected_names = unrolling_iterable(self.my_redirected_names)
TOPPTR = self.access_desc.PTRTYPE
if TOPPTR == self.PTRTYPE:
_super_collect = None
else:
_super_collect = self.firstsubstructdesc._collect_residual_args
def _collect_residual_args(v):
if _super_collect is None:
assert not v.vable_access # xxx need to use access ?
t = ()
else:
t = _super_collect(v.super)
for name in my_redirected_names:
t = t + (getattr(v, name),)
return t
self._collect_residual_args = _collect_residual_args
def collect_residual_args(v):
t = (v,) + _collect_residual_args(v)
return t
self.collect_residual_args = collect_residual_args
def _define_access_is_null(self, hrtyper):
RGenOp = hrtyper.RGenOp
annhelper = hrtyper.annhelper
def access_is_null(struc):
assert not struc.vable_access
access_is_null_ptr = annhelper.delayedfunction(access_is_null,
[self.s_structtype],
annmodel.s_None,
needtype = True)
self.gv_access_is_null_ptr = RGenOp.constPrebuiltGlobal(
access_is_null_ptr)
self.access_is_null_token = RGenOp.sigToken(
lltype.typeOf(access_is_null_ptr).TO)
def factory(self):
vstructbox = StructTypeDesc.factory(self)
outsidebox = rvalue.PtrRedBox(self.innermostdesc.ptrkind,
self.gv_null)
content = vstructbox.content
assert isinstance(content, VirtualizableStruct)
content.content_boxes.append(outsidebox)
return vstructbox
# ____________________________________________________________
# XXX basic field descs for now
class FieldDesc(object):
__metaclass__ = cachedtype
_attrs_ = 'structdesc'
allow_void = False
virtualizable = False
gv_default = None
canbevirtual = False
gcref = False
fieldnonnull = False
def __init__(self, hrtyper, PTRTYPE, RESTYPE):
RGenOp = hrtyper.RGenOp
self.PTRTYPE = PTRTYPE
T = None
if isinstance(RESTYPE, lltype.ContainerType):
T = RESTYPE
RESTYPE = lltype.Ptr(RESTYPE)
self.fieldnonnull = True
elif isinstance(RESTYPE, lltype.Ptr):
T = RESTYPE.TO
if hasattr(T, '_hints'):
# xxx hack for simple recursive cases
if not PTRTYPE.TO._hints.get('virtualizable', False):
self.virtualizable = T._hints.get('virtualizable', False)
self.gcref = T._gckind == 'gc'
if isinstance(T, lltype.ContainerType):
if not T._is_varsize() or hasattr(T, 'll_newlist'):
self.canbevirtual = True
else:
T = None
self.fieldnonnull = PTRTYPE.TO._hints.get('shouldntbenull', False)
self.RESTYPE = RESTYPE
self.ptrkind = RGenOp.kindToken(PTRTYPE)
self.kind = RGenOp.kindToken(RESTYPE)
if self.RESTYPE is not lltype.Void:
self.gv_default = RGenOp.constPrebuiltGlobal(self.RESTYPE._defl())
if RESTYPE is lltype.Void and self.allow_void:
pass # no redboxcls at all
else:
if self.virtualizable:
self.structdesc = StructTypeDesc(hrtyper, T)
self.redboxcls = rvalue.ll_redboxcls(RESTYPE)
self.immutable = PTRTYPE.TO._hints.get('immutable', False)
def _freeze_(self):
return True
def makedefaultbox(self):
return self.redboxcls(self.kind, self.gv_default)
def makebox(self, jitstate, gvar):
if self.virtualizable:
structbox = self.structdesc.factory()
content = structbox.content
assert isinstance(content, VirtualizableStruct)
content.load_from(jitstate, gvar)
return structbox
box = self.redboxcls(self.kind, gvar)
if self.fieldnonnull:
assert isinstance(box, rvalue.PtrRedBox)
box.known_nonzero = True
return box
class NamedFieldDesc(FieldDesc):
def __init__(self, hrtyper, PTRTYPE, name):
FieldDesc.__init__(self, hrtyper, PTRTYPE, getattr(PTRTYPE.TO, name))
T = self.PTRTYPE.TO
self.fieldname = name
self.fieldtoken = hrtyper.RGenOp.fieldToken(T, name)
def compact_repr(self): # goes in ll helper names
return "Fld_%s_in_%s" % (self.fieldname, self.PTRTYPE._short_name())
def generate_get(self, jitstate, genvar):
builder = jitstate.curbuilder
gv_item = builder.genop_getfield(self.fieldtoken, genvar)
return self.makebox(jitstate, gv_item)
def generate_set(self, jitstate, genvar, gv_value):
builder = jitstate.curbuilder
builder.genop_setfield(self.fieldtoken, genvar, gv_value)
def generate_getsubstruct(self, jitstate, genvar):
builder = jitstate.curbuilder
gv_sub = builder.genop_getsubstruct(self.fieldtoken, genvar)
return self.makebox(jitstate, gv_sub)
class StructFieldDesc(NamedFieldDesc):
def __init__(self, hrtyper, PTRTYPE, name, index):
NamedFieldDesc.__init__(self, hrtyper, PTRTYPE, name)
self.fieldindex = index
class ArrayFieldDesc(FieldDesc):
allow_void = True
def __init__(self, hrtyper, TYPE):
assert isinstance(TYPE, lltype.Array)
FieldDesc.__init__(self, hrtyper, lltype.Ptr(TYPE), TYPE.OF)
RGenOp = hrtyper.RGenOp
self.arraytoken = RGenOp.arrayToken(TYPE)
self.varsizealloctoken = RGenOp.varsizeAllocToken(TYPE)
self.indexkind = RGenOp.kindToken(lltype.Signed)
# ____________________________________________________________
class FrozenVirtualStruct(FrozenContainer):
def __init__(self, typedesc):
self.typedesc = typedesc
#self.fz_content_boxes initialized later
def exactmatch(self, vstruct, outgoingvarboxes, memo):
assert isinstance(vstruct, VirtualContainer)
contmemo = memo.containers
if self in contmemo:
ok = vstruct is contmemo[self]
if not ok:
outgoingvarboxes.append(vstruct.ownbox)
return ok
if vstruct in contmemo:
assert contmemo[vstruct] is not self
outgoingvarboxes.append(vstruct.ownbox)
return False
if (not isinstance(vstruct, VirtualStruct)
or self.typedesc is not vstruct.typedesc):
if not memo.force_merge:
raise rvalue.DontMerge
outgoingvarboxes.append(vstruct.ownbox)
return False
contmemo[self] = vstruct
contmemo[vstruct] = self
self_boxes = self.fz_content_boxes
vstruct_boxes = vstruct.content_boxes
fullmatch = True
for i in range(len(self_boxes)):
if not self_boxes[i].exactmatch(vstruct_boxes[i],
outgoingvarboxes,
memo):
fullmatch = False
return fullmatch
def unfreeze(self, incomingvarboxes, memo):
contmemo = memo.containers
if self in contmemo:
return contmemo[self]
typedesc = self.typedesc
ownbox = typedesc.factory()
contmemo[self] = ownbox
vstruct = ownbox.content
assert isinstance(vstruct, VirtualStruct)
self_boxes = self.fz_content_boxes
for i in range(len(self_boxes)):
fz_box = self_boxes[i]
vstruct.content_boxes[i] = fz_box.unfreeze(incomingvarboxes,
memo)
return ownbox
class VirtualStruct(VirtualContainer):
_attrs_ = "typedesc content_boxes".split()
allowed_in_virtualizable = True
def __init__(self, typedesc):
self.typedesc = typedesc
#self.content_boxes = ... set in factory()
#self.ownbox = ... set in factory()
def enter_block(self, incoming, memo):
contmemo = memo.containers
if self not in contmemo:
contmemo[self] = None
for box in self.content_boxes:
box.enter_block(incoming, memo)
def setforced(self, gv_forced):
self.content_boxes = None
self.ownbox.setgenvar_hint(gv_forced, known_nonzero=True)
self.ownbox.content = None
def force_runtime_container(self, jitstate):
typedesc = self.typedesc
builder = jitstate.curbuilder
boxes = self.content_boxes
self.content_boxes = None
if typedesc.materialize is not None:
for box in boxes:
if box is None or not box.is_constant():
break
else:
gv = typedesc.materialize(builder.rgenop, boxes)
self.ownbox.setgenvar_hint(gv, known_nonzero=True)
self.ownbox.content = None
return
debug_print(lltype.Void, "FORCE CONTAINER: "+ typedesc.TYPE._name)
#debug_pdb(lltype.Void)
genvar = builder.genop_malloc_fixedsize(typedesc.alloctoken)
# force the box pointing to this VirtualStruct
self.setforced(genvar)
fielddescs = typedesc.fielddescs
for i in range(len(fielddescs)):
fielddesc = fielddescs[i]
box = boxes[i]
fielddesc.generate_set(jitstate, genvar, box.getgenvar(jitstate))
def freeze(self, memo):
contmemo = memo.containers
assert self not in contmemo # contmemo no longer used
result = contmemo[self] = FrozenVirtualStruct(self.typedesc)
frozens = [box.freeze(memo) for box in self.content_boxes]
result.fz_content_boxes = frozens
return result
def copy(self, memo):
typedesc = self.typedesc
contmemo = memo.containers
assert self not in contmemo # contmemo no longer used
result = contmemo[self] = typedesc.VirtualStructCls(typedesc)
result.content_boxes = [box.copy(memo)
for box in self.content_boxes]
result.ownbox = self.ownbox.copy(memo)
return result
def replace(self, memo):
contmemo = memo.containers
assert self not in contmemo # contmemo no longer used
contmemo[self] = None
content_boxes = self.content_boxes
for i in range(len(content_boxes)):
content_boxes[i] = content_boxes[i].replace(memo)
self.ownbox = self.ownbox.replace(memo)
def op_getfield(self, jitstate, fielddesc):
return self.content_boxes[fielddesc.fieldindex]
def op_setfield(self, jitstate, fielddesc, valuebox):
self.content_boxes[fielddesc.fieldindex] = valuebox
def op_getsubstruct(self, jitstate, fielddesc):
return self.ownbox
def make_rti(self, jitstate, memo):
try:
return memo.containers[self]
except KeyError:
pass
typedesc = self.typedesc
bitmask = 1 << memo.bitcount
memo.bitcount += 1
rgenop = jitstate.curbuilder.rgenop
vrti = rvirtualizable.VirtualRTI(rgenop, bitmask)
vrti.devirtualize = typedesc.devirtualize
memo.containers[self] = vrti
builder = jitstate.curbuilder
place = builder.alloc_frame_place(typedesc.ptrkind)
vrti.forced_place = place
forced_box = rvalue.PtrRedBox(typedesc.ptrkind)
memo.forced_boxes.append((forced_box, place))
vars_gv = memo.framevars_gv
varindexes = vrti.varindexes
vrtis = vrti.vrtis
j = -1
for box in self.content_boxes:
if box.genvar:
varindexes.append(memo.frameindex)
memo.frameindex += 1
vars_gv.append(box.genvar)
else:
varindexes.append(j)
assert isinstance(box, rvalue.PtrRedBox)
content = box.content
assert content.allowed_in_virtualizable
vrtis.append(content.make_rti(jitstate, memo))
j -= 1
self.content_boxes.append(forced_box)
return vrti
def reshape(self, jitstate, shapemask, memo):
if self in memo.containers:
return
typedesc = self.typedesc
builder = jitstate.curbuilder
memo.containers[self] = None
bitmask = 1<<memo.bitcount
memo.bitcount += 1
boxes = self.content_boxes
outside_box = boxes.pop()
if bitmask&shapemask:
gv_forced = outside_box.genvar
memo.forced.append((self, gv_forced))
for box in boxes:
if not box.genvar:
assert isinstance(box, rvalue.PtrRedBox)
content = box.content
assert content.allowed_in_virtualizable
content.reshape(jitstate, shapemask, memo)
class VirtualizableStruct(VirtualStruct):
def force_runtime_container(self, jitstate):
assert 0
def getgenvar(self, jitstate):
typedesc = self.typedesc
gv_outside = self.content_boxes[-1].genvar
if gv_outside is typedesc.gv_null:
assert isinstance(typedesc, VirtualizableStructTypeDesc)
builder = jitstate.curbuilder
gv_outside = builder.genop_malloc_fixedsize(typedesc.alloctoken)
outsidebox = rvalue.PtrRedBox(self.content_boxes[-1].kind,
gv_outside,
known_nonzero = True)
self.content_boxes[-1] = outsidebox
jitstate.add_virtualizable(self.ownbox)
#access_token = typedesc.access_desc.fieldtoken
#gv_access_null = typedesc.access_desc.gv_default
#builder.genop_setfield(access_token, gv_outside, gv_access_null)
# write all non-redirected fields
boxes = self.content_boxes
fielddescs = typedesc.fielddescs
redirected = typedesc.redirected
for i in range(len(fielddescs)):
if i not in redirected:
fielddesc = fielddescs[i]
box = boxes[i]
fielddesc.generate_set(jitstate, gv_outside,
box.getgenvar(jitstate))
return gv_outside
def store_back(self, jitstate):
typedesc = self.typedesc
assert isinstance(typedesc, VirtualizableStructTypeDesc)
boxes = self.content_boxes
gv_outside = boxes[-1].genvar
for fielddesc, i in typedesc.redirected_fielddescs:
box = boxes[i]
fielddesc.generate_set(jitstate, gv_outside,
box.getgenvar(jitstate))
def load_from(self, jitstate, gv_outside):
typedesc = self.typedesc
assert isinstance(typedesc, VirtualizableStructTypeDesc)
# XXX missing check for gv_outside being NULL
boxes = self.content_boxes
boxes[-1] = rvalue.PtrRedBox(boxes[-1].kind,
gv_outside,
known_nonzero=True)
builder = jitstate.curbuilder
builder.genop_call(typedesc.access_is_null_token,
typedesc.gv_access_is_null_ptr,
[gv_outside])
for fielddesc, i in typedesc.redirected_fielddescs:
boxes[i] = fielddesc.generate_get(jitstate, gv_outside)
jitstate.add_virtualizable(self.ownbox)
def make_rti(self, jitstate, memo):
typedesc = self.typedesc
outsidebox = self.content_boxes[-1]
gv_outside = outsidebox.genvar
if gv_outside is typedesc.gv_null:
return None
try:
return memo.containers[self]
except KeyError:
pass
assert isinstance(typedesc, VirtualizableStructTypeDesc)
rgenop = jitstate.curbuilder.rgenop
vable_rti = rvirtualizable.VirtualizableRTI(rgenop, 0)
vable_rti.touch_update = typedesc.touch_update
vable_rti.shape_place = jitstate.shape_place
memo.containers[self] = vable_rti
vars_gv = memo.framevars_gv
varindexes = vable_rti.varindexes
vrtis = vable_rti.vrtis
boxes = self.content_boxes
j = -1
for _, i in typedesc.redirected_fielddescs:
box = boxes[i]
if box.genvar:
varindexes.append(memo.frameindex)
memo.frameindex += 1
vars_gv.append(box.genvar)
else:
varindexes.append(j)
assert isinstance(box, rvalue.PtrRedBox)
content = box.content
assert content.allowed_in_virtualizable
vrtis.append(content.make_rti(jitstate, memo))
j -= 1
nvirtual = -j-1
bitmask = 1 << memo.bitcount
memo.bitcount += 1
memo.bitcount += nvirtual
vable_rti.bitmask = bitmask
return vable_rti
def prepare_for_residual_call(self, jitstate, gv_base, vable_rti):
typedesc = self.typedesc
assert isinstance(typedesc, VirtualizableStructTypeDesc)
builder = jitstate.curbuilder
gv_outside = self.content_boxes[-1].genvar
base_desc = typedesc.base_desc
base_token = base_desc.fieldtoken
builder.genop_setfield(base_token, gv_outside, gv_base)
vable_rti_ptr = cast_instance_to_base_ptr(vable_rti)
gv_vable_rti = builder.rgenop.genconst(vable_rti_ptr)
rti_token = typedesc.rti_desc.fieldtoken
builder.genop_setfield(rti_token, gv_outside, gv_vable_rti)
access_token = typedesc.access_desc.fieldtoken
builder.genop_setfield(access_token, gv_outside, typedesc.gv_access)
def check_forced_after_residual_call(self, jitstate):
typedesc = self.typedesc
builder = jitstate.curbuilder
gv_outside = self.content_boxes[-1].genvar
if gv_outside is typedesc.gv_null:
return
assert isinstance(typedesc, VirtualizableStructTypeDesc)
access_token = typedesc.access_desc.fieldtoken
gv_access_null = typedesc.access_desc.gv_default
builder.genop_setfield(access_token, gv_outside, gv_access_null)
def reshape(self, jitstate, shapemask, memo):
typedesc = self.typedesc
builder = jitstate.curbuilder
gv_outside = self.content_boxes[-1].genvar
if gv_outside is typedesc.gv_null:
return
if self in memo.containers:
return
memo.containers[self] = None
assert isinstance(typedesc, VirtualizableStructTypeDesc)
boxes = self.content_boxes
nvirtual = 0
for _, i in typedesc.redirected_fielddescs:
box = boxes[i]
if not box.genvar:
nvirtual += 1
assert isinstance(box, rvalue.PtrRedBox)
content = box.content
assert content.allowed_in_virtualizable
content.reshape(jitstate, shapemask, memo)
bitmask = 1 << memo.bitcount
memo.bitcount += 1
memo.bitcount += nvirtual
if shapemask&bitmask:
vmask = bitmask
for fielddesc, i in typedesc.redirected_fielddescs:
box = boxes[i]
if not box.genvar:
vmask = vmask<<1
if not (shapemask&vmask):
continue
boxes[i] = fielddesc.generate_get(jitstate, gv_outside)
def op_getfield(self, jitstate, fielddesc):
typedesc = self.typedesc
assert isinstance(typedesc, VirtualizableStructTypeDesc)
gv_outside = self.content_boxes[-1].genvar
fieldindex = fielddesc.fieldindex
if (gv_outside is typedesc.gv_null or
fieldindex in typedesc.redirected):
return self.content_boxes[fieldindex]
else:
gv_ptr = self.getgenvar(jitstate)
box = fielddesc.generate_get(jitstate, gv_ptr)
return box
def op_setfield(self, jitstate, fielddesc, valuebox):
typedesc = self.typedesc
assert isinstance(typedesc, VirtualizableStructTypeDesc)
fieldindex = fielddesc.fieldindex
gv_outside = self.content_boxes[-1].genvar
if (gv_outside is typedesc.gv_null or
fieldindex in typedesc.redirected):
self.content_boxes[fielddesc.fieldindex] = valuebox
else:
gv_ptr = self.getgenvar(jitstate)
fielddesc.generate_set(jitstate, gv_ptr,
valuebox.getgenvar(jitstate))
def op_ptreq(self, jitstate, otherbox, reverse):
if self is otherbox.content:
answer = True
else:
gv_outside = self.content_boxes[-1].genvar
if gv_outside is self.typedesc.gv_null:
answer = False
else:
return None # fall-back
return rvalue.ll_fromvalue(jitstate, answer ^ reverse)
# patching VirtualStructCls
StructTypeDesc.VirtualStructCls = VirtualStruct
VirtualizableStructTypeDesc.VirtualStructCls = VirtualizableStruct
# ____________________________________________________________
class FrozenPartialDataStruct(AbstractContainer):
def __init__(self):
self.fz_data = []
def getfzbox(self, searchindex):
for index, fzbox in self.fz_data:
if index == searchindex:
return fzbox
else:
return None
def match(self, box, partialdatamatch):
content = box.content
if not isinstance(content, PartialDataStruct):
return False
cankeep = {}
for index, subbox in content.data:
selfbox = self.getfzbox(index)
if selfbox is not None and selfbox.is_constant_equal(subbox):
cankeep[index] = None
fullmatch = len(cankeep) == len(self.fz_data)
try:
prevkeep = partialdatamatch[box]
except KeyError:
partialdatamatch[box] = cankeep
else:
if prevkeep is not None:
d = {}
for index in prevkeep:
if index in cankeep:
d[index] = None
partialdatamatch[box] = d
return fullmatch
class PartialDataStruct(AbstractContainer):
def __init__(self):
self.data = []
def op_getfield(self, jitstate, fielddesc):
searchindex = fielddesc.fieldindex
for index, box in self.data:
if index == searchindex:
return box
else:
return None
def op_ptreq(self, jitstate, otherbox, reverse):
return None # XXX for now
def remember_field(self, fielddesc, box):
searchindex = fielddesc.fieldindex
for i in range(len(self.data)):
if self.data[i][0] == searchindex:
self.data[i] = searchindex, box
return
else:
self.data.append((searchindex, box))
def partialfreeze(self, memo):
contmemo = memo.containers
assert self not in contmemo # contmemo no longer used
result = contmemo[self] = FrozenPartialDataStruct()
for index, box in self.data:
if box.is_constant():
frozenbox = box.freeze(memo)
result.fz_data.append((index, frozenbox))
if len(result.fz_data) == 0:
return None
else:
return result
def copy(self, memo):
result = PartialDataStruct()
for index, box in self.data:
result.data.append((index, box.copy(memo)))
return result
def replace(self, memo):
for i in range(len(self.data)):
index, box = self.data[i]
box = box.replace(memo)
self.data[i] = index, box
def enter_block(self, incoming, memo):
contmemo = memo.containers
if self not in contmemo:
contmemo[self] = None
for index, box in self.data:
box.enter_block(incoming, memo)
def cleanup_partial_data(self, keep):
if keep is None:
return None
j = 0
data = self.data
for i in range(len(data)):
item = data[i]
if item[0] in keep:
data[j] = item
j += 1
if j == 0:
return None
del data[j:]
return self
| Python |
from pypy.rpython.lltypesystem import lltype
from pypy.rpython.extregistry import ExtRegistryEntry
from pypy.jit.timeshifter.rcontainer import cachedtype
from pypy.jit.timeshifter import rvalue, rtimeshift
from pypy.translator.c import exceptiontransform
from pypy.rlib.unroll import unrolling_iterable
from pypy.tool.sourcetools import func_with_new_name
class SegfaultException(Exception):
"Signals a run-time segfault detected at compile-time."
class Index:
def __init__(self, n):
self.n = n
class OopSpecDesc:
__metaclass__ = cachedtype
do_call = None
def __init__(self, hrtyper, fnobj, can_raise):
ll_func = fnobj._callable
FUNCTYPE = lltype.typeOf(fnobj)
nb_args = len(FUNCTYPE.ARGS)
self.can_raise = can_raise
# parse the oopspec and fill in the arguments
operation_name, args = ll_func.oopspec.split('(', 1)
assert args.endswith(')')
args = args[:-1] + ',' # trailing comma to force tuple syntax
if args.strip() == ',':
args = '()'
argnames = ll_func.func_code.co_varnames[:nb_args]
d = dict(zip(argnames, [Index(n) for n in range(nb_args)]))
self.argtuple = eval(args, d)
# end of rather XXX'edly hackish parsing
OOPARGTYPES = []
arg_llsig_to_oopsig = {}
for i, obj in enumerate(self.argtuple):
if isinstance(obj, Index):
arg_llsig_to_oopsig[obj.n] = i
OOPARG = FUNCTYPE.ARGS[obj.n]
else:
OOPARG = lltype.typeOf(obj)
OOPARGTYPES.append(OOPARG)
self.residualargsources = []
for i in range(nb_args):
ARGTYPE = FUNCTYPE.ARGS[i]
if ARGTYPE is not lltype.Void:
self.residualargsources.append(arg_llsig_to_oopsig[i])
RGenOp = hrtyper.RGenOp
self.args_gv = [None] * nb_args
fnptr = fnobj._as_ptr()
self.gv_fnptr = RGenOp.constPrebuiltGlobal(fnptr)
result_kind = RGenOp.kindToken(FUNCTYPE.RESULT)
self.result_kind = result_kind
if FUNCTYPE.RESULT is lltype.Void:
self.errorbox = None
else:
error_value = exceptiontransform.error_value(FUNCTYPE.RESULT)
self.errorbox = rvalue.redbox_from_prebuilt_value(RGenOp,
error_value)
redboxbuilder = rvalue.ll_redboxbuilder(FUNCTYPE.RESULT)
self.redboxbuilder = redboxbuilder
self.sigtoken = RGenOp.sigToken(FUNCTYPE)
if operation_name == 'newlist':
typename, method = 'list', 'oop_newlist'
SELFTYPE = FUNCTYPE.RESULT.TO
self.is_method = False
elif operation_name == 'newdict':
typename, method = 'dict', 'oop_newdict'
SELFTYPE = FUNCTYPE.RESULT.TO
self.is_method = False
else:
typename, method = operation_name.split('.')
method = 'oop_%s_%s' % (typename, method)
SELFTYPE = FUNCTYPE.ARGS[self.argtuple[0].n].TO
self.is_method = True
vmodule = __import__('pypy.jit.timeshifter.v%s' % (typename,),
None, None, [method])
self.typedesc = vmodule.TypeDesc(hrtyper, SELFTYPE)
self.ll_handler = getattr(vmodule, method)
self.couldfold = getattr(self.ll_handler, 'couldfold', False)
if self.couldfold:
oopargcheck = ll_func.oopargcheck # required if couldfold=True
# make a copy of the function, for specialization purposes
oopargcheck = func_with_new_name(oopargcheck,
'argcheck_%s' % (method,))
ARGS = FUNCTYPE.ARGS
residualargsources = self.residualargsources
unrolling_ARGS = unrolling_iterable(ARGS)
unrolling_OOPARGS = unrolling_iterable(enumerate(OOPARGTYPES))
def do_call(jitstate, argboxes):
oopargs = ()
for i, ARG in unrolling_OOPARGS:
v = rvalue.ll_getvalue(argboxes[i], ARG)
oopargs += (v,)
if not oopargcheck(*oopargs):
raise SegfaultException
args = ()
j = 0
for ARG in unrolling_ARGS:
if ARG == lltype.Void:
v = None
else:
argsrc = residualargsources[j]
j = j + 1
v = oopargs[argsrc]
args += (v,)
result = fnptr(*args)
if FUNCTYPE.RESULT == lltype.Void:
return None
return rvalue.ll_fromvalue(jitstate, result)
self.do_call = do_call
# hack! to avoid confusion between the .typedesc attribute
# of oopspecdescs of different types (lists, dicts, etc.)
# let's use different subclasses for the oopspecdesc too.
self.__class__ = globals()['OopSpecDesc_%s' % typename]
def residual_call(self, jitstate, argboxes, deepfrozen=False):
builder = jitstate.curbuilder
args_gv = []
fold = deepfrozen
for argsrc in self.residualargsources:
gv_arg = argboxes[argsrc].getgenvar(jitstate)
args_gv.append(gv_arg)
fold &= gv_arg.is_const
if fold:
try:
return self.do_call(jitstate, argboxes)
except Exception, e:
jitstate.residual_exception(e)
return self.errorbox
gv_result = builder.genop_call(self.sigtoken, self.gv_fnptr, args_gv)
if self.can_raise:
jitstate.generated_oop_residual_can_raise = True
return self.redboxbuilder(self.result_kind, gv_result)
def residual_exception(self, jitstate, ExcCls):
ll_evalue = get_ll_instance_for_exccls(ExcCls)
jitstate.residual_ll_exception(ll_evalue)
return self.errorbox
residual_exception._annspecialcase_ = 'specialize:arg(2)'
class OopSpecDesc_list(OopSpecDesc):
pass
class OopSpecDesc_dict(OopSpecDesc):
pass
def get_ll_instance_for_exccls(ExcCls):
raise NotImplementedError
class Entry(ExtRegistryEntry):
_about_ = get_ll_instance_for_exccls
def compute_result_annotation(self, s_exccls):
from pypy.annotation import model as annmodel
assert s_exccls.is_constant()
bk = self.bookkeeper
excdata = bk.annotator.policy.rtyper.exceptiondata
return annmodel.lltype_to_annotation(excdata.lltype_of_exception_value)
def specialize_call(self, hop):
ExcCls = hop.args_s[0].const
rtyper = hop.rtyper
bk = rtyper.annotator.bookkeeper
clsdef = bk.getuniqueclassdef(ExcCls)
excdata = rtyper.exceptiondata
ll_evalue = excdata.get_standard_ll_exc_instance(rtyper, clsdef)
return hop.inputconst(hop.r_result, ll_evalue)
| Python |
from pypy.rpython.lltypesystem import lltype, llmemory
class Memo(object):
_annspecialcase_ = 'specialize:ctr_location'
def __init__(self):
self.boxes = {}
self.containers = {}
def enter_block_memo():
return Memo()
def freeze_memo():
return Memo()
def exactmatch_memo(force_merge=False):
memo = Memo()
memo.partialdatamatch = {}
memo.forget_nonzeroness = {}
memo.force_merge=force_merge
return memo
def copy_memo():
return Memo()
def unfreeze_memo():
return Memo()
def make_vrti_memo():
return Memo()
class DontMerge(Exception):
pass
class RedBox(object):
_attrs_ = ['kind', 'genvar']
def __init__(self, kind, genvar=None):
self.kind = kind
self.genvar = genvar # None or a genvar
def __repr__(self):
if not self.genvar:
return '<dummy>'
else:
return '<%r>' % (self.genvar,)
def is_constant(self):
return bool(self.genvar) and self.genvar.is_const
def getgenvar(self, jitstate):
return self.genvar
def setgenvar(self, newgenvar):
assert not self.is_constant()
self.genvar = newgenvar
def learn_boolvalue(self, jitstate, boolval):
return True
def enter_block(self, incoming, memo):
memo = memo.boxes
if not self.is_constant() and self not in memo:
incoming.append(self)
memo[self] = None
def forcevar(self, jitstate, memo, forget_nonzeroness):
if self.is_constant():
# cannot mutate constant boxes in-place
builder = jitstate.curbuilder
box = self.copy(memo)
box.genvar = builder.genop_same_as(self.kind, self.genvar)
return box
else:
return self
def replace(self, memo):
memo = memo.boxes
return memo.setdefault(self, self)
def ll_redboxcls(TYPE):
assert TYPE is not lltype.Void, "cannot make red boxes of voids"
return ll_redboxbuilder(TYPE)
def redboxbuilder_void(kind, gv_value):return None
def redboxbuilder_int(kind, gv_value): return IntRedBox(kind, gv_value)
def redboxbuilder_dbl(kind, gv_value): return DoubleRedBox(kind,gv_value)
def redboxbuilder_ptr(kind, gv_value): return PtrRedBox(kind, gv_value)
def ll_redboxbuilder(TYPE):
if TYPE is lltype.Void:
return redboxbuilder_void
elif isinstance(TYPE, lltype.Ptr):
return redboxbuilder_ptr
elif TYPE is lltype.Float:
return redboxbuilder_dbl
else:
assert isinstance(TYPE, lltype.Primitive)
# XXX what about long longs?
return redboxbuilder_int
def ll_fromvalue(jitstate, value):
"Make a constant RedBox from a low-level value."
gv = ll_gv_fromvalue(jitstate, value)
T = lltype.typeOf(value)
kind = jitstate.curbuilder.rgenop.kindToken(T)
cls = ll_redboxcls(T)
return cls(kind, gv)
def redbox_from_prebuilt_value(RGenOp, value):
T = lltype.typeOf(value)
kind = RGenOp.kindToken(T)
gv = RGenOp.constPrebuiltGlobal(value)
cls = ll_redboxcls(T)
return cls(kind, gv)
def ll_gv_fromvalue(jitstate, value):
rgenop = jitstate.curbuilder.rgenop
gv = rgenop.genconst(value)
return gv
def ll_getvalue(box, T):
"Return the content of a known-to-be-constant RedBox."
return box.genvar.revealconst(T)
def ll_is_constant(box):
"Check if a red box is known to be constant."
return box.is_constant()
class IntRedBox(RedBox):
"A red box that contains a constant integer-like value."
def learn_boolvalue(self, jitstate, boolval):
if self.is_constant():
return self.genvar.revealconst(lltype.Bool) == boolval
else:
self.setgenvar(ll_gv_fromvalue(jitstate, boolval))
return True
def copy(self, memo):
memo = memo.boxes
try:
return memo[self]
except KeyError:
result = memo[self] = IntRedBox(self.kind, self.genvar)
return result
def freeze(self, memo):
memo = memo.boxes
try:
return memo[self]
except KeyError:
if self.is_constant():
result = FrozenIntConst(self.kind, self.genvar)
else:
result = FrozenIntVar(self.kind)
memo[self] = result
return result
class DoubleRedBox(RedBox):
"A red box that contains a constant double-precision floating point value."
def copy(self, memo):
memo = memo.boxes
try:
return memo[self]
except KeyError:
result = memo[self] = DoubleRedBox(self.kind, self.genvar)
return result
def freeze(self, memo):
memo = memo.boxes
try:
return memo[self]
except KeyError:
if self.is_constant():
result = FrozenDoubleConst(self.kind, self.genvar)
else:
result = FrozenDoubleVar(self.kind)
memo[self] = result
return result
class PtrRedBox(RedBox):
content = None # or an AbstractContainer
def __init__(self, kind, genvar=None, known_nonzero=False):
self.kind = kind
self.genvar = genvar # None or a genvar
if genvar is not None and genvar.is_const:
known_nonzero = bool(genvar.revealconst(llmemory.Address))
self.known_nonzero = known_nonzero
def setgenvar(self, newgenvar):
RedBox.setgenvar(self, newgenvar)
self.known_nonzero = (newgenvar.is_const and
bool(newgenvar.revealconst(llmemory.Address)))
def setgenvar_hint(self, newgenvar, known_nonzero):
RedBox.setgenvar(self, newgenvar)
self.known_nonzero = known_nonzero
def learn_nonzeroness(self, jitstate, nonzeroness):
ok = True
if nonzeroness:
if self.is_constant():
ok = self.known_nonzero # not ok if constant zero
else:
self.known_nonzero = True
else:
if self.is_constant():
ok = not self.genvar.revealconst(llmemory.Address) # ok if null
else:
gv_null = jitstate.curbuilder.rgenop.genzeroconst(self.kind)
self.setgenvar_hint(gv_null, known_nonzero=False)
return ok
learn_boolvalue = learn_nonzeroness
def __repr__(self):
if not self.genvar and self.content is not None:
return '<virtual %s>' % (self.content,)
else:
return RedBox.__repr__(self)
def op_getfield(self, jitstate, fielddesc):
self.learn_nonzeroness(jitstate, True)
if self.content is not None:
box = self.content.op_getfield(jitstate, fielddesc)
if box is not None:
return box
gv_ptr = self.getgenvar(jitstate)
box = fielddesc.generate_get(jitstate, gv_ptr)
if fielddesc.immutable:
self.remember_field(fielddesc, box)
return box
def op_setfield(self, jitstate, fielddesc, valuebox):
self.learn_nonzeroness(jitstate, True)
gv_ptr = self.genvar
if gv_ptr:
fielddesc.generate_set(jitstate, gv_ptr,
valuebox.getgenvar(jitstate))
else:
assert self.content is not None
self.content.op_setfield(jitstate, fielddesc, valuebox)
def op_getsubstruct(self, jitstate, fielddesc):
self.learn_nonzeroness(jitstate, True)
gv_ptr = self.genvar
if gv_ptr:
return fielddesc.generate_getsubstruct(jitstate, gv_ptr)
else:
assert self.content is not None
return self.content.op_getsubstruct(jitstate, fielddesc)
def remember_field(self, fielddesc, box):
if self.genvar.is_const:
return # no point in remembering field then
if self.content is None:
from pypy.jit.timeshifter import rcontainer
self.content = rcontainer.PartialDataStruct()
self.content.remember_field(fielddesc, box)
def copy(self, memo):
boxmemo = memo.boxes
try:
result = boxmemo[self]
except KeyError:
result = PtrRedBox(self.kind, self.genvar, self.known_nonzero)
boxmemo[self] = result
if self.content:
result.content = self.content.copy(memo)
assert isinstance(result, PtrRedBox)
return result
def replace(self, memo):
boxmemo = memo.boxes
try:
result = boxmemo[self]
except KeyError:
boxmemo[self] = self
if self.content:
self.content.replace(memo)
result = self
assert isinstance(result, PtrRedBox)
return result
def freeze(self, memo):
boxmemo = memo.boxes
try:
return boxmemo[self]
except KeyError:
content = self.content
if not self.genvar:
from pypy.jit.timeshifter import rcontainer
assert isinstance(content, rcontainer.VirtualContainer)
result = FrozenPtrVirtual(self.kind)
boxmemo[self] = result
result.fz_content = content.freeze(memo)
return result
elif self.genvar.is_const:
result = FrozenPtrConst(self.kind, self.genvar)
elif content is None:
result = FrozenPtrVar(self.kind, self.known_nonzero)
else:
# if self.content is not None, it's a PartialDataStruct
from pypy.jit.timeshifter import rcontainer
assert isinstance(content, rcontainer.PartialDataStruct)
result = FrozenPtrVarWithPartialData(self.kind,
known_nonzero=True)
boxmemo[self] = result
result.fz_partialcontent = content.partialfreeze(memo)
return result
boxmemo[self] = result
return result
def getgenvar(self, jitstate):
if not self.genvar:
content = self.content
from pypy.jit.timeshifter import rcontainer
if isinstance(content, rcontainer.VirtualizableStruct):
return content.getgenvar(jitstate)
assert isinstance(content, rcontainer.VirtualContainer)
content.force_runtime_container(jitstate)
assert self.genvar
return self.genvar
def forcevar(self, jitstate, memo, forget_nonzeroness):
from pypy.jit.timeshifter import rcontainer
# xxx
assert not isinstance(self.content, rcontainer.VirtualizableStruct)
if self.is_constant():
# cannot mutate constant boxes in-place
builder = jitstate.curbuilder
box = self.copy(memo)
box.genvar = builder.genop_same_as(self.kind, self.genvar)
else:
# force virtual containers
self.getgenvar(jitstate)
box = self
if forget_nonzeroness:
box.known_nonzero = False
return box
def enter_block(self, incoming, memo):
if self.genvar:
RedBox.enter_block(self, incoming, memo)
if self.content:
self.content.enter_block(incoming, memo)
# ____________________________________________________________
class FrozenValue(object):
"""An abstract value frozen in a saved state.
"""
def __init__(self, kind):
self.kind = kind
def is_constant_equal(self, box):
return False
def is_constant_nullptr(self):
return False
class FrozenConst(FrozenValue):
def exactmatch(self, box, outgoingvarboxes, memo):
if self.is_constant_equal(box):
return True
else:
outgoingvarboxes.append(box)
return False
class FrozenVar(FrozenValue):
def exactmatch(self, box, outgoingvarboxes, memo):
memo = memo.boxes
if self not in memo:
memo[self] = box
outgoingvarboxes.append(box)
return True
elif memo[self] is box:
return True
else:
outgoingvarboxes.append(box)
return False
class FrozenIntConst(FrozenConst):
def __init__(self, kind, gv_const):
self.kind = kind
self.gv_const = gv_const
def is_constant_equal(self, box):
return (box.is_constant() and
self.gv_const.revealconst(lltype.Signed) ==
box.genvar.revealconst(lltype.Signed))
def unfreeze(self, incomingvarboxes, memo):
# XXX could return directly the original IntRedBox
return IntRedBox(self.kind, self.gv_const)
class FrozenIntVar(FrozenVar):
def unfreeze(self, incomingvarboxes, memo):
memo = memo.boxes
if self not in memo:
newbox = IntRedBox(self.kind, None)
incomingvarboxes.append(newbox)
memo[self] = newbox
return newbox
else:
return memo[self]
class FrozenDoubleConst(FrozenConst):
def __init__(self, kind, gv_const):
self.kind = kind
self.gv_const = gv_const
def is_constant_equal(self, box):
return (box.is_constant() and
self.gv_const.revealconst(lltype.Float) ==
box.genvar.revealconst(lltype.Float))
def unfreeze(self, incomingvarboxes, memo):
return DoubleRedBox(self.kind, self.gv_const)
class FrozenDoubleVar(FrozenVar):
def unfreeze(self, incomingvarboxes, memo):
memo = memo.boxes
if self not in memo:
newbox = DoubleRedBox(self.kind, None)
incomingvarboxes.append(newbox)
memo[self] = newbox
return newbox
else:
return memo[self]
class FrozenPtrConst(FrozenConst):
def __init__(self, kind, gv_const):
self.kind = kind
self.gv_const = gv_const
def is_constant_equal(self, box):
return (box.is_constant() and
self.gv_const.revealconst(llmemory.Address) ==
box.genvar.revealconst(llmemory.Address))
def is_constant_nullptr(self):
return not self.gv_const.revealconst(llmemory.Address)
def exactmatch(self, box, outgoingvarboxes, memo):
assert isinstance(box, PtrRedBox)
memo.partialdatamatch[box] = None # could do better
if self.is_constant_nullptr():
memo.forget_nonzeroness[box] = None
match = FrozenConst.exactmatch(self, box, outgoingvarboxes, memo)
if not memo.force_merge and not match:
from pypy.jit.timeshifter.rcontainer import VirtualContainer
if isinstance(box.content, VirtualContainer):
raise DontMerge # XXX recursive data structures?
return match
def unfreeze(self, incomingvarboxes, memo):
return PtrRedBox(self.kind, self.gv_const)
class FrozenPtrVar(FrozenVar):
def __init__(self, kind, known_nonzero):
self.kind = kind
self.known_nonzero = known_nonzero
def exactmatch(self, box, outgoingvarboxes, memo):
assert isinstance(box, PtrRedBox)
memo.partialdatamatch[box] = None
if not self.known_nonzero:
memo.forget_nonzeroness[box] = None
match = FrozenVar.exactmatch(self, box, outgoingvarboxes, memo)
if self.known_nonzero and not box.known_nonzero:
match = False
if not memo.force_merge and not match:
from pypy.jit.timeshifter.rcontainer import VirtualContainer
if isinstance(box.content, VirtualContainer):
raise DontMerge # XXX recursive data structures?
return match
def unfreeze(self, incomingvarboxes, memo):
memo = memo.boxes
if self not in memo:
newbox = PtrRedBox(self.kind, None, self.known_nonzero)
incomingvarboxes.append(newbox)
memo[self] = newbox
return newbox
else:
return memo[self]
class FrozenPtrVarWithPartialData(FrozenPtrVar):
def exactmatch(self, box, outgoingvarboxes, memo):
if self.fz_partialcontent is None:
return FrozenPtrVar.exactmatch(self, box, outgoingvarboxes, memo)
assert isinstance(box, PtrRedBox)
partialdatamatch = self.fz_partialcontent.match(box,
memo.partialdatamatch)
# skip the parent's exactmatch()!
exact = FrozenVar.exactmatch(self, box, outgoingvarboxes, memo)
match = exact and partialdatamatch
if not memo.force_merge and not match:
from pypy.jit.timeshifter.rcontainer import VirtualContainer
if isinstance(box.content, VirtualContainer):
raise DontMerge # XXX recursive data structures?
return match
class FrozenPtrVirtual(FrozenValue):
def exactmatch(self, box, outgoingvarboxes, memo):
assert isinstance(box, PtrRedBox)
if box.genvar:
outgoingvarboxes.append(box)
match = False
else:
assert box.content is not None
match = self.fz_content.exactmatch(box.content, outgoingvarboxes,
memo)
return match
def unfreeze(self, incomingvarboxes, memo):
return self.fz_content.unfreeze(incomingvarboxes, memo)
##class FrozenPtrVarWithData(FrozenValue):
## def exactmatch(self, box, outgoingvarboxes, memo):
## memo = memo.boxes
## if self not in memo:
## memo[self] = box
## outgoingvarboxes.append(box)
## return True
## elif memo[self] is box:
## return True
## else:
## outgoingvarboxes.append(box)
## return False
| Python |
from pypy.rpython.lltypesystem import lltype, llmemory
from pypy.jit.timeshifter.rcontainer import VirtualContainer, FrozenContainer
from pypy.jit.timeshifter.rcontainer import cachedtype
from pypy.jit.timeshifter import rvalue, rvirtualizable
from pypy.rpython.lltypesystem import lloperation
debug_print = lloperation.llop.debug_print
class ItemDesc(object):
__metaclass__ = cachedtype
gcref = False
canbevirtual = False
def _freeze_(self):
return True
def __init__(self, ITEM):
self.RESTYPE = ITEM
if isinstance(ITEM, lltype.Ptr):
T = ITEM.TO
self.gcref = T._gckind == 'gc'
if isinstance(T, lltype.ContainerType):
if not T._is_varsize():
self.canbevirtual = True
class ListTypeDesc(object):
__metaclass__ = cachedtype
def __init__(self, hrtyper, LIST):
RGenOp = hrtyper.RGenOp
rtyper = hrtyper.rtyper
self.LIST = LIST
self.LISTPTR = lltype.Ptr(LIST)
self.ptrkind = RGenOp.kindToken(self.LISTPTR)
self.null = self.LISTPTR._defl()
self.gv_null = RGenOp.constPrebuiltGlobal(self.null)
argtypes = [lltype.Signed]
ll_newlist_ptr = rtyper.annotate_helper_fn(LIST.ll_newlist,
argtypes)
self.gv_ll_newlist = RGenOp.constPrebuiltGlobal(ll_newlist_ptr)
self.tok_ll_newlist = RGenOp.sigToken(lltype.typeOf(ll_newlist_ptr).TO)
argtypes = [self.LISTPTR, lltype.Signed, LIST.ITEM]
ll_setitem_fast = rtyper.annotate_helper_fn(LIST.ll_setitem_fast,
argtypes)
self.gv_ll_setitem_fast = RGenOp.constPrebuiltGlobal(ll_setitem_fast)
self.tok_ll_setitem_fast = RGenOp.sigToken(
lltype.typeOf(ll_setitem_fast).TO)
self._define_devirtualize()
def _define_devirtualize(self):
LIST = self.LIST
LISTPTR = self.LISTPTR
itemdesc = ItemDesc(LIST.ITEM)
def make(vrti):
n = len(vrti.varindexes)
l = LIST.ll_newlist(n)
return lltype.cast_opaque_ptr(llmemory.GCREF, l)
def fill_into(vablerti, l, base, vrti):
l = lltype.cast_opaque_ptr(LISTPTR, l)
n = len(vrti.varindexes)
for i in range(n):
v = vrti._read_field(vablerti, itemdesc, base, i)
l.ll_setitem_fast(i, v)
self.devirtualize = make, fill_into
def _freeze_(self):
return True
def factory(self, length, itembox):
vlist = VirtualList(self, length, itembox)
box = rvalue.PtrRedBox(self.ptrkind, known_nonzero=True)
box.content = vlist
vlist.ownbox = box
return box
TypeDesc = ListTypeDesc
class FrozenVirtualList(FrozenContainer):
def __init__(self, typedesc):
self.typedesc = typedesc
#self.fz_item_boxes initialized later
def exactmatch(self, vlist, outgoingvarboxes, memo):
assert isinstance(vlist, VirtualList)
contmemo = memo.containers
if self in contmemo:
ok = vlist is contmemo[self]
if not ok:
outgoingvarboxes.append(vlist.ownbox)
return ok
if vlist in contmemo:
assert contmemo[vlist] is not self
outgoingvarboxes.append(vlist.ownbox)
return False
assert self.typedesc is vlist.typedesc
self_boxes = self.fz_item_boxes
vlist_boxes = vlist.item_boxes
if len(self_boxes) != len(vlist_boxes):
outgoingvarboxes.append(vlist.ownbox)
return False
contmemo[self] = vlist
contmemo[vlist] = self
fullmatch = True
for i in range(len(self_boxes)):
if not self_boxes[i].exactmatch(vlist_boxes[i],
outgoingvarboxes,
memo):
fullmatch = False
return fullmatch
def unfreeze(self, incomingvarboxes, memo):
contmemo = memo.containers
if self in contmemo:
return contmemo[self]
typedesc = self.typedesc
self_boxes = self.fz_item_boxes
length = len(self_boxes)
ownbox = typedesc.factory(length, None)
contmemo[self] = ownbox
vlist = ownbox.content
assert isinstance(vlist, VirtualList)
for i in range(length):
fz_box = self_boxes[i]
vlist.item_boxes[i] = fz_box.unfreeze(incomingvarboxes,
memo)
return ownbox
class VirtualList(VirtualContainer):
allowed_in_virtualizable = True
def __init__(self, typedesc, length=0, itembox=None):
self.typedesc = typedesc
self.item_boxes = [itembox] * length
# self.ownbox = ... set in factory()
def enter_block(self, incoming, memo):
contmemo = memo.containers
if self not in contmemo:
contmemo[self] = None
for box in self.item_boxes:
box.enter_block(incoming, memo)
def setforced(self, gv_forced):
self.item_boxes = None
self.ownbox.setgenvar_hint(gv_forced, known_nonzero=True)
self.ownbox.content = None
def force_runtime_container(self, jitstate):
typedesc = self.typedesc
builder = jitstate.curbuilder
boxes = self.item_boxes
self.item_boxes = None
debug_print(lltype.Void, "FORCE LIST (%d items)" % (len(boxes),))
args_gv = [builder.rgenop.genconst(len(boxes))]
gv_list = builder.genop_call(typedesc.tok_ll_newlist,
typedesc.gv_ll_newlist,
args_gv)
self.setforced(gv_list)
for i in range(len(boxes)):
gv_item = boxes[i].getgenvar(jitstate)
args_gv = [gv_list, builder.rgenop.genconst(i), gv_item]
builder.genop_call(typedesc.tok_ll_setitem_fast,
typedesc.gv_ll_setitem_fast,
args_gv)
def freeze(self, memo):
contmemo = memo.containers
try:
return contmemo[self]
except KeyError:
result = contmemo[self] = FrozenVirtualList(self.typedesc)
frozens = [box.freeze(memo) for box in self.item_boxes]
result.fz_item_boxes = frozens
return result
def copy(self, memo):
contmemo = memo.containers
try:
return contmemo[self]
except KeyError:
result = contmemo[self] = VirtualList(self.typedesc)
result.item_boxes = [box.copy(memo)
for box in self.item_boxes]
result.ownbox = self.ownbox.copy(memo)
return result
def replace(self, memo):
contmemo = memo.containers
if self not in contmemo:
contmemo[self] = None
for i in range(len(self.item_boxes)):
self.item_boxes[i] = self.item_boxes[i].replace(memo)
self.ownbox = self.ownbox.replace(memo)
def make_rti(self, jitstate, memo):
try:
return memo.containers[self]
except KeyError:
pass
typedesc = self.typedesc
bitmask = 1 << memo.bitcount
memo.bitcount += 1
rgenop = jitstate.curbuilder.rgenop
vrti = rvirtualizable.VirtualRTI(rgenop, bitmask)
vrti.devirtualize = typedesc.devirtualize
memo.containers[self] = vrti
builder = jitstate.curbuilder
place = builder.alloc_frame_place(typedesc.ptrkind)
vrti.forced_place = place
forced_box = rvalue.PtrRedBox(typedesc.ptrkind)
memo.forced_boxes.append((forced_box, place))
vars_gv = memo.framevars_gv
varindexes = vrti.varindexes
vrtis = vrti.vrtis
j = -1
for box in self.item_boxes:
if box.genvar:
varindexes.append(memo.frameindex)
memo.frameindex += 1
vars_gv.append(box.genvar)
else:
varindexes.append(j)
assert isinstance(box, rvalue.PtrRedBox)
content = box.content
assert content.allowed_in_virtualizable
vrtis.append(content.make_rti(jitstate, memo))
j -= 1
self.item_boxes.append(forced_box)
return vrti
def reshape(self, jitstate, shapemask, memo):
if self in memo.containers:
return
typedesc = self.typedesc
builder = jitstate.curbuilder
memo.containers[self] = None
bitmask = 1<<memo.bitcount
memo.bitcount += 1
boxes = self.item_boxes
outside_box = boxes.pop()
if bitmask&shapemask:
gv_forced = outside_box.genvar
memo.forced.append((self, gv_forced))
for box in boxes:
if not box.genvar:
assert isinstance(box, rvalue.PtrRedBox)
content = box.content
assert content.allowed_in_virtualizable
content.reshape(jitstate, shapemask, memo)
def oop_newlist(jitstate, oopspecdesc, lengthbox, itembox=None):
if lengthbox.is_constant():
length = rvalue.ll_getvalue(lengthbox, lltype.Signed)
return oopspecdesc.typedesc.factory(length, itembox)
return oopspecdesc.residual_call(jitstate, [lengthbox, itembox])
def oop_list_copy(jitstate, oopspecdesc, selfbox):
content = selfbox.content
if isinstance(content, VirtualList):
copybox = oopspecdesc.typedesc.factory(0, None)
copycontent = copybox.content
assert isinstance(copycontent, VirtualList)
copycontent.item_boxes.extend(content.item_boxes)
return copybox
else:
return oopspecdesc.residual_call(jitstate, [selfbox])
def oop_list_len(jitstate, oopspecdesc, deepfrozen, selfbox):
content = selfbox.content
if isinstance(content, VirtualList):
return rvalue.ll_fromvalue(jitstate, len(content.item_boxes))
else:
return oopspecdesc.residual_call(jitstate, [selfbox],
deepfrozen=deepfrozen)
oop_list_len.couldfold = True
def oop_list_nonzero(jitstate, oopspecdesc, deepfrozen, selfbox):
content = selfbox.content
if isinstance(content, VirtualList):
return rvalue.ll_fromvalue(jitstate, bool(content.item_boxes))
else:
return oopspecdesc.residual_call(jitstate, [selfbox],
deepfrozen=deepfrozen)
oop_list_nonzero.couldfold = True
def oop_list_append(jitstate, oopspecdesc, selfbox, itembox):
content = selfbox.content
if isinstance(content, VirtualList):
content.item_boxes.append(itembox)
else:
oopspecdesc.residual_call(jitstate, [selfbox, itembox])
def oop_list_insert(jitstate, oopspecdesc, selfbox, indexbox, itembox):
content = selfbox.content
if isinstance(content, VirtualList) and indexbox.is_constant():
index = rvalue.ll_getvalue(indexbox, lltype.Signed)
# XXX what if the assert fails?
assert 0 <= index <= len(content.item_boxes)
content.item_boxes.insert(index, itembox)
else:
oopspecdesc.residual_call(jitstate, [selfbox, indexbox, itembox])
def oop_list_concat(jitstate, oopspecdesc, selfbox, otherbox):
content = selfbox.content
if isinstance(content, VirtualList):
assert isinstance(otherbox, rvalue.PtrRedBox)
othercontent = otherbox.content
if othercontent is not None and isinstance(othercontent, VirtualList):
newbox = oopspecdesc.typedesc.factory(0, None)
newcontent = newbox.content
assert isinstance(newcontent, VirtualList)
newcontent.item_boxes.extend(content.item_boxes)
newcontent.item_boxes.extend(othercontent.item_boxes)
return newbox
return oopspecdesc.residual_call(jitstate, [selfbox, otherbox])
def oop_list_pop(jitstate, oopspecdesc, selfbox, indexbox=None):
content = selfbox.content
if indexbox is None:
if isinstance(content, VirtualList):
try:
return content.item_boxes.pop()
except IndexError:
return oopspecdesc.residual_exception(jitstate, IndexError)
else:
return oopspecdesc.residual_call(jitstate, [selfbox])
if (isinstance(content, VirtualList) and
indexbox.is_constant()):
index = rvalue.ll_getvalue(indexbox, lltype.Signed)
try:
return content.item_boxes.pop(index)
except IndexError:
return oopspecdesc.residual_exception(jitstate, IndexError)
return oopspecdesc.residual_call(jitstate, [selfbox, indexbox])
def oop_list_reverse(jitstate, oopspecdesc, selfbox):
content = selfbox.content
if isinstance(content, VirtualList):
content.item_boxes.reverse()
else:
oopspecdesc.residual_call(jitstate, [selfbox])
def oop_list_getitem(jitstate, oopspecdesc, deepfrozen, selfbox, indexbox):
content = selfbox.content
if isinstance(content, VirtualList) and indexbox.is_constant():
index = rvalue.ll_getvalue(indexbox, lltype.Signed)
try:
return content.item_boxes[index]
except IndexError:
return oopspecdesc.residual_exception(jitstate, IndexError)
else:
return oopspecdesc.residual_call(jitstate, [selfbox, indexbox],
deepfrozen=deepfrozen)
oop_list_getitem.couldfold = True
def oop_list_setitem(jitstate, oopspecdesc, selfbox, indexbox, itembox):
content = selfbox.content
if isinstance(content, VirtualList) and indexbox.is_constant():
index = rvalue.ll_getvalue(indexbox, lltype.Signed)
try:
content.item_boxes[index] = itembox
except IndexError:
oopspecdesc.residual_exception(jitstate, IndexError)
else:
oopspecdesc.residual_call(jitstate, [selfbox, indexbox, itembox])
def oop_list_delitem(jitstate, oopspecdesc, selfbox, indexbox):
content = selfbox.content
if isinstance(content, VirtualList) and indexbox.is_constant():
index = rvalue.ll_getvalue(indexbox, lltype.Signed)
try:
del content.item_boxes[index]
except IndexError:
oopspecdesc.residual_exception(jitstate, IndexError)
else:
oopspecdesc.residual_call(jitstate, [selfbox, indexbox])
| Python |
import py
Option = py.test.config.Option
option = py.test.config.addoptions("timeshifter tests options",
Option('--dump', action="store_true", default=False,
dest="use_dump_backend",
help="uses the dump backend, to log the backend operations"),
)
| Python |
'''Toy Language with Cons Cells'''
import py
from pypy.jit.tl.opcode import *
from pypy.jit.tl import opcode as tlopcode
from pypy.rlib.jit import hint
class Obj(object):
def t(self): raise TypeError
def int_o(self): raise TypeError
def add(self, other): raise TypeError
def sub(self, other): raise TypeError
def mul(self, other): raise TypeError
def div(self, other): raise TypeError
def eq(self, other): raise TypeError
def lt(self, other): raise TypeError
def car(self): raise TypeError
def cdr(self): raise TypeError
def _concat(self, other): raise TypeError
class IntObj(Obj):
def __init__(self, value):
self.value = value
def t(self):
return bool(self.value)
def int_o(self):
return self.value
def add(self, other): return IntObj(self.value + other.int_o())
def sub(self, other): return IntObj(self.value - other.int_o())
def mul(self, other): return IntObj(self.value * other.int_o())
def div(self, other): return IntObj(self.value // other.int_o())
def eq(self, other):
return isinstance(other, IntObj) and self.value == other.value
def lt(self, other): return self.value < other.int_o()
zero = IntObj(0)
class LispObj(Obj):
def div(self, n):
n = n.int_o()
if n < 0:
raise IndexError
return self._nth(n)
def add(self, other):
if not isinstance(other, LispObj):
raise TypeError
return self._concat(other)
class NilObj(LispObj):
def t(self):
return False
def eq(self, other):
return self is other
def _concat(self, other):
return other
def _nth(self, n):
raise IndexError
nil = NilObj()
class ConsObj(LispObj):
def __init__(self, car, cdr):
self._car = car
self._cdr = cdr
def t(self):
return True
def eq(self, other):
return (isinstance(other, ConsObj) and
self._car.eq(other._car) and self._cdr.eq(other._cdr))
def car(self):
return self._car
def cdr(self):
return self._cdr
def _concat(self, other):
return ConsObj(self._car, self._cdr._concat(other))
def _nth(self, n):
if n == 0:
return self._car
else:
return self._cdr._nth(n-1)
def char2int(c):
t = ord(c)
if t & 128:
t = -(-ord(c) & 0xff)
return t
def make_interp(supports_call):
def interp(code='', pc=0, inputarg=0):
if not isinstance(code,str):
raise TypeError("code '%s' should be a string" % str(code))
return interp_eval(code, pc, IntObj(inputarg)).int_o()
def interp_eval(code, pc, inputarg):
code_len = len(code)
stack = []
while pc < code_len:
hint(None, global_merge_point=True)
opcode = ord(code[pc])
opcode = hint(opcode, concrete=True)
pc += 1
if opcode == NOP:
pass
elif opcode == NIL:
stack.append(nil)
elif opcode == CONS:
car, cdr = stack.pop(), stack.pop()
stack.append(ConsObj(car, cdr))
elif opcode == CAR:
stack.append(stack.pop().car())
elif opcode == CDR:
stack.append(stack.pop().cdr())
elif opcode == PUSH:
stack.append(IntObj(char2int(code[pc])))
pc += 1
elif opcode == POP:
stack.pop()
elif opcode == SWAP:
a, b = stack.pop(), stack.pop()
stack.append(a)
stack.append(b)
elif opcode == ROLL: #rotate stack top to somewhere below
r = char2int(code[pc])
if r < -1:
i = len(stack) + r
if i < 0:
raise IndexError
stack.insert( i, stack.pop() )
elif r > 1:
i = len(stack) - r
if i < 0:
raise IndexError
stack.append(stack.pop(i))
pc += 1
elif opcode == PICK:
stack.append( stack[-1 - char2int(code[pc])] )
pc += 1
elif opcode == PUT:
stack[-1 - char2int(code[pc])] = stack.pop()
pc += 1
elif opcode == ADD:
a, b = stack.pop(), stack.pop()
hint(a.__class__, promote=True)
hint(b.__class__, promote=True)
stack.append(b.add(a))
elif opcode == SUB:
a, b = stack.pop(), stack.pop()
hint(a.__class__, promote=True)
hint(b.__class__, promote=True)
stack.append(b.sub(a))
elif opcode == MUL:
a, b = stack.pop(), stack.pop()
hint(a.__class__, promote=True)
hint(b.__class__, promote=True)
stack.append(b.mul(a))
elif opcode == DIV:
a, b = stack.pop(), stack.pop()
hint(a.__class__, promote=True)
hint(b.__class__, promote=True)
stack.append(b.div(a))
elif opcode == EQ:
a, b = stack.pop(), stack.pop()
hint(a.__class__, promote=True)
hint(b.__class__, promote=True)
stack.append(IntObj(b.eq(a)))
elif opcode == NE:
a, b = stack.pop(), stack.pop()
hint(a.__class__, promote=True)
hint(b.__class__, promote=True)
stack.append(IntObj(not b.eq(a)))
elif opcode == LT:
a, b = stack.pop(), stack.pop()
hint(a.__class__, promote=True)
hint(b.__class__, promote=True)
stack.append(IntObj(b.lt(a)))
elif opcode == LE:
a, b = stack.pop(), stack.pop()
hint(a.__class__, promote=True)
hint(b.__class__, promote=True)
stack.append(IntObj(not a.lt(b)))
elif opcode == GT:
a, b = stack.pop(), stack.pop()
hint(a.__class__, promote=True)
hint(b.__class__, promote=True)
stack.append(IntObj(a.lt(b)))
elif opcode == GE:
a, b = stack.pop(), stack.pop()
hint(a.__class__, promote=True)
hint(b.__class__, promote=True)
stack.append(IntObj(not b.lt(a)))
elif opcode == BR_COND:
cond = stack.pop()
hint(cond.__class__, promote=True)
if cond.t():
pc += char2int(code[pc])
pc += 1
elif opcode == BR_COND_STK:
offset = stack.pop().int_o()
if stack.pop().t():
pc += hint(offset, forget=True)
elif supports_call and opcode == CALL:
offset = char2int(code[pc])
pc += 1
res = interp_eval(code, pc + offset, zero)
stack.append( res )
elif opcode == RETURN:
break
elif opcode == PUSHARG:
stack.append(inputarg)
else:
raise RuntimeError("unknown opcode: " + str(opcode))
return stack[-1]
return interp, interp_eval
interp , interp_eval = make_interp(supports_call = True)
interp_without_call, interp_eval_without_call = make_interp(supports_call = False)
| Python |
from pypy.jit.tl import tiny2
from pypy.jit.codegen.hlinfo import highleveljitinfo
def entry_point(args):
"""Main entry point of the stand-alone executable:
takes a list of strings and returns the exit code.
"""
# store args[0] in a place where the JIT log can find it (used by
# viewcode.py to know the executable whose symbols it should display)
highleveljitinfo.sys_executable = args[0]
if len(args) < 2:
print "Invalid command line arguments."
print args[0] + " 'tiny2 program string' arg0 [arg1 [arg2 [...]]]"
return 1
bytecode = [s for s in args[1].split(' ') if s != '']
args = [tiny2.StrBox(arg) for arg in args[2:]]
res = tiny2.interpret(bytecode, args)
print tiny2.repr(res)
return 0
def target(driver, args):
return entry_point, None
# ____________________________________________________________
from pypy.jit.hintannotator.policy import HintAnnotatorPolicy
class MyHintAnnotatorPolicy(HintAnnotatorPolicy):
novirtualcontainer = True
oopspec = True
def look_inside_graph(self, graph):
# temporary workaround
return getattr(graph, 'func', None) is not tiny2.myint_internal
def portal(driver):
"""Return the 'portal' function, and the hint-annotator policy.
The portal is the function that gets patched with a call to the JIT
compiler.
"""
return tiny2.interpret, MyHintAnnotatorPolicy()
| Python |
from pypy.rlib.jit import hint
def ll_plus_minus(s, x, y):
acc = x
pc = 0
while pc < len(s):
op = s[pc]
hint(op, concrete=True)
if op == '+':
acc += y
elif op == '-':
acc -= y
pc += 1
return acc
def test_simple():
res = ll_plus_minus("+-++", 100, 10)
assert res == 120
| Python |
from pypy.rlib.jit import hint
MOV_A_R = 1
MOV_R_A = 2
JUMP_IF_A = 3
SET_A = 4
ADD_R_TO_A = 5
RETURN_A = 6
ALLOCATE = 7
NEG_A = 8
def interpret(bytecode, a):
"""Another Toy Language interpreter, this one register-based."""
regs = []
pc = 0
while True:
hint(None, global_merge_point=True)
opcode = hint(ord(bytecode[pc]), concrete=True)
pc += 1
if opcode == MOV_A_R:
n = ord(bytecode[pc])
pc += 1
regs[n] = a
elif opcode == MOV_R_A:
n = ord(bytecode[pc])
pc += 1
a = regs[n]
elif opcode == JUMP_IF_A:
target = ord(bytecode[pc])
pc += 1
if a:
pc = target
elif opcode == SET_A:
a = ord(bytecode[pc])
pc += 1
elif opcode == ADD_R_TO_A:
n = ord(bytecode[pc])
pc += 1
a += regs[n]
elif opcode == RETURN_A:
return a
elif opcode == ALLOCATE:
n = ord(bytecode[pc])
pc += 1
regs = [0] * n
elif opcode == NEG_A:
a = -a
# ____________________________________________________________
# example bytecode: compute the square of 'a' >= 1
SQUARE_LIST = [
ALLOCATE, 3,
MOV_A_R, 0, # counter
MOV_A_R, 1, # copy of 'a'
SET_A, 0,
MOV_A_R, 2, # accumulator for the result
# 10:
SET_A, 1,
NEG_A,
ADD_R_TO_A, 0,
MOV_A_R, 0,
MOV_R_A, 2,
ADD_R_TO_A, 1,
MOV_A_R, 2,
MOV_R_A, 0,
JUMP_IF_A, 10,
MOV_R_A, 2,
RETURN_A ]
SQUARE = ''.join([chr(n) for n in SQUARE_LIST])
if __name__ == '__main__':
print ','.join([str(n) for n in SQUARE_LIST])
| Python |
names = {}
def opcode(n, opcode_name):
global opcode_names
names[opcode_name] = globals()[opcode_name] = n
# basic tl opcodes:
opcode(1, "NOP")
opcode(2, "PUSH") #1 operand
opcode(3, "POP")
opcode(4, "SWAP")
opcode(5, "ROLL")
opcode(6, "PICK") #1 operand (DUP = PICK,0)
opcode(7, "PUT") #1 operand
opcode(8, "ADD")
opcode(9, "SUB")
opcode(10, "MUL")
opcode(11, "DIV")
opcode(12, "EQ")
opcode(13, "NE")
opcode(14, "LT")
opcode(15, "LE")
opcode(16, "GT")
opcode(17, "GE")
opcode(18, "BR_COND") #1 operand offset
opcode(19, "BR_COND_STK") # no operand, takes [condition, offset] from the stack
opcode(20, "CALL") #1 operand offset
opcode(21, "RETURN")
opcode(22, "PUSHARG")
opcode(23, "INVALID")
# tl with cons cells and boxed values opcodes
opcode(24, "NIL")
opcode(25, "CONS")
opcode(26, "CAR")
opcode(27, "CDR")
del opcode
def compile(code=''):
bytecode = []
labels = {} #[key] = pc
label_usage = [] #(name, pc)
for s in code.split('\n'):
for comment in '; # //'.split():
s = s.split(comment, 1)[0]
s = s.strip()
if not s:
continue
t = s.split()
if t[0].endswith(':'):
labels[ t[0][:-1] ] = len(bytecode)
continue
bytecode.append(names[t[0]])
if len(t) > 1:
try:
bytecode.append( int(t[1]) )
except ValueError:
label_usage.append( (t[1], len(bytecode)) )
bytecode.append( 0 )
for label, pc in label_usage:
bytecode[pc] = labels[label] - pc - 1
return ''.join([chr(i & 0xff) for i in bytecode])
| Python |
from pypy.jit.tl import tiny1
from pypy.jit.codegen.hlinfo import highleveljitinfo
def entry_point(args):
"""Main entry point of the stand-alone executable:
takes a list of strings and returns the exit code.
"""
# store args[0] in a place where the JIT log can find it (used by
# viewcode.py to know the executable whose symbols it should display)
highleveljitinfo.sys_executable = args[0]
if len(args) < 4:
print "Usage: %s bytecode x y" % (args[0],)
return 2
bytecode = args[1]
x = int(args[2])
y = int(args[3])
res = tiny1.ll_plus_minus(bytecode, x, y)
print res
return 0
def target(driver, args):
return entry_point, None
# ____________________________________________________________
from pypy.jit.hintannotator.policy import HintAnnotatorPolicy
class MyHintAnnotatorPolicy(HintAnnotatorPolicy):
novirtualcontainer = True
oopspec = True
def portal(driver):
"""Return the 'portal' function, and the hint-annotator policy.
The portal is the function that gets patched with a call to the JIT
compiler.
"""
return tiny1.ll_plus_minus, MyHintAnnotatorPolicy()
| Python |
class BrainInterpreter(object):
def __init__(self):
self.table = [0] * 30000
self.pointer = 0
def interp_char(self, code, code_pointer, input, output):
char_code = code[code_pointer]
if char_code == '>':
self.pointer += 1
elif char_code == '<':
self.pointer -= 1
elif char_code == '+':
self.table[self.pointer] += 1
elif char_code == '-':
self.table[self.pointer] -= 1
elif char_code == '.':
output.write(chr(self.table[self.pointer]))
elif char_code == ',':
self.table[self.pointer] = ord(input.read(1))
elif char_code == '[':
# find corresponding ]
if self.table[self.pointer] == 0:
need = 1
p = code_pointer + 1
while need > 0:
if code[p] == ']':
need -= 1
elif code[p] == '[':
need += 1
p += 1
return p
elif char_code == ']':
if self.table[self.pointer] != 0:
need = 1
p = code_pointer - 1
while need > 0:
if code[p] == ']':
need += 1
elif code[p] == '[':
need -= 1
p -= 1
return p + 2
return code_pointer + 1
def interpret(self, code, input_string, output_io):
code_pointer = 0
while code_pointer < len(code):
code_pointer = self.interp_char(code, code_pointer,
input_string, output_io)
#print code_pointer, self.table[:5]
return output_io
| Python |
"""
An interpreter for a strange word-based language: the program is a list
of space-separated words. Most words push themselves on a stack; some
words have another action. The result is the space-separated words
from the stack.
Hello World => 'Hello World'
6 7 ADD => '13' 'ADD' is a special word
7 * 5 = 7 5 MUL => '7 * 5 = 35' '*' and '=' are not special words
Arithmetic on non-integers gives a 'symbolic' result:
X 2 MUL => 'X*2'
Input arguments can be passed on the command-line, and used as #1, #2, etc.:
#1 1 ADD => one more than the argument on the command-line,
or if it was not an integer, concatenates '+1'
You can store back into an (existing) argument index with ->#N:
#1 5 ADD ->#1
Braces { } delimitate a loop. Don't forget spaces around each one.
The '}' pops an integer value off the stack and loops if it is not zero:
{ #1 #1 1 SUB ->#1 #1 } => when called with 5, gives '5 4 3 2 1'
"""
from pypy.rlib.jit import hint, _is_early_constant
#
# See pypy/doc/jit.txt for a higher-level overview of the JIT techniques
# detailed in the following comments.
#
class Box:
# Although all words are in theory strings, we use two subclasses
# to represent the strings differently from the words known to be integers.
# This is an optimization that is essential for the JIT and merely
# useful for the basic interpreter.
pass
class IntBox(Box):
def __init__(self, intval):
self.intval = intval
def as_int(self):
return self.intval
def as_str(self):
return str(self.intval)
class StrBox(Box):
def __init__(self, strval):
self.strval = strval
def as_int(self):
return myint(self.strval)
def as_str(self):
return self.strval
def func_add_int(ix, iy): return ix + iy
def func_sub_int(ix, iy): return ix - iy
def func_mul_int(ix, iy): return ix * iy
def func_add_str(sx, sy): return sx + '+' + sy
def func_sub_str(sx, sy): return sx + '-' + sy
def func_mul_str(sx, sy): return sx + '*' + sy
def op2(stack, func_int, func_str):
# Operate on the top two stack items. The promotion hints force the
# class of each arguments (IntBox or StrBox) to turn into a compile-time
# constant if they weren't already. The effect we seek is to make the
# calls to as_int() direct calls at compile-time, instead of indirect
# ones. The JIT compiler cannot look into indirect calls, but it
# can analyze and inline the code in directly-called functions.
y = stack.pop()
hint(y.__class__, promote=True)
x = stack.pop()
hint(x.__class__, promote=True)
try:
z = IntBox(func_int(x.as_int(), y.as_int()))
except ValueError:
z = StrBox(func_str(x.as_str(), y.as_str()))
stack.append(z)
def interpret(bytecode, args):
"""The interpreter's entry point and portal function.
"""
# ------------------------------
# First a lot of JIT hints...
#
# A portal needs a "global merge point" at the beginning, for
# technical reasons, if it uses promotion hints:
hint(None, global_merge_point=True)
# An important hint: 'bytecode' is a list, which is in theory
# mutable. Let's tell the JIT compiler that it can assume that the
# list is entirely frozen, i.e. immutable and only containing immutable
# objects. Otherwise, it cannot do anything - it would have to assume
# that the list can unpredictably change at runtime.
bytecode = hint(bytecode, deepfreeze=True)
# Now some strange code that makes a copy of the 'args' list in
# a complicated way... this is a workaround forcing the whole 'args'
# list to be virtual. It is a way to tell the JIT compiler that it
# doesn't have to worry about the 'args' list being unpredictably
# modified.
oldargs = args
argcount = hint(len(oldargs), promote=True)
args = []
n = 0
while n < argcount:
hint(n, concrete=True)
args.append(oldargs[n])
n += 1
# ------------------------------
# the real code starts here
loops = []
stack = []
pos = 0
while pos < len(bytecode):
# It is a good idea to put another 'global merge point' at the
# start of each iteration in the interpreter's main loop. The
# JIT compiler keeps a table of all the times it passed through
# the global merge point. It allows it to detect when it can
# stop compiling and generate a jump back to some machine code
# that was already generated earlier.
hint(None, global_merge_point=True)
opcode = bytecode[pos]
hint(opcode, concrete=True) # same as in tiny1.py
pos += 1
if opcode == 'ADD': op2(stack, func_add_int, func_add_str)
elif opcode == 'SUB': op2(stack, func_sub_int, func_sub_str)
elif opcode == 'MUL': op2(stack, func_mul_int, func_mul_str)
elif opcode[0] == '#':
n = myint(opcode, start=1)
stack.append(args[n-1])
elif opcode.startswith('->#'):
n = myint(opcode, start=3)
if n > len(args):
raise IndexError
args[n-1] = stack.pop()
elif opcode == '{':
loops.append(pos)
elif opcode == '}':
if stack.pop().as_int() == 0:
loops.pop()
else:
pos = loops[-1]
# A common problem when interpreting loops or jumps: the 'pos'
# above is read out of a list, so the hint-annotator thinks
# it must be red (not a compile-time constant). But the
# hint(opcode, concrete=True) in the next iteration of the
# loop requires all variables the 'opcode' depends on to be
# green, including this 'pos'. We promote 'pos' to a green
# here, as early as possible. Note that in practice the 'pos'
# read out of the 'loops' list will be a compile-time constant
# because it was pushed as a compile-time constant by the '{'
# case above into 'loops', which is a virtual list, so the
# promotion below is just a way to make the colors match.
pos = hint(pos, promote=True)
else:
stack.append(StrBox(opcode))
return stack
def repr(stack):
# this bit moved out of the portal function because JIT'ing it is not
# very useful, and the JIT generator is confused by the 'for' right now...
return ' '.join([x.as_str() for x in stack])
# ------------------------------
# Pure workaround code! It will eventually be unnecessary.
# For now, myint(s, n) is a JIT-friendly way to spell int(s[n:]).
# We don't support negative numbers, though.
def myint_internal(s, start=0):
if start >= len(s):
return -1
res = 0
while start < len(s):
c = s[start]
n = ord(c) - ord('0')
if not (0 <= n <= 9):
return -1
res = res * 10 + n
start += 1
return res
def myint(s, start=0):
if _is_early_constant(s):
s = hint(s, promote=True)
start = hint(start, promote=True)
n = myint_internal(s, start)
if n < 0:
raise ValueError
else:
n = myint_internal(s, start)
if n < 0:
raise ValueError
return n
# ------------------------------
def test_main():
main = """#1 5 ADD""".split()
res = interpret(main, [IntBox(20)])
assert repr(res) == '25'
res = interpret(main, [StrBox('foo')])
assert repr(res) == 'foo+5'
FACTORIAL = """The factorial of #1 is
1 { #1 MUL #1 1 SUB ->#1 #1 }""".split()
def test_factorial():
res = interpret(FACTORIAL, [IntBox(5)])
assert repr(res) == 'The factorial of 5 is 120'
FIBONACCI = """Fibonacci numbers:
{ #1 #2 #1 #2 ADD ->#2 ->#1 #3 1 SUB ->#3 #3 }""".split()
def test_fibonacci():
res = interpret(FIBONACCI, [IntBox(1), IntBox(1), IntBox(10)])
assert repr(res) == "Fibonacci numbers: 1 1 2 3 5 8 13 21 34 55"
| Python |
'''Toy Language'''
import py
from pypy.jit.tl.opcode import *
from pypy.rlib.jit import hint
def char2int(c):
t = ord(c)
if t & 128:
t = -(-ord(c) & 0xff)
return t
def make_interp(supports_call):
def interp(code='', pc=0, inputarg=0):
if not isinstance(code,str):
raise TypeError("code '%s' should be a string" % str(code))
code_len = len(code)
stack = []
while pc < code_len:
opcode = ord(code[pc])
opcode = hint(opcode, concrete=True)
pc += 1
if opcode == NOP:
pass
elif opcode == PUSH:
stack.append( char2int(code[pc]) )
pc += 1
elif opcode == POP:
stack.pop()
elif opcode == SWAP:
a, b = stack.pop(), stack.pop()
stack.append(a)
stack.append(b)
elif opcode == ROLL: #rotate stack top to somewhere below
r = char2int(code[pc])
if r < -1:
i = len(stack) + r
if i < 0:
raise IndexError
stack.insert( i, stack.pop() )
elif r > 1:
i = len(stack) - r
if i < 0:
raise IndexError
stack.append(stack.pop(i))
pc += 1
elif opcode == PICK:
stack.append( stack[-1 - char2int(code[pc])] )
pc += 1
elif opcode == PUT:
stack[-1 - char2int(code[pc])] = stack.pop()
pc += 1
elif opcode == ADD:
a, b = stack.pop(), stack.pop()
stack.append( b + a )
elif opcode == SUB:
a, b = stack.pop(), stack.pop()
stack.append( b - a )
elif opcode == MUL:
a, b = stack.pop(), stack.pop()
stack.append( b * a )
elif opcode == DIV:
a, b = stack.pop(), stack.pop()
stack.append( b / a )
elif opcode == EQ:
a, b = stack.pop(), stack.pop()
stack.append( b == a )
elif opcode == NE:
a, b = stack.pop(), stack.pop()
stack.append( b != a )
elif opcode == LT:
a, b = stack.pop(), stack.pop()
stack.append( b < a )
elif opcode == LE:
a, b = stack.pop(), stack.pop()
stack.append( b <= a )
elif opcode == GT:
a, b = stack.pop(), stack.pop()
stack.append( b > a )
elif opcode == GE:
a, b = stack.pop(), stack.pop()
stack.append( b >= a )
elif opcode == BR_COND:
if stack.pop():
pc += char2int(code[pc])
pc += 1
elif opcode == BR_COND_STK:
offset = stack.pop()
if stack.pop():
pc += hint(offset, forget=True)
elif supports_call and opcode == CALL:
offset = char2int(code[pc])
pc += 1
res = interp(code, pc + offset)
stack.append( res )
elif opcode == RETURN:
break
elif opcode == PUSHARG:
stack.append( inputarg )
else:
raise RuntimeError("unknown opcode: " + str(opcode))
return stack[-1]
return interp
interp = make_interp(supports_call = True)
interp_without_call = make_interp(supports_call = False)
| Python |
import autopath
import py
from pypy.config import pypyoption, translationoption, config
from pypy.doc.config.confrest import all_optiondescrs
thisdir = py.magic.autopath().dirpath()
for descr in all_optiondescrs:
prefix = descr._name
c = config.Config(descr)
thisdir.join(prefix + ".txt").ensure()
for p in c.getpaths(include_groups=True):
basename = prefix + "." + p + ".txt"
f = thisdir.join(basename)
f.ensure()
| Python |
from pypy.doc.confrest import *
from pypy.config.makerestdoc import make_cmdline_overview
from pypy.config.config import Config
from pypy.config import pypyoption, translationoption
all_optiondescrs = [pypyoption.pypy_optiondescription,
translationoption.translation_optiondescription,
]
start_to_descr = dict([(descr._name, descr) for descr in all_optiondescrs])
class PyPyPage(PyPyPage):
def fill(self):
super(PyPyPage, self).fill()
self.menubar[:] = html.div(
html.a("general documentation", href="../index.html",
class_="menu"), " ",
html.a("config index", href="index.html",
class_="menu"), " ",
html.a("command-line overview", href="commandline.html",
class_="menu"), " ",
" ", id="menubar")
class Project(Project):
stylesheet = "../style.css"
title = "PyPy Configuration"
prefix_title = "PyPy Configuration"
Page = PyPyPage
def get_content(self, txtpath, encoding):
if txtpath.basename == "commandline.txt":
result = [".. contents::"]
for descr in all_optiondescrs:
result.append(".. %s_:\n" % (descr._name, ))
result.append(make_cmdline_overview(descr).text())
result.append("")
result.append(txtpath.read())
return "\n".join(result)
fullpath = txtpath.purebasename
start = fullpath.split(".")[0]
path = fullpath.rsplit(".", 1)[0]
basedescr = start_to_descr.get(start)
if basedescr is None:
return txtpath.read()
if fullpath.count(".") == 0:
descr = basedescr
path = ""
else:
conf = Config(basedescr)
subconf, step = conf._cfgimpl_get_home_by_path(
fullpath.split(".", 1)[1])
descr = getattr(subconf._cfgimpl_descr, step)
text = unicode(descr.make_rest_doc(path).text())
if txtpath.check(file=True):
content = txtpath.read()
if content:
text += "\nDescription\n==========="
return u"%s\n\n%s" % (text, unicode(txtpath.read(), encoding))
return text
| Python |
"""
self cloning, automatic path configuration
copy this into any subdirectory of pypy from which scripts need
to be run, typically all of the test subdirs.
The idea is that any such script simply issues
import autopath
and this will make sure that the parent directory containing "pypy"
is in sys.path.
If you modify the master "autopath.py" version (in pypy/tool/autopath.py)
you can directly run it which will copy itself on all autopath.py files
it finds under the pypy root directory.
This module always provides these attributes:
pypydir pypy root directory path
this_dir directory where this autopath.py resides
"""
def __dirinfo(part):
""" return (partdir, this_dir) and insert parent of partdir
into sys.path. If the parent directories don't have the part
an EnvironmentError is raised."""
import sys, os
try:
head = this_dir = os.path.realpath(os.path.dirname(__file__))
except NameError:
head = this_dir = os.path.realpath(os.path.dirname(sys.argv[0]))
while head:
partdir = head
head, tail = os.path.split(head)
if tail == part:
break
else:
raise EnvironmentError, "'%s' missing in '%r'" % (partdir, this_dir)
pypy_root = os.path.join(head, '')
try:
sys.path.remove(head)
except ValueError:
pass
sys.path.insert(0, head)
munged = {}
for name, mod in sys.modules.items():
if '.' in name:
continue
fn = getattr(mod, '__file__', None)
if not isinstance(fn, str):
continue
newname = os.path.splitext(os.path.basename(fn))[0]
if not newname.startswith(part + '.'):
continue
path = os.path.join(os.path.dirname(os.path.realpath(fn)), '')
if path.startswith(pypy_root) and newname != part:
modpaths = os.path.normpath(path[len(pypy_root):]).split(os.sep)
if newname != '__init__':
modpaths.append(newname)
modpath = '.'.join(modpaths)
if modpath not in sys.modules:
munged[modpath] = mod
for name, mod in munged.iteritems():
if name not in sys.modules:
sys.modules[name] = mod
if '.' in name:
prename = name[:name.rfind('.')]
postname = name[len(prename)+1:]
if prename not in sys.modules:
__import__(prename)
if not hasattr(sys.modules[prename], postname):
setattr(sys.modules[prename], postname, mod)
return partdir, this_dir
def __clone():
""" clone master version of autopath.py into all subdirs """
from os.path import join, walk
if not this_dir.endswith(join('pypy','tool')):
raise EnvironmentError("can only clone master version "
"'%s'" % join(pypydir, 'tool',_myname))
def sync_walker(arg, dirname, fnames):
if _myname in fnames:
fn = join(dirname, _myname)
f = open(fn, 'rwb+')
try:
if f.read() == arg:
print "checkok", fn
else:
print "syncing", fn
f = open(fn, 'w')
f.write(arg)
finally:
f.close()
s = open(join(pypydir, 'tool', _myname), 'rb').read()
walk(pypydir, sync_walker, s)
_myname = 'autopath.py'
# set guaranteed attributes
pypydir, this_dir = __dirinfo('pypy')
if __name__ == '__main__':
__clone()
| Python |
import autopath
import py
from pypy.config import pypyoption, translationoption, config
thisdir = py.magic.autopath().dirpath()
if __name__ == '__main__':
c = config.Config(pypyoption.pypy_optiondescription).usemodules
prefix = "objspace.usemodules"
thisdir.join(prefix + ".txt").ensure()
for p in c.getpaths(include_groups=True):
basename = prefix + "." + p + ".txt"
f = thisdir.join(basename)
if f.check() and f.size():
continue
print "making docs for", p
text = ["Use the '%s' module. " % (p, )]
if p in pypyoption.essential_modules:
text.append("This module is essential, included by default and should not be removed.")
elif p in pypyoption.default_modules:
text.append("This module is expected to be working and is included by default.")
elif p in pypyoption.working_modules:
text.append("This module is expected to be fully working.")
text.append("")
f.write("\n".join(text))
| Python |
import py
from py.__.doc.confrest import *
class PyPyPage(Page):
def fill_menubar(self):
self.menubar = html.div(
html.a("news",
href="http://codespeak.net/pypy/dist/pypy/doc/news.html",
class_="menu"), " ",
html.a("getting-started",
href=self.get_doclink("getting-started.html"),
class_="menu"), " ",
html.a("documentation", href=self.get_doclink("index.html"),
class_="menu"), " ",
html.a("downloads", href=self.get_doclink("download.html"),
class_="menu"), " ",
html.a("svn", href="https://codespeak.net/viewvc/pypy/dist/",
class_="menu"), " ",
html.a("issues",
href="https://codespeak.net/issue/pypy-dev/",
class_="menu"),
html.a("contact", href=self.get_doclink("contact.html"),
class_="menu"), " ",
html.a("EU/project",
href="http://pypy.org/", class_="menu"), " ",
" ", id="menubar")
def get_doclink(self, target):
return relpath(self.targetpath.strpath,
self.project.get_docpath().join(target).strpath)
class Project(Project):
mydir = py.magic.autopath().dirpath()
title = "PyPy"
stylesheet = 'style.css'
encoding = 'latin1'
prefix_title = "PyPy"
logo = html.div(
html.a(
html.img(alt="PyPy", id="pyimg",
src="http://codespeak.net/pypy/img/py-web1.png",
height=110, width=149)))
Page = PyPyPage
def get_docpath(self):
return self.mydir
| Python |
import py
from py.__.doc.conftest import Directory, DoctestText, ReSTChecker
from py.__.rest.directive import register_linkrole
thisdir = py.magic.autopath().dirpath()
Option = py.test.config.Option
option = py.test.config.addoptions("pypy-doc options",
Option('--generate-redirections', action="store_true",
dest="generateredirections",
default=False, help="Generate the redirecting HTML files"),
Option('--enable-doctests', action="store_true",
dest="doctests",
default=False, help="enable doctests in .txt files"),
)
class PyPyDoctestText(DoctestText):
def run(self):
if not option.doctests:
py.test.skip("specify --enable-doctests to run doctests")
# XXX refine doctest support with respect to scoping
return super(PyPyDoctestText, self).run()
def execute(self, module, docstring):
# XXX execute PyPy prompts as well
l = []
for line in docstring.split('\n'):
if line.find('>>>>') != -1:
line = ""
l.append(line)
text = "\n".join(l)
super(PyPyDoctestText, self).execute(module, text)
#mod = py.std.types.ModuleType(self.fspath.basename, text)
#self.mergescopes(mod, scopes)
#failed, tot = py.std.doctest.testmod(mod, verbose=1)
#if failed:
# py.test.fail("doctest %s: %s failed out of %s" %(
# self.fspath, failed, tot))
class PyPyReSTChecker(ReSTChecker):
DoctestText = PyPyDoctestText
class Directory(Directory):
ReSTChecker = PyPyReSTChecker
def run(self):
l = super(Directory, self).run()
if 'statistic' in l:
l.remove('statistic')
return l
try:
from docutils.parsers.rst import directives, states, roles
except ImportError:
pass
else:
# enable :config: link role
def config_role(name, rawtext, text, lineno, inliner, options={},
content=[]):
from docutils import nodes
from pypy.config.pypyoption import get_pypy_config
from pypy.config.makerestdoc import get_cmdline
txt = thisdir.join("config", text + ".txt")
html = thisdir.join("config", text + ".html")
assert txt.check()
assert name == "config"
sourcedir = py.path.local(inliner.document.settings._source).dirpath()
curr = sourcedir
prefix = ""
while 1:
relative = str(html.relto(curr))
if relative:
break
curr = curr.dirpath()
prefix += "../"
config = get_pypy_config()
# begin horror
h, n = config._cfgimpl_get_home_by_path(text)
opt = getattr(h._cfgimpl_descr, n)
# end horror
cmdline = get_cmdline(opt.cmdline, text)
if cmdline is not None:
shortest_long_option = 'X'*1000
for cmd in cmdline.split():
if cmd.startswith('--') and len(cmd) < len(shortest_long_option):
shortest_long_option = cmd
text = shortest_long_option
target = prefix + relative
print text, target
reference_node = nodes.reference(rawtext, text, name=text, refuri=target)
return [reference_node], []
config_role.content = True
config_role.options = {}
roles.register_canonical_role("config", config_role)
| Python |
#!/usr/bin/env python
import log_reader
def daily_date_hasher(date):
return ((date.year, date.month, date.day))
def read_log(filename, path_guesser, date_hasher=daily_date_hasher,
max_reads=None):
assert callable(path_guesser)
lr = log_reader.ApacheReader(filename)
ret = {}
keys = []
for num, i in enumerate(lr):
if max_reads and num > max_reads:
return keys, ret
if 'path' in i:
if path_guesser(i['path']):
hash = date_hasher(i['time'])
if hash in ret:
ret[hash] += 1
else:
ret[hash] = 1
keys.append(hash)
return keys, ret
def test_daily_date_hasher():
from datetime import datetime
one = datetime(2007, 2, 25, 3, 10, 50)
two = datetime(2007, 2, 25, 7, 1, 5)
three = datetime(2007, 3, 25, 3, 10, 50)
assert daily_date_hasher(one) == daily_date_hasher(two)
assert daily_date_hasher(one) != daily_date_hasher(three)
def test_read_log():
def path_guesser(path):
return path.startswith("/viewvc")
keys, ret = read_log("code.log", path_guesser)
assert sum(ret.values()) == 51
assert sorted(keys) == keys
assert ret[(2007, 2, 25)] == 51
if __name__ == "__main__":
import sys
import re
if len(sys.argv) == 3:
max_reads = int(sys.argv[2])
elif len(sys.argv) != 2:
print "Usage ./parse_logs.py <logfile> [max reads]"
sys.exit(1)
else:
max_reads = None
def path_guesser(path):
return "pypy" in path
keys, ret = read_log(sys.argv[1], path_guesser, max_reads=max_reads)
for key in keys:
year, month, day = key
print "%d-%d-%d, %d" % (year, month, day, ret[key])
| Python |
#!/usr/bin/env python
import log_reader
def daily_date_hasher(date):
return ((date.year, date.month, date.day))
def read_log(filename, path_guesser, date_hasher=daily_date_hasher,
max_reads=None):
assert callable(path_guesser)
lr = log_reader.ApacheReader(filename)
ret = {}
keys = []
for num, i in enumerate(lr):
if max_reads and num > max_reads:
return keys, ret
if 'path' in i:
if path_guesser(i['path']):
hash = date_hasher(i['time'])
if hash in ret:
ret[hash] += 1
else:
ret[hash] = 1
keys.append(hash)
return keys, ret
def test_daily_date_hasher():
from datetime import datetime
one = datetime(2007, 2, 25, 3, 10, 50)
two = datetime(2007, 2, 25, 7, 1, 5)
three = datetime(2007, 3, 25, 3, 10, 50)
assert daily_date_hasher(one) == daily_date_hasher(two)
assert daily_date_hasher(one) != daily_date_hasher(three)
def test_read_log():
def path_guesser(path):
return path.startswith("/viewvc")
keys, ret = read_log("code.log", path_guesser)
assert sum(ret.values()) == 51
assert sorted(keys) == keys
assert ret[(2007, 2, 25)] == 51
if __name__ == "__main__":
import sys
import re
if len(sys.argv) == 3:
max_reads = int(sys.argv[2])
elif len(sys.argv) != 2:
print "Usage ./parse_logs.py <logfile> [max reads]"
sys.exit(1)
else:
max_reads = None
def path_guesser(path):
return "pypy" in path
keys, ret = read_log(sys.argv[1], path_guesser, max_reads=max_reads)
for key in keys:
year, month, day = key
print "%d-%d-%d, %d" % (year, month, day, ret[key])
| Python |
#!/usr/bin/env python
import py
import string
import re
nonalpha = "".join([chr(i) for i in range(256) if not chr(i).isalpha()])
replacement = (string.ascii_letters * (int(len(nonalpha) / len(string.ascii_letters)) + 1))[:len(nonalpha)]
transtable = string.maketrans(nonalpha, replacement)
del nonalpha
del replacement
def find_replacement(tex, used={}):
replacement = tex.translate(transtable)
while replacement in used:
replacement += "a"
used[replacement] = True
return replacement
def create_tex_eps(dot, temppath):
result = ["\\documentclass{article}",
"\\usepackage[dvips]{graphicx}",
"\\usepackage{psfrag}",
"\\pagestyle{empty}",
"\\begin{document}",
"\\onecolumn"]
texre = re.compile("(\$.*?\$)")
dotcontent = dot.read()
def repl(match, already_seen={}):
tex = match.group(1)
if tex in already_seen:
return already_seen[tex]
r = find_replacement(tex)
already_seen[tex] = r
result.append("\\psfrag{%s}[cc][cc]{%s}" % (r, tex))
return r
tempdot = temppath.join(dot.basename)
eps = tempdot.new(ext='eps')
dotcontent = texre.sub(repl, dotcontent)
result.append("\\includegraphics{%s}" % eps)
result.append("\\end{document}")
tempdot.write(dotcontent)
tex = eps.new(ext="tex")
texcontent = "\n".join(result)
tex.write(texcontent)
epscontent = py.process.cmdexec("dot -Tps %s" % (tempdot, ))
eps.write(re.sub("\n\[.*\]\nxshow", "\nshow", epscontent))
return tex, eps
def process_dot(dot):
temppath = py.test.ensuretemp("dot")
tex, texcontent = create_tex_eps(dot, temppath)
dvi = tex.new(ext="dvi")
output = dvi.new(purebasename=dvi.purebasename + "out", ext="eps")
oldpath = dot.dirpath()
dvi.dirpath().chdir()
py.process.cmdexec("latex %s" % (tex, ))
py.process.cmdexec("dvips -E -o %s %s" % (output, dvi))
oldpath.chdir()
return output
if __name__ == '__main__':
from py.compat import optparse
parser = optparse.OptionParser()
parser.add_option("-T", dest="format",
help="output format")
options, args = parser.parse_args()
if len(args) != 1:
raise ValueError, "need exactly one argument"
epsfile = process_dot(py.path.local(args[0]))
if options.format == "ps" or options.format == "eps":
print epsfile.read()
elif options.format == "png":
png = epsfile.new(ext="png")
py.process.cmdexec("convert %s %s" % (epsfile, png))
print png.read()
| Python |
#!/usr/bin/env python
import py
import string
import re
nonalpha = "".join([chr(i) for i in range(256) if not chr(i).isalpha()])
replacement = (string.ascii_letters * (int(len(nonalpha) / len(string.ascii_letters)) + 1))[:len(nonalpha)]
transtable = string.maketrans(nonalpha, replacement)
del nonalpha
del replacement
def find_replacement(tex, used={}):
replacement = tex.translate(transtable)
while replacement in used:
replacement += "a"
used[replacement] = True
return replacement
def create_tex_eps(dot, temppath):
result = ["\\documentclass{article}",
"\\usepackage[dvips]{graphicx}",
"\\usepackage{psfrag}",
"\\pagestyle{empty}",
"\\begin{document}",
"\\onecolumn"]
texre = re.compile("(\$.*?\$)")
dotcontent = dot.read()
def repl(match, already_seen={}):
tex = match.group(1)
if tex in already_seen:
return already_seen[tex]
r = find_replacement(tex)
already_seen[tex] = r
result.append("\\psfrag{%s}[cc][cc]{%s}" % (r, tex))
return r
tempdot = temppath.join(dot.basename)
eps = tempdot.new(ext='eps')
dotcontent = texre.sub(repl, dotcontent)
result.append("\\includegraphics{%s}" % eps)
result.append("\\end{document}")
tempdot.write(dotcontent)
tex = eps.new(ext="tex")
texcontent = "\n".join(result)
tex.write(texcontent)
epscontent = py.process.cmdexec("dot -Tps %s" % (tempdot, ))
eps.write(re.sub("\n\[.*\]\nxshow", "\nshow", epscontent))
return tex, eps
def process_dot(dot):
temppath = py.test.ensuretemp("dot")
tex, texcontent = create_tex_eps(dot, temppath)
dvi = tex.new(ext="dvi")
output = dvi.new(purebasename=dvi.purebasename + "out", ext="eps")
oldpath = dot.dirpath()
dvi.dirpath().chdir()
py.process.cmdexec("latex %s" % (tex, ))
py.process.cmdexec("dvips -E -o %s %s" % (output, dvi))
oldpath.chdir()
return output
if __name__ == '__main__':
from py.compat import optparse
parser = optparse.OptionParser()
parser.add_option("-T", dest="format",
help="output format")
options, args = parser.parse_args()
if len(args) != 1:
raise ValueError, "need exactly one argument"
epsfile = process_dot(py.path.local(args[0]))
if options.format == "ps" or options.format == "eps":
print epsfile.read()
elif options.format == "png":
png = epsfile.new(ext="png")
py.process.cmdexec("convert %s %s" % (epsfile, png))
print png.read()
| Python |
import py
py.magic.autopath()
import pypy
pypydir = py.path.local(pypy.__file__).dirpath()
distdir = pypydir.dirpath()
dist_url = 'http://codespeak.net/svn/pypy/dist/'
issue_url = 'http://codespeak.net/issue/pypy-dev/'
docdir = pypydir.join('doc')
reffile = pypydir.join('doc', '_ref.txt')
linkrex = py.std.re.compile('`(\S+)`_')
name2target = {}
def addlink(linkname, linktarget):
assert linkname and linkname != '/'
if linktarget in name2target:
if linkname in name2target[linktarget]:
return
name2target.setdefault(linktarget, []).append(linkname)
for textfile in docdir.visit(lambda x: x.ext == '.txt',
lambda x: x.check(dotfile=0)):
for linkname in linkrex.findall(textfile.read()):
if '/' in linkname:
for startloc in ('', 'pypy'):
cand = distdir.join(startloc, linkname)
if cand.check():
rel = cand.relto(distdir)
# we are in pypy/doc/x.txt
target = '../../' + cand.relto(distdir)
addlink(linkname, target)
break
else:
print "WARNING %s: link %r may be bogus" %(textfile, linkname)
elif linkname.startswith('issue'):
addlink(linkname, issue_url+linkname)
items = name2target.items()
items.sort()
lines = []
for linktarget, linknamelist in items:
linknamelist.sort()
for linkname in linknamelist[:-1]:
lines.append(".. _`%s`:" % linkname)
lines.append(".. _`%s`: %s" %(linknamelist[-1], linktarget))
reffile.write("\n".join(lines))
print "wrote %d references to %r" %(len(lines), reffile)
#print "last ten lines"
#for x in lines[-10:]: print x
| Python |
#
| Python |
"""
generates a contributor list
"""
import py
try:
path = py.std.sys.argv[1]
except IndexError:
print "usage: %s PATH" %(py.std.sys.argv[0])
raise SystemExit, 1
d = {}
for logentry in py.path.svnwc(py.std.sys.argv[1]).log():
a = logentry.author
if a in d:
d[a] += 1
else:
d[a] = 1
items = d.items()
items.sort(lambda x,y: -cmp(x[1], y[1]))
import uconf # http://codespeak.net/svn/uconf/dist/uconf
# Authors that don't want to be listed
excluded = set("anna gintas ignas".split())
cutoff = 5 # cutoff for authors in the LICENSE file
mark = False
for author, count in items:
user = uconf.system.User(author)
try:
realname = user.realname.strip()
except KeyError:
realname = author
if not mark and count < cutoff:
mark = True
print '-'*60
print " ", realname
#print count, " ", author
| Python |
#
| Python |
import py
from py.__.doc.confrest import *
class PyPyPage(Page):
def fill_menubar(self):
self.menubar = html.div(
html.a("news", href="../news.html", class_="menu"), " ",
html.a("doc", href="../index.html", class_="menu"), " ",
html.a("contact", href="../contact.html", class_="menu"), " ",
html.a("getting-started",
href="../getting-started.html", class_="menu"), " ",
html.a("EU/project",
href="http://pypy.org/", class_="menu"), " ",
html.a("issue",
href="https://codespeak.net/issue/pypy-dev/",
class_="menu"),
" ", id="menubar")
class Project(Project):
mydir = py.magic.autopath().dirpath()
title = "PyPy"
stylesheet = 'style.css'
encoding = 'latin1'
prefix_title = "PyPy"
logo = html.div(
html.a(
html.img(alt="PyPy", id="pyimg",
src="http://codespeak.net/pypy/img/py-web1.png",
height=110, width=149)))
Page = PyPyPage
def get_docpath(self):
return self.mydir
| Python |
import py
from py.__.doc.confrest import *
class PyPyPage(Page):
def fill_menubar(self):
self.menubar = html.div(
html.a("news", href="../news.html", class_="menu"), " ",
html.a("doc", href="../index.html", class_="menu"), " ",
html.a("contact", href="../contact.html", class_="menu"), " ",
html.a("getting-started",
href="../getting-started.html", class_="menu"), " ",
html.a("EU/project",
href="http://pypy.org/", class_="menu"), " ",
html.a("issue",
href="https://codespeak.net/issue/pypy-dev/",
class_="menu"),
" ", id="menubar")
class Project(Project):
mydir = py.magic.autopath().dirpath()
title = "PyPy"
stylesheet = 'style.css'
encoding = 'latin1'
prefix_title = "PyPy"
logo = html.div(
html.a(
html.img(alt="PyPy", id="pyimg",
src="http://codespeak.net/pypy/img/py-web1.png",
height=110, width=149)))
Page = PyPyPage
def get_docpath(self):
return self.mydir
| Python |
import py
import datetime
import dateutil
from dateutil import parser
import pylab
import matplotlib
greyscale = False
def get_data(p):
data = p.readlines()
title = data[0].strip()
axis = data[1].strip().split(',')
data = [convert_data(t) for t in zip(*[l.strip().split(',') for l in data[2:]])]
return title, axis, data
def convert_data(row):
if not row:
return []
first = row[0]
try:
int(first)
return [int(elt) for elt in row]
except ValueError:
pass
try:
float(first)
return [float(elt) for elt in row]
except ValueError:
pass
if first[0] == '"':
return [elt[1:-1] for elt in row]
return [parsedate(elt) for elt in row]
def parsedate(s):
if len(s) <= 7:
year, month = s.split("-")
result = datetime.datetime(int(year), int(month), 15)
else:
result = parser.parse(s)
return pylab.date2num(result)
if greyscale:
colors = ["k", "k--", "k."]
else:
colors = "brg"
def csv2png(p):
print p
title, axis, data = get_data(p)
dates = data[0]
release_title, release_axis, release_data = get_data( py.path.local("release_dates.dat") )
release_dates, release_names = release_data
sprint_title, sprint_axis, sprint_data = get_data( py.path.local("sprint_dates.dat") )
sprint_locations, sprint_begin_dates, sprint_end_dates = sprint_data
ax = pylab.subplot(111)
for i, d in enumerate(data[1:]):
args = [dates, d, colors[i]]
pylab.plot_date(linewidth=0.8, *args)
ymax = max(pylab.yticks()[0]) #just below the legend
for i, release_date in enumerate(release_dates):
release_name = release_names[i]
if greyscale:
color = 0.3
else:
color = "g"
pylab.axvline(release_date, linewidth=0.8, color=color, alpha=0.5)
ax.text(release_date, ymax * 0.4, release_name,
fontsize=10,
horizontalalignment='right',
verticalalignment='top',
rotation='vertical')
for i, location in enumerate(sprint_locations):
begin = sprint_begin_dates[i]
end = sprint_end_dates[i]
if float(begin) >= float(min(dates[0],dates[-1])):
if greyscale:
color = 0.8
else:
color = "y"
pylab.axvspan(begin, end, linewidth=0, facecolor=color, alpha=0.5)
ax.text(begin, ymax * 0.85, location,
fontsize=10,
horizontalalignment='right',
verticalalignment='top',
rotation='vertical')
pylab.legend(axis[1:], "upper left")
pylab.ylabel(axis[0])
pylab.xlabel("")
ticklabels = ax.get_xticklabels()
pylab.setp(ticklabels, 'rotation', 45, size=9)
# ax.autoscale_view()
ax.grid(True)
pylab.title(title)
pylab.savefig(p.purebasename + ".png")
pylab.savefig(p.purebasename + ".eps")
py.process.cmdexec("epstopdf %s" % (p.purebasename + ".eps", ))
if __name__ == '__main__':
args = py.std.sys.argv
if len(args) == 1:
print "usage: %s <filenames> <--all>" % args[0]
py.std.sys.exit()
for arg in args[1:]:
if arg == "--all":
for p in py.path.local().listdir("*.csv"):
py.std.os.system("python %s %s" % (args[0], p.basename))
else:
csv2png(py.path.local(arg))
| Python |
import py
chunks = 7
p = py.path.local(py.std.sys.argv[1])
data = [l.strip() for l in p.readlines()]
result = data[:2]
data = data[2:]
acc = 0
for i, line in enumerate(data):
print line
line = line.split(',')
acc += int(line[1])
if i % chunks == chunks - 1:
line[1] = str(acc)
result.append(", ".join(line))
acc = 0
p.write("\n".join(result))
| Python |
import autopath
from pypy.rlib.parsing.pypackrat import PackratParser
from pypy.rlib.parsing.makepackrat import BacktrackException, Status
from pypy.lang.scheme.object import W_Pair, W_Integer, W_String, W_Identifier, \
W_Nil, W_Boolean, W_Real, literal
def unquote(s):
str_lst = []
last_ch = ''
for c in s[1:]:
if last_ch == '\\' and c == '"':
pass
else:
str_lst.append(last_ch)
last_ch = c
return ''.join(str_lst)
class SchemeParser(PackratParser):
r"""
STRING:
c = `\"([^\\\"]|\\\"|\\\\)*\"`
IGNORE*
return {W_String(unquote(c))};
IDENTIFIER:
c = `[\+\-\*\^\?a-zA-Z!<=>_~/$%&:][\+\-\*\^\?a-zA-Z0-9!<=>_~/$%&:]*`
IGNORE*
return {W_Identifier(c)};
FIXNUM:
c = `\-?(0|([1-9][0-9]*))`
IGNORE*
return {W_Integer(int(c))};
FLOAT:
c = `\-?[0-9]*\.[0-9]*`
IGNORE*
return {W_Real(float(c))};
BOOLEAN:
c = `#(t|f)`
IGNORE*
return {W_Boolean(c[1] == 't')};
IGNORE:
` |\n|\t|;[^\n]*`;
EOF:
!__any__;
file:
IGNORE*
s = sexpr*
EOF
return {s};
literal:
`'`
s = sexpr
return {literal(s)};
sexpr:
list
| literal
| FLOAT
| FIXNUM
| BOOLEAN
| IDENTIFIER
| STRING;
list:
'('
IGNORE*
p = pair
')'
IGNORE*
return {p};
pair:
car = sexpr
'.'
IGNORE*
cdr = sexpr
return {W_Pair(car, cdr)}
| car = sexpr
cdr = pair
return {W_Pair(car, cdr)}
| return {W_Nil()};
"""
def parse(code):
p = SchemeParser(code)
return p.file()
| Python |
#!/usr/bin/env python
""" Interactive (untranslatable) version of the pypy
scheme interpreter
"""
import autopath
from pypy.lang.scheme.object import ExecutionContext, SchemeException, \
SchemeQuit
from pypy.lang.scheme.ssparser import parse
from pypy.rlib.parsing.makepackrat import BacktrackException
import os, sys
def check_parens(s):
return s.count("(") == s.count(")")
def interactive():
print "PyPy Scheme interpreter"
ctx = ExecutionContext()
to_exec = ""
cont = False
while 1:
if cont:
ps = '.. '
else:
ps = '-> '
sys.stdout.write(ps)
to_exec += sys.stdin.readline()
if to_exec == "\n":
to_exec = ""
elif check_parens(to_exec):
try:
if to_exec == "":
print
raise SchemeQuit
print parse(to_exec)[0].eval(ctx).to_string()
except SchemeQuit, e:
break
except BacktrackException, e:
print "syntax error"
except SchemeException, e:
print "error: %s" % e
to_exec = ""
cont = False
else:
cont = True
if __name__ == '__main__':
interactive()
| Python |
"""
self cloning, automatic path configuration
copy this into any subdirectory of pypy from which scripts need
to be run, typically all of the test subdirs.
The idea is that any such script simply issues
import autopath
and this will make sure that the parent directory containing "pypy"
is in sys.path.
If you modify the master "autopath.py" version (in pypy/tool/autopath.py)
you can directly run it which will copy itself on all autopath.py files
it finds under the pypy root directory.
This module always provides these attributes:
pypydir pypy root directory path
this_dir directory where this autopath.py resides
"""
def __dirinfo(part):
""" return (partdir, this_dir) and insert parent of partdir
into sys.path. If the parent directories don't have the part
an EnvironmentError is raised."""
import sys, os
try:
head = this_dir = os.path.realpath(os.path.dirname(__file__))
except NameError:
head = this_dir = os.path.realpath(os.path.dirname(sys.argv[0]))
while head:
partdir = head
head, tail = os.path.split(head)
if tail == part:
break
else:
raise EnvironmentError, "'%s' missing in '%r'" % (partdir, this_dir)
pypy_root = os.path.join(head, '')
try:
sys.path.remove(head)
except ValueError:
pass
sys.path.insert(0, head)
munged = {}
for name, mod in sys.modules.items():
if '.' in name:
continue
fn = getattr(mod, '__file__', None)
if not isinstance(fn, str):
continue
newname = os.path.splitext(os.path.basename(fn))[0]
if not newname.startswith(part + '.'):
continue
path = os.path.join(os.path.dirname(os.path.realpath(fn)), '')
if path.startswith(pypy_root) and newname != part:
modpaths = os.path.normpath(path[len(pypy_root):]).split(os.sep)
if newname != '__init__':
modpaths.append(newname)
modpath = '.'.join(modpaths)
if modpath not in sys.modules:
munged[modpath] = mod
for name, mod in munged.iteritems():
if name not in sys.modules:
sys.modules[name] = mod
if '.' in name:
prename = name[:name.rfind('.')]
postname = name[len(prename)+1:]
if prename not in sys.modules:
__import__(prename)
if not hasattr(sys.modules[prename], postname):
setattr(sys.modules[prename], postname, mod)
return partdir, this_dir
def __clone():
""" clone master version of autopath.py into all subdirs """
from os.path import join, walk
if not this_dir.endswith(join('pypy','tool')):
raise EnvironmentError("can only clone master version "
"'%s'" % join(pypydir, 'tool',_myname))
def sync_walker(arg, dirname, fnames):
if _myname in fnames:
fn = join(dirname, _myname)
f = open(fn, 'rwb+')
try:
if f.read() == arg:
print "checkok", fn
else:
print "syncing", fn
f = open(fn, 'w')
f.write(arg)
finally:
f.close()
s = open(join(pypydir, 'tool', _myname), 'rb').read()
walk(pypydir, sync_walker, s)
_myname = 'autopath.py'
# set guaranteed attributes
pypydir, this_dir = __dirinfo('pypy')
if __name__ == '__main__':
__clone()
| Python |
import py
class SchemeException(Exception):
pass
class UnboundVariable(SchemeException):
def __str__(self):
return "Unbound variable %s" % (self.args[0], )
class NotCallable(SchemeException):
def __str__(self):
return "%s is not a callable" % (self.args[0].to_string(), )
class WrongArgsNumber(SchemeException):
def __str__(self):
return "Wrong number of args"
class WrongArgType(SchemeException):
def __str__(self):
return "Wrong argument type: %s is not %s" % \
(self.args[0].to_string(), self.args[1])
class SchemeSyntaxError(SchemeException):
def __str__(self):
return "Syntax error"
class SchemeQuit(SchemeException):
"""raised on (quit) evaluation"""
pass
class W_Root(object):
def to_string(self):
return ''
def to_boolean(self):
return True
def __repr__(self):
return "<W_Root " + self.to_string() + ">"
def eval(self, ctx):
return self
class W_Symbol(W_Root):
def __init__(self, val):
self.name = val
def to_string(self):
return self.name
def __repr__(self):
return "<W_symbol " + self.name + ">"
class W_Identifier(W_Symbol):
def __init__(self, val):
self.name = val
def to_string(self):
return self.name
def __repr__(self):
return "<W_Identifier " + self.name + ">"
def eval(self, ctx):
if ctx is None:
ctx = ExecutionContext()
w_obj = ctx.get(self.name)
if w_obj is not None:
return w_obj
else:
#reference to undefined identifier
#unbound
raise UnboundVariable(self.name)
class W_Boolean(W_Root):
def __init__(self, val):
self.boolval = bool(val)
def to_string(self):
if self.boolval:
return "#t"
return "#f"
def to_boolean(self):
return self.boolval
def __repr__(self):
return "<W_Boolean " + str(self.boolval) + " >"
class W_String(W_Root):
def __init__(self, val):
self.strval = val
def to_string(self):
return self.strval
def __repr__(self):
return "<W_String " + self.strval + " >"
class W_Number(W_Root):
pass
class W_Real(W_Number):
def __init__(self, val):
self.exact = False
self.realval = val
def to_string(self):
return str(self.realval)
def to_number(self):
return self.to_float()
def to_fixnum(self):
return int(self.realval)
def to_float(self):
return self.realval
def round(self):
int_part = int(self.realval)
if self.realval > 0:
if self.realval >= (int_part + 0.5):
return int_part + 1
return int_part
else:
if self.realval <= (int_part - 0.5):
return int_part - 1
return int_part
def is_integer(self):
return self.realval == self.round()
class W_Integer(W_Real):
def __init__(self, val):
self.intval = val
self.realval = val
self.exact = True
def to_string(self):
return str(self.intval)
def to_number(self):
return self.to_fixnum()
def to_fixnum(self):
return self.intval
def to_float(self):
return float(self.intval)
class W_Pair(W_Root):
def __init__(self, car, cdr):
self.car = car
self.cdr = cdr
def to_string(self):
car = self.car.to_string()
cdr = self.cdr.to_string()
return "(" + car + " . " + cdr + ")"
def eval(self, ctx):
oper = self.car.eval(ctx)
if not isinstance(oper, W_Callable):
raise NotCallable(oper)
return oper.call(ctx, self.cdr)
class W_Nil(W_Root):
def to_string(self):
return "()"
class W_Callable(W_Root):
def call(self, ctx, lst):
raise NotImplementedError
def eval_body(self, ctx, body):
body_expression = body
body_result = None
while not isinstance(body_expression, W_Nil):
body_result = body_expression.car.eval(ctx)
body_expression = body_expression.cdr
return body_result
class W_Procedure(W_Callable):
def __init__(self, pname=""):
self.pname = pname
def to_string(self):
return "#<primitive-procedure %s>" % (self.pname,)
def call(self, ctx, lst):
#evaluate all arguments into list
arg_lst = []
arg = lst
while not isinstance(arg, W_Nil):
if not isinstance(arg, W_Pair):
raise SchemeSyntaxError
arg_lst.append(arg.car.eval(ctx))
arg = arg.cdr
return self.procedure(ctx, arg_lst)
def procedure(self, ctx, lst):
raise NotImplementedError
class W_Macro(W_Callable):
def __init__(self, pname=""):
self.pname = pname
def to_string(self):
return "#<primitive-macro %s>" % (self.pname,)
def call(self, ctx, lst=None):
raise NotImplementedError
class Formal(object):
def __init__(self, name, islist=False):
self.name = name
self.islist = islist
class W_Lambda(W_Procedure):
def __init__(self, args, body, closure, pname="#f"):
self.args = []
arg = args
while not isinstance(arg, W_Nil):
if isinstance(arg, W_Identifier):
self.args.append(Formal(arg.to_string(), True))
break
else:
if not isinstance(arg, W_Pair):
raise SchemeSyntaxError
if not isinstance(arg.car, W_Identifier):
raise WrongArgType(arg.car, "Identifier")
#list of argument names, not evaluated
self.args.append(Formal(arg.car.to_string(), False))
arg = arg.cdr
self.body = body
self.pname = pname
self.closure = closure
def to_string(self):
return "#<procedure %s>" % (self.pname,)
def procedure(self, ctx, lst):
#ctx is a caller context, which is joyfully ignored
local_ctx = self.closure.copy()
#set lambda arguments
for idx in range(len(self.args)):
formal = self.args[idx]
if formal.islist:
local_ctx.put(formal.name, plst2lst(lst[idx:]))
else:
local_ctx.put(formal.name, lst[idx])
return self.eval_body(local_ctx, self.body)
def plst2lst(plst):
"""coverts python list() of W_Root into W_Pair scheme list"""
w_cdr = W_Nil()
plst.reverse()
for w_obj in plst:
w_cdr = W_Pair(w_obj, w_cdr)
return w_cdr
##
# operations
##
class ListOper(W_Procedure):
def procedure(self, ctx, lst):
if len(lst) == 0:
if self.default_result is None:
raise WrongArgsNumber()
return self.default_result
if len(lst) == 1:
if not isinstance(lst[0], W_Number):
raise WrongArgType(lst[0], "Number")
return self.unary_oper(lst[0])
acc = None
for arg in lst:
if not isinstance(arg, W_Number):
raise WrongArgType(arg, "Number")
if acc is None:
acc = arg
else:
acc = self.oper(acc, arg)
return acc
def unary_oper(self, x):
if isinstance(x, W_Integer):
return W_Integer(self.do_unary_oper(x.to_fixnum()))
else:
return W_Real(self.do_unary_oper(x.to_float()))
def oper(self, x, y):
if isinstance(x, W_Integer) and isinstance(y, W_Integer):
return W_Integer(self.do_oper(x.to_fixnum(), y.to_fixnum()))
else:
return W_Real(self.do_oper(x.to_float(), y.to_float()))
def create_op_class(oper, unary_oper, title, default_result=None):
class Op(ListOper):
pass
local_locals = {}
attr_name = "do_oper"
code = py.code.Source("""
def %s(self, x, y):
return x %s y
""" % (attr_name, oper))
exec code.compile() in local_locals
local_locals[attr_name]._annspecialcase_ = 'specialize:argtype(1)'
setattr(Op, attr_name, local_locals[attr_name])
attr_name = "do_unary_oper"
code = py.code.Source("""
def %s(self, x):
return %s x
""" % (attr_name, unary_oper))
exec code.compile() in local_locals
local_locals[attr_name]._annspecialcase_ = 'specialize:argtype(1)'
setattr(Op, attr_name, local_locals[attr_name])
if default_result is None:
Op.default_result = None
else:
Op.default_result = W_Integer(default_result)
Op.__name__ = "Op" + title
return Op
Add = create_op_class('+', '', "Add", 0)
Sub = create_op_class('-', '-', "Sub")
Mul = create_op_class('*', '', "Mul", 1)
Div = create_op_class('/', '1 /', "Div")
class Equal(W_Procedure):
def procedure(self, ctx, lst):
if len(lst) < 2:
return W_Boolean(True)
prev = lst[0]
if not isinstance(prev, W_Number):
raise WrongArgType(prev, "Number")
for arg in lst[1:]:
if not isinstance(arg, W_Number):
raise WrongArgType(arg, "Number")
if prev.to_number() != arg.to_number():
return W_Boolean(False)
prev = arg
return W_Boolean(True)
class List(W_Procedure):
def procedure(self, ctx, lst):
return plst2lst(lst)
##
# Predicate
##
class PredicateNumber(W_Procedure):
def procedure(self, ctx, lst):
if len(lst) != 1:
raise WrongArgsNumber
w_obj = lst[0]
if not isinstance(w_obj, W_Number):
raise WrongArgType(w_obj, 'Number')
return W_Boolean(self.predicate(w_obj))
class IntegerP(PredicateNumber):
def predicate(self, w_obj):
if not w_obj.exact:
return w_obj.is_integer()
return True
class RealP(PredicateNumber):
def predicate(self, w_obj):
return isinstance(w_obj, W_Real)
class NumberP(PredicateNumber):
def predicate(self, w_obj):
return isinstance(w_obj, W_Number)
class ExactP(PredicateNumber):
def predicate(self, w_obj):
return w_obj.exact
class InexactP(PredicateNumber):
def predicate(self, w_obj):
return not w_obj.exact
class ZeroP(PredicateNumber):
def predicate(self, w_obj):
return w_obj.to_number() == 0.0
class OddP(PredicateNumber):
def predicate(self, w_obj):
if not w_obj.is_integer():
raise WrongArgType(w_obj, "Integer")
return w_obj.round() % 2 != 0
class EvenP(PredicateNumber):
def predicate(self, w_obj):
if not w_obj.is_integer():
raise WrongArgType(w_obj, "Integer")
return w_obj.round() % 2 == 0
##
# Macro
##
class Define(W_Macro):
def call(self, ctx, lst):
if not isinstance(lst, W_Pair):
raise SchemeSyntaxError
w_identifier = lst.car
if not isinstance(w_identifier, W_Identifier):
raise WrongArgType(w_identifier, "Identifier")
w_val = lst.cdr.car.eval(ctx)
ctx.set(w_identifier.name, w_val)
return w_val
class Sete(W_Macro):
def call(self, ctx, lst):
if not isinstance(lst, W_Pair):
raise SchemeSyntaxError
w_identifier = lst.car
if not isinstance(w_identifier, W_Identifier):
raise WrongArgType(w_identifier, "Identifier")
w_val = lst.cdr.car.eval(ctx)
ctx.sete(w_identifier.name, w_val)
return w_val
class MacroIf(W_Macro):
def call(self, ctx, lst):
if not isinstance(lst, W_Pair):
raise SchemeSyntaxError
w_condition = lst.car
w_then = lst.cdr.car
if isinstance(lst.cdr.cdr, W_Nil):
w_else = W_Boolean(False)
else:
w_else = lst.cdr.cdr.car
w_cond_val = w_condition.eval(ctx)
if w_cond_val.to_boolean() is True:
return w_then.eval(ctx)
else:
return w_else.eval(ctx)
class Cons(W_Procedure):
def procedure(self, ctx, lst):
w_car = lst[0]
w_cdr = lst[1]
#cons is always creating a new pair
return W_Pair(w_car, w_cdr)
class Car(W_Procedure):
def procedure(self, ctx, lst):
w_pair = lst[0]
if not isinstance(w_pair, W_Pair):
raise WrongArgType(w_pair, "Pair")
return w_pair.car
class Cdr(W_Procedure):
def procedure(self, ctx, lst):
w_pair = lst[0]
if not isinstance(w_pair, W_Pair):
raise WrongArgType(w_pair, "Pair")
return w_pair.cdr
class Quit(W_Procedure):
def procedure(self, ctx, lst):
raise SchemeQuit
class Lambda(W_Macro):
def call(self, ctx, lst):
w_args = lst.car
w_body = lst.cdr
return W_Lambda(w_args, w_body, ctx.copy())
class Let(W_Macro):
def call(self, ctx, lst):
if not isinstance(lst, W_Pair):
raise SchemeSyntaxError
local_ctx = ctx.copy()
w_formal = lst.car
while not isinstance(w_formal, W_Nil):
name = w_formal.car.car.to_string()
#evaluate the values in caller ctx
val = w_formal.car.cdr.car.eval(ctx)
local_ctx.put(name, val)
w_formal = w_formal.cdr
return self.eval_body(local_ctx, lst.cdr)
class Letrec(W_Macro):
def call(self, ctx, lst):
if not isinstance(lst, W_Pair):
raise SchemeSyntaxError
local_ctx = ctx.copy()
#bound variables
w_formal = lst.car
while not isinstance(w_formal, W_Nil):
name = w_formal.car.car.to_string()
local_ctx.put(name, W_Nil())
w_formal = w_formal.cdr
#eval in local_ctx and assign values
w_formal = lst.car
while not isinstance(w_formal, W_Nil):
name = w_formal.car.car.to_string()
val = w_formal.car.cdr.car.eval(local_ctx)
local_ctx.set(name, val)
w_formal = w_formal.cdr
return self.eval_body(local_ctx, lst.cdr)
def literal(sexpr):
return W_Pair(W_Identifier('quote'), W_Pair(sexpr, W_Nil()))
class Quote(W_Macro):
def call(self, ctx, lst):
if not isinstance(lst, W_Pair):
raise SchemeSyntaxError
return lst.car
##
# Location()
##
class Location(object):
def __init__(self, w_obj):
self.obj = w_obj
##
# dict mapping operations to W_Xxx objects
# callables must have 2 arguments
# - ctx = execution context
# - lst = list of arguments
##
OMAP = \
{
#arithmetic operations
'+': Add,
'-': Sub,
'*': Mul,
'/': Div,
#list operations
'cons': Cons,
'car': Car,
'cdr': Cdr,
'list': List,
'quit': Quit,
#comparisons
'=': Equal,
#predicates
'integer?': IntegerP,
'rational?': RealP,
'real?': RealP,
'complex?': NumberP,
'number?': NumberP,
'exact?': ExactP,
'inexact?': InexactP,
'zero?': ZeroP,
'odd?': OddP,
'even?': EvenP,
#macros
'define': Define,
'set!': Sete,
'if': MacroIf,
'lambda': Lambda,
'let': Let,
'letrec': Letrec,
'quote': Quote,
}
OPERATION_MAP = {}
for name, cls in OMAP.items():
OPERATION_MAP[name] = Location(cls(name))
class ExecutionContext(object):
"""Execution context implemented as a dict.
{ "IDENTIFIER": Location(W_Root()) }
"""
def __init__(self, globalscope=None, scope=None, closure=False):
if globalscope is None:
self.globalscope = OPERATION_MAP.copy()
else:
self.globalscope = globalscope
if scope is None:
self.scope = {}
else:
self.scope = scope
self.closure = closure
def copy(self):
return ExecutionContext(self.globalscope, self.scope.copy(), True)
def get(self, name):
loc = self.scope.get(name, None)
if loc is not None:
return loc.obj
loc = self.globalscope.get(name, None)
if loc is not None:
return loc.obj
return None
def sete(self, name, obj):
"""update existing location or raise
directly used by (set! <var> <expr>) macro
"""
loc = self.scope.get(name, None)
if loc is not None:
loc.obj = obj
return obj
loc = self.globalscope.get(name, None)
if loc is not None:
loc.obj = obj
return obj
raise UnboundVariable(name)
def set(self, name, obj):
"""update existing location or create new location"""
if self.closure:
loc = self.scope.get(name, None)
else:
loc = self.globalscope.get(name, None)
if loc is not None:
loc.obj = obj
else:
self.put(name, obj)
def put(self, name, obj):
"""create new location"""
if self.closure:
self.scope[name] = Location(obj)
else:
self.globalscope[name] = Location(obj)
def get_location(self, name):
"""internal/test use only
returns location bound to variable
"""
loc = self.scope.get(name, None)
if loc is not None:
return loc
loc = self.globalscope.get(name, None)
if loc is not None:
return loc
return None
| Python |
#!/usr/bin/env python
""" Interactive (untranslatable) version of the pypy
scheme interpreter
"""
import autopath
from pypy.lang.scheme.object import ExecutionContext, SchemeException, \
SchemeQuit
from pypy.lang.scheme.ssparser import parse
from pypy.rlib.parsing.makepackrat import BacktrackException
import os, sys
def check_parens(s):
return s.count("(") == s.count(")")
def interactive():
print "PyPy Scheme interpreter"
ctx = ExecutionContext()
to_exec = ""
cont = False
while 1:
if cont:
ps = '.. '
else:
ps = '-> '
sys.stdout.write(ps)
to_exec += sys.stdin.readline()
if to_exec == "\n":
to_exec = ""
elif check_parens(to_exec):
try:
if to_exec == "":
print
raise SchemeQuit
print parse(to_exec)[0].eval(ctx).to_string()
except SchemeQuit, e:
break
except BacktrackException, e:
print "syntax error"
except SchemeException, e:
print "error: %s" % e
to_exec = ""
cont = False
else:
cont = True
if __name__ == '__main__':
interactive()
| Python |
import math
from pypy.lang.js.jsparser import parse, ParseError
from pypy.lang.js.astbuilder import ASTBuilder
from pypy.lang.js.operations import *
from pypy.lang.js.jsobj import ThrowException
from pypy.rlib.objectmodel import we_are_translated
from pypy.rlib.streamio import open_file_as_stream
ASTBUILDER = ASTBuilder()
def writer(x):
print x
def load_source(script_source):
temp_tree = parse(script_source)
return ASTBUILDER.dispatch(temp_tree)
def load_file(filename):
f = open_file_as_stream(filename)
t = load_source(f.readall())
f.close()
return t
class W_NativeObject(W_Object):
def __init__(self, Class, Prototype, ctx=None,
Value=w_Undefined, callfunc=None):
W_Object.__init__(self, ctx, Prototype,
Class, Value, callfunc)
class W_ObjectObject(W_NativeObject):
def Call(self, ctx, args=[], this=None):
if len(args) >= 1 and not isnull_or_undefined(args[0]):
return args[0].ToObject(ctx)
else:
return self.Construct(ctx)
def Construct(self, ctx, args=[]):
if len(args) >= 1 and not (isinstance(args[0], W_Undefined) \
or isinstance(args[0], W_Null)):
# XXX later we could separate builtins and normal objects
return args[0].ToObject(ctx)
return create_object(ctx, 'Object')
class W_BooleanObject(W_NativeObject):
def Call(self, ctx, args=[], this=None):
if len(args) >= 1 and not isnull_or_undefined(args[0]):
return W_Boolean(args[0].ToBoolean())
else:
return W_Boolean(False)
def Construct(self, ctx, args=[]):
if len(args) >= 1 and not isnull_or_undefined(args[0]):
Value = W_Boolean(args[0].ToBoolean())
return create_object(ctx, 'Boolean', Value = Value)
return create_object(ctx, 'Boolean', Value = W_Boolean(False))
class W_NumberObject(W_NativeObject):
def Call(self, ctx, args=[], this=None):
if len(args) >= 1 and not isnull_or_undefined(args[0]):
return W_Number(args[0].ToNumber())
else:
return W_Number(0.0)
def Construct(self, ctx, args=[]):
if len(args) >= 1 and not isnull_or_undefined(args[0]):
Value = W_Number(args[0].ToNumber())
return create_object(ctx, 'Number', Value = Value)
return create_object(ctx, 'Number', Value = W_Number(0.0))
class W_StringObject(W_NativeObject):
def Call(self, ctx, args=[], this=None):
if len(args) >= 1 and not isnull_or_undefined(args[0]):
return W_String(args[0].ToString(ctx))
else:
return W_String('')
def Construct(self, ctx, args=[]):
if len(args) >= 1 and not isnull_or_undefined(args[0]):
Value = W_String(args[0].ToString(ctx))
return create_object(ctx, 'String', Value = Value)
return create_object(ctx, 'String', Value = W_String(''))
class W_ArrayObject(W_NativeObject):
def Call(self, ctx, args=[], this=None):
proto = ctx.get_global().Get('Array').Get('prototype')
array = W_Array(ctx, Prototype=proto, Class = proto.Class)
for i in range(len(args)):
print "yeahh"
array.Put(str(i), args[0])
return array
def Construct(self, ctx, args=[]):
return self.Call(ctx, args)
TEST = False
def evaljs(ctx, args, this):
if len(args) >= 1:
if isinstance(args[0], W_String):
code = args[0]
else:
return args[0]
else:
code = W_String('')
try:
node = load_source(code.ToString(ctx))
except ParseError, e:
raise ThrowException(W_String('SintaxError: '+str(e)))
if TEST:
try:
return node.execute(ctx)
except ThrowException, e:
return W_String("error")
else:
return node.execute(ctx)
def parseIntjs(ctx, args, this):
if len(args) < 1:
return W_Number(NaN)
s = args[0].ToString(ctx).strip(" ")
if len(args) > 1:
radix = args[1].ToInt32()
else:
radix = 10
if len(s) >= 2 and (s.startswith('0x') or s.startswith('0X')) :
radix = 16
s = s[2:]
if s == '' or radix < 2 or radix > 36:
return W_Number(NaN)
try:
n = int(s, radix)
except ValueError:
n = NaN
return W_Number(n)
def parseFloatjs(ctx, args, this):
if len(args) < 1:
return W_Number(NaN)
s = args[0].ToString(ctx).strip(" ")
try:
n = float(s)
except ValueError:
n = NaN
return W_Number(n)
def printjs(ctx, args, this):
writer(",".join([i.GetValue().ToString(ctx) for i in args]))
return w_Undefined
def isnanjs(ctx, args, this):
if len(args) < 1:
return W_Boolean(True)
return W_Boolean(args[0].ToNumber() == NaN)
def isfinitejs(ctx, args, this):
if len(args) < 1:
return W_Boolean(True)
n = args[0].ToNumber()
if n == Infinity or n == -Infinity or n == NaN:
return W_Boolean(False)
else:
return W_Boolean(True)
def booleanjs(ctx, args, this):
if len(args) > 0:
return W_Boolean(args[0].ToBoolean())
return W_Boolean(False)
def stringjs(ctx, args, this):
if len(args) > 0:
return W_String(args[0].ToString(ctx))
return W_String('')
def arrayjs(ctx, args, this):
arr = W_Array()
for i in range(len(args)):
arr.Put(str(i), args[i])
return arr
def numberjs(ctx, args, this):
if len(args) > 0:
return W_Number(args[0].ToNumber())
return W_Number(0)
def absjs(ctx, args, this):
return W_Number(abs(args[0].ToNumber()))
def floorjs(ctx, args, this):
return W_Number(math.floor(args[0].ToNumber()))
def powjs(ctx, args, this):
return W_Number(math.pow(args[0].ToNumber(), args[1].ToNumber()))
def sqrtjs(ctx, args, this):
return W_Number(math.sqrt(args[0].ToNumber()))
def versionjs(ctx, args, this):
return w_Undefined
class W_ToString(W_NewBuiltin):
def Call(self, ctx, args=[], this=None):
return W_String("[object %s]"%this.Class)
class W_ValueOf(W_NewBuiltin):
def Call(self, ctx, args=[], this=None):
return this
class W_HasOwnProperty(W_NewBuiltin):
def Call(self, ctx, args=[], this=None):
if len(args) >= 1:
propname = args[0].ToString(ctx)
if propname in this.propdict:
return W_Boolean(True)
return W_Boolean(False)
class W_IsPrototypeOf(W_NewBuiltin):
def Call(self, ctx, args=[], this=None):
if len(args) >= 1 and isinstance(args[0], W_PrimitiveObject):
O = this
V = args[0].Prototype
while V is not None:
if O == V:
return W_Boolean(True)
V = V.Prototype
return W_Boolean(False)
class W_PropertyIsEnumerable(W_NewBuiltin):
def Call(self, ctx, args=[], this=None):
if len(args) >= 1:
propname = args[0].ToString(ctx)
if propname in this.propdict and not this.propdict[propname].de:
return W_Boolean(True)
return W_Boolean(False)
class W_Function(W_NewBuiltin):
def Call(self, ctx, args=[], this=None):
tam = len(args)
if tam >= 1:
fbody = args[tam-1].GetValue().ToString(ctx)
argslist = []
for i in range(tam-1):
argslist.append(args[i].GetValue().ToString(ctx))
fargs = ','.join(argslist)
functioncode = "function (%s) {%s}"%(fargs, fbody)
else:
functioncode = "function () {}"
#remove program and sourcelements node
funcnode = parse(functioncode).children[0].children[0]
return ASTBUILDER.dispatch(funcnode).execute(ctx)
def Construct(self, ctx, args=[]):
return self.Call(ctx, args, this=None)
functionstring= 'function (arguments go here!) {\n'+ \
' [lots of stuff :)]\n'+ \
'}'
class W_FToString(W_NewBuiltin):
def Call(self, ctx, args=[], this=None):
if this.Class == 'Function':
return W_String(functionstring)
else:
raise JsTypeError('this is not a function object')
class W_Apply(W_NewBuiltin):
def Call(self, ctx, args=[], this=None):
try:
if isnull_or_undefined(args[0]):
thisArg = ctx.get_global()
else:
thisArg = args[0].ToObject(ctx)
except IndexError:
thisArg = ctx.get_global()
try:
arrayArgs = args[1]
if isinstance(arrayArgs, W_ListObject):
callargs = arrayArgs.tolist()
elif isinstance(arrayArgs, W_Undefined) \
or isinstance(arrayArgs, W_Null):
callargs = []
else:
raise JsTypeError('arrayArgs is not an Array or Arguments object')
except IndexError:
callargs = []
return this.Call(ctx, callargs, this=thisArg)
class W_Call(W_NewBuiltin):
def Call(self, ctx, args=[], this=None):
if len(args) >= 1:
if isnull_or_undefined(args[0]):
thisArg = ctx.get_global()
else:
thisArg = args[0]
callargs = args[1:]
else:
thisArg = ctx.get_global()
callargs = []
return this.Call(ctx, callargs, this = thisArg)
class W_ValueToString(W_NewBuiltin):
"this is the toString function for objects with Value"
def Call(self, ctx, args=[], this=None):
return W_String(this.Value.ToString(ctx))
class W_ValueValueOf(W_NewBuiltin):
"this is the valueOf function for objects with Value"
def Call(self, ctx, args=[], this=None):
return this.Value
class W_CharAt(W_NewBuiltin):
def Call(self, ctx, args=[], this=None):
string = this.ToString(ctx)
if len(args)>=1:
pos = args[0].ToInt32()
if (not pos >=0) or (pos > len(string) - 1):
return W_String('')
else:
return W_String('')
return W_String(string[pos])
class W_Concat(W_NewBuiltin):
def Call(self, ctx, args=[], this=None):
string = this.ToString(ctx)
others = [obj.ToString(ctx) for obj in args]
string += ''.join(others)
return W_String(string)
class W_IndexOf(W_NewBuiltin):
def Call(self, ctx, args=[], this=None):
string = this.ToString(ctx)
if len(args) < 1:
return W_Number(-1.0)
substr = args[0].ToString(ctx)
size = len(string)
subsize = len(substr)
if len(args) < 2:
pos = 0
else:
pos = args[1].ToInt32()
pos = min(max(pos, 0), size)
return W_Number(string.find(substr, pos))
class W_Substring(W_NewBuiltin):
def Call(self, ctx, args=[], this=None):
string = this.ToString(ctx)
size = len(string)
if len(args) < 1:
start = 0
else:
start = args[0].ToInt32()
if len(args) < 2:
end = size
else:
end = args[1].ToInt32()
tmp1 = min(max(start, 0), size)
tmp2 = min(max(end, 0), size)
start = min(tmp1, tmp2)
end = max(tmp1, tmp2)
return W_String(string[start:end])
class W_ArrayToString(W_NewBuiltin):
def Call(self, ctx, args=[], this=None):
length = this.Get('length').ToUInt32()
sep = ','
return W_String(sep.join([this.Get(str(index)).ToString(ctx)
for index in range(length)]))
class W_DateFake(W_NewBuiltin): # XXX This is temporary
def Call(self, ctx, args=[], this=None):
return create_object(ctx, 'Object')
def Construct(self, ctx, args=[]):
return create_object(ctx, 'Object')
class Interpreter(object):
"""Creates a js interpreter"""
def __init__(self):
def put_values(obj, dictvalues):
for key,value in dictvalues.iteritems():
obj.Put(key, value)
w_Global = W_Object(Class="global")
ctx = global_context(w_Global)
w_ObjPrototype = W_Object(Prototype=None, Class='Object')
w_Function = W_Function(ctx, Class='Function',
Prototype=w_ObjPrototype)
w_Global.Put('Function', w_Function)
w_Object = W_ObjectObject('Object', w_Function)
w_Object.Put('prototype', w_ObjPrototype, dd=True, de=True, ro=True)
w_Global.Put('Object', w_Object)
w_FncPrototype = w_Function.Call(ctx, this=w_Function)
w_Function.Put('prototype', w_FncPrototype, dd=True, de=True, ro=True)
w_Function.Put('constructor', w_Function)
w_Object.Put('length', W_Number(1), ro=True, dd=True)
toString = W_ToString(ctx)
put_values(w_ObjPrototype, {
'constructor': w_Object,
'__proto__': w_Null,
'toString': toString,
'toLocaleString': toString,
'valueOf': W_ValueOf(ctx),
'hasOwnProperty': W_HasOwnProperty(ctx),
'isPrototypeOf': W_IsPrototypeOf(ctx),
'propertyIsEnumerable': W_PropertyIsEnumerable(ctx),
})
#properties of the function prototype
put_values(w_FncPrototype, {
'constructor': w_FncPrototype,
'__proto__': w_ObjPrototype,
'toString': W_FToString(ctx),
'apply': W_Apply(ctx),
'call': W_Call(ctx),
})
w_Boolean = W_BooleanObject('Boolean', w_FncPrototype)
w_Boolean.Put('constructor', w_FncPrototype)
w_BoolPrototype = create_object(ctx, 'Object', Value=W_Boolean(False))
w_BoolPrototype.Class = 'Boolean'
put_values(w_BoolPrototype, {
'constructor': w_FncPrototype,
'__proto__': w_BoolPrototype,
'toString': W_ValueToString(ctx),
'valueOf': W_ValueValueOf(ctx),
})
w_Boolean.Put('prototype', w_BoolPrototype)
w_Global.Put('Boolean', w_Boolean)
#Number
w_Number = W_NumberObject('Number', w_FncPrototype)
w_NumPrototype = create_object(ctx, 'Object', Value=W_Number(0.0))
w_NumPrototype.Class = 'Number'
put_values(w_NumPrototype, {
'constructor': w_FncPrototype,
'__proto__': w_NumPrototype,
'toString': W_ValueToString(ctx),
'valueOf': W_ValueValueOf(ctx),
})
put_values(w_Number, {
'constructor': w_FncPrototype,
'prototype': w_NumPrototype,
'NaN': W_Number(NaN),
'POSITIVE_INFINITY': W_Number(Infinity),
'NEGATIVE_INFINITY': W_Number(-Infinity),
})
w_Global.Put('Number', w_Number)
#String
w_String = W_StringObject('String', w_FncPrototype)
w_StrPrototype = create_object(ctx, 'Object', Value=W_String(''))
w_StrPrototype.Class = 'String'
put_values(w_StrPrototype, {
'constructor': w_FncPrototype,
'__proto__': w_StrPrototype,
'toString': W_ValueToString(ctx),
'valueOf': W_ValueValueOf(ctx),
'charAt': W_CharAt(ctx),
'concat': W_Concat(ctx),
'indexOf': W_IndexOf(ctx),
'substring': W_Substring(ctx),
})
w_String.Put('prototype', w_StrPrototype)
w_Global.Put('String', w_String)
w_Array = W_ArrayObject('Array', w_FncPrototype)
w_ArrPrototype = create_object(ctx, 'Object')
w_ArrPrototype.Class = 'Array'
put_values(w_ArrPrototype, {
'constructor': w_FncPrototype,
'__proto__': w_ArrPrototype,
'toString': W_ArrayToString(ctx),
})
w_Array.Put('prototype', w_ArrPrototype)
w_Global.Put('Array', w_Array)
#Math
w_math = W_Object(Class='Math')
w_Global.Put('Math', w_math)
w_math.Put('__proto__', w_ObjPrototype)
w_math.Put('prototype', w_ObjPrototype, dd=True, de=True, ro=True)
w_math.Put('abs', W_Builtin(absjs, Class='function'))
w_math.Put('floor', W_Builtin(floorjs, Class='function'))
w_math.Put('pow', W_Builtin(powjs, Class='function'))
w_math.Put('sqrt', W_Builtin(sqrtjs, Class='function'))
w_math.Put('E', W_Number(math.e))
w_math.Put('PI', W_Number(math.pi))
w_Global.Put('version', W_Builtin(versionjs))
#Date
w_Date = W_DateFake(ctx, Class='Date')
w_Global.Put('Date', w_Date)
w_Global.Put('NaN', W_Number(NaN))
w_Global.Put('Infinity', W_Number(Infinity))
w_Global.Put('undefined', w_Undefined)
w_Global.Put('eval', W_Builtin(evaljs))
w_Global.Put('parseInt', W_Builtin(parseIntjs))
w_Global.Put('parseFloat', W_Builtin(parseFloatjs))
w_Global.Put('isNaN', W_Builtin(isnanjs))
w_Global.Put('isFinite', W_Builtin(isnanjs))
w_Global.Put('print', W_Builtin(printjs))
w_Global.Put('this', w_Global)
self.global_context = ctx
self.w_Global = w_Global
self.w_Object = w_Object
def run(self, script):
"""run the interpreter"""
return script.execute(self.global_context)
def wrap_arguments(pyargs):
"receives a list of arguments and wrap then in their js equivalents"
res = []
for arg in pyargs:
if isinstance(arg, W_Root):
res.append(arg)
elif isinstance(arg, str):
res.append(W_String(arg))
elif isinstance(arg, int) or isinstance(arg, float) \
or isinstance(arg, long):
res.append(W_Number(arg))
elif isinstance(arg, bool):
res.append(W_Boolean(arg))
return res | Python |
import py
Option = py.test.config.Option
option = py.test.config.addoptions("ecma compatibility tests",
Option('', '--ecma',
action="store_true", dest="ecma", default=False,
help="run js interpreter ecma tests"
),
)
| Python |
# encoding: utf-8
"""
operations.py
Implements the javascript operations nodes for the interpretation tree
"""
#XXX * imports are bad
from pypy.lang.js.jsobj import *
from pypy.rlib.parsing.ebnfparse import Symbol, Nonterminal
from pypy.rlib.rarithmetic import r_uint, intmask
from constants import unescapedict, SLASH
import sys
import os
class Position(object):
def __init__(self, lineno=-1, start=-1, end=-1):
self.lineno = lineno
self.start = start
self.end = end
class Node(object):
"""
Node is the base class for all the other nodes.
"""
def __init__(self, pos):
"""
Initializes the content from the AST specific for each node type
"""
raise NotImplementedError
def eval(self, ctx):
"""
Used for expression evaluation
"""
raise NotImplementedError
def execute(self, ctx):
"""
Called on statament execution
"""
raise NotImplementedError
def get_literal(self):
raise NotImplementedError
def get_args(self, ctx):
raise NotImplementedError
def __str__(self):
return "%s()"%(self.__class__)
class Statement(Node):
def __init__(self, pos):
self.pos = pos
class Expression(Statement):
def execute(self, ctx):
return self.eval(ctx)
class ListOp(Expression):
def __init__(self, pos, nodes):
self.pos = pos
self.nodes = nodes
class UnaryOp(Expression):
def __init__(self, pos, expr, postfix=False):
self.pos = pos
#assert isinstance(expr, Node)
self.expr = expr
self.postfix = postfix
class BinaryOp(Expression):
def __init__(self, pos, left, right):
self.pos = pos
self.left = left
self.right = right
class BinaryComparisonOp(BinaryOp):
def eval(self, ctx):
s2 = self.left.eval(ctx).GetValue()
s4 = self.right.eval(ctx).GetValue()
return self.decision(ctx, s2, s4)
def decision(self, ctx, op1, op2):
raise NotImplementedError
class BinaryBitwiseOp(BinaryOp):
def eval(self, ctx):
s5 = self.left.eval(ctx).GetValue().ToInt32()
s6 = self.right.eval(ctx).GetValue().ToInt32()
return self.decision(ctx, s5, s6)
def decision(self, ctx, op1, op2):
raise NotImplementedError
class Undefined(Statement):
def eval(self, ctx):
return w_Undefined
def execute(self, ctx):
return w_Undefined
astundef = Undefined(Position())
class PropertyInit(BinaryOp):
pass
class Array(ListOp):
def eval(self, ctx):
proto = ctx.get_global().Get('Array').Get('prototype')
array = W_Array(ctx, Prototype=proto, Class = proto.Class)
for i in range(len(self.nodes)):
array.Put(str(i), self.nodes[i].eval(ctx).GetValue())
return array
class Assignment(Expression):
def __init__(self, pos, left, right, atype):
self.pos = pos
self.left = left
self.right = right
self.type = atype
def eval(self, ctx):
v1 = self.left.eval(ctx)
v3 = self.right.eval(ctx).GetValue()
op = self.type
if op == "=":
val = v3
elif op == "*=":
val = mult(ctx, v1.GetValue(), v3)
elif op == "+=":
val = plus(ctx, v1.GetValue(), v3)
elif op == "-=":
val = sub(ctx, v1.GetValue(), v3)
elif op == "/=":
val = division(ctx, v1.GetValue(), v3)
elif op == "%=":
val = mod(ctx, v1.GetValue(), v3)
elif op == "&=":
val = W_Number(v1.GetValue().ToInt32() & v3.ToInt32())
elif op == "|=":
val = W_Number(v1.GetValue().ToInt32() | v3.ToInt32())
elif op == "^=":
val = W_Number(v1.GetValue().ToInt32() ^ v3.ToInt32())
else:
print op
raise NotImplementedError()
v1.PutValue(val, ctx)
return val
class Block(Statement):
def __init__(self, pos, nodes):
self.pos = pos
self.nodes = nodes
def execute(self, ctx):
try:
last = w_Undefined
for node in self.nodes:
last = node.execute(ctx)
return last
except ExecutionReturned, e:
if e.type == 'return':
return e.value
else:
raise e
class BitwiseAnd(BinaryBitwiseOp):
def decision(self, ctx, op1, op2):
return W_Number(op1&op2)
class BitwiseNot(UnaryOp):
def eval(self, ctx):
op1 = self.expr.eval(ctx).GetValue().ToInt32()
return W_Number(~op1)
class BitwiseOr(BinaryBitwiseOp):
def decision(self, ctx, op1, op2):
return W_Number(op1|op2)
class BitwiseXor(BinaryBitwiseOp):
def decision(self, ctx, op1, op2):
return W_Number(op1^op2)
class Unconditional(Statement):
def __init__(self, pos, target):
self.pos = pos
self.target = target
class Break(Unconditional):
def execute(self, ctx):
raise ExecutionReturned('break', None, None)
class Continue(Unconditional):
def execute(self, ctx):
raise ExecutionReturned('continue', None, None)
class Call(BinaryOp):
def eval(self, ctx):
r1 = self.left.eval(ctx)
r2 = self.right.eval(ctx)
r3 = r1.GetValue()
if not isinstance(r3, W_PrimitiveObject):
raise ThrowException(W_String("it is not a callable"))
if isinstance(r1, W_Reference):
r6 = r1.GetBase()
else:
r6 = None
if isinstance(r2, ActivationObject):
r7 = None
else:
r7 = r6
try:
res = r3.Call(ctx=ctx, args=r2.get_args(), this=r7)
except JsTypeError:
raise ThrowException(W_String('it is not a function'))
return res
class Comma(BinaryOp):
def eval(self, ctx):
self.left.eval(ctx)
return self.right.eval(ctx)
class Conditional(Expression):
def __init__(self, pos, condition, truepart, falsepart):
self.pos = pos
self.condition = condition
self.truepart = truepart
self.falsepart = falsepart
def eval(self, ctx):
if self.condition.eval(ctx).GetValue().ToBoolean():
return self.truepart.eval(ctx).GetValue()
else:
return self.falsepart.eval(ctx).GetValue()
class Member(BinaryOp):
"this is for object[name]"
def eval(self, ctx):
w_obj = self.left.eval(ctx).GetValue().ToObject(ctx)
name = self.right.eval(ctx).GetValue().ToString(ctx)
return W_Reference(name, w_obj)
class MemberDot(BinaryOp):
"this is for object.name"
def eval(self, ctx):
w_obj = self.left.eval(ctx).GetValue().ToObject(ctx)
name = self.right.get_literal()
return W_Reference(name, w_obj)
class FunctionStatement(Statement):
def __init__(self, pos, name, params, body):
self.pos = pos
self.name = name
self.body = body
self.params = params
def eval(self, ctx):
proto = ctx.get_global().Get('Function').Get('prototype')
w_func = W_Object(ctx=ctx, Prototype=proto, Class='Function', callfunc=self)
w_func.Put('length', W_Number(len(self.params)))
w_obj = create_object(ctx, 'Object')
w_obj.Put('constructor', w_func, de=True)
w_func.Put('prototype', w_obj)
return w_func
def execute(self, ctx):
return self.eval(ctx)
class Identifier(Expression):
def __init__(self, pos, name):
self.pos = pos
self.name = name
def eval(self, ctx):
return ctx.resolve_identifier(self.name)
def get_literal(self):
return self.name
class This(Identifier):
pass
class If(Statement):
def __init__(self, pos, condition, thenpart, elsepart=astundef):
self.pos = pos
self.condition = condition
self.thenPart = thenpart
self.elsePart = elsepart
def execute(self, ctx):
temp = self.condition.eval(ctx).GetValue()
if temp.ToBoolean():
return self.thenPart.execute(ctx)
else:
return self.elsePart.execute(ctx)
class Group(UnaryOp):
def eval(self, ctx):
return self.expr.eval(ctx)
##############################################################################
#
# Binary logic comparison ops and suporting abstract operation
#
##############################################################################
def ARC(ctx, x, y):
"""
Implements the Abstract Relational Comparison x < y
Still not fully to the spec
"""
s1 = x.ToPrimitive(ctx, 'Number')
s2 = y.ToPrimitive(ctx, 'Number')
if not (isinstance(s1, W_String) and isinstance(s2, W_String)):
s4 = s1.ToNumber()
s5 = s2.ToNumber()
if s4 == NaN or s5 == NaN:
return -1
if s4 < s5:
return 1
else:
return 0
else:
s4 = s1.ToString(ctx)
s5 = s2.ToString(ctx)
if s4 < s5:
return 1
if s4 == s5:
return 0
return -1
class Or(BinaryOp):
def eval(self, ctx):
s2 = self.left.eval(ctx).GetValue()
if s2.ToBoolean():
return s2
s4 = self.right.eval(ctx).GetValue()
return s4
class And(BinaryOp):
def eval(self, ctx):
s2 = self.left.eval(ctx).GetValue()
if not s2.ToBoolean():
return s2
s4 = self.right.eval(ctx).GetValue()
return s4
class Ge(BinaryComparisonOp):
def decision(self, ctx, op1, op2):
s5 = ARC(ctx, op1, op2)
if s5 in (-1, 1):
return W_Boolean(False)
else:
return W_Boolean(True)
class Gt(BinaryComparisonOp):
def decision(self, ctx, op1, op2):
s5 = ARC(ctx, op2, op1)
if s5 == -1:
return W_Boolean(False)
else:
return W_Boolean(s5)
class Le(BinaryComparisonOp):
def decision(self, ctx, op1, op2):
s5 = ARC(ctx, op2, op1)
if s5 in (-1, 1):
return W_Boolean(False)
else:
return W_Boolean(True)
class Lt(BinaryComparisonOp):
def decision(self, ctx, op1, op2):
s5 = ARC(ctx, op1, op2)
if s5 == -1:
return W_Boolean(False)
else:
return W_Boolean(s5)
##############################################################################
#
# Bitwise shifts
#
##############################################################################
class Ursh(BinaryComparisonOp):
def decision(self, ctx, op1, op2):
a = op1.ToUInt32()
b = op2.ToUInt32()
return W_Number(a >> (b & 0x1F))
class Rsh(BinaryComparisonOp):
def decision(self, ctx, op1, op2):
a = op1.ToInt32()
b = op2.ToUInt32()
return W_Number(a >> intmask(b & 0x1F))
class Lsh(BinaryComparisonOp):
def decision(self, ctx, op1, op2):
a = op1.ToInt32()
b = op2.ToUInt32()
return W_Number(a << intmask(b & 0x1F))
##############################################################################
#
# Equality and unequality (== and !=)
#
##############################################################################
def AEC(ctx, x, y):
"""
Implements the Abstract Equality Comparison x == y
trying to be fully to the spec
"""
type1 = x.type()
type2 = y.type()
if type1 == type2:
if type1 == "undefined" or type1 == "null":
return True
if type1 == "number":
n1 = x.ToNumber()
n2 = y.ToNumber()
nan_string = str(NaN)
if str(n1) == nan_string or str(n2) == nan_string:
return False
if n1 == n2:
return True
return False
elif type1 == "string":
return x.ToString(ctx) == y.ToString(ctx)
elif type1 == "boolean":
return x.ToBoolean() == x.ToBoolean()
return x == y
else:
#step 14
if (type1 == "undefined" and type2 == "null") or \
(type1 == "null" and type2 == "undefined"):
return True
if type1 == "number" and type2 == "string":
return AEC(ctx, x, W_Number(y.ToNumber()))
if type1 == "string" and type2 == "number":
return AEC(ctx, W_Number(x.ToNumber()), y)
if type1 == "boolean":
return AEC(ctx, W_Number(x.ToNumber()), y)
if type2 == "boolean":
return AEC(ctx, x, W_Number(y.ToNumber()))
if (type1 == "string" or type1 == "number") and \
type2 == "object":
return AEC(ctx, x, y.ToPrimitive(ctx))
if (type2 == "string" or type2 == "number") and \
type1 == "object":
return AEC(ctx, x.ToPrimitive(ctx), y)
return False
objtype = x.GetValue().type()
if objtype == y.GetValue().type():
if objtype == "undefined" or objtype == "null":
return True
if isinstance(x, W_String) and isinstance(y, W_String):
r = x.ToString(ctx) == y.ToString(ctx)
else:
r = x.ToNumber() == y.ToNumber()
return r
class Eq(BinaryComparisonOp):
def decision(self, ctx, op1, op2):
return W_Boolean(AEC(ctx, op1, op2))
class Ne(BinaryComparisonOp):
def decision(self, ctx, op1, op2):
return W_Boolean(not AEC(ctx, op1, op2))
##############################################################################
#
# Strict Equality and unequality, usually means same place in memory
# or equality for primitive values
#
##############################################################################
def SEC(ctx, x, y):
"""
Implements the Strict Equality Comparison x === y
trying to be fully to the spec
"""
type1 = x.type()
type2 = y.type()
if type1 != type2:
return False
if type1 == "undefined" or type1 == "null":
return True
if type1 == "number":
n1 = x.ToNumber()
n2 = y.ToNumber()
nan_string = str(NaN)
if str(n1) == nan_string or str(n2) == nan_string:
return False
if n1 == n2:
return True
return False
if type1 == "string":
return x.ToString(ctx) == y.ToString(ctx)
if type1 == "boolean":
return x.ToBoolean() == x.ToBoolean()
return x == y
class StrictEq(BinaryComparisonOp):
def decision(self, ctx, op1, op2):
return W_Boolean(SEC(ctx, op1, op2))
class StrictNe(BinaryComparisonOp):
def decision(self, ctx, op1, op2):
return W_Boolean(not SEC(ctx, op1, op2))
class In(BinaryComparisonOp):
"""
The in operator, eg: "property in object"
"""
def decision(self, ctx, op1, op2):
if not isinstance(op2, W_Object):
raise ThrowException(W_String("TypeError"))
name = op1.ToString(ctx)
return W_Boolean(op2.HasProperty(name))
class Delete(UnaryOp):
"""
the delete op, erases properties from objects
"""
def eval(self, ctx):
r1 = self.expr.eval(ctx)
if not isinstance(r1, W_Reference):
return W_Boolean(True)
r3 = r1.GetBase()
r4 = r1.GetPropertyName()
return W_Boolean(r3.Delete(r4))
class Increment(UnaryOp):
"""
++value (prefix) and value++ (postfix)
"""
def eval(self, ctx):
thing = self.expr.eval(ctx)
val = thing.GetValue()
x = val.ToNumber()
resl = plus(ctx, W_Number(x), W_Number(1))
thing.PutValue(resl, ctx)
if self.postfix:
return val
else:
return resl
class Decrement(UnaryOp):
"""
same as increment --value and value --
"""
def eval(self, ctx):
thing = self.expr.eval(ctx)
val = thing.GetValue()
x = val.ToNumber()
resl = sub(ctx, W_Number(x), W_Number(1))
thing.PutValue(resl, ctx)
if self.postfix:
return val
else:
return resl
class Index(BinaryOp):
def eval(self, ctx):
w_obj = self.left.eval(ctx).GetValue().ToObject(ctx)
name= self.right.eval(ctx).GetValue().ToString(ctx)
return W_Reference(name, w_obj)
class ArgumentList(ListOp):
def eval(self, ctx):
return W_List([node.eval(ctx).GetValue() for node in self.nodes])
##############################################################################
#
# Math Ops
#
##############################################################################
class BinaryNumberOp(BinaryOp):
def eval(self, ctx):
nleft = self.left.eval(ctx).GetValue().ToPrimitive(ctx, 'Number')
nright = self.right.eval(ctx).GetValue().ToPrimitive(ctx, 'Number')
result = self.mathop(ctx, nleft, nright)
return result
def mathop(self, ctx, n1, n2):
raise NotImplementedError
def plus(ctx, nleft, nright):
if isinstance(nleft, W_String) or isinstance(nright, W_String):
sleft = nleft.ToString(ctx)
sright = nright.ToString(ctx)
return W_String(sleft + sright)
else:
fleft = nleft.ToNumber()
fright = nright.ToNumber()
return W_Number(fleft + fright)
def mult(ctx, nleft, nright):
fleft = nleft.ToNumber()
fright = nright.ToNumber()
return W_Number(fleft * fright)
def mod(ctx, nleft, nright): # XXX this one is really not following spec
ileft = nleft.ToInt32()
iright = nright.ToInt32()
return W_Number(ileft % iright)
def division(ctx, nleft, nright):
fleft = nleft.ToNumber()
fright = nright.ToNumber()
return W_Number(fleft / fright)
def sub(ctx, nleft, nright):
fleft = nleft.ToNumber()
fright = nright.ToNumber()
return W_Number(fleft - fright)
class Plus(BinaryNumberOp):
def mathop(self, ctx, n1, n2):
return plus(ctx, n1, n2)
class Mult(BinaryNumberOp):
def mathop(self, ctx, n1, n2):
return mult(ctx, n1, n2)
class Mod(BinaryNumberOp):
def mathop(self, ctx, n1, n2):
return mod(ctx, n1, n2)
class Division(BinaryNumberOp):
def mathop(self, ctx, n1, n2):
return division(ctx, n1, n2)
class Sub(BinaryNumberOp):
def mathop(self, ctx, n1, n2):
return sub(ctx, n1, n2)
class Null(Expression):
def eval(self, ctx):
return w_Null
##############################################################################
#
# Value and object creation
#
##############################################################################
def commonnew(ctx, obj, args):
if not isinstance(obj, W_PrimitiveObject):
raise ThrowException(W_String('it is not a constructor'))
try:
res = obj.Construct(ctx=ctx, args=args)
except JsTypeError:
raise ThrowException(W_String('it is not a constructor'))
return res
class New(UnaryOp):
def eval(self, ctx):
x = self.expr.eval(ctx).GetValue()
return commonnew(ctx, x, [])
class NewWithArgs(BinaryOp):
def eval(self, ctx):
x = self.left.eval(ctx).GetValue()
args = self.right.eval(ctx).get_args()
return commonnew(ctx, x, args)
class Number(Expression):
def __init__(self, pos, num):
self.pos = pos
assert isinstance(num, float)
self.num = num
def eval(self, ctx):
return W_Number(self.num)
class String(Expression):
def __init__(self, pos, strval):
self.pos = pos
self.strval = self.string_unquote(strval)
def eval(self, ctx):
return W_String(self.strval)
def get_literal(self):
return W_String(self.strval).ToString()
def string_unquote(self, string):
temp = []
stop = len(string)-1
assert stop >= 0
last = ""
#removing the begining quotes (" or \')
if string.startswith('"'):
singlequote = False
else:
singlequote = True
internalstring = string[1:stop]
for c in internalstring:
if last == SLASH:
unescapeseq = unescapedict[last+c]
temp.append(unescapeseq)
c = ' ' # Could be anything
elif c != SLASH:
temp.append(c)
last = c
return ''.join(temp)
class ObjectInit(ListOp):
def eval(self, ctx):
w_obj = create_object(ctx, 'Object')
for prop in self.nodes:
name = prop.left.eval(ctx).GetPropertyName()
w_expr = prop.right.eval(ctx).GetValue()
w_obj.Put(name, w_expr)
return w_obj
class SourceElements(Statement):
"""
SourceElements nodes are found on each function declaration and in global code
"""
def __init__(self, pos, var_decl, func_decl, nodes):
self.pos = pos
self.var_decl = var_decl
self.func_decl = func_decl
self.nodes = nodes
def execute(self, ctx):
for varname in self.var_decl:
ctx.variable.Put(varname, w_Undefined)
for funcname, funccode in self.func_decl.items():
ctx.variable.Put(funcname, funccode.eval(ctx))
node = self
try:
last = w_Undefined
for node in self.nodes:
last = node.execute(ctx)
return last
except Exception, e:
if isinstance(e, ExecutionReturned) and e.type == 'return':
return e.value
else:
# TODO: proper exception handling
print "exception in line: %s, on: %s%s"%(node.pos.lineno, node, os.linesep)
raise
class Program(Statement):
def __init__(self, pos, body):
self.pos = pos
self.body = body
def execute(self, ctx):
return self.body.execute(ctx)
class Return(Statement):
def __init__(self, pos, expr):
self.pos = pos
self.expr = expr
def execute(self, ctx):
if isinstance(self.expr, Undefined):
raise ExecutionReturned('return', None, None)
else:
raise ExecutionReturned('return', self.expr.eval(ctx), None)
class Throw(Statement):
def __init__(self, pos, exp):
self.pos = pos
self.exp = exp
def execute(self, ctx):
raise ThrowException(self.exp.eval(ctx).GetValue())
class Try(Statement):
def __init__(self, pos, tryblock, catchparam, catchblock, finallyblock):
self.pos = pos
self.tryblock = tryblock
self.catchparam = catchparam
self.catchblock = catchblock
self.finallyblock = finallyblock
def execute(self, ctx):
e = None
tryresult = w_Undefined
try:
tryresult = self.tryblock.execute(ctx)
except ThrowException, excpt:
e = excpt
if self.catchblock is not None:
obj = W_Object()
obj.Put(self.catchparam.get_literal(), e.exception)
ctx.push_object(obj)
tryresult = self.catchblock.execute(ctx)
ctx.pop_object()
if self.finallyblock is not None:
tryresult = self.finallyblock.execute(ctx)
#if there is no catchblock reraise the exception
if (e is not None) and (self.catchblock is None):
raise e
return tryresult
class Typeof(UnaryOp):
def eval(self, ctx):
val = self.expr.eval(ctx)
if isinstance(val, W_Reference) and val.GetBase() is None:
return W_String("undefined")
return W_String(val.GetValue().type())
class VariableDeclaration(Expression):
def __init__(self, pos, identifier, expr=None):
self.pos = pos
self.identifier = identifier
self.expr = expr
def eval(self, ctx):
name = self.identifier.get_literal()
if self.expr is None:
ctx.variable.Put(name, w_Undefined)
else:
ctx.variable.Put(name, self.expr.eval(ctx).GetValue())
return self.identifier.eval(ctx)
class VariableDeclList(Expression):
def __init__(self, pos, nodes):
self.pos = pos
self.nodes = nodes
def eval(self, ctx):
for var in self.nodes:
var.eval(ctx)
return w_Undefined
class Variable(Statement):
def __init__(self, pos, body):
self.pos = pos
self.body = body
def execute(self, ctx):
return self.body.eval(ctx)
class Void(UnaryOp):
def eval(self, ctx):
self.expr.eval(ctx)
return w_Undefined
class With(Statement):
def __init__(self, pos, identifier, body):
self.pos = pos
self.identifier = identifier
self.body = body
def execute(self, ctx):
obj = self.identifier.eval(ctx).GetValue().ToObject(ctx)
ctx.push_object(obj)
try:
retval = self.body.execute(ctx)
finally:
ctx.pop_object()
return retval
class WhileBase(Statement):
def __init__(self, pos, condition, body):
self.pos = pos
self.condition = condition
self.body = body
class Do(WhileBase):
opcode = 'DO'
def execute(self, ctx):
try:
self.body.execute(ctx)
except ExecutionReturned, e:
if e.type == 'break':
return
elif e.type == 'continue':
pass
while self.condition.eval(ctx).ToBoolean():
try:
self.body.execute(ctx)
except ExecutionReturned, e:
if e.type == 'break':
break
elif e.type == 'continue':
continue
class While(WhileBase):
def execute(self, ctx):
while self.condition.eval(ctx).ToBoolean():
try:
self.body.execute(ctx)
except ExecutionReturned, e:
if e.type == 'break':
break
elif e.type == 'continue':
continue
class ForVarIn(Statement):
def __init__(self, pos, vardecl, lobject, body):
self.pos = pos
self.vardecl = vardecl
self.object = lobject
self.body = body
def execute(self, ctx):
self.vardecl.eval(ctx)
obj = self.object.eval(ctx).GetValue().ToObject(ctx)
for prop in obj.propdict.values():
if prop.de:
continue
iterator = self.vardecl.eval(ctx)
iterator.PutValue(prop.value, ctx)
try:
result = self.body.execute(ctx)
except ExecutionReturned, e:
if e.type == 'break':
break
elif e.type == 'continue':
continue
class ForIn(Statement):
def __init__(self, pos, iterator, lobject, body):
self.pos = pos
#assert isinstance(iterator, Node)
self.iterator = iterator
self.object = lobject
self.body = body
def execute(self, ctx):
obj = self.object.eval(ctx).GetValue().ToObject(ctx)
for prop in obj.propdict.values():
if prop.de:
continue
iterator = self.iterator.eval(ctx)
iterator.PutValue(prop.value, ctx)
try:
result = self.body.execute(ctx)
except ExecutionReturned, e:
if e.type == 'break':
break
elif e.type == 'continue':
continue
class For(Statement):
def __init__(self, pos, setup, condition, update, body):
self.pos = pos
self.setup = setup
self.condition = condition
self.update = update
self.body = body
def execute(self, ctx):
self.setup.eval(ctx).GetValue()
while self.condition.eval(ctx).ToBoolean():
try:
self.body.execute(ctx)
self.update.eval(ctx)
except ExecutionReturned, e:
if e.type == 'break':
break
elif e.type == 'continue':
self.update.eval(ctx)
continue
class Boolean(Expression):
def __init__(self, pos, boolval):
self.pos = pos
self.bool = boolval
def eval(self, ctx):
return W_Boolean(self.bool)
class Not(UnaryOp):
def eval(self, ctx):
return W_Boolean(not self.expr.eval(ctx).GetValue().ToBoolean())
class UMinus(UnaryOp):
def eval(self, ctx):
return W_Number(-self.expr.eval(ctx).GetValue().ToNumber())
class UPlus(UnaryOp):
def eval(self, ctx):
return W_Number(+self.expr.eval(ctx).GetValue().ToNumber())
| Python |
escapes = [
r'\n',
r'\r',
r'\f',
r'\v',
r'\ ',
r'\t',
r"\'",
r'\b',
r'\"',
r'\\',
r'\u'] #don't know what to do with these
codes = [
'\n',
'\r',
'\f',
'\v',
'\ ',
'\t',
"'",
"\b",
'"',
'\\',
'u']
escapedict = dict(zip(codes, escapes))
unescapedict = dict(zip(escapes, codes))
SLASH = "\\" | Python |
#!/usr/bin/env python
# encoding: utf-8
"""
js_interactive.py
"""
import autopath
import sys
import getopt
from pypy.lang.js.interpreter import load_source, Interpreter, load_file
from pypy.lang.js.jsparser import parse, ParseError
from pypy.lang.js.jsobj import W_Builtin, W_String, ThrowException, w_Undefined
from pypy.rlib.streamio import open_file_as_stream
import code
sys.ps1 = 'js> '
sys.ps2 = '... '
try:
# Setup Readline
import readline
import os
histfile = os.path.join(os.environ["HOME"], ".jspypyhist")
try:
getattr(readline, "clear_history", lambda : None)()
readline.read_history_file(histfile)
except IOError:
pass
import atexit
atexit.register(readline.write_history_file, histfile)
except ImportError:
pass
def loadjs(ctx, args, this):
filename = args[0].ToString()
t = load_file(filename)
return t.execute(ctx)
def tracejs(ctx, args, this):
arguments = args
import pdb
pdb.set_trace()
def quitjs(ctx, args, this):
sys.exit(0)
class JSInterpreter(code.InteractiveConsole):
def __init__(self, locals=None, filename="<console>"):
code.InteractiveConsole.__init__(self, locals, filename)
self.interpreter = Interpreter()
self.interpreter.w_Global.Put('quit', W_Builtin(quitjs))
self.interpreter.w_Global.Put('load', W_Builtin(loadjs))
self.interpreter.w_Global.Put('trace', W_Builtin(tracejs))
def runcodefromfile(self, filename):
f = open_file_as_stream(filename)
self.runsource(f.readall())
f.close()
def runcode(self, ast):
"""Run the javascript code in the AST. All exceptions raised
by javascript code must be caught and handled here. When an
exception occurs, self.showtraceback() is called to display a
traceback.
"""
try:
res = self.interpreter.run(ast)
if res not in (None, w_Undefined):
try:
print res.GetValue().ToString(self.interpreter.w_Global)
except ThrowException, exc:
print exc.exception.ToString(self.interpreter.w_Global)
except SystemExit:
raise
except ThrowException, exc:
self.showtraceback(exc)
else:
if code.softspace(sys.stdout, 0):
print
def runsource(self, source, filename="<input>"):
"""Parse and run source in the interpreter.
One of these cases can happen:
1) The input is incorrect. Prints a nice syntax error message.
2) The input in incomplete. More input is required. Returns None.
3) The input is complete. Executes the source code.
"""
try:
ast = load_source(source)
except ParseError, exc:
if exc.source_pos.i == len(source):
# Case 2
return True # True means that more input is needed
else:
# Case 1
self.showsyntaxerror(filename, exc)
return False
# Case 3
self.runcode(ast)
return False
def showtraceback(self, exc):
# XXX format exceptions nicier
print exc.exception.ToString()
def showsyntaxerror(self, filename, exc):
# XXX format syntax errors nicier
print ' '*4 + \
' '*exc.source_pos.columnno + \
'^'
print 'Syntax Error'
def interact(self, banner=None):
if banner is None:
banner = 'PyPy JavaScript Interpreter'
code.InteractiveConsole.interact(self, banner)
def main(inspect=False, files=[]):
jsi = JSInterpreter()
for filename in files:
jsi.runcodefromfile(filename)
if (not files) or inspect:
jsi.interact()
if __name__ == '__main__':
from optparse import OptionParser
parser = OptionParser(usage='%prog [options] [files] ...',
description='PyPy JavaScript Interpreter')
parser.add_option('-i', dest='inspect',
action='store_true', default=False,
help='inspect interactively after running script')
# ... (add other options)
opts, args = parser.parse_args()
if args:
main(inspect=opts.inspect, files=args)
else:
main(inspect=opts.inspect)
sys.exit(0)
| Python |
#!/usr/bin/env python
import autopath
from py import path
import py
import os
import sys
from subprocess import *
pwd = path.local(__file__)
shell = pwd.dirpath('test', 'ecma', 'shell.js')
exclusionlist = ['shell.js', 'browser.js']
def filter(filename):
if filename.basename in exclusionlist or not filename.basename.endswith('.js'):
return False
else:
return True
if py.path.local.sysfind("js") is None:
print "js interpreter not found in path"
sys.exit()
results = open('results.txt', 'w')
for f in pwd.dirpath('test', 'ecma').visit(filter):
print f.basename
cmd = './js_interactive.py -n -f %s -f %s'%(shell, f)
p = Popen(cmd, shell=True, stdout=PIPE)
passed = 0
total = 0
for line in p.stdout.readlines():
if "PASSED!" in line:
passed += 1
total += 1
elif "FAILED!" in line:
total += 1
results.write('%s passed %s of %s tests\n'%(f.basename, passed, total))
results.flush()
| Python |
from pypy.rlib.parsing.tree import RPythonVisitor, Symbol, Nonterminal
from pypy.lang.js import operations
class ASTBuilder(RPythonVisitor):
BINOP_TO_CLS = {
'+': operations.Plus,
'-': operations.Sub,
'*': operations.Mult,
'/': operations.Division,
'%': operations.Mod,
'^': operations.BitwiseXor,
'|': operations.BitwiseOr,
'&': operations.BitwiseAnd,
'&&': operations.And,
'||': operations.Or,
'==': operations.Eq,
'!=': operations.Ne,
'!==': operations.StrictNe,
'===': operations.StrictEq,
'>': operations.Gt,
'>=': operations.Ge,
'<': operations.Lt,
'<=': operations.Le,
'>>': operations.Rsh,
'>>>': operations.Ursh,
'<<': operations.Lsh,
'.': operations.MemberDot,
'[': operations.Member,
',': operations.Comma,
'in': operations.In,
}
UNOP_TO_CLS = {
'~': operations.BitwiseNot,
'!': operations.Not,
'+': operations.UPlus,
'-': operations.UMinus,
'++': operations.Increment,
'--': operations.Decrement,
'typeof': operations.Typeof,
'void': operations.Void,
'delete': operations.Delete,
}
LISTOP_TO_CLS = {
'[': operations.Array,
'{': operations.ObjectInit,
}
def get_pos(self, node):
value = ''
source_pos = None
if isinstance(node, Symbol):
value = node.additional_info
source_pos = node.token.source_pos
elif len(node.children) > 0:
curr = node.children[0]
while not isinstance(curr, Symbol):
if len(curr.children):
curr = curr.children[0]
else:
break
else:
value = curr.additional_info
source_pos = curr.token.source_pos
# XXX some of the source positions are not perfect
if source_pos is None:
return operations.Position()
return operations.Position(
source_pos.lineno,
source_pos.columnno,
source_pos.columnno + len(value))
def visit_DECIMALLITERAL(self, node):
pos = self.get_pos(node)
number = operations.Number(pos, float(node.additional_info))
return number
def visit_HEXINTEGERLITERAL(self, node):
pos = self.get_pos(node)
number = operations.Number(pos, float(int(node.additional_info, 16)))
return number
def visit_OCTALLITERAL(self, node):
pos = self.get_pos(node)
number = operations.Number(pos, float(int(node.additional_info, 8)))
return number
def string(self,node):
pos = self.get_pos(node)
return operations.String(pos, node.additional_info)
visit_DOUBLESTRING = string
visit_SINGLESTRING = string
def binaryop(self, node):
left = self.dispatch(node.children[0])
for i in range((len(node.children) - 1) // 2):
op = node.children[i * 2 + 1]
pos = self.get_pos(op)
right = self.dispatch(node.children[i * 2 + 2])
result = self.BINOP_TO_CLS[op.additional_info](pos, left, right)
left = result
return left
visit_additiveexpression = binaryop
visit_multiplicativeexpression = binaryop
visit_bitwisexorexpression = binaryop
visit_bitwiseandexpression = binaryop
visit_bitwiseorexpression = binaryop
visit_equalityexpression = binaryop
visit_logicalorexpression = binaryop
visit_logicalandexpression = binaryop
visit_relationalexpression = binaryop
visit_shiftexpression = binaryop
visit_expression = binaryop
visit_expressionnoin = binaryop
def visit_memberexpression(self, node):
if isinstance(node.children[0], Symbol) and \
node.children[0].additional_info == 'new': # XXX could be a identifier?
pos = self.get_pos(node)
left = self.dispatch(node.children[1])
right = self.dispatch(node.children[2])
return operations.NewWithArgs(pos, left, right)
else:
return self.binaryop(node)
def literalop(self, node):
pos = self.get_pos(node);
value = node.children[0].additional_info
if value == "true":
return operations.Boolean(pos, True)
elif value == "false":
return operations.Boolean(pos, False)
else:
return operations.Null(pos)
visit_nullliteral = literalop
visit_booleanliteral = literalop
def visit_unaryexpression(self, node):
op = node.children[0]
pos = self.get_pos(op)
child = self.dispatch(node.children[1])
return self.UNOP_TO_CLS[op.additional_info](pos, child)
def visit_postfixexpression(self, node):
op = node.children[1]
pos = self.get_pos(op)
child = self.dispatch(node.children[0])
return self.UNOP_TO_CLS[op.additional_info](pos, child, postfix=True)
def listop(self, node):
op = node.children[0]
pos = self.get_pos(op)
l = [self.dispatch(child) for child in node.children[1:]]
return self.LISTOP_TO_CLS[op.additional_info](pos, l)
visit_arrayliteral = listop # elision
visit_objectliteral = listop
def visit_block(self, node):
op = node.children[0]
pos = self.get_pos(op)
l = [self.dispatch(child) for child in node.children[1:]]
return operations.Block(pos, l)
def visit_arguments(self, node):
pos = self.get_pos(node)
nodes = [self.dispatch(child) for child in node.children[1:]]
return operations.ArgumentList(pos, nodes)
def visit_formalparameterlist(self, node):
pos = self.get_pos(node)
nodes = [self.dispatch(child) for child in node.children]
return operations.ArgumentList(pos, nodes)
def visit_variabledeclarationlist(self, node):
pos = self.get_pos(node)
nodes = [self.dispatch(child) for child in node.children]
return operations.VariableDeclList(pos, nodes)
visit_variabledeclarationlistnoin = visit_variabledeclarationlist
def visit_propertynameandvalue(self, node):
pos = self.get_pos(node)
left = self.dispatch(node.children[0])
right = self.dispatch(node.children[1])
return operations.PropertyInit(pos,left,right)
def visit_IDENTIFIERNAME(self, node):
pos = self.get_pos(node)
name = node.additional_info
return operations.Identifier(pos, name)
def visit_program(self, node):
self.varlists = []
self.funclists = []
pos = self.get_pos(node)
body = self.dispatch(node.children[0])
return operations.Program(pos, body)
def visit_variablestatement(self, node):
pos = self.get_pos(node)
body = self.dispatch(node.children[0])
return operations.Variable(pos, body)
def visit_throwstatement(self, node):
pos = self.get_pos(node)
exp = self.dispatch(node.children[0])
return operations.Throw(pos, exp)
def visit_sourceelements(self, node):
pos = self.get_pos(node)
self.varlists.append({})
self.funclists.append({})
nodes=[]
for child in node.children:
node = self.dispatch(child)
if node is not None:
nodes.append(node)
var_decl = self.varlists.pop().keys()
func_decl = self.funclists.pop()
return operations.SourceElements(pos, var_decl, func_decl, nodes)
def functioncommon(self, node, declaration=True):
pos = self.get_pos(node)
i=0
identifier, i = self.get_next_expr(node, i)
parameters, i = self.get_next_expr(node, i)
functionbody, i = self.get_next_expr(node, i)
if parameters == operations.astundef:
p = []
else:
p = [pident.get_literal() for pident in parameters.nodes]
funcobj = operations.FunctionStatement(pos, identifier, p, functionbody)
if declaration:
self.funclists[-1][identifier.get_literal()] = funcobj
return funcobj
def visit_functiondeclaration(self, node):
self.functioncommon(node)
return None
def visit_functionexpression(self, node):
return self.functioncommon(node, declaration=False)
def visit_variabledeclaration(self, node):
pos = self.get_pos(node)
identifier = self.dispatch(node.children[0])
self.varlists[-1][identifier.get_literal()] = None
if len(node.children) > 1:
expr = self.dispatch(node.children[1])
else:
expr = None
return operations.VariableDeclaration(pos, identifier, expr)
visit_variabledeclarationnoin = visit_variabledeclaration
def visit_expressionstatement(self, node):
return self.dispatch(node.children[0])
def visit_callexpression(self, node):
pos = self.get_pos(node)
left = self.dispatch(node.children[0])
for rightnode in node.children[1:]:
right = self.dispatch(rightnode)
left = operations.Call(pos, left, right)
return left
def visit_assignmentexpression(self, node):
pos = self.get_pos(node)
left = self.dispatch(node.children[0])
atype = node.children[1].additional_info
right = self.dispatch(node.children[2])
return operations.Assignment(pos, left, right, atype)
visit_assignmentexpressionnoin = visit_assignmentexpression
def visit_emptystatement(self, node):
return operations.astundef
def visit_newexpression(self, node):
if len(node.children) == 1:
return self.dispatch(node.children[0])
else:
pos = self.get_pos(node)
val = self.dispatch(node.children[1])
return operations.New(pos, val)
def visit_ifstatement(self, node):
pos = self.get_pos(node)
condition = self.dispatch(node.children[0])
ifblock = self.dispatch(node.children[1])
if len(node.children) > 2:
elseblock = self.dispatch(node.children[2])
else:
elseblock = operations.astundef
return operations.If(pos, condition, ifblock, elseblock)
def visit_iterationstatement(self, node):
return self.dispatch(node.children[0])
def visit_whiles(self, node):
pos = self.get_pos(node)
itertype = node.children[0].additional_info
if itertype == 'while':
condition = self.dispatch(node.children[1])
block = self.dispatch(node.children[2])
return operations.While(pos, condition, block)
elif itertype == "do":
pass
def visit_regularfor(self, node):
pos = self.get_pos(node)
i = 1
setup, i = self.get_next_expr(node, i)
condition, i = self.get_next_expr(node, i)
if isinstance(condition, operations.Undefined):
condition = operations.Boolean(pos, True)
update, i = self.get_next_expr(node, i)
body, i = self.get_next_expr(node, i)
return operations.For(pos, setup, condition, update, body)
visit_regularvarfor = visit_regularfor
def visit_infor(self, node):
pos = self.get_pos(node)
left = self.dispatch(node.children[1])
right = self.dispatch(node.children[2])
body= self.dispatch(node.children[3])
return operations.ForIn(pos, left, right, body)
def visit_invarfor(self, node):
pos = self.get_pos(node)
left = self.dispatch(node.children[1])
right = self.dispatch(node.children[2])
body= self.dispatch(node.children[3])
return operations.ForVarIn(pos, left, right, body)
def get_next_expr(self, node, i):
if isinstance(node.children[i], Symbol) and \
node.children[i].additional_info in [';', ')', '(', '}']:
return operations.astundef, i+1
else:
return self.dispatch(node.children[i]), i+2
def visit_breakstatement(self, node):
pos = self.get_pos(node)
if len(node.children) > 0:
target = self.dispatch(node.children[0])
else:
target = operations.astundef
return operations.Break(pos, target)
def visit_returnstatement(self, node):
pos = self.get_pos(node)
if len(node.children) > 0:
value = self.dispatch(node.children[0])
else:
value = operations.astundef
return operations.Return(pos, value)
def visit_conditionalexpression(self, node):
pos = self.get_pos(node)
condition = self.dispatch(node.children[0])
truepart = self.dispatch(node.children[2])
falsepart = self.dispatch(node.children[3])
return operations.Conditional(pos, condition, truepart, falsepart)
def visit_trystatement(self, node):
pos = self.get_pos(node)
tryblock = self.dispatch(node.children[0])
catchparam = None
catchblock = None
finallyblock = None
if node.children[1].children[0].additional_info == "catch":
catchparam = self.dispatch(node.children[1].children[1])
catchblock = self.dispatch(node.children[1].children[2])
if len(node.children) > 2:
finallyblock = self.dispatch(node.children[2].children[1])
else:
finallyblock = self.dispatch(node.children[1].children[1])
return operations.Try(pos, tryblock, catchparam, catchblock, finallyblock)
def visit_primaryexpression(self, node):
pos = self.get_pos(node)
return operations.This(pos, 'this')
def visit_withstatement(self, node):
pos = self.get_pos(node)
identifier = self.dispatch(node.children[0])
body = self.dispatch(node.children[1])
return operations.With(pos, identifier, body)
| Python |
"""
self cloning, automatic path configuration
copy this into any subdirectory of pypy from which scripts need
to be run, typically all of the test subdirs.
The idea is that any such script simply issues
import autopath
and this will make sure that the parent directory containing "pypy"
is in sys.path.
If you modify the master "autopath.py" version (in pypy/tool/autopath.py)
you can directly run it which will copy itself on all autopath.py files
it finds under the pypy root directory.
This module always provides these attributes:
pypydir pypy root directory path
this_dir directory where this autopath.py resides
"""
def __dirinfo(part):
""" return (partdir, this_dir) and insert parent of partdir
into sys.path. If the parent directories don't have the part
an EnvironmentError is raised."""
import sys, os
try:
head = this_dir = os.path.realpath(os.path.dirname(__file__))
except NameError:
head = this_dir = os.path.realpath(os.path.dirname(sys.argv[0]))
while head:
partdir = head
head, tail = os.path.split(head)
if tail == part:
break
else:
raise EnvironmentError, "'%s' missing in '%r'" % (partdir, this_dir)
pypy_root = os.path.join(head, '')
try:
sys.path.remove(head)
except ValueError:
pass
sys.path.insert(0, head)
munged = {}
for name, mod in sys.modules.items():
if '.' in name:
continue
fn = getattr(mod, '__file__', None)
if not isinstance(fn, str):
continue
newname = os.path.splitext(os.path.basename(fn))[0]
if not newname.startswith(part + '.'):
continue
path = os.path.join(os.path.dirname(os.path.realpath(fn)), '')
if path.startswith(pypy_root) and newname != part:
modpaths = os.path.normpath(path[len(pypy_root):]).split(os.sep)
if newname != '__init__':
modpaths.append(newname)
modpath = '.'.join(modpaths)
if modpath not in sys.modules:
munged[modpath] = mod
for name, mod in munged.iteritems():
if name not in sys.modules:
sys.modules[name] = mod
if '.' in name:
prename = name[:name.rfind('.')]
postname = name[len(prename)+1:]
if prename not in sys.modules:
__import__(prename)
if not hasattr(sys.modules[prename], postname):
setattr(sys.modules[prename], postname, mod)
return partdir, this_dir
def __clone():
""" clone master version of autopath.py into all subdirs """
from os.path import join, walk
if not this_dir.endswith(join('pypy','tool')):
raise EnvironmentError("can only clone master version "
"'%s'" % join(pypydir, 'tool',_myname))
def sync_walker(arg, dirname, fnames):
if _myname in fnames:
fn = join(dirname, _myname)
f = open(fn, 'rwb+')
try:
if f.read() == arg:
print "checkok", fn
else:
print "syncing", fn
f = open(fn, 'w')
f.write(arg)
finally:
f.close()
s = open(join(pypydir, 'tool', _myname), 'rb').read()
walk(pypydir, sync_walker, s)
_myname = 'autopath.py'
# set guaranteed attributes
pypydir, this_dir = __dirinfo('pypy')
if __name__ == '__main__':
__clone()
| Python |
Subsets and Splits
SQL Console for ajibawa-2023/Python-Code-Large
Provides a useful breakdown of language distribution in the training data, showing which languages have the most samples and helping identify potential imbalances across different language groups.