Added module builder

src/ModuleBuilder.cpp

@@ -1,18 +1,18 @@
-#include "Compiler.h"
+#include "ModuleBuilder.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/Support/raw_ostream.h"
 
-Compiler::Compiler(shared_ptr<Expression> expression): expression(expression) {
+ModuleBuilder::ModuleBuilder(shared_ptr<Expression> expression): expression(expression) {
     context = make_shared<llvm::LLVMContext>();
     module = make_shared<llvm::Module>("dummy", *context);
     builder = make_shared<llvm::IRBuilder<>>(*context);
 
-    //int32Type = shared_ptr<llvm::IntegerType>(llvm::Type::getInt32Ty(context));
+    voidType = llvm::Type::getVoidTy(*context);
     int32Type = llvm::Type::getInt32Ty(*context);
 }
 
-llvm::Value *Compiler::valueForExpression(shared_ptr<Expression> expression) {
+llvm::Value *ModuleBuilder::valueForExpression(shared_ptr<Expression> expression) {
     switch (expression->getKind()) {
         case Expression::Kind::LITERAL:
             return llvm::ConstantInt::get(int32Type, expression->getInteger(), true);
@@ -35,8 +35,19 @@ llvm::Value *Compiler::valueForExpression(shared_ptr<Expression> expression) {
     }
 }
 
-shared_ptr<llvm::Module> Compiler::getModule() {
+shared_ptr<llvm::Module> ModuleBuilder::getModule() {
+    //llvm::Value *value = valueForExpression(expression);
+
+    llvm::FunctionType *fType = llvm::FunctionType::get(int32Type, false);
+    llvm::Function *f = llvm::Function::Create(fType, llvm::GlobalValue::InternalLinkage, "dummyFunc", module.get());
+
+    llvm::BasicBlock *block = llvm::BasicBlock::Create(*context, "entry", f);
+    builder->SetInsertPoint(block);
     llvm::Value *value = valueForExpression(expression);
-    value->print(llvm::outs(), false);
+    //builder->CreateRetVoid();
+    builder->CreateRet(value);
+
+    //value->print(llvm::outs(), false);
+    //cout << endl;
     return module;
 }

src/ModuleBuilder.h

@@ -1,5 +1,5 @@
-#ifndef COMPILER_H
-#define COMPILER_H
+#ifndef MODULE_BUILDER_H
+#define MODULE_BUILDER_H
 
 #include "llvm/IR/Module.h"
 #include "llvm/IR/IRBuilder.h"
@@ -7,21 +7,20 @@
 
 using namespace std;
 
-class Compiler {
+class ModuleBuilder {
 private:
     shared_ptr<llvm::LLVMContext> context;
-    //llvm::LLVMContext context;
     shared_ptr<llvm::Module> module;
     shared_ptr<llvm::IRBuilder<>> builder;
 
-    //shared_ptr<llvm::IntegerType> int32Type;
+    llvm::Type *voidType;
     llvm::IntegerType *int32Type;
 
     shared_ptr<Expression> expression;
     llvm::Value *valueForExpression(shared_ptr<Expression> expression);
 
 public:
-    Compiler(shared_ptr<Expression> expression);
+    ModuleBuilder(shared_ptr<Expression> expression);
     shared_ptr<llvm::Module> getModule();
 };
 

src/main.cpp

@@ -6,9 +6,18 @@
 
 #include "Expression.h"
 #include "Parser.h"
-#include "Compiler.h"
+#include "ModuleBuilder.h"
 
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/IR/LegacyPassManager.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/MC/TargetRegistry.h"
+#include "llvm/Support/TargetSelect.h"
+#include "llvm/Target/TargetOptions.h"
+#include "llvm/TargetParser/Triple.h"
+#include "llvm/TargetParser/Host.h"
+
 
 using namespace std;
 
@@ -43,10 +52,42 @@ int main(int argc, char **argv) {
     shared_ptr<Expression> expression = parser.getExpression();
     cout << expression->toString() << endl;
 
-    Compiler compiler(expression);
-    compiler.getModule();
-    shared_ptr<llvm::Module> module = compiler.getModule();
+    ModuleBuilder moduleBuilder(expression);
+    shared_ptr<llvm::Module> module = moduleBuilder.getModule();
     module->print(llvm::outs(), nullptr);
 
+    llvm::InitializeAllTargetInfos();
+    llvm::InitializeAllTargets();
+    llvm::InitializeAllTargetMCs();
+    llvm::InitializeAllAsmParsers();
+    llvm::InitializeAllAsmPrinters();
+
+    string targetTriple = llvm::sys::getDefaultTargetTriple();
+    cout << targetTriple << endl;
+    string errorString;
+    const llvm::Target *target = llvm::TargetRegistry::lookupTarget(targetTriple, errorString);
+    cout << errorString << endl;
+
+    llvm::TargetOptions options;
+    llvm::TargetMachine *targetMachine = target->createTargetMachine(targetTriple, "generic", "", options, llvm::Reloc::PIC_);
+
+    module->setDataLayout(targetMachine->createDataLayout());
+    module->setTargetTriple(targetTriple);
+
+    error_code errorCode;
+    llvm::raw_fd_ostream outputFile("test.o", errorCode, llvm::sys::fs::OF_None);
+    if (errorCode) {
+        cout << errorCode.message();
+        exit(1);
+    }
+
+    llvm::legacy::PassManager passManager;
+    if(targetMachine->addPassesToEmitFile(passManager, outputFile, nullptr, llvm::CodeGenFileType::AssemblyFile)) {
+        cout << "failed" << endl;
+        exit(1);
+    }
+    passManager.run(*module);
+    outputFile.flush();
+
     return 0;
 }