| //===-- 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 "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 { |
| 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 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 ©From) { |
| 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 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; |
| } |
| |
| 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; |
| } |
