bindings/python/llvm/tests/test_core.py

   1 from .base import TestBase
   2 from ..core import MemoryBuffer
   3 from ..core import PassRegistry
   4 from ..core import Context
   5 from ..core import Module
   6 from ..core import Enums
   7 from ..core import OpCode
   8 from ..bit_reader import parse_bitcode
   9
  10 class TestCore(TestBase):
  11     def test_enumerations(self):
  12         for enum_cls, enum_spec in Enums:
  13             for enum_name, enum_value in enum_spec:
  14                 # First make sure that enum_cls has the name of the enum as an
  15                 # attribute. People will access these values as
  16                 # EnumCls.EnumName.
  17                 self.assertTrue(hasattr(enum_cls, enum_name))
  18                 v_attr = getattr(enum_cls, enum_name)
  19                 self.assertTrue(isinstance(v_attr, enum_cls))
  20
  21                 # Then make sure that the value returned for this attribute is
  22                 # correct in both ways.
  23                 self.assertEqual(v_attr.value, enum_value)
  24
  25                 e = enum_cls.from_value(enum_value)
  26                 self.assertTrue(isinstance(e, enum_cls))
  27                 self.assertEqual(e, v_attr)
  28
  29     def test_memory_buffer_create_from_file(self):
  30         source = self.get_test_file()
  31
  32         MemoryBuffer(filename=source)
  33
  34     def test_memory_buffer_failing(self):
  35         with self.assertRaises(Exception):
  36             MemoryBuffer(filename="/hopefully/this/path/doesnt/exist")
  37
  38     def test_memory_buffer_len(self):
  39         source = self.get_test_file()
  40         m = MemoryBuffer(filename=source)
  41         self.assertEqual(len(m), 50)
  42
  43     def test_create_passregistry(self):
  44         PassRegistry()
  45
  46     def test_create_context(self):
  47         Context.GetGlobalContext()
  48
  49     def test_create_module_with_name(self):
  50         # Make sure we can not create a module without a LLVMModuleRef.
  51         with self.assertRaises(TypeError):
  52             m = Module()
  53         m = Module.CreateWithName("test-module")
  54
  55     def test_module_getset_datalayout(self):
  56         m = Module.CreateWithName("test-module")
  57         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"
  58         m.datalayout = dl
  59         self.assertEqual(m.datalayout, dl)
  60
  61     def test_module_getset_target(self):
  62         m = Module.CreateWithName("test-module")
  63         target = "thumbv7-apple-ios5.0.0"
  64         m.target = target
  65         self.assertEqual(m.target, target)
  66
  67     def test_module_print_module_to_file(self):
  68         m = Module.CreateWithName("test")
  69         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"
  70         m.datalayout = dl
  71         target = "thumbv7-apple-ios5.0.0"
  72         m.target = target
  73         m.print_module_to_file("test2.ll")
  74
  75     def test_module_function_iteration(self):
  76         m = parse_bitcode(MemoryBuffer(filename=self.get_test_bc()))
  77         i = 0
  78         functions = ["f", "f2", "f3", "f4", "f5", "f6", "g1", "g2", "h1", "h2",
  79                      "h3"]
  80         # Forward
  81         for f in m:
  82             self.assertEqual(f.name, functions[i])
  83             f.dump()
  84             i += 1
  85         # Backwards
  86         for f in reversed(m):
  87             i -= 1
  88             self.assertEqual(f.name, functions[i])
  89             f.dump()
  90
  91     def test_function_basicblock_iteration(self):
  92         m = parse_bitcode(MemoryBuffer(filename=self.get_test_bc()))
  93         i = 0
  94
  95         bb_list = ['b1', 'b2', 'end']
  96
  97         f = m.first
  98         while f.name != "f6":
  99             f = f.next
 100
 101         # Forward
 102         for bb in f:
 103             self.assertEqual(bb.name, bb_list[i])
 104             bb.dump()
 105             i += 1
 106
 107         # Backwards
 108         for bb in reversed(f):
 109             i -= 1
 110             self.assertEqual(bb.name, bb_list[i])
 111             bb.dump()
 112
 113     def test_basicblock_instruction_iteration(self):
 114         m = parse_bitcode(MemoryBuffer(filename=self.get_test_bc()))
 115         i = 0
 116
 117         inst_list = [('arg1', OpCode.ExtractValue),
 118                      ('arg2', OpCode.ExtractValue),
 119                      ('', OpCode.Call),
 120                      ('', OpCode.Ret)]
 121
 122         bb = m.first.first
 123
 124         # Forward
 125         for inst in bb:
 126             self.assertEqual(inst.name, inst_list[i][0])
 127             self.assertEqual(inst.opcode, inst_list[i][1])
 128             for op in range(len(inst)):
 129                 o = inst.get_operand(op)
 130                 print o.name
 131                 o.dump()
 132             inst.dump()
 133             i += 1
 134
 135         # Backwards
 136         for inst in reversed(bb):
 137             i -= 1
 138             self.assertEqual(inst.name, inst_list[i][0])
 139             self.assertEqual(inst.opcode, inst_list[i][1])
 140             inst.dump()