Home | History | Annotate | Download | only in llvm
      1 #===- core.py - Python LLVM Bindings -------------------------*- python -*--===#
      2 #
      3 #                     The LLVM Compiler Infrastructure
      4 #
      5 # This file is distributed under the University of Illinois Open Source
      6 # License. See LICENSE.TXT for details.
      7 #
      8 #===------------------------------------------------------------------------===#
      9 
     10 from .common import LLVMObject
     11 from .common import c_object_p
     12 from .common import get_library
     13 
     14 from . import enumerations
     15 
     16 from ctypes import POINTER
     17 from ctypes import byref
     18 from ctypes import c_char_p
     19 from ctypes import c_uint
     20 
     21 __all__ = [
     22     "lib",
     23     "Enums",
     24     "OpCode",
     25     "MemoryBuffer",
     26     "Module",
     27     "Value",
     28     "Function",
     29     "BasicBlock",
     30     "Instruction",
     31     "Context",
     32     "PassRegistry"
     33 ]
     34 
     35 lib = get_library()
     36 Enums = []
     37 
     38 class LLVMEnumeration(object):
     39     """Represents an individual LLVM enumeration."""
     40 
     41     def __init__(self, name, value):
     42         self.name = name
     43         self.value = value
     44 
     45     def __repr__(self):
     46         return '%s.%s' % (self.__class__.__name__,
     47                           self.name)
     48 
     49     @classmethod
     50     def from_value(cls, value):
     51         """Obtain an enumeration instance from a numeric value."""
     52         result = cls._value_map.get(value, None)
     53 
     54         if result is None:
     55             raise ValueError('Unknown %s: %d' % (cls.__name__,
     56                                                  value))
     57 
     58         return result
     59 
     60     @classmethod
     61     def register(cls, name, value):
     62         """Registers a new enumeration.
     63 
     64         This is called by this module for each enumeration defined in
     65         enumerations. You should not need to call this outside this module.
     66         """
     67         if value in cls._value_map:
     68             raise ValueError('%s value already registered: %d' % (cls.__name__,
     69                                                                   value))
     70         enum = cls(name, value)
     71         cls._value_map[value] = enum
     72         setattr(cls, name, enum)
     73 
     74 class Attribute(LLVMEnumeration):
     75     """Represents an individual Attribute enumeration."""
     76 
     77     _value_map = {}
     78 
     79     def __init__(self, name, value):
     80         super(Attribute, self).__init__(name, value)
     81 
     82 class OpCode(LLVMEnumeration):
     83     """Represents an individual OpCode enumeration."""
     84 
     85     _value_map = {}
     86 
     87     def __init__(self, name, value):
     88         super(OpCode, self).__init__(name, value)
     89 
     90 class TypeKind(LLVMEnumeration):
     91     """Represents an individual TypeKind enumeration."""
     92 
     93     _value_map = {}
     94 
     95     def __init__(self, name, value):
     96         super(TypeKind, self).__init__(name, value)
     97 
     98 class Linkage(LLVMEnumeration):
     99     """Represents an individual Linkage enumeration."""
    100 
    101     _value_map = {}
    102 
    103     def __init__(self, name, value):
    104         super(Linkage, self).__init__(name, value)
    105 
    106 class Visibility(LLVMEnumeration):
    107     """Represents an individual visibility enumeration."""
    108 
    109     _value_map = {}
    110 
    111     def __init__(self, name, value):
    112         super(Visibility, self).__init__(name, value)
    113 
    114 class CallConv(LLVMEnumeration):
    115     """Represents an individual calling convention enumeration."""
    116 
    117     _value_map = {}
    118 
    119     def __init__(self, name, value):
    120         super(CallConv, self).__init__(name, value)
    121 
    122 class IntPredicate(LLVMEnumeration):
    123     """Represents an individual IntPredicate enumeration."""
    124 
    125     _value_map = {}
    126 
    127     def __init__(self, name, value):
    128         super(IntPredicate, self).__init__(name, value)
    129 
    130 class RealPredicate(LLVMEnumeration):
    131     """Represents an individual RealPredicate enumeration."""
    132 
    133     _value_map = {}
    134 
    135     def __init__(self, name, value):
    136         super(RealPredicate, self).__init__(name, value)
    137 
    138 class LandingPadClauseTy(LLVMEnumeration):
    139     """Represents an individual LandingPadClauseTy enumeration."""
    140 
    141     _value_map = {}
    142 
    143     def __init__(self, name, value):
    144         super(LandingPadClauseTy, self).__init__(name, value)
    145 
    146 class MemoryBuffer(LLVMObject):
    147     """Represents an opaque memory buffer."""
    148 
    149     def __init__(self, filename=None):
    150         """Create a new memory buffer.
    151 
    152         Currently, we support creating from the contents of a file at the
    153         specified filename.
    154         """
    155         if filename is None:
    156             raise Exception("filename argument must be defined")
    157 
    158         memory = c_object_p()
    159         out = c_char_p(None)
    160 
    161         result = lib.LLVMCreateMemoryBufferWithContentsOfFile(filename,
    162                 byref(memory), byref(out))
    163 
    164         if result:
    165             raise Exception("Could not create memory buffer: %s" % out.value)
    166 
    167         LLVMObject.__init__(self, memory, disposer=lib.LLVMDisposeMemoryBuffer)
    168 
    169     def __len__(self):
    170         return lib.LLVMGetBufferSize(self)
    171 
    172 class Value(LLVMObject):
    173     
    174     def __init__(self, value):
    175         LLVMObject.__init__(self, value)
    176 
    177     @property
    178     def name(self):
    179         return lib.LLVMGetValueName(self)
    180 
    181     def dump(self):
    182         lib.LLVMDumpValue(self)
    183     
    184     def get_operand(self, i):
    185         return Value(lib.LLVMGetOperand(self, i))
    186     
    187     def set_operand(self, i, v):
    188         return lib.LLVMSetOperand(self, i, v)
    189     
    190     def __len__(self):
    191         return lib.LLVMGetNumOperands(self)
    192 
    193 class Module(LLVMObject):
    194     """Represents the top-level structure of an llvm program in an opaque object."""
    195 
    196     def __init__(self, module, name=None, context=None):
    197         LLVMObject.__init__(self, module, disposer=lib.LLVMDisposeModule)
    198 
    199     @classmethod
    200     def CreateWithName(cls, module_id):
    201         m = Module(lib.LLVMModuleCreateWithName(module_id))
    202         Context.GetGlobalContext().take_ownership(m)
    203         return m
    204 
    205     @property
    206     def datalayout(self):
    207         return lib.LLVMGetDataLayout(self)
    208 
    209     @datalayout.setter
    210     def datalayout(self, new_data_layout):
    211         """new_data_layout is a string."""
    212         lib.LLVMSetDataLayout(self, new_data_layout)
    213 
    214     @property
    215     def target(self):
    216         return lib.LLVMGetTarget(self)
    217 
    218     @target.setter
    219     def target(self, new_target):
    220         """new_target is a string."""
    221         lib.LLVMSetTarget(self, new_target)
    222 
    223     def dump(self):
    224         lib.LLVMDumpModule(self)
    225 
    226     class __function_iterator(object):
    227         def __init__(self, module, reverse=False):
    228             self.module = module
    229             self.reverse = reverse
    230             if self.reverse:
    231                 self.function = self.module.last
    232             else:
    233                 self.function = self.module.first
    234         
    235         def __iter__(self):
    236             return self
    237         
    238         def next(self):
    239             if not isinstance(self.function, Function):
    240                 raise StopIteration("")
    241             result = self.function
    242             if self.reverse:
    243                 self.function = self.function.prev
    244             else:
    245                 self.function = self.function.next
    246             return result
    247     
    248     def __iter__(self):
    249         return Module.__function_iterator(self)
    250 
    251     def __reversed__(self):
    252         return Module.__function_iterator(self, reverse=True)
    253 
    254     @property
    255     def first(self):
    256         return Function(lib.LLVMGetFirstFunction(self))
    257 
    258     @property
    259     def last(self):
    260         return Function(lib.LLVMGetLastFunction(self))
    261 
    262     def print_module_to_file(self, filename):
    263         out = c_char_p(None)
    264         # Result is inverted so 0 means everything was ok.
    265         result = lib.LLVMPrintModuleToFile(self, filename, byref(out))        
    266         if result:
    267             raise RuntimeError("LLVM Error: %s" % out.value)
    268 
    269 class Function(Value):
    270 
    271     def __init__(self, value):
    272         Value.__init__(self, value)
    273     
    274     @property
    275     def next(self):
    276         f = lib.LLVMGetNextFunction(self)
    277         return f and Function(f)
    278     
    279     @property
    280     def prev(self):
    281         f = lib.LLVMGetPreviousFunction(self)
    282         return f and Function(f)
    283     
    284     @property
    285     def first(self):
    286         b = lib.LLVMGetFirstBasicBlock(self)
    287         return b and BasicBlock(b)
    288 
    289     @property
    290     def last(self):
    291         b = lib.LLVMGetLastBasicBlock(self)
    292         return b and BasicBlock(b)
    293 
    294     class __bb_iterator(object):
    295         def __init__(self, function, reverse=False):
    296             self.function = function
    297             self.reverse = reverse
    298             if self.reverse:
    299                 self.bb = function.last
    300             else:
    301                 self.bb = function.first
    302         
    303         def __iter__(self):
    304             return self
    305         
    306         def next(self):
    307             if not isinstance(self.bb, BasicBlock):
    308                 raise StopIteration("")
    309             result = self.bb
    310             if self.reverse:
    311                 self.bb = self.bb.prev
    312             else:
    313                 self.bb = self.bb.next
    314             return result
    315     
    316     def __iter__(self):
    317         return Function.__bb_iterator(self)
    318 
    319     def __reversed__(self):
    320         return Function.__bb_iterator(self, reverse=True)
    321     
    322     def __len__(self):
    323         return lib.LLVMCountBasicBlocks(self)
    324 
    325 class BasicBlock(LLVMObject):
    326     
    327     def __init__(self, value):
    328         LLVMObject.__init__(self, value)
    329 
    330     @property
    331     def next(self):
    332         b = lib.LLVMGetNextBasicBlock(self)
    333         return b and BasicBlock(b)
    334 
    335     @property
    336     def prev(self):
    337         b = lib.LLVMGetPreviousBasicBlock(self)
    338         return b and BasicBlock(b)
    339     
    340     @property
    341     def first(self):
    342         i = lib.LLVMGetFirstInstruction(self)
    343         return i and Instruction(i)
    344 
    345     @property
    346     def last(self):
    347         i = lib.LLVMGetLastInstruction(self)
    348         return i and Instruction(i)
    349 
    350     def __as_value(self):
    351         return Value(lib.LLVMBasicBlockAsValue(self))
    352     
    353     @property
    354     def name(self):
    355         return lib.LLVMGetValueName(self.__as_value())
    356 
    357     def dump(self):
    358         lib.LLVMDumpValue(self.__as_value())
    359 
    360     def get_operand(self, i):
    361         return Value(lib.LLVMGetOperand(self.__as_value(),
    362                                         i))
    363     
    364     def set_operand(self, i, v):
    365         return lib.LLVMSetOperand(self.__as_value(),
    366                                   i, v)
    367     
    368     def __len__(self):
    369         return lib.LLVMGetNumOperands(self.__as_value())
    370 
    371     class __inst_iterator(object):
    372         def __init__(self, bb, reverse=False):            
    373             self.bb = bb
    374             self.reverse = reverse
    375             if self.reverse:
    376                 self.inst = self.bb.last
    377             else:
    378                 self.inst = self.bb.first
    379         
    380         def __iter__(self):
    381             return self
    382         
    383         def next(self):
    384             if not isinstance(self.inst, Instruction):
    385                 raise StopIteration("")
    386             result = self.inst
    387             if self.reverse:
    388                 self.inst = self.inst.prev
    389             else:
    390                 self.inst = self.inst.next
    391             return result
    392     
    393     def __iter__(self):
    394         return BasicBlock.__inst_iterator(self)
    395 
    396     def __reversed__(self):
    397         return BasicBlock.__inst_iterator(self, reverse=True)
    398 
    399 
    400 class Instruction(Value):
    401 
    402     def __init__(self, value):
    403         Value.__init__(self, value)
    404 
    405     @property
    406     def next(self):
    407         i = lib.LLVMGetNextInstruction(self)
    408         return i and Instruction(i)
    409 
    410     @property
    411     def prev(self):
    412         i = lib.LLVMGetPreviousInstruction(self)
    413         return i and Instruction(i)
    414 
    415     @property
    416     def opcode(self):
    417         return OpCode.from_value(lib.LLVMGetInstructionOpcode(self))
    418 
    419 class Context(LLVMObject):
    420 
    421     def __init__(self, context=None):
    422         if context is None:
    423             context = lib.LLVMContextCreate()
    424             LLVMObject.__init__(self, context, disposer=lib.LLVMContextDispose)
    425         else:
    426             LLVMObject.__init__(self, context)
    427 
    428     @classmethod
    429     def GetGlobalContext(cls):
    430         return Context(lib.LLVMGetGlobalContext())
    431 
    432 class PassRegistry(LLVMObject):
    433     """Represents an opaque pass registry object."""
    434 
    435     def __init__(self):
    436         LLVMObject.__init__(self,
    437                             lib.LLVMGetGlobalPassRegistry())
    438 
    439 def register_library(library):
    440     # Initialization/Shutdown declarations.
    441     library.LLVMInitializeCore.argtypes = [PassRegistry]
    442     library.LLVMInitializeCore.restype = None
    443 
    444     library.LLVMInitializeTransformUtils.argtypes = [PassRegistry]
    445     library.LLVMInitializeTransformUtils.restype = None
    446 
    447     library.LLVMInitializeScalarOpts.argtypes = [PassRegistry]
    448     library.LLVMInitializeScalarOpts.restype = None
    449 
    450     library.LLVMInitializeObjCARCOpts.argtypes = [PassRegistry]
    451     library.LLVMInitializeObjCARCOpts.restype = None
    452 
    453     library.LLVMInitializeVectorization.argtypes = [PassRegistry]
    454     library.LLVMInitializeVectorization.restype = None
    455 
    456     library.LLVMInitializeInstCombine.argtypes = [PassRegistry]
    457     library.LLVMInitializeInstCombine.restype = None
    458 
    459     library.LLVMInitializeIPO.argtypes = [PassRegistry]
    460     library.LLVMInitializeIPO.restype = None
    461 
    462     library.LLVMInitializeInstrumentation.argtypes = [PassRegistry]
    463     library.LLVMInitializeInstrumentation.restype = None
    464 
    465     library.LLVMInitializeAnalysis.argtypes = [PassRegistry]
    466     library.LLVMInitializeAnalysis.restype = None
    467 
    468     library.LLVMInitializeIPA.argtypes = [PassRegistry]
    469     library.LLVMInitializeIPA.restype = None
    470 
    471     library.LLVMInitializeCodeGen.argtypes = [PassRegistry]
    472     library.LLVMInitializeCodeGen.restype = None
    473 
    474     library.LLVMInitializeTarget.argtypes = [PassRegistry]
    475     library.LLVMInitializeTarget.restype = None
    476 
    477     library.LLVMShutdown.argtypes = []
    478     library.LLVMShutdown.restype = None
    479 
    480     # Pass Registry declarations.
    481     library.LLVMGetGlobalPassRegistry.argtypes = []
    482     library.LLVMGetGlobalPassRegistry.restype = c_object_p
    483 
    484     # Context declarations.
    485     library.LLVMContextCreate.argtypes = []
    486     library.LLVMContextCreate.restype = c_object_p
    487 
    488     library.LLVMContextDispose.argtypes = [Context]
    489     library.LLVMContextDispose.restype = None
    490 
    491     library.LLVMGetGlobalContext.argtypes = []
    492     library.LLVMGetGlobalContext.restype = c_object_p
    493 
    494     # Memory buffer declarations
    495     library.LLVMCreateMemoryBufferWithContentsOfFile.argtypes = [c_char_p,
    496             POINTER(c_object_p), POINTER(c_char_p)]
    497     library.LLVMCreateMemoryBufferWithContentsOfFile.restype = bool
    498 
    499     library.LLVMGetBufferSize.argtypes = [MemoryBuffer]
    500 
    501     library.LLVMDisposeMemoryBuffer.argtypes = [MemoryBuffer]
    502 
    503     # Module declarations
    504     library.LLVMModuleCreateWithName.argtypes = [c_char_p]
    505     library.LLVMModuleCreateWithName.restype = c_object_p
    506 
    507     library.LLVMDisposeModule.argtypes = [Module]
    508     library.LLVMDisposeModule.restype = None
    509 
    510     library.LLVMGetDataLayout.argtypes = [Module]
    511     library.LLVMGetDataLayout.restype = c_char_p
    512 
    513     library.LLVMSetDataLayout.argtypes = [Module, c_char_p]
    514     library.LLVMSetDataLayout.restype = None
    515 
    516     library.LLVMGetTarget.argtypes = [Module]
    517     library.LLVMGetTarget.restype = c_char_p
    518 
    519     library.LLVMSetTarget.argtypes = [Module, c_char_p]
    520     library.LLVMSetTarget.restype = None
    521 
    522     library.LLVMDumpModule.argtypes = [Module]
    523     library.LLVMDumpModule.restype = None
    524 
    525     library.LLVMPrintModuleToFile.argtypes = [Module, c_char_p,
    526                                               POINTER(c_char_p)]
    527     library.LLVMPrintModuleToFile.restype = bool
    528 
    529     library.LLVMGetFirstFunction.argtypes = [Module]
    530     library.LLVMGetFirstFunction.restype = c_object_p
    531 
    532     library.LLVMGetLastFunction.argtypes = [Module]
    533     library.LLVMGetLastFunction.restype = c_object_p
    534 
    535     library.LLVMGetNextFunction.argtypes = [Function]
    536     library.LLVMGetNextFunction.restype = c_object_p
    537 
    538     library.LLVMGetPreviousFunction.argtypes = [Function]
    539     library.LLVMGetPreviousFunction.restype = c_object_p
    540 
    541     # Value declarations.
    542     library.LLVMGetValueName.argtypes = [Value]
    543     library.LLVMGetValueName.restype = c_char_p
    544 
    545     library.LLVMDumpValue.argtypes = [Value]
    546     library.LLVMDumpValue.restype = None
    547 
    548     library.LLVMGetOperand.argtypes = [Value, c_uint]
    549     library.LLVMGetOperand.restype = c_object_p
    550 
    551     library.LLVMSetOperand.argtypes = [Value, Value, c_uint]
    552     library.LLVMSetOperand.restype = None
    553 
    554     library.LLVMGetNumOperands.argtypes = [Value]
    555     library.LLVMGetNumOperands.restype = c_uint
    556 
    557     # Basic Block Declarations.
    558     library.LLVMGetFirstBasicBlock.argtypes = [Function]
    559     library.LLVMGetFirstBasicBlock.restype = c_object_p
    560 
    561     library.LLVMGetLastBasicBlock.argtypes = [Function]
    562     library.LLVMGetLastBasicBlock.restype = c_object_p
    563 
    564     library.LLVMGetNextBasicBlock.argtypes = [BasicBlock]
    565     library.LLVMGetNextBasicBlock.restype = c_object_p
    566 
    567     library.LLVMGetPreviousBasicBlock.argtypes = [BasicBlock]
    568     library.LLVMGetPreviousBasicBlock.restype = c_object_p
    569 
    570     library.LLVMGetFirstInstruction.argtypes = [BasicBlock]
    571     library.LLVMGetFirstInstruction.restype = c_object_p
    572 
    573     library.LLVMGetLastInstruction.argtypes = [BasicBlock]
    574     library.LLVMGetLastInstruction.restype = c_object_p
    575 
    576     library.LLVMBasicBlockAsValue.argtypes = [BasicBlock]
    577     library.LLVMBasicBlockAsValue.restype = c_object_p
    578 
    579     library.LLVMCountBasicBlocks.argtypes = [Function]
    580     library.LLVMCountBasicBlocks.restype = c_uint
    581 
    582     # Instruction Declarations.
    583     library.LLVMGetNextInstruction.argtypes = [Instruction]
    584     library.LLVMGetNextInstruction.restype = c_object_p
    585 
    586     library.LLVMGetPreviousInstruction.argtypes = [Instruction]
    587     library.LLVMGetPreviousInstruction.restype = c_object_p
    588 
    589     library.LLVMGetInstructionOpcode.argtypes = [Instruction]
    590     library.LLVMGetInstructionOpcode.restype = c_uint
    591 
    592 def register_enumerations():
    593     if Enums:
    594         return None
    595     enums = [
    596         (Attribute, enumerations.Attributes),
    597         (OpCode, enumerations.OpCodes),
    598         (TypeKind, enumerations.TypeKinds),
    599         (Linkage, enumerations.Linkages),
    600         (Visibility, enumerations.Visibility),
    601         (CallConv, enumerations.CallConv),
    602         (IntPredicate, enumerations.IntPredicate),
    603         (RealPredicate, enumerations.RealPredicate),
    604         (LandingPadClauseTy, enumerations.LandingPadClauseTy),
    605     ]
    606     for enum_class, enum_spec in enums:
    607         for name, value in enum_spec:
    608             print name, value
    609             enum_class.register(name, value)
    610     return enums
    611 
    612 def initialize_llvm():
    613     Context.GetGlobalContext()
    614     p = PassRegistry()
    615     lib.LLVMInitializeCore(p)
    616     lib.LLVMInitializeTransformUtils(p)
    617     lib.LLVMInitializeScalarOpts(p)
    618     lib.LLVMInitializeObjCARCOpts(p)
    619     lib.LLVMInitializeVectorization(p)
    620     lib.LLVMInitializeInstCombine(p)
    621     lib.LLVMInitializeIPO(p)
    622     lib.LLVMInitializeInstrumentation(p)
    623     lib.LLVMInitializeAnalysis(p)
    624     lib.LLVMInitializeIPA(p)
    625     lib.LLVMInitializeCodeGen(p)
    626     lib.LLVMInitializeTarget(p)
    627 
    628 register_library(lib)
    629 Enums = register_enumerations()
    630 initialize_llvm()
    631