plessl-llvmruby 0.0.3

data/ext/llvm_instruction.cpp

@@ -0,0 +1,259 @@
+#include "llvmruby.h" 
+#include <sstream>
+
+extern VALUE cLLVMInstruction;
+extern VALUE cLLVMBinaryOps;
+
+extern "C" {
+
+#define LAST_INSTRUCTION_NUM 100
+VALUE gInstructionClasses[LAST_INSTRUCTION_NUM];
+
+#define DATA_GET_INSTRUCTION Instruction *i; Data_Get_Struct(self, Instruction, i);
+
+VALUE
+llvm_instruction_wrap(Instruction* i) {
+   return Data_Wrap_Struct(gInstructionClasses[i->getOpcode()], NULL, NULL, i);
+}
+
+VALUE
+llvm_instruction_inspect(VALUE self) {
+  Instruction *i = LLVM_INSTRUCTION(self);
+  std::ostringstream strstrm;
+  strstrm << *i;
+  return rb_str_new2(strstrm.str().c_str());
+}
+
+VALUE
+llvm_instruction_get_opcode_name(VALUE self) {
+  Instruction *i = LLVM_INSTRUCTION(self);
+  std::string name = i->getOpcodeName();
+  return rb_str_new2(name.c_str());
+}
+
+VALUE 
+llvm_instruction_may_read_from_memory(VALUE self) {
+  DATA_GET_INSTRUCTION
+  return i->mayReadFromMemory() ? Qtrue : Qfalse;
+}
+
+VALUE 
+llvm_instruction_may_write_to_memory(VALUE self) {
+  DATA_GET_INSTRUCTION
+  return i->mayWriteToMemory() ? Qtrue : Qfalse;
+}
+
+VALUE
+llvm_instruction_is_identical_to(VALUE self, VALUE ri2) {
+  DATA_GET_INSTRUCTION
+  CHECK_TYPE(ri2, cLLVMInstruction);
+  Instruction *i2 = LLVM_INSTRUCTION(ri2);
+  return i->isIdenticalTo(i2) ? Qtrue : Qfalse;
+}
+
+VALUE 
+llvm_instruction_is_same_operation_as(VALUE self, VALUE ri2) {
+  DATA_GET_INSTRUCTION
+  CHECK_TYPE(ri2, cLLVMInstruction);
+  Instruction *i2 = LLVM_INSTRUCTION(ri2);
+  return i->isSameOperationAs(i2) ? Qtrue : Qfalse;
+}
+
+VALUE
+llvm_instruction_is_used_outside_of_block(VALUE self, VALUE rbb) {
+  DATA_GET_INSTRUCTION
+  CHECK_TYPE(rbb, cLLVMBasicBlock);
+  BasicBlock *bb = LLVM_BASIC_BLOCK(rbb);
+  return i->isUsedOutsideOfBlock(bb) ? Qtrue: Qfalse;
+}
+
+#define DATA_GET_TERMINATOR_INST TerminatorInst *ti; Data_Get_Struct(self, TerminatorInst, ti);
+
+VALUE
+llvm_terminator_inst_num_successors(VALUE self) {
+  DATA_GET_TERMINATOR_INST
+  return INT2FIX(ti->getNumSuccessors());
+}
+
+VALUE
+llvm_terminator_inst_get_successor(VALUE self, VALUE ridx) {
+  DATA_GET_TERMINATOR_INST
+  BasicBlock *bb = ti->getSuccessor(FIX2INT(ridx));
+  return llvm_basic_block_wrap(bb);
+}
+
+VALUE
+llvm_terminator_inst_set_successor(VALUE self, VALUE ridx, VALUE rbb) {
+  DATA_GET_TERMINATOR_INST
+ 
+  BasicBlock *bb;
+  Data_Get_Struct(rbb, BasicBlock, bb);
+
+  ti->setSuccessor(FIX2INT(ridx), bb);
+  return rbb;
+}
+
+#define DATA_GET_BRANCH_INST BranchInst *bi; Data_Get_Struct(self, BranchInst, bi);
+
+VALUE
+llvm_branch_inst_is_unconditional(VALUE self) {
+  DATA_GET_BRANCH_INST
+  return bi->isUnconditional() ? Qtrue : Qfalse;
+}
+
+VALUE
+llvm_branch_inst_is_conditional(VALUE self) {
+  DATA_GET_BRANCH_INST
+  return bi->isConditional() ? Qtrue : Qfalse;
+}
+
+VALUE
+llvm_branch_inst_get_condition(VALUE self) {
+  DATA_GET_BRANCH_INST
+  return llvm_value_wrap(bi->getCondition()); 
+}
+
+VALUE
+llvm_branch_inst_set_condition(VALUE self, VALUE rv) {
+  DATA_GET_BRANCH_INST
+  
+  Value *v;
+  Data_Get_Struct(rv, Value, v);
+
+  bi->setCondition(v);
+  return rv;
+}
+
+#define DATA_GET_SWITCH_INST SwitchInst *si; Data_Get_Struct(self, SwitchInst, si);
+
+VALUE
+llvm_switch_inst_get_default_dest(VALUE self) {
+  DATA_GET_SWITCH_INST
+  BasicBlock *bb = si->getDefaultDest();
+  return llvm_basic_block_wrap(bb); 
+}
+
+VALUE
+llvm_switch_inst_get_num_cases(VALUE self) {
+  DATA_GET_SWITCH_INST
+  return INT2FIX(si->getNumCases());
+}
+
+VALUE
+llvm_switch_inst_add_case(VALUE self, VALUE rci, VALUE rbb) {
+  DATA_GET_SWITCH_INST
+  
+  ConstantInt *ci;
+  Data_Get_Struct(rci, ConstantInt, ci);
+
+  BasicBlock *bb;
+  Data_Get_Struct(rbb, BasicBlock, bb);
+
+  si->addCase(ci, bb);
+  return self;
+}
+
+#define DATA_GET_ALLOCATION_INST AllocationInst *ai; Data_Get_Struct(self, AllocationInst, ai);
+
+VALUE 
+llvm_allocation_inst_is_array_allocation(VALUE self) {
+  DATA_GET_ALLOCATION_INST
+  return ai->isArrayAllocation() ? true : false;
+}
+
+VALUE 
+llvm_allocation_inst_array_size(VALUE self) {
+  DATA_GET_ALLOCATION_INST
+  return llvm_value_wrap(ai->getArraySize());
+}
+
+VALUE 
+llvm_allocation_inst_allocated_type(VALUE self) {
+  DATA_GET_ALLOCATION_INST
+  Type *at = const_cast<Type*>(ai->getAllocatedType()); 
+  return Data_Wrap_Struct(cLLVMType, NULL, NULL, at);
+}
+
+VALUE 
+llvm_allocation_inst_alignment(VALUE self) {
+  DATA_GET_ALLOCATION_INST
+  return INT2FIX(ai->getAlignment());
+}
+
+#define DEFINE_INST(type, name) rb_define_const(cLLVMInstruction, #name, INT2FIX(Instruction::name));
+#define DEFINE_BINARY_INST(name) DEFINE_INST(cLLVMBinaryOps, name)
+#define DEFINE_PRED(name) rb_define_const(cLLVMInstruction, #name, INT2FIX(ICmpInst::name));
+#define DEFINE_FPRED(name) rb_define_const(cLLVMInstruction, #name, INT2FIX(FCmpInst::name));
+#define DEFINE_CAST(name) rb_define_const(cLLVMInstruction, #name, INT2FIX(Instruction::name));
+
+void init_instructions() {
+  for(int i = 0; i < LAST_INSTRUCTION_NUM; ++i) {
+    gInstructionClasses[i] = cLLVMInstruction;
+  }
+
+  // Need to be able to quickly look up at runtime Ruby classes cooresponding to LLVM classes
+  #define HANDLE_TERM_INST(Num, Opcode, Klass) gInstructionClasses[Num] = cLLVM##Klass;
+  #define HANDLE_BINARY_INST(Num, Opcode, Klass) gInstructionClasses[Num] = cLLVM##Klass; 
+  #define HANDLE_MEMORY_INST(Num, Opcode, Klass) gInstructionClasses[Num] = cLLVM##Klass;
+  #include "llvm/Instruction.def"
+  
+  // Standard binary operators
+  DEFINE_BINARY_INST(Add)
+  DEFINE_BINARY_INST(Sub)
+  DEFINE_BINARY_INST(Mul)
+  DEFINE_BINARY_INST(UDiv)
+  DEFINE_BINARY_INST(SDiv)
+  DEFINE_BINARY_INST(FDiv)
+  DEFINE_BINARY_INST(URem)
+  DEFINE_BINARY_INST(SRem)
+  DEFINE_BINARY_INST(FRem)
+
+  // Logical operators (integer operands)
+  DEFINE_BINARY_INST(Shl) // Shift left  (logical)
+  DEFINE_BINARY_INST(LShr) // Shift right (logical)
+  DEFINE_BINARY_INST(AShr) // shift right (arithmetic)
+  DEFINE_BINARY_INST(And)
+  DEFINE_BINARY_INST(Or)
+  DEFINE_BINARY_INST(Xor)
+
+  // Integer predicates
+  DEFINE_PRED(ICMP_EQ) // equal
+  DEFINE_PRED(ICMP_NE) // not equal
+  DEFINE_PRED(ICMP_UGT) // unsigned greater than
+  DEFINE_PRED(ICMP_UGE) // unsigned greater or equal
+  DEFINE_PRED(ICMP_ULT) // unsigned less than
+  DEFINE_PRED(ICMP_ULE) // unsigned less or equal
+  DEFINE_PRED(ICMP_SGT) // signed greater than
+  DEFINE_PRED(ICMP_SGE) // signed greater or equal
+  DEFINE_PRED(ICMP_SLT) // signed less than
+  DEFINE_PRED(ICMP_SLE) // signed less or equal
+
+  DEFINE_FPRED(FCMP_OEQ)
+  DEFINE_FPRED(FCMP_OGT)
+  DEFINE_FPRED(FCMP_OGE)
+  DEFINE_FPRED(FCMP_OLT)
+  DEFINE_FPRED(FCMP_OLE)
+  DEFINE_FPRED(FCMP_ONE)
+  DEFINE_FPRED(FCMP_ORD)
+  DEFINE_FPRED(FCMP_UNO)
+  DEFINE_FPRED(FCMP_UEQ)
+  DEFINE_FPRED(FCMP_UGT)
+  DEFINE_FPRED(FCMP_UGE)
+  DEFINE_FPRED(FCMP_ULT)
+  DEFINE_FPRED(FCMP_ULE)
+  DEFINE_FPRED(FCMP_UNE)
+
+  DEFINE_CAST(Trunc)
+  DEFINE_CAST(ZExt)
+  DEFINE_CAST(SExt)
+  DEFINE_CAST(FPToUI)
+  DEFINE_CAST(FPToSI)
+  DEFINE_CAST(UIToFP)
+  DEFINE_CAST(SIToFP)
+  DEFINE_CAST(FPTrunc)
+  DEFINE_CAST(FPExt)
+  DEFINE_CAST(PtrToInt)
+  DEFINE_CAST(IntToPtr)
+  DEFINE_CAST(BitCast)
+}
+}

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_use.cpp

@@ -0,0 +1,9 @@
+#include "llvmruby.h"
+
+extern "C" {
+VALUE
+llvm_use_wrap(Use *u) {
+  return Data_Wrap_Struct(cLLVMUse, NULL, NULL, u);
+}
+
+}