nils.hoelscher
/
llvm-for-llvmta
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
llvm-for-llvmta/lib/Target/AMDGPU/AMDGPULibFunc.cpp

1052 lines
38 KiB
C++
Raw Normal View History

first commit
2022-04-25 10:02:23 +02:00
//===-- AMDGPULibFunc.cpp -------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file contains utility functions to work with Itanium mangled names
//
//===----------------------------------------------------------------------===//
#include "AMDGPULibFunc.h"
#include "AMDGPU.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/ValueSymbolTable.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
namespace {
enum EManglingParam {
E_NONE,
EX_EVENT,
EX_FLOAT4,
EX_INTV4,
EX_RESERVEDID,
EX_SAMPLER,
EX_SIZET,
EX_UINT,
EX_UINTV4,
E_ANY,
E_CONSTPTR_ANY,
E_CONSTPTR_SWAPGL,
E_COPY,
E_IMAGECOORDS,
E_POINTEE,
E_SETBASE_I32,
E_SETBASE_U32,
E_MAKEBASE_UNS,
E_V16_OF_POINTEE,
E_V2_OF_POINTEE,
E_V3_OF_POINTEE,
E_V4_OF_POINTEE,
E_V8_OF_POINTEE,
E_VLTLPTR_ANY,
};
struct ManglingRule {
const char *Name;
unsigned char Lead[2];
unsigned char Param[5];
int maxLeadIndex() const { return (std::max)(Lead[0], Lead[1]); }
int getNumLeads() const { return (Lead[0] ? 1 : 0) + (Lead[1] ? 1 : 0); }
unsigned getNumArgs() const;
static StringMap<int> buildManglingRulesMap();
};
// Information about library functions with unmangled names.
class UnmangledFuncInfo {
const char *Name;
unsigned NumArgs;
// Table for all lib functions with unmangled names.
static const UnmangledFuncInfo Table[];
// Number of entries in Table.
static const unsigned TableSize;
static StringMap<unsigned> buildNameMap();
public:
using ID = AMDGPULibFunc::EFuncId;
constexpr UnmangledFuncInfo(const char *_Name, unsigned _NumArgs)
: Name(_Name), NumArgs(_NumArgs) {}
// Get index to Table by function name.
static bool lookup(StringRef Name, ID &Id);
static unsigned toIndex(ID Id) {
assert(static_cast<unsigned>(Id) >
static_cast<unsigned>(AMDGPULibFunc::EI_LAST_MANGLED) &&
"Invalid unmangled library function");
return static_cast<unsigned>(Id) - 1 -
static_cast<unsigned>(AMDGPULibFunc::EI_LAST_MANGLED);
}
static ID toFuncId(unsigned Index) {
assert(Index < TableSize &&
"Invalid unmangled library function");
return static_cast<ID>(
Index + 1 + static_cast<unsigned>(AMDGPULibFunc::EI_LAST_MANGLED));
}
static unsigned getNumArgs(ID Id) { return Table[toIndex(Id)].NumArgs; }
static StringRef getName(ID Id) { return Table[toIndex(Id)].Name; }
};
unsigned ManglingRule::getNumArgs() const {
unsigned I=0;
while (I < (sizeof Param/sizeof Param[0]) && Param[I]) ++I;
return I;
}
// This table describes function formal argument type rules. The order of rules
// corresponds to the EFuncId enum at AMDGPULibFunc.h
//
// "<func name>", { <leads> }, { <param rules> }
// where:
// <leads> - list of integers that are one-based indexes of formal argument
// used to mangle a function name. Other argument types are derived from types
// of these 'leads'. The order of integers in this list correspond to the
// order in which these arguments are mangled in the EDG mangling scheme. The
// same order should be preserved for arguments in the AMDGPULibFunc structure
// when it is used for mangling. For example:
// { "vstorea_half", {3,1}, {E_ANY,EX_SIZET,E_ANY}},
// will be mangled in EDG scheme as vstorea_half_<3dparam>_<1stparam>
// When mangling from code use:
// AMDGPULibFunc insc;
// insc.param[0] = ... // describe 3rd parameter
// insc.param[1] = ... // describe 1rd parameter
//
// <param rules> - list of rules used to derive all of the function formal
// argument types. EX_ prefixed are simple types, other derived from the
// latest 'lead' argument type in the order of encoding from first to last.
// E_ANY - use prev lead type, E_CONSTPTR_ANY - make const pointer out of
// prev lead type, etc. see ParamIterator::getNextParam() for details.
static constexpr ManglingRule manglingRules[] = {
{ "", {0}, {0} },
{ "abs" , {1}, {E_ANY}},
{ "abs_diff" , {1}, {E_ANY,E_COPY}},
{ "acos" , {1}, {E_ANY}},
{ "acosh" , {1}, {E_ANY}},
{ "acospi" , {1}, {E_ANY}},
{ "add_sat" , {1}, {E_ANY,E_COPY}},
{ "all" , {1}, {E_ANY}},
{ "any" , {1}, {E_ANY}},
{ "asin" , {1}, {E_ANY}},
{ "asinh" , {1}, {E_ANY}},
{ "asinpi" , {1}, {E_ANY}},
{ "async_work_group_copy" , {1}, {E_ANY,E_CONSTPTR_SWAPGL,EX_SIZET,EX_EVENT}},
{ "async_work_group_strided_copy" , {1}, {E_ANY,E_CONSTPTR_SWAPGL,EX_SIZET,EX_SIZET,EX_EVENT}},
{ "atan" , {1}, {E_ANY}},
{ "atan2" , {1}, {E_ANY,E_COPY}},
{ "atan2pi" , {1}, {E_ANY,E_COPY}},
{ "atanh" , {1}, {E_ANY}},
{ "atanpi" , {1}, {E_ANY}},
{ "atomic_add" , {1}, {E_VLTLPTR_ANY,E_POINTEE}},
{ "atomic_and" , {1}, {E_VLTLPTR_ANY,E_POINTEE}},
{ "atomic_cmpxchg" , {1}, {E_VLTLPTR_ANY,E_POINTEE,E_POINTEE}},
{ "atomic_dec" , {1}, {E_VLTLPTR_ANY}},
{ "atomic_inc" , {1}, {E_VLTLPTR_ANY}},
{ "atomic_max" , {1}, {E_VLTLPTR_ANY,E_POINTEE}},
{ "atomic_min" , {1}, {E_VLTLPTR_ANY,E_POINTEE}},
{ "atomic_or" , {1}, {E_VLTLPTR_ANY,E_POINTEE}},
{ "atomic_sub" , {1}, {E_VLTLPTR_ANY,E_POINTEE}},
{ "atomic_xchg" , {1}, {E_VLTLPTR_ANY,E_POINTEE}},
{ "atomic_xor" , {1}, {E_VLTLPTR_ANY,E_POINTEE}},
{ "bitselect" , {1}, {E_ANY,E_COPY,E_COPY}},
{ "cbrt" , {1}, {E_ANY}},
{ "ceil" , {1}, {E_ANY}},
{ "clamp" , {1}, {E_ANY,E_COPY,E_COPY}},
{ "clz" , {1}, {E_ANY}},
{ "commit_read_pipe" , {1}, {E_ANY,EX_RESERVEDID}},
{ "commit_write_pipe" , {1}, {E_ANY,EX_RESERVEDID}},
{ "copysign" , {1}, {E_ANY,E_COPY}},
{ "cos" , {1}, {E_ANY}},
{ "cosh" , {1}, {E_ANY}},
{ "cospi" , {1}, {E_ANY}},
{ "cross" , {1}, {E_ANY,E_COPY}},
{ "ctz" , {1}, {E_ANY}},
{ "degrees" , {1}, {E_ANY}},
{ "distance" , {1}, {E_ANY,E_COPY}},
{ "divide" , {1}, {E_ANY,E_COPY}},
{ "dot" , {1}, {E_ANY,E_COPY}},
{ "erf" , {1}, {E_ANY}},
{ "erfc" , {1}, {E_ANY}},
{ "exp" , {1}, {E_ANY}},
{ "exp10" , {1}, {E_ANY}},
{ "exp2" , {1}, {E_ANY}},
{ "expm1" , {1}, {E_ANY}},
{ "fabs" , {1}, {E_ANY}},
{ "fast_distance" , {1}, {E_ANY,E_COPY}},
{ "fast_length" , {1}, {E_ANY}},
{ "fast_normalize" , {1}, {E_ANY}},
{ "fdim" , {1}, {E_ANY,E_COPY}},
{ "floor" , {1}, {E_ANY}},
{ "fma" , {1}, {E_ANY,E_COPY,E_COPY}},
{ "fmax" , {1}, {E_ANY,E_COPY}},
{ "fmin" , {1}, {E_ANY,E_COPY}},
{ "fmod" , {1}, {E_ANY,E_COPY}},
{ "fract" , {2}, {E_POINTEE,E_ANY}},
{ "frexp" , {1,2}, {E_ANY,E_ANY}},
{ "get_image_array_size" , {1}, {E_ANY}},
{ "get_image_channel_data_type" , {1}, {E_ANY}},
{ "get_image_channel_order" , {1}, {E_ANY}},
{ "get_image_dim" , {1}, {E_ANY}},
{ "get_image_height" , {1}, {E_ANY}},
{ "get_image_width" , {1}, {E_ANY}},
{ "get_pipe_max_packets" , {1}, {E_ANY}},
{ "get_pipe_num_packets" , {1}, {E_ANY}},
{ "hadd" , {1}, {E_ANY,E_COPY}},
{ "hypot" , {1}, {E_ANY,E_COPY}},
{ "ilogb" , {1}, {E_ANY}},
{ "isequal" , {1}, {E_ANY,E_COPY}},
{ "isfinite" , {1}, {E_ANY}},
{ "isgreater" , {1}, {E_ANY,E_COPY}},
{ "isgreaterequal" , {1}, {E_ANY,E_COPY}},
{ "isinf" , {1}, {E_ANY}},
{ "isless" , {1}, {E_ANY,E_COPY}},
{ "islessequal" , {1}, {E_ANY,E_COPY}},
{ "islessgreater" , {1}, {E_ANY,E_COPY}},
{ "isnan" , {1}, {E_ANY}},
{ "isnormal" , {1}, {E_ANY}},
{ "isnotequal" , {1}, {E_ANY,E_COPY}},
{ "isordered" , {1}, {E_ANY,E_COPY}},
{ "isunordered" , {1}, {E_ANY,E_COPY}},
{ "ldexp" , {1}, {E_ANY,E_SETBASE_I32}},
{ "length" , {1}, {E_ANY}},
{ "lgamma" , {1}, {E_ANY}},
{ "lgamma_r" , {1,2}, {E_ANY,E_ANY}},
{ "log" , {1}, {E_ANY}},
{ "log10" , {1}, {E_ANY}},
{ "log1p" , {1}, {E_ANY}},
{ "log2" , {1}, {E_ANY}},
{ "logb" , {1}, {E_ANY}},
{ "mad" , {1}, {E_ANY,E_COPY,E_COPY}},
{ "mad24" , {1}, {E_ANY,E_COPY,E_COPY}},
{ "mad_hi" , {1}, {E_ANY,E_COPY,E_COPY}},
{ "mad_sat" , {1}, {E_ANY,E_COPY,E_COPY}},
{ "max" , {1}, {E_ANY,E_COPY}},
{ "maxmag" , {1}, {E_ANY,E_COPY}},
{ "min" , {1}, {E_ANY,E_COPY}},
{ "minmag" , {1}, {E_ANY,E_COPY}},
{ "mix" , {1}, {E_ANY,E_COPY,E_COPY}},
{ "modf" , {2}, {E_POINTEE,E_ANY}},
{ "mul24" , {1}, {E_ANY,E_COPY}},
{ "mul_hi" , {1}, {E_ANY,E_COPY}},
{ "nan" , {1}, {E_ANY}},
{ "nextafter" , {1}, {E_ANY,E_COPY}},
{ "normalize" , {1}, {E_ANY}},
{ "popcount" , {1}, {E_ANY}},
{ "pow" , {1}, {E_ANY,E_COPY}},
{ "pown" , {1}, {E_ANY,E_SETBASE_I32}},
{ "powr" , {1}, {E_ANY,E_COPY}},
{ "prefetch" , {1}, {E_CONSTPTR_ANY,EX_SIZET}},
{ "radians" , {1}, {E_ANY}},
{ "recip" , {1}, {E_ANY}},
{ "remainder" , {1}, {E_ANY,E_COPY}},
{ "remquo" , {1,3}, {E_ANY,E_COPY,E_ANY}},
{ "reserve_read_pipe" , {1}, {E_ANY,EX_UINT}},
{ "reserve_write_pipe" , {1}, {E_ANY,EX_UINT}},
{ "rhadd" , {1}, {E_ANY,E_COPY}},
{ "rint" , {1}, {E_ANY}},
{ "rootn" , {1}, {E_ANY,E_SETBASE_I32}},
{ "rotate" , {1}, {E_ANY,E_COPY}},
{ "round" , {1}, {E_ANY}},
{ "rsqrt" , {1}, {E_ANY}},
{ "select" , {1,3}, {E_ANY,E_COPY,E_ANY}},
{ "shuffle" , {1,2}, {E_ANY,E_ANY}},
{ "shuffle2" , {1,3}, {E_ANY,E_COPY,E_ANY}},
{ "sign" , {1}, {E_ANY}},
{ "signbit" , {1}, {E_ANY}},
{ "sin" , {1}, {E_ANY}},
{ "sincos" , {2}, {E_POINTEE,E_ANY}},
{ "sinh" , {1}, {E_ANY}},
{ "sinpi" , {1}, {E_ANY}},
{ "smoothstep" , {1}, {E_ANY,E_COPY,E_COPY}},
{ "sqrt" , {1}, {E_ANY}},
{ "step" , {1}, {E_ANY,E_COPY}},
{ "sub_group_broadcast" , {1}, {E_ANY,EX_UINT}},
{ "sub_group_commit_read_pipe" , {1}, {E_ANY,EX_RESERVEDID}},
{ "sub_group_commit_write_pipe" , {1}, {E_ANY,EX_RESERVEDID}},
{ "sub_group_reduce_add" , {1}, {E_ANY}},
{ "sub_group_reduce_max" , {1}, {E_ANY}},
{ "sub_group_reduce_min" , {1}, {E_ANY}},
{ "sub_group_reserve_read_pipe" , {1}, {E_ANY,EX_UINT}},
{ "sub_group_reserve_write_pipe" , {1}, {E_ANY,EX_UINT}},
{ "sub_group_scan_exclusive_add" , {1}, {E_ANY}},
{ "sub_group_scan_exclusive_max" , {1}, {E_ANY}},
{ "sub_group_scan_exclusive_min" , {1}, {E_ANY}},
{ "sub_group_scan_inclusive_add" , {1}, {E_ANY}},
{ "sub_group_scan_inclusive_max" , {1}, {E_ANY}},
{ "sub_group_scan_inclusive_min" , {1}, {E_ANY}},
{ "sub_sat" , {1}, {E_ANY,E_COPY}},
{ "tan" , {1}, {E_ANY}},
{ "tanh" , {1}, {E_ANY}},
{ "tanpi" , {1}, {E_ANY}},
{ "tgamma" , {1}, {E_ANY}},
{ "trunc" , {1}, {E_ANY}},
{ "upsample" , {1}, {E_ANY,E_MAKEBASE_UNS}},
{ "vec_step" , {1}, {E_ANY}},
{ "vstore" , {3}, {E_POINTEE,EX_SIZET,E_ANY}},
{ "vstore16" , {3}, {E_V16_OF_POINTEE,EX_SIZET,E_ANY}},
{ "vstore2" , {3}, {E_V2_OF_POINTEE,EX_SIZET,E_ANY}},
{ "vstore3" , {3}, {E_V3_OF_POINTEE,EX_SIZET,E_ANY}},
{ "vstore4" , {3}, {E_V4_OF_POINTEE,EX_SIZET,E_ANY}},
{ "vstore8" , {3}, {E_V8_OF_POINTEE,EX_SIZET,E_ANY}},
{ "work_group_commit_read_pipe" , {1}, {E_ANY,EX_RESERVEDID}},
{ "work_group_commit_write_pipe" , {1}, {E_ANY,EX_RESERVEDID}},
{ "work_group_reduce_add" , {1}, {E_ANY}},
{ "work_group_reduce_max" , {1}, {E_ANY}},
{ "work_group_reduce_min" , {1}, {E_ANY}},
{ "work_group_reserve_read_pipe" , {1}, {E_ANY,EX_UINT}},
{ "work_group_reserve_write_pipe" , {1}, {E_ANY,EX_UINT}},
{ "work_group_scan_exclusive_add" , {1}, {E_ANY}},
{ "work_group_scan_exclusive_max" , {1}, {E_ANY}},
{ "work_group_scan_exclusive_min" , {1}, {E_ANY}},
{ "work_group_scan_inclusive_add" , {1}, {E_ANY}},
{ "work_group_scan_inclusive_max" , {1}, {E_ANY}},
{ "work_group_scan_inclusive_min" , {1}, {E_ANY}},
{ "write_imagef" , {1}, {E_ANY,E_IMAGECOORDS,EX_FLOAT4}},
{ "write_imagei" , {1}, {E_ANY,E_IMAGECOORDS,EX_INTV4}},
{ "write_imageui" , {1}, {E_ANY,E_IMAGECOORDS,EX_UINTV4}},
{ "ncos" , {1}, {E_ANY} },
{ "nexp2" , {1}, {E_ANY} },
{ "nfma" , {1}, {E_ANY, E_COPY, E_COPY} },
{ "nlog2" , {1}, {E_ANY} },
{ "nrcp" , {1}, {E_ANY} },
{ "nrsqrt" , {1}, {E_ANY} },
{ "nsin" , {1}, {E_ANY} },
{ "nsqrt" , {1}, {E_ANY} },
{ "ftz" , {1}, {E_ANY} },
{ "fldexp" , {1}, {E_ANY, EX_UINT} },
{ "class" , {1}, {E_ANY, EX_UINT} },
{ "rcbrt" , {1}, {E_ANY} },
};
// Library functions with unmangled name.
const UnmangledFuncInfo UnmangledFuncInfo::Table[] = {
{"__read_pipe_2", 4},
{"__read_pipe_4", 6},
{"__write_pipe_2", 4},
{"__write_pipe_4", 6},
};
const unsigned UnmangledFuncInfo::TableSize =
array_lengthof(UnmangledFuncInfo::Table);
static AMDGPULibFunc::Param getRetType(AMDGPULibFunc::EFuncId id,
const AMDGPULibFunc::Param (&Leads)[2]) {
AMDGPULibFunc::Param Res = Leads[0];
// TBD - This switch may require to be extended for other intriniscs
switch (id) {
case AMDGPULibFunc::EI_SINCOS:
Res.PtrKind = AMDGPULibFunc::BYVALUE;
break;
default:
break;
}
return Res;
}
class ParamIterator {
const AMDGPULibFunc::Param (&Leads)[2];
const ManglingRule& Rule;
int Index;
public:
ParamIterator(const AMDGPULibFunc::Param (&leads)[2],
const ManglingRule& rule)
: Leads(leads), Rule(rule), Index(0) {}
AMDGPULibFunc::Param getNextParam();
};
AMDGPULibFunc::Param ParamIterator::getNextParam() {
AMDGPULibFunc::Param P;
if (Index >= int(sizeof Rule.Param/sizeof Rule.Param[0])) return P;
const char R = Rule.Param[Index];
switch (R) {
case E_NONE: break;
case EX_UINT:
P.ArgType = AMDGPULibFunc::U32; break;
case EX_INTV4:
P.ArgType = AMDGPULibFunc::I32; P.VectorSize = 4; break;
case EX_UINTV4:
P.ArgType = AMDGPULibFunc::U32; P.VectorSize = 4; break;
case EX_FLOAT4:
P.ArgType = AMDGPULibFunc::F32; P.VectorSize = 4; break;
case EX_SIZET:
P.ArgType = AMDGPULibFunc::U64; break;
case EX_EVENT:
P.ArgType = AMDGPULibFunc::EVENT; break;
case EX_SAMPLER:
P.ArgType = AMDGPULibFunc::SAMPLER; break;
case EX_RESERVEDID: break; // TBD
default:
if (Index == (Rule.Lead[1] - 1)) P = Leads[1];
else P = Leads[0];
switch (R) {
case E_ANY:
case E_COPY: break;
case E_POINTEE:
P.PtrKind = AMDGPULibFunc::BYVALUE; break;
case E_V2_OF_POINTEE:
P.VectorSize = 2; P.PtrKind = AMDGPULibFunc::BYVALUE; break;
case E_V3_OF_POINTEE:
P.VectorSize = 3; P.PtrKind = AMDGPULibFunc::BYVALUE; break;
case E_V4_OF_POINTEE:
P.VectorSize = 4; P.PtrKind = AMDGPULibFunc::BYVALUE; break;
case E_V8_OF_POINTEE:
P.VectorSize = 8; P.PtrKind = AMDGPULibFunc::BYVALUE; break;
case E_V16_OF_POINTEE:
P.VectorSize = 16; P.PtrKind = AMDGPULibFunc::BYVALUE; break;
case E_CONSTPTR_ANY:
P.PtrKind |= AMDGPULibFunc::CONST; break;
case E_VLTLPTR_ANY:
P.PtrKind |= AMDGPULibFunc::VOLATILE; break;
case E_SETBASE_I32:
P.ArgType = AMDGPULibFunc::I32; break;
case E_SETBASE_U32:
P.ArgType = AMDGPULibFunc::U32; break;
case E_MAKEBASE_UNS:
P.ArgType &= ~AMDGPULibFunc::BASE_TYPE_MASK;
P.ArgType |= AMDGPULibFunc::UINT;
break;
case E_IMAGECOORDS:
switch (P.ArgType) {
case AMDGPULibFunc::IMG1DA: P.VectorSize = 2; break;
case AMDGPULibFunc::IMG1DB: P.VectorSize = 1; break;
case AMDGPULibFunc::IMG2DA: P.VectorSize = 4; break;
case AMDGPULibFunc::IMG1D: P.VectorSize = 1; break;
case AMDGPULibFunc::IMG2D: P.VectorSize = 2; break;
case AMDGPULibFunc::IMG3D: P.VectorSize = 4; break;
}
P.PtrKind = AMDGPULibFunc::BYVALUE;
P.ArgType = AMDGPULibFunc::I32;
break;
case E_CONSTPTR_SWAPGL: {
unsigned AS = AMDGPULibFunc::getAddrSpaceFromEPtrKind(P.PtrKind);
switch (AS) {
case AMDGPUAS::GLOBAL_ADDRESS: AS = AMDGPUAS::LOCAL_ADDRESS; break;
case AMDGPUAS::LOCAL_ADDRESS: AS = AMDGPUAS::GLOBAL_ADDRESS; break;
}
P.PtrKind = AMDGPULibFunc::getEPtrKindFromAddrSpace(AS);
P.PtrKind |= AMDGPULibFunc::CONST;
break;
}
default: llvm_unreachable("Unhandeled param rule");
}
}
++Index;
return P;
}
inline static void drop_front(StringRef& str, size_t n = 1) {
str = str.drop_front(n);
}
static bool eatTerm(StringRef& mangledName, const char c) {
if (mangledName.front() == c) {
drop_front(mangledName);
return true;
}
return false;
}
template <size_t N>
static bool eatTerm(StringRef& mangledName, const char (&str)[N]) {
if (mangledName.startswith(StringRef(str, N-1))) {
drop_front(mangledName, N-1);
return true;
}
return false;
}
static int eatNumber(StringRef& s) {
size_t const savedSize = s.size();
int n = 0;
while (!s.empty() && isDigit(s.front())) {
n = n*10 + s.front() - '0';
drop_front(s);
}
return s.size() < savedSize ? n : -1;
}
static StringRef eatLengthPrefixedName(StringRef& mangledName) {
int const Len = eatNumber(mangledName);
if (Len <= 0 || static_cast<size_t>(Len) > mangledName.size())
return StringRef();
StringRef Res = mangledName.substr(0, Len);
drop_front(mangledName, Len);
return Res;
}
} // end anonymous namespace
AMDGPUMangledLibFunc::AMDGPUMangledLibFunc() {
FuncId = EI_NONE;
FKind = NOPFX;
Leads[0].reset();
Leads[1].reset();
Name.clear();
}
AMDGPUUnmangledLibFunc::AMDGPUUnmangledLibFunc() {
FuncId = EI_NONE;
FuncTy = nullptr;
}
AMDGPUMangledLibFunc::AMDGPUMangledLibFunc(
EFuncId id, const AMDGPUMangledLibFunc &copyFrom) {
FuncId = id;
FKind = copyFrom.FKind;
Leads[0] = copyFrom.Leads[0];
Leads[1] = copyFrom.Leads[1];
}
///////////////////////////////////////////////////////////////////////////////
// Demangling
static int parseVecSize(StringRef& mangledName) {
size_t const Len = eatNumber(mangledName);
switch (Len) {
case 2: case 3: case 4: case 8: case 16:
return Len;
default:
break;
}
return 1;
}
static AMDGPULibFunc::ENamePrefix parseNamePrefix(StringRef& mangledName) {
std::pair<StringRef, StringRef> const P = mangledName.split('_');
AMDGPULibFunc::ENamePrefix Pfx =
StringSwitch<AMDGPULibFunc::ENamePrefix>(P.first)
.Case("native", AMDGPULibFunc::NATIVE)
.Case("half" , AMDGPULibFunc::HALF)
.Default(AMDGPULibFunc::NOPFX);
if (Pfx != AMDGPULibFunc::NOPFX)
mangledName = P.second;
return Pfx;
}
StringMap<int> ManglingRule::buildManglingRulesMap() {
StringMap<int> Map(array_lengthof(manglingRules));
int Id = 0;
for (auto Rule : manglingRules)
Map.insert({Rule.Name, Id++});
return Map;
}
bool AMDGPUMangledLibFunc::parseUnmangledName(StringRef FullName) {
static const StringMap<int> manglingRulesMap =
ManglingRule::buildManglingRulesMap();
FuncId = static_cast<EFuncId>(manglingRulesMap.lookup(FullName));
return FuncId != EI_NONE;
}
///////////////////////////////////////////////////////////////////////////////
// Itanium Demangling
namespace {
struct ItaniumParamParser {
AMDGPULibFunc::Param Prev;
bool parseItaniumParam(StringRef& param, AMDGPULibFunc::Param &res);
};
} // namespace
bool ItaniumParamParser::parseItaniumParam(StringRef& param,
AMDGPULibFunc::Param &res) {
res.reset();
if (param.empty()) return false;
// parse pointer prefix
if (eatTerm(param, 'P')) {
if (eatTerm(param, 'K')) res.PtrKind |= AMDGPULibFunc::CONST;
if (eatTerm(param, 'V')) res.PtrKind |= AMDGPULibFunc::VOLATILE;
unsigned AS;
if (!eatTerm(param, "U3AS")) {
AS = 0;
} else {
AS = param.front() - '0';
drop_front(param, 1);
}
res.PtrKind |= AMDGPULibFuncBase::getEPtrKindFromAddrSpace(AS);
} else {
res.PtrKind = AMDGPULibFunc::BYVALUE;
}
// parse vector size
if (eatTerm(param,"Dv")) {
res.VectorSize = parseVecSize(param);
if (res.VectorSize==1 || !eatTerm(param, '_')) return false;
}
// parse type
char const TC = param.front();
if (isDigit(TC)) {
res.ArgType = StringSwitch<AMDGPULibFunc::EType>
(eatLengthPrefixedName(param))
.Case("ocl_image1darray" , AMDGPULibFunc::IMG1DA)
.Case("ocl_image1dbuffer", AMDGPULibFunc::IMG1DB)
.Case("ocl_image2darray" , AMDGPULibFunc::IMG2DA)
.Case("ocl_image1d" , AMDGPULibFunc::IMG1D)
.Case("ocl_image2d" , AMDGPULibFunc::IMG2D)
.Case("ocl_image3d" , AMDGPULibFunc::IMG3D)
.Case("ocl_event" , AMDGPULibFunc::DUMMY)
.Case("ocl_sampler" , AMDGPULibFunc::DUMMY)
.Default(AMDGPULibFunc::DUMMY);
} else {
drop_front(param);
switch (TC) {
case 'h': res.ArgType = AMDGPULibFunc::U8; break;
case 't': res.ArgType = AMDGPULibFunc::U16; break;
case 'j': res.ArgType = AMDGPULibFunc::U32; break;
case 'm': res.ArgType = AMDGPULibFunc::U64; break;
case 'c': res.ArgType = AMDGPULibFunc::I8; break;
case 's': res.ArgType = AMDGPULibFunc::I16; break;
case 'i': res.ArgType = AMDGPULibFunc::I32; break;
case 'l': res.ArgType = AMDGPULibFunc::I64; break;
case 'f': res.ArgType = AMDGPULibFunc::F32; break;
case 'd': res.ArgType = AMDGPULibFunc::F64; break;
case 'D': if (!eatTerm(param, 'h')) return false;
res.ArgType = AMDGPULibFunc::F16; break;
case 'S':
if (!eatTerm(param, '_')) {
eatNumber(param);
if (!eatTerm(param, '_')) return false;
}
res.VectorSize = Prev.VectorSize;
res.ArgType = Prev.ArgType;
break;
default:;
}
}
if (res.ArgType == 0) return false;
Prev.VectorSize = res.VectorSize;
Prev.ArgType = res.ArgType;
return true;
}
bool AMDGPUMangledLibFunc::parseFuncName(StringRef &mangledName) {
StringRef Name = eatLengthPrefixedName(mangledName);
FKind = parseNamePrefix(Name);
if (!parseUnmangledName(Name))
return false;
const ManglingRule& Rule = manglingRules[FuncId];
ItaniumParamParser Parser;
for (int I=0; I < Rule.maxLeadIndex(); ++I) {
Param P;
if (!Parser.parseItaniumParam(mangledName, P))
return false;
if ((I + 1) == Rule.Lead[0]) Leads[0] = P;
if ((I + 1) == Rule.Lead[1]) Leads[1] = P;
}
return true;
}
bool AMDGPUUnmangledLibFunc::parseFuncName(StringRef &Name) {
if (!UnmangledFuncInfo::lookup(Name, FuncId))
return false;
setName(Name);
return true;
}
bool AMDGPULibFunc::parse(StringRef FuncName, AMDGPULibFunc &F) {
if (FuncName.empty()) {
F.Impl = std::unique_ptr<AMDGPULibFuncImpl>();
return false;
}
if (eatTerm(FuncName, "_Z"))
F.Impl = std::make_unique<AMDGPUMangledLibFunc>();
else
F.Impl = std::make_unique<AMDGPUUnmangledLibFunc>();
if (F.Impl->parseFuncName(FuncName))
return true;
F.Impl = std::unique_ptr<AMDGPULibFuncImpl>();
return false;
}
StringRef AMDGPUMangledLibFunc::getUnmangledName(StringRef mangledName) {
StringRef S = mangledName;
if (eatTerm(S, "_Z"))
return eatLengthPrefixedName(S);
return StringRef();
}
///////////////////////////////////////////////////////////////////////////////
// Mangling
template <typename Stream>
void AMDGPUMangledLibFunc::writeName(Stream &OS) const {
const char *Pfx = "";
switch (FKind) {
case NATIVE: Pfx = "native_"; break;
case HALF: Pfx = "half_"; break;
default: break;
}
if (!Name.empty()) {
OS << Pfx << Name;
} else if (FuncId != EI_NONE) {
OS << Pfx;
const StringRef& S = manglingRules[FuncId].Name;
OS.write(S.data(), S.size());
}
}
std::string AMDGPUMangledLibFunc::mangle() const { return mangleNameItanium(); }
///////////////////////////////////////////////////////////////////////////////
// Itanium Mangling
static const char *getItaniumTypeName(AMDGPULibFunc::EType T) {
switch (T) {
case AMDGPULibFunc::U8: return "h";
case AMDGPULibFunc::U16: return "t";
case AMDGPULibFunc::U32: return "j";
case AMDGPULibFunc::U64: return "m";
case AMDGPULibFunc::I8: return "c";
case AMDGPULibFunc::I16: return "s";
case AMDGPULibFunc::I32: return "i";
case AMDGPULibFunc::I64: return "l";
case AMDGPULibFunc::F16: return "Dh";
case AMDGPULibFunc::F32: return "f";
case AMDGPULibFunc::F64: return "d";
case AMDGPULibFunc::IMG1DA: return "16ocl_image1darray";
case AMDGPULibFunc::IMG1DB: return "17ocl_image1dbuffer";
case AMDGPULibFunc::IMG2DA: return "16ocl_image2darray";
case AMDGPULibFunc::IMG1D: return "11ocl_image1d";
case AMDGPULibFunc::IMG2D: return "11ocl_image2d";
case AMDGPULibFunc::IMG3D: return "11ocl_image3d";
case AMDGPULibFunc::SAMPLER: return "11ocl_sampler";
case AMDGPULibFunc::EVENT: return "9ocl_event";
default: llvm_unreachable("Unhandeled param type");
}
return nullptr;
}
namespace {
// Itanium mangling ABI says:
// "5.1.8. Compression
// ... Each non-terminal in the grammar for which <substitution> appears on the
// right-hand side is both a source of future substitutions and a candidate
// for being substituted. There are two exceptions that appear to be
// substitution candidates from the grammar, but are explicitly excluded:
// 1. <builtin-type> other than vendor extended types ..."
// For the purpose of functions the following productions make sence for the
// substitution:
// <type> ::= <builtin-type>
// ::= <class-enum-type>
// ::= <array-type>
// ::=<CV-qualifiers> <type>
// ::= P <type> # pointer-to
// ::= <substitution>
//
// Note that while types like images, samplers and events are by the ABI encoded
// using <class-enum-type> production rule they're not used for substitution
// because clang consider them as builtin types.
//
// DvNN_ type is GCC extension for vectors and is a subject for the substitution.
class ItaniumMangler {
SmallVector<AMDGPULibFunc::Param, 10> Str; // list of accumulated substituions
bool UseAddrSpace;
int findSubst(const AMDGPULibFunc::Param& P) const {
for(unsigned I = 0; I < Str.size(); ++I) {
const AMDGPULibFunc::Param& T = Str[I];
if (P.PtrKind == T.PtrKind &&
P.VectorSize == T.VectorSize &&
P.ArgType == T.ArgType) {
return I;
}
}
return -1;
}
template <typename Stream>
bool trySubst(Stream& os, const AMDGPULibFunc::Param& p) {
int const subst = findSubst(p);
if (subst < 0) return false;
// Substitutions are mangled as S(XX)?_ where XX is a hexadecimal number
// 0 1 2
// S_ S0_ S1_
if (subst == 0) os << "S_";
else os << 'S' << (subst-1) << '_';
return true;
}
public:
ItaniumMangler(bool useAddrSpace)
: UseAddrSpace(useAddrSpace) {}
template <typename Stream>
void operator()(Stream& os, AMDGPULibFunc::Param p) {
// Itanium mangling ABI 5.1.8. Compression:
// Logically, the substitutable components of a mangled name are considered
// left-to-right, components before the composite structure of which they
// are a part. If a component has been encountered before, it is substituted
// as described below. This decision is independent of whether its components
// have been substituted, so an implementation may optimize by considering
// large structures for substitution before their components. If a component
// has not been encountered before, its mangling is identified, and it is
// added to a dictionary of substitution candidates. No entity is added to
// the dictionary twice.
AMDGPULibFunc::Param Ptr;
if (p.PtrKind) {
if (trySubst(os, p)) return;
os << 'P';
if (p.PtrKind & AMDGPULibFunc::CONST) os << 'K';
if (p.PtrKind & AMDGPULibFunc::VOLATILE) os << 'V';
unsigned AS = UseAddrSpace
? AMDGPULibFuncBase::getAddrSpaceFromEPtrKind(p.PtrKind)
: 0;
if (AS != 0) os << "U3AS" << AS;
Ptr = p;
p.PtrKind = 0;
}
if (p.VectorSize > 1) {
if (trySubst(os, p)) goto exit;
Str.push_back(p);
os << "Dv" << static_cast<unsigned>(p.VectorSize) << '_';
}
os << getItaniumTypeName((AMDGPULibFunc::EType)p.ArgType);
exit:
if (Ptr.ArgType) Str.push_back(Ptr);
}
};
} // namespace
std::string AMDGPUMangledLibFunc::mangleNameItanium() const {
SmallString<128> Buf;
raw_svector_ostream S(Buf);
SmallString<128> NameBuf;
raw_svector_ostream Name(NameBuf);
writeName(Name);
const StringRef& NameStr = Name.str();
S << "_Z" << static_cast<int>(NameStr.size()) << NameStr;
ItaniumMangler Mangler(true);
ParamIterator I(Leads, manglingRules[FuncId]);
Param P;
while ((P = I.getNextParam()).ArgType != 0)
Mangler(S, P);
return std::string(S.str());
}
///////////////////////////////////////////////////////////////////////////////
// Misc
static Type* getIntrinsicParamType(
LLVMContext& C,
const AMDGPULibFunc::Param& P,
bool useAddrSpace) {
Type* T = nullptr;
switch (P.ArgType) {
case AMDGPULibFunc::U8:
case AMDGPULibFunc::I8: T = Type::getInt8Ty(C); break;
case AMDGPULibFunc::U16:
case AMDGPULibFunc::I16: T = Type::getInt16Ty(C); break;
case AMDGPULibFunc::U32:
case AMDGPULibFunc::I32: T = Type::getInt32Ty(C); break;
case AMDGPULibFunc::U64:
case AMDGPULibFunc::I64: T = Type::getInt64Ty(C); break;
case AMDGPULibFunc::F16: T = Type::getHalfTy(C); break;
case AMDGPULibFunc::F32: T = Type::getFloatTy(C); break;
case AMDGPULibFunc::F64: T = Type::getDoubleTy(C); break;
case AMDGPULibFunc::IMG1DA:
case AMDGPULibFunc::IMG1DB:
case AMDGPULibFunc::IMG2DA:
case AMDGPULibFunc::IMG1D:
case AMDGPULibFunc::IMG2D:
case AMDGPULibFunc::IMG3D:
T = StructType::create(C,"ocl_image")->getPointerTo(); break;
case AMDGPULibFunc::SAMPLER:
T = StructType::create(C,"ocl_sampler")->getPointerTo(); break;
case AMDGPULibFunc::EVENT:
T = StructType::create(C,"ocl_event")->getPointerTo(); break;
default:
llvm_unreachable("Unhandeled param type");
return nullptr;
}
if (P.VectorSize > 1)
T = FixedVectorType::get(T, P.VectorSize);
if (P.PtrKind != AMDGPULibFunc::BYVALUE)
T = useAddrSpace ? T->getPointerTo((P.PtrKind & AMDGPULibFunc::ADDR_SPACE)
- 1)
: T->getPointerTo();
return T;
}
FunctionType *AMDGPUMangledLibFunc::getFunctionType(Module &M) const {
LLVMContext& C = M.getContext();
std::vector<Type*> Args;
ParamIterator I(Leads, manglingRules[FuncId]);
Param P;
while ((P=I.getNextParam()).ArgType != 0)
Args.push_back(getIntrinsicParamType(C, P, true));
return FunctionType::get(
getIntrinsicParamType(C, getRetType(FuncId, Leads), true),
Args, false);
}
unsigned AMDGPUMangledLibFunc::getNumArgs() const {
return manglingRules[FuncId].getNumArgs();
}
unsigned AMDGPUUnmangledLibFunc::getNumArgs() const {
return UnmangledFuncInfo::getNumArgs(FuncId);
}
std::string AMDGPUMangledLibFunc::getName() const {
SmallString<128> Buf;
raw_svector_ostream OS(Buf);
writeName(OS);
return std::string(OS.str());
}
Function *AMDGPULibFunc::getFunction(Module *M, const AMDGPULibFunc &fInfo) {
std::string FuncName = fInfo.mangle();
Function *F = dyn_cast_or_null<Function>(
M->getValueSymbolTable().lookup(FuncName));
// check formal with actual types conformance
if (F && !F->isDeclaration()
&& !F->isVarArg()
&& F->arg_size() == fInfo.getNumArgs()) {
return F;
}
return nullptr;
}
FunctionCallee AMDGPULibFunc::getOrInsertFunction(Module *M,
const AMDGPULibFunc &fInfo) {
std::string const FuncName = fInfo.mangle();
Function *F = dyn_cast_or_null<Function>(
M->getValueSymbolTable().lookup(FuncName));
// check formal with actual types conformance
if (F && !F->isDeclaration()
&& !F->isVarArg()
&& F->arg_size() == fInfo.getNumArgs()) {
return F;
}
FunctionType *FuncTy = fInfo.getFunctionType(*M);
bool hasPtr = false;
for (FunctionType::param_iterator
PI = FuncTy->param_begin(),
PE = FuncTy->param_end();
PI != PE; ++PI) {
const Type* argTy = static_cast<const Type*>(*PI);
if (argTy->isPointerTy()) {
hasPtr = true;
break;
}
}
FunctionCallee C;
if (hasPtr) {
// Do not set extra attributes for functions with pointer arguments.
C = M->getOrInsertFunction(FuncName, FuncTy);
} else {
AttributeList Attr;
LLVMContext &Ctx = M->getContext();
Attr = Attr.addAttribute(Ctx, AttributeList::FunctionIndex,
Attribute::ReadOnly);
Attr = Attr.addAttribute(Ctx, AttributeList::FunctionIndex,
Attribute::NoUnwind);
C = M->getOrInsertFunction(FuncName, FuncTy, Attr);
}
return C;
}
StringMap<unsigned> UnmangledFuncInfo::buildNameMap() {
StringMap<unsigned> Map;
for (unsigned I = 0; I != TableSize; ++I)
Map[Table[I].Name] = I;
return Map;
}
bool UnmangledFuncInfo::lookup(StringRef Name, ID &Id) {
static const StringMap<unsigned> Map = buildNameMap();
auto Loc = Map.find(Name);
if (Loc != Map.end()) {
Id = toFuncId(Loc->second);
return true;
}
Id = AMDGPULibFunc::EI_NONE;
return false;
}
AMDGPULibFunc::AMDGPULibFunc(const AMDGPULibFunc &F) {
if (auto *MF = dyn_cast<AMDGPUMangledLibFunc>(F.Impl.get()))
Impl.reset(new AMDGPUMangledLibFunc(*MF));
else if (auto *UMF = dyn_cast<AMDGPUUnmangledLibFunc>(F.Impl.get()))
Impl.reset(new AMDGPUUnmangledLibFunc(*UMF));
else
Impl = std::unique_ptr<AMDGPULibFuncImpl>();
}
AMDGPULibFunc &AMDGPULibFunc::operator=(const AMDGPULibFunc &F) {
if (this == &F)
return *this;
new (this) AMDGPULibFunc(F);
return *this;
}
AMDGPULibFunc::AMDGPULibFunc(EFuncId Id, const AMDGPULibFunc &CopyFrom) {
assert(AMDGPULibFuncBase::isMangled(Id) && CopyFrom.isMangled() &&
"not supported");
Impl.reset(new AMDGPUMangledLibFunc(
Id, *cast<AMDGPUMangledLibFunc>(CopyFrom.Impl.get())));
}
AMDGPULibFunc::AMDGPULibFunc(StringRef Name, FunctionType *FT) {
Impl.reset(new AMDGPUUnmangledLibFunc(Name, FT));
}
void AMDGPULibFunc::initMangled() { Impl.reset(new AMDGPUMangledLibFunc()); }
AMDGPULibFunc::Param *AMDGPULibFunc::getLeads() {
if (!Impl)
initMangled();
return cast<AMDGPUMangledLibFunc>(Impl.get())->Leads;
}
const AMDGPULibFunc::Param *AMDGPULibFunc::getLeads() const {
return cast<const AMDGPUMangledLibFunc>(Impl.get())->Leads;
}