type llvalue
type llbasicblock
type llbuilder
+type llmoduleprovider
type type_kind =
Void_type
llbuilder -> llvalue = "llvm_build_shufflevector"
+(*===-- Module providers --------------------------------------------------===*)
+external create_module_provider : llmodule -> llmoduleprovider
+ = "LLVMCreateModuleProviderForExistingModule"
+external dispose_module_provider : llmoduleprovider -> unit
+ = "llvm_dispose_module_provider"
+
+
(*===-- Non-Externs -------------------------------------------------------===*)
(* These functions are built using the externals, so must be declared late. *)
class. **)
type llbuilder
+(** Used to provide a module to JIT or interpreter. **)
+type llmoduleprovider
+
(** The kind of an [lltype], the result of [classify_type ty]. See the
[llvm::Type::TypeID] enumeration. **)
type type_kind =
See the method [llvm::LLVMBuilder::CreateShuffleVector]. **)
external build_shufflevector : llvalue -> llvalue -> llvalue -> string ->
llbuilder -> llvalue = "llvm_build_shufflevector"
+
+
+(*===-- Module providers --------------------------------------------------===*)
+
+(** [create_module_provider m] encapsulates [m] in a module provider and takes
+ ownership of the module. See the constructor
+ [llvm::ExistingModuleProvider::ExistingModuleProvider]. **)
+external create_module_provider : llmodule -> llmoduleprovider
+ = "LLVMCreateModuleProviderForExistingModule"
+
+(** [dispose_module_provider mp] destroys the module provider [mp] as well as
+ the contained module. **)
+external dispose_module_provider : llmoduleprovider -> unit
+ = "llvm_dispose_module_provider"
return LLVMBuildShuffleVector(Builder_val(B), V1, V2, Mask, String_val(Name));
}
+
+/*===-- Module Providers --------------------------------------------------===*/
+
+/* llmoduleprovider -> unit */
+CAMLprim value llvm_dispose_module_provider(LLVMModuleProviderRef MP) {
+ LLVMDisposeModuleProvider(MP);
+ return Val_unit;
+}
int LLVMReadBitcodeFromFile(const char *Path, LLVMModuleRef *OutModule,
char **OutMessage);
+/* Reads a module from the specified path, returning a reference to a lazy
+ module provider via the OutModule parameter. Returns 0 on success. Optionally
+ returns a human-readable error message. */
+int LLVMCreateModuleProviderFromFile(const char *Path,
+ LLVMModuleProviderRef *OutMP,
+ char **OutMessage);
+
/* Disposes of the message allocated by the bitcode reader, if any. */
void LLVMDisposeBitcodeReaderMessage(char *Message);
typedef struct LLVMOpaqueValue *LLVMValueRef;
typedef struct LLVMOpaqueBasicBlock *LLVMBasicBlockRef;
typedef struct LLVMOpaqueBuilder *LLVMBuilderRef;
+typedef struct LLVMOpaqueModuleProvider *LLVMModuleProviderRef;
typedef enum {
LLVMVoidTypeKind, /* type with no size */
LLVMValueRef V2, LLVMValueRef Mask,
const char *Name);
+/*===-- Module providers --------------------------------------------------===*/
+
+/* Encapsulates the module M in a module provider, taking ownership of the
+ * module.
+ * See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider.
+ */
+LLVMModuleProviderRef
+LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M);
+
+/* Destroys the module provider MP as well as the contained module.
+ * See the destructor llvm::ModuleProvider::~ModuleProvider.
+ */
+void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP);
+
#ifdef __cplusplus
}
namespace llvm {
+ class ModuleProvider;
+
/* Opaque module conversions
*/
inline Module *unwrap(LLVMModuleRef M) {
inline LLVMTypeHandleRef wrap(PATypeHolder *B) {
return reinterpret_cast<LLVMTypeHandleRef>(B);
}
+
+ /* Opaque module provider conversions.
+ */
+ inline ModuleProvider *unwrap(LLVMModuleProviderRef P) {
+ return reinterpret_cast<ModuleProvider*>(P);
+ }
+
+ inline LLVMModuleProviderRef wrap(ModuleProvider *P) {
+ return reinterpret_cast<LLVMModuleProviderRef>(P);
+ }
}
#endif /* !defined(__cplusplus) */
#include "llvm/DerivedTypes.h"
#include "llvm/GlobalVariable.h"
#include "llvm/TypeSymbolTable.h"
+#include "llvm/ModuleProvider.h"
#include <cassert>
using namespace llvm;
return wrap(unwrap(B)->CreateShuffleVector(unwrap(V1), unwrap(V2),
unwrap(Mask), Name));
}
+
+
+/*===-- Module providers --------------------------------------------------===*/
+
+LLVMModuleProviderRef
+LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M) {
+ return wrap(new ExistingModuleProvider(unwrap(M)));
+}
+
+void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP) {
+ delete unwrap(MP);
+}
+
end
+(*===-- Module Provider ---------------------------------------------------===*)
+
+let test_module_provider () =
+ let m = create_module "test" in
+ let mp = create_module_provider m in
+ dispose_module_provider mp
+
+
(*===-- Writer ------------------------------------------------------------===*)
let test_writer () =
suite "functions" test_functions;
suite "basic blocks" test_basic_blocks;
suite "builder" test_builder;
+ suite "module provider" test_module_provider;
suite "writer" test_writer;
exit !exit_status