[AMDGPU] Do not emit isa info as code object metadata

[kzhuravl]

Summary

It was decided to expose this information through other means (rocr)

[yaxunl]

LGTM.

Do we have a general guideline what should be in metadata and what should not? Do we assume that end user should be able to manually craft the metadata when they write the ISA assembly by hand?

[arsenm]

In D30970#701589, @yaxunl wrote:

LGTM.

Do we have a general guideline what should be in metadata and what should not? Do we assume that end user should be able to manually craft the metadata when they write the ISA assembly by hand?

I'm not sure why we need to encode some of these static hardware properties into it. Why doesn't the runtime/debugger know these already?

[tony-tye]

In D30970#701733, @arsenm wrote:

In D30970#701589, @yaxunl wrote:

LGTM.

Do we have a general guideline what should be in metadata and what should not? Do we assume that end user should be able to manually craft the metadata when they write the ISA assembly by hand?

I'm not sure why we need to encode some of these static hardware properties into it. Why doesn't the runtime/debugger know these already?

The plan is not to encode any hardware static properties in the code object, the tools will get these from the ROCM Runtime queries.

The general guideline is that properties required to load the code object into the hardware by the ROCM Runtime and execute it by the CP micro code hardware are in the kernel code descriptor in the .rodata section. Debug information is in the standard DWARF sections. All other properties that are specific to the kernels is in the code object metadata, which includes information needed by high level language runtimes (above ROCM Runtime), tools and any other consumers of the code object. Hardware static information is available from ROCM Runtime queries (which is implemented from header files shared with the compiler so there is a single definition).

[kzhuravl]

Do we have a general guideline what should be in metadata and what should not? Do we assume that end user should be able to manually craft the metadata when they write the ISA assembly by hand?

Our end goal is to make it as flexible as possible (i.e. support unknown keys). Currently we only support a specific set of keys which are defined in the header. I will post docs and format in a separate patch a bit later.

There are assembler tests that show that metadata can be assembled. But overall, crafting the metadata depends on the purpose of the ISA assembly. The consensus we came to is that low level runtimes (e.g. rocr) should not rely on metadata. Rocr does not, so the metadata is not required when targeting code directly for rocr. If the code is being targeted for a high level runtime, or other tools, then some metadata might be required. Each high level runtime, or tool should provide a set of required fields with their documentation, so the user that is crafting ISA can include those fields when writing ISA ass.

I'm not sure why we need to encode some of these static hardware properties into it. Why doesn't the runtime/debugger know these already?

It was agreed that this info should be obtained through the runtime, hence removing it here.

lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp

if (TM.getTargetTriple().getOS() != Triple::AMDHSA)
     return;
 
   AMDGPU::IsaInfo::IsaVersion ISA =
       AMDGPU::IsaInfo::getIsaVersion(getSTI()->getFeatureBits());
 
   getTargetStreamer().EmitDirectiveHSACodeObjectVersion(2, 1);
   getTargetStreamer().EmitDirectiveHSACodeObjectISA(
       ISA.Major, ISA.Minor, ISA.Stepping, "AMD", "AMDGPU");
-  getTargetStreamer().EmitStartOfCodeObjectMetadata(
-      getSTI()->getFeatureBits(), M);
+  getTargetStreamer().EmitStartOfCodeObjectMetadata(M);
 }
 
 void AMDGPUAsmPrinter::EmitEndOfAsmFile(Module &M) {
   if (TM.getTargetTriple().getOS() != Triple::AMDHSA)
     return;
 
-  getTargetStreamer().EmitEndOfCodeObjectMetadata(getSTI()->getFeatureBits());
+  getTargetStreamer().EmitEndOfCodeObjectMetadata();
 }
 
 bool AMDGPUAsmPrinter::isBlockOnlyReachableByFallthrough(
   const MachineBasicBlock *MBB) const {
   if (!AsmPrinter::isBlockOnlyReachableByFallthrough(MBB))
     return false;
 
   if (MBB->empty())

lib/Target/AMDGPU/AsmParser/AMDGPUAsmParser.cpp

bool AMDGPUAsmParser::ParseDirectiveCodeObjectMetadata() {
 
   if (getLexer().is(AsmToken::Eof) && !FoundEnd) {
     return TokError(
         "expected directive .end_amdgpu_code_object_metadata not found");
   }
 
   YamlStream.flush();
 
-  if (!getTargetStreamer().EmitCodeObjectMetadata(getFeatureBits(), YamlString))
+  if (!getTargetStreamer().EmitCodeObjectMetadata(YamlString))
     return Error(getParser().getTok().getLoc(), "invalid code object metadata");
 
   return false;
 }
 
 bool AMDGPUAsmParser::ParseAMDKernelCodeTValue(StringRef ID,
                                                amd_kernel_code_t &Header) {
   SmallString<40> ErrStr;

lib/Target/AMDGPU/MCTargetDesc/AMDGPUCodeObjectMetadata.h

enum class ValueType : uint8_t {
   F32     = 8,
   I64     = 9,
   U64     = 10,
   F64     = 11,
   Unknown = 0xff
 };
 
 //===----------------------------------------------------------------------===//
-// Instruction Set Architecture Metadata (ISA).
-//===----------------------------------------------------------------------===//
-namespace Isa {
-
-namespace Key {
-/// \brief Key for Isa::Metadata::mWavefrontSize.
-constexpr char WavefrontSize[] = "WavefrontSize";
-/// \brief Key for Isa::Metadata::mLocalMemorySize.
-constexpr char LocalMemorySize[] = "LocalMemorySize";
-/// \brief Key for Isa::Metadata::mEUsPerCU.
-constexpr char EUsPerCU[] = "EUsPerCU";
-/// \brief Key for Isa::Metadata::mMaxWavesPerEU.
-constexpr char MaxWavesPerEU[] = "MaxWavesPerEU";
-/// \brief Key for Isa::Metadata::mMaxFlatWorkGroupSize.
-constexpr char MaxFlatWorkGroupSize[] = "MaxFlatWorkGroupSize";
-/// \brief Key for Isa::Metadata::mSGPRAllocGranule.
-constexpr char SGPRAllocGranule[] = "SGPRAllocGranule";
-/// \brief Key for Isa::Metadata::mTotalNumSGPRs.
-constexpr char TotalNumSGPRs[] = "TotalNumSGPRs";
-/// \brief Key for Isa::Metadata::mAddressableNumSGPRs.
-constexpr char AddressableNumSGPRs[] = "AddressableNumSGPRs";
-/// \brief Key for Isa::Metadata::mVGPRAllocGranule.
-constexpr char VGPRAllocGranule[] = "VGPRAllocGranule";
-/// \brief Key for Isa::Metadata::mTotalNumVGPRs.
-constexpr char TotalNumVGPRs[] = "TotalNumVGPRs";
-/// \brief Key for Isa::Metadata::mAddressableNumVGPRs.
-constexpr char AddressableNumVGPRs[] = "AddressableNumVGPRs";
-} // end namespace Key
-
-/// \brief In-memory representation of instruction set architecture metadata.
-struct Metadata final {
-  /// \brief Wavefront size. Required.
-  uint32_t mWavefrontSize = 0;
-  /// \brief Local memory size in bytes. Required.
-  uint32_t mLocalMemorySize = 0;
-  /// \brief Number of execution units per compute unit. Required.
-  uint32_t mEUsPerCU = 0;
-  /// \brief Maximum number of waves per execution unit. Required.
-  uint32_t mMaxWavesPerEU = 0;
-  /// \brief Maximum flat work group size. Required.
-  uint32_t mMaxFlatWorkGroupSize = 0;
-  /// \brief SGPR allocation granularity. Required.
-  uint32_t mSGPRAllocGranule = 0;
-  /// \brief Total number of SGPRs. Required.
-  uint32_t mTotalNumSGPRs = 0;
-  /// \brief Addressable number of SGPRs. Required.
-  uint32_t mAddressableNumSGPRs = 0;
-  /// \brief VGPR allocation granularity. Required.
-  uint32_t mVGPRAllocGranule = 0;
-  /// \brief Total number of VGPRs. Required.
-  uint32_t mTotalNumVGPRs = 0;
-  /// \brief Addressable number of VGPRs. Required.
-  uint32_t mAddressableNumVGPRs = 0;
-
-  /// \brief Default constructor.
-  Metadata() = default;
-};
-
-} // end namespace Isa
-
-//===----------------------------------------------------------------------===//
 // Kernel Metadata.
 //===----------------------------------------------------------------------===//
 namespace Kernel {
 
 //===----------------------------------------------------------------------===//
 // Kernel Attributes Metadata.
 //===----------------------------------------------------------------------===//
 namespace Attrs {
struct Metadata final {
   Metadata() = default;
 };
 
 } // end namespace Kernel
 
 namespace Key {
 /// \brief Key for CodeObject::Metadata::mVersion.
 constexpr char Version[] = "Version";
-/// \brief Key for CodeObject::Metadata::mIsa.
-constexpr char Isa[] = "Isa";
 /// \brief Key for CodeObject::Metadata::mPrintf.
 constexpr char Printf[] = "Printf";
 /// \brief Key for CodeObject::Metadata::mKernels.
 constexpr char Kernels[] = "Kernels";
 } // end namespace Key
 
 /// \brief In-memory representation of code object metadata.
 struct Metadata final {
   /// \brief Code object metadata version. Required.
   std::vector<uint8_t> mVersion = std::vector<uint8_t>();
-  /// \brief Instruction set architecture metadata. Optional.
-  Isa::Metadata mIsa = Isa::Metadata();
   /// \brief Printf metadata. Optional.
   std::vector<std::string> mPrintf = std::vector<std::string>();
   /// \brief Kernels metadata. Optional.
   std::vector<Kernel::Metadata> mKernels = std::vector<Kernel::Metadata>();
 
   /// \brief Default constructor.
   Metadata() = default;
 

lib/Target/AMDGPU/MCTargetDesc/AMDGPUCodeObjectMetadataStreamer.h

 #include "AMDGPUCodeObjectMetadata.h"
 #include "AMDKernelCodeT.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace llvm {
 
 class Argument;
 class DataLayout;
-class FeatureBitset;
 class Function;
 class MDNode;
 class Module;
 class Type;
 
 namespace AMDGPU {
 namespace CodeObject {
 
private:
   ValueType getValueType(Type *Ty, StringRef TypeName) const;
 
   std::string getTypeName(Type *Ty, bool Signed) const;
 
   std::vector<uint32_t> getWorkGroupDimensions(MDNode *Node) const;
 
   void emitVersion();
 
-  void emitIsa(const FeatureBitset &Features);
-
   void emitPrintf(const Module &Mod);
 
   void emitKernelLanguage(const Function &Func);
 
   void emitKernelAttrs(const Function &Func);
 
   void emitKernelArgs(const Function &Func);
 
   void emitKernelArg(const Argument &Arg);
 
   void emitKernelArg(const DataLayout &DL, Type *Ty, ValueKind ValueKind,
                      StringRef TypeQual = "", StringRef BaseTypeName = "",
                      StringRef AccQual = "", StringRef Name = "",
                      StringRef TypeName = "");
 
   void emitKernelCodeProps(const amd_kernel_code_t &KernelCode);
 
   void emitKernelDebugProps(const amd_kernel_code_t &KernelCode);
 
 public:
   MetadataStreamer() = default;
   ~MetadataStreamer() = default;
 
-  void begin(const FeatureBitset &Features, const Module &Mod);
+  void begin(const Module &Mod);
 
   void end() {}
 
   void emitKernel(const Function &Func, const amd_kernel_code_t &KernelCode);
 
   ErrorOr<std::string> toYamlString();
 
-  ErrorOr<std::string> toYamlString(const FeatureBitset &Features,
-                                    StringRef YamlString);
+  ErrorOr<std::string> toYamlString(StringRef YamlString);
 };
 
 } // end namespace CodeObject
 } // end namespace AMDGPU
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_AMDGPU_MCTARGETDESC_AMDGPUCODEOBJECTMETADATASTREAMER_H

lib/Target/AMDGPU/MCTargetDesc/AMDGPUCodeObjectMetadataStreamer.cpp

 /// \file
 /// \brief AMDGPU Code Object Metadata Streamer.
 ///
 //
 //===----------------------------------------------------------------------===//
 
 #include "AMDGPU.h"
 #include "AMDGPUCodeObjectMetadataStreamer.h"
-#include "Utils/AMDGPUBaseInfo.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/YAMLTraits.h"
 
 using namespace llvm::AMDGPU;
 using namespace llvm::AMDGPU::CodeObject;
-using namespace llvm::AMDGPU::IsaInfo;
 
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(uint8_t)
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(uint32_t)
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(std::string)
 LLVM_YAML_IS_SEQUENCE_VECTOR(Kernel::Arg::Metadata)
 LLVM_YAML_IS_SEQUENCE_VECTOR(Kernel::Metadata)
 
 namespace llvm {
static void enumeration(IO &YIO, ValueType &EN) {
     YIO.enumCase(EN, "F32", ValueType::F32);
     YIO.enumCase(EN, "I64", ValueType::I64);
     YIO.enumCase(EN, "U64", ValueType::U64);
     YIO.enumCase(EN, "F64", ValueType::F64);
   }
 };
 
 template <>
-struct MappingTraits<Isa::Metadata> {
-  static void mapping(IO &YIO, Isa::Metadata &MD) {
-    YIO.mapRequired(Isa::Key::WavefrontSize, MD.mWavefrontSize);
-    YIO.mapRequired(Isa::Key::LocalMemorySize, MD.mLocalMemorySize);
-    YIO.mapRequired(Isa::Key::EUsPerCU, MD.mEUsPerCU);
-    YIO.mapRequired(Isa::Key::MaxWavesPerEU, MD.mMaxWavesPerEU);
-    YIO.mapRequired(Isa::Key::MaxFlatWorkGroupSize, MD.mMaxFlatWorkGroupSize);
-    YIO.mapRequired(Isa::Key::SGPRAllocGranule, MD.mSGPRAllocGranule);
-    YIO.mapRequired(Isa::Key::TotalNumSGPRs, MD.mTotalNumSGPRs);
-    YIO.mapRequired(Isa::Key::AddressableNumSGPRs, MD.mAddressableNumSGPRs);
-    YIO.mapRequired(Isa::Key::VGPRAllocGranule, MD.mVGPRAllocGranule);
-    YIO.mapRequired(Isa::Key::TotalNumVGPRs, MD.mTotalNumVGPRs);
-    YIO.mapRequired(Isa::Key::AddressableNumVGPRs, MD.mAddressableNumVGPRs);
-  }
-};
-
-template <>
 struct MappingTraits<Kernel::Attrs::Metadata> {
   static void mapping(IO &YIO, Kernel::Attrs::Metadata &MD) {
     YIO.mapOptional(Kernel::Attrs::Key::ReqdWorkGroupSize,
                     MD.mReqdWorkGroupSize, std::vector<uint32_t>());
     YIO.mapOptional(Kernel::Attrs::Key::WorkGroupSizeHint,
                     MD.mWorkGroupSizeHint, std::vector<uint32_t>());
     YIO.mapOptional(Kernel::Attrs::Key::VecTypeHint,
                     MD.mVecTypeHint, std::string());
if (!MD.mDebugProps.empty() || !YIO.outputting())
       YIO.mapOptional(Kernel::Key::DebugProps, MD.mDebugProps);
   }
 };
 
 template <>
 struct MappingTraits<CodeObject::Metadata> {
   static void mapping(IO &YIO, CodeObject::Metadata &MD) {
     YIO.mapRequired(Key::Version, MD.mVersion);
-    YIO.mapOptional(Key::Isa, MD.mIsa);
     YIO.mapOptional(Key::Printf, MD.mPrintf, std::vector<std::string>());
     if (!MD.mKernels.empty() || !YIO.outputting())
       YIO.mapOptional(Key::Kernels, MD.mKernels);
   }
 };
 
 } // end namespace yaml
 

 
 void MetadataStreamer::emitVersion() {
   auto &Version = CodeObjectMetadata.mVersion;
 
   Version.push_back(MetadataVersionMajor);
   Version.push_back(MetadataVersionMinor);
 }
 
-void MetadataStreamer::emitIsa(const FeatureBitset &Features) {
-  auto &Isa = CodeObjectMetadata.mIsa;
-
-  Isa.mWavefrontSize = getWavefrontSize(Features);
-  Isa.mLocalMemorySize = getLocalMemorySize(Features);
-  Isa.mEUsPerCU = getEUsPerCU(Features);
-  Isa.mMaxWavesPerEU = getMaxWavesPerEU(Features);
-  Isa.mMaxFlatWorkGroupSize = getMaxFlatWorkGroupSize(Features);
-  Isa.mSGPRAllocGranule = getSGPRAllocGranule(Features);
-  Isa.mTotalNumSGPRs = getTotalNumSGPRs(Features);
-  Isa.mAddressableNumSGPRs = getAddressableNumSGPRs(Features);
-  Isa.mVGPRAllocGranule = getVGPRAllocGranule(Features);
-  Isa.mTotalNumVGPRs = getTotalNumVGPRs(Features);
-  Isa.mAddressableNumVGPRs = getAddressableNumVGPRs(Features);
-}
-
 void MetadataStreamer::emitPrintf(const Module &Mod) {
   auto &Printf = CodeObjectMetadata.mPrintf;
 
   auto Node = Mod.getNamedMetadata("llvm.printf.fmts");
   if (!Node)
     return;
 
   for (auto Op : Node->operands())
void MetadataStreamer::emitKernelDebugProps(
   DebugProps.mReservedNumVGPRs = KernelCode.reserved_vgpr_count;
   DebugProps.mReservedFirstVGPR = KernelCode.reserved_vgpr_first;
   DebugProps.mPrivateSegmentBufferSGPR =
       KernelCode.debug_private_segment_buffer_sgpr;
   DebugProps.mWavefrontPrivateSegmentOffsetSGPR =
       KernelCode.debug_wavefront_private_segment_offset_sgpr;
 }
 
-void MetadataStreamer::begin(const FeatureBitset &Features, const Module &Mod) {
+void MetadataStreamer::begin(const Module &Mod) {
   emitVersion();
-  emitIsa(Features);
   emitPrintf(Mod);
 }
 
 void MetadataStreamer::emitKernel(const Function &Func,
                                   const amd_kernel_code_t &KernelCode) {
   if (Func.getCallingConv() != CallingConv::AMDGPU_KERNEL)
     return;
 
ErrorOr<std::string> MetadataStreamer::toYamlString() {
   if (DumpCodeObjectMetadata)
     dump(YamlString.get());
   if (VerifyCodeObjectMetadata)
     verify(YamlString.get());
 
   return YamlString;
 }
 
-ErrorOr<std::string> MetadataStreamer::toYamlString(
-    const FeatureBitset &Features, StringRef YamlString) {
+ErrorOr<std::string> MetadataStreamer::toYamlString(StringRef YamlString) {
   auto ErrorOrCodeObjectMetadata = Metadata::fromYamlString(YamlString);
   if (!ErrorOrCodeObjectMetadata)
     return ErrorOrCodeObjectMetadata.getError();
 
   CodeObjectMetadata = ErrorOrCodeObjectMetadata.get();
-  emitIsa(Features);
   return toYamlString();
 }
 
 } // end namespace CodeObject
 } // end namespace AMDGPU
 } // end namespace llvm

lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.h

 #include "AMDGPUCodeObjectMetadataStreamer.h"
 #include "AMDKernelCodeT.h"
 #include "llvm/MC/MCStreamer.h"
 
 namespace llvm {
 #include "AMDGPUPTNote.h"
 
 class DataLayout;
-class FeatureBitset;
 class Function;
 class MCELFStreamer;
 class MCSymbol;
 class MDNode;
 class Module;
 class Type;
 
 class AMDGPUTargetStreamer : public MCTargetStreamer {
public:
   virtual void EmitAMDKernelCodeT(const amd_kernel_code_t &Header) = 0;
 
   virtual void EmitAMDGPUSymbolType(StringRef SymbolName, unsigned Type) = 0;
 
   virtual void EmitAMDGPUHsaModuleScopeGlobal(StringRef GlobalName) = 0;
 
   virtual void EmitAMDGPUHsaProgramScopeGlobal(StringRef GlobalName) = 0;
 
-  virtual void EmitStartOfCodeObjectMetadata(const FeatureBitset &Features,
-                                             const Module &Mod);
+  virtual void EmitStartOfCodeObjectMetadata(const Module &Mod);
 
   virtual void EmitKernelCodeObjectMetadata(
       const Function &Func, const amd_kernel_code_t &KernelCode);
 
-  virtual void EmitEndOfCodeObjectMetadata(const FeatureBitset &Features);
+  virtual void EmitEndOfCodeObjectMetadata();
 
   /// \returns True on success, false on failure.
-  virtual bool EmitCodeObjectMetadata(const FeatureBitset &Features,
-                                      StringRef YamlString) = 0;
+  virtual bool EmitCodeObjectMetadata(StringRef YamlString) = 0;
 };
 
 class AMDGPUTargetAsmStreamer final : public AMDGPUTargetStreamer {
   formatted_raw_ostream &OS;
 public:
   AMDGPUTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS);
   void EmitDirectiveHSACodeObjectVersion(uint32_t Major,
                                          uint32_t Minor) override;
 
   void EmitDirectiveHSACodeObjectISA(uint32_t Major, uint32_t Minor,
                                      uint32_t Stepping, StringRef VendorName,
                                      StringRef ArchName) override;
 
   void EmitAMDKernelCodeT(const amd_kernel_code_t &Header) override;
 
   void EmitAMDGPUSymbolType(StringRef SymbolName, unsigned Type) override;
 
   void EmitAMDGPUHsaModuleScopeGlobal(StringRef GlobalName) override;
 
   void EmitAMDGPUHsaProgramScopeGlobal(StringRef GlobalName) override;
 
   /// \returns True on success, false on failure.
-  bool EmitCodeObjectMetadata(const FeatureBitset &Features,
-                              StringRef YamlString) override;
+  bool EmitCodeObjectMetadata(StringRef YamlString) override;
 };
 
 class AMDGPUTargetELFStreamer final : public AMDGPUTargetStreamer {
   MCStreamer &Streamer;
 
   void EmitAMDGPUNote(const MCExpr *DescSize,
                       AMDGPU::ElfNote::NoteType Type,
                       function_ref<void(MCELFStreamer &)> EmitDesc);
public:
 
   void EmitAMDGPUSymbolType(StringRef SymbolName, unsigned Type) override;
 
   void EmitAMDGPUHsaModuleScopeGlobal(StringRef GlobalName) override;
 
   void EmitAMDGPUHsaProgramScopeGlobal(StringRef GlobalName) override;
 
   /// \returns True on success, false on failure.
-  bool EmitCodeObjectMetadata(const FeatureBitset &Features,
-                              StringRef YamlString) override;
+  bool EmitCodeObjectMetadata(StringRef YamlString) override;
 };
 
 }
 #endif

lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp

 
 //===----------------------------------------------------------------------===//
 // AMDGPUTargetStreamer
 //===----------------------------------------------------------------------===//
 
 AMDGPUTargetStreamer::AMDGPUTargetStreamer(MCStreamer &S)
     : MCTargetStreamer(S) {}
 
-void AMDGPUTargetStreamer::EmitStartOfCodeObjectMetadata(
-    const FeatureBitset &Features, const Module &Mod) {
-  CodeObjectMetadataStreamer.begin(Features, Mod);
+void AMDGPUTargetStreamer::EmitStartOfCodeObjectMetadata(const Module &Mod) {
+  CodeObjectMetadataStreamer.begin(Mod);
 }
 
 void AMDGPUTargetStreamer::EmitKernelCodeObjectMetadata(
     const Function &Func, const amd_kernel_code_t &KernelCode) {
   CodeObjectMetadataStreamer.emitKernel(Func, KernelCode);
 }
 
-void AMDGPUTargetStreamer::EmitEndOfCodeObjectMetadata(
-    const FeatureBitset &Features) {
+void AMDGPUTargetStreamer::EmitEndOfCodeObjectMetadata() {
   CodeObjectMetadataStreamer.end();
-  EmitCodeObjectMetadata(Features,
-                         CodeObjectMetadataStreamer.toYamlString().get());
+  EmitCodeObjectMetadata(CodeObjectMetadataStreamer.toYamlString().get());
 }
 
 //===----------------------------------------------------------------------===//
 // AMDGPUTargetAsmStreamer
 //===----------------------------------------------------------------------===//
 
 AMDGPUTargetAsmStreamer::AMDGPUTargetAsmStreamer(MCStreamer &S,
                                                  formatted_raw_ostream &OS)
void AMDGPUTargetAsmStreamer::EmitAMDGPUHsaModuleScopeGlobal(
   OS << "\t.amdgpu_hsa_module_global " << GlobalName << '\n';
 }
 
 void AMDGPUTargetAsmStreamer::EmitAMDGPUHsaProgramScopeGlobal(
     StringRef GlobalName) {
   OS << "\t.amdgpu_hsa_program_global " << GlobalName << '\n';
 }
 
-bool AMDGPUTargetAsmStreamer::EmitCodeObjectMetadata(
-    const FeatureBitset &Features, StringRef YamlString) {
-  auto VerifiedYamlString =
-      CodeObjectMetadataStreamer.toYamlString(Features, YamlString);
+bool AMDGPUTargetAsmStreamer::EmitCodeObjectMetadata(StringRef YamlString) {
+  auto VerifiedYamlString = CodeObjectMetadataStreamer.toYamlString(YamlString);
   if (!VerifiedYamlString)
     return false;
 
   OS << '\t' << AMDGPU::CodeObject::MetadataAssemblerDirectiveBegin << '\n';
   OS << VerifiedYamlString.get();
   OS << '\t' << AMDGPU::CodeObject::MetadataAssemblerDirectiveEnd << '\n';
 
   return true;
void AMDGPUTargetELFStreamer::EmitAMDGPUHsaProgramScopeGlobal(
     StringRef GlobalName) {
 
   MCSymbolELF *Symbol = cast<MCSymbolELF>(
       getStreamer().getContext().getOrCreateSymbol(GlobalName));
   Symbol->setType(ELF::STT_OBJECT);
   Symbol->setBinding(ELF::STB_GLOBAL);
 }
 
-bool AMDGPUTargetELFStreamer::EmitCodeObjectMetadata(
-    const FeatureBitset &Features, StringRef YamlString) {
-  auto VerifiedYamlString =
-      CodeObjectMetadataStreamer.toYamlString(Features, YamlString);
+bool AMDGPUTargetELFStreamer::EmitCodeObjectMetadata(StringRef YamlString) {
+  auto VerifiedYamlString = CodeObjectMetadataStreamer.toYamlString(YamlString);
   if (!VerifiedYamlString)
     return false;
 
   // Create two labels to mark the beginning and end of the desc field
   // and a MCExpr to calculate the size of the desc field.
   auto &Context = getContext();
   auto *DescBegin = Context.createTempSymbol();
   auto *DescEnd = Context.createTempSymbol();

test/CodeGen/AMDGPU/code-object-metadata-from-llvm-ir-full.ll

 %opencl.image3d_t = type opaque
 %opencl.queue_t = type opaque
 %opencl.pipe_t = type opaque
 %struct.B = type { i32 addrspace(1)*}
 %opencl.clk_event_t = type opaque
 
 ; CHECK: ---
 ; CHECK:  Version: [ 1, 0 ]
-
-; CHECK:  Isa:
-; CHECK:    WavefrontSize:        64
-; CHECK:    LocalMemorySize:      65536
-; CHECK:    EUsPerCU:             4
-; CHECK:    MaxWavesPerEU:        10
-; CHECK:    MaxFlatWorkGroupSize: 2048
-; GFX700:   SGPRAllocGranule:     8
-; GFX800:   SGPRAllocGranule:     16
-; GFX900:   SGPRAllocGranule:     16
-; GFX700:   TotalNumSGPRs:        512
-; GFX800:   TotalNumSGPRs:        800
-; GFX900:   TotalNumSGPRs:        800
-; GFX700:   AddressableNumSGPRs:  104
-; GFX800:   AddressableNumSGPRs:  96
-; GFX900:   AddressableNumSGPRs:  102
-; CHECK:    VGPRAllocGranule:     4
-; CHECK:    TotalNumVGPRs:        256
-; CHECK:    AddressableNumVGPRs:  256
-
 ; CHECK:  Printf: [ '1:1:4:%d\n', '2:1:8:%g\n' ]
-
 ; CHECK:  Kernels:
 
 ; CHECK:      - Name:            test_char
 ; CHECK-NEXT:   Language:        OpenCL C
 ; CHECK-NEXT:   LanguageVersion: [ 2, 0 ]
 ; CHECK-NEXT:   Args:
 ; CHECK-NEXT:     - Size:          1
 ; CHECK-NEXT:       Align:         1

 !94 = !{!"", !"", !"", !"", !"", !"", !""}
 !100 = !{!"1:1:4:%d\5Cn"}
 !101 = !{!"2:1:8:%g\5Cn"}
 
 ; NOTES: Displaying notes found at file offset 0x{{[0-9]+}}
 ; NOTES-NEXT: Owner    Data size    Description
 ; NOTES-NEXT: AMD      0x00000008   Unknown note type: (0x00000001)
 ; NOTES-NEXT: AMD      0x0000001b   Unknown note type: (0x00000003)
-; GFX700:     AMD      0x0000920c   Unknown note type: (0x0000000a)
-; GFX800:     AMD      0x0000922b   Unknown note type: (0x0000000a)
-; GFX900:     AMD      0x0000920d   Unknown note type: (0x0000000a)
+; GFX700:     AMD      0x000090f3   Unknown note type: (0x0000000a)
+; GFX800:     AMD      0x00009112   Unknown note type: (0x0000000a)
+; GFX900:     AMD      0x000090f3   Unknown note type: (0x0000000a)
 
 ; PARSER: AMDGPU Code Object Metadata Parser Test: PASS

test/CodeGen/AMDGPU/code-object-metadata-invalid-ocl-version-1.ll

 ; RUN: llc -mtriple=amdgcn-amd-amdhsa -filetype=obj -o - < %s | llvm-readobj -amdgpu-code-object-metadata | FileCheck %s
 
 ; Make sure llc does not crash for invalid opencl version metadata.
 
 ; CHECK: ---
 ; CHECK: Version: [ 1, 0 ]
-; CHECK: Isa:
-; CHECK:   WavefrontSize:        64
-; CHECK:   LocalMemorySize:      65536
-; CHECK:   EUsPerCU:             4
-; CHECK:   MaxWavesPerEU:        10
-; CHECK:   MaxFlatWorkGroupSize: 2048
-; CHECK:   SGPRAllocGranule:     8
-; CHECK:   TotalNumSGPRs:        512
-; CHECK:   AddressableNumSGPRs:  104
-; CHECK:   VGPRAllocGranule:     4
-; CHECK:   TotalNumVGPRs:        256
-; CHECK:   AddressableNumVGPRs:  256
 ; CHECK: ...
 
 !opencl.ocl.version = !{}

test/CodeGen/AMDGPU/code-object-metadata-invalid-ocl-version-2.ll

 ; RUN: llc -mtriple=amdgcn-amd-amdhsa -filetype=obj -o - < %s | llvm-readobj -amdgpu-code-object-metadata | FileCheck %s
 
 ; Make sure llc does not crash for invalid opencl version metadata.
 
 ; CHECK: ---
 ; CHECK: Version: [ 1, 0 ]
-; CHECK: Isa:
-; CHECK:   WavefrontSize:        64
-; CHECK:   LocalMemorySize:      65536
-; CHECK:   EUsPerCU:             4
-; CHECK:   MaxWavesPerEU:        10
-; CHECK:   MaxFlatWorkGroupSize: 2048
-; CHECK:   SGPRAllocGranule:     8
-; CHECK:   TotalNumSGPRs:        512
-; CHECK:   AddressableNumSGPRs:  104
-; CHECK:   VGPRAllocGranule:     4
-; CHECK:   TotalNumVGPRs:        256
-; CHECK:   AddressableNumVGPRs:  256
 ; CHECK: ...
 
 !opencl.ocl.version = !{!0}
 !0 = !{}

test/CodeGen/AMDGPU/code-object-metadata-invalid-ocl-version-3.ll

 ; RUN: llc -mtriple=amdgcn-amd-amdhsa -filetype=obj -o - < %s | llvm-readobj -amdgpu-code-object-metadata | FileCheck %s
 
 ; Make sure llc does not crash for invalid opencl version metadata.
 
 ; CHECK: ---
 ; CHECK: Version: [ 1, 0 ]
-; CHECK: Isa:
-; CHECK:   WavefrontSize:        64
-; CHECK:   LocalMemorySize:      65536
-; CHECK:   EUsPerCU:             4
-; CHECK:   MaxWavesPerEU:        10
-; CHECK:   MaxFlatWorkGroupSize: 2048
-; CHECK:   SGPRAllocGranule:     8
-; CHECK:   TotalNumSGPRs:        512
-; CHECK:   AddressableNumSGPRs:  104
-; CHECK:   VGPRAllocGranule:     4
-; CHECK:   TotalNumVGPRs:        256
-; CHECK:   AddressableNumVGPRs:  256
 ; CHECK: ...
 
 !opencl.ocl.version = !{!0}
 !0 = !{i32 1}

test/MC/AMDGPU/code-object-metadata-isa.s

-// RUN: llvm-mc -triple=amdgcn-amd-amdhsa -mcpu=gfx700 -show-encoding %s | FileCheck --check-prefix=CHECK --check-prefix=GFX700 %s
-// RUN: llvm-mc -triple=amdgcn-amd-amdhsa -mcpu=gfx800 -show-encoding %s | FileCheck --check-prefix=CHECK --check-prefix=GFX800 %s
-// RUN: llvm-mc -triple=amdgcn-amd-amdhsa -mcpu=gfx900 -show-encoding %s | FileCheck --check-prefix=CHECK --check-prefix=GFX900 %s
-
-// CHECK:  .amdgpu_code_object_metadata
-// CHECK:    Version: [ 1, 0 ]
-// CHECK:    Isa:
-// CHECK:      WavefrontSize:        64
-// CHECK:      LocalMemorySize:      65536
-// CHECK:      EUsPerCU:             4
-// CHECK:      MaxWavesPerEU:        10
-// CHECK:      MaxFlatWorkGroupSize: 2048
-// GFX700:     SGPRAllocGranule:     8
-// GFX800:     SGPRAllocGranule:     16
-// GFX900:     SGPRAllocGranule:     16
-// GFX700:     TotalNumSGPRs:        512
-// GFX800:     TotalNumSGPRs:        800
-// GFX900:     TotalNumSGPRs:        800
-// GFX700:     AddressableNumSGPRs:  104
-// GFX800:     AddressableNumSGPRs:  96
-// GFX900:     AddressableNumSGPRs:  102
-// CHECK:      VGPRAllocGranule:     4
-// CHECK:      TotalNumVGPRs:        256
-// CHECK:      AddressableNumVGPRs:  256
-// CHECK:    Printf: [ '1:1:4:%d\n', '2:1:8:%g\n' ]
-// CHECK:    Kernels:
-// CHECK:      - Name:            test_kernel
-// CHECK:        Language:        OpenCL C
-// CHECK:        LanguageVersion: [ 2, 0 ]
-// CHECK:        Args:
-// CHECK:          - Size:          1
-// CHECK:            Align:         1
-// CHECK:            Kind:          ByValue
-// CHECK:            ValueType:     I8
-// CHECK:            AccQual:       None
-// CHECK:            TypeName:      char
-// CHECK:          - Size:          8
-// CHECK:            Align:         8
-// CHECK:            Kind:          HiddenGlobalOffsetX
-// CHECK:            ValueType:     I64
-// CHECK:          - Size:          8
-// CHECK:            Align:         8
-// CHECK:            Kind:          HiddenGlobalOffsetY
-// CHECK:            ValueType:     I64
-// CHECK:          - Size:          8
-// CHECK:            Align:         8
-// CHECK:            Kind:          HiddenGlobalOffsetZ
-// CHECK:            ValueType:     I64
-// CHECK:          - Size:          8
-// CHECK:            Align:         8
-// CHECK:            Kind:          HiddenPrintfBuffer
-// CHECK:            ValueType:     I8
-// CHECK:            AddrSpaceQual: Global
-// CHECK:  .end_amdgpu_code_object_metadata
-.amdgpu_code_object_metadata
-  Version: [ 1, 0 ]
-  Isa:
-    WavefrontSize:        1
-    LocalMemorySize:      1
-    EUsPerCU:             1
-    MaxWavesPerEU:        1
-    MaxFlatWorkGroupSize: 1
-    SGPRAllocGranule:     1
-    TotalNumSGPRs:        1
-    AddressableNumSGPRs:  1
-    VGPRAllocGranule:     1
-    TotalNumVGPRs:        1
-    AddressableNumVGPRs:  1
-  Printf: [ '1:1:4:%d\n', '2:1:8:%g\n' ]
-  Kernels:
-    - Name:            test_kernel
-      Language:        OpenCL C
-      LanguageVersion: [ 2, 0 ]
-      Args:
-        - Size:          1
-          Align:         1
-          Kind:          ByValue
-          ValueType:     I8
-          AccQual:       None
-          TypeName:      char
-        - Size:          8
-          Align:         8
-          Kind:          HiddenGlobalOffsetX
-          ValueType:     I64
-        - Size:          8
-          Align:         8
-          Kind:          HiddenGlobalOffsetY
-          ValueType:     I64
-        - Size:          8
-          Align:         8
-          Kind:          HiddenGlobalOffsetZ
-          ValueType:     I64
-        - Size:          8
-          Align:         8
-          Kind:          HiddenPrintfBuffer
-          ValueType:     I8
-          AddrSpaceQual: Global
-.end_amdgpu_code_object_metadata

test/MC/AMDGPU/code-object-metadata-kernel-args.s

 // RUN: llvm-mc -triple=amdgcn-amd-amdhsa -mcpu=gfx700 -show-encoding %s | FileCheck --check-prefix=CHECK --check-prefix=GFX700 %s
 // RUN: llvm-mc -triple=amdgcn-amd-amdhsa -mcpu=gfx800 -show-encoding %s | FileCheck --check-prefix=CHECK --check-prefix=GFX800 %s
 // RUN: llvm-mc -triple=amdgcn-amd-amdhsa -mcpu=gfx900 -show-encoding %s | FileCheck --check-prefix=CHECK --check-prefix=GFX900 %s
 
 // CHECK:  .amdgpu_code_object_metadata
 // CHECK:    Version: [ 1, 0 ]
-// CHECK:    Isa:
-// CHECK:      WavefrontSize:        64
-// CHECK:      LocalMemorySize:      65536
-// CHECK:      EUsPerCU:             4
-// CHECK:      MaxWavesPerEU:        10
-// CHECK:      MaxFlatWorkGroupSize: 2048
-// GFX700:     SGPRAllocGranule:     8
-// GFX800:     SGPRAllocGranule:     16
-// GFX900:     SGPRAllocGranule:     16
-// GFX700:     TotalNumSGPRs:        512
-// GFX800:     TotalNumSGPRs:        800
-// GFX900:     TotalNumSGPRs:        800
-// GFX700:     AddressableNumSGPRs:  104
-// GFX800:     AddressableNumSGPRs:  96
-// GFX900:     AddressableNumSGPRs:  102
-// CHECK:      VGPRAllocGranule:     4
-// CHECK:      TotalNumVGPRs:        256
-// CHECK:      AddressableNumVGPRs:  256
 // CHECK:    Printf: [ '1:1:4:%d\n', '2:1:8:%g\n' ]
 // CHECK:    Kernels:
 // CHECK:      - Name:            test_kernel
 // CHECK:        Language:        OpenCL C
 // CHECK:        LanguageVersion: [ 2, 0 ]
 // CHECK:        Args:
 // CHECK:          - Size:          1
 // CHECK:            Align:         1

test/MC/AMDGPU/code-object-metadata-kernel-attrs.s

 // RUN: llvm-mc -triple=amdgcn-amd-amdhsa -mcpu=gfx700 -show-encoding %s | FileCheck --check-prefix=CHECK --check-prefix=GFX700 %s
 // RUN: llvm-mc -triple=amdgcn-amd-amdhsa -mcpu=gfx800 -show-encoding %s | FileCheck --check-prefix=CHECK --check-prefix=GFX800 %s
 // RUN: llvm-mc -triple=amdgcn-amd-amdhsa -mcpu=gfx900 -show-encoding %s | FileCheck --check-prefix=CHECK --check-prefix=GFX900 %s
 
 // CHECK:  .amdgpu_code_object_metadata
 // CHECK:    Version: [ 1, 0 ]
-// CHECK:    Isa:
-// CHECK:      WavefrontSize:        64
-// CHECK:      LocalMemorySize:      65536
-// CHECK:      EUsPerCU:             4
-// CHECK:      MaxWavesPerEU:        10
-// CHECK:      MaxFlatWorkGroupSize: 2048
-// GFX700:     SGPRAllocGranule:     8
-// GFX800:     SGPRAllocGranule:     16
-// GFX900:     SGPRAllocGranule:     16
-// GFX700:     TotalNumSGPRs:        512
-// GFX800:     TotalNumSGPRs:        800
-// GFX900:     TotalNumSGPRs:        800
-// GFX700:     AddressableNumSGPRs:  104
-// GFX800:     AddressableNumSGPRs:  96
-// GFX900:     AddressableNumSGPRs:  102
-// CHECK:      VGPRAllocGranule:     4
-// CHECK:      TotalNumVGPRs:        256
-// CHECK:      AddressableNumVGPRs:  256
 // CHECK:    Printf: [ '1:1:4:%d\n', '2:1:8:%g\n' ]
 // CHECK:    Kernels:
 // CHECK:      - Name:            test_kernel
 // CHECK:        Language:        OpenCL C
 // CHECK:        LanguageVersion: [ 2, 0 ]
 // CHECK:    Attrs:
 // CHECK:        ReqdWorkGroupSize: [ 1, 2, 4 ]
 // CHECK:        WorkGroupSizeHint: [ 8, 16, 32 ]

test/MC/AMDGPU/hsa.s

.amdgpu_code_object_metadata
   Version: [ 3, 0 ]
   Kernels:
     - Name: amd_kernel_code_t_test_all
     - Name: amd_kernel_code_t_minimal
 .end_amdgpu_code_object_metadata
 
 // ASM: .amdgpu_code_object_metadata
 // ASM:    Version: [ 3, 0 ]
-// ASM:    Isa:
-// ASM:      WavefrontSize:        64
-// ASM:      LocalMemorySize:      65536
-// ASM:      EUsPerCU:             4
-// ASM:      MaxWavesPerEU:        10
-// ASM:      MaxFlatWorkGroupSize: 2048
-// ASM:      SGPRAllocGranule:     8
-// ASM:      TotalNumSGPRs:        512
-// ASM:      AddressableNumSGPRs:  104
-// ASM:      VGPRAllocGranule:     4
-// ASM:      TotalNumVGPRs:        256
-// ASM:      AddressableNumVGPRs:  256
 // ASM:    Kernels:
 // ASM:      - Name: amd_kernel_code_t_test_all
 // ASM:      - Name: amd_kernel_code_t_minimal
 // ASM: .end_amdgpu_code_object_metadata
 
 .amdgpu_hsa_kernel amd_kernel_code_t_test_all
 .amdgpu_hsa_kernel amd_kernel_code_t_minimal