[SystemZ] Add support for tune-cpu attribute

[Kai]

Summary

clang (like gcc) has the -mtune= command line option. This option
adds the "tune-cpu" attribute to a function. The intended functionality
is that the scheduling model of that cpu is used. E.g. -mtune=z15 -march=z14
generates only instructions supported on z14 but uses the scheduling model
of z15 for it.
This PR adds the infrastructure to support this.

[uweigand]

LGTM, thanks!

llvm/lib/Target/SystemZ/SystemZSubtarget.h

private:
   Triple TargetTriple;
   std::unique_ptr<SystemZCallingConventionRegisters> SpecialRegisters;
   SystemZInstrInfo InstrInfo;
   SystemZTargetLowering TLInfo;
   SystemZSelectionDAGInfo TSInfo;
   std::unique_ptr<const SystemZFrameLowering> FrameLowering;
 
   SystemZSubtarget &initializeSubtargetDependencies(StringRef CPU,
+                                                    StringRef TuneCPU,
                                                     StringRef FS);
   SystemZCallingConventionRegisters *initializeSpecialRegisters();
 
 public:
   SystemZSubtarget(const Triple &TT, const std::string &CPU,
-                   const std::string &FS, const TargetMachine &TM);
+                   const std::string &TuneCPU, const std::string &FS,
+                   const TargetMachine &TM);
 
   SystemZCallingConventionRegisters *getSpecialRegisters() const {
     assert(SpecialRegisters && "Unsupported SystemZ calling convention");
     return SpecialRegisters.get();
   }
 
   template <class SR> SR &getSpecialRegisters() const {
     return *static_cast<SR *>(getSpecialRegisters());

llvm/lib/Target/SystemZ/SystemZSubtarget.cpp

 static cl::opt<bool> UseSubRegLiveness(
     "systemz-subreg-liveness",
     cl::desc("Enable subregister liveness tracking for SystemZ (experimental)"),
     cl::Hidden);
 
 // Pin the vtable to this file.
 void SystemZSubtarget::anchor() {}
 
-SystemZSubtarget &
-SystemZSubtarget::initializeSubtargetDependencies(StringRef CPU, StringRef FS) {
-  StringRef CPUName = CPU;
-  if (CPUName.empty())
-    CPUName = "generic";
+SystemZSubtarget &SystemZSubtarget::initializeSubtargetDependencies(
+    StringRef CPU, StringRef TuneCPU, StringRef FS) {
+  if (CPU.empty())
+    CPU = "generic";
+  if (TuneCPU.empty())
+    TuneCPU = CPU;
   // Parse features string.
-  ParseSubtargetFeatures(CPUName, /*TuneCPU*/ CPUName, FS);
+  ParseSubtargetFeatures(CPU, TuneCPU, FS);
 
   // -msoft-float implies -mno-vx.
   if (HasSoftFloat)
     HasVector = false;
 
   // -mno-vx implicitly disables all vector-related features.
   if (!HasVector) {
     HasVectorEnhancements1 = false;
else if (isTargetELF())
     return new SystemZELFRegisters;
   else {
     llvm_unreachable("Invalid Calling Convention. Cannot initialize Special "
                      "Call Registers!");
   }
 }
 
 SystemZSubtarget::SystemZSubtarget(const Triple &TT, const std::string &CPU,
+                                   const std::string &TuneCPU,
                                    const std::string &FS,
                                    const TargetMachine &TM)
-    : SystemZGenSubtargetInfo(TT, CPU, /*TuneCPU*/ CPU, FS),
+    : SystemZGenSubtargetInfo(TT, CPU, TuneCPU, FS),
       HasDistinctOps(false), HasLoadStoreOnCond(false), HasHighWord(false),
       HasFPExtension(false), HasPopulationCount(false),
       HasMessageSecurityAssist3(false), HasMessageSecurityAssist4(false),
       HasResetReferenceBitsMultiple(false), HasFastSerialization(false),
       HasInterlockedAccess1(false), HasMiscellaneousExtensions(false),
       HasExecutionHint(false), HasLoadAndTrap(false),
       HasTransactionalExecution(false), HasProcessorAssist(false),
       HasDFPZonedConversion(false), HasEnhancedDAT2(false), HasVector(false),
       HasLoadStoreOnCond2(false), HasLoadAndZeroRightmostByte(false),
       HasMessageSecurityAssist5(false), HasDFPPackedConversion(false),
       HasMiscellaneousExtensions2(false), HasGuardedStorage(false),
       HasMessageSecurityAssist7(false), HasMessageSecurityAssist8(false),
       HasVectorEnhancements1(false), HasVectorPackedDecimal(false),
       HasInsertReferenceBitsMultiple(false), HasMiscellaneousExtensions3(false),
       HasMessageSecurityAssist9(false), HasVectorEnhancements2(false),
       HasVectorPackedDecimalEnhancement(false), HasEnhancedSort(false),
       HasDeflateConversion(false), HasVectorPackedDecimalEnhancement2(false),
       HasNNPAssist(false), HasBEAREnhancement(false),
       HasResetDATProtection(false), HasProcessorActivityInstrumentation(false),
       HasSoftFloat(false), TargetTriple(TT),
       SpecialRegisters(initializeSpecialRegisters()),
-      InstrInfo(initializeSubtargetDependencies(CPU, FS)), TLInfo(TM, *this),
-      FrameLowering(SystemZFrameLowering::create(*this)) {}
+      InstrInfo(initializeSubtargetDependencies(CPU, TuneCPU, FS)),
+      TLInfo(TM, *this), FrameLowering(SystemZFrameLowering::create(*this)) {}
 
 bool SystemZSubtarget::enableSubRegLiveness() const {
   return UseSubRegLiveness;
 }
 
 bool SystemZSubtarget::isPC32DBLSymbol(const GlobalValue *GV,
                                        CodeModel::Model CM) const {
   // PC32DBL accesses require the low bit to be clear.

llvm/lib/Target/SystemZ/SystemZTargetMachine.cpp

SystemZTargetMachine::SystemZTargetMachine(const Target &T, const Triple &TT,
   initAsmInfo();
 }
 
 SystemZTargetMachine::~SystemZTargetMachine() = default;
 
 const SystemZSubtarget *
 SystemZTargetMachine::getSubtargetImpl(const Function &F) const {
   Attribute CPUAttr = F.getFnAttribute("target-cpu");
+  Attribute TuneAttr = F.getFnAttribute("tune-cpu");
   Attribute FSAttr = F.getFnAttribute("target-features");
 
   std::string CPU =
       CPUAttr.isValid() ? CPUAttr.getValueAsString().str() : TargetCPU;
+  std::string TuneCPU =
+      TuneAttr.isValid() ? TuneAttr.getValueAsString().str() : CPU;
   std::string FS =
       FSAttr.isValid() ? FSAttr.getValueAsString().str() : TargetFS;
 
   // FIXME: This is related to the code below to reset the target options,
   // we need to know whether or not the soft float flag is set on the
   // function, so we can enable it as a subtarget feature.
   bool softFloat = F.getFnAttribute("use-soft-float").getValueAsBool();
 
   if (softFloat)
     FS += FS.empty() ? "+soft-float" : ",+soft-float";
 
-  auto &I = SubtargetMap[CPU + FS];
+  auto &I = SubtargetMap[CPU + TuneCPU + FS];
   if (!I) {
     // This needs to be done before we create a new subtarget since any
     // creation will depend on the TM and the code generation flags on the
     // function that reside in TargetOptions.
     resetTargetOptions(F);
-    I = std::make_unique<SystemZSubtarget>(TargetTriple, CPU, FS, *this);
+    I = std::make_unique<SystemZSubtarget>(TargetTriple, CPU, TuneCPU, FS,
+                                           *this);
   }
 
   return I.get();
 }
 
 namespace {
 
 /// SystemZ Code Generator Pass Configuration Options.