Add more benchmarks for literal strings.

[sbenza]

Summary

Comparing against the empty string should generate much better code that
what it does today.
We can also generate better code when comparing against literals that
are larger than the SSO space.

[sbenza]

Fix benchmark for rhs being empty.

[sbenza]

• Make it easier for the compiler to optimize operator==(string,char*).

[sbenza]

Remove string file changes from this PR.
They were added by mistake.

[EricWF]

LGTM.

In future, you don't need review before adding or improving tests.

libcxx/benchmarks/string.bench.cpp

 };
 
 enum class DiffType { Control, ChangeFirst, ChangeMiddle, ChangeLast };
 struct AllDiffTypes : EnumValuesAsTuple<AllDiffTypes, DiffType, 4> {
   static constexpr const char* Names[] = {"Control", "ChangeFirst",
                                           "ChangeMiddle", "ChangeLast"};
 };
 
-static constexpr char kSmallStringLiteral[] = "012345678";
+static constexpr char SmallStringLiteral[] = "012345678";
 
 TEST_ALWAYS_INLINE const char* getSmallString(DiffType D) {
   switch (D) {
     case DiffType::Control:
-      return kSmallStringLiteral;
+      return SmallStringLiteral;
     case DiffType::ChangeFirst:
       return "-12345678";
     case DiffType::ChangeMiddle:
       return "0123-5678";
     case DiffType::ChangeLast:
       return "01234567-";
   }
 }
 
+static constexpr char LargeStringLiteral[] =
+    "012345678901234567890123456789012345678901234567890123456789012";
+
 TEST_ALWAYS_INLINE const char* getLargeString(DiffType D) {
 #define LARGE_STRING_FIRST "123456789012345678901234567890"
 #define LARGE_STRING_SECOND "234567890123456789012345678901"
   switch (D) {
     case DiffType::Control:
       return "0" LARGE_STRING_FIRST "1" LARGE_STRING_SECOND "2";
     case DiffType::ChangeFirst:
       return "-" LARGE_STRING_FIRST "1" LARGE_STRING_SECOND "2";
struct StringRelational {
   }
 
   static std::string name() {
     return "BM_StringRelational" + Rel::name() + LHLength::name() +
            RHLength::name() + DiffType::name();
   }
 };
 
-template <class Rel, class LHLength, class DiffType>
+template <class Rel, class LHLength, class RHLength, class DiffType>
 struct StringRelationalLiteral {
   static void run(benchmark::State& state) {
     auto Lhs = makeString(LHLength(), DiffType());
     for (auto _ : state) {
       benchmark::DoNotOptimize(Lhs);
+      constexpr const char* Literal = RHLength::value == Length::Empty
+                                          ? ""
+                                          : RHLength::value == Length::Small
+                                                ? SmallStringLiteral
+                                                : LargeStringLiteral;
       switch (Rel()) {
       case Relation::Eq:
-        benchmark::DoNotOptimize(Lhs == kSmallStringLiteral);
+        benchmark::DoNotOptimize(Lhs == Literal);
         break;
       case Relation::Less:
-        benchmark::DoNotOptimize(Lhs < kSmallStringLiteral);
+        benchmark::DoNotOptimize(Lhs < Literal);
         break;
       case Relation::Compare:
-        benchmark::DoNotOptimize(Lhs.compare(kSmallStringLiteral));
+        benchmark::DoNotOptimize(Lhs.compare(Literal));
         break;
       }
     }
   }
 
   static bool skip() {
     // Doesn't matter how they differ if they have different size.
-    if (LHLength() != Length::Small && DiffType() != ::DiffType::Control)
+    if (LHLength() != RHLength() && DiffType() != ::DiffType::Control)
       return true;
     // We don't need huge. Doensn't give anything different than Large.
-    if (LHLength() == Length::Huge)
+    if (LHLength() == Length::Huge || RHLength() == Length::Huge)
       return true;
     return false;
   }
 
   static std::string name() {
     return "BM_StringRelationalLiteral" + Rel::name() + LHLength::name() +
-           DiffType::name();
+           RHLength::name() + DiffType::name();
   }
 };
 
 enum class Depth { Shallow, Deep };
 struct AllDepths : EnumValuesAsTuple<AllDepths, Depth, 2> {
   static constexpr const char* Names[] = {"Shallow", "Deep"};
 };
 
const auto Verify = [&](std::string Exp, size_t Pos) {
       std::abort();
     };
     Verify(makeString(L, DiffType::ChangeFirst), 0);
     Verify(makeString(L, DiffType::ChangeMiddle), Control.size() / 2);
     Verify(makeString(L, DiffType::ChangeLast), Control.size() - 1);
   }
 }
 
+// Some small codegen thunks to easily see generated code.
+bool StringEqString(const std::string& a, const std::string& b) {
+  return a == b;
+}
+bool StringEqCStr(const std::string& a, const char* b) { return a == b; }
+bool CStrEqString(const char* a, const std::string& b) { return a == b; }
+bool StringEqCStrLiteralEmpty(const std::string& a) {
+  return a == "";
+}
+bool StringEqCStrLiteralSmall(const std::string& a) {
+  return a == SmallStringLiteral;
+}
+bool StringEqCStrLiteralLarge(const std::string& a) {
+  return a == LargeStringLiteral;
+}
+
 int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
 
   sanityCheckGeneratedStrings();
 
   makeCartesianProductBenchmark<StringConstructDestroyCStr, AllLengths,
                                 AllOpacity>();
   makeCartesianProductBenchmark<StringCopy, AllLengths>();
   makeCartesianProductBenchmark<StringMove, AllLengths>();
   makeCartesianProductBenchmark<StringDestroy, AllLengths>();
   makeCartesianProductBenchmark<StringRelational, AllRelations, AllLengths,
                                 AllLengths, AllDiffTypes>();
   makeCartesianProductBenchmark<StringRelationalLiteral, AllRelations,
-                                AllLengths, AllDiffTypes>();
+                                AllLengths, AllLengths, AllDiffTypes>();
   makeCartesianProductBenchmark<StringRead, AllTemperatures, AllDepths,
                                 AllLengths>();
   benchmark::RunSpecifiedBenchmarks();
+
+  if (argc < 0) {
+    // ODR-use the functions to force them being generated in the binary.
+    auto functions = std::make_tuple(
+        StringEqString, StringEqCStr, CStrEqString, StringEqCStrLiteralEmpty,
+        StringEqCStrLiteralSmall, StringEqCStrLiteralLarge);
+    printf("%p", &functions);
+  }
 }