lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.cpp

   1 //===--- AMDGPUHSAMetadataStreamer.cpp --------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 /// \file
  11 /// AMDGPU HSA Metadata Streamer.
  12 ///
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "AMDGPUHSAMetadataStreamer.h"
  17 #include "AMDGPU.h"
  18 #include "AMDGPUSubtarget.h"
  19 #include "SIMachineFunctionInfo.h"
  20 #include "SIProgramInfo.h"
  21 #include "Utils/AMDGPUBaseInfo.h"
  22 #include "llvm/ADT/StringSwitch.h"
  23 #include "llvm/IR/Constants.h"
  24 #include "llvm/IR/Module.h"
  25 #include "llvm/Support/raw_ostream.h"
  26
  27 namespace llvm {
  28
  29 static cl::opt<bool> DumpHSAMetadata(
  30     "amdgpu-dump-hsa-metadata",
  31     cl::desc("Dump AMDGPU HSA Metadata"));
  32 static cl::opt<bool> VerifyHSAMetadata(
  33     "amdgpu-verify-hsa-metadata",
  34     cl::desc("Verify AMDGPU HSA Metadata"));
  35
  36 namespace AMDGPU {
  37 namespace HSAMD {
  38
  39 void MetadataStreamer::dump(StringRef HSAMetadataString) const {
  40   errs() << "AMDGPU HSA Metadata:\n" << HSAMetadataString << '\n';
  41 }
  42
  43 void MetadataStreamer::verify(StringRef HSAMetadataString) const {
  44   errs() << "AMDGPU HSA Metadata Parser Test: ";
  45
  46   HSAMD::Metadata FromHSAMetadataString;
  47   if (fromString(HSAMetadataString, FromHSAMetadataString)) {
  48     errs() << "FAIL\n";
  49     return;
  50   }
  51
  52   std::string ToHSAMetadataString;
  53   if (toString(FromHSAMetadataString, ToHSAMetadataString)) {
  54     errs() << "FAIL\n";
  55     return;
  56   }
  57
  58   errs() << (HSAMetadataString == ToHSAMetadataString ? "PASS" : "FAIL")
  59          << '\n';
  60   if (HSAMetadataString != ToHSAMetadataString) {
  61     errs() << "Original input: " << HSAMetadataString << '\n'
  62            << "Produced output: " << ToHSAMetadataString << '\n';
  63   }
  64 }
  65
  66 AccessQualifier MetadataStreamer::getAccessQualifier(StringRef AccQual) const {
  67   if (AccQual.empty())
  68     return AccessQualifier::Unknown;
  69
  70   return StringSwitch<AccessQualifier>(AccQual)
  71              .Case("read_only",  AccessQualifier::ReadOnly)
  72              .Case("write_only", AccessQualifier::WriteOnly)
  73              .Case("read_write", AccessQualifier::ReadWrite)
  74              .Default(AccessQualifier::Default);
  75 }
  76
  77 AddressSpaceQualifier MetadataStreamer::getAddressSpaceQualifer(
  78     unsigned AddressSpace) const {
  79   if (AddressSpace == AMDGPUASI.PRIVATE_ADDRESS)
  80     return AddressSpaceQualifier::Private;
  81   if (AddressSpace == AMDGPUASI.GLOBAL_ADDRESS)
  82     return AddressSpaceQualifier::Global;
  83   if (AddressSpace == AMDGPUASI.CONSTANT_ADDRESS)
  84     return AddressSpaceQualifier::Constant;
  85   if (AddressSpace == AMDGPUASI.LOCAL_ADDRESS)
  86     return AddressSpaceQualifier::Local;
  87   if (AddressSpace == AMDGPUASI.FLAT_ADDRESS)
  88     return AddressSpaceQualifier::Generic;
  89   if (AddressSpace == AMDGPUASI.REGION_ADDRESS)
  90     return AddressSpaceQualifier::Region;
  91
  92   llvm_unreachable("Unknown address space qualifier");
  93 }
  94
  95 ValueKind MetadataStreamer::getValueKind(Type *Ty, StringRef TypeQual,
  96                                          StringRef BaseTypeName) const {
  97   if (TypeQual.find("pipe") != StringRef::npos)
  98     return ValueKind::Pipe;
  99
 100   return StringSwitch<ValueKind>(BaseTypeName)
 101              .Case("image1d_t", ValueKind::Image)
 102              .Case("image1d_array_t", ValueKind::Image)
 103              .Case("image1d_buffer_t", ValueKind::Image)
 104              .Case("image2d_t", ValueKind::Image)
 105              .Case("image2d_array_t", ValueKind::Image)
 106              .Case("image2d_array_depth_t", ValueKind::Image)
 107              .Case("image2d_array_msaa_t", ValueKind::Image)
 108              .Case("image2d_array_msaa_depth_t", ValueKind::Image)
 109              .Case("image2d_depth_t", ValueKind::Image)
 110              .Case("image2d_msaa_t", ValueKind::Image)
 111              .Case("image2d_msaa_depth_t", ValueKind::Image)
 112              .Case("image3d_t", ValueKind::Image)
 113              .Case("sampler_t", ValueKind::Sampler)
 114              .Case("queue_t", ValueKind::Queue)
 115              .Default(isa<PointerType>(Ty) ?
 116                           (Ty->getPointerAddressSpace() ==
 117                            AMDGPUASI.LOCAL_ADDRESS ?
 118                            ValueKind::DynamicSharedPointer :
 119                            ValueKind::GlobalBuffer) :
 120                       ValueKind::ByValue);
 121 }
 122
 123 ValueType MetadataStreamer::getValueType(Type *Ty, StringRef TypeName) const {
 124   switch (Ty->getTypeID()) {
 125   case Type::IntegerTyID: {
 126     auto Signed = !TypeName.startswith("u");
 127     switch (Ty->getIntegerBitWidth()) {
 128     case 8:
 129       return Signed ? ValueType::I8 : ValueType::U8;
 130     case 16:
 131       return Signed ? ValueType::I16 : ValueType::U16;
 132     case 32:
 133       return Signed ? ValueType::I32 : ValueType::U32;
 134     case 64:
 135       return Signed ? ValueType::I64 : ValueType::U64;
 136     default:
 137       return ValueType::Struct;
 138     }
 139   }
 140   case Type::HalfTyID:
 141     return ValueType::F16;
 142   case Type::FloatTyID:
 143     return ValueType::F32;
 144   case Type::DoubleTyID:
 145     return ValueType::F64;
 146   case Type::PointerTyID:
 147     return getValueType(Ty->getPointerElementType(), TypeName);
 148   case Type::VectorTyID:
 149     return getValueType(Ty->getVectorElementType(), TypeName);
 150   default:
 151     return ValueType::Struct;
 152   }
 153 }
 154
 155 std::string MetadataStreamer::getTypeName(Type *Ty, bool Signed) const {
 156   switch (Ty->getTypeID()) {
 157   case Type::IntegerTyID: {
 158     if (!Signed)
 159       return (Twine('u') + getTypeName(Ty, true)).str();
 160
 161     auto BitWidth = Ty->getIntegerBitWidth();
 162     switch (BitWidth) {
 163     case 8:
 164       return "char";
 165     case 16:
 166       return "short";
 167     case 32:
 168       return "int";
 169     case 64:
 170       return "long";
 171     default:
 172       return (Twine('i') + Twine(BitWidth)).str();
 173     }
 174   }
 175   case Type::HalfTyID:
 176     return "half";
 177   case Type::FloatTyID:
 178     return "float";
 179   case Type::DoubleTyID:
 180     return "double";
 181   case Type::VectorTyID: {
 182     auto VecTy = cast<VectorType>(Ty);
 183     auto ElTy = VecTy->getElementType();
 184     auto NumElements = VecTy->getVectorNumElements();
 185     return (Twine(getTypeName(ElTy, Signed)) + Twine(NumElements)).str();
 186   }
 187   default:
 188     return "unknown";
 189   }
 190 }
 191
 192 std::vector<uint32_t> MetadataStreamer::getWorkGroupDimensions(
 193     MDNode *Node) const {
 194   std::vector<uint32_t> Dims;
 195   if (Node->getNumOperands() != 3)
 196     return Dims;
 197
 198   for (auto &Op : Node->operands())
 199     Dims.push_back(mdconst::extract<ConstantInt>(Op)->getZExtValue());
 200   return Dims;
 201 }
 202
 203 Kernel::CodeProps::Metadata MetadataStreamer::getHSACodeProps(
 204     const MachineFunction &MF,
 205     const SIProgramInfo &ProgramInfo) const {
 206   const GCNSubtarget &STM = MF.getSubtarget<GCNSubtarget>();
 207   const SIMachineFunctionInfo &MFI = *MF.getInfo<SIMachineFunctionInfo>();
 208   HSAMD::Kernel::CodeProps::Metadata HSACodeProps;
 209   const Function &F = MF.getFunction();
 210
 211   // Avoid asserting on erroneous cases.
 212   if (F.getCallingConv() != CallingConv::AMDGPU_KERNEL)
 213     return HSACodeProps;
 214
 215   HSACodeProps.mKernargSegmentSize =
 216       STM.getKernArgSegmentSize(F, MFI.getExplicitKernArgSize());
 217   HSACodeProps.mGroupSegmentFixedSize = ProgramInfo.LDSSize;
 218   HSACodeProps.mPrivateSegmentFixedSize = ProgramInfo.ScratchSize;
 219   HSACodeProps.mKernargSegmentAlign =
 220       std::max(uint32_t(4), MFI.getMaxKernArgAlign());
 221   HSACodeProps.mWavefrontSize = STM.getWavefrontSize();
 222   HSACodeProps.mNumSGPRs = ProgramInfo.NumSGPR;
 223   HSACodeProps.mNumVGPRs = ProgramInfo.NumVGPR;
 224   HSACodeProps.mMaxFlatWorkGroupSize = MFI.getMaxFlatWorkGroupSize();
 225   HSACodeProps.mIsDynamicCallStack = ProgramInfo.DynamicCallStack;
 226   HSACodeProps.mIsXNACKEnabled = STM.isXNACKEnabled();
 227   HSACodeProps.mNumSpilledSGPRs = MFI.getNumSpilledSGPRs();
 228   HSACodeProps.mNumSpilledVGPRs = MFI.getNumSpilledVGPRs();
 229
 230   return HSACodeProps;
 231 }
 232
 233 Kernel::DebugProps::Metadata MetadataStreamer::getHSADebugProps(
 234     const MachineFunction &MF,
 235     const SIProgramInfo &ProgramInfo) const {
 236   const GCNSubtarget &STM = MF.getSubtarget<GCNSubtarget>();
 237   HSAMD::Kernel::DebugProps::Metadata HSADebugProps;
 238
 239   if (!STM.debuggerSupported())
 240     return HSADebugProps;
 241
 242   HSADebugProps.mDebuggerABIVersion.push_back(1);
 243   HSADebugProps.mDebuggerABIVersion.push_back(0);
 244
 245   if (STM.debuggerEmitPrologue()) {
 246     HSADebugProps.mPrivateSegmentBufferSGPR =
 247         ProgramInfo.DebuggerPrivateSegmentBufferSGPR;
 248     HSADebugProps.mWavefrontPrivateSegmentOffsetSGPR =
 249         ProgramInfo.DebuggerWavefrontPrivateSegmentOffsetSGPR;
 250   }
 251
 252   return HSADebugProps;
 253 }
 254
 255 void MetadataStreamer::emitVersion() {
 256   auto &Version = HSAMetadata.mVersion;
 257
 258   Version.push_back(VersionMajor);
 259   Version.push_back(VersionMinor);
 260 }
 261
 262 void MetadataStreamer::emitPrintf(const Module &Mod) {
 263   auto &Printf = HSAMetadata.mPrintf;
 264
 265   auto Node = Mod.getNamedMetadata("llvm.printf.fmts");
 266   if (!Node)
 267     return;
 268
 269   for (auto Op : Node->operands())
 270     if (Op->getNumOperands())
 271       Printf.push_back(cast<MDString>(Op->getOperand(0))->getString());
 272 }
 273
 274 void MetadataStreamer::emitKernelLanguage(const Function &Func) {
 275   auto &Kernel = HSAMetadata.mKernels.back();
 276
 277   // TODO: What about other languages?
 278   auto Node = Func.getParent()->getNamedMetadata("opencl.ocl.version");
 279   if (!Node || !Node->getNumOperands())
 280     return;
 281   auto Op0 = Node->getOperand(0);
 282   if (Op0->getNumOperands() <= 1)
 283     return;
 284
 285   Kernel.mLanguage = "OpenCL C";
 286   Kernel.mLanguageVersion.push_back(
 287       mdconst::extract<ConstantInt>(Op0->getOperand(0))->getZExtValue());
 288   Kernel.mLanguageVersion.push_back(
 289       mdconst::extract<ConstantInt>(Op0->getOperand(1))->getZExtValue());
 290 }
 291
 292 void MetadataStreamer::emitKernelAttrs(const Function &Func) {
 293   auto &Attrs = HSAMetadata.mKernels.back().mAttrs;
 294
 295   if (auto Node = Func.getMetadata("reqd_work_group_size"))
 296     Attrs.mReqdWorkGroupSize = getWorkGroupDimensions(Node);
 297   if (auto Node = Func.getMetadata("work_group_size_hint"))
 298     Attrs.mWorkGroupSizeHint = getWorkGroupDimensions(Node);
 299   if (auto Node = Func.getMetadata("vec_type_hint")) {
 300     Attrs.mVecTypeHint = getTypeName(
 301         cast<ValueAsMetadata>(Node->getOperand(0))->getType(),
 302         mdconst::extract<ConstantInt>(Node->getOperand(1))->getZExtValue());
 303   }
 304   if (Func.hasFnAttribute("runtime-handle")) {
 305     Attrs.mRuntimeHandle =
 306         Func.getFnAttribute("runtime-handle").getValueAsString().str();
 307   }
 308 }
 309
 310 void MetadataStreamer::emitKernelArgs(const Function &Func) {
 311   for (auto &Arg : Func.args())
 312     emitKernelArg(Arg);
 313
 314   emitHiddenKernelArgs(Func);
 315 }
 316
 317 void MetadataStreamer::emitKernelArg(const Argument &Arg) {
 318   auto Func = Arg.getParent();
 319   auto ArgNo = Arg.getArgNo();
 320   const MDNode *Node;
 321
 322   StringRef Name;
 323   Node = Func->getMetadata("kernel_arg_name");
 324   if (Node && ArgNo < Node->getNumOperands())
 325     Name = cast<MDString>(Node->getOperand(ArgNo))->getString();
 326   else if (Arg.hasName())
 327     Name = Arg.getName();
 328
 329   StringRef TypeName;
 330   Node = Func->getMetadata("kernel_arg_type");
 331   if (Node && ArgNo < Node->getNumOperands())
 332     TypeName = cast<MDString>(Node->getOperand(ArgNo))->getString();
 333
 334   StringRef BaseTypeName;
 335   Node = Func->getMetadata("kernel_arg_base_type");
 336   if (Node && ArgNo < Node->getNumOperands())
 337     BaseTypeName = cast<MDString>(Node->getOperand(ArgNo))->getString();
 338
 339   StringRef AccQual;
 340   if (Arg.getType()->isPointerTy() && Arg.onlyReadsMemory() &&
 341       Arg.hasNoAliasAttr()) {
 342     AccQual = "read_only";
 343   } else {
 344     Node = Func->getMetadata("kernel_arg_access_qual");
 345     if (Node && ArgNo < Node->getNumOperands())
 346       AccQual = cast<MDString>(Node->getOperand(ArgNo))->getString();
 347   }
 348
 349   StringRef TypeQual;
 350   Node = Func->getMetadata("kernel_arg_type_qual");
 351   if (Node && ArgNo < Node->getNumOperands())
 352     TypeQual = cast<MDString>(Node->getOperand(ArgNo))->getString();
 353
 354   Type *Ty = Arg.getType();
 355   const DataLayout &DL = Func->getParent()->getDataLayout();
 356
 357   unsigned PointeeAlign = 0;
 358   if (auto PtrTy = dyn_cast<PointerType>(Ty)) {
 359     if (PtrTy->getAddressSpace() == AMDGPUASI.LOCAL_ADDRESS) {
 360       PointeeAlign = Arg.getParamAlignment();
 361       if (PointeeAlign == 0)
 362         PointeeAlign = DL.getABITypeAlignment(PtrTy->getElementType());
 363     }
 364   }
 365
 366   emitKernelArg(DL, Ty, getValueKind(Arg.getType(), TypeQual, BaseTypeName),
 367                 PointeeAlign, Name, TypeName, BaseTypeName, AccQual, TypeQual);
 368 }
 369
 370 void MetadataStreamer::emitKernelArg(const DataLayout &DL, Type *Ty,
 371                                      ValueKind ValueKind,
 372                                      unsigned PointeeAlign,
 373                                      StringRef Name,
 374                                      StringRef TypeName, StringRef BaseTypeName,
 375                                      StringRef AccQual, StringRef TypeQual) {
 376   HSAMetadata.mKernels.back().mArgs.push_back(Kernel::Arg::Metadata());
 377   auto &Arg = HSAMetadata.mKernels.back().mArgs.back();
 378
 379   Arg.mName = Name;
 380   Arg.mTypeName = TypeName;
 381   Arg.mSize = DL.getTypeAllocSize(Ty);
 382   Arg.mAlign = DL.getABITypeAlignment(Ty);
 383   Arg.mValueKind = ValueKind;
 384   Arg.mValueType = getValueType(Ty, BaseTypeName);
 385   Arg.mPointeeAlign = PointeeAlign;
 386
 387   if (auto PtrTy = dyn_cast<PointerType>(Ty))
 388     Arg.mAddrSpaceQual = getAddressSpaceQualifer(PtrTy->getAddressSpace());
 389
 390   Arg.mAccQual = getAccessQualifier(AccQual);
 391
 392   // TODO: Emit Arg.mActualAccQual.
 393
 394   SmallVector<StringRef, 1> SplitTypeQuals;
 395   TypeQual.split(SplitTypeQuals, " ", -1, false);
 396   for (StringRef Key : SplitTypeQuals) {
 397     auto P = StringSwitch<bool*>(Key)
 398                  .Case("const",    &Arg.mIsConst)
 399                  .Case("restrict", &Arg.mIsRestrict)
 400                  .Case("volatile", &Arg.mIsVolatile)
 401                  .Case("pipe",     &Arg.mIsPipe)
 402                  .Default(nullptr);
 403     if (P)
 404       *P = true;
 405   }
 406 }
 407
 408 void MetadataStreamer::emitHiddenKernelArgs(const Function &Func) {
 409   int HiddenArgNumBytes =
 410       getIntegerAttribute(Func, "amdgpu-implicitarg-num-bytes", 0);
 411
 412   if (!HiddenArgNumBytes)
 413     return;
 414
 415   auto &DL = Func.getParent()->getDataLayout();
 416   auto Int64Ty = Type::getInt64Ty(Func.getContext());
 417
 418   if (HiddenArgNumBytes >= 8)
 419     emitKernelArg(DL, Int64Ty, ValueKind::HiddenGlobalOffsetX);
 420   if (HiddenArgNumBytes >= 16)
 421     emitKernelArg(DL, Int64Ty, ValueKind::HiddenGlobalOffsetY);
 422   if (HiddenArgNumBytes >= 24)
 423     emitKernelArg(DL, Int64Ty, ValueKind::HiddenGlobalOffsetZ);
 424
 425   auto Int8PtrTy = Type::getInt8PtrTy(Func.getContext(),
 426                                       AMDGPUASI.GLOBAL_ADDRESS);
 427
 428   // Emit "printf buffer" argument if printf is used, otherwise emit dummy
 429   // "none" argument.
 430   if (HiddenArgNumBytes >= 32) {
 431     if (Func.getParent()->getNamedMetadata("llvm.printf.fmts"))
 432       emitKernelArg(DL, Int8PtrTy, ValueKind::HiddenPrintfBuffer);
 433     else
 434       emitKernelArg(DL, Int8PtrTy, ValueKind::HiddenNone);
 435   }
 436
 437   // Emit "default queue" and "completion action" arguments if enqueue kernel is
 438   // used, otherwise emit dummy "none" arguments.
 439   if (HiddenArgNumBytes >= 48) {
 440     if (Func.hasFnAttribute("calls-enqueue-kernel")) {
 441       emitKernelArg(DL, Int8PtrTy, ValueKind::HiddenDefaultQueue);
 442       emitKernelArg(DL, Int8PtrTy, ValueKind::HiddenCompletionAction);
 443     } else {
 444       emitKernelArg(DL, Int8PtrTy, ValueKind::HiddenNone);
 445       emitKernelArg(DL, Int8PtrTy, ValueKind::HiddenNone);
 446     }
 447   }
 448 }
 449
 450 void MetadataStreamer::begin(const Module &Mod) {
 451   AMDGPUASI = getAMDGPUAS(Mod);
 452   emitVersion();
 453   emitPrintf(Mod);
 454 }
 455
 456 void MetadataStreamer::end() {
 457   std::string HSAMetadataString;
 458   if (toString(HSAMetadata, HSAMetadataString))
 459     return;
 460
 461   if (DumpHSAMetadata)
 462     dump(HSAMetadataString);
 463   if (VerifyHSAMetadata)
 464     verify(HSAMetadataString);
 465 }
 466
 467 void MetadataStreamer::emitKernel(const MachineFunction &MF, const SIProgramInfo &ProgramInfo) {
 468   auto &Func = MF.getFunction();
 469   auto CodeProps = getHSACodeProps(MF, ProgramInfo);
 470   auto DebugProps = getHSADebugProps(MF, ProgramInfo);
 471
 472   if (Func.getCallingConv() != CallingConv::AMDGPU_KERNEL)
 473     return;
 474
 475   HSAMetadata.mKernels.push_back(Kernel::Metadata());
 476   auto &Kernel = HSAMetadata.mKernels.back();
 477
 478   Kernel.mName = Func.getName();
 479   Kernel.mSymbolName = (Twine(Func.getName()) + Twine("@kd")).str();
 480   emitKernelLanguage(Func);
 481   emitKernelAttrs(Func);
 482   emitKernelArgs(Func);
 483   HSAMetadata.mKernels.back().mCodeProps = CodeProps;
 484   HSAMetadata.mKernels.back().mDebugProps = DebugProps;
 485 }
 486
 487 } // end namespace HSAMD
 488 } // end namespace AMDGPU
 489 } // end namespace llvm