Centralize benchmarking infrastructure and the toolchain-wide benchmarks (#7212)

The benchmarks themselves aren't really specific to `driver`.

Keeping the source generation near to the primary use case of
benchmarking also seems like a more discoverable location.

I feel a little bad doing this reorganization right after I gave a talk
with links to a bunch of this code, but seems good to reorganize a bit
before doing some work to extend things now that we have full standard
library support for C++ benchmarking and other improvements.

Assisted-by: Antigravity with Gemini

toolchain/benchmarking/source_gen_main.cpp

@@ -0,0 +1,118 @@
+// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <optional>
+#include <system_error>
+
+#include "common/bazel_working_dir.h"
+#include "common/command_line.h"
+#include "common/init_llvm.h"
+#include "common/ostream.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/FileSystem.h"
+#include "toolchain/benchmarking/source_gen.h"
+
+namespace Carbon::Testing {
+namespace {
+
+constexpr CommandLine::CommandInfo Info = {
+    .name = "source_gen",
+    .help = R"""(
+A source generator for Carbon.
+)""",
+};
+
+constexpr CommandLine::ArgInfo OutputArgInfo = {
+    .name = "output",
+    .value_name = "FILE",
+    .help = R"""(
+Writes the generate source code to a file rather than stdout.
+)""",
+};
+
+constexpr CommandLine::ArgInfo LinesArgInfo = {
+    .name = "lines",
+    .value_name = "N",
+    .help = R"""(
+The number of lines of code to target for a generated source file.
+)""",
+};
+
+constexpr CommandLine::ArgInfo LanguageArgInfo = {
+    .name = "language",
+    //.value_name = "[carbon|cpp]",
+    .help = R"""(
+The language of source code to generate. The C++ source generation is best
+effort to try to provide as much comparable benchmarking as possible, but the
+primary language focus is generating Carbon.
+)""",
+};
+
+auto Run(llvm::ArrayRef<llvm::StringRef> args) -> bool {
+  // Default to outputting to stdout and writing 10k lines of source code.
+  llvm::StringRef output_filename = "-";
+  int lines = 10'000;
+  SourceGen::Language language;
+
+  auto parse_result = CommandLine::Parse(
+      args, llvm::outs(), Info, [&](CommandLine::CommandBuilder& b) {
+        b.AddStringOption(OutputArgInfo,
+                          [&](auto& arg_b) { arg_b.Set(&output_filename); });
+        b.AddIntegerOption(LinesArgInfo,
+                           [&](auto& arg_b) { arg_b.Set(&lines); });
+        b.AddOneOfOption(LanguageArgInfo, [&](auto& arg_b) {
+          arg_b.SetOneOf(
+              {
+                  arg_b.OneOfValue("carbon", SourceGen::Language::Carbon)
+                      .Default(true),
+                  arg_b.OneOfValue("cpp", SourceGen::Language::Cpp),
+              },
+              &language);
+        });
+
+        // No-op action as there is only one operation for this command.
+        b.Do([] {});
+      });
+  if (!parse_result.ok()) {
+    llvm::errs() << "error: " << *parse_result << "\n";
+    return false;
+  } else if (*parse_result == CommandLine::ParseResult::MetaSuccess) {
+    // Fully handled by the CLI library.
+    return true;
+  }
+
+  std::optional<llvm::raw_fd_ostream> output_file;
+  llvm::raw_fd_ostream* output = &llvm::outs();
+  if (output_filename != "-") {
+    std::error_code ec;
+    output_file.emplace(output_filename, ec, llvm::sys::fs::OF_None);
+    if (ec) {
+      llvm::errs() << "ERROR: Unable to open output file '" << output_filename
+                   << "': " << ec.message() << "\n";
+      return false;
+    }
+    output = &*output_file;
+  }
+
+  SourceGen gen(language);
+  *output << gen.GenApiFileDenseDecls(lines, SourceGen::DenseDeclParams{});
+  output->flush();
+  return true;
+}
+
+}  // namespace
+}  // namespace Carbon::Testing
+
+auto main(int argc, char** argv) -> int {
+  // Do LLVM's initialization first, this will also transform UTF-16 to UTF-8.
+  Carbon::InitLLVM init_llvm(argc, argv);
+
+  Carbon::SetWorkingDirForBazelRun();
+
+  llvm::SmallVector<llvm::StringRef> args(argv + 1, argv + argc);
+  bool success = Carbon::Testing::Run(args);
+  return success ? EXIT_SUCCESS : EXIT_FAILURE;
+}