plessl-llvmruby 0.0.3

data/ext/llvm_user.cpp

@@ -0,0 +1,71 @@
+#include "llvmruby.h"
+
+extern "C" {
+VALUE
+llvm_user_wrap(User *u) {
+  return Data_Wrap_Struct(cLLVMUser, NULL, NULL, u);
+}
+
+//llvm_user_get_operand_list
+VALUE
+llvm_user_get_operand_list(VALUE self) {
+  User *usr = LLVM_USER(self);
+  VALUE op_array = rb_ary_new();
+  User::op_iterator op = usr->op_begin();
+  while(op != usr->op_end()) {
+    Use *u = op++;
+    rb_ary_push(op_array, llvm_use_wrap(op));
+  }
+  return op_array;
+}
+
+
+//llvm_user_set_operand
+VALUE
+llvm_user_set_operand(VALUE self, VALUE i, VALUE val) {
+  User *u = LLVM_USER(self);
+  Value *v;
+  Data_Get_Struct(val, Value, v);
+  u->setOperand(FIX2UINT(i),v);
+  return Qtrue;
+}
+
+
+//llvm_user_get_operand
+VALUE
+llvm_user_get_operand(VALUE self, VALUE i) {
+  User *u = LLVM_USER(self);
+  return llvm_value_wrap(u->getOperand(FIX2UINT(i)));
+}
+
+
+//llvm_user_get_num_operands
+VALUE
+llvm_user_get_num_operands(VALUE self) {
+  User *u = LLVM_USER(self);
+  return INT2NUM(u->getNumOperands());
+}
+
+
+//llvm_user_drop_all_references
+VALUE
+llvm_user_drop_all_references(VALUE self) {
+  User *u = LLVM_USER(self);
+  u->dropAllReferences();
+  return Qtrue;
+}
+
+
+//llvm_user_replace_uses_of_with
+VALUE
+llvm_user_replace_uses_of_with(VALUE self, VALUE from, VALUE to) {
+  User *u = LLVM_USER(self);
+  Value *v_from, *v_to;
+  Data_Get_Struct(from, Value, v_from);
+  Data_Get_Struct(to, Value, v_to);
+  u->replaceUsesOfWith(v_from,v_to);
+  return Qtrue;
+}
+
+
+}

data/ext/llvm_value.cpp

@@ -0,0 +1,254 @@
+#include "llvmruby.h"
+
+extern "C" {
+VALUE 
+llvm_value_wrap(Value* v) { 
+  return Data_Wrap_Struct(cLLVMValue, NULL, NULL, v); 
+}
+
+VALUE
+llvm_value_name(VALUE self) {
+  Value *v;
+  Data_Get_Struct(self, Value, v);
+
+  if(v->hasName()) {
+    const char *name = v->getNameStart();
+    int len = v->getNameLen();
+    return rb_str_new(name, len);
+  } else {
+    return Qnil;
+  }
+}
+
+VALUE
+llvm_value_set_name(VALUE self, VALUE rname) {
+  Value *v;
+  Data_Get_Struct(self, Value, v);
+  v->setName(RSTRING_PTR(rname), RSTRING_LEN(rname));
+  return rname; 
+}
+
+VALUE
+llvm_value_type(VALUE self) {
+  Value *v;
+  Data_Get_Struct(self, Value, v);
+  const Type *t = v->getType();  
+  return Data_Wrap_Struct(cLLVMType, NULL, NULL, (void*) t);;
+}
+
+VALUE 
+llvm_value_num_uses(VALUE self) {
+  Value *v;
+  Data_Get_Struct(self, Value, v);
+  return INT2FIX(v->getNumUses());
+}
+
+VALUE 
+llvm_value_used_in_basic_block(VALUE self, VALUE rbb) {
+  Value *v;
+  Data_Get_Struct(self, Value, v);
+  
+  BasicBlock *bb;
+  Data_Get_Struct(rbb, BasicBlock, bb);
+
+  return v->isUsedInBasicBlock(bb) ? Qtrue : Qfalse;
+}
+
+VALUE 
+llvm_value_replace_all_uses_with(VALUE self, VALUE rv2) {
+  Value *v1, *v2;
+  Data_Get_Struct(self, Value, v1);
+  Data_Get_Struct(rv2, Value, v2);
+  v1->replaceAllUsesWith(v2);
+  return rv2;
+}
+
+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_value_is_constant(VALUE self) {
+  Value *v;
+  Data_Get_Struct(self, Value, v);
+  return isa<Constant>(v) ? Qtrue : Qfalse;
+}
+
+VALUE
+llvm_value_is_int_constant(VALUE self) {
+  Value *v;
+  Data_Get_Struct(self, Value, v);
+  return isa<ConstantInt>(v) ? Qtrue : Qfalse;
+}
+
+VALUE
+llvm_value_is_float_constant(VALUE self) {
+  Value *v;
+  Data_Get_Struct(self, Value, v);
+  return isa<ConstantFP>(v) ? Qtrue : Qfalse;
+}
+
+VALUE
+llvm_value_get_int_constant_value(VALUE self) {
+  Value *v;
+  Data_Get_Struct(self, Value, v);
+  if (ConstantInt *C = dyn_cast<ConstantInt>(v)) {
+    APInt val = C->getValue();
+    return LL2NUM(val.getLimitedValue());
+  } else {
+    rb_raise(rb_eTypeError, "Argument not an integer constant");
+  }
+}
+
+VALUE
+llvm_value_get_float_constant_value(VALUE self) {
+  Value *v;
+  Data_Get_Struct(self, Value, v);
+  if (ConstantFP *C = dyn_cast<ConstantFP>(v)) {
+    APFloat val = C->getValueAPF();
+    return rb_float_new(val.convertToFloat());
+  } else {
+    rb_raise(rb_eTypeError, "Argument not a float constant");
+  }
+}
+
+
+VALUE
+llvm_value_is_null(VALUE self) {
+  Value *v;
+  Data_Get_Struct(self, Value, v);
+  if (Constant *C = dyn_cast<Constant>(v))
+    return C->isNullValue() ? Qtrue : Qfalse;
+  return Qfalse;
+}
+
+VALUE
+llvm_value_is_undef(VALUE self) {
+  Value *v;
+  Data_Get_Struct(self, Value, v);
+  return isa<UndefValue>(v) ? Qtrue : Qfalse;
+}
+
+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);
+}
+
+VALUE 
+llvm_type_to_s(VALUE self) {
+  Type *type;
+  Data_Get_Struct(self, Type, type);
+  return rb_str_new2(type->getDescription().c_str());
+}
+
+VALUE 
+llvm_type_type_id(VALUE self) {
+  Type *type;
+  Data_Get_Struct(self, Type, type);
+  return INT2FIX((int) type->getTypeID());
+}
+
+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,328 @@
+#include "ruby.h"
+
+VALUE cLLVMRuby = Qnil;
+VALUE cLLVMValue = Qnil;
+VALUE cLLVMUser = Qnil;
+VALUE cLLVMUse = 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 cLLVMTerminatorInst = Qnil;
+VALUE cLLVMUnaryInstruction = Qnil;
+VALUE cLLVMBinaryOperator = Qnil;
+VALUE cLLVMCmpInst = Qnil;
+VALUE cLLVMICmpInst = Qnil;
+VALUE cLLVMFCmpInst = Qnil;
+VALUE cLLVMAllocationInst = Qnil;
+VALUE cLLVMFreeInst = Qnil;
+VALUE cLLVMPhi = Qnil;
+VALUE cLLVMBinaryOps = Qnil;
+VALUE cLLVMPassManager = Qnil;
+VALUE cLLVMExecutionEngine = Qnil;
+
+#define HANDLE_TERM_INST(Num, Opcode, Klass) VALUE cLLVM##Klass;
+#define HANDLE_MEMORY_INST(Num, Opcode, Klass) VALUE cLLVM##Klass;
+#include "llvm/Instruction.def"
+
+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);
+VALUE llvm_type_to_s(VALUE);
+VALUE llvm_type_type_id(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_instruction_may_read_from_memory(VALUE);
+VALUE llvm_instruction_may_write_to_memory(VALUE);
+VALUE llvm_instruction_is_identical_to(VALUE, VALUE);
+VALUE llvm_instruction_is_same_operation_as(VALUE, VALUE);
+VALUE llvm_instruction_is_used_outside_of_block(VALUE, VALUE);
+
+VALUE llvm_terminator_inst_num_successors(VALUE);
+VALUE llvm_terminator_inst_get_successor(VALUE, VALUE);
+VALUE llvm_terminator_inst_set_successor(VALUE, VALUE, VALUE);
+
+VALUE llvm_branch_inst_is_conditional(VALUE);
+VALUE llvm_branch_inst_is_unconditional(VALUE);
+VALUE llvm_branch_inst_get_condition(VALUE);
+VALUE llvm_branch_inst_set_condition(VALUE, 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_allocation_inst_is_array_allocation(VALUE);
+VALUE llvm_allocation_inst_array_size(VALUE);
+VALUE llvm_allocation_inst_allocated_type(VALUE);
+VALUE llvm_allocation_inst_alignment(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_name(VALUE);
+VALUE llvm_value_set_name(VALUE, VALUE);
+VALUE llvm_value_type(VALUE);
+VALUE llvm_value_num_uses(VALUE);
+VALUE llvm_value_used_in_basic_block(VALUE, VALUE);
+VALUE llvm_value_replace_all_uses_with(VALUE, VALUE);
+
+VALUE llvm_value_is_constant(VALUE self);
+VALUE llvm_value_is_int_constant(VALUE self);
+VALUE llvm_value_is_float_constant(VALUE self);
+VALUE llvm_value_get_int_constant_value(VALUE self);
+VALUE llvm_value_get_float_constant_value(VALUE self);
+VALUE llvm_value_is_null(VALUE self);
+VALUE llvm_value_is_undef(VALUE self);
+
+VALUE llvm_user_get_operand_list(VALUE);
+VALUE llvm_user_get_num_operands(VALUE);
+VALUE llvm_user_get_operand(VALUE, VALUE);
+VALUE llvm_user_set_operand(VALUE, VALUE, VALUE);
+VALUE llvm_user_drop_all_references(VALUE);
+VALUE llvm_user_replace_uses_of_with(VALUE, VALUE, 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);
+  cLLVMUser = rb_define_class_under(cLLVMRuby, "User", cLLVMValue);
+  cLLVMUse = rb_define_class_under(cLLVMRuby, "Use", 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", cLLVMUser);
+  cLLVMUnaryInstruction = rb_define_class_under(cLLVMRuby, "UnaryInstruction", cLLVMInstruction);
+  cLLVMBinaryOperator = rb_define_class_under(cLLVMRuby, "BinaryOperator", cLLVMInstruction);
+  cLLVMTerminatorInst = rb_define_class_under(cLLVMRuby, "TerminatorInst", cLLVMInstruction);
+  cLLVMAllocationInst = rb_define_class_under(cLLVMRuby, "AllocationInst", cLLVMInstruction);
+  cLLVMBinaryOps = rb_define_class_under(cLLVMInstruction, "BinaryOps", rb_cObject);
+
+  #define HANDLE_TERM_INST(Num, Opcode, Klass) cLLVM##Klass = rb_define_class_under(cLLVMRuby, #Klass, cLLVMTerminatorInst);
+  #include "llvm/Instruction.def"
+
+  cLLVMLoadInst = rb_define_class_under(cLLVMRuby, "LoadInst", cLLVMUnaryInstruction);
+  cLLVMStoreInst = rb_define_class_under(cLLVMRuby, "StoreInst", cLLVMInstruction);
+  cLLVMFreeInst = rb_define_class_under(cLLVMRuby, "FreeInst", cLLVMUnaryInstruction);
+  cLLVMGetElementPtrInst = rb_define_class_under(cLLVMRuby, "GetElementPtrInst", cLLVMInstruction);
+  cLLVMAllocaInst = rb_define_class_under(cLLVMRuby, "AllocaInst", cLLVMAllocationInst);
+  cLLVMMallocInst = rb_define_class_under(cLLVMRuby, "MallocInst", cLLVMAllocationInst);
+
+  cLLVMCmpInst = rb_define_class_under(cLLVMRuby, "CmpInst", cLLVMInstruction);
+  cLLVMICmpInst = rb_define_class_under(cLLVMRuby, "ICmpInst", cLLVMCmpInst);
+  cLLVMFCmpInst = rb_define_class_under(cLLVMRuby, "FCmpInst", cLLVMCmpInst);
+  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_method(cLLVMType, "to_s", llvm_type_to_s, 0);
+  rb_define_method(cLLVMType, "type_id", llvm_type_type_id, 0);
+
+  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, "name", llvm_value_name, 0);
+  rb_define_method(cLLVMValue, "name=", llvm_value_set_name, 1);
+  rb_define_method(cLLVMValue, "type", llvm_value_type, 0);
+  rb_define_method(cLLVMValue, "num_uses", llvm_value_num_uses, 0);
+  rb_define_method(cLLVMValue, "used_in_basic_block?", llvm_value_used_in_basic_block, 1);
+  rb_define_method(cLLVMValue, "replace_all_uses_with", llvm_value_replace_all_uses_with, 1);
+
+  rb_define_method(cLLVMValue, "is_constant", llvm_value_is_constant, 0);
+  rb_define_method(cLLVMValue, "is_int_constant", llvm_value_is_int_constant, 0);
+  rb_define_method(cLLVMValue, "is_float_constant", llvm_value_is_float_constant, 0);
+  rb_define_method(cLLVMValue, "get_int_constant_value", llvm_value_get_int_constant_value, 0);
+  rb_define_method(cLLVMValue, "get_float_constant_value", llvm_value_get_float_constant_value, 0);
+  rb_define_method(cLLVMValue, "is_null", llvm_value_is_null, 0);
+  rb_define_method(cLLVMValue, "is_undef", llvm_value_is_undef, 0);
+
+  rb_define_method(cLLVMUser, "get_operand_list", llvm_user_get_operand_list, 0);
+  rb_define_method(cLLVMUser, "get_num_operands", llvm_user_get_num_operands, 0);
+  rb_define_method(cLLVMUser, "get_operand", llvm_user_get_operand, 1);
+  rb_define_method(cLLVMUser, "set_operand", llvm_user_set_operand, 2);
+  rb_define_method(cLLVMUser, "drop_all_references", llvm_user_drop_all_references, 0);
+  rb_define_method(cLLVMUser, "replace_uses_of_with", llvm_user_replace_uses_of_with, 2);
+
+
+  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(cLLVMInstruction, "may_read_from_memory?", llvm_instruction_may_read_from_memory, 0);
+  rb_define_method(cLLVMInstruction, "may_write_to_memory?", llvm_instruction_may_write_to_memory, 0);
+  rb_define_method(cLLVMInstruction, "identical_to?", llvm_instruction_is_identical_to, 1);
+  rb_define_method(cLLVMInstruction, "same_operation_as?", llvm_instruction_is_same_operation_as, 1);
+  rb_define_method(cLLVMInstruction, "used_outside_of_block?", llvm_instruction_is_used_outside_of_block, 1);
+  
+  rb_define_method(cLLVMTerminatorInst, "num_successors", llvm_terminator_inst_num_successors, 0);
+  rb_define_method(cLLVMTerminatorInst, "get_successor", llvm_terminator_inst_get_successor, 1);
+  rb_define_method(cLLVMTerminatorInst, "set_successor", llvm_terminator_inst_set_successor, 2);
+
+  rb_define_method(cLLVMBranchInst, "conditional?", llvm_branch_inst_is_conditional, 0);
+  rb_define_method(cLLVMBranchInst, "unconditional?", llvm_branch_inst_is_unconditional, 0);
+  rb_define_method(cLLVMBranchInst, "condition", llvm_branch_inst_get_condition, 0);
+  rb_define_method(cLLVMBranchInst, "condition=", llvm_branch_inst_set_condition, 1);
+
+  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(cLLVMAllocationInst, "array_allocation?", llvm_allocation_inst_is_array_allocation, 0);
+  rb_define_method(cLLVMAllocationInst, "array_size", llvm_allocation_inst_array_size, 0);
+  rb_define_method(cLLVMAllocationInst, "allocated_type", llvm_allocation_inst_allocated_type, 0);
+  rb_define_method(cLLVMAllocationInst, "alignment", llvm_allocation_inst_alignment, 0);
+
+  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));
+  */
+}