← Back to branch summary

~pali/+junk/llvm-toolchain-3.7

« back to all changes in this revision

Viewing changes to bindings/python/llvm/core.py

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2015-07-15 17:51:08 UTC
  • Revision ID: package-import@ubuntu.com-20150715175108-l8mynwovkx4zx697
Tags: upstream-3.7~+rc2
Import upstream version 3.7~+rc2

Show diffs side-by-side

added added

removed removed

Lines of Context:
bindings/python/llvm/core.py
 
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()