jyapayne/llvmpy
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

move native tests

Browse source
This commit is contained in:
Ilan Schnell 2012-08-19 17:08:34 -05:00
commit 501c3d0f61
3 changed files with 50 additions and 169 deletions
Download patch file Download diff file Expand all files Collapse all files

51
llvm/test_llvmpy.py
View file

@ -4,6 +4,7 @@ LLVM tests
import os import os
import sys import sys
import unittest import unittest
import subprocess
is_py3k = bool(sys.version_info[0] == 3) is_py3k = bool(sys.version_info[0] == 3)
@ -14,7 +15,8 @@ else:
from llvm import __version__ from llvm import __version__
from llvm.core import Module, Type, GlobalVariable, Function, Builder from llvm.core import (Module, Type, GlobalVariable, Function, Builder,
Constant)
import llvm.passes as lp import llvm.passes as lp
import llvm.ee as le import llvm.ee as le
@ -290,6 +292,53 @@ tests.append(TestObjCache)
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------
class TestNative(unittest.TestCase):
def _make_module(self):
m = Module.new('module1')
m.add_global_variable(Type.int(), 'i')
fty = Type.function(Type.int(), [])
f = m.add_function(fty, name='main')
bldr = Builder.new(f.append_basic_block('entry'))
bldr.ret(Constant.int(Type.int(), 0xab))
return m
def _compile(self, src):
dst = '/tmp/llvmobj.out'
s = subprocess.call(['cc', '-o', dst, src])
if s != 0:
raise Exception("Cannot compile")
s = subprocess.call([dst])
self.assertEqual(s, 0xab)
def test_assembly(self):
m = self._make_module()
output = m.to_native_assembly()
src = '/tmp/llvmasm.s'
with open(src, 'wb') as fout:
fout.write(output)
self._compile(src)
def test_object(self):
m = self._make_module()
output = m.to_native_object()
src = '/tmp/llvmobj.o'
with open(src, 'wb') as fout:
fout.write(output)
self._compile(src)
tests.append(TestNative)
# ---------------------------------------------------------------------------
def run(verbosity=1): def run(verbosity=1):
print('llvmpy is installed in: ' + os.path.dirname(__file__)) print('llvmpy is installed in: ' + os.path.dirname(__file__))
print('llvmpy version: ' + __version__) print('llvmpy version: ' + __version__)

53
test/native.py
View file

@ -1,53 +0,0 @@
#!/usr/bin/env python
from llvm import *
from llvm.core import *
import unittest, subprocess
class TestNative(unittest.TestCase):
def _make_module(self):
m = Module.new('module1')
m.add_global_variable(Type.int(), 'i')
fty = Type.function(Type.int(), [])
f = m.add_function(fty, name='main')
bldr = Builder.new(f.append_basic_block('entry'))
bldr.ret(Constant.int(Type.int(), 0xab))
return m
def _compile(self, src):
dst = '/tmp/llvmobj.out'
s = subprocess.call(['cc', '-o', dst, src])
if s != 0:
raise Exception("Cannot compile")
s = subprocess.call([dst])
self.assertEqual(s, 0xab)
def test_assembly(self):
m = self._make_module()
output = m.to_native_assembly()
src = '/tmp/llvmasm.s'
with open(src, 'wb') as fout:
fout.write(output)
self._compile(src)
def test_object(self):
m = self._make_module()
output = m.to_native_object()
src = '/tmp/llvmobj.o'
with open(src, 'wb') as fout:
fout.write(output)
self._compile(src)
if __name__ == '__main__':
unittest.main()

115
test/objcache.py
View file

@ -1,115 +0,0 @@
#!/usr/bin/env python
from llvm.core import *
import logging, sys, unittest
class TestObjCache(unittest.TestCase):
if sys.version_info[:2] < (2, 7):
def assertIs(self, expr1, expr2, msg=None):
if expr1 is not expr2:
standardMsg = '%s is not %s' % (safe_repr(expr1),
safe_repr(expr2))
self.fail(self._formatMessage(msg, standardMsg))
def test_objcache(self):
logging.debug("Testing module aliasing ..")
m1 = Module.new('a')
t = Type.int()
ft = Type.function(t, [t])
f1 = m1.add_function(ft, "func")
m2 = f1.module
self.assertIs(m1, m2)
logging.debug("Testing global vairable aliasing 1 .. ")
gv1 = GlobalVariable.new(m1, t, "gv")
gv2 = GlobalVariable.get(m1, "gv")
self.assertIs(gv1, gv2)
logging.debug("Testing global vairable aliasing 2 .. ")
gv3 = m1.global_variables[0]
self.assertIs(gv1, gv3)
logging.debug("Testing global vairable aliasing 3 .. ")
gv2 = None
gv3 = None
gv1.delete()
gv4 = GlobalVariable.new(m1, t, "gv")
self.assert_(gv1 is not gv4)
logging.debug("Testing function aliasing 1 ..")
b1 = f1.append_basic_block('entry')
f2 = b1.function
self.assertIs(f1, f2)
logging.debug("Testing function aliasing 2 ..")
f3 = m1.get_function_named("func")
self.assertIs(f1, f3)
logging.debug("Testing function aliasing 3 ..")
f4 = Function.get_or_insert(m1, ft, "func")
self.assertIs(f1, f4)
logging.debug("Testing function aliasing 4 ..")
f5 = Function.get(m1, "func")
self.assertIs(f1, f5)
logging.debug("Testing function aliasing 5 ..")
f6 = m1.get_or_insert_function(ft, "func")
self.assertIs(f1, f6)
logging.debug("Testing function aliasing 6 ..")
f7 = m1.functions[0]
self.assertIs(f1, f7)
logging.debug("Testing argument aliasing .. ")
a1 = f1.args[0]
a2 = f1.args[0]
self.assertIs(a1, a2)
logging.debug("Testing basic block aliasing 1 .. ")
b2 = f1.basic_blocks[0]
self.assertIs(b1, b2)
logging.debug("Testing basic block aliasing 2 .. ")
b3 = f1.get_entry_basic_block()
self.assertIs(b1, b3)
logging.debug("Testing basic block aliasing 3 .. ")
b31 = f1.entry_basic_block
self.assertIs(b1, b31)
logging.debug("Testing basic block aliasing 4 .. ")
bldr = Builder.new(b1)
b4 = bldr.basic_block
self.assertIs(b1, b4)
logging.debug("Testing basic block aliasing 5 .. ")
i1 = bldr.ret_void()
b5 = i1.basic_block
self.assertIs(b1, b5)
logging.debug("Testing instruction aliasing 1 .. ")
i2 = b5.instructions[0]
self.assertIs(i1, i2)
# phi node
phi = bldr.phi(t)
phi.add_incoming(f1.args[0], b1)
v2 = phi.get_incoming_value(0)
b6 = phi.get_incoming_block(0)
logging.debug("Testing PHI / basic block aliasing 5 .. ")
self.assertIs(b1, b6)
logging.debug("Testing PHI / value aliasing .. ")
self.assertIs(f1.args[0], v2)
if __name__ == '__main__':
unittest.main()