RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 19:23:23 +01:00
Code Issues Projects Releases Wiki Activity
3ba3c2e680
llvm-mirror/lib/Target/AMDGPU/AMDGPULibFunc.cpp
Yaxun Liu 0d9fbc03e5 [AMDGPU] Remove hardcoded address space value from AMDGPULibFunc 
AMDGPULibFunc hardcodes address space values of the old address space mapping,
which causes invalid addrspacecast instructions and undefined functions in
APPSDK sample MonteCarloAsianDP.

This patch fixes that.

Differential Revision: https://reviews.llvm.org/D39616

llvm-svn: 317409
2017-11-04 17:37:43 +00:00

1055 lines
38 KiB
C++
Raw Blame History

//===-- AMDGPULibFunc.cpp -------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains utility functions to work with Itanium mangled names
//
//===----------------------------------------------------------------------===//
#include "AMDGPU.h"
#include "AMDGPULibFunc.h"
#include <llvm/ADT/SmallString.h>
#include <llvm/ADT/SmallVector.h>
#include <llvm/ADT/StringSwitch.h>
#include "llvm/IR/Attributes.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>
#include <string>
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 {
StringRef const 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;
};
// Information about library functions with unmangled names.
class UnmangledFuncInfo {
StringRef const Name;
unsigned NumArgs;
// Table for all lib functions with unmangled names.
static const UnmangledFuncInfo Table[];
// Number of entries in Table.
static const unsigned TableSize;
// Map function name to index.
class NameMap : public StringMap<unsigned> {
public:
NameMap() {
for (unsigned I = 0; I != TableSize; ++I)
(*this)[Table[I].Name] = I;
}
};
friend class NameMap;
static NameMap Map;
public:
using ID = AMDGPULibFunc::EFuncId;
UnmangledFuncInfo() = default;
UnmangledFuncInfo(StringRef _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 const ManglingRule manglingRules[] = {
{ StringRef(), {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 =
sizeof(UnmangledFuncInfo::Table) / sizeof(UnmangledFuncInfo::Table[0]);
UnmangledFuncInfo::NameMap UnmangledFuncInfo::Map;
static const struct ManglingRulesMap : public StringMap<int> {
ManglingRulesMap()
: StringMap<int>(sizeof(manglingRules)/sizeof(manglingRules[0])) {
int Id = 0;
for (auto Rule : manglingRules)
insert({ Rule.Name, Id++ });
}
} manglingRulesMap;
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 inline bool isDigit(char c) { return c >= '0' && c <= '9'; }
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;
}
bool AMDGPUMangledLibFunc::parseUnmangledName(StringRef FullName) {
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 = make_unique<AMDGPUMangledLibFunc>();
else
F.Impl = 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 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 = VectorType::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 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;
}
Function *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;
}
}
Constant *C = nullptr;
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.addAttribute(Ctx, AttributeList::FunctionIndex, Attribute::ReadOnly);
Attr.addAttribute(Ctx, AttributeList::FunctionIndex, Attribute::NoUnwind);
C = M->getOrInsertFunction(FuncName, FuncTy, Attr);
}
return cast<Function>(C);
}
bool UnmangledFuncInfo::lookup(StringRef Name, ID &Id) {
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;
}
Reference in New Issue View Git Blame Copy Permalink