llvm.org GIT mirror llvm / 3e39731
Move C++ code out of the C headers and into either C++ headers or the C++ files themselves. This enables people to use just a C compiler to interoperate with LLVM. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@180063 91177308-0d34-0410-b5e6-96231b3b80d8 Eric Christopher 6 years ago
27 changed file(s) with 254 addition(s) and 229 deletion(s). Raw diff Collapse all Expand all
3131 class PassManagerBase;
3232 class Target;
3333 class DataLayout;
34 class TargetLibraryInfo;
3435 class TargetFrameLowering;
3536 class TargetInstrInfo;
3637 class TargetIntrinsicInfo;
0 //===- llvm/Wrap.h - C++ Type Wrapping for the C Interface -----*- C++ -*-===//
1 //
2 // The LLVM Compiler Infrastructure
3 //
4 // This file is distributed under the University of Illinois Open Source
5 // License. See LICENSE.TXT for details.
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file declares the wrapping functions for the C interface.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "llvm-c/Core.h"
14 #include "llvm/IR/BasicBlock.h"
15 #include "llvm/IR/IRBuilder.h"
16 #include "llvm/IR/Module.h"
17 #include "llvm/IR/Type.h"
18 #include "llvm/PassRegistry.h"
19
20 /* When included into a C++ source file, also declares 'wrap' and 'unwrap'
21 helpers to perform opaque reference<-->pointer conversions. These helpers
22 are shorter and more tightly typed than writing the casts by hand when
23 authoring bindings. In assert builds, they will do runtime type checking.
24
25 Need these includes to support the LLVM 'cast' template for the C++ 'wrap'
26 and 'unwrap' conversion functions. */
27
28 namespace llvm {
29 class MemoryBuffer;
30 class PassManagerBase;
31 struct GenericValue;
32 class ExecutionEngine;
33
34 #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
35 inline ty *unwrap(ref P) { \
36 return reinterpret_cast(P); \
37 } \
38 \
39 inline ref wrap(const ty *P) { \
40 return reinterpret_cast(const_cast(P)); \
41 }
42
43 #define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref) \
44 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
45 \
46 template \
47 inline T *unwrap(ref P) { \
48 return cast(unwrap(P)); \
49 }
50
51 #define DEFINE_STDCXX_CONVERSION_FUNCTIONS(ty, ref) \
52 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
53 \
54 template \
55 inline T *unwrap(ref P) { \
56 T *Q = (T*)unwrap(P); \
57 assert(Q && "Invalid cast!"); \
58 return Q; \
59 }
60
61 DEFINE_ISA_CONVERSION_FUNCTIONS (Type, LLVMTypeRef )
62 DEFINE_ISA_CONVERSION_FUNCTIONS (Value, LLVMValueRef )
63 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module, LLVMModuleRef )
64 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock, LLVMBasicBlockRef )
65 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef )
66 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef )
67 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMContext, LLVMContextRef )
68 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Use, LLVMUseRef )
69 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase, LLVMPassManagerRef )
70 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassRegistry, LLVMPassRegistryRef )
71
72 /* LLVMModuleProviderRef exists for historical reasons, but now just holds a
73 * Module.
74 */
75 inline Module *unwrap(LLVMModuleProviderRef MP) {
76 return reinterpret_cast(MP);
77 }
78
79 /* Specialized opaque context conversions.
80 */
81 inline LLVMContext **unwrap(LLVMContextRef* Tys) {
82 return reinterpret_cast(Tys);
83 }
84
85 inline LLVMContextRef *wrap(const LLVMContext **Tys) {
86 return reinterpret_cast(const_cast(Tys));
87 }
88
89 /* Specialized opaque type conversions.
90 */
91 inline Type **unwrap(LLVMTypeRef* Tys) {
92 return reinterpret_cast(Tys);
93 }
94
95 inline LLVMTypeRef *wrap(Type **Tys) {
96 return reinterpret_cast(const_cast(Tys));
97 }
98
99 /* Specialized opaque value conversions.
100 */
101 inline Value **unwrap(LLVMValueRef *Vals) {
102 return reinterpret_cast(Vals);
103 }
104
105 template
106 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
107 #ifdef DEBUG
108 for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
109 cast(*I);
110 #endif
111 (void)Length;
112 return reinterpret_cast(Vals);
113 }
114
115 inline LLVMValueRef *wrap(const Value **Vals) {
116 return reinterpret_cast(const_cast(Vals));
117 }
118 }
1717 #include "llvm/Support/DataTypes.h"
1818
1919 #ifdef __cplusplus
20
21 /* Need these includes to support the LLVM 'cast' template for the C++ 'wrap'
22 and 'unwrap' conversion functions. */
23 #include "llvm/IR/IRBuilder.h"
24 #include "llvm/IR/Module.h"
25 #include "llvm/PassRegistry.h"
26
2720 extern "C" {
2821 #endif
2922
5851 * Many exotic languages can interoperate with C code but have a harder time
5952 * with C++ due to name mangling. So in addition to C, this interface enables
6053 * tools written in such languages.
61 *
62 * When included into a C++ source file, also declares 'wrap' and 'unwrap'
63 * helpers to perform opaque reference<-->pointer conversions. These helpers
64 * are shorter and more tightly typed than writing the casts by hand when
65 * authoring bindings. In assert builds, they will do runtime type checking.
6654 *
6755 * @{
6856 */
26892677
26902678 #ifdef __cplusplus
26912679 }
2692
2693 namespace llvm {
2694 class MemoryBuffer;
2695 class PassManagerBase;
2696
2697 #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
2698 inline ty *unwrap(ref P) { \
2699 return reinterpret_cast(P); \
2700 } \
2701 \
2702 inline ref wrap(const ty *P) { \
2703 return reinterpret_cast(const_cast(P)); \
2704 }
2705
2706 #define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref) \
2707 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
2708 \
2709 template \
2710 inline T *unwrap(ref P) { \
2711 return cast(unwrap(P)); \
2712 }
2713
2714 #define DEFINE_STDCXX_CONVERSION_FUNCTIONS(ty, ref) \
2715 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
2716 \
2717 template \
2718 inline T *unwrap(ref P) { \
2719 T *Q = (T*)unwrap(P); \
2720 assert(Q && "Invalid cast!"); \
2721 return Q; \
2722 }
2723
2724 DEFINE_ISA_CONVERSION_FUNCTIONS (Type, LLVMTypeRef )
2725 DEFINE_ISA_CONVERSION_FUNCTIONS (Value, LLVMValueRef )
2726 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module, LLVMModuleRef )
2727 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock, LLVMBasicBlockRef )
2728 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef )
2729 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(MemoryBuffer, LLVMMemoryBufferRef )
2730 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMContext, LLVMContextRef )
2731 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Use, LLVMUseRef )
2732 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBase, LLVMPassManagerRef )
2733 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassRegistry, LLVMPassRegistryRef )
2734 /* LLVMModuleProviderRef exists for historical reasons, but now just holds a
2735 * Module.
2736 */
2737 inline Module *unwrap(LLVMModuleProviderRef MP) {
2738 return reinterpret_cast(MP);
2739 }
2740
2741 #undef DEFINE_STDCXX_CONVERSION_FUNCTIONS
2742 #undef DEFINE_ISA_CONVERSION_FUNCTIONS
2743 #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
2744
2745 /* Specialized opaque context conversions.
2746 */
2747 inline LLVMContext **unwrap(LLVMContextRef* Tys) {
2748 return reinterpret_cast(Tys);
2749 }
2750
2751 inline LLVMContextRef *wrap(const LLVMContext **Tys) {
2752 return reinterpret_cast(const_cast(Tys));
2753 }
2754
2755 /* Specialized opaque type conversions.
2756 */
2757 inline Type **unwrap(LLVMTypeRef* Tys) {
2758 return reinterpret_cast(Tys);
2759 }
2760
2761 inline LLVMTypeRef *wrap(Type **Tys) {
2762 return reinterpret_cast(const_cast(Tys));
2763 }
2764
2765 /* Specialized opaque value conversions.
2766 */
2767 inline Value **unwrap(LLVMValueRef *Vals) {
2768 return reinterpret_cast(Vals);
2769 }
2770
2771 template
2772 inline T **unwrap(LLVMValueRef *Vals, unsigned Length) {
2773 #ifdef DEBUG
2774 for (LLVMValueRef *I = Vals, *E = Vals + Length; I != E; ++I)
2775 cast(*I);
2776 #endif
2777 (void)Length;
2778 return reinterpret_cast(Vals);
2779 }
2780
2781 inline LLVMValueRef *wrap(const Value **Vals) {
2782 return reinterpret_cast(const_cast(Vals));
2783 }
2784 }
2785
27862680 #endif /* !defined(__cplusplus) */
27872681
27882682 #endif /* !defined(LLVM_C_CORE_H) */
136136 */
137137
138138 #ifdef __cplusplus
139 }
140
141 namespace llvm {
142 struct GenericValue;
143 class ExecutionEngine;
144
145 #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref) \
146 inline ty *unwrap(ref P) { \
147 return reinterpret_cast(P); \
148 } \
149 \
150 inline ref wrap(const ty *P) { \
151 return reinterpret_cast(const_cast(P)); \
152 }
153
154 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(GenericValue, LLVMGenericValueRef )
155 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ExecutionEngine, LLVMExecutionEngineRef)
156
157 #undef DEFINE_SIMPLE_CONVERSION_FUNCTIONS
158 }
159
139 }
160140 #endif /* defined(__cplusplus) */
161141
162142 #endif
2222 #include "llvm/Config/llvm-config.h"
2323
2424 #ifdef __cplusplus
25 #include "llvm/Object/ObjectFile.h"
26
2725 extern "C" {
2826 #endif
2927
9896
9997 #ifdef __cplusplus
10098 }
101
102 namespace llvm {
103 namespace object {
104 inline ObjectFile *unwrap(LLVMObjectFileRef OF) {
105 return reinterpret_cast(OF);
106 }
107
108 inline LLVMObjectFileRef wrap(const ObjectFile *OF) {
109 return reinterpret_cast(const_cast(OF));
110 }
111
112 inline section_iterator *unwrap(LLVMSectionIteratorRef SI) {
113 return reinterpret_cast(SI);
114 }
115
116 inline LLVMSectionIteratorRef
117 wrap(const section_iterator *SI) {
118 return reinterpret_cast
119 (const_cast(SI));
120 }
121
122 inline symbol_iterator *unwrap(LLVMSymbolIteratorRef SI) {
123 return reinterpret_cast(SI);
124 }
125
126 inline LLVMSymbolIteratorRef
127 wrap(const symbol_iterator *SI) {
128 return reinterpret_cast
129 (const_cast(SI));
130 }
131
132 inline relocation_iterator *unwrap(LLVMRelocationIteratorRef SI) {
133 return reinterpret_cast(SI);
134 }
135
136 inline LLVMRelocationIteratorRef
137 wrap(const relocation_iterator *SI) {
138 return reinterpret_cast
139 (const_cast(SI));
140 }
141
142 }
143 }
144
14599 #endif /* defined(__cplusplus) */
146100
147101 #endif
234234
235235 #ifdef __cplusplus
236236 }
237
238 namespace llvm {
239 class DataLayout;
240 class TargetLibraryInfo;
241
242 inline DataLayout *unwrap(LLVMTargetDataRef P) {
243 return reinterpret_cast(P);
244 }
245
246 inline LLVMTargetDataRef wrap(const DataLayout *P) {
247 return reinterpret_cast(const_cast(P));
248 }
249
250 inline TargetLibraryInfo *unwrap(LLVMTargetLibraryInfoRef P) {
251 return reinterpret_cast(P);
252 }
253
254 inline LLVMTargetLibraryInfoRef wrap(const TargetLibraryInfo *P) {
255 TargetLibraryInfo *X = const_cast(P);
256 return reinterpret_cast(X);
257 }
258 }
259
260237 #endif /* defined(__cplusplus) */
261238
262239 #endif
116116 /** Compile the LLVM IR stored in \p M and store the result in \p OutMemBuf. */
117117 LLVMBool LLVMTargetMachineEmitToMemoryBuffer(LLVMTargetMachineRef T, LLVMModuleRef M,
118118 LLVMCodeGenFileType codegen, char** ErrorMessage, LLVMMemoryBufferRef *OutMemBuf);
119
120
121
122119 #ifdef __cplusplus
123 }
124
125 namespace llvm {
126 class TargetMachine;
127 class Target;
128
129 inline TargetMachine *unwrap(LLVMTargetMachineRef P) {
130 return reinterpret_cast(P);
131 }
132 inline Target *unwrap(LLVMTargetRef P) {
133 return reinterpret_cast(P);
134 }
135 inline LLVMTargetMachineRef wrap(const TargetMachine *P) {
136 return reinterpret_cast(
137 const_cast(P));
138 }
139 inline LLVMTargetRef wrap(const Target * P) {
140 return reinterpret_cast(const_cast(P));
141 }
142120 }
143121 #endif
144122
8585
8686 #ifdef __cplusplus
8787 }
88
89 namespace llvm {
90 inline PassManagerBuilder *unwrap(LLVMPassManagerBuilderRef P) {
91 return reinterpret_cast(P);
92 }
93
94 inline LLVMPassManagerBuilderRef wrap(PassManagerBuilder *P) {
95 return reinterpret_cast(P);
96 }
97 }
9888 #endif
9989
10090 #endif
88
99 #include "llvm-c/Analysis.h"
1010 #include "llvm-c/Initialization.h"
11 #include "llvm/Wrap.h"
1112 #include "llvm/Analysis/Verifier.h"
1213 #include "llvm/InitializePasses.h"
1314 #include
1111 //===----------------------------------------------------------------------===//
1212
1313 #include "llvm/InitializePasses.h"
14 #include "llvm/Wrap.h"
1415 #include "llvm-c/Initialization.h"
1516
1617 using namespace llvm;
77 //===----------------------------------------------------------------------===//
88
99 #include "llvm-c/BitReader.h"
10 #include "llvm/Wrap.h"
1011 #include "llvm/Bitcode/ReaderWriter.h"
1112 #include "llvm/IR/LLVMContext.h"
1213 #include "llvm/Support/MemoryBuffer.h"
77 //===----------------------------------------------------------------------===//
88
99 #include "llvm-c/BitWriter.h"
10 #include "llvm/Wrap.h"
1011 #include "llvm/Bitcode/ReaderWriter.h"
1112 #include "llvm/Support/raw_ostream.h"
1213 using namespace llvm;
1212 //===----------------------------------------------------------------------===//
1313
1414 #include "llvm/InitializePasses.h"
15 #include "llvm/Wrap.h"
1516 #include "llvm-c/Initialization.h"
1617
1718 using namespace llvm;
1515 #include "llvm/ExecutionEngine/ExecutionEngine.h"
1616 #include "llvm/ExecutionEngine/GenericValue.h"
1717 #include "llvm/Support/ErrorHandling.h"
18 #include "llvm/Wrap.h"
1819 #include
1920
2021 using namespace llvm;
22
23 // Wrapping the C bindings types.
24 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(GenericValue, LLVMGenericValueRef )
25 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ExecutionEngine, LLVMExecutionEngineRef)
26
27 inline DataLayout *unwrap(LLVMTargetDataRef P) {
28 return reinterpret_cast(P);
29 }
30
31 inline LLVMTargetDataRef wrap(const DataLayout *P) {
32 return reinterpret_cast(const_cast(P));
33 }
34
35 inline TargetLibraryInfo *unwrap(LLVMTargetLibraryInfoRef P) {
36 return reinterpret_cast(P);
37 }
38
39 inline LLVMTargetLibraryInfoRef wrap(const TargetLibraryInfo *P) {
40 TargetLibraryInfo *X = const_cast(P);
41 return reinterpret_cast(X);
42 }
2143
2244 /*===-- Operations on generic values --------------------------------------===*/
2345
1212 //===----------------------------------------------------------------------===//
1313
1414 #include "llvm-c/Core.h"
15 #include "llvm/Wrap.h"
1516 #include "llvm/Bitcode/ReaderWriter.h"
1617 #include "llvm/IR/Attributes.h"
1718 #include "llvm/IR/Constants.h"
1111 //===----------------------------------------------------------------------===//
1212
1313 #include "llvm/Linker.h"
14 #include "llvm/Wrap.h"
1415 #include "llvm-c/Linker.h"
1516 #include "llvm/ADT/DenseSet.h"
1617 #include "llvm/ADT/Optional.h"
1313
1414 #include "llvm/Object/ObjectFile.h"
1515 #include "llvm-c/Object.h"
16 #include "llvm/Wrap.h"
1617
1718 using namespace llvm;
1819 using namespace object;
20
21 inline ObjectFile *unwrap(LLVMObjectFileRef OF) {
22 return reinterpret_cast(OF);
23 }
24
25 inline LLVMObjectFileRef wrap(const ObjectFile *OF) {
26 return reinterpret_cast(const_cast(OF));
27 }
28
29 inline section_iterator *unwrap(LLVMSectionIteratorRef SI) {
30 return reinterpret_cast(SI);
31 }
32
33 inline LLVMSectionIteratorRef
34 wrap(const section_iterator *SI) {
35 return reinterpret_cast
36 (const_cast(SI));
37 }
38
39 inline symbol_iterator *unwrap(LLVMSymbolIteratorRef SI) {
40 return reinterpret_cast(SI);
41 }
42
43 inline LLVMSymbolIteratorRef
44 wrap(const symbol_iterator *SI) {
45 return reinterpret_cast
46 (const_cast(SI));
47 }
48
49 inline relocation_iterator *unwrap(LLVMRelocationIteratorRef SI) {
50 return reinterpret_cast(SI);
51 }
52
53 inline LLVMRelocationIteratorRef
54 wrap(const relocation_iterator *SI) {
55 return reinterpret_cast
56 (const_cast(SI));
57 }
1958
2059 // ObjectFile creation
2160 LLVMObjectFileRef LLVMCreateObjectFile(LLVMMemoryBufferRef MemBuf) {
1717 #include "llvm/IR/LLVMContext.h"
1818 #include "llvm/InitializePasses.h"
1919 #include "llvm/PassManager.h"
20 #include "llvm/Wrap.h"
2021 #include "llvm/Target/TargetLibraryInfo.h"
2122 #include
2223
2324 using namespace llvm;
25
26 inline DataLayout *unwrap(LLVMTargetDataRef P) {
27 return reinterpret_cast(P);
28 }
29
30 inline LLVMTargetDataRef wrap(const DataLayout *P) {
31 return reinterpret_cast(const_cast(P));
32 }
33
34 inline TargetLibraryInfo *unwrap(LLVMTargetLibraryInfoRef P) {
35 return reinterpret_cast(P);
36 }
37
38 inline LLVMTargetLibraryInfoRef wrap(const TargetLibraryInfo *P) {
39 TargetLibraryInfo *X = const_cast(P);
40 return reinterpret_cast(X);
41 }
2442
2543 void llvm::initializeTarget(PassRegistry &Registry) {
2644 initializeDataLayoutPass(Registry);
1616 #include "llvm/IR/DataLayout.h"
1717 #include "llvm/IR/Module.h"
1818 #include "llvm/PassManager.h"
19 #include "llvm/Wrap.h"
1920 #include "llvm/Support/CodeGen.h"
2021 #include "llvm/Support/FormattedStream.h"
2122 #include "llvm/Support/TargetRegistry.h"
2728
2829 using namespace llvm;
2930
30
31 inline DataLayout *unwrap(LLVMTargetDataRef P) {
32 return reinterpret_cast(P);
33 }
34
35 inline LLVMTargetDataRef wrap(const DataLayout *P) {
36 return reinterpret_cast(const_cast(P));
37 }
38
39 inline TargetLibraryInfo *unwrap(LLVMTargetLibraryInfoRef P) {
40 return reinterpret_cast(P);
41 }
42
43 inline LLVMTargetLibraryInfoRef wrap(const TargetLibraryInfo *P) {
44 TargetLibraryInfo *X = const_cast(P);
45 return reinterpret_cast(X);
46 }
47
48 inline TargetMachine *unwrap(LLVMTargetMachineRef P) {
49 return reinterpret_cast(P);
50 }
51 inline Target *unwrap(LLVMTargetRef P) {
52 return reinterpret_cast(P);
53 }
54 inline LLVMTargetMachineRef wrap(const TargetMachine *P) {
55 return
56 reinterpret_cast(const_cast(P));
57 }
58 inline LLVMTargetRef wrap(const Target * P) {
59 return reinterpret_cast(const_cast(P));
60 }
3161
3262 LLVMTargetRef LLVMGetFirstTarget() {
3363 const Target* target = &*TargetRegistry::begin();
1616 #include "llvm-c/Transforms/IPO.h"
1717 #include "llvm/InitializePasses.h"
1818 #include "llvm/PassManager.h"
19 #include "llvm/Wrap.h"
1920 #include "llvm/Transforms/IPO.h"
2021
2122 using namespace llvm;
1818 #include "llvm/Analysis/Passes.h"
1919 #include "llvm/Analysis/Verifier.h"
2020 #include "llvm/PassManager.h"
21 #include "llvm/Wrap.h"
2122 #include "llvm/Support/CommandLine.h"
2223 #include "llvm/Support/ManagedStatic.h"
2324 #include "llvm/Target/TargetLibraryInfo.h"
329330 PM.add(createGlobalDCEPass());
330331 }
331332
333 inline PassManagerBuilder *unwrap(LLVMPassManagerBuilderRef P) {
334 return reinterpret_cast(P);
335 }
336
337 inline LLVMPassManagerBuilderRef wrap(PassManagerBuilder *P) {
338 return reinterpret_cast(P);
339 }
340
332341 LLVMPassManagerBuilderRef LLVMPassManagerBuilderCreate() {
333342 PassManagerBuilder *PMB = new PassManagerBuilder();
334343 return wrap(PMB);
5252 #include "llvm/Support/ValueHandle.h"
5353 #include "llvm/Target/TargetLibraryInfo.h"
5454 #include "llvm/Transforms/Utils/Local.h"
55 #include "llvm/Wrap.h"
5556 #include
5657 #include
5758 using namespace llvm;
1212 //===----------------------------------------------------------------------===//
1313
1414 #include "llvm/InitializePasses.h"
15 #include "llvm/Wrap.h"
1516 #include "llvm-c/Initialization.h"
1617
1718 using namespace llvm;
1616 #include "llvm-c/Core.h"
1717 #include "llvm-c/Initialization.h"
1818 #include "llvm/InitializePasses.h"
19 #include "llvm/Wrap.h"
1920 #include "llvm/Support/CommandLine.h"
2021
2122 namespace llvm {
2020 #include "llvm/IR/DataLayout.h"
2121 #include "llvm/InitializePasses.h"
2222 #include "llvm/PassManager.h"
23 #include "llvm/Wrap.h"
2324
2425 using namespace llvm;
2526
1212 //===----------------------------------------------------------------------===//
1313
1414 #include "llvm/InitializePasses.h"
15 #include "llvm/Wrap.h"
1516 #include "llvm-c/Initialization.h"
1617
1718 using namespace llvm;
1919 #include "llvm/Analysis/Verifier.h"
2020 #include "llvm/InitializePasses.h"
2121 #include "llvm/PassManager.h"
22 #include "llvm/Wrap.h"
2223
2324 using namespace llvm;
2425