This is an archive of the discontinued LLVM Phabricator instance.

Differential D46587

[AMDGPU] Provide machine -> name mapping
ClosedPublic

Authored by tpr on May 8 2018, 10:07 AM.

Details

Reviewers
kzhuravl
scott.linder
Commits
rG64afc2d7f05a: [AMDGPU] Provide machine -> name mapping
rL331798: [AMDGPU] Provide machine -> name mapping
Summary

AMDGPU stores a numerical code for the particular GPU variant in EFlags
in the ELF file. This commit provides a mapping from that number into
the machine name for use by objdump-type tools.

Change-Id: Id37fc0bebad443bd89c0080985ce298c4e7e9319

Diff Detail

Repository
rL LLVM

Event Timeline

tpr created this revision.May 8 2018, 10:07 AM
Herald added subscribers: llvm-commits, t-tye, dstuttard and 5 others. · View Herald TranscriptMay 8 2018, 10:07 AM
Harbormaster completed remote builds in B17839: Diff 145716.May 8 2018, 10:07 AM
tpr added reviewers: kzhuravl, scott.linder.May 8 2018, 10:09 AM
kzhuravl accepted this revision.May 8 2018, 10:11 AM

LGTM

This revision is now accepted and ready to land.May 8 2018, 10:11 AM
Closed by commit rL331798: [AMDGPU] Provide machine -> name mapping (authored by tpr). · Explain WhyMay 8 2018, 11:56 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
lib/
Target/
AMDGPU/
MCTargetDesc/
3 lines
118 lines

Diff 145751

llvm/trunk/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.h

Show All 28 Lines
class AMDGPUTargetStreamer : public MCTargetStreamer { class AMDGPUTargetStreamer : public MCTargetStreamer {
protected: protected:
MCContext &getContext() const { return Streamer.getContext(); } MCContext &getContext() const { return Streamer.getContext(); }
/// \returns Equivalent EF_AMDGPU_MACH_* value for given \p GPU name. /// \returns Equivalent EF_AMDGPU_MACH_* value for given \p GPU name.
unsigned getMACH(StringRef GPU) const; unsigned getMACH(StringRef GPU) const;
public: public:
/// \returns Equivalent GPU name for an EF_AMDGPU_MACH_* value.
static const char *getMachName(unsigned Mach);
AMDGPUTargetStreamer(MCStreamer &S) : MCTargetStreamer(S) {} AMDGPUTargetStreamer(MCStreamer &S) : MCTargetStreamer(S) {}
virtual void EmitDirectiveHSACodeObjectVersion(uint32_t Major, virtual void EmitDirectiveHSACodeObjectVersion(uint32_t Major,
uint32_t Minor) = 0; uint32_t Minor) = 0;
virtual void EmitDirectiveHSACodeObjectISA(uint32_t Major, uint32_t Minor, virtual void EmitDirectiveHSACodeObjectISA(uint32_t Major, uint32_t Minor,
uint32_t Stepping, uint32_t Stepping,
StringRef VendorName, StringRef VendorName,
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp

Show All 33 Lines
using namespace llvm; using namespace llvm;
using namespace llvm::AMDGPU; using namespace llvm::AMDGPU;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AMDGPUTargetStreamer // AMDGPUTargetStreamer
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
unsigned AMDGPUTargetStreamer::getMACH(StringRef GPU) const { static const struct {
return llvm::StringSwitch<unsigned>(GPU) const char *Name;
unsigned Mach;
} MachTable[] = {
// Radeon HD 2000/3000 Series (R600). // Radeon HD 2000/3000 Series (R600).
.Case("r600", ELF::EF_AMDGPU_MACH_R600_R600) { "r600", ELF::EF_AMDGPU_MACH_R600_R600 },
.Case("r630", ELF::EF_AMDGPU_MACH_R600_R630) { "r630", ELF::EF_AMDGPU_MACH_R600_R630 },
.Case("rs880", ELF::EF_AMDGPU_MACH_R600_RS880) { "rs880", ELF::EF_AMDGPU_MACH_R600_RS880 },
.Case("rv670", ELF::EF_AMDGPU_MACH_R600_RV670) { "rv670", ELF::EF_AMDGPU_MACH_R600_RV670 },
// Radeon HD 4000 Series (R700). // Radeon HD 4000 Series (R700).
.Case("rv710", ELF::EF_AMDGPU_MACH_R600_RV710) { "rv710", ELF::EF_AMDGPU_MACH_R600_RV710 },
.Case("rv730", ELF::EF_AMDGPU_MACH_R600_RV730) { "rv730", ELF::EF_AMDGPU_MACH_R600_RV730 },
.Case("rv770", ELF::EF_AMDGPU_MACH_R600_RV770) { "rv770", ELF::EF_AMDGPU_MACH_R600_RV770 },
// Radeon HD 5000 Series (Evergreen). // Radeon HD 5000 Series (Evergreen).
.Case("cedar", ELF::EF_AMDGPU_MACH_R600_CEDAR) { "cedar", ELF::EF_AMDGPU_MACH_R600_CEDAR },
.Case("cypress", ELF::EF_AMDGPU_MACH_R600_CYPRESS) { "cypress", ELF::EF_AMDGPU_MACH_R600_CYPRESS },
.Case("juniper", ELF::EF_AMDGPU_MACH_R600_JUNIPER) { "juniper", ELF::EF_AMDGPU_MACH_R600_JUNIPER },
.Case("redwood", ELF::EF_AMDGPU_MACH_R600_REDWOOD) { "redwood", ELF::EF_AMDGPU_MACH_R600_REDWOOD },
.Case("sumo", ELF::EF_AMDGPU_MACH_R600_SUMO) { "sumo", ELF::EF_AMDGPU_MACH_R600_SUMO },
// Radeon HD 6000 Series (Northern Islands). // Radeon HD 6000 Series (Northern Islands).
.Case("barts", ELF::EF_AMDGPU_MACH_R600_BARTS) { "barts", ELF::EF_AMDGPU_MACH_R600_BARTS },
.Case("caicos", ELF::EF_AMDGPU_MACH_R600_CAICOS) { "caicos", ELF::EF_AMDGPU_MACH_R600_CAICOS },
.Case("cayman", ELF::EF_AMDGPU_MACH_R600_CAYMAN) { "cayman", ELF::EF_AMDGPU_MACH_R600_CAYMAN },
.Case("turks", ELF::EF_AMDGPU_MACH_R600_TURKS) { "turks", ELF::EF_AMDGPU_MACH_R600_TURKS },
// AMDGCN GFX6. // AMDGCN GFX6.
.Case("gfx600", ELF::EF_AMDGPU_MACH_AMDGCN_GFX600) { "gfx600", ELF::EF_AMDGPU_MACH_AMDGCN_GFX600 },
.Case("tahiti", ELF::EF_AMDGPU_MACH_AMDGCN_GFX600) { "tahiti", ELF::EF_AMDGPU_MACH_AMDGCN_GFX600 },
.Case("gfx601", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601) { "gfx601", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601 },
.Case("hainan", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601) { "hainan", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601 },
.Case("oland", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601) { "oland", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601 },
.Case("pitcairn", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601) { "pitcairn", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601 },
.Case("verde", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601) { "verde", ELF::EF_AMDGPU_MACH_AMDGCN_GFX601 },
// AMDGCN GFX7. // AMDGCN GFX7.
.Case("gfx700", ELF::EF_AMDGPU_MACH_AMDGCN_GFX700) { "gfx700", ELF::EF_AMDGPU_MACH_AMDGCN_GFX700 },
.Case("kaveri", ELF::EF_AMDGPU_MACH_AMDGCN_GFX700) { "kaveri", ELF::EF_AMDGPU_MACH_AMDGCN_GFX700 },
.Case("gfx701", ELF::EF_AMDGPU_MACH_AMDGCN_GFX701) { "gfx701", ELF::EF_AMDGPU_MACH_AMDGCN_GFX701 },
.Case("hawaii", ELF::EF_AMDGPU_MACH_AMDGCN_GFX701) { "hawaii", ELF::EF_AMDGPU_MACH_AMDGCN_GFX701 },
.Case("gfx702", ELF::EF_AMDGPU_MACH_AMDGCN_GFX702) { "gfx702", ELF::EF_AMDGPU_MACH_AMDGCN_GFX702 },
.Case("gfx703", ELF::EF_AMDGPU_MACH_AMDGCN_GFX703) { "gfx703", ELF::EF_AMDGPU_MACH_AMDGCN_GFX703 },
.Case("kabini", ELF::EF_AMDGPU_MACH_AMDGCN_GFX703) { "kabini", ELF::EF_AMDGPU_MACH_AMDGCN_GFX703 },
.Case("mullins", ELF::EF_AMDGPU_MACH_AMDGCN_GFX703) { "mullins", ELF::EF_AMDGPU_MACH_AMDGCN_GFX703 },
.Case("gfx704", ELF::EF_AMDGPU_MACH_AMDGCN_GFX704) { "gfx704", ELF::EF_AMDGPU_MACH_AMDGCN_GFX704 },
.Case("bonaire", ELF::EF_AMDGPU_MACH_AMDGCN_GFX704) { "bonaire", ELF::EF_AMDGPU_MACH_AMDGCN_GFX704 },
// AMDGCN GFX8. // AMDGCN GFX8.
.Case("gfx801", ELF::EF_AMDGPU_MACH_AMDGCN_GFX801) { "gfx801", ELF::EF_AMDGPU_MACH_AMDGCN_GFX801 },
.Case("carrizo", ELF::EF_AMDGPU_MACH_AMDGCN_GFX801) { "carrizo", ELF::EF_AMDGPU_MACH_AMDGCN_GFX801 },
.Case("gfx802", ELF::EF_AMDGPU_MACH_AMDGCN_GFX802) { "gfx802", ELF::EF_AMDGPU_MACH_AMDGCN_GFX802 },
.Case("iceland", ELF::EF_AMDGPU_MACH_AMDGCN_GFX802) { "iceland", ELF::EF_AMDGPU_MACH_AMDGCN_GFX802 },
.Case("tonga", ELF::EF_AMDGPU_MACH_AMDGCN_GFX802) { "tonga", ELF::EF_AMDGPU_MACH_AMDGCN_GFX802 },
.Case("gfx803", ELF::EF_AMDGPU_MACH_AMDGCN_GFX803) { "gfx803", ELF::EF_AMDGPU_MACH_AMDGCN_GFX803 },
.Case("fiji", ELF::EF_AMDGPU_MACH_AMDGCN_GFX803) { "fiji", ELF::EF_AMDGPU_MACH_AMDGCN_GFX803 },
.Case("polaris10", ELF::EF_AMDGPU_MACH_AMDGCN_GFX803) { "polaris10", ELF::EF_AMDGPU_MACH_AMDGCN_GFX803 },
.Case("polaris11", ELF::EF_AMDGPU_MACH_AMDGCN_GFX803) { "polaris11", ELF::EF_AMDGPU_MACH_AMDGCN_GFX803 },
.Case("gfx810", ELF::EF_AMDGPU_MACH_AMDGCN_GFX810) { "gfx810", ELF::EF_AMDGPU_MACH_AMDGCN_GFX810 },
.Case("stoney", ELF::EF_AMDGPU_MACH_AMDGCN_GFX810) { "stoney", ELF::EF_AMDGPU_MACH_AMDGCN_GFX810 },
// AMDGCN GFX9. // AMDGCN GFX9.
.Case("gfx900", ELF::EF_AMDGPU_MACH_AMDGCN_GFX900) { "gfx900", ELF::EF_AMDGPU_MACH_AMDGCN_GFX900 },
.Case("gfx902", ELF::EF_AMDGPU_MACH_AMDGCN_GFX902) { "gfx902", ELF::EF_AMDGPU_MACH_AMDGCN_GFX902 },
.Case("gfx904", ELF::EF_AMDGPU_MACH_AMDGCN_GFX904) { "gfx904", ELF::EF_AMDGPU_MACH_AMDGCN_GFX904 },
.Case("gfx906", ELF::EF_AMDGPU_MACH_AMDGCN_GFX906) { "gfx906", ELF::EF_AMDGPU_MACH_AMDGCN_GFX906 },
// Not specified processor. // Not specified processor.
.Default(ELF::EF_AMDGPU_MACH_NONE); { nullptr, ELF::EF_AMDGPU_MACH_NONE }
};
unsigned AMDGPUTargetStreamer::getMACH(StringRef GPU) const {
auto Entry = MachTable;
for (; Entry->Name && GPU != Entry->Name; ++Entry)
;
return Entry->Mach;
}
const char *AMDGPUTargetStreamer::getMachName(unsigned Mach) {
auto Entry = MachTable;
for (; Entry->Name && Mach != Entry->Mach; ++Entry)
;
return Entry->Name;
} }
bool AMDGPUTargetStreamer::EmitHSAMetadata(StringRef HSAMetadataString) { bool AMDGPUTargetStreamer::EmitHSAMetadata(StringRef HSAMetadataString) {
HSAMD::Metadata HSAMetadata; HSAMD::Metadata HSAMetadata;
if (HSAMD::fromString(HSAMetadataString, HSAMetadata)) if (HSAMD::fromString(HSAMetadataString, HSAMetadata))
return false; return false;
return EmitHSAMetadata(HSAMetadata); return EmitHSAMetadata(HSAMetadata);
▲ Show 20 Lines • Show All 239 Lines • Show Last 20 Lines