ResultSetReductionCodegen.h File Reference

#include "ResultSetReductionJIT.h"
#include "ResultSetReductionOps.h"
#include <llvm/IR/LLVMContext.h>
#include <llvm/IR/Type.h>

Include dependency graph for ResultSetReductionCodegen.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
llvm::Type *	llvm_type (const Type type, llvm::LLVMContext &ctx)
void	translate_function (const Function *function, llvm::Function *llvm_function, const ReductionCode &reduction_code, const std::unordered_map< const Function *, llvm::Function * > &f)

Function Documentation

llvm::Type* llvm_type	(	const Type	type,
		llvm::LLVMContext &	ctx
	)

Definition at line 26 of file ResultSetReductionCodegen.cpp.

References Double, DoublePtr, logger::FATAL, Float, FloatPtr, get_fp_type(), get_int_type(), Int1, Int32, Int32Ptr, Int64, Int64Ptr, Int64PtrPtr, Int8, Int8Ptr, LOG, run_benchmark_import::type, UNREACHABLE, Void, and VoidPtr.

Referenced by anonymous_namespace{ResultSetReductionJIT.cpp}::create_llvm_function(), StubGenerator::generateStub(), and anonymous_namespace{ResultSetReductionCodegen.cpp}::translate_body().

                                                           {
  switch (type) {
    case Type::Int1: {
      return get_int_type(1, ctx);
    }
    case Type::Int8: {
      return get_int_type(8, ctx);
    }
    case Type::Int32: {
      return get_int_type(32, ctx);
    }
    case Type::Int64: {
      return get_int_type(64, ctx);
    }
    case Type::Float: {
      return get_fp_type(32, ctx);
    }
    case Type::Double: {
      return get_fp_type(64, ctx);
    }
    case Type::Void: {
      return llvm::Type::getVoidTy(ctx);
    }
    case Type::Int8Ptr: {
      return llvm::PointerType::get(get_int_type(8, ctx), 0);
    }
    case Type::Int32Ptr: {
      return llvm::PointerType::get(get_int_type(32, ctx), 0);
    }
    case Type::Int64Ptr: {
      return llvm::PointerType::get(get_int_type(64, ctx), 0);
    }
    case Type::FloatPtr: {
      return llvm::Type::getFloatPtrTy(ctx);
    }
    case Type::DoublePtr: {
      return llvm::Type::getDoublePtrTy(ctx);
    }
    case Type::VoidPtr: {
      return llvm::PointerType::get(get_int_type(8, ctx), 0);
    }
    case Type::Int64PtrPtr: {
      return llvm::PointerType::get(llvm::PointerType::get(get_int_type(64, ctx), 0), 0);
    }
    default: {
      LOG(FATAL) << "Argument type not supported: " << static_cast<int>(type);
      break;
    }
  }
  UNREACHABLE();
  return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void translate_function	(	const Function *	function,
		llvm::Function *	llvm_function,
		const ReductionCode &	reduction_code,
		const std::unordered_map< const Function *, llvm::Function * > &	f
	)

Definition at line 366 of file ResultSetReductionCodegen.cpp.

References AUTOMATIC_IR_METADATA, ReductionCode::cgen_state, CHECK, anonymous_namespace{ResultSetReductionCodegen.cpp}::create_entry_block(), Double, f(), logger::FATAL, Float, Int32, Int64, Int8, LOG, anonymous_namespace{ResultSetReductionCodegen.cpp}::translate_body(), and verify_function_ir().

Referenced by ResultSetReductionJIT::codegen(), and GpuReductionHelperJIT::codegen().

                                                                                   {
  auto cgen_state = reduction_code.cgen_state;
  AUTOMATIC_IR_METADATA(cgen_state);
  create_entry_block(llvm_function, cgen_state);
  // Set the value mapping based on the input arguments.
  std::unordered_map<const Value*, llvm::Value*> m;
  auto llvm_arg_it = llvm_function->arg_begin();
  for (size_t arg_idx = 0; arg_idx < function->arg_types().size(); ++arg_idx) {
    llvm::Value* llvm_arg = &(*llvm_arg_it);
    const auto it_ok = m.emplace(function->arg(arg_idx), llvm_arg);
    CHECK(it_ok.second);
    ++llvm_arg_it;
  }
  // Add mapping for the constants used by the function.
  for (const auto& constant : function->constants()) {
    llvm::Value* constant_llvm{nullptr};
    switch (constant->type()) {
      case Type::Int8: {
        constant_llvm =
            cgen_state->llInt<int8_t>(static_cast<ConstantInt*>(constant.get())->value());
        break;
      }
      case Type::Int32: {
        constant_llvm = cgen_state->llInt<int32_t>(
            static_cast<ConstantInt*>(constant.get())->value());
        break;
      }
      case Type::Int64: {
        constant_llvm = cgen_state->llInt<int64_t>(
            static_cast<ConstantInt*>(constant.get())->value());
        break;
      }
      case Type::Float: {
        constant_llvm = cgen_state->llFp(
            static_cast<float>(static_cast<ConstantFP*>(constant.get())->value()));
        break;
      }
      case Type::Double: {
        constant_llvm =
            cgen_state->llFp(static_cast<ConstantFP*>(constant.get())->value());
        break;
      }
      default: {
        LOG(FATAL) << "Constant type not supported: "
                   << static_cast<int>(constant->type());
      }
    }
    CHECK(constant_llvm);
    const auto it_ok = m.emplace(constant.get(), constant_llvm);
    CHECK(it_ok.second);
  }
  translate_body(function->body(), function, llvm_function, reduction_code, m, f);
  verify_function_ir(llvm_function);
}

Here is the call graph for this function:

Here is the caller graph for this function: