AMDGPU: Bring elf flags in sync with the spec

- Add MACH flags
- Add XNACK flag
- Add reserved flags
- Minor cleanups in docs

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

llvm-svn: 325399

6 files changed, 116 insertions, 31 deletions

diff --git a/llvm/lib/ObjectYAML/ELFYAML.cpp b/llvm/lib/ObjectYAML/ELFYAML.cpp
index 551269e1d6f..928b7b2b1c2 100644
--- a/llvm/lib/ObjectYAML/ELFYAML.cpp
+++ b/llvm/lib/ObjectYAML/ELFYAML.cpp
@@ -369,8 +369,37 @@ void ScalarBitSetTraits<ELFYAML::ELF_EF>::bitset(IO &IO,
     BCase(EF_RISCV_RVE);
     break;
   case ELF::EM_AMDGPU:
-    BCaseMask(EF_AMDGPU_ARCH_R600, EF_AMDGPU_ARCH);
-    BCaseMask(EF_AMDGPU_ARCH_GCN, EF_AMDGPU_ARCH);
+    BCaseMask(EF_AMDGPU_MACH_NONE, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_R600_R600, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_R600_R630, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_R600_RS880, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_R600_RV670, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_R600_RV710, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_R600_RV730, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_R600_RV770, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_R600_CEDAR, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_R600_CYPRESS, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_R600_JUNIPER, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_R600_REDWOOD, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_R600_SUMO, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_R600_BARTS, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_R600_CAICOS, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_R600_CAYMAN, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_R600_TURKS, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX600, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX601, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX700, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX701, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX702, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX703, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX704, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX801, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX802, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX803, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX810, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX900, EF_AMDGPU_MACH);
+    BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX902, EF_AMDGPU_MACH);
+    BCase(EF_AMDGPU_XNACK);
     break;
   case ELF::EM_X86_64:
     break;
diff --git a/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUELFStreamer.cpp b/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUELFStreamer.cpp
index 1497edc7a05..f43db4e368c 100644
--- a/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUELFStreamer.cpp
+++ b/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUELFStreamer.cpp
@@ -15,30 +15,6 @@
 
 using namespace llvm;
 
-AMDGPUELFStreamer::AMDGPUELFStreamer(const Triple &T, MCContext &Context,
-                                     std::unique_ptr<MCAsmBackend> MAB,
-                                     raw_pwrite_stream &OS,
-                                     std::unique_ptr<MCCodeEmitter> Emitter)
-    : MCELFStreamer(Context, std::move(MAB), OS, std::move(Emitter)) {
-  unsigned Arch = ELF::EF_AMDGPU_ARCH_NONE;
-  switch (T.getArch()) {
-  case Triple::r600:
-    Arch = ELF::EF_AMDGPU_ARCH_R600;
-    break;
-  case Triple::amdgcn:
-    Arch = ELF::EF_AMDGPU_ARCH_GCN;
-    break;
-  default:
-    break;
-  }
-
-  MCAssembler &MCA = getAssembler();
-  unsigned EFlags = MCA.getELFHeaderEFlags();
-  EFlags &= ~ELF::EF_AMDGPU_ARCH;
-  EFlags |= Arch;
-  MCA.setELFHeaderEFlags(EFlags);
-}
-
 MCELFStreamer *llvm::createAMDGPUELFStreamer(
     const Triple &T, MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
     raw_pwrite_stream &OS, std::unique_ptr<MCCodeEmitter> Emitter,
diff --git a/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUELFStreamer.h b/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUELFStreamer.h
index 0cc0a4c5cd5..af007ac0840 100644
--- a/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUELFStreamer.h
+++ b/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUELFStreamer.h
@@ -27,7 +27,8 @@ class AMDGPUELFStreamer : public MCELFStreamer {
 public:
   AMDGPUELFStreamer(const Triple &T, MCContext &Context,
                     std::unique_ptr<MCAsmBackend> MAB, raw_pwrite_stream &OS,
-                    std::unique_ptr<MCCodeEmitter> Emitter);
+                    std::unique_ptr<MCCodeEmitter> Emitter)
+      : MCELFStreamer(Context, std::move(MAB), OS, std::move(Emitter)) {}
 };
 
 MCELFStreamer *createAMDGPUELFStreamer(const Triple &T, MCContext &Context,
diff --git a/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUMCTargetDesc.cpp b/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUMCTargetDesc.cpp
index 2b321c04fb3..7e581204be1 100644
--- a/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUMCTargetDesc.cpp
+++ b/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUMCTargetDesc.cpp
@@ -76,7 +76,7 @@ static MCTargetStreamer *createAMDGPUAsmTargetStreamer(MCStreamer &S,
 static MCTargetStreamer * createAMDGPUObjectTargetStreamer(
                                                    MCStreamer &S,
                                                    const MCSubtargetInfo &STI) {
-  return new AMDGPUTargetELFStreamer(S);
+  return new AMDGPUTargetELFStreamer(S, STI);
 }
 
 static MCStreamer *createMCStreamer(const Triple &T, MCContext &Context,
@@ -103,6 +103,8 @@ extern "C" void LLVMInitializeAMDGPUTargetMC() {
   // R600 specific registration
   TargetRegistry::RegisterMCCodeEmitter(getTheAMDGPUTarget(),
                                         createR600MCCodeEmitter);
+  TargetRegistry::RegisterObjectTargetStreamer(
+      getTheAMDGPUTarget(), createAMDGPUObjectTargetStreamer);
 
   // GCN specific registration
   TargetRegistry::RegisterMCCodeEmitter(getTheGCNTarget(),
diff --git a/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp b/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp
index d897956dacc..5223c3a7b3f 100644
--- a/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp
+++ b/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp
@@ -39,6 +39,66 @@ using namespace llvm::AMDGPU;
 // AMDGPUTargetStreamer
 //===----------------------------------------------------------------------===//
 
+unsigned AMDGPUTargetStreamer::getMACH(StringRef GPU) const {
+  return llvm::StringSwitch<unsigned>(GPU)
+      // Radeon HD 2000/3000 Series (R600).
+      .Case("r600", ELF::EF_AMDGPU_MACH_R600_R600)
+      .Case("r630", ELF::EF_AMDGPU_MACH_R600_R630)
+      .Case("rs880", ELF::EF_AMDGPU_MACH_R600_RS880)
+      .Case("rv670", ELF::EF_AMDGPU_MACH_R600_RV670)
+      // Radeon HD 4000 Series (R700).
+      .Case("rv710", ELF::EF_AMDGPU_MACH_R600_RV710)
+      .Case("rv730", ELF::EF_AMDGPU_MACH_R600_RV730)
+      .Case("rv770", ELF::EF_AMDGPU_MACH_R600_RV770)
+      // Radeon HD 5000 Series (Evergreen).
+      .Case("cedar", ELF::EF_AMDGPU_MACH_R600_CEDAR)
+      .Case("cypress", ELF::EF_AMDGPU_MACH_R600_CYPRESS)
+      .Case("juniper", ELF::EF_AMDGPU_MACH_R600_JUNIPER)
+      .Case("redwood", ELF::EF_AMDGPU_MACH_R600_REDWOOD)
+      .Case("sumo", ELF::EF_AMDGPU_MACH_R600_SUMO)
+      // Radeon HD 6000 Series (Northern Islands).
+      .Case("barts", ELF::EF_AMDGPU_MACH_R600_BARTS)
+      .Case("caicos", ELF::EF_AMDGPU_MACH_R600_CAICOS)
+      .Case("cayman", ELF::EF_AMDGPU_MACH_R600_CAYMAN)
+      .Case("turks", ELF::EF_AMDGPU_MACH_R600_TURKS)
+      // AMDGCN GFX6.
+      .Case("gfx600", ELF::EF_AMDGPU_MACH_AMDGCN_GFX600)
+      .Case("tahiti", ELF::EF_AMDGPU_MACH_AMDGCN_GFX600)
+      .Case("gfx601", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601)
+      .Case("hainan", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601)
+      .Case("oland", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601)
+      .Case("pitcairn", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601)
+      .Case("verde", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601)
+      // AMDGCN GFX7.
+      .Case("gfx700", ELF::EF_AMDGPU_MACH_AMDGCN_GFX700)
+      .Case("kaveri", ELF::EF_AMDGPU_MACH_AMDGCN_GFX700)
+      .Case("gfx701", ELF::EF_AMDGPU_MACH_AMDGCN_GFX701)
+      .Case("hawaii", ELF::EF_AMDGPU_MACH_AMDGCN_GFX701)
+      .Case("gfx702", ELF::EF_AMDGPU_MACH_AMDGCN_GFX702)
+      .Case("gfx703", ELF::EF_AMDGPU_MACH_AMDGCN_GFX703)
+      .Case("kabini", ELF::EF_AMDGPU_MACH_AMDGCN_GFX703)
+      .Case("mullins", ELF::EF_AMDGPU_MACH_AMDGCN_GFX703)
+      .Case("gfx704", ELF::EF_AMDGPU_MACH_AMDGCN_GFX704)
+      .Case("bonaire", ELF::EF_AMDGPU_MACH_AMDGCN_GFX704)
+      // AMDGCN GFX8.
+      .Case("gfx801", ELF::EF_AMDGPU_MACH_AMDGCN_GFX801)
+      .Case("carrizo", ELF::EF_AMDGPU_MACH_AMDGCN_GFX801)
+      .Case("gfx802", ELF::EF_AMDGPU_MACH_AMDGCN_GFX802)
+      .Case("iceland", ELF::EF_AMDGPU_MACH_AMDGCN_GFX802)
+      .Case("tonga", ELF::EF_AMDGPU_MACH_AMDGCN_GFX802)
+      .Case("gfx803", ELF::EF_AMDGPU_MACH_AMDGCN_GFX803)
+      .Case("fiji", ELF::EF_AMDGPU_MACH_AMDGCN_GFX803)
+      .Case("polaris10", ELF::EF_AMDGPU_MACH_AMDGCN_GFX803)
+      .Case("polaris11", ELF::EF_AMDGPU_MACH_AMDGCN_GFX803)
+      .Case("gfx810", ELF::EF_AMDGPU_MACH_AMDGCN_GFX810)
+      .Case("stoney", ELF::EF_AMDGPU_MACH_AMDGCN_GFX810)
+      // AMDGCN GFX9.
+      .Case("gfx900", ELF::EF_AMDGPU_MACH_AMDGCN_GFX900)
+      .Case("gfx902", ELF::EF_AMDGPU_MACH_AMDGCN_GFX902)
+      // Not specified processor.
+      .Default(ELF::EF_AMDGPU_MACH_NONE);
+}
+
 bool AMDGPUTargetStreamer::EmitHSAMetadata(StringRef HSAMetadataString) {
   HSAMD::Metadata HSAMetadata;
   if (HSAMD::fromString(HSAMetadataString, HSAMetadata))
@@ -122,8 +182,21 @@ bool AMDGPUTargetAsmStreamer::EmitPALMetadata(
 // AMDGPUTargetELFStreamer
 //===----------------------------------------------------------------------===//
 
-AMDGPUTargetELFStreamer::AMDGPUTargetELFStreamer(MCStreamer &S)
-    : AMDGPUTargetStreamer(S), Streamer(S) {}
+AMDGPUTargetELFStreamer::AMDGPUTargetELFStreamer(
+    MCStreamer &S, const MCSubtargetInfo &STI)
+    : AMDGPUTargetStreamer(S), STI(STI), Streamer(S) {
+  MCAssembler &MCA = getStreamer().getAssembler();
+  unsigned EFlags = MCA.getELFHeaderEFlags();
+
+  EFlags &= ~ELF::EF_AMDGPU_MACH;
+  EFlags |= getMACH(STI.getCPU());
+
+  EFlags &= ~ELF::EF_AMDGPU_XNACK;
+  if (AMDGPU::hasXNACK(STI))
+    EFlags |= ELF::EF_AMDGPU_XNACK;
+
+  MCA.setELFHeaderEFlags(EFlags);
+}
 
 MCELFStreamer &AMDGPUTargetELFStreamer::getStreamer() {
   return static_cast<MCELFStreamer &>(Streamer);
diff --git a/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.h b/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.h
index 0919b754480..5c1d454cf4a 100644
--- a/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.h
+++ b/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.h
@@ -30,6 +30,9 @@ class AMDGPUTargetStreamer : public MCTargetStreamer {
 protected:
   MCContext &getContext() const { return Streamer.getContext(); }
 
+  /// \returns Equivalent EF_AMDGPU_MACH_* value for given \p GPU name.
+  unsigned getMACH(StringRef GPU) const;
+
 public:
   AMDGPUTargetStreamer(MCStreamer &S) : MCTargetStreamer(S) {}
 
@@ -84,13 +87,14 @@ public:
 };
 
 class AMDGPUTargetELFStreamer final : public AMDGPUTargetStreamer {
+  const MCSubtargetInfo &STI;
   MCStreamer &Streamer;
 
   void EmitAMDGPUNote(const MCExpr *DescSize, unsigned NoteType,
                       function_ref<void(MCELFStreamer &)> EmitDesc);
 
 public:
-  AMDGPUTargetELFStreamer(MCStreamer &S);
+  AMDGPUTargetELFStreamer(MCStreamer &S, const MCSubtargetInfo &STI);
 
   MCELFStreamer &getStreamer();