tombagby-llvmruby 0.0.1

data/ext/llvm_module.cpp

@@ -0,0 +1,189 @@
+#include "llvmruby.h"
+#include "llvm/Assembly/Parser.h"
+#include "llvm/Bitcode/ReaderWriter.h"
+#include "llvm/Analysis/Verifier.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include <fstream>
+#include <sstream>
+
+extern "C" {
+
+VALUE
+llvm_module_allocate(VALUE klass) {
+  return Data_Wrap_Struct(klass, NULL, NULL, NULL);
+}
+
+VALUE
+llvm_module_initialize(VALUE self, VALUE rname) {
+  Check_Type(rname, T_STRING);
+  DATA_PTR(self) = new Module(StringValuePtr(rname));
+  return self;
+}
+
+VALUE
+llvm_module_get_or_insert_function(VALUE self, VALUE name, VALUE rtype) {
+  Check_Type(name, T_STRING);
+  CHECK_TYPE(rtype, cLLVMFunctionType);
+
+  Module *m = LLVM_MODULE(self);
+  FunctionType *type = LLVM_FUNC_TYPE(rtype);
+  Function *f = cast<Function>(m->getOrInsertFunction(StringValuePtr(name), type));
+  return llvm_function_wrap(f); 
+}
+
+VALUE
+llvm_module_get_function(VALUE self, VALUE name) {
+  Check_Type(name, T_STRING);
+  Module *m = LLVM_MODULE(self);
+  Function *f = m->getFunction(StringValuePtr(name));
+  return llvm_function_wrap(f);  
+}
+
+VALUE
+llvm_module_global_variable(VALUE self, VALUE rtype, VALUE rinitializer) {
+  Module *m = LLVM_MODULE(self);
+  Type *type = LLVM_TYPE(rtype);
+  Constant *initializer = (Constant*)DATA_PTR(rinitializer);
+  GlobalVariable *gv = new GlobalVariable(type, true, GlobalValue::InternalLinkage, initializer, "", m);
+  return llvm_value_wrap(gv);
+}
+
+
+VALUE
+llvm_module_inspect(VALUE self) {
+  Module *m = LLVM_MODULE(self);
+  std::ostringstream strstrm;
+  strstrm << *m;
+  return rb_str_new2(strstrm.str().c_str());
+}
+
+VALUE
+llvm_pass_manager_allocate(VALUE klass) {
+  return Data_Wrap_Struct(klass, NULL, NULL, NULL);
+}
+
+VALUE
+llvm_pass_manager_initialize(VALUE self) {
+  PassManager *pm = new PassManager;
+  DATA_PTR(self) = pm;
+  return self;
+}
+
+VALUE
+llvm_pass_manager_run(VALUE self, VALUE module) {
+  PassManager *pm = (PassManager*) DATA_PTR(self);
+  Module *m = LLVM_MODULE(module);
+  
+  pm->add(new TargetData(m));
+  pm->add(createVerifierPass());
+  pm->add(createLowerSetJmpPass());
+  pm->add(createRaiseAllocationsPass());
+  pm->add(createCFGSimplificationPass());
+  pm->add(createPromoteMemoryToRegisterPass());
+  pm->add(createGlobalOptimizerPass());
+  pm->add(createGlobalDCEPass());
+  pm->add(createFunctionInliningPass());
+  
+  pm->run(*m);
+  return Qtrue;
+}
+
+static ExecutionEngine *EE = NULL;
+
+VALUE
+llvm_execution_engine_get(VALUE klass, VALUE module) {
+  CHECK_TYPE(module, cLLVMModule);
+
+  Module *m = LLVM_MODULE(module);
+  ExistingModuleProvider *MP = new ExistingModuleProvider(m);
+
+  if(EE == NULL) {
+    EE = ExecutionEngine::create(MP, false);
+  } else {
+    EE->addModuleProvider(MP);
+  }
+
+  return Qtrue;
+}
+
+VALUE
+llvm_module_external_function(VALUE self, VALUE name, VALUE type) {
+  Check_Type(name, T_STRING);
+  CHECK_TYPE(type, cLLVMFunctionType);
+
+  Module *module = LLVM_MODULE(self);
+  Function *f = Function::Create(
+    LLVM_FUNC_TYPE(type), 
+    Function::ExternalLinkage, 
+    StringValuePtr(name),
+    module
+  );
+  return Data_Wrap_Struct(cLLVMFunction, NULL, NULL, f);
+}
+
+VALUE
+llvm_module_read_assembly(VALUE self, VALUE assembly) {
+  Check_Type(assembly, T_STRING);
+
+  ParseError e;
+  Module *module = ParseAssemblyString(
+    StringValuePtr(assembly),
+    LLVM_MODULE(self),
+    &e
+  );
+  //TODO How do we handle errors?
+  return Data_Wrap_Struct(cLLVMModule, NULL, NULL, module);
+}
+
+VALUE
+llvm_module_read_bitcode(VALUE self, VALUE bitcode) {
+  Check_Type(bitcode, T_STRING);
+
+  MemoryBuffer *buf = MemoryBuffer::getMemBufferCopy(RSTRING(bitcode)->ptr,RSTRING(bitcode)->ptr+RSTRING(bitcode)->len);
+  Module *module = ParseBitcodeFile(buf);
+  delete buf;
+  return Data_Wrap_Struct(cLLVMModule, NULL, NULL, module);
+}
+
+
+VALUE
+llvm_module_write_bitcode(VALUE self, VALUE file_name) {
+  Check_Type(file_name, T_STRING);
+
+  // Don't really know how to handle c++ streams well, 
+  // dumping all into string buffer and then saving
+  std::ofstream file;
+  file.open(StringValuePtr(file_name)); 
+  WriteBitcodeToFile(LLVM_MODULE(self), file);   // Convert value into a string.
+  return Qtrue;
+}
+
+VALUE
+llvm_execution_engine_run_function(int argc, VALUE *argv, VALUE klass) {
+  if(argc < 1) { rb_raise(rb_eArgError, "Expected at least one argument"); }
+  CHECK_TYPE(argv[0], cLLVMFunction);
+  Function *func = LLVM_FUNCTION(argv[0]);
+
+  // Using run function is much slower than getting C function pointer
+  // and calling that, but it lets us pass in arbitrary numbers of
+  // arguments easily for now, which is nice
+  std::vector<GenericValue> arg_values;
+  for(int i = 1; i < argc; ++i) {
+    GenericValue arg_val;
+    arg_val.IntVal = APInt(sizeof(long)*8, argv[i]);
+    arg_values.push_back(arg_val);
+  }
+
+  GenericValue v = EE->runFunction(func, arg_values);
+  VALUE val = v.IntVal.getZExtValue();
+  return val;
+}
+
+/* For tests: assume no args, return uncoverted int and turn it into fixnum */
+VALUE llvm_execution_engine_run_autoconvert(VALUE klass, VALUE func) {
+  std::vector<GenericValue> args;
+  GenericValue v = EE->runFunction(LLVM_FUNCTION(func), args);
+  VALUE val = INT2NUM(v.IntVal.getZExtValue());
+  return val;
+}
+}

data/ext/llvm_value.cpp

@@ -0,0 +1,128 @@
+#include "llvmruby.h"
+
+extern "C" {
+VALUE 
+llvm_value_wrap(Value* v) { 
+  return Data_Wrap_Struct(cLLVMValue, NULL, NULL, v); 
+}
+
+VALUE
+llvm_value_get_name(VALUE self) {
+  Value *v = LLVM_VAL(self);
+  std::string name = v->getName();
+  return rb_str_new2(name.c_str());
+}
+
+VALUE 
+llvm_value_get_constant(VALUE self, VALUE type, VALUE v) {
+  return llvm_value_wrap(ConstantInt::get(LLVM_TYPE(type), FIX2INT(v)));
+}
+
+VALUE 
+llvm_value_get_float_constant(VALUE self, VALUE v) {
+  return llvm_value_wrap(ConstantFP::get(Type::FloatTy, RFLOAT(v)->value));
+}
+
+VALUE 
+llvm_value_get_double_constant(VALUE self, VALUE v) {
+  return llvm_value_wrap(ConstantFP::get(Type::DoubleTy, RFLOAT(v)->value));
+}
+
+VALUE
+llvm_value_get_struct_constant(int argc, VALUE *argv, VALUE self) {
+  StructType *t = (StructType*)DATA_PTR(argv[0]);
+  std::vector<Constant*> vals;
+
+  for(int i = 1; i < argc; ++i) {
+    Constant *c = (Constant*)DATA_PTR(argv[i]);
+    vals.push_back(c);
+  }
+  return llvm_value_wrap(ConstantStruct::get(t, vals));
+}
+
+VALUE 
+llvm_value_get_immediate_constant(VALUE self, VALUE v) {
+  const IntegerType* type; 
+  if(sizeof(VALUE) == 4) {
+    type = Type::Int32Ty;
+  } else {
+    type = Type::Int64Ty;
+  }
+  return llvm_value_wrap(ConstantInt::get(type, (long)v));
+}
+
+VALUE 
+llvm_type_pointer(VALUE self, VALUE rtype) {
+  Type *type;
+  Data_Get_Struct(rtype, Type, type);
+  Type* ptr_type = PointerType::getUnqual(type);
+  return Data_Wrap_Struct(cLLVMPointerType, NULL, NULL, ptr_type);
+}
+
+VALUE 
+llvm_type_struct(VALUE self, VALUE rtypes, VALUE rpacked) {
+  std::vector<const Type*> types;
+
+  for(int i = 0; i < RARRAY_LEN(rtypes); ++i) {
+    VALUE v = RARRAY_PTR(rtypes)[i];
+    const Type *t;
+    Data_Get_Struct(v, Type, t);
+    types.push_back(t);
+  }
+  StructType *s = StructType::get(types);
+  return Data_Wrap_Struct(cLLVMStructType, NULL, NULL, s);
+}
+
+VALUE 
+llvm_type_array(VALUE self, VALUE rtype, VALUE size) {
+  Type *type;
+  Data_Get_Struct(rtype, Type, type);
+  type = ArrayType::get(type, FIX2INT(size)); 
+  return Data_Wrap_Struct(cLLVMArrayType, NULL, NULL, type);
+}
+
+VALUE 
+llvm_type_vector(VALUE self, VALUE rtype, VALUE size) {
+  Type *type;
+  Data_Get_Struct(rtype, Type, type);
+  type = VectorType::get(type, FIX2INT(size));
+  return Data_Wrap_Struct(cLLVMVectorType, NULL, NULL, type);
+}
+
+VALUE
+llvm_type_function(int argc, VALUE *argv, VALUE self) {
+  VALUE rret_type, rarg_types, var_args;
+
+  rb_scan_args(argc, argv, "21", &rret_type, &rarg_types, &var_args);
+
+  std::vector<const Type*> arg_types;
+  for(int i = 0; i < RARRAY_LEN(rarg_types); ++i) {
+    VALUE v = RARRAY_PTR(rarg_types)[i];
+    arg_types.push_back(LLVM_TYPE(v));
+  }
+  const Type *ret_type = LLVM_TYPE(rret_type);
+  FunctionType *ftype = FunctionType::get(ret_type, arg_types, RTEST(var_args));
+  return Data_Wrap_Struct(cLLVMFunctionType, NULL, NULL, ftype);
+}
+
+void init_types() {
+  rb_define_const(cLLVMType, "Int1Ty",  Data_Wrap_Struct(cLLVMType, NULL, NULL, const_cast<IntegerType*>(Type::Int1Ty)));
+  rb_define_const(cLLVMType, "Int8Ty",  Data_Wrap_Struct(cLLVMType, NULL, NULL, const_cast<IntegerType*>(Type::Int8Ty)));
+  rb_define_const(cLLVMType, "Int16Ty", Data_Wrap_Struct(cLLVMType, NULL, NULL, const_cast<IntegerType*>(Type::Int16Ty)));
+  rb_define_const(cLLVMType, "Int32Ty", Data_Wrap_Struct(cLLVMType, NULL, NULL, const_cast<IntegerType*>(Type::Int32Ty)));
+  rb_define_const(cLLVMType, "Int64Ty", Data_Wrap_Struct(cLLVMType, NULL, NULL, const_cast<IntegerType*>(Type::Int64Ty)));
+  rb_define_const(cLLVMType, "VoidTy",  Data_Wrap_Struct(cLLVMType, NULL, NULL, const_cast<Type*>(Type::VoidTy)));
+  rb_define_const(cLLVMType, "LabelTy",  Data_Wrap_Struct(cLLVMType, NULL, NULL, const_cast<Type*>(Type::LabelTy)));
+  rb_define_const(cLLVMType, "FloatTy",  Data_Wrap_Struct(cLLVMType, NULL, NULL, const_cast<Type*>(Type::FloatTy)));
+  rb_define_const(cLLVMType, "DoubleTy",  Data_Wrap_Struct(cLLVMType, NULL, NULL, const_cast<Type*>(Type::DoubleTy)));
+
+  // Figure out details of the target machine
+  const IntegerType *machine_word_type;
+  if(sizeof(void*) == 4) {
+    machine_word_type = Type::Int32Ty;
+  } else {
+    machine_word_type = Type::Int64Ty;
+  }
+  rb_define_const(cLLVMRuby, "MACHINE_WORD", Data_Wrap_Struct(cLLVMType, NULL, NULL, const_cast<IntegerType*>(machine_word_type)));
+}
+}

data/ext/llvmruby.c

@@ -0,0 +1,214 @@
+#include "ruby.h"
+
+VALUE cLLVMRuby = Qnil;
+VALUE cLLVMValue = Qnil;
+VALUE cLLVMModule = Qnil;
+VALUE cLLVMFunction = Qnil;
+VALUE cLLVMBasicBlock = Qnil;
+VALUE cLLVMBuilder = Qnil;
+VALUE cLLVMType = Qnil;
+VALUE cLLVMPointerType = Qnil;
+VALUE cLLVMStructType = Qnil;
+VALUE cLLVMArrayType = Qnil;
+VALUE cLLVMVectorType = Qnil;
+VALUE cLLVMFunctionType = Qnil;
+VALUE cLLVMInstruction = Qnil;
+VALUE cLLVMSwitchInst = Qnil;
+VALUE cLLVMPhi = Qnil;
+VALUE cLLVMBinaryOps = Qnil;
+VALUE cLLVMPassManager = Qnil;
+VALUE cLLVMExecutionEngine = Qnil;
+
+void init_types();
+VALUE llvm_type_pointer(VALUE, VALUE);
+VALUE llvm_type_struct(VALUE, VALUE, VALUE);
+VALUE llvm_type_array(VALUE, VALUE, VALUE);
+VALUE llvm_type_vector(VALUE, VALUE, VALUE);
+VALUE llvm_type_function2(VALUE, VALUE);
+VALUE llvm_type_function(VALUE, VALUE, VALUE);
+
+void init_instructions();
+
+VALUE llvm_module_allocate(VALUE);
+VALUE llvm_module_initialize(VALUE); 
+VALUE llvm_module_get_or_insert_function(VALUE, VALUE);
+VALUE llvm_module_get_function(VALUE, VALUE);
+VALUE llvm_module_global_variable(VALUE, VALUE, VALUE);
+VALUE llvm_module_external_function(VALUE, VALUE, VALUE);
+VALUE llvm_module_read_assembly(VALUE, VALUE);
+VALUE llvm_module_read_bitcode(VALUE, VALUE);
+VALUE llvm_module_write_bitcode(VALUE, VALUE);
+VALUE llvm_module_inspect(VALUE);
+
+VALUE llvm_function_allocate(VALUE);
+VALUE llvm_function_create_block(VALUE);
+VALUE llvm_function_arguments(VALUE);
+VALUE llvm_function_inspect(VALUE);
+VALUE llvm_function_get_basic_block_list(VALUE);
+
+VALUE llvm_basic_block_builder(VALUE);
+VALUE llvm_basic_block_size(VALUE);
+VALUE llvm_basic_block_get_instruction_list(VALUE);
+
+VALUE llvm_instruction_inspect(VALUE);
+VALUE llvm_instruction_get_opcode_name(VALUE);
+
+VALUE llvm_switch_inst_get_default_dest(VALUE);
+VALUE llvm_switch_inst_get_num_cases(VALUE);
+VALUE llvm_switch_inst_add_case(VALUE, VALUE, VALUE);
+
+VALUE llvm_builder_set_insert_point(VALUE, VALUE);
+VALUE llvm_builder_bin_op(VALUE, VALUE, VALUE, VALUE);
+VALUE llvm_builder_phi(VALUE, VALUE);
+VALUE llvm_builder_return(VALUE, VALUE);
+VALUE llvm_builder_br(VALUE, VALUE);
+VALUE llvm_builder_cond_br(VALUE, VALUE, VALUE, VALUE);
+VALUE llvm_builder_switch(VALUE, VALUE, VALUE);
+
+VALUE llvm_builder_malloc(VALUE, VALUE, VALUE);
+VALUE llvm_builder_free(VALUE, VALUE);
+VALUE llvm_builder_alloca(VALUE, VALUE, VALUE);
+VALUE llvm_builder_load(VALUE, VALUE);
+VALUE llvm_builder_store(VALUE, VALUE, VALUE);
+VALUE llvm_builder_icmp(VALUE, VALUE, VALUE, VALUE);
+VALUE llvm_builder_fcmp(VALUE, VALUE, VALUE, VALUE);
+VALUE llvm_builder_gep(VALUE, VALUE, VALUE);
+VALUE llvm_builder_struct_gep(VALUE, VALUE, VALUE);
+VALUE llvm_builder_cast(VALUE, VALUE, VALUE, VALUE);
+VALUE llvm_builder_int_to_ptr(VALUE, VALUE, VALUE);
+VALUE llvm_builder_int_cast(VALUE, VALUE, VALUE);
+VALUE llvm_builder_call(int, VALUE*, VALUE);
+VALUE llvm_builder_insert_element(VALUE, VALUE, VALUE, VALUE);
+VALUE llvm_builder_extract_element(VALUE, VALUE, VALUE);
+VALUE llvm_builder_get_global(VALUE);
+VALUE llvm_builder_create_global_string_ptr(VALUE);
+
+VALUE llvm_value_get_constant(VALUE);
+VALUE llvm_value_get_float_constant(VALUE);
+VALUE llvm_value_get_double_constant(VALUE);
+VALUE llvm_value_get_immediate_constant(VALUE);
+VALUE llvm_value_get_struct_constant(int, VALUE*, VALUE);
+VALUE llvm_value_get_name(VALUE);
+
+
+VALUE llvm_phi_add_incoming(VALUE, VALUE, VALUE);
+
+VALUE llvm_pass_manager_allocate(VALUE);
+VALUE llvm_pass_manager_initialize(VALUE);
+VALUE llvm_pass_manager_run(VALUE, VALUE);
+VALUE llvm_execution_engine_get(VALUE, VALUE);
+VALUE llvm_execution_engine_run_function(int, VALUE*, VALUE);
+VALUE llvm_execution_engine_run_autoconvert(VALUE, VALUE);
+
+void Init_llvmruby() {
+  cLLVMRuby = rb_define_module("LLVM");
+
+  cLLVMType = rb_define_class_under(cLLVMRuby, "Type", rb_cObject);
+  cLLVMPointerType = rb_define_class_under(cLLVMRuby, "PointerType", cLLVMType);
+  cLLVMStructType = rb_define_class_under(cLLVMRuby, "StructType", cLLVMType);
+  cLLVMArrayType = rb_define_class_under(cLLVMRuby, "ArrayType", cLLVMType);
+  cLLVMVectorType = rb_define_class_under(cLLVMRuby, "VectorType", cLLVMType);
+  cLLVMFunctionType = rb_define_class_under(cLLVMRuby, "FunctionType", cLLVMType);
+
+  cLLVMValue = rb_define_class_under(cLLVMRuby, "Value", rb_cObject);
+  cLLVMModule = rb_define_class_under(cLLVMRuby, "Module", rb_cObject);
+  cLLVMFunction = rb_define_class_under(cLLVMRuby, "Function", rb_cObject);
+  cLLVMBasicBlock = rb_define_class_under(cLLVMRuby, "BasicBlock", cLLVMValue);   
+  cLLVMBuilder = rb_define_class_under(cLLVMRuby, "Builder", rb_cObject);
+
+  cLLVMInstruction = rb_define_class_under(cLLVMRuby, "Instruction", rb_cObject);
+  cLLVMSwitchInst = rb_define_class_under(cLLVMRuby, "SwitchInst", cLLVMInstruction);
+  cLLVMBinaryOps = rb_define_class_under(cLLVMInstruction, "BinaryOps", rb_cObject);
+  cLLVMPhi = rb_define_class_under(cLLVMRuby, "Phi", cLLVMValue);
+
+  cLLVMPassManager = rb_define_class_under(cLLVMRuby, "PassManager", rb_cObject);
+  cLLVMExecutionEngine = rb_define_class_under(cLLVMRuby, "ExecutionEngine", rb_cObject);
+
+  init_types();
+  rb_define_module_function(cLLVMType, "pointer", llvm_type_pointer, 1);
+  rb_define_module_function(cLLVMType, "struct", llvm_type_struct, 1);
+  rb_define_module_function(cLLVMType, "array", llvm_type_array, 2);
+  rb_define_module_function(cLLVMType, "vector", llvm_type_vector, 2);
+  rb_define_module_function(cLLVMType, "function", llvm_type_function, -1);
+
+  rb_define_module_function(cLLVMValue, "get_constant", llvm_value_get_constant, 2);
+  rb_define_module_function(cLLVMValue, "get_float_constant", llvm_value_get_float_constant, 1);
+  rb_define_module_function(cLLVMValue, "get_double_constant", llvm_value_get_double_constant, 1);
+  rb_define_module_function(cLLVMValue, "get_immediate_constant", llvm_value_get_immediate_constant, 1);
+  rb_define_module_function(cLLVMValue, "get_struct_constant", llvm_value_get_struct_constant, -1);
+  rb_define_method(cLLVMValue, "get_name", llvm_value_get_name, 0);
+
+  init_instructions();
+
+  rb_define_alloc_func(cLLVMModule, llvm_module_allocate);
+  rb_define_module_function(cLLVMModule, "read_assembly", llvm_module_read_assembly, 1);
+  rb_define_module_function(cLLVMModule, "read_bitcode", llvm_module_read_bitcode, 1);
+  rb_define_method(cLLVMModule, "initialize", llvm_module_initialize, 1);
+  rb_define_method(cLLVMModule, "get_or_insert_function", llvm_module_get_or_insert_function, 2);
+  rb_define_method(cLLVMModule, "get_function", llvm_module_get_function, 1);
+  rb_define_method(cLLVMModule, "global_variable", llvm_module_global_variable, 2);
+  rb_define_method(cLLVMModule, "external_function", llvm_module_external_function, 2);
+  rb_define_method(cLLVMModule, "write_bitcode", llvm_module_write_bitcode, 1);
+  rb_define_method(cLLVMModule, "inspect", llvm_module_inspect, 0);
+
+  rb_define_method(cLLVMFunction, "create_block", llvm_function_create_block, 0);
+  rb_define_method(cLLVMFunction, "arguments", llvm_function_arguments, 0);
+  rb_define_method(cLLVMFunction, "inspect", llvm_function_inspect, 0);
+  rb_define_method(cLLVMFunction, "get_basic_block_list", llvm_function_get_basic_block_list, 0);
+
+  rb_define_method(cLLVMBasicBlock, "builder", llvm_basic_block_builder, 0);
+  rb_define_method(cLLVMBasicBlock, "size", llvm_basic_block_size, 0);
+  rb_define_method(cLLVMBasicBlock, "get_instruction_list", llvm_basic_block_get_instruction_list, 0);
+
+  rb_define_method(cLLVMInstruction, "inspect", llvm_instruction_inspect, 0);
+  rb_define_method(cLLVMInstruction, "get_opcode_name", llvm_instruction_get_opcode_name, 0);
+
+  rb_define_method(cLLVMSwitchInst, "get_default_dest", llvm_switch_inst_get_default_dest, 0);
+  rb_define_method(cLLVMSwitchInst, "get_num_cases", llvm_switch_inst_get_num_cases, 0);
+  rb_define_method(cLLVMSwitchInst, "add_case", llvm_switch_inst_add_case, 2);
+
+  rb_define_method(cLLVMBuilder, "set_insert_point", llvm_builder_set_insert_point, 1);
+  rb_define_method(cLLVMBuilder, "bin_op", llvm_builder_bin_op, 3);
+  rb_define_method(cLLVMBuilder, "phi", llvm_builder_phi, 1);
+  rb_define_method(cLLVMBuilder, "return", llvm_builder_return, 1);
+  rb_define_method(cLLVMBuilder, "br", llvm_builder_br, 1);
+  rb_define_method(cLLVMBuilder, "cond_br", llvm_builder_cond_br, 3);
+  rb_define_method(cLLVMBuilder, "switch", llvm_builder_switch, 2);
+  rb_define_method(cLLVMBuilder, "malloc", llvm_builder_malloc, 2);
+  rb_define_method(cLLVMBuilder, "free", llvm_builder_free, 1);
+  rb_define_method(cLLVMBuilder, "alloca", llvm_builder_alloca, 2);
+  rb_define_method(cLLVMBuilder, "load", llvm_builder_load, 1);
+  rb_define_method(cLLVMBuilder, "store", llvm_builder_store, 2);
+  rb_define_method(cLLVMBuilder, "icmp", llvm_builder_icmp, 3);
+  rb_define_method(cLLVMBuilder, "fcmp", llvm_builder_fcmp, 3);
+
+  rb_define_method(cLLVMBuilder, "gep", llvm_builder_gep, 2);
+  rb_define_method(cLLVMBuilder, "struct_gep", llvm_builder_struct_gep, 2);
+  rb_define_method(cLLVMBuilder, "cast", llvm_builder_cast, 3);
+  rb_define_method(cLLVMBuilder, "int_to_ptr", llvm_builder_int_to_ptr, 2);
+  rb_define_method(cLLVMBuilder, "int_cast", llvm_builder_int_cast, 3);
+  rb_define_method(cLLVMBuilder, "call", llvm_builder_call, -1);
+  rb_define_method(cLLVMBuilder, "insert_element", llvm_builder_insert_element, 3);
+  rb_define_method(cLLVMBuilder, "extract_element", llvm_builder_extract_element, 2);
+  rb_define_method(cLLVMBuilder, "get_global", llvm_builder_get_global, 0);
+  rb_define_method(cLLVMBuilder, "create_global_string_ptr", llvm_builder_create_global_string_ptr, 1);
+
+  rb_define_method(cLLVMPhi, "add_incoming", llvm_phi_add_incoming, 2);
+
+  rb_define_alloc_func(cLLVMModule, llvm_pass_manager_allocate);
+  rb_define_method(cLLVMPassManager, "initialize", llvm_pass_manager_initialize, 0);
+  rb_define_method(cLLVMPassManager, "run", llvm_pass_manager_run, 1);
+
+  rb_define_module_function(cLLVMExecutionEngine, "get", llvm_execution_engine_get, 1);
+  rb_define_module_function(cLLVMExecutionEngine, "run_function", llvm_execution_engine_run_function, -1);
+  rb_define_module_function(cLLVMExecutionEngine, "run_autoconvert", llvm_execution_engine_run_autoconvert, 1);
+
+  /*
+  printf("sizeof long: %d\n", (int)sizeof(long));
+  printf("sizeof ptr: %d\n", (int)sizeof(long*));
+  printf("sizeof value: %d\n", (int)sizeof(VALUE));
+  printf("sizeof array: %d\n", (int)sizeof(struct RArray));
+  printf("sizeof int: %d\n", (int)sizeof(int));
+  printf("sizeof char: %d\n", (int)sizeof(char));
+  */
+}

data/ext/llvmruby.h

@@ -0,0 +1,60 @@
+#define __STDC_LIMIT_MACROS
+
+#include "llvm/Module.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/Constants.h"
+#include "llvm/Instructions.h"
+#include "llvm/ModuleProvider.h"
+#include "llvm/PassManager.h"
+#include "llvm/LinkAllPasses.h"
+#include "llvm/Target/TargetData.h"
+#include "llvm/Transforms/Scalar.h"
+#include "llvm/Analysis/Verifier.h"
+#include "llvm/ExecutionEngine/JIT.h"
+#include "llvm/ExecutionEngine/Interpreter.h"
+#include "llvm/ExecutionEngine/GenericValue.h"
+#include "llvm/Support/IRBuilder.h"
+#include <iostream>
+using namespace llvm;
+
+#include "ruby.h"
+
+extern VALUE cLLVMRuby;
+extern VALUE cLLVMValue;
+extern VALUE cLLVMModule;
+extern VALUE cLLVMFunction;
+extern VALUE cLLVMBasicBlock;
+extern VALUE cLLVMBuilder;
+extern VALUE cLLVMType;
+extern VALUE cLLVMPointerType;
+extern VALUE cLLVMStructType;
+extern VALUE cLLVMArrayType;
+extern VALUE cLLVMVectorType;
+extern VALUE cLLVMFunctionType;
+extern VALUE cLLVMInstruction;
+extern VALUE cLLVMSwitchInst;
+extern VALUE cLLVMBinaryOps;
+extern VALUE cLLVMPhi;
+extern VALUE cLLVMPassManager;
+
+#define LLVM_VAL(obj) ((Value*)DATA_PTR(obj))
+#define LLVM_TYPE(obj) ((Type*)DATA_PTR(obj))
+#define LLVM_FUNC_TYPE(obj) ((FunctionType*)DATA_PTR(obj))
+#define LLVM_MODULE(obj) ((Module*)DATA_PTR(obj))
+#define LLVM_FUNCTION(obj) ((Function*)DATA_PTR(obj))
+#define LLVM_BASIC_BLOCK(obj) ((BasicBlock*)DATA_PTR(obj))
+#define LLVM_INSTRUCTION(obj) ((Instruction*)DATA_PTR(obj))
+#define LLVM_PHI(obj) ((PHINode*)DATA_PTR(obj))
+
+#define CHECK_TYPE(val, klass)\
+  if(CLASS_OF(val) != klass) {\
+    rb_raise(rb_eTypeError, "wrong argument type: %s given, expected %s", rb_obj_classname(val), rb_class2name(klass));\
+  }
+
+extern "C" {
+VALUE llvm_value_wrap(Value*);
+VALUE llvm_function_wrap(Function*);
+VALUE llvm_basic_block_wrap(BasicBlock*);
+VALUE llvm_function_create_block(VALUE);
+VALUE llvm_instruction_wrap(Instruction*);
+}