mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-10-30 16:17:05 +00:00
0ee9a84cac
Also fixed some trailing whitespace issues. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@201929 91177308-0d34-0410-b5e6-96231b3b80d8
141 lines
4.6 KiB
Python
141 lines
4.6 KiB
Python
from .base import TestBase
|
|
from ..core import MemoryBuffer
|
|
from ..core import PassRegistry
|
|
from ..core import Context
|
|
from ..core import Module
|
|
from ..core import Enums
|
|
from ..core import OpCode
|
|
from ..bit_reader import parse_bitcode
|
|
|
|
class TestCore(TestBase):
|
|
def test_enumerations(self):
|
|
for enum_cls, enum_spec in Enums:
|
|
for enum_name, enum_value in enum_spec:
|
|
# First make sure that enum_cls has the name of the enum as an
|
|
# attribute. People will access these values as
|
|
# EnumCls.EnumName.
|
|
self.assertTrue(hasattr(enum_cls, enum_name))
|
|
v_attr = getattr(enum_cls, enum_name)
|
|
self.assertTrue(isinstance(v_attr, enum_cls))
|
|
|
|
# Then make sure that the value returned for this attribute is
|
|
# correct in both ways.
|
|
self.assertEqual(v_attr.value, enum_value)
|
|
|
|
e = enum_cls.from_value(enum_value)
|
|
self.assertTrue(isinstance(e, enum_cls))
|
|
self.assertEqual(e, v_attr)
|
|
|
|
def test_memory_buffer_create_from_file(self):
|
|
source = self.get_test_file()
|
|
|
|
MemoryBuffer(filename=source)
|
|
|
|
def test_memory_buffer_failing(self):
|
|
with self.assertRaises(Exception):
|
|
MemoryBuffer(filename="/hopefully/this/path/doesnt/exist")
|
|
|
|
def test_memory_buffer_len(self):
|
|
source = self.get_test_file()
|
|
m = MemoryBuffer(filename=source)
|
|
self.assertEqual(len(m), 50)
|
|
|
|
def test_create_passregistry(self):
|
|
PassRegistry()
|
|
|
|
def test_create_context(self):
|
|
Context.GetGlobalContext()
|
|
|
|
def test_create_module_with_name(self):
|
|
# Make sure we can not create a module without a LLVMModuleRef.
|
|
with self.assertRaises(TypeError):
|
|
m = Module()
|
|
m = Module.CreateWithName("test-module")
|
|
|
|
def test_module_getset_datalayout(self):
|
|
m = Module.CreateWithName("test-module")
|
|
dl = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:32:64-v128:32:128-a0:0:32-n32-S32"
|
|
m.datalayout = dl
|
|
self.assertEqual(m.datalayout, dl)
|
|
|
|
def test_module_getset_target(self):
|
|
m = Module.CreateWithName("test-module")
|
|
target = "thumbv7-apple-ios5.0.0"
|
|
m.target = target
|
|
self.assertEqual(m.target, target)
|
|
|
|
def test_module_print_module_to_file(self):
|
|
m = Module.CreateWithName("test")
|
|
dl = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:32:64-v128:32:128-a0:0:32-n32-S32"
|
|
m.datalayout = dl
|
|
target = "thumbv7-apple-ios5.0.0"
|
|
m.target = target
|
|
m.print_module_to_file("test2.ll")
|
|
|
|
def test_module_function_iteration(self):
|
|
m = parse_bitcode(MemoryBuffer(filename=self.get_test_bc()))
|
|
i = 0
|
|
functions = ["f", "f2", "f3", "f4", "f5", "f6", "g1", "g2", "h1", "h2",
|
|
"h3"]
|
|
# Forward
|
|
for f in m:
|
|
self.assertEqual(f.name, functions[i])
|
|
f.dump()
|
|
i += 1
|
|
# Backwards
|
|
for f in reversed(m):
|
|
i -= 1
|
|
self.assertEqual(f.name, functions[i])
|
|
f.dump()
|
|
|
|
def test_function_basicblock_iteration(self):
|
|
m = parse_bitcode(MemoryBuffer(filename=self.get_test_bc()))
|
|
i = 0
|
|
|
|
bb_list = ['b1', 'b2', 'end']
|
|
|
|
f = m.first
|
|
while f.name != "f6":
|
|
f = f.next
|
|
|
|
# Forward
|
|
for bb in f:
|
|
self.assertEqual(bb.name, bb_list[i])
|
|
bb.dump()
|
|
i += 1
|
|
|
|
# Backwards
|
|
for bb in reversed(f):
|
|
i -= 1
|
|
self.assertEqual(bb.name, bb_list[i])
|
|
bb.dump()
|
|
|
|
def test_basicblock_instruction_iteration(self):
|
|
m = parse_bitcode(MemoryBuffer(filename=self.get_test_bc()))
|
|
i = 0
|
|
|
|
inst_list = [('arg1', OpCode.ExtractValue),
|
|
('arg2', OpCode.ExtractValue),
|
|
('', OpCode.Call),
|
|
('', OpCode.Ret)]
|
|
|
|
bb = m.first.first
|
|
|
|
# Forward
|
|
for inst in bb:
|
|
self.assertEqual(inst.name, inst_list[i][0])
|
|
self.assertEqual(inst.opcode, inst_list[i][1])
|
|
for op in range(len(inst)):
|
|
o = inst.get_operand(op)
|
|
print o.name
|
|
o.dump()
|
|
inst.dump()
|
|
i += 1
|
|
|
|
# Backwards
|
|
for inst in reversed(bb):
|
|
i -= 1
|
|
self.assertEqual(inst.name, inst_list[i][0])
|
|
self.assertEqual(inst.opcode, inst_list[i][1])
|
|
inst.dump()
|