[PowerPC] Use PredictableSelectIsExpensive to enable select to branch in CGP

[ZhangKang]

Summary

There is a patch D19488: [CodeGenPrepare] use branch weight metadata to decide if a select should be turned into a branch, this patch is for CGP, it will try to convert SELECT to branch based on the BranchProbability, when the BranchProbability more than MinPercentageForPredictableBranch(default value is 99%).
The variable PredictableSelectExpensive can be set whether we will do this SELECT to branch optimization, the default value is false. Now only ARM and X86 has set this variable like this:

For PPC, we should also set the variable PredictableSelectIsExpensive to do the select to if based on BranchProbability in CodeGenPrepare.

[nemanjai]

llvm/lib/Target/PowerPC/PPC.td

292

This should certainly be set for Power8 as well.

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

1285

I think that having the same name PredictableSelectIsExpensive as members of both the TLI and the Subtarget is a bit confusing. At the very least, the comment should be a bit more descriptive. Perhaps:

// Let the subtarget (CPU) decide if a predictable select is more
// expensive than the corresponding branch. This information is used
// in CGP to decide when to convert selects into branches.

llvm/lib/Target/PowerPC/PPCSubtarget.h

143

For the sake of convention, leave this uninitialized here and initialize it in PPCSubtarget::initializeEnvironment() just like all the rest of these.

[ZhangKang]

llvm/lib/Target/PowerPC/PPC.td

292

I haven't do the performance for the Power8, so I only enable it for Power9.

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

1285

Have modified the comments.

[ZhangKang]

Modified the patch to follow Nemanjai's comments.

[ZhangKang]

Modify the test case and add set the FeaturePredictableSelectIsExpensive for power8.

[ZhangKang]

llvm/lib/Target/PowerPC/PPC.td

292

Have set the FeaturePredictableSelectIsExpensive for Power8.

[ZhangKang]

Update the full context.

[nemanjai]

LGTM.

[ZhangKang]

Rebase.

[ZhangKang]

Rebase.

llvm/lib/Target/PowerPC/PPC.td

 // A separate feature for this even though it is equivalent to P9Vector
 // because this is a feature of the implementation rather than the architecture
 // and may go away with future CPU's.
 def FeatureVectorsUseTwoUnits : SubtargetFeature<"vectors-use-two-units",
                                                  "VectorsUseTwoUnits",
                                                  "true",
                                                  "Vectors use two units">;
 
+
+def FeaturePredictableSelectIsExpensive :
+  SubtargetFeature<"predictable-select-expensive",
+                   "PredictableSelectIsExpensive",
+                   "true",
+                   "Prefer likely predicted branches over selects">;
+
 // Since new processors generally contain a superset of features of those that
 // came before them, the idea is to make implementations of new processors
 // less error prone and easier to read.
 // Namely:
 //     list<SubtargetFeature> P8InheritableFeatures = ...
 //     list<SubtargetFeature> FutureProcessorAddtionalFeatures =
 //         [ features that Power8 does not support but inheritable ]
 //     list<SubtargetFeature> FutureProcessorSpecificFeatures =
list<SubtargetFeature> P8AdditionalFeatures = [DirectivePwr8,
                                                  FeaturePartwordAtomic];
   list<SubtargetFeature> P8SpecificFeatures = [];
   list<SubtargetFeature> P8InheritableFeatures =
     !listconcat(P7InheritableFeatures, P8AdditionalFeatures);
   list<SubtargetFeature> P8Features =
     !listconcat(P8InheritableFeatures, P8SpecificFeatures);
 
   // Power9
-  list<SubtargetFeature> P9AdditionalFeatures = [DirectivePwr9,
-                                                 FeatureP9Altivec,
-                                                 FeatureP9Vector,
-                                                 FeatureISA3_0];
+  list<SubtargetFeature> P9AdditionalFeatures =
+    [DirectivePwr9,
+     FeatureISA3_0,
+     FeaturePredictableSelectIsExpensive
+     ];
+
   // Some features are unique to Power9 and there is no reason to assume
   // they will be part of any future CPUs. One example is the narrower
   // dispatch for vector operations than scalar ones. For the time being,
   // this list also includes scheduling-related features since we do not have
   // enough info to create custom scheduling strategies for future CPUs.
   list<SubtargetFeature> P9SpecificFeatures = [FeatureVectorsUseTwoUnits,
                                                FeaturePPCPreRASched,
                                                FeaturePPCPostRASched];

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

if (Subtarget.getCPUDirective() == PPC::DIR_E500mc ||
     MaxStoresPerMemset = 128;
     MaxStoresPerMemcpy = 128;
     MaxStoresPerMemmove = 128;
     MaxLoadsPerMemcmp = 128;
   } else {
     MaxLoadsPerMemcmp = 8;
     MaxLoadsPerMemcmpOptSize = 4;
   }
+
+  // Let the subtarget (CPU) decide if a predictable select is more expensive
+  // than the corresponding branch. This information is used in CGP to decide
+  // when to convert selects into branches.
+  PredictableSelectIsExpensive = Subtarget.isPredictableSelectIsExpensive();
 }
 
 /// getMaxByValAlign - Helper for getByValTypeAlignment to determine
 /// the desired ByVal argument alignment.
 static void getMaxByValAlign(Type *Ty, unsigned &MaxAlign,
                              unsigned MaxMaxAlign) {
   if (MaxAlign == MaxMaxAlign)
     return;

llvm/lib/Target/PowerPC/PPCSubtarget.h

protected:
   bool HasHTM;
   bool HasFloat128;
   bool IsISA3_0;
   bool UseLongCalls;
   bool SecurePlt;
   bool VectorsUseTwoUnits;
   bool UsePPCPreRASchedStrategy;
   bool UsePPCPostRASchedStrategy;
+  bool PredictableSelectIsExpensive;
 
   POPCNTDKind HasPOPCNTD;
 
   /// When targeting QPX running a stock PPC64 Linux kernel where the stack
   /// alignment has not been changed, we need to keep the 16-byte alignment
   /// of the stack.
   bool IsQPXStackUnaligned;
 
MCRegister getTOCPointerRegister() const {
     return IsPPC64 ? PPC::X2 : PPC::R2;
   }
 
   MCRegister getStackPointerRegister() const {
     return IsPPC64 ? PPC::X1 : PPC::R1;
   }
 
   bool isXRaySupported() const override { return IsPPC64 && IsLittleEndian; }
+
+  bool isPredictableSelectIsExpensive() const {
+    return PredictableSelectIsExpensive;
+  }
 };
 } // End llvm namespace
 
 #endif

llvm/lib/Target/PowerPC/PPCSubtarget.cpp

void PPCSubtarget::initializeEnvironment() {
   HasHTM = false;
   HasFloat128 = false;
   IsISA3_0 = false;
   UseLongCalls = false;
   SecurePlt = false;
   VectorsUseTwoUnits = false;
   UsePPCPreRASchedStrategy = false;
   UsePPCPostRASchedStrategy = false;
+  PredictableSelectIsExpensive = false;
 
   HasPOPCNTD = POPCNTD_Unavailable;
 }
 
 void PPCSubtarget::initSubtargetFeatures(StringRef CPU, StringRef FS) {
   // Determine default and user specified characteristics
   std::string CPUName = CPU;
   if (CPUName.empty() || CPU == "generic") {