[CostModel] Add -cost-kind=all costmodel output (#130490)

In order to make the different cost model kinds easier to test, and to
manage the complexity of all the different variants, this patch
introduces a -cost-kind=all option that will print the output of all
cost model kinds. It feel especially helpful for tests that already have
multiple run lines (with / without +fullfp16 for example).

It currently produces the output:
```
Cost Model: Found costs of RThru:1 CodeSize:1 Lat:3 SizeLat:1 for: %F16 = fadd half undef, undef
```

The output is collapsed into a single value if all costs are the same.
Invalid costs print "Invalid" via the normal InstructionCost printing.

Two test files are updated to show some examples with
-intrinsic-cost-strategy=type-based-intrinsic-cost and Invalid costs.
Once we have something we are happy with I will try to use this to
update more tests, as in b021bdb but
for more variants.

Author: davemgreen

llvm/lib/Analysis/CostModel.cpp

@@ -28,17 +28,25 @@
 
 using namespace llvm;
 
-static cl::opt<TargetTransformInfo::TargetCostKind> CostKind(
+enum class OutputCostKind {
+  RecipThroughput,
+  Latency,
+  CodeSize,
+  SizeAndLatency,
+  All,
+};
+
+static cl::opt<OutputCostKind> CostKind(
     "cost-kind", cl::desc("Target cost kind"),
-    cl::init(TargetTransformInfo::TCK_RecipThroughput),
-    cl::values(clEnumValN(TargetTransformInfo::TCK_RecipThroughput,
-                          "throughput", "Reciprocal throughput"),
-               clEnumValN(TargetTransformInfo::TCK_Latency,
-                          "latency", "Instruction latency"),
-               clEnumValN(TargetTransformInfo::TCK_CodeSize,
-                          "code-size", "Code size"),
-               clEnumValN(TargetTransformInfo::TCK_SizeAndLatency,
-                          "size-latency", "Code size and latency")));
+    cl::init(OutputCostKind::RecipThroughput),
+    cl::values(clEnumValN(OutputCostKind::RecipThroughput, "throughput",
+                          "Reciprocal throughput"),
+               clEnumValN(OutputCostKind::Latency, "latency",
+                          "Instruction latency"),
+               clEnumValN(OutputCostKind::CodeSize, "code-size", "Code size"),
+               clEnumValN(OutputCostKind::SizeAndLatency, "size-latency",
+                          "Code size and latency"),
+               clEnumValN(OutputCostKind::All, "all", "Print all cost kinds")));
 
 enum class IntrinsicCostStrategy {
   InstructionCost,
@@ -79,22 +87,53 @@ static InstructionCost getCost(Instruction &Inst, TTI::TargetCostKind CostKind,
   return TTI.getInstructionCost(&Inst, CostKind);
 }
 
+static TTI::TargetCostKind
+OutputCostKindToTargetCostKind(OutputCostKind CostKind) {
+  switch (CostKind) {
+  case OutputCostKind::RecipThroughput:
+    return TTI::TCK_RecipThroughput;
+  case OutputCostKind::Latency:
+    return TTI::TCK_Latency;
+  case OutputCostKind::CodeSize:
+    return TTI::TCK_CodeSize;
+  case OutputCostKind::SizeAndLatency:
+    return TTI::TCK_SizeAndLatency;
+  default:
+    llvm_unreachable("Unexpected OutputCostKind!");
+  };
+}
+
 PreservedAnalyses CostModelPrinterPass::run(Function &F,
                                             FunctionAnalysisManager &AM) {
   auto &TTI = AM.getResult<TargetIRAnalysis>(F);
   auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
   OS << "Printing analysis 'Cost Model Analysis' for function '" << F.getName() << "':\n";
   for (BasicBlock &B : F) {
     for (Instruction &Inst : B) {
-      // TODO: Use a pass parameter instead of cl::opt CostKind to determine
-      // which cost kind to print.
-      InstructionCost Cost = getCost(Inst, CostKind, TTI, TLI);
-      if (auto CostVal = Cost.getValue())
-        OS << "Cost Model: Found an estimated cost of " << *CostVal;
-      else
-        OS << "Cost Model: Invalid cost";
-
-      OS << " for instruction: " << Inst << "\n";
+      OS << "Cost Model: ";
+      if (CostKind == OutputCostKind::All) {
+        OS << "Found costs of ";
+        InstructionCost RThru =
+            getCost(Inst, TTI::TCK_RecipThroughput, TTI, TLI);
+        InstructionCost CodeSize = getCost(Inst, TTI::TCK_CodeSize, TTI, TLI);
+        InstructionCost Lat = getCost(Inst, TTI::TCK_Latency, TTI, TLI);
+        InstructionCost SizeLat =
+            getCost(Inst, TTI::TCK_SizeAndLatency, TTI, TLI);
+        if (RThru == CodeSize && RThru == Lat && RThru == SizeLat)
+          OS << RThru;
+        else
+          OS << "RThru:" << RThru << " CodeSize:" << CodeSize << " Lat:" << Lat
+             << " SizeLat:" << SizeLat;
+        OS << " for: " << Inst << "\n";
+      } else {
+        InstructionCost Cost =
+            getCost(Inst, OutputCostKindToTargetCostKind(CostKind), TTI, TLI);
+        if (auto CostVal = Cost.getValue())
+          OS << "Found an estimated cost of " << *CostVal;
+        else
+          OS << "Invalid cost";
+        OS << " for instruction: " << Inst << "\n";
+      }
     }
   }
   return PreservedAnalyses::all();