llvm-codegen.h

Go to the documentation of this file.

// Copyright 2012 Cloudera Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.


#ifndef IMPALA_CODEGEN_LLVM_CODEGEN_H
#define IMPALA_CODEGEN_LLVM_CODEGEN_H

#include "common/status.h"

#include <map>
#include <string>
#include <vector>
#include <boost/scoped_ptr.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/unordered_set.hpp>

#include <llvm/Analysis/Verifier.h>
#include <llvm/IR/DerivedTypes.h>
#include <llvm/IR/IRBuilder.h>
#include <llvm/IR/Intrinsics.h>
#include <llvm/IR/LLVMContext.h>
#include <llvm/IR/Module.h>
#include <llvm/Support/raw_ostream.h>

#include "exprs/expr.h"
#include "impala-ir/impala-ir-functions.h"
#include "runtime/types.h"
#include "util/runtime-profile.h"

namespace llvm {
  class AllocaInst;
  class BasicBlock;
  class ConstantFolder;
  class ExecutionEngine;
  class Function;
  class FunctionPassManager;
  class LLVMContext;
  class Module;
  class NoFolder;
  class PassManager;
  class PointerType;
  class StructType;
  class TargetData;
  class Type;
  class Value;

  template<bool B, typename T, typename I>
  class IRBuilder;

  template<bool preserveName>
  class IRBuilderDefaultInserter;
}

namespace impala {

class CodegenAnyVal;
class SubExprElimination;

//
//
//
//
//
class LlvmCodeGen {
 public:
  static void InitializeLlvm(bool load_backend = false);

  static Status LoadImpalaIR(
      ObjectPool*, const std::string& id, boost::scoped_ptr<LlvmCodeGen>* codegen);

  static Status LoadFromFile(ObjectPool*, const std::string& file, const std::string& id,
      boost::scoped_ptr<LlvmCodeGen>* codegen);

  ~LlvmCodeGen();

  RuntimeProfile* runtime_profile() { return &profile_; }
  RuntimeProfile::Counter* codegen_timer() { return codegen_timer_; }

  void EnableOptimizations(bool enable);

  std::string GetIR(bool full_module) const;

  typedef llvm::IRBuilder<> LlvmBuilder;

  struct NamedVariable {
    std::string name;
    llvm::Type* type;

    NamedVariable(const std::string& name="", llvm::Type* type = NULL) {
      this->name = name;
      this->type = type;
    }
  };

  class FnPrototype {
   public:
    FnPrototype(LlvmCodeGen*, const std::string& name, llvm::Type* ret_type);

    const std::string& name() const { return name_; }

    void AddArgument(const NamedVariable& var) {
      args_.push_back(var);
    }

    llvm::Function* GeneratePrototype(LlvmBuilder* builder = NULL,
        llvm::Value** params = NULL);

   private:
    friend class LlvmCodeGen;

    LlvmCodeGen* codegen_;
    std::string name_;
    llvm::Type* ret_type_;
    std::vector<NamedVariable> args_;
  };

  llvm::PointerType* GetPtrType(llvm::Type* type);

  llvm::Type* GetType(const ColumnType& type);

  llvm::PointerType* GetPtrType(const ColumnType& type);

  llvm::Type* GetType(const std::string& name);

  llvm::PointerType* GetPtrType(const std::string& name);

  llvm::LLVMContext& context() { return *context_.get(); }

  llvm::ExecutionEngine* execution_engine() { return execution_engine_.get(); }

  llvm::Module* module() { return module_; }

  void RegisterExprFn(int64_t id, llvm::Function* function) {
    DCHECK(registered_exprs_map_.find(id) == registered_exprs_map_.end());
    registered_exprs_map_[id] = function;
    registered_exprs_.insert(function);
  }

  llvm::Function* GetRegisteredExprFn(int64_t id) {
    std::map<int64_t, llvm::Function*>::iterator it = registered_exprs_map_.find(id);
    if (it == registered_exprs_map_.end()) return NULL;
    return it->second;
  }

  Status FinalizeModule();

  //
  llvm::Function* ReplaceCallSites(llvm::Function* caller, bool update_in_place,
      llvm::Function* new_fn, const std::string& target_name, int* num_replaced);

  llvm::Function* CloneFunction(llvm::Function* fn);

  void ReplaceInstWithValue(llvm::Instruction* from, llvm::Value* to);

  llvm::Argument* GetArgument(llvm::Function* fn, int i);

  llvm::Function* FinalizeFunction(llvm::Function* function);

  int InlineCallSites(llvm::Function* fn, bool skip_registered_fns);

  llvm::Function* OptimizeFunctionWithExprs(llvm::Function* fn);

  //
  //
  //
  void AddFunctionToJit(llvm::Function* fn, void** fn_ptr);

  bool VerifyFunction(llvm::Function* function);

  void CodegenDebugTrace(LlvmBuilder* builder, const char* message);

  template <typename T> static std::string Print(T* value_or_type) {
    std::string str;
    llvm::raw_string_ostream stream(str);
    value_or_type->print(stream);
    return str;
  }

  llvm::Function* GetLibCFunction(FnPrototype* prototype);

  llvm::Function* GetFunction(IRFunction::Type);

  llvm::Function* GetHashFunction(int num_bytes = -1);
  llvm::Function* GetFnvHashFunction(int num_bytes = -1);
  llvm::Function* GetMurmurHashFunction(int num_bytes = -1);

  //
  llvm::AllocaInst* CreateEntryBlockAlloca(llvm::Function* f, const NamedVariable& var);
  llvm::AllocaInst* CreateEntryBlockAlloca(const LlvmBuilder& builder, llvm::Type* type,
                                           const char* name = "");

  void CreateIfElseBlocks(llvm::Function* fn, const std::string& if_name,
      const std::string& else_name,
      llvm::BasicBlock** if_block, llvm::BasicBlock** else_block,
      llvm::BasicBlock* insert_before = NULL);

  llvm::Value* CastPtrToLlvmPtr(llvm::Type* type, const void* ptr);

  llvm::Value* GetIntConstant(PrimitiveType type, int64_t val);

  llvm::Value* true_value() { return true_value_; }
  llvm::Value* false_value() { return false_value_; }
  llvm::Value* null_ptr_value() { return llvm::ConstantPointerNull::get(ptr_type()); }

  llvm::Type* boolean_type() { return GetType(TYPE_BOOLEAN); }
  llvm::Type* tinyint_type() { return GetType(TYPE_TINYINT); }
  llvm::Type* smallint_type() { return GetType(TYPE_SMALLINT); }
  llvm::Type* int_type() { return GetType(TYPE_INT); }
  llvm::Type* bigint_type() { return GetType(TYPE_BIGINT); }
  llvm::Type* float_type() { return GetType(TYPE_FLOAT); }
  llvm::Type* double_type() { return GetType(TYPE_DOUBLE); }
  llvm::Type* string_val_type() { return string_val_type_; }
  llvm::PointerType* ptr_type() { return ptr_type_; }
  llvm::Type* void_type() { return void_type_; }
  llvm::Type* i128_type() { return llvm::Type::getIntNTy(context(), 128); }

  void GetFunctions(std::vector<llvm::Function*>* functions);

  void GetSymbols(boost::unordered_set<std::string>* symbols);

  llvm::Function* CodegenMinMax(const ColumnType& type, bool min);

  void CodegenMemcpy(LlvmBuilder*, llvm::Value* dst, llvm::Value* src, int size);

  static Status LoadModule(LlvmCodeGen* codegen, const std::string& file,
                           llvm::Module** module);

  Status LinkModule(const std::string& file);

 private:
  friend class LlvmCodeGenTest;
  friend class SubExprElimination;

  LlvmCodeGen(ObjectPool* pool, const std::string& module_id);

  Status Init();

  Status LoadIntrinsics();

  //
  void* JitFunction(llvm::Function* function);

  void OptimizeModule();

  void ClearHashFns();

  std::string id_;

  RuntimeProfile profile_;

  RuntimeProfile::Counter* load_module_timer_;

  RuntimeProfile::Counter* prepare_module_timer_;

  RuntimeProfile::Counter* codegen_timer_;

  RuntimeProfile::Counter* optimization_timer_;

  RuntimeProfile::Counter* compile_timer_;

  RuntimeProfile::Counter* module_file_size_;

  bool optimizations_enabled_;

  bool is_corrupt_;

  bool is_compiled_;

  std::string error_string_;

  boost::scoped_ptr<llvm::LLVMContext> context_;

  llvm::Module* module_;

  boost::scoped_ptr<llvm::ExecutionEngine> execution_engine_;

  std::map<llvm::Function*, bool> jitted_functions_;

  boost::mutex jitted_functions_lock_;

  std::map<std::string, llvm::Function*> external_functions_;

  std::vector<llvm::Function*> loaded_functions_;

  std::vector<llvm::Function*> codegend_functions_;

  std::map<int64_t, llvm::Function*> registered_exprs_map_;

  std::set<llvm::Function*> registered_exprs_;

  std::map<llvm::Intrinsic::ID, llvm::Function*> llvm_intrinsics_;

  std::map<int, llvm::Function*> hash_fns_;

  std::set<std::string> linked_modules_;

  std::vector<std::pair<llvm::Function*, void**> > fns_to_jit_compile_;

  llvm::Function* debug_trace_fn_;

  std::vector<std::string> debug_strings_;

  llvm::PointerType* ptr_type_;             // int8_t*
  llvm::Type* void_type_;                   // void
  llvm::Type* string_val_type_;             // StringValue
  llvm::Type* timestamp_val_type_;          // TimestampValue

  llvm::Value* true_value_;
  llvm::Value* false_value_;
};

}

#endif