1 //===-- AMDGPULibFunc.cpp -------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file contains utility functions to work with Itanium mangled names 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "AMDGPULibFunc.h" 14 #include "AMDGPU.h" 15 #include "llvm/ADT/SmallString.h" 16 #include "llvm/ADT/SmallVector.h" 17 #include "llvm/ADT/StringExtras.h" 18 #include "llvm/ADT/StringSwitch.h" 19 #include "llvm/IR/Attributes.h" 20 #include "llvm/IR/DerivedTypes.h" 21 #include "llvm/IR/Function.h" 22 #include "llvm/IR/Module.h" 23 #include "llvm/IR/ValueSymbolTable.h" 24 #include "llvm/Support/raw_ostream.h" 25 #include <string> 26 27 using namespace llvm; 28 29 namespace { 30 31 enum EManglingParam { 32 E_NONE, 33 EX_EVENT, 34 EX_FLOAT4, 35 EX_INTV4, 36 EX_RESERVEDID, 37 EX_SAMPLER, 38 EX_SIZET, 39 EX_UINT, 40 EX_UINTV4, 41 E_ANY, 42 E_CONSTPTR_ANY, 43 E_CONSTPTR_SWAPGL, 44 E_COPY, 45 E_IMAGECOORDS, 46 E_POINTEE, 47 E_SETBASE_I32, 48 E_SETBASE_U32, 49 E_MAKEBASE_UNS, 50 E_V16_OF_POINTEE, 51 E_V2_OF_POINTEE, 52 E_V3_OF_POINTEE, 53 E_V4_OF_POINTEE, 54 E_V8_OF_POINTEE, 55 E_VLTLPTR_ANY, 56 }; 57 58 struct ManglingRule { 59 const char *Name; 60 unsigned char Lead[2]; 61 unsigned char Param[5]; 62 63 int maxLeadIndex() const { return (std::max)(Lead[0], Lead[1]); } 64 int getNumLeads() const { return (Lead[0] ? 1 : 0) + (Lead[1] ? 1 : 0); } 65 66 unsigned getNumArgs() const; 67 68 static StringMap<int> buildManglingRulesMap(); 69 }; 70 71 // Information about library functions with unmangled names. 72 class UnmangledFuncInfo { 73 const char *Name; 74 unsigned NumArgs; 75 76 // Table for all lib functions with unmangled names. 77 static const UnmangledFuncInfo Table[]; 78 79 // Number of entries in Table. 80 static const unsigned TableSize; 81 82 static StringMap<unsigned> buildNameMap(); 83 84 public: 85 using ID = AMDGPULibFunc::EFuncId; 86 constexpr UnmangledFuncInfo(const char *_Name, unsigned _NumArgs) 87 : Name(_Name), NumArgs(_NumArgs) {} 88 // Get index to Table by function name. 89 static bool lookup(StringRef Name, ID &Id); 90 static unsigned toIndex(ID Id) { 91 assert(static_cast<unsigned>(Id) > 92 static_cast<unsigned>(AMDGPULibFunc::EI_LAST_MANGLED) && 93 "Invalid unmangled library function"); 94 return static_cast<unsigned>(Id) - 1 - 95 static_cast<unsigned>(AMDGPULibFunc::EI_LAST_MANGLED); 96 } 97 static ID toFuncId(unsigned Index) { 98 assert(Index < TableSize && 99 "Invalid unmangled library function"); 100 return static_cast<ID>( 101 Index + 1 + static_cast<unsigned>(AMDGPULibFunc::EI_LAST_MANGLED)); 102 } 103 static unsigned getNumArgs(ID Id) { return Table[toIndex(Id)].NumArgs; } 104 static StringRef getName(ID Id) { return Table[toIndex(Id)].Name; } 105 }; 106 107 unsigned ManglingRule::getNumArgs() const { 108 unsigned I=0; 109 while (I < (sizeof Param/sizeof Param[0]) && Param[I]) ++I; 110 return I; 111 } 112 113 // This table describes function formal argument type rules. The order of rules 114 // corresponds to the EFuncId enum at AMDGPULibFunc.h 115 // 116 // "<func name>", { <leads> }, { <param rules> } 117 // where: 118 // <leads> - list of integers that are one-based indexes of formal argument 119 // used to mangle a function name. Other argument types are derived from types 120 // of these 'leads'. The order of integers in this list correspond to the 121 // order in which these arguments are mangled in the EDG mangling scheme. The 122 // same order should be preserved for arguments in the AMDGPULibFunc structure 123 // when it is used for mangling. For example: 124 // { "vstorea_half", {3,1}, {E_ANY,EX_SIZET,E_ANY}}, 125 // will be mangled in EDG scheme as vstorea_half_<3dparam>_<1stparam> 126 // When mangling from code use: 127 // AMDGPULibFunc insc; 128 // insc.param[0] = ... // describe 3rd parameter 129 // insc.param[1] = ... // describe 1rd parameter 130 // 131 // <param rules> - list of rules used to derive all of the function formal 132 // argument types. EX_ prefixed are simple types, other derived from the 133 // latest 'lead' argument type in the order of encoding from first to last. 134 // E_ANY - use prev lead type, E_CONSTPTR_ANY - make const pointer out of 135 // prev lead type, etc. see ParamIterator::getNextParam() for details. 136 137 static constexpr ManglingRule manglingRules[] = { 138 { "", {0}, {0} }, 139 { "abs" , {1}, {E_ANY}}, 140 { "abs_diff" , {1}, {E_ANY,E_COPY}}, 141 { "acos" , {1}, {E_ANY}}, 142 { "acosh" , {1}, {E_ANY}}, 143 { "acospi" , {1}, {E_ANY}}, 144 { "add_sat" , {1}, {E_ANY,E_COPY}}, 145 { "all" , {1}, {E_ANY}}, 146 { "any" , {1}, {E_ANY}}, 147 { "asin" , {1}, {E_ANY}}, 148 { "asinh" , {1}, {E_ANY}}, 149 { "asinpi" , {1}, {E_ANY}}, 150 { "async_work_group_copy" , {1}, {E_ANY,E_CONSTPTR_SWAPGL,EX_SIZET,EX_EVENT}}, 151 { "async_work_group_strided_copy" , {1}, {E_ANY,E_CONSTPTR_SWAPGL,EX_SIZET,EX_SIZET,EX_EVENT}}, 152 { "atan" , {1}, {E_ANY}}, 153 { "atan2" , {1}, {E_ANY,E_COPY}}, 154 { "atan2pi" , {1}, {E_ANY,E_COPY}}, 155 { "atanh" , {1}, {E_ANY}}, 156 { "atanpi" , {1}, {E_ANY}}, 157 { "atomic_add" , {1}, {E_VLTLPTR_ANY,E_POINTEE}}, 158 { "atomic_and" , {1}, {E_VLTLPTR_ANY,E_POINTEE}}, 159 { "atomic_cmpxchg" , {1}, {E_VLTLPTR_ANY,E_POINTEE,E_POINTEE}}, 160 { "atomic_dec" , {1}, {E_VLTLPTR_ANY}}, 161 { "atomic_inc" , {1}, {E_VLTLPTR_ANY}}, 162 { "atomic_max" , {1}, {E_VLTLPTR_ANY,E_POINTEE}}, 163 { "atomic_min" , {1}, {E_VLTLPTR_ANY,E_POINTEE}}, 164 { "atomic_or" , {1}, {E_VLTLPTR_ANY,E_POINTEE}}, 165 { "atomic_sub" , {1}, {E_VLTLPTR_ANY,E_POINTEE}}, 166 { "atomic_xchg" , {1}, {E_VLTLPTR_ANY,E_POINTEE}}, 167 { "atomic_xor" , {1}, {E_VLTLPTR_ANY,E_POINTEE}}, 168 { "bitselect" , {1}, {E_ANY,E_COPY,E_COPY}}, 169 { "cbrt" , {1}, {E_ANY}}, 170 { "ceil" , {1}, {E_ANY}}, 171 { "clamp" , {1}, {E_ANY,E_COPY,E_COPY}}, 172 { "clz" , {1}, {E_ANY}}, 173 { "commit_read_pipe" , {1}, {E_ANY,EX_RESERVEDID}}, 174 { "commit_write_pipe" , {1}, {E_ANY,EX_RESERVEDID}}, 175 { "copysign" , {1}, {E_ANY,E_COPY}}, 176 { "cos" , {1}, {E_ANY}}, 177 { "cosh" , {1}, {E_ANY}}, 178 { "cospi" , {1}, {E_ANY}}, 179 { "cross" , {1}, {E_ANY,E_COPY}}, 180 { "ctz" , {1}, {E_ANY}}, 181 { "degrees" , {1}, {E_ANY}}, 182 { "distance" , {1}, {E_ANY,E_COPY}}, 183 { "divide" , {1}, {E_ANY,E_COPY}}, 184 { "dot" , {1}, {E_ANY,E_COPY}}, 185 { "erf" , {1}, {E_ANY}}, 186 { "erfc" , {1}, {E_ANY}}, 187 { "exp" , {1}, {E_ANY}}, 188 { "exp10" , {1}, {E_ANY}}, 189 { "exp2" , {1}, {E_ANY}}, 190 { "expm1" , {1}, {E_ANY}}, 191 { "fabs" , {1}, {E_ANY}}, 192 { "fast_distance" , {1}, {E_ANY,E_COPY}}, 193 { "fast_length" , {1}, {E_ANY}}, 194 { "fast_normalize" , {1}, {E_ANY}}, 195 { "fdim" , {1}, {E_ANY,E_COPY}}, 196 { "floor" , {1}, {E_ANY}}, 197 { "fma" , {1}, {E_ANY,E_COPY,E_COPY}}, 198 { "fmax" , {1}, {E_ANY,E_COPY}}, 199 { "fmin" , {1}, {E_ANY,E_COPY}}, 200 { "fmod" , {1}, {E_ANY,E_COPY}}, 201 { "fract" , {2}, {E_POINTEE,E_ANY}}, 202 { "frexp" , {1,2}, {E_ANY,E_ANY}}, 203 { "get_image_array_size" , {1}, {E_ANY}}, 204 { "get_image_channel_data_type" , {1}, {E_ANY}}, 205 { "get_image_channel_order" , {1}, {E_ANY}}, 206 { "get_image_dim" , {1}, {E_ANY}}, 207 { "get_image_height" , {1}, {E_ANY}}, 208 { "get_image_width" , {1}, {E_ANY}}, 209 { "get_pipe_max_packets" , {1}, {E_ANY}}, 210 { "get_pipe_num_packets" , {1}, {E_ANY}}, 211 { "hadd" , {1}, {E_ANY,E_COPY}}, 212 { "hypot" , {1}, {E_ANY,E_COPY}}, 213 { "ilogb" , {1}, {E_ANY}}, 214 { "isequal" , {1}, {E_ANY,E_COPY}}, 215 { "isfinite" , {1}, {E_ANY}}, 216 { "isgreater" , {1}, {E_ANY,E_COPY}}, 217 { "isgreaterequal" , {1}, {E_ANY,E_COPY}}, 218 { "isinf" , {1}, {E_ANY}}, 219 { "isless" , {1}, {E_ANY,E_COPY}}, 220 { "islessequal" , {1}, {E_ANY,E_COPY}}, 221 { "islessgreater" , {1}, {E_ANY,E_COPY}}, 222 { "isnan" , {1}, {E_ANY}}, 223 { "isnormal" , {1}, {E_ANY}}, 224 { "isnotequal" , {1}, {E_ANY,E_COPY}}, 225 { "isordered" , {1}, {E_ANY,E_COPY}}, 226 { "isunordered" , {1}, {E_ANY,E_COPY}}, 227 { "ldexp" , {1}, {E_ANY,E_SETBASE_I32}}, 228 { "length" , {1}, {E_ANY}}, 229 { "lgamma" , {1}, {E_ANY}}, 230 { "lgamma_r" , {1,2}, {E_ANY,E_ANY}}, 231 { "log" , {1}, {E_ANY}}, 232 { "log10" , {1}, {E_ANY}}, 233 { "log1p" , {1}, {E_ANY}}, 234 { "log2" , {1}, {E_ANY}}, 235 { "logb" , {1}, {E_ANY}}, 236 { "mad" , {1}, {E_ANY,E_COPY,E_COPY}}, 237 { "mad24" , {1}, {E_ANY,E_COPY,E_COPY}}, 238 { "mad_hi" , {1}, {E_ANY,E_COPY,E_COPY}}, 239 { "mad_sat" , {1}, {E_ANY,E_COPY,E_COPY}}, 240 { "max" , {1}, {E_ANY,E_COPY}}, 241 { "maxmag" , {1}, {E_ANY,E_COPY}}, 242 { "min" , {1}, {E_ANY,E_COPY}}, 243 { "minmag" , {1}, {E_ANY,E_COPY}}, 244 { "mix" , {1}, {E_ANY,E_COPY,E_COPY}}, 245 { "modf" , {2}, {E_POINTEE,E_ANY}}, 246 { "mul24" , {1}, {E_ANY,E_COPY}}, 247 { "mul_hi" , {1}, {E_ANY,E_COPY}}, 248 { "nan" , {1}, {E_ANY}}, 249 { "nextafter" , {1}, {E_ANY,E_COPY}}, 250 { "normalize" , {1}, {E_ANY}}, 251 { "popcount" , {1}, {E_ANY}}, 252 { "pow" , {1}, {E_ANY,E_COPY}}, 253 { "pown" , {1}, {E_ANY,E_SETBASE_I32}}, 254 { "powr" , {1}, {E_ANY,E_COPY}}, 255 { "prefetch" , {1}, {E_CONSTPTR_ANY,EX_SIZET}}, 256 { "radians" , {1}, {E_ANY}}, 257 { "recip" , {1}, {E_ANY}}, 258 { "remainder" , {1}, {E_ANY,E_COPY}}, 259 { "remquo" , {1,3}, {E_ANY,E_COPY,E_ANY}}, 260 { "reserve_read_pipe" , {1}, {E_ANY,EX_UINT}}, 261 { "reserve_write_pipe" , {1}, {E_ANY,EX_UINT}}, 262 { "rhadd" , {1}, {E_ANY,E_COPY}}, 263 { "rint" , {1}, {E_ANY}}, 264 { "rootn" , {1}, {E_ANY,E_SETBASE_I32}}, 265 { "rotate" , {1}, {E_ANY,E_COPY}}, 266 { "round" , {1}, {E_ANY}}, 267 { "rsqrt" , {1}, {E_ANY}}, 268 { "select" , {1,3}, {E_ANY,E_COPY,E_ANY}}, 269 { "shuffle" , {1,2}, {E_ANY,E_ANY}}, 270 { "shuffle2" , {1,3}, {E_ANY,E_COPY,E_ANY}}, 271 { "sign" , {1}, {E_ANY}}, 272 { "signbit" , {1}, {E_ANY}}, 273 { "sin" , {1}, {E_ANY}}, 274 { "sincos" , {2}, {E_POINTEE,E_ANY}}, 275 { "sinh" , {1}, {E_ANY}}, 276 { "sinpi" , {1}, {E_ANY}}, 277 { "smoothstep" , {1}, {E_ANY,E_COPY,E_COPY}}, 278 { "sqrt" , {1}, {E_ANY}}, 279 { "step" , {1}, {E_ANY,E_COPY}}, 280 { "sub_group_broadcast" , {1}, {E_ANY,EX_UINT}}, 281 { "sub_group_commit_read_pipe" , {1}, {E_ANY,EX_RESERVEDID}}, 282 { "sub_group_commit_write_pipe" , {1}, {E_ANY,EX_RESERVEDID}}, 283 { "sub_group_reduce_add" , {1}, {E_ANY}}, 284 { "sub_group_reduce_max" , {1}, {E_ANY}}, 285 { "sub_group_reduce_min" , {1}, {E_ANY}}, 286 { "sub_group_reserve_read_pipe" , {1}, {E_ANY,EX_UINT}}, 287 { "sub_group_reserve_write_pipe" , {1}, {E_ANY,EX_UINT}}, 288 { "sub_group_scan_exclusive_add" , {1}, {E_ANY}}, 289 { "sub_group_scan_exclusive_max" , {1}, {E_ANY}}, 290 { "sub_group_scan_exclusive_min" , {1}, {E_ANY}}, 291 { "sub_group_scan_inclusive_add" , {1}, {E_ANY}}, 292 { "sub_group_scan_inclusive_max" , {1}, {E_ANY}}, 293 { "sub_group_scan_inclusive_min" , {1}, {E_ANY}}, 294 { "sub_sat" , {1}, {E_ANY,E_COPY}}, 295 { "tan" , {1}, {E_ANY}}, 296 { "tanh" , {1}, {E_ANY}}, 297 { "tanpi" , {1}, {E_ANY}}, 298 { "tgamma" , {1}, {E_ANY}}, 299 { "trunc" , {1}, {E_ANY}}, 300 { "upsample" , {1}, {E_ANY,E_MAKEBASE_UNS}}, 301 { "vec_step" , {1}, {E_ANY}}, 302 { "vstore" , {3}, {E_POINTEE,EX_SIZET,E_ANY}}, 303 { "vstore16" , {3}, {E_V16_OF_POINTEE,EX_SIZET,E_ANY}}, 304 { "vstore2" , {3}, {E_V2_OF_POINTEE,EX_SIZET,E_ANY}}, 305 { "vstore3" , {3}, {E_V3_OF_POINTEE,EX_SIZET,E_ANY}}, 306 { "vstore4" , {3}, {E_V4_OF_POINTEE,EX_SIZET,E_ANY}}, 307 { "vstore8" , {3}, {E_V8_OF_POINTEE,EX_SIZET,E_ANY}}, 308 { "work_group_commit_read_pipe" , {1}, {E_ANY,EX_RESERVEDID}}, 309 { "work_group_commit_write_pipe" , {1}, {E_ANY,EX_RESERVEDID}}, 310 { "work_group_reduce_add" , {1}, {E_ANY}}, 311 { "work_group_reduce_max" , {1}, {E_ANY}}, 312 { "work_group_reduce_min" , {1}, {E_ANY}}, 313 { "work_group_reserve_read_pipe" , {1}, {E_ANY,EX_UINT}}, 314 { "work_group_reserve_write_pipe" , {1}, {E_ANY,EX_UINT}}, 315 { "work_group_scan_exclusive_add" , {1}, {E_ANY}}, 316 { "work_group_scan_exclusive_max" , {1}, {E_ANY}}, 317 { "work_group_scan_exclusive_min" , {1}, {E_ANY}}, 318 { "work_group_scan_inclusive_add" , {1}, {E_ANY}}, 319 { "work_group_scan_inclusive_max" , {1}, {E_ANY}}, 320 { "work_group_scan_inclusive_min" , {1}, {E_ANY}}, 321 { "write_imagef" , {1}, {E_ANY,E_IMAGECOORDS,EX_FLOAT4}}, 322 { "write_imagei" , {1}, {E_ANY,E_IMAGECOORDS,EX_INTV4}}, 323 { "write_imageui" , {1}, {E_ANY,E_IMAGECOORDS,EX_UINTV4}}, 324 { "ncos" , {1}, {E_ANY} }, 325 { "nexp2" , {1}, {E_ANY} }, 326 { "nfma" , {1}, {E_ANY, E_COPY, E_COPY} }, 327 { "nlog2" , {1}, {E_ANY} }, 328 { "nrcp" , {1}, {E_ANY} }, 329 { "nrsqrt" , {1}, {E_ANY} }, 330 { "nsin" , {1}, {E_ANY} }, 331 { "nsqrt" , {1}, {E_ANY} }, 332 { "ftz" , {1}, {E_ANY} }, 333 { "fldexp" , {1}, {E_ANY, EX_UINT} }, 334 { "class" , {1}, {E_ANY, EX_UINT} }, 335 { "rcbrt" , {1}, {E_ANY} }, 336 }; 337 338 // Library functions with unmangled name. 339 const UnmangledFuncInfo UnmangledFuncInfo::Table[] = { 340 {"__read_pipe_2", 4}, 341 {"__read_pipe_4", 6}, 342 {"__write_pipe_2", 4}, 343 {"__write_pipe_4", 6}, 344 }; 345 346 const unsigned UnmangledFuncInfo::TableSize = 347 array_lengthof(UnmangledFuncInfo::Table); 348 349 static AMDGPULibFunc::Param getRetType(AMDGPULibFunc::EFuncId id, 350 const AMDGPULibFunc::Param (&Leads)[2]) { 351 AMDGPULibFunc::Param Res = Leads[0]; 352 // TBD - This switch may require to be extended for other intriniscs 353 switch (id) { 354 case AMDGPULibFunc::EI_SINCOS: 355 Res.PtrKind = AMDGPULibFunc::BYVALUE; 356 break; 357 default: 358 break; 359 } 360 return Res; 361 } 362 363 class ParamIterator { 364 const AMDGPULibFunc::Param (&Leads)[2]; 365 const ManglingRule& Rule; 366 int Index; 367 public: 368 ParamIterator(const AMDGPULibFunc::Param (&leads)[2], 369 const ManglingRule& rule) 370 : Leads(leads), Rule(rule), Index(0) {} 371 372 AMDGPULibFunc::Param getNextParam(); 373 }; 374 375 AMDGPULibFunc::Param ParamIterator::getNextParam() { 376 AMDGPULibFunc::Param P; 377 if (Index >= int(sizeof Rule.Param/sizeof Rule.Param[0])) return P; 378 379 const char R = Rule.Param[Index]; 380 switch (R) { 381 case E_NONE: break; 382 case EX_UINT: 383 P.ArgType = AMDGPULibFunc::U32; break; 384 case EX_INTV4: 385 P.ArgType = AMDGPULibFunc::I32; P.VectorSize = 4; break; 386 case EX_UINTV4: 387 P.ArgType = AMDGPULibFunc::U32; P.VectorSize = 4; break; 388 case EX_FLOAT4: 389 P.ArgType = AMDGPULibFunc::F32; P.VectorSize = 4; break; 390 case EX_SIZET: 391 P.ArgType = AMDGPULibFunc::U64; break; 392 case EX_EVENT: 393 P.ArgType = AMDGPULibFunc::EVENT; break; 394 case EX_SAMPLER: 395 P.ArgType = AMDGPULibFunc::SAMPLER; break; 396 case EX_RESERVEDID: break; // TBD 397 default: 398 if (Index == (Rule.Lead[1] - 1)) P = Leads[1]; 399 else P = Leads[0]; 400 401 switch (R) { 402 case E_ANY: 403 case E_COPY: break; 404 405 case E_POINTEE: 406 P.PtrKind = AMDGPULibFunc::BYVALUE; break; 407 case E_V2_OF_POINTEE: 408 P.VectorSize = 2; P.PtrKind = AMDGPULibFunc::BYVALUE; break; 409 case E_V3_OF_POINTEE: 410 P.VectorSize = 3; P.PtrKind = AMDGPULibFunc::BYVALUE; break; 411 case E_V4_OF_POINTEE: 412 P.VectorSize = 4; P.PtrKind = AMDGPULibFunc::BYVALUE; break; 413 case E_V8_OF_POINTEE: 414 P.VectorSize = 8; P.PtrKind = AMDGPULibFunc::BYVALUE; break; 415 case E_V16_OF_POINTEE: 416 P.VectorSize = 16; P.PtrKind = AMDGPULibFunc::BYVALUE; break; 417 case E_CONSTPTR_ANY: 418 P.PtrKind |= AMDGPULibFunc::CONST; break; 419 case E_VLTLPTR_ANY: 420 P.PtrKind |= AMDGPULibFunc::VOLATILE; break; 421 case E_SETBASE_I32: 422 P.ArgType = AMDGPULibFunc::I32; break; 423 case E_SETBASE_U32: 424 P.ArgType = AMDGPULibFunc::U32; break; 425 426 case E_MAKEBASE_UNS: 427 P.ArgType &= ~AMDGPULibFunc::BASE_TYPE_MASK; 428 P.ArgType |= AMDGPULibFunc::UINT; 429 break; 430 431 case E_IMAGECOORDS: 432 switch (P.ArgType) { 433 case AMDGPULibFunc::IMG1DA: P.VectorSize = 2; break; 434 case AMDGPULibFunc::IMG1DB: P.VectorSize = 1; break; 435 case AMDGPULibFunc::IMG2DA: P.VectorSize = 4; break; 436 case AMDGPULibFunc::IMG1D: P.VectorSize = 1; break; 437 case AMDGPULibFunc::IMG2D: P.VectorSize = 2; break; 438 case AMDGPULibFunc::IMG3D: P.VectorSize = 4; break; 439 } 440 P.PtrKind = AMDGPULibFunc::BYVALUE; 441 P.ArgType = AMDGPULibFunc::I32; 442 break; 443 444 case E_CONSTPTR_SWAPGL: { 445 unsigned AS = AMDGPULibFunc::getAddrSpaceFromEPtrKind(P.PtrKind); 446 switch (AS) { 447 case AMDGPUAS::GLOBAL_ADDRESS: AS = AMDGPUAS::LOCAL_ADDRESS; break; 448 case AMDGPUAS::LOCAL_ADDRESS: AS = AMDGPUAS::GLOBAL_ADDRESS; break; 449 } 450 P.PtrKind = AMDGPULibFunc::getEPtrKindFromAddrSpace(AS); 451 P.PtrKind |= AMDGPULibFunc::CONST; 452 break; 453 } 454 455 default: llvm_unreachable("Unhandeled param rule"); 456 } 457 } 458 ++Index; 459 return P; 460 } 461 462 inline static void drop_front(StringRef& str, size_t n = 1) { 463 str = str.drop_front(n); 464 } 465 466 static bool eatTerm(StringRef& mangledName, const char c) { 467 if (mangledName.front() == c) { 468 drop_front(mangledName); 469 return true; 470 } 471 return false; 472 } 473 474 template <size_t N> 475 static bool eatTerm(StringRef& mangledName, const char (&str)[N]) { 476 if (mangledName.startswith(StringRef(str, N-1))) { 477 drop_front(mangledName, N-1); 478 return true; 479 } 480 return false; 481 } 482 483 static int eatNumber(StringRef& s) { 484 size_t const savedSize = s.size(); 485 int n = 0; 486 while (!s.empty() && isDigit(s.front())) { 487 n = n*10 + s.front() - '0'; 488 drop_front(s); 489 } 490 return s.size() < savedSize ? n : -1; 491 } 492 493 static StringRef eatLengthPrefixedName(StringRef& mangledName) { 494 int const Len = eatNumber(mangledName); 495 if (Len <= 0 || static_cast<size_t>(Len) > mangledName.size()) 496 return StringRef(); 497 StringRef Res = mangledName.substr(0, Len); 498 drop_front(mangledName, Len); 499 return Res; 500 } 501 502 } // end anonymous namespace 503 504 AMDGPUMangledLibFunc::AMDGPUMangledLibFunc() { 505 FuncId = EI_NONE; 506 FKind = NOPFX; 507 Leads[0].reset(); 508 Leads[1].reset(); 509 Name.clear(); 510 } 511 512 AMDGPUUnmangledLibFunc::AMDGPUUnmangledLibFunc() { 513 FuncId = EI_NONE; 514 FuncTy = nullptr; 515 } 516 517 AMDGPUMangledLibFunc::AMDGPUMangledLibFunc( 518 EFuncId id, const AMDGPUMangledLibFunc ©From) { 519 FuncId = id; 520 FKind = copyFrom.FKind; 521 Leads[0] = copyFrom.Leads[0]; 522 Leads[1] = copyFrom.Leads[1]; 523 } 524 525 /////////////////////////////////////////////////////////////////////////////// 526 // Demangling 527 528 static int parseVecSize(StringRef& mangledName) { 529 size_t const Len = eatNumber(mangledName); 530 switch (Len) { 531 case 2: case 3: case 4: case 8: case 16: 532 return Len; 533 default: 534 break; 535 } 536 return 1; 537 } 538 539 static AMDGPULibFunc::ENamePrefix parseNamePrefix(StringRef& mangledName) { 540 std::pair<StringRef, StringRef> const P = mangledName.split('_'); 541 AMDGPULibFunc::ENamePrefix Pfx = 542 StringSwitch<AMDGPULibFunc::ENamePrefix>(P.first) 543 .Case("native", AMDGPULibFunc::NATIVE) 544 .Case("half" , AMDGPULibFunc::HALF) 545 .Default(AMDGPULibFunc::NOPFX); 546 547 if (Pfx != AMDGPULibFunc::NOPFX) 548 mangledName = P.second; 549 550 return Pfx; 551 } 552 553 StringMap<int> ManglingRule::buildManglingRulesMap() { 554 StringMap<int> Map(array_lengthof(manglingRules)); 555 int Id = 0; 556 for (auto Rule : manglingRules) 557 Map.insert({Rule.Name, Id++}); 558 return Map; 559 } 560 561 bool AMDGPUMangledLibFunc::parseUnmangledName(StringRef FullName) { 562 static const StringMap<int> manglingRulesMap = 563 ManglingRule::buildManglingRulesMap(); 564 FuncId = static_cast<EFuncId>(manglingRulesMap.lookup(FullName)); 565 return FuncId != EI_NONE; 566 } 567 568 /////////////////////////////////////////////////////////////////////////////// 569 // Itanium Demangling 570 571 namespace { 572 struct ItaniumParamParser { 573 AMDGPULibFunc::Param Prev; 574 bool parseItaniumParam(StringRef& param, AMDGPULibFunc::Param &res); 575 }; 576 } // namespace 577 578 bool ItaniumParamParser::parseItaniumParam(StringRef& param, 579 AMDGPULibFunc::Param &res) { 580 res.reset(); 581 if (param.empty()) return false; 582 583 // parse pointer prefix 584 if (eatTerm(param, 'P')) { 585 if (eatTerm(param, 'K')) res.PtrKind |= AMDGPULibFunc::CONST; 586 if (eatTerm(param, 'V')) res.PtrKind |= AMDGPULibFunc::VOLATILE; 587 unsigned AS; 588 if (!eatTerm(param, "U3AS")) { 589 AS = 0; 590 } else { 591 AS = param.front() - '0'; 592 drop_front(param, 1); 593 } 594 res.PtrKind |= AMDGPULibFuncBase::getEPtrKindFromAddrSpace(AS); 595 } else { 596 res.PtrKind = AMDGPULibFunc::BYVALUE; 597 } 598 599 // parse vector size 600 if (eatTerm(param,"Dv")) { 601 res.VectorSize = parseVecSize(param); 602 if (res.VectorSize==1 || !eatTerm(param, '_')) return false; 603 } 604 605 // parse type 606 char const TC = param.front(); 607 if (isDigit(TC)) { 608 res.ArgType = StringSwitch<AMDGPULibFunc::EType> 609 (eatLengthPrefixedName(param)) 610 .Case("ocl_image1darray" , AMDGPULibFunc::IMG1DA) 611 .Case("ocl_image1dbuffer", AMDGPULibFunc::IMG1DB) 612 .Case("ocl_image2darray" , AMDGPULibFunc::IMG2DA) 613 .Case("ocl_image1d" , AMDGPULibFunc::IMG1D) 614 .Case("ocl_image2d" , AMDGPULibFunc::IMG2D) 615 .Case("ocl_image3d" , AMDGPULibFunc::IMG3D) 616 .Case("ocl_event" , AMDGPULibFunc::DUMMY) 617 .Case("ocl_sampler" , AMDGPULibFunc::DUMMY) 618 .Default(AMDGPULibFunc::DUMMY); 619 } else { 620 drop_front(param); 621 switch (TC) { 622 case 'h': res.ArgType = AMDGPULibFunc::U8; break; 623 case 't': res.ArgType = AMDGPULibFunc::U16; break; 624 case 'j': res.ArgType = AMDGPULibFunc::U32; break; 625 case 'm': res.ArgType = AMDGPULibFunc::U64; break; 626 case 'c': res.ArgType = AMDGPULibFunc::I8; break; 627 case 's': res.ArgType = AMDGPULibFunc::I16; break; 628 case 'i': res.ArgType = AMDGPULibFunc::I32; break; 629 case 'l': res.ArgType = AMDGPULibFunc::I64; break; 630 case 'f': res.ArgType = AMDGPULibFunc::F32; break; 631 case 'd': res.ArgType = AMDGPULibFunc::F64; break; 632 case 'D': if (!eatTerm(param, 'h')) return false; 633 res.ArgType = AMDGPULibFunc::F16; break; 634 case 'S': 635 if (!eatTerm(param, '_')) { 636 eatNumber(param); 637 if (!eatTerm(param, '_')) return false; 638 } 639 res.VectorSize = Prev.VectorSize; 640 res.ArgType = Prev.ArgType; 641 break; 642 default:; 643 } 644 } 645 if (res.ArgType == 0) return false; 646 Prev.VectorSize = res.VectorSize; 647 Prev.ArgType = res.ArgType; 648 return true; 649 } 650 651 bool AMDGPUMangledLibFunc::parseFuncName(StringRef &mangledName) { 652 StringRef Name = eatLengthPrefixedName(mangledName); 653 FKind = parseNamePrefix(Name); 654 if (!parseUnmangledName(Name)) 655 return false; 656 657 const ManglingRule& Rule = manglingRules[FuncId]; 658 ItaniumParamParser Parser; 659 for (int I=0; I < Rule.maxLeadIndex(); ++I) { 660 Param P; 661 if (!Parser.parseItaniumParam(mangledName, P)) 662 return false; 663 664 if ((I + 1) == Rule.Lead[0]) Leads[0] = P; 665 if ((I + 1) == Rule.Lead[1]) Leads[1] = P; 666 } 667 return true; 668 } 669 670 bool AMDGPUUnmangledLibFunc::parseFuncName(StringRef &Name) { 671 if (!UnmangledFuncInfo::lookup(Name, FuncId)) 672 return false; 673 setName(Name); 674 return true; 675 } 676 677 bool AMDGPULibFunc::parse(StringRef FuncName, AMDGPULibFunc &F) { 678 if (FuncName.empty()) { 679 F.Impl = std::unique_ptr<AMDGPULibFuncImpl>(); 680 return false; 681 } 682 683 if (eatTerm(FuncName, "_Z")) 684 F.Impl = std::make_unique<AMDGPUMangledLibFunc>(); 685 else 686 F.Impl = std::make_unique<AMDGPUUnmangledLibFunc>(); 687 if (F.Impl->parseFuncName(FuncName)) 688 return true; 689 690 F.Impl = std::unique_ptr<AMDGPULibFuncImpl>(); 691 return false; 692 } 693 694 StringRef AMDGPUMangledLibFunc::getUnmangledName(StringRef mangledName) { 695 StringRef S = mangledName; 696 if (eatTerm(S, "_Z")) 697 return eatLengthPrefixedName(S); 698 return StringRef(); 699 } 700 701 /////////////////////////////////////////////////////////////////////////////// 702 // Mangling 703 704 template <typename Stream> 705 void AMDGPUMangledLibFunc::writeName(Stream &OS) const { 706 const char *Pfx = ""; 707 switch (FKind) { 708 case NATIVE: Pfx = "native_"; break; 709 case HALF: Pfx = "half_"; break; 710 default: break; 711 } 712 if (!Name.empty()) { 713 OS << Pfx << Name; 714 } else if (FuncId != EI_NONE) { 715 OS << Pfx; 716 const StringRef& S = manglingRules[FuncId].Name; 717 OS.write(S.data(), S.size()); 718 } 719 } 720 721 std::string AMDGPUMangledLibFunc::mangle() const { return mangleNameItanium(); } 722 723 /////////////////////////////////////////////////////////////////////////////// 724 // Itanium Mangling 725 726 static const char *getItaniumTypeName(AMDGPULibFunc::EType T) { 727 switch (T) { 728 case AMDGPULibFunc::U8: return "h"; 729 case AMDGPULibFunc::U16: return "t"; 730 case AMDGPULibFunc::U32: return "j"; 731 case AMDGPULibFunc::U64: return "m"; 732 case AMDGPULibFunc::I8: return "c"; 733 case AMDGPULibFunc::I16: return "s"; 734 case AMDGPULibFunc::I32: return "i"; 735 case AMDGPULibFunc::I64: return "l"; 736 case AMDGPULibFunc::F16: return "Dh"; 737 case AMDGPULibFunc::F32: return "f"; 738 case AMDGPULibFunc::F64: return "d"; 739 case AMDGPULibFunc::IMG1DA: return "16ocl_image1darray"; 740 case AMDGPULibFunc::IMG1DB: return "17ocl_image1dbuffer"; 741 case AMDGPULibFunc::IMG2DA: return "16ocl_image2darray"; 742 case AMDGPULibFunc::IMG1D: return "11ocl_image1d"; 743 case AMDGPULibFunc::IMG2D: return "11ocl_image2d"; 744 case AMDGPULibFunc::IMG3D: return "11ocl_image3d"; 745 case AMDGPULibFunc::SAMPLER: return "11ocl_sampler"; 746 case AMDGPULibFunc::EVENT: return "9ocl_event"; 747 default: llvm_unreachable("Unhandeled param type"); 748 } 749 return nullptr; 750 } 751 752 namespace { 753 // Itanium mangling ABI says: 754 // "5.1.8. Compression 755 // ... Each non-terminal in the grammar for which <substitution> appears on the 756 // right-hand side is both a source of future substitutions and a candidate 757 // for being substituted. There are two exceptions that appear to be 758 // substitution candidates from the grammar, but are explicitly excluded: 759 // 1. <builtin-type> other than vendor extended types ..." 760 761 // For the purpose of functions the following productions make sence for the 762 // substitution: 763 // <type> ::= <builtin-type> 764 // ::= <class-enum-type> 765 // ::= <array-type> 766 // ::=<CV-qualifiers> <type> 767 // ::= P <type> # pointer-to 768 // ::= <substitution> 769 // 770 // Note that while types like images, samplers and events are by the ABI encoded 771 // using <class-enum-type> production rule they're not used for substitution 772 // because clang consider them as builtin types. 773 // 774 // DvNN_ type is GCC extension for vectors and is a subject for the substitution. 775 776 777 class ItaniumMangler { 778 SmallVector<AMDGPULibFunc::Param, 10> Str; // list of accumulated substituions 779 bool UseAddrSpace; 780 781 int findSubst(const AMDGPULibFunc::Param& P) const { 782 for(unsigned I = 0; I < Str.size(); ++I) { 783 const AMDGPULibFunc::Param& T = Str[I]; 784 if (P.PtrKind == T.PtrKind && 785 P.VectorSize == T.VectorSize && 786 P.ArgType == T.ArgType) { 787 return I; 788 } 789 } 790 return -1; 791 } 792 793 template <typename Stream> 794 bool trySubst(Stream& os, const AMDGPULibFunc::Param& p) { 795 int const subst = findSubst(p); 796 if (subst < 0) return false; 797 // Substitutions are mangled as S(XX)?_ where XX is a hexadecimal number 798 // 0 1 2 799 // S_ S0_ S1_ 800 if (subst == 0) os << "S_"; 801 else os << 'S' << (subst-1) << '_'; 802 return true; 803 } 804 805 public: 806 ItaniumMangler(bool useAddrSpace) 807 : UseAddrSpace(useAddrSpace) {} 808 809 template <typename Stream> 810 void operator()(Stream& os, AMDGPULibFunc::Param p) { 811 812 // Itanium mangling ABI 5.1.8. Compression: 813 // Logically, the substitutable components of a mangled name are considered 814 // left-to-right, components before the composite structure of which they 815 // are a part. If a component has been encountered before, it is substituted 816 // as described below. This decision is independent of whether its components 817 // have been substituted, so an implementation may optimize by considering 818 // large structures for substitution before their components. If a component 819 // has not been encountered before, its mangling is identified, and it is 820 // added to a dictionary of substitution candidates. No entity is added to 821 // the dictionary twice. 822 AMDGPULibFunc::Param Ptr; 823 824 if (p.PtrKind) { 825 if (trySubst(os, p)) return; 826 os << 'P'; 827 if (p.PtrKind & AMDGPULibFunc::CONST) os << 'K'; 828 if (p.PtrKind & AMDGPULibFunc::VOLATILE) os << 'V'; 829 unsigned AS = UseAddrSpace 830 ? AMDGPULibFuncBase::getAddrSpaceFromEPtrKind(p.PtrKind) 831 : 0; 832 if (AS != 0) os << "U3AS" << AS; 833 Ptr = p; 834 p.PtrKind = 0; 835 } 836 837 if (p.VectorSize > 1) { 838 if (trySubst(os, p)) goto exit; 839 Str.push_back(p); 840 os << "Dv" << static_cast<unsigned>(p.VectorSize) << '_'; 841 } 842 843 os << getItaniumTypeName((AMDGPULibFunc::EType)p.ArgType); 844 845 exit: 846 if (Ptr.ArgType) Str.push_back(Ptr); 847 } 848 }; 849 } // namespace 850 851 std::string AMDGPUMangledLibFunc::mangleNameItanium() const { 852 SmallString<128> Buf; 853 raw_svector_ostream S(Buf); 854 SmallString<128> NameBuf; 855 raw_svector_ostream Name(NameBuf); 856 writeName(Name); 857 const StringRef& NameStr = Name.str(); 858 S << "_Z" << static_cast<int>(NameStr.size()) << NameStr; 859 860 ItaniumMangler Mangler(true); 861 ParamIterator I(Leads, manglingRules[FuncId]); 862 Param P; 863 while ((P = I.getNextParam()).ArgType != 0) 864 Mangler(S, P); 865 return std::string(S.str()); 866 } 867 868 /////////////////////////////////////////////////////////////////////////////// 869 // Misc 870 871 static Type* getIntrinsicParamType( 872 LLVMContext& C, 873 const AMDGPULibFunc::Param& P, 874 bool useAddrSpace) { 875 Type* T = nullptr; 876 switch (P.ArgType) { 877 case AMDGPULibFunc::U8: 878 case AMDGPULibFunc::I8: T = Type::getInt8Ty(C); break; 879 case AMDGPULibFunc::U16: 880 case AMDGPULibFunc::I16: T = Type::getInt16Ty(C); break; 881 case AMDGPULibFunc::U32: 882 case AMDGPULibFunc::I32: T = Type::getInt32Ty(C); break; 883 case AMDGPULibFunc::U64: 884 case AMDGPULibFunc::I64: T = Type::getInt64Ty(C); break; 885 case AMDGPULibFunc::F16: T = Type::getHalfTy(C); break; 886 case AMDGPULibFunc::F32: T = Type::getFloatTy(C); break; 887 case AMDGPULibFunc::F64: T = Type::getDoubleTy(C); break; 888 889 case AMDGPULibFunc::IMG1DA: 890 case AMDGPULibFunc::IMG1DB: 891 case AMDGPULibFunc::IMG2DA: 892 case AMDGPULibFunc::IMG1D: 893 case AMDGPULibFunc::IMG2D: 894 case AMDGPULibFunc::IMG3D: 895 T = StructType::create(C,"ocl_image")->getPointerTo(); break; 896 case AMDGPULibFunc::SAMPLER: 897 T = StructType::create(C,"ocl_sampler")->getPointerTo(); break; 898 case AMDGPULibFunc::EVENT: 899 T = StructType::create(C,"ocl_event")->getPointerTo(); break; 900 default: 901 llvm_unreachable("Unhandeled param type"); 902 return nullptr; 903 } 904 if (P.VectorSize > 1) 905 T = FixedVectorType::get(T, P.VectorSize); 906 if (P.PtrKind != AMDGPULibFunc::BYVALUE) 907 T = useAddrSpace ? T->getPointerTo((P.PtrKind & AMDGPULibFunc::ADDR_SPACE) 908 - 1) 909 : T->getPointerTo(); 910 return T; 911 } 912 913 FunctionType *AMDGPUMangledLibFunc::getFunctionType(Module &M) const { 914 LLVMContext& C = M.getContext(); 915 std::vector<Type*> Args; 916 ParamIterator I(Leads, manglingRules[FuncId]); 917 Param P; 918 while ((P=I.getNextParam()).ArgType != 0) 919 Args.push_back(getIntrinsicParamType(C, P, true)); 920 921 return FunctionType::get( 922 getIntrinsicParamType(C, getRetType(FuncId, Leads), true), 923 Args, false); 924 } 925 926 unsigned AMDGPUMangledLibFunc::getNumArgs() const { 927 return manglingRules[FuncId].getNumArgs(); 928 } 929 930 unsigned AMDGPUUnmangledLibFunc::getNumArgs() const { 931 return UnmangledFuncInfo::getNumArgs(FuncId); 932 } 933 934 std::string AMDGPUMangledLibFunc::getName() const { 935 SmallString<128> Buf; 936 raw_svector_ostream OS(Buf); 937 writeName(OS); 938 return std::string(OS.str()); 939 } 940 941 Function *AMDGPULibFunc::getFunction(Module *M, const AMDGPULibFunc &fInfo) { 942 std::string FuncName = fInfo.mangle(); 943 Function *F = dyn_cast_or_null<Function>( 944 M->getValueSymbolTable().lookup(FuncName)); 945 946 // check formal with actual types conformance 947 if (F && !F->isDeclaration() 948 && !F->isVarArg() 949 && F->arg_size() == fInfo.getNumArgs()) { 950 return F; 951 } 952 return nullptr; 953 } 954 955 FunctionCallee AMDGPULibFunc::getOrInsertFunction(Module *M, 956 const AMDGPULibFunc &fInfo) { 957 std::string const FuncName = fInfo.mangle(); 958 Function *F = dyn_cast_or_null<Function>( 959 M->getValueSymbolTable().lookup(FuncName)); 960 961 // check formal with actual types conformance 962 if (F && !F->isDeclaration() 963 && !F->isVarArg() 964 && F->arg_size() == fInfo.getNumArgs()) { 965 return F; 966 } 967 968 FunctionType *FuncTy = fInfo.getFunctionType(*M); 969 970 bool hasPtr = false; 971 for (FunctionType::param_iterator 972 PI = FuncTy->param_begin(), 973 PE = FuncTy->param_end(); 974 PI != PE; ++PI) { 975 const Type* argTy = static_cast<const Type*>(*PI); 976 if (argTy->isPointerTy()) { 977 hasPtr = true; 978 break; 979 } 980 } 981 982 FunctionCallee C; 983 if (hasPtr) { 984 // Do not set extra attributes for functions with pointer arguments. 985 C = M->getOrInsertFunction(FuncName, FuncTy); 986 } else { 987 AttributeList Attr; 988 LLVMContext &Ctx = M->getContext(); 989 Attr = Attr.addAttribute(Ctx, AttributeList::FunctionIndex, 990 Attribute::ReadOnly); 991 Attr = Attr.addAttribute(Ctx, AttributeList::FunctionIndex, 992 Attribute::NoUnwind); 993 C = M->getOrInsertFunction(FuncName, FuncTy, Attr); 994 } 995 996 return C; 997 } 998 999 StringMap<unsigned> UnmangledFuncInfo::buildNameMap() { 1000 StringMap<unsigned> Map; 1001 for (unsigned I = 0; I != TableSize; ++I) 1002 Map[Table[I].Name] = I; 1003 return Map; 1004 } 1005 1006 bool UnmangledFuncInfo::lookup(StringRef Name, ID &Id) { 1007 static const StringMap<unsigned> Map = buildNameMap(); 1008 auto Loc = Map.find(Name); 1009 if (Loc != Map.end()) { 1010 Id = toFuncId(Loc->second); 1011 return true; 1012 } 1013 Id = AMDGPULibFunc::EI_NONE; 1014 return false; 1015 } 1016 1017 AMDGPULibFunc::AMDGPULibFunc(const AMDGPULibFunc &F) { 1018 if (auto *MF = dyn_cast<AMDGPUMangledLibFunc>(F.Impl.get())) 1019 Impl.reset(new AMDGPUMangledLibFunc(*MF)); 1020 else if (auto *UMF = dyn_cast<AMDGPUUnmangledLibFunc>(F.Impl.get())) 1021 Impl.reset(new AMDGPUUnmangledLibFunc(*UMF)); 1022 else 1023 Impl = std::unique_ptr<AMDGPULibFuncImpl>(); 1024 } 1025 1026 AMDGPULibFunc &AMDGPULibFunc::operator=(const AMDGPULibFunc &F) { 1027 if (this == &F) 1028 return *this; 1029 new (this) AMDGPULibFunc(F); 1030 return *this; 1031 } 1032 1033 AMDGPULibFunc::AMDGPULibFunc(EFuncId Id, const AMDGPULibFunc &CopyFrom) { 1034 assert(AMDGPULibFuncBase::isMangled(Id) && CopyFrom.isMangled() && 1035 "not supported"); 1036 Impl.reset(new AMDGPUMangledLibFunc( 1037 Id, *cast<AMDGPUMangledLibFunc>(CopyFrom.Impl.get()))); 1038 } 1039 1040 AMDGPULibFunc::AMDGPULibFunc(StringRef Name, FunctionType *FT) { 1041 Impl.reset(new AMDGPUUnmangledLibFunc(Name, FT)); 1042 } 1043 1044 void AMDGPULibFunc::initMangled() { Impl.reset(new AMDGPUMangledLibFunc()); } 1045 1046 AMDGPULibFunc::Param *AMDGPULibFunc::getLeads() { 1047 if (!Impl) 1048 initMangled(); 1049 return cast<AMDGPUMangledLibFunc>(Impl.get())->Leads; 1050 } 1051 1052 const AMDGPULibFunc::Param *AMDGPULibFunc::getLeads() const { 1053 return cast<const AMDGPUMangledLibFunc>(Impl.get())->Leads; 1054 } 1055