builder_misc.h

/****************************************************************************
 * Copyright (C) 2014-2015 Intel Corporation.   All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 *
 * @file builder_misc.h
 *
 * @brief miscellaneous builder functions
 *
 * Notes:
 *
 ******************************************************************************/
#pragma once

Constant* C(bool i);
Constant* C(char i);
Constant* C(uint8_t i);
Constant* C(int i);
Constant* C(int64_t i);
Constant* C(uint64_t i);
Constant* C(uint16_t i);
Constant* C(uint32_t i);
Constant* C(float i);

template <typename Ty>
Constant* C(const std::initializer_list<Ty>& constList)
{
    std::vector<Constant*> vConsts;
    for (auto i : constList)
    {
        vConsts.push_back(C((Ty)i));
    }
    return ConstantVector::get(vConsts);
}

template <typename Ty>
Constant* C(const std::vector<Ty>& constList)
{
    std::vector<Constant*> vConsts;
    for (auto i : constList)
    {
        vConsts.push_back(C((Ty)i));
    }
    return ConstantVector::get(vConsts);
}

template <typename Ty>
Constant* CA(LLVMContext& ctx, ArrayRef<Ty> constList)
{
    return ConstantDataArray::get(ctx, constList);
}

template <typename Ty>
Constant* CInc(uint32_t base, uint32_t count)
{
    std::vector<Constant*> vConsts;

    for (uint32_t i = 0; i < count; i++)
    {
        vConsts.push_back(C((Ty)base));
        base++;
    }
    return ConstantVector::get(vConsts);
}

Constant* PRED(bool pred);

Value* VIMMED1(uint64_t i);
Value* VIMMED1_16(uint64_t i);

Value* VIMMED1(int i);
Value* VIMMED1_16(int i);

Value* VIMMED1(uint32_t i);
Value* VIMMED1_16(uint32_t i);

Value* VIMMED1(float i);
Value* VIMMED1_16(float i);

Value* VIMMED1(bool i);
Value* VIMMED1_16(bool i);

Value* VUNDEF(Type* t);

Value* VUNDEF_F();
Value* VUNDEF_F_16();

Value* VUNDEF_I();
Value* VUNDEF_I_16();

Value* VUNDEF(Type* ty, uint32_t size);

Value* VUNDEF_IPTR();

Value* VBROADCAST(Value* src, const llvm::Twine& name = "");
Value* VBROADCAST_16(Value* src);

Value* VRCP(Value* va, const llvm::Twine& name = "");
Value* VPLANEPS(Value* vA, Value* vB, Value* vC, Value*& vX, Value*& vY);

uint32_t IMMED(Value* i);
int32_t  S_IMMED(Value* i);

CallInst* CALL(Value* Callee, const std::initializer_list<Value*>& args, const llvm::Twine& name = "");
CallInst* CALL(Value* Callee)
{
#if LLVM_VERSION_MAJOR >= 11
    // Not a great idea - we loose type info (Function) calling CALL
    // and then we recast it here. Good for now, but needs to be
    // more clean - optimally just always CALL a Function
    return CALLA(FunctionCallee(cast<Function>(Callee)));
#else
    return CALLA(Callee);
#endif
}
CallInst* CALL(Value* Callee, Value* arg);
CallInst* CALL2(Value* Callee, Value* arg1, Value* arg2);
CallInst* CALL3(Value* Callee, Value* arg1, Value* arg2, Value* arg3);

Value* MASK(Value* vmask);
Value* MASK_16(Value* vmask);

Value* VMASK(Value* mask);
Value* VMASK_16(Value* mask);

Value* VMOVMSK(Value* mask);

//////////////////////////////////////////////////////////////////////////
/// @brief Float / Fixed-point conversions
//////////////////////////////////////////////////////////////////////////
// Signed
Value* VCVT_F32_FIXED_SI(Value*             vFloat,
                         uint32_t           numIntBits,
                         uint32_t           numFracBits,
                         const llvm::Twine& name = "");
Value* VCVT_FIXED_SI_F32(Value*             vFixed,
                         uint32_t           numIntBits,
                         uint32_t           numFracBits,
                         const llvm::Twine& name = "");
// Unsigned
Value* VCVT_F32_FIXED_UI(Value*             vFloat,
                         uint32_t           numIntBits,
                         uint32_t           numFracBits,
                         const llvm::Twine& name = "");
Value* VCVT_FIXED_UI_F32(Value*             vFixed,
                         uint32_t           numIntBits,
                         uint32_t           numFracBits,
                         const llvm::Twine& name = "");

//////////////////////////////////////////////////////////////////////////
/// @brief functions that build IR to call x86 intrinsics directly, or
/// emulate them with other instructions if not available on the host
//////////////////////////////////////////////////////////////////////////

Value* EXTRACT_16(Value* x, uint32_t imm);
Value* JOIN_16(Value* a, Value* b);

Value* PSHUFB(Value* a, Value* b);
Value* PMOVSXBD(Value* a);
Value* PMOVSXWD(Value* a);
Value* CVTPH2PS(Value* a, const llvm::Twine& name = "");
Value* CVTPS2PH(Value* a, Value* rounding);
Value* PMAXSD(Value* a, Value* b);
Value* PMINSD(Value* a, Value* b);
Value* PMAXUD(Value* a, Value* b);
Value* PMINUD(Value* a, Value* b);
Value* VABSPS(Value* a);
Value* FMADDPS(Value* a, Value* b, Value* c);

Value* ICLAMP(Value* src, Value* low, Value* high, const llvm::Twine& name = "");
Value* FCLAMP(Value* src, Value* low, Value* high);
Value* FCLAMP(Value* src, float low, float high);

CallInst* PRINT(const std::string& printStr);
CallInst* PRINT(const std::string& printStr, const std::initializer_list<Value*>& printArgs);

Value* VPOPCNT(Value* a);

Value* INT3()
{
    return DEBUGTRAP();
}


Value* VEXTRACTI128(Value* a, Constant* imm8);
Value* VINSERTI128(Value* a, Value* b, Constant* imm8);

// rdtsc buckets macros
void RDTSC_START(Value* pBucketMgr, Value* pId);
void RDTSC_STOP(Value* pBucketMgr, Value* pId);

Value* CreateEntryAlloca(Function* pFunc, Type* pType);
Value* CreateEntryAlloca(Function* pFunc, Type* pType, Value* pArraySize);

uint32_t GetTypeSize(Type* pType);