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
