anonymous_namespace{ResultSetReductionCodegen.cpp} Namespace Reference

Functions
llvm::ICmpInst::Predicate	llvm_predicate (const ICmp::Predicate predicate)
llvm::BinaryOperator::BinaryOps	llvm_binary_op (const BinaryOperator::BinaryOp op)
llvm::Instruction::CastOps	llvm_cast_op (const Cast::CastOp op)
void	return_early (llvm::Value *cond, const ReductionCode &reduction_code, llvm::Function *func, llvm::Value *error_code)
llvm::Value *	mapped_value (const Value *val, const std::unordered_map< const Value *, llvm::Value * > &m)
llvm::Function *	mapped_function (const Function *function, const std::unordered_map< const Function *, llvm::Function * > &f)
std::vector< llvm::Value * >	llvm_args (const std::vector< const Value * > args, const std::unordered_map< const Value *, llvm::Value * > &m)
void	translate_for (const For *for_loop, Function *ir_reduce_loop, const ReductionCode &reduction_code, std::unordered_map< const Value *, llvm::Value * > &m, const std::unordered_map< const Function *, llvm::Function * > &f)
void	translate_body (const std::vector< std::unique_ptr< Instruction >> &body, const Function *function, llvm::Function *llvm_function, const ReductionCode &reduction_code, std::unordered_map< const Value *, llvm::Value * > &m, const std::unordered_map< const Function *, llvm::Function * > &f)
void	create_entry_block (llvm::Function *function, CgenState *cgen_state)

Function Documentation

void anonymous_namespace{ResultSetReductionCodegen.cpp}::create_entry_block	(	llvm::Function *	function,
		CgenState *	cgen_state
	)

Definition at line 357 of file ResultSetReductionCodegen.cpp.

References AUTOMATIC_IR_METADATA, CgenState::context_, and CgenState::ir_builder_.

Referenced by translate_function().

                                                                       {
  AUTOMATIC_IR_METADATA(cgen_state);
  const auto bb_entry =
      llvm::BasicBlock::Create(cgen_state->context_, ".entry", function, 0);
  cgen_state->ir_builder_.SetInsertPoint(bb_entry);
}

Here is the caller graph for this function:

std::vector<llvm::Value*> anonymous_namespace{ResultSetReductionCodegen.cpp}::llvm_args	(	const std::vector< const Value * >	args,
		const std::unordered_map< const Value *, llvm::Value * > &	m
	)

Definition at line 184 of file ResultSetReductionCodegen.cpp.

References mapped_value(), and shared::transform().

Referenced by translate_body().

                                                         {
  std::vector<llvm::Value*> llvm_args;
  std::transform(
      args.begin(), args.end(), std::back_inserter(llvm_args), [&m](const Value* value) {
        return mapped_value(value, m);
      });
  return llvm_args;
}

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::BinaryOperator::BinaryOps anonymous_namespace{ResultSetReductionCodegen.cpp}::llvm_binary_op

(

const BinaryOperator::BinaryOp

op

)

Definition at line 99 of file ResultSetReductionCodegen.cpp.

References BinaryOperator::Add, logger::FATAL, LOG, BinaryOperator::Mul, and UNREACHABLE.

Referenced by translate_body().

                                                                            {
  switch (op) {
    case BinaryOperator::BinaryOp::Add: {
      return llvm::Instruction::Add;
    }
    case BinaryOperator::BinaryOp::Mul: {
      return llvm::Instruction::Mul;
    }
    default: {
      LOG(FATAL) << "Invalid binary operator: " << static_cast<int>(op);
    }
  }
  UNREACHABLE();
  return llvm::Instruction::Add;
}

Here is the caller graph for this function:

llvm::Instruction::CastOps anonymous_namespace{ResultSetReductionCodegen.cpp}::llvm_cast_op

(

const Cast::CastOp

op

)

Definition at line 116 of file ResultSetReductionCodegen.cpp.

References Cast::BitCast, logger::FATAL, LOG, Cast::SExt, Cast::Trunc, and UNREACHABLE.

Referenced by translate_body().

                                                         {
  switch (op) {
    case Cast::CastOp::Trunc: {
      return llvm::Instruction::Trunc;
    }
    case Cast::CastOp::SExt: {
      return llvm::Instruction::SExt;
    }
    case Cast::CastOp::BitCast: {
      return llvm::Instruction::BitCast;
    }
    default: {
      LOG(FATAL) << "Invalid cast operator: " << static_cast<int>(op);
    }
  }
  UNREACHABLE();
  return llvm::Instruction::SExt;
}

Here is the caller graph for this function:

llvm::ICmpInst::Predicate anonymous_namespace{ResultSetReductionCodegen.cpp}::llvm_predicate

(

const ICmp::Predicate

predicate

)

Definition at line 82 of file ResultSetReductionCodegen.cpp.

References ICmp::EQ, logger::FATAL, LOG, ICmp::NE, and UNREACHABLE.

Referenced by translate_body().

                                                                    {
  switch (predicate) {
    case ICmp::Predicate::EQ: {
      return llvm::ICmpInst::ICMP_EQ;
    }
    case ICmp::Predicate::NE: {
      return llvm::ICmpInst::ICMP_NE;
    }
    default: {
      LOG(FATAL) << "Invalid predicate: " << static_cast<int>(predicate);
    }
  }
  UNREACHABLE();
  return llvm::ICmpInst::ICMP_EQ;
}

Here is the caller graph for this function:

llvm::Function* anonymous_namespace{ResultSetReductionCodegen.cpp}::mapped_function	(	const Function *	function,
		const std::unordered_map< const Function *, llvm::Function * > &	f
	)

Definition at line 174 of file ResultSetReductionCodegen.cpp.

References CHECK.

Referenced by translate_body(), and translate_for().

                                                               {
  const auto it = f.find(function);
  CHECK(it != f.end()) << function->name() << " not found.";
  return it->second;
}

Here is the caller graph for this function:

llvm::Value* anonymous_namespace{ResultSetReductionCodegen.cpp}::mapped_value	(	const Value *	val,
		const std::unordered_map< const Value *, llvm::Value * > &	m
	)

Definition at line 162 of file ResultSetReductionCodegen.cpp.

References CHECK.

Referenced by llvm_args(), translate_body(), and translate_for().

                                                                               {
  if (val) {
    const auto it = m.find(val);
    CHECK(it != m.end());
    return it->second;
  } else {
    return nullptr;
  }
}

Here is the caller graph for this function:

void anonymous_namespace{ResultSetReductionCodegen.cpp}::return_early	(	llvm::Value *	cond,
		const ReductionCode &	reduction_code,
		llvm::Function *	func,
		llvm::Value *	error_code
	)

Definition at line 139 of file ResultSetReductionCodegen.cpp.

References AUTOMATIC_IR_METADATA, ReductionCode::cgen_state, and CHECK.

Referenced by translate_body().

                                         {
  auto cgen_state = reduction_code.cgen_state;
  AUTOMATIC_IR_METADATA(cgen_state);
  auto& ctx = cgen_state->context_;
  const auto early_return = llvm::BasicBlock::Create(ctx, ".early_return", func, 0);
  const auto do_reduction = llvm::BasicBlock::Create(ctx, ".do_reduction", func, 0);
  cgen_state->ir_builder_.CreateCondBr(cond, early_return, do_reduction);
  cgen_state->ir_builder_.SetInsertPoint(early_return);

  if (func->getReturnType()->isVoidTy()) {
    cgen_state->ir_builder_.CreateRetVoid();
  } else {
    CHECK(error_code);
    cgen_state->ir_builder_.CreateRet(error_code);
  }

  cgen_state->ir_builder_.SetInsertPoint(do_reduction);
}

Here is the caller graph for this function:

void anonymous_namespace{ResultSetReductionCodegen.cpp}::translate_body	(	const std::vector< std::unique_ptr< Instruction >> &	body,
		const Function *	function,
		llvm::Function *	llvm_function,
		const ReductionCode &	reduction_code,
		std::unordered_map< const Value *, llvm::Value * > &	m,
		const std::unordered_map< const Function *, llvm::Function * > &	f
	)

Definition at line 202 of file ResultSetReductionCodegen.cpp.

References run_benchmark_import::args, AUTOMATIC_IR_METADATA, ReductionCode::cgen_state, CHECK, f(), logger::FATAL, ReductionCode::ir_reduce_loop, llvm_args(), llvm_binary_op(), llvm_cast_op(), LLVM_MAYBE_ALIGN, llvm_predicate(), llvm_type(), boost::serialization::load(), LOG, mapped_function(), mapped_value(), pointee_type(), return_early(), shared::transform(), and translate_for().

Referenced by translate_for(), and translate_function().

                                                                               {
  auto cgen_state = reduction_code.cgen_state;
  AUTOMATIC_IR_METADATA(cgen_state);
  auto& ctx = cgen_state->context_;
  for (const auto& instr : body) {
    const auto instr_ptr = instr.get();
    llvm::Value* translated{nullptr};
    if (auto gep = dynamic_cast<const GetElementPtr*>(instr_ptr)) {
      auto* base = mapped_value(gep->base(), m);
      translated = cgen_state->ir_builder_.CreateGEP(
          base->getType()->getScalarType()->getPointerElementType(),
          base,
          mapped_value(gep->index(), m),
          gep->label());
    } else if (auto load = dynamic_cast<const Load*>(instr_ptr)) {
      auto* value = mapped_value(load->source(), m);
      translated = cgen_state->ir_builder_.CreateLoad(
          value->getType()->getPointerElementType(), value, load->label());
    } else if (auto icmp = dynamic_cast<const ICmp*>(instr_ptr)) {
      translated = cgen_state->ir_builder_.CreateICmp(llvm_predicate(icmp->predicate()),
                                                      mapped_value(icmp->lhs(), m),
                                                      mapped_value(icmp->rhs(), m),
                                                      icmp->label());
    } else if (auto binary_operator = dynamic_cast<const BinaryOperator*>(instr_ptr)) {
      translated =
          cgen_state->ir_builder_.CreateBinOp(llvm_binary_op(binary_operator->op()),
                                              mapped_value(binary_operator->lhs(), m),
                                              mapped_value(binary_operator->rhs(), m),
                                              binary_operator->label());
    } else if (auto cast = dynamic_cast<const Cast*>(instr_ptr)) {
      translated = cgen_state->ir_builder_.CreateCast(llvm_cast_op(cast->op()),
                                                      mapped_value(cast->source(), m),
                                                      llvm_type(cast->type(), ctx),
                                                      cast->label());
    } else if (auto ret = dynamic_cast<const Ret*>(instr_ptr)) {
      if (ret->value()) {
        cgen_state->ir_builder_.CreateRet(mapped_value(ret->value(), m));
      } else {
        cgen_state->ir_builder_.CreateRetVoid();
      }
    } else if (auto call = dynamic_cast<const Call*>(instr_ptr)) {
      std::vector<llvm::Value*> llvm_args;
      const auto args = call->arguments();
      std::transform(args.begin(),
                     args.end(),
                     std::back_inserter(llvm_args),
                     [&m](const Value* value) { return mapped_value(value, m); });
      if (call->callee()) {
        translated = cgen_state->ir_builder_.CreateCall(
            mapped_function(call->callee(), f), llvm_args, call->label());
      } else {
        translated = cgen_state->emitCall(call->callee_name(), llvm_args);
      }
    } else if (auto external_call = dynamic_cast<const ExternalCall*>(instr_ptr)) {
      translated = cgen_state->emitExternalCall(external_call->callee_name(),
                                                llvm_type(external_call->type(), ctx),
                                                llvm_args(external_call->arguments(), m));
    } else if (auto alloca = dynamic_cast<const Alloca*>(instr_ptr)) {
      translated = cgen_state->ir_builder_.CreateAlloca(
          llvm_type(pointee_type(alloca->type()), ctx),
          mapped_value(alloca->array_size(), m),
          alloca->label());
    } else if (auto memcpy = dynamic_cast<const MemCpy*>(instr_ptr)) {
      cgen_state->ir_builder_.CreateMemCpy(mapped_value(memcpy->dest(), m),
                                           LLVM_MAYBE_ALIGN(0),
                                           mapped_value(memcpy->source(), m),
                                           LLVM_MAYBE_ALIGN(0),
                                           mapped_value(memcpy->size(), m));
    } else if (auto ret_early = dynamic_cast<const ReturnEarly*>(instr_ptr)) {
      return_early(mapped_value(ret_early->cond(), m),
                   reduction_code,
                   llvm_function,
                   mapped_value(ret_early->error_code(), m));
    } else if (auto for_loop = dynamic_cast<const For*>(instr_ptr)) {
      translate_for(for_loop, reduction_code.ir_reduce_loop.get(), reduction_code, m, f);
    } else {
      LOG(FATAL) << "Instruction not supported yet";
    }
    if (translated) {
      const auto it_ok = m.emplace(instr_ptr, translated);
      CHECK(it_ok.second);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void anonymous_namespace{ResultSetReductionCodegen.cpp}::translate_for	(	const For *	for_loop,
		Function *	ir_reduce_loop,
		const ReductionCode &	reduction_code,
		std::unordered_map< const Value *, llvm::Value * > &	m,
		const std::unordered_map< const Function *, llvm::Function * > &	f
	)

Definition at line 293 of file ResultSetReductionCodegen.cpp.

References AUTOMATIC_IR_METADATA, ReductionCode::cgen_state, JoinLoop::codegen(), For::end(), f(), get_int_type(), INNER, mapped_function(), mapped_value(), For::start(), translate_body(), JoinLoopDomain::upper_bound, gpu_enabled::upper_bound(), and UpperBound.

Referenced by translate_body().

                                                                              {
  auto cgen_state = reduction_code.cgen_state;
  AUTOMATIC_IR_METADATA(cgen_state);
  const auto bb_entry = cgen_state->ir_builder_.GetInsertBlock();
  auto& ctx = cgen_state->context_;
  const auto i64_type = get_int_type(64, cgen_state->context_);
  const auto end_index = mapped_value(for_loop->end(), m);
  const auto start_index = mapped_value(for_loop->start(), m);
  // The start and end indices are absolute. Subtract the start index from the iterator.
  const auto iteration_count =
      cgen_state->ir_builder_.CreateSub(end_index, start_index, "iteration_count");
  const auto upper_bound = cgen_state->ir_builder_.CreateSExt(iteration_count, i64_type);
  const auto bb_exit =
      llvm::BasicBlock::Create(ctx, ".exit", mapped_function(ir_reduce_loop, f));
  JoinLoop join_loop(
      JoinLoopKind::UpperBound,
      JoinType::INNER,
      [upper_bound](const std::vector<llvm::Value*>& v) {
        JoinLoopDomain domain{{0}};
        domain.upper_bound = upper_bound;
        return domain;
      },
      nullptr,
      nullptr,
      nullptr,
      nullptr,
      false,
      "reduction_loop");
  const auto bb_loop_body = JoinLoop::codegen(
      {join_loop},
      [cgen_state, for_loop, ir_reduce_loop, &f, &m, &reduction_code](
          const std::vector<llvm::Value*>& iterators) {
        const auto loop_body_bb = llvm::BasicBlock::Create(
            cgen_state->context_,
            ".loop_body",
            cgen_state->ir_builder_.GetInsertBlock()->getParent());
        cgen_state->ir_builder_.SetInsertPoint(loop_body_bb);
        // Make the iterator the same type as start and end indices (32-bit integer).
        const auto loop_iter =
            cgen_state->ir_builder_.CreateTrunc(iterators.back(),
                                                get_int_type(32, cgen_state->context_),
                                                "relative_entry_idx");
        m.emplace(for_loop->iter(), loop_iter);
        translate_body(for_loop->body(),
                       ir_reduce_loop,
                       mapped_function(ir_reduce_loop, f),
                       reduction_code,
                       m,
                       f);
        return loop_body_bb;
      },
      nullptr,
      bb_exit,
      cgen_state);
  cgen_state->ir_builder_.SetInsertPoint(bb_entry);
  cgen_state->ir_builder_.CreateBr(bb_loop_body);
  cgen_state->ir_builder_.SetInsertPoint(bb_exit);
}

Here is the call graph for this function:

Here is the caller graph for this function: