tombagby-llvmruby 0.0.1

data/COPYING

@@ -0,0 +1,21 @@
+Copyright (c) 2008 Thomas Bagby 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README

@@ -0,0 +1,76 @@
+* What's LLVMRuby
+
+LLVMRuby is a set of bindings making the LLVM compiler infrastructure 
+(http://llvm.org) usable from Ruby.  This extention allows using LLVM
+as an abstract assembler and reflects a good chunk of the LLVM class
+hierarchy into Ruby.  Included is an example of using this to build
+a simple JIT compiler, written entirely in Ruby, which is able to 
+interact with the native Ruby 1.8/1.9 data types.
+
+* How to build
+
+You must get LLVM from svn and build it separately:
+
+  $ svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm 
+
+Make sure that you configure LLVM with PIC enabled:
+  
+  $ ./configure --enable-pic
+
+Add the llvm bin directory to your path, extconf needs to be able to find llvm-conf:
+
+  $ export PATH=$PATH:/$LLVMDIR/Debug/bin
+
+Once you have built LLVM, run extconf.rb giving it location of LLVM:
+
+  $ ruby extconf.rb --with-llvm-include=/$DIR/llvm/include --with-llvm-lib=/$DIR/llvm/Debug/lib
+
+Run make
+
+  $ make
+
+Run the tests (you will need Rake installed)
+
+  $ rake test
+
+Look in test.rb to see examples of use and start messing around.
+
+* Caveats
+
+I created this using very latest LLVM (from svn, soon to be 2.4).  Other 
+versions may not work.  I have been trying to get the 2.3 released package 
+to work, only one conditional typedef is required, but it complaining about 
+fPIC stuff :(
+
+I primarily develop this on my home machine which is 64bit Fedora.  I 
+occasionally test it on a 32bit CentOS machine, and recently tested it 
+on a 32bit MacBook.  It built and passed tests with no issues.  My
+knowledge of building either Ruby or LLVM on Windows is minimal.  It
+should be doable, but I don't believe LLVM currently is usable with
+VC++, which is the main compiler for Ruby on Windows, so you may run
+into fun times trying to figure out a good way to make that go.
+
+* Things that definitely do not work right now
+
+No attempt has been made to properly free LLVM objects.  This probably
+isn't hard, LLVM api has easy to deal with memory management.  Many LLVM
+objects end up owned by modules/execution engine and shouldn't be freed
+normally anyway.
+
+There needs to be a lot more exception raising when arguments are of wrong
+number/type.
+
+Malformed LLVM functions will cause the program to abort, even just 
+from calling verify on a module.  This seems like a bug in LLVM.
+Verification in theory is slow and should be used only for debugging, but
+it would nice if tests did not abort and die because of missing block
+terminators or whatever. 
+
+* Copying
+
+See the file COPYING
+
+* Author
+
+For questions or answers, my email is: tomatobagby@gmail.com
+

data/Rakefile

@@ -0,0 +1,31 @@
+require 'rake/testtask'
+
+desc "Run the tests"
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'ext'
+  t.test_files = FileList['test/test*.rb']
+  t.warning = true
+end
+
+OBJ = "ext/llvmruby." + Config::CONFIG["DLEXT"]
+
+file "ext/Makefile" do
+  #cmd = "extconf.rb --with-llvm-include=`llvm-config --includedir` --with-llvm-lib=`llvm-config --libdir`"
+  cmd = 'extconf.rb'
+  Dir.chdir("ext") { ruby(cmd) }
+end
+
+file OBJ => %w(ext/Makefile) + FileList["ext/*.{cpp,c,h}"] do
+  Dir.chdir("ext") { sh "make" }
+end
+
+desc "Compile llvmruby extensions"
+task :compile => OBJ
+task :default => :compile
+
+desc "Remove compiled files"
+task :clean do |t|
+  for file in FileList.new("ext/*.o", "ext/Makefile", "ext/mkmf.log", OBJ)
+    File.delete(file) rescue true
+  end
+end

data/ext/extconf.rb

@@ -0,0 +1,14 @@
+require 'mkmf'
+
+extension_name = 'llvmruby'
+
+dir_config(extension_name)
+dir_config('llvm', `llvm-config --includedir`.strip, `llvm-config --libdir`.strip)
+
+have_library('stdc++')
+have_library('pthread')
+
+with_ldflags(`llvm-config --libs all`) do 
+  create_makefile(extension_name)
+end
+

data/ext/llvm_basicblock.cpp

@@ -0,0 +1,296 @@
+#include "llvmruby.h"
+
+extern VALUE cLLVMBasicBlock;
+extern VALUE cLLVMBuilder;
+
+extern "C" {
+VALUE 
+llvm_basic_block_wrap(BasicBlock* bb) { 
+  return Data_Wrap_Struct(cLLVMBasicBlock, NULL, NULL, bb); 
+}
+
+VALUE
+llvm_basic_block_size(VALUE self) {
+  BasicBlock *bb = LLVM_BASIC_BLOCK(self);
+  return INT2NUM(bb->size());
+}
+
+VALUE
+llvm_basic_block_get_instruction_list(VALUE self) {
+  BasicBlock *bb = LLVM_BASIC_BLOCK(self);
+  VALUE ins_array = rb_ary_new();
+  BasicBlock::iterator ins = bb->begin();
+  while(ins != bb->end()) {
+    Instruction *i = ins++;
+    rb_ary_push(ins_array, llvm_instruction_wrap(i));
+  }
+  return ins_array;
+}
+
+VALUE 
+llvm_basic_block_builder(VALUE self) {
+  BasicBlock* bb;
+  Data_Get_Struct(self, BasicBlock, bb);
+  IRBuilder<> *builder = new IRBuilder<>(bb);
+  return Data_Wrap_Struct(cLLVMBuilder, NULL, NULL, builder);
+}
+
+#define DATA_GET_BUILDER IRBuilder<> *builder; Data_Get_Struct(self, IRBuilder<>, builder);
+#define DATA_GET_BLOCK   BasicBlock *bb; CHECK_TYPE(rbb, cLLVMBasicBlock); Data_Get_Struct(rbb, BasicBlock, bb);
+
+VALUE
+llvm_builder_set_insert_point(VALUE self, VALUE rbb) {
+  DATA_GET_BUILDER
+  DATA_GET_BLOCK 
+  builder->SetInsertPoint(bb);
+  return self;
+}
+
+VALUE 
+llvm_builder_bin_op(VALUE self, VALUE rbin_op, VALUE rv1, VALUE rv2) {
+  Check_Type(rbin_op, T_FIXNUM);
+  //CHECK_TYPE(rv1, cLLVMValue);
+  //CHECK_TYPE(rv2, cLLVMValue);
+  DATA_GET_BUILDER
+
+  Instruction::BinaryOps bin_op = (Instruction::BinaryOps)FIX2INT(rbin_op);
+  
+  Value *v1, *v2; 
+  Data_Get_Struct(rv1, Value, v1);
+  Data_Get_Struct(rv2, Value, v2);
+  Value *res = builder->CreateBinOp(bin_op, v1, v2);
+  return llvm_value_wrap(res);
+}
+
+VALUE
+llvm_builder_phi(VALUE self, VALUE type) {
+  CHECK_TYPE(type, cLLVMType);
+  DATA_GET_BUILDER
+  PHINode *v = builder->CreatePHI(LLVM_TYPE(type)); 
+  return Data_Wrap_Struct(cLLVMPhi, NULL, NULL, v);
+}
+
+VALUE
+llvm_phi_add_incoming(VALUE self, VALUE val, VALUE rbb) {
+  CHECK_TYPE(val, cLLVMValue);
+  DATA_GET_BLOCK
+  PHINode *phi = LLVM_PHI(self);
+  phi->addIncoming(LLVM_VAL(val), bb);
+  return self;
+}
+
+VALUE 
+llvm_builder_return(VALUE self, VALUE rv) {
+  //CHECK_TYPE(rv, cLLVMValue);
+  DATA_GET_BUILDER
+  return llvm_value_wrap(builder->CreateRet(LLVM_VAL(rv)));
+}
+
+VALUE 
+llvm_builder_br(VALUE self, VALUE rblock) {
+  DATA_GET_BUILDER
+
+  BasicBlock *bb;
+  Data_Get_Struct(rblock, BasicBlock, bb);
+  return llvm_value_wrap(builder->CreateBr(bb)); 
+}  
+
+VALUE 
+llvm_builder_cond_br(VALUE self, VALUE rcond, VALUE rtrue_block, VALUE rfalse_block) {
+  DATA_GET_BUILDER
+
+  Value *cond;
+  Data_Get_Struct(rcond, Value, cond);
+
+  BasicBlock *true_block, *false_block;
+  Data_Get_Struct(rtrue_block, BasicBlock, true_block);
+  Data_Get_Struct(rfalse_block, BasicBlock, false_block);
+
+  return llvm_value_wrap(builder->CreateCondBr(cond, true_block, false_block));
+}
+
+VALUE
+llvm_builder_switch(VALUE self, VALUE rv, VALUE rdefault) {
+  DATA_GET_BUILDER
+
+  BasicBlock *deflt;
+  Data_Get_Struct(rdefault, BasicBlock, deflt);
+
+  Value *v;
+  Data_Get_Struct(rv, Value, v);
+
+  Value* switch_instr = builder->CreateSwitch(v, deflt);
+  return Data_Wrap_Struct(cLLVMSwitchInst, NULL, NULL, switch_instr);
+}
+
+VALUE
+llvm_builder_malloc(VALUE self, VALUE rtype, VALUE rsize) {
+  DATA_GET_BUILDER
+
+  const Type *type;
+  Data_Get_Struct(rtype, Type, type);
+
+  Value *size = ConstantInt::get(Type::Int32Ty, FIX2INT(rsize));
+  Value *v = builder->CreateMalloc(type, size);
+  return llvm_value_wrap(v);
+}
+
+VALUE
+llvm_builder_free(VALUE self, VALUE rptr) {
+   DATA_GET_BUILDER
+   Value *v = LLVM_VAL(rptr);
+   builder->CreateFree(v);
+   return Qtrue;
+}
+  
+VALUE 
+llvm_builder_alloca(VALUE self, VALUE rtype, VALUE rsize) {
+  DATA_GET_BUILDER
+
+  const Type* type;
+  Data_Get_Struct(rtype, Type, type);
+
+  Value *size = ConstantInt::get(Type::Int32Ty, FIX2INT(rsize));
+  Value *v = builder->CreateAlloca(type, size);
+  return llvm_value_wrap(v);
+}
+
+VALUE
+llvm_builder_load(VALUE self, VALUE rptr) {
+  DATA_GET_BUILDER
+
+  Value *ptr;
+  Data_Get_Struct(rptr, Value, ptr);
+  return llvm_value_wrap(builder->CreateLoad(ptr));
+}
+
+VALUE
+llvm_builder_store(VALUE self, VALUE rv, VALUE rptr) {
+  DATA_GET_BUILDER
+
+  Value *v, *ptr;
+  Data_Get_Struct(rv, Value, v);
+  Data_Get_Struct(rptr, Value, ptr);
+  return llvm_value_wrap(builder->CreateStore(v, ptr));
+}
+
+VALUE
+llvm_builder_icmp(VALUE self, VALUE pred, VALUE lhs, VALUE rhs) {
+  DATA_GET_BUILDER
+
+  CmpInst::Predicate p = (CmpInst::Predicate)FIX2INT(pred);
+  Value *v = builder->CreateICmp(p, LLVM_VAL(lhs), LLVM_VAL(rhs));
+  return llvm_value_wrap(v);
+}
+
+VALUE
+llvm_builder_fcmp(VALUE self, VALUE pred, VALUE lhs, VALUE rhs) {
+  DATA_GET_BUILDER
+
+  CmpInst::Predicate p = (CmpInst::Predicate)FIX2INT(pred);
+  Value *v = builder->CreateFCmp(p, LLVM_VAL(lhs), LLVM_VAL(rhs));
+  return llvm_value_wrap(v);
+}
+
+VALUE
+llvm_builder_gep(VALUE self, VALUE rptr, VALUE ridx) {
+  DATA_GET_BUILDER
+
+  Value *ptr, *idx;
+  Data_Get_Struct(rptr, Value, ptr);
+  Data_Get_Struct(ridx, Value, idx);
+  return llvm_value_wrap(builder->CreateGEP(ptr, idx));
+}
+
+VALUE
+llvm_builder_struct_gep(VALUE self, VALUE rptr, VALUE ridx) {
+  DATA_GET_BUILDER 
+
+  Value *ptr; 
+  Data_Get_Struct(rptr, Value, ptr);
+  return llvm_value_wrap(builder->CreateStructGEP(ptr, FIX2INT(ridx)));
+}
+
+VALUE
+llvm_builder_cast(VALUE self, VALUE rop, VALUE rv, VALUE rdest_ty) {
+   DATA_GET_BUILDER
+
+   Instruction::CastOps op = (Instruction::CastOps)FIX2INT(rop); 
+
+   Value *v;
+   Data_Get_Struct(rv, Value, v);
+
+   Type *dest_ty;
+   Data_Get_Struct(rdest_ty, Type, dest_ty);
+
+   return llvm_value_wrap(builder->CreateCast(op, v, dest_ty));
+}
+
+VALUE
+llvm_builder_int_to_ptr(VALUE self, VALUE ri, VALUE rtype) {
+  DATA_GET_BUILDER
+
+  Value *i;
+  Data_Get_Struct(ri, Value, i);
+ 
+  const Type* type; 
+  Data_Get_Struct(rtype, Type, type);
+
+  return llvm_value_wrap(builder->CreateIntToPtr(i, type));
+}
+
+VALUE llvm_builder_int_cast(VALUE self, VALUE i, VALUE type, VALUE sign) {
+  DATA_GET_BUILDER
+  bool isSigned = (sign != Qnil && sign != Qfalse);
+  return llvm_value_wrap(builder->CreateIntCast(LLVM_VAL(i), LLVM_TYPE(type), isSigned));
+}
+
+VALUE
+llvm_builder_call(int argc, VALUE* argv, VALUE self) {
+  DATA_GET_BUILDER
+
+  Function *callee = LLVM_FUNCTION(argv[0]);
+  int num_args = argc-1;
+  Value** args = (Value**)alloca(num_args*sizeof(Value*));
+  for(int i = 0; i < num_args; ++i) {
+    args[i] = LLVM_VAL(argv[i+1]); 
+  }
+  return llvm_value_wrap(builder->CreateCall(callee, args, args+num_args));
+}
+
+VALUE
+llvm_builder_insert_element(VALUE self, VALUE rv, VALUE rnv, VALUE ridx) {
+  DATA_GET_BUILDER
+
+  Value *v, *nv, *idx;
+  Data_Get_Struct(rv, Value, v); 
+  Data_Get_Struct(rnv, Value, nv);
+  Data_Get_Struct(ridx, Value, idx);
+
+  return llvm_value_wrap(builder->CreateInsertElement(v, nv, idx));
+}
+
+VALUE
+llvm_builder_extract_element(VALUE self, VALUE rv, VALUE ridx) {
+  DATA_GET_BUILDER
+
+  Value *v, *idx;
+  Data_Get_Struct(rv, Value, v);
+  Data_Get_Struct(ridx, Value, idx);
+
+  return llvm_value_wrap(builder->CreateExtractElement(v, idx));
+}
+
+VALUE
+llvm_builder_get_global(VALUE self) {
+  GlobalVariable *g = new GlobalVariable(Type::Int64Ty, false, GlobalValue::ExternalLinkage, 0, "shakalaka");
+  return llvm_value_wrap(g);
+}
+
+VALUE
+llvm_builder_create_global_string_ptr(VALUE self, VALUE str) {
+  DATA_GET_BUILDER
+  Value *v = builder->CreateGlobalStringPtr(StringValuePtr(str));
+  return llvm_value_wrap(v);
+}
+}

data/ext/llvm_function.cpp

@@ -0,0 +1,48 @@
+#include "llvmruby.h"
+#include <sstream>
+
+extern "C" {
+VALUE 
+llvm_function_wrap(Function *f) { 
+  return Data_Wrap_Struct(cLLVMFunction, NULL, NULL, f); 
+}
+
+VALUE 
+llvm_function_create_block(VALUE self) {
+  BasicBlock *bb = BasicBlock::Create("bb", LLVM_FUNCTION(self));
+  return llvm_basic_block_wrap(bb);
+}
+
+VALUE
+llvm_function_arguments(VALUE self) {
+  Function *f = LLVM_FUNCTION(self);
+  VALUE arg_array = rb_ary_new();
+  Function::arg_iterator args = f->arg_begin();
+  while(args != f->arg_end()) {
+    Value *arg = args++;
+    rb_ary_push(arg_array, llvm_value_wrap(arg));
+  }
+  return arg_array;
+}
+
+VALUE
+llvm_function_inspect(VALUE self) {
+  Function *f = LLVM_FUNCTION(self); 
+  std::ostringstream strstrm;
+  strstrm << *f;
+  return rb_str_new2(strstrm.str().c_str());
+}
+
+VALUE
+llvm_function_get_basic_block_list(VALUE self) {
+  Function *f = LLVM_FUNCTION(self);
+  VALUE bb_array = rb_ary_new();
+  Function::iterator bbs = f->begin();
+  while(bbs != f->end()) {
+    BasicBlock *bb = bbs++;
+    rb_ary_push(bb_array, llvm_basic_block_wrap(bb));
+  }
+  return bb_array;
+}
+
+}

data/ext/llvm_instruction.cpp

@@ -0,0 +1,125 @@
+#include "llvmruby.h"
+#include <sstream>
+
+extern VALUE cLLVMInstruction;
+extern VALUE cLLVMBinaryOps;
+
+extern "C" {
+
+VALUE
+llvm_instruction_wrap(Instruction* i) {
+   return Data_Wrap_Struct(cLLVMInstruction, 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());
+}
+
+#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 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() {
+  // 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)
+}
+}