Function get_operand

llvm_util/utils.cpp:279–471

Value* get_operand(llvm::Value *v,
                   function<Value*(llvm::ConstantExpr*)> constexpr_conv,
                   function<Value*(AggregateValue*)> copy_inserter,
                   function<bool(llvm::Function*)> register_fn_decl) {
  if (auto ptr = get_identifier(*v))
    return ptr;

  auto ty = llvm_type2alive(v->getType());
  if (!ty)
    return nullptr;

  // automatic splat of constant values
  if (auto vty = dyn_cast<llvm::FixedVectorType>(v->getType());
      vty && isa<llvm::ConstantInt, llvm::ConstantFP>(v)) {
    llvm::Value *llvm_splat = nullptr;
    if (auto cnst = dyn_cast<llvm::ConstantInt>(v)) {
      llvm_splat
        = llvm::ConstantInt::get(vty->getElementType(), cnst->getValue());
    } else if (auto cnst = dyn_cast<llvm::ConstantFP>(v)) {
      llvm_splat
        = llvm::ConstantFP::get(vty->getElementType(), cnst->getValue());
    } else
      UNREACHABLE();

    auto splat = get_operand(llvm_splat, constexpr_conv, copy_inserter,
                             register_fn_decl);
    if (!splat)
      return nullptr;

    vector<Value*> vals(vty->getNumElements(), splat);
    auto val = make_unique<AggregateValue>(*ty, std::move(vals));
    auto ret = val.get();
    current_fn->addConstant(std::move(val));
    RETURN_CACHE(ret);
  }

  if (auto cnst = dyn_cast<llvm::ConstantInt>(v)) {
    RETURN_CACHE(make_intconst(cnst->getValue()));
  }

  if (auto cnst = dyn_cast<llvm::ConstantFP>(v)) {
    auto &apfloat = cnst->getValueAPF();
    auto c
     = make_unique<FloatConst>(*ty,
                               toString(apfloat.bitcastToAPInt(), 10, false),
                               true);
    auto ret = c.get();
    current_fn->addConstant(std::move(c));
    RETURN_CACHE(ret);
  }

  if (isa<llvm::PoisonValue>(v)) {
    RETURN_CACHE(get_poison(*ty));
  }

  if (isa<llvm::UndefValue>(v)) {
    auto val = make_unique<UndefValue>(*ty);
    auto ret = val.get();