[pypy-svn] r16081 - pypy/dist/pypy/translator/llvm2
rxe at codespeak.net
rxe at codespeak.net
Mon Aug 15 19:57:44 CEST 2005
Author: rxe
Date: Mon Aug 15 19:57:41 2005
New Revision: 16081
Modified:
pypy/dist/pypy/translator/llvm2/arraynode.py
pypy/dist/pypy/translator/llvm2/codewriter.py
pypy/dist/pypy/translator/llvm2/database.py
pypy/dist/pypy/translator/llvm2/funcnode.py
pypy/dist/pypy/translator/llvm2/genllvm.py
pypy/dist/pypy/translator/llvm2/opwriter.py
pypy/dist/pypy/translator/llvm2/structnode.py
Log:
Basically refactoring and finishing up cleaning up database code in preparation
for implementing the external functions via some automation.
For those who have been interested in reading database and been postponing it -
it is now reached a healthy state (IMHO). ;-)
Modified: pypy/dist/pypy/translator/llvm2/arraynode.py
==============================================================================
--- pypy/dist/pypy/translator/llvm2/arraynode.py (original)
+++ pypy/dist/pypy/translator/llvm2/arraynode.py Mon Aug 15 19:57:41 2005
@@ -41,7 +41,7 @@
return "<ArrayTypeNode %r>" % self.ref
def setup(self):
- self.db.prepare_repr_arg_type(self.arraytype)
+ self.db.prepare_type(self.arraytype)
def is_atomic(self):
if isinstance(self.arraytype, lltype.Primitive):
@@ -57,7 +57,7 @@
def writedatatypedecl(self, codewriter):
codewriter.arraydef(self.ref,
self.db.get_machine_word(),
- self.db.repr_arg_type(self.arraytype))
+ self.db.repr_type(self.arraytype))
def writedecl(self, codewriter):
# declaration for constructor
@@ -65,7 +65,7 @@
def writeimpl(self, codewriter):
log.writeimpl(self.ref)
- fromtype = self.db.repr_arg_type(self.arraytype)
+ fromtype = self.db.repr_type(self.arraytype)
varsize.write_constructor(self.db, codewriter, self.ref,
self.constructor_decl,
fromtype,
@@ -82,6 +82,9 @@
td = "%s = type { %s }" % (self.ref, self.db.get_machine_word())
codewriter.append(td)
+ def is_atomic(self):
+ return True
+
class ArrayNode(ConstantLLVMNode):
""" An arraynode. Elements can be
a primitive,
@@ -120,12 +123,12 @@
def get_typerepr(self):
arraylen = self.get_arrayvalue()[0]
- typeval = self.db.repr_arg_type(self.arraytype)
+ typeval = self.db.repr_type(self.arraytype)
return "{ %s, [%s x %s] }" % (self.db.get_machine_word(),
arraylen, typeval)
def get_ref(self):
- typeval = self.db.repr_arg_type(lltype.typeOf(self.value))
+ typeval = self.db.repr_type(lltype.typeOf(self.value))
ref = "cast (%s* %s to %s*)" % (self.get_typerepr(),
self.ref,
typeval)
@@ -151,7 +154,7 @@
def constantvalue(self):
physicallen, arrayrepr = self.get_arrayvalue()
- typeval = self.db.repr_arg_type(self.arraytype)
+ typeval = self.db.repr_type(self.arraytype)
# first length is logical, second is physical
value = "%s %s, [%s x %s] %s" % (self.db.get_machine_word(),
Modified: pypy/dist/pypy/translator/llvm2/codewriter.py
==============================================================================
--- pypy/dist/pypy/translator/llvm2/codewriter.py (original)
+++ pypy/dist/pypy/translator/llvm2/codewriter.py Mon Aug 15 19:57:41 2005
@@ -15,7 +15,6 @@
self.n_lines += 1
if self.show_line_numbers:
line = "%-75s; %d" % (line, self.n_lines)
- #print >> self.f, line
self.f.write(line + '\n')
def comment(self, line, indent=True):
@@ -97,12 +96,6 @@
["[%s, %%%s]" % item
for item in zip(refs, blocknames)])
s = "%s = phi %s %s" % (targetvar, type_, mergelist)
- #for ref in refs:
- # if targetvar == ref:
- # self.comment('breaks SSA form: ' + s)
- # break
- #else:
- # self.indent(s)
self.indent(s)
def binaryop(self, name, targetvar, type_, ref1, ref2):
@@ -158,6 +151,3 @@
res += "sbyte* getelementptr ([%s x sbyte]* %s, int 0, int 0) )"
res = res % (tmpname, len, tmpname)
self.indent(res)
-
- #def __str__(self):
- # return "\n".join(self._lines)
Modified: pypy/dist/pypy/translator/llvm2/database.py
==============================================================================
--- pypy/dist/pypy/translator/llvm2/database.py (original)
+++ pypy/dist/pypy/translator/llvm2/database.py Mon Aug 15 19:57:41 2005
@@ -1,3 +1,4 @@
+
import sys
from pypy.translator.llvm2.log import log
from pypy.translator.llvm2.funcnode import FuncNode, FuncTypeNode
@@ -9,54 +10,14 @@
from pypy.translator.llvm2.opaquenode import OpaqueNode, OpaqueTypeNode
from pypy.translator.llvm2.node import ConstantLLVMNode
from pypy.rpython import lltype
-from pypy.objspace.flow.model import Block, Constant, Variable
-from pypy.rpython.rstr import STR
+from pypy.objspace.flow.model import Constant, Variable
log = log.database
-class NormalizingDict(object):
- """ this is a helper dict for obj2node in order
- to allow saner key-unification for Ptrs to functions
- (and possibly other stuff in the future)
- """
- def __init__(self):
- self._dict = {}
- def __repr__(self):
- return repr(self._dict)
- def dump(self):
- r = ""
- for x,y in self._dict.items():
- r += "%s -> %s" % (x, y)
- return r
- def _get(self, key):
- if isinstance(key, Constant):
- if isinstance(key.value, lltype._ptr):
- key = key.value._obj
- return key
- def __getitem__(self, key):
- key = self._get(key)
- return self._dict[key]
- def __contains__(self, key):
- key = self._get(key)
- return key in self._dict
- def __setitem__(self, key, value):
- key = self._get(key)
- self._dict[key] = value
- def __delitem__(self, key):
- key = self._get(key)
- del self._dict[key]
- def get(self, key):
- key = self._get(key)
- return self._dict.get(key)
- def values(self):
- return self._dict.values()
- def items(self):
- return self._dict.items()
-
class Database(object):
def __init__(self, translator):
self._translator = translator
- self.obj2node = NormalizingDict()
+ self.obj2node = {}
self._pendingsetup = []
self._tmpcount = 1
@@ -108,8 +69,7 @@
r = ""
for k, v in self.obj2node.items():
- if (isinstance(k, lltype.LowLevelType) or
- isinstance(k, Constant)):
+ if isinstance(k, lltype.LowLevelType):
continue
assert isinstance(lltype.typeOf(k), lltype.ContainerType)
@@ -124,7 +84,7 @@
"pbcref -> %s \n" % (v, k, ref, pbc_ref)
return r
- #_______create node_____________________________________
+ #_______setting up and preperation______________________________
def create_constant_node(self, type_, value):
node = None
@@ -157,55 +117,23 @@
def addpending(self, key, node):
# santity check we at least have a key of the right type
assert (isinstance(key, lltype.LowLevelType) or
- isinstance(key, Constant) or
isinstance(lltype.typeOf(key), lltype.ContainerType))
assert key not in self.obj2node, (
"node with key %r already known!" %(key,))
log("added to pending nodes:", type(key), node)
+
self.obj2node[key] = node
self._pendingsetup.append(node)
- def prepare_repr_arg(self, const_or_var):
- """if const_or_var is not already in a dictionary self.obj2node,
- the appropriate node gets constructed and gets added to
- self._pendingsetup and to self.obj2node"""
- if const_or_var in self.obj2node:
- return
-
- if isinstance(const_or_var, Constant):
- ct = const_or_var.concretetype
- if isinstance(ct, lltype.Primitive):
- log.prepare(const_or_var, "(is primitive)")
- return
-
- assert isinstance(ct, lltype.Ptr), "Preparation of non primitive and non pointer"
- value = const_or_var.value._obj
-
- # Only prepare root values at this point
- if isinstance(ct, lltype.Array) or isinstance(ct, lltype.Struct):
- p, c = lltype.parentlink(value)
- if p is None:
- log.prepare_repr_arg("skipping preparing non root", value)
- return
-
- if value is not None:
- self.addpending(const_or_var, self.create_constant_node(ct.TO, value))
- else:
- log.prepare(const_or_var, type(const_or_var))
-
- def prepare_repr_arg_multi(self, args):
- for const_or_var in args:
- self.prepare_repr_arg(const_or_var)
-
- def prepare_repr_arg_type(self, type_):
+ def prepare_type(self, type_):
if type_ in self.obj2node:
return
if isinstance(type_, lltype.Primitive):
pass
elif isinstance(type_, lltype.Ptr):
- self.prepare_repr_arg_type(type_.TO)
+ self.prepare_type(type_.TO)
elif isinstance(type_, lltype.Struct):
if type_._arrayfld:
@@ -227,14 +155,9 @@
else:
assert False, "need to prepare typerepr %s %s" % (type_, type(type_))
- def prepare_repr_arg_type_multi(self, types):
+ def prepare_type_multi(self, types):
for type_ in types:
- self.prepare_repr_arg_type(type_)
-
- def prepare_arg(self, const_or_var):
- log.prepare(const_or_var)
- self.prepare_repr_arg_type(const_or_var.concretetype)
- self.prepare_repr_arg(const_or_var)
+ self.prepare_type(type_)
def prepare_constant(self, type_, value):
if isinstance(type_, lltype.Primitive):
@@ -256,16 +179,49 @@
if value not in self.obj2node:
self.addpending(value, self.create_constant_node(type_, value))
- # Always add type (it is safe)
- self.prepare_repr_arg_type(type_)
+ # always add type (it is safe)
+ self.prepare_type(type_)
- def setup_all(self, entrynode):
- # Constants setup need to be done after the rest
- self.entrynode = entrynode
+ def prepare_arg_value(self, const_or_var):
+ """if const_or_var is not already in a dictionary self.obj2node,
+ the appropriate node gets constructed and gets added to
+ self._pendingsetup and to self.obj2node"""
+ if isinstance(const_or_var, Constant):
+ ct = const_or_var.concretetype
+ if isinstance(ct, lltype.Primitive):
+ log.prepare(const_or_var, "(is primitive)")
+ return
+
+ assert isinstance(ct, lltype.Ptr), "Preparation of non primitive and non pointer"
+ value = const_or_var.value._obj
+
+ # Only prepare root values at this point
+ if isinstance(ct, lltype.Array) or isinstance(ct, lltype.Struct):
+ p, c = lltype.parentlink(value)
+ if p is None:
+ log.prepare_arg_value("skipping preparing non root", value)
+ return
+
+ if value is not None and value not in self.obj2node:
+ self.addpending(value, self.create_constant_node(ct.TO, value))
+ else:
+ assert isinstance(const_or_var, Variable)
+
+
+ def prepare_arg(self, const_or_var):
+ log.prepare(const_or_var)
+ self.prepare_type(const_or_var.concretetype)
+ self.prepare_arg_value(const_or_var)
+
+ def setup_all(self, key):
+ print self.obj2node
+ entrynode = self.obj2node[key]
while self._pendingsetup:
node = self._pendingsetup.pop()
log.settingup(node)
node.setup()
+ self.entrynode = entrynode
+ return entrynode
def getnodes(self):
return self.obj2node.values()
@@ -278,7 +234,8 @@
if isinstance(arg.concretetype, lltype.Primitive):
return self.primitive_to_str(arg.concretetype, arg.value)
else:
- node = self.obj2node.get(arg)
+ assert isinstance(arg.value, lltype._ptr)
+ node = self.obj2node.get(arg.value._obj)
if node is None:
return 'null'
else:
@@ -288,18 +245,21 @@
return "%" + str(arg)
def repr_arg_type(self, arg):
- if isinstance(arg, (Constant, Variable)):
- arg = arg.concretetype
+ assert isinstance(arg, (Constant, Variable))
+ ct = arg.concretetype
+ return self.repr_type(ct)
+
+ def repr_type(self, type_):
try:
- return self.obj2node[arg].ref
+ return self.obj2node[type_].ref
except KeyError:
- if isinstance(arg, lltype.Primitive):
- return self.primitives[arg]
- elif isinstance(arg, lltype.Ptr):
- return self.repr_arg_type(arg.TO) + '*'
+ if isinstance(type_, lltype.Primitive):
+ return self.primitives[type_]
+ elif isinstance(type_, lltype.Ptr):
+ return self.repr_type(type_.TO) + '*'
else:
- raise TypeError("cannot represent %r" %(arg,))
-
+ raise TypeError("cannot represent %r" %(type_,))
+
def repr_argwithtype(self, arg):
return self.repr_arg(arg), self.repr_arg_type(arg)
@@ -314,10 +274,10 @@
type_ = lltype.typeOf(value)
if isinstance(type_, lltype.Primitive):
repr = self.primitive_to_str(type_, value)
- return None, "%s %s" % (self.repr_arg_type(type_), repr)
+ return None, "%s %s" % (self.repr_type(type_), repr)
elif isinstance(type_, lltype.Ptr):
- toptr = self.repr_arg_type(type_)
+ toptr = self.repr_type(type_)
value = value._obj
# special case, null pointer
@@ -339,6 +299,9 @@
self._tmpcount += 1
return "%tmp." + str(count)
+ def repr_constructor(self, type_):
+ return self.obj2node[type_].constructor_ref
+
# __________________________________________________________
# Primitive stuff
@@ -386,3 +349,7 @@
def is_atomic(self, value):
return self.obj2node[value].is_atomic()
+
+ def get_childref(self, parent, child):
+ node = self.obj2node[parent]
+ return node.get_childref(child)
Modified: pypy/dist/pypy/translator/llvm2/funcnode.py
==============================================================================
--- pypy/dist/pypy/translator/llvm2/funcnode.py (original)
+++ pypy/dist/pypy/translator/llvm2/funcnode.py Mon Aug 15 19:57:41 2005
@@ -20,12 +20,12 @@
return "<FuncTypeNode %r>" % self.ref
def setup(self):
- self.db.prepare_repr_arg_type(self.type_.RESULT)
- self.db.prepare_repr_arg_type_multi(self.type_._trueargs())
+ self.db.prepare_type(self.type_.RESULT)
+ self.db.prepare_type_multi(self.type_._trueargs())
def writedatatypedecl(self, codewriter):
- returntype = self.db.repr_arg_type(self.type_.RESULT)
- inputargtypes = self.db.repr_arg_type_multi(self.type_._trueargs())
+ returntype = self.db.repr_type(self.type_.RESULT)
+ inputargtypes = [self.db.repr_type(a) for a in self.type_._trueargs()]
codewriter.funcdef(self.ref, returntype, inputargtypes)
class FuncNode(ConstantLLVMNode):
@@ -90,10 +90,23 @@
blocks = [x for x in flatten(self.graph) if isinstance(x, Block)]
for block in blocks:
for op in block.operations:
- strop = str(op)
- l = (len(strop) + 2) # new line & null
+ strop = str(op) + "\n\x00"
+ l = len(strop)
+ if strop.find("direct_call") == -1:
+ continue
tempname = self.db.add_op2comment(l, op)
- typeandata = '[%s x sbyte] c"%s\\0A\\00"' % (l, strop)
+ printables = dict([(ord(i), None) for i in
+ ("0123456789abcdefghijklmnopqrstuvwxyz" +
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +
+ "!#$%&()*+,-./:;<=>?@[\\]^_`{|}~ '")])
+ s = []
+ for c in strop:
+ if ord(c) in printables:
+ s.append(c)
+ else:
+ s.append("\\%02x" % ord(c))
+ r = 'c"%s"' % "".join(s)
+ typeandata = '[%s x sbyte] %s' % (l, r)
codewriter.globalinstance(tempname, typeandata)
def writeglobalconstants(self, codewriter):
@@ -162,7 +175,7 @@
else:
last_op_index = None
for op_index, op in enumerate(block.operations):
- if False: # print out debug string
+ if True: # print out debug string
codewriter.newline()
codewriter.comment("** %s **" % str(op))
info = self.db.get_op2comment(op)
Modified: pypy/dist/pypy/translator/llvm2/genllvm.py
==============================================================================
--- pypy/dist/pypy/translator/llvm2/genllvm.py (original)
+++ pypy/dist/pypy/translator/llvm2/genllvm.py Mon Aug 15 19:57:41 2005
@@ -6,7 +6,6 @@
from pypy.translator.llvm2.database import Database
from pypy.translator.llvm2.pyxwrapper import write_pyx_wrapper
from pypy.translator.llvm2.log import log
-from pypy.objspace.flow.model import Constant
from pypy.rpython.rmodel import inputconst, getfunctionptr
from pypy.rpython import lltype
from pypy.tool.udir import udir
@@ -24,7 +23,7 @@
class GenLLVM(object):
- def __init__(self, translator, debug=False):
+ def __init__(self, translator, debug=True):
# reset counters
LLVMNode.nodename_count = {}
@@ -47,25 +46,22 @@
for ll_helper in (e.ll_exception_match,):
ptr = getfunctionptr(self.translator, ll_helper)
c = inputconst(lltype.typeOf(ptr), ptr)
- self.db.prepare_repr_arg(c)
- assert c in self.db.obj2node
+ self.db.prepare_arg_value(c)
ptr = getfunctionptr(self.translator, func)
c = inputconst(lltype.typeOf(ptr), ptr)
- self.db.prepare_repr_arg(c)
- assert c in self.db.obj2node
+ entry_point = c.value._obj
+ self.db.prepare_arg_value(c)
if self.debug: print 'gen_llvm_source db.setup_all) ' + time.ctime()
#7 minutes
- self.db.setup_all(self.db.obj2node[c])
+ self.entrynode = self.db.setup_all(entry_point)
if self.debug: print 'gen_llvm_source typ_decl.writedatatypedecl) ' + time.ctime()
if self.debug: print 'gen_llvm_source n_nodes) %d' % len(self.db.getnodes())
#3 seconds
- if self.debug:
- log.gen_llvm_source(self.db.dump_pbcs())
-
- self.entrynode = self.db.obj2node[c]
-
+ #if self.debug:
+ # log.gen_llvm_source(self.db.dump_pbcs())
+
# prevent running the same function twice in a test
if func.func_name in function_count:
postfix = '_%d' % function_count[func.func_name]
@@ -74,8 +70,8 @@
postfix = ''
function_count[func.func_name] = 1
filename = udir.join(func.func_name + postfix).new(ext='.ll')
-
- codewriter = CodeWriter( open(str(filename),'w') )
+ f = open(str(filename),'w')
+ codewriter = CodeWriter(f)
comment = codewriter.comment
nl = codewriter.newline
@@ -91,10 +87,10 @@
if self.debug: print 'gen_llvm_source typ_decl.writecomments) ' + time.ctime()
#0 minutes
- if self.debug:
- nl(); comment("Comments") ; nl()
- for typ_decl in self.db.getnodes():
- typ_decl.writecomments(codewriter)
+ #if self.debug:
+ # nl(); comment("Comments") ; nl()
+ # for typ_decl in self.db.getnodes():
+ # typ_decl.writecomments(codewriter)
if self.debug: print 'gen_llvm_source extdeclarations) ' + time.ctime()
nl(); comment("Function Prototypes") ; nl()
@@ -102,8 +98,8 @@
codewriter.append(extdecl)
if self.debug: print 'gen_llvm_source self._debug_prototype) ' + time.ctime()
- if self.debug:
- self._debug_prototype(codewriter)
+ #if self.debug:
+ # self._debug_prototype(codewriter)
if self.debug: print 'gen_llvm_source typ_decl.writedecl) ' + time.ctime()
for typ_decl in self.db.getnodes():
Modified: pypy/dist/pypy/translator/llvm2/opwriter.py
==============================================================================
--- pypy/dist/pypy/translator/llvm2/opwriter.py (original)
+++ pypy/dist/pypy/translator/llvm2/opwriter.py Mon Aug 15 19:57:41 2005
@@ -298,7 +298,8 @@
#assert functionref in extfunctions, msg
assert len(op_args) >= 1
- assert len(self.block.exits) >= 2 #at least one label and one exception label
+ # at least one label and one exception label
+ assert len(self.block.exits) >= 2
link = self.block.exits[0]
assert link.exitcase is None
@@ -336,8 +337,7 @@
assert issubclass(link.exitcase, Exception)
etype = self.db.obj2node[link.llexitcase._obj]
- current_exception_type = etype.get_ref()
-
+ current_exception_type = etype.get_ref()
target = self.node.block_to_name[link.target]
exc_found_label = block_label + '_exception_found_branchto_' + target
last_exc_type_var, last_exc_value_var = None, None
@@ -388,37 +388,27 @@
self.codewriter.br_uncond(target)
def malloc(self, op):
+ arg_type = op.args[0].value
targetvar = self.db.repr_arg(op.result)
- arg = op.args[0]
- assert (isinstance(arg, Constant) and
- isinstance(arg.value, lltype.Struct))
- #XXX unclean
- node = self.db.obj2node[arg.value]
- type_ = node.ref
- self.codewriter.malloc(targetvar, type_, atomic=node.is_atomic())
+
+ type_ = self.db.repr_type(arg_type)
+ atomic = self.db.is_atomic(arg_type)
+ self.codewriter.malloc(targetvar, type_, atomic=atomic)
def malloc_varsize(self, op):
- targetvar = self.db.repr_arg(op.result)
- arg_type = op.args[0]
- assert (isinstance(arg_type, Constant) and
- isinstance(arg_type.value, (lltype.Array, lltype.Struct)))
-
- #XXX unclean
- node = self.db.obj2node[arg_type.value]
-
- #XXX AAARRRRRRRRRGFFFFFFFFFFFFGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHH
- from pypy.translator.llvm2.arraynode import VoidArrayTypeNode
- if isinstance(node, VoidArrayTypeNode):
- type_ = node.ref
- self.codewriter.malloc(targetvar, type_, atomic=True)
+ arg_type = op.args[0].value
+ if isinstance(arg_type, lltype.Array) and arg_type.OF is lltype.Void:
+ # This is a backend decision to NOT represent a void array with
+ # anything and save space - therefore not varsizeda anymore
+ self.malloc(op)
return
- struct_type = node.ref
- struct_cons = node.constructor_ref
+ targetvar = self.db.repr_arg(op.result)
+ type_ = self.db.repr_type(arg_type) + "*"
+ type_cons = self.db.repr_constructor(arg_type)
argrefs = self.db.repr_arg_multi(op.args[1:])
argtypes = self.db.repr_arg_type_multi(op.args[1:])
- self.codewriter.call(targetvar, struct_type + "*", struct_cons,
- argrefs, argtypes)
+ self.codewriter.call(targetvar, type_, type_cons, argrefs, argtypes)
def _getindexhelper(self, name, struct):
assert name in list(struct._names)
Modified: pypy/dist/pypy/translator/llvm2/structnode.py
==============================================================================
--- pypy/dist/pypy/translator/llvm2/structnode.py (original)
+++ pypy/dist/pypy/translator/llvm2/structnode.py Mon Aug 15 19:57:41 2005
@@ -26,7 +26,7 @@
def setup(self):
# Recurse
for field in self._fields():
- self.db.prepare_repr_arg_type(field)
+ self.db.prepare_type(field)
def is_atomic(self):
for f in self._fields():
@@ -41,9 +41,8 @@
# main entry points from genllvm
def writedatatypedecl(self, codewriter):
- fields = self._fields()
- codewriter.structdef(self.ref,
- self.db.repr_arg_type_multi(fields))
+ fields_types = [self.db.repr_type(f) for f in self._fields()]
+ codewriter.structdef(self.ref, fields_types)
class StructVarsizeTypeNode(StructTypeNode):
@@ -78,8 +77,7 @@
name = current._names_without_voids()[-1]
current = current._flds[name]
assert isinstance(current, lltype.Array)
- arraytype = self.db.repr_arg_type(current.OF)
- # XXX write type info as a comment
+ arraytype = self.db.repr_type(current.OF)
varsize.write_constructor(self.db,
codewriter,
self.ref,
@@ -125,7 +123,7 @@
self.db.prepare_constant(lltype.typeOf(p), p)
def get_typerepr(self):
- return self.db.repr_arg_type(self.structtype)
+ return self.db.repr_type(self.structtype)
def get_childref(self, index):
pos = 0
@@ -147,8 +145,7 @@
if p is None:
ref = self.ref
else:
- parent = self.db.obj2node[p]
- ref = parent.get_childref(c)
+ ref = self.db.get_childref(p, c)
return ref
def get_pbcref(self, toptr):
@@ -204,14 +201,14 @@
def get_typerepr(self):
# last type is a special case and need to be worked out recursively
types = self._gettypes()[:-1]
- types_repr = [self.db.repr_arg_type(T) for name, T in types]
+ types_repr = [self.db.repr_type(T) for name, T in types]
types_repr.append(self._get_lastnode().get_typerepr())
return "{%s}" % ", ".join(types_repr)
def get_ref(self):
ref = super(StructVarsizeNode, self).get_ref()
- typeval = self.db.repr_arg_type(lltype.typeOf(self.value))
+ typeval = self.db.repr_type(lltype.typeOf(self.value))
ref = "cast (%s* %s to %s*)" % (self.get_typerepr(),
ref,
typeval)
More information about the Pypy-commit
mailing list