nullability/pointer_nullability_analysis_benchmark.cc

// Part of the Crubit 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 "absl/base/nullability.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "benchmark/benchmark.h"
#include "nullability/pointer_nullability_diagnosis.h"
#include "nullability/pragma.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclBase.h"
#include "clang/Basic/LLVM.h"
#include "clang/Testing/CommandLineArgs.h"
#include "clang/Testing/TestAST.h"
#include "llvm/Support/ErrorHandling.h"

namespace clang::tidy::nullability {
namespace {

NamedDecl *absl_nonnull lookup(absl::string_view Name, const DeclContext &DC) {
  auto Result = DC.lookup(&DC.getParentASTContext().Idents.get(Name));
  if (!Result.isSingleResult())
    llvm::reportFatalInternalError(Twine("lookup failed for ") + Name);
  return Result.front();
}

void benchmarkAnalysisOnCode(benchmark::State& State, llvm::StringRef Code) {
  clang::TestInputs Inputs(Code);
  Inputs.Language = TestLanguage::Lang_CXX20;
  Inputs.ExtraArgs = {
      "-fsyntax-only",
      "-Wno-unused-value",
      "-Wno-nonnull",
  };
  TestAST AST(Inputs);
  auto* Target = cast<FunctionDecl>(
      lookup("Target", *AST.context().getTranslationUnitDecl()));
  NullabilityPragmas NoPragmas;
  LambdaCaptureNullabilityMap CaptureMap;

  for (auto _ : State)
    (void)diagnosePointerNullability(Target, NoPragmas, CaptureMap);
}

void BM_PointerAnalysisCopyPointer(benchmark::State &State) {
  benchmarkAnalysisOnCode(State, R"cpp(
    int *Target(int *p) {
      int *q = p;
      return q;
    }
  )cpp");
}
BENCHMARK(BM_PointerAnalysisCopyPointer);

void BM_PointerAnalysisIntLoop(benchmark::State &State) {
  benchmarkAnalysisOnCode(State, R"cpp(
    int Target(int *p) {
      for (int i = 0; i < 10; ++i) *p += i;
      return *p;
    }
  )cpp");
}
BENCHMARK(BM_PointerAnalysisIntLoop);

void BM_PointerAnalysisPointerLoop(benchmark::State &State) {
  benchmarkAnalysisOnCode(State, R"cpp(
    int *_Nullable next();
    void Target(int i) {
      for (int *p = next(); p != nullptr; p = next()) *p += i;
    }
  )cpp");
}
BENCHMARK(BM_PointerAnalysisPointerLoop);

void BM_PointerAnalysisBranch(benchmark::State &State) {
  benchmarkAnalysisOnCode(State, R"cpp(
    int Target(int *p, bool b) {
      int i = 0;
      if (b)
        i = *p;
      else
        p = nullptr;
      return *p;
    }
  )cpp");
}
BENCHMARK(BM_PointerAnalysisBranch);

void BM_PointerAnalysisLoopAndBranch(benchmark::State &State) {
  benchmarkAnalysisOnCode(State, R"cpp(
    int *_Nullable next();
    bool cond();
    void Target(int *p, bool b) {
      int x = 0;
      for (int *p = next(); p != nullptr; p = next()) {
        if (cond())
          x = *p;  // arbitrary code with `*p`.
        else
          *p = x;  // different code with `*p`.
      }
    }
  )cpp");
}
BENCHMARK(BM_PointerAnalysisLoopAndBranch);

void BM_PointerAnalysisTwoLoops(benchmark::State &State) {
  benchmarkAnalysisOnCode(State, R"cpp(
    int Target(int *p, bool b) {
      int x = 0;
      for (int i = 0; i < 10; ++i) {
        x += *p;
      }
      x = 7;
      for (int i = 0; i < 10; ++i) {
        x += *p;
      }
      return *p;
    }
  )cpp");
}
BENCHMARK(BM_PointerAnalysisTwoLoops);

constexpr inline char preamble[] = R"cpp(
  namespace std {
  using size_t = unsigned;

  template <typename T>
  class vector {
   public:
    using iterator = T*;
    size_t size() const;
    iterator begin();
    iterator end();
  };

  class string_view {
   public:
    bool empty();
    char front();
    char* data();
    size_t size() const;
    void remove_prefix(size_t);
  };

  class string {
   public:
    struct iterator {
      char& operator*();
      iterator& operator++();
      iterator operator++(int);
      iterator& operator+=(unsigned);
      friend size_t operator-(const iterator&, const iterator&);
      friend bool operator!=(const iterator&, const iterator&);
    };
    void resize(size_t);
    void erase(size_t);
    iterator begin();
    iterator end();
  };
  }  // namespace std
)cpp";

// This benchmark is a simplified version of a function that joins two file-path
// strings.
void BM_PointerAnalysisJoinFilePath(benchmark::State &State) {
  absl::string_view code = R"cpp(
    std::string Target(std::vector<std::string_view> paths) {
      std::string result;

      if (paths.size() == 0) return result;

      std::size_t total_size = paths.size() - 1;
      for (const std::string_view path : paths) {
        total_size += path.size();
      }
      result.resize(total_size);

      auto begin = result.begin();
      auto out = begin;
      for (std::string_view path : paths) {
        if (path.empty()) continue;
        if (path.front() != '/' && out != begin) {
          *out++ = '/';
        }
        const std::size_t this_size = path.size();
        out += this_size;
      }
      result.erase(out - begin);

      return result;
    }
  )cpp";
  benchmarkAnalysisOnCode(State, absl::StrCat(preamble, code));
}
BENCHMARK(BM_PointerAnalysisJoinFilePath);

// In practice, the call to `memcpy` inside the loop demonstrated a substantial
// impact on microbenchmark performance. It is unclear why, and probably worth
// further reducing this benchmark. For now, it seems interesting enough to
// include in the suite.
void BM_PointerAnalysisCallInLoop(benchmark::State &State) {
  absl::string_view code = R"cpp(
    void* memcpy(void* dest, const void* src, std::size_t count);

    void Target(char* out, std::vector<std::string_view> paths) {
      if (paths.size() != 0) {
        std::size_t total_size = paths.size() - 1;
        for (const std::string_view path : paths) {
          total_size += path.size();
        }
        for (std::string_view path : paths) {
          if (path.empty()) continue;
          const std::size_t this_size = path.size();
          memcpy(out, path.data(), this_size);
          out += this_size;
        }
      }
    }
  )cpp";
  benchmarkAnalysisOnCode(State, absl::StrCat(preamble, code));
}
BENCHMARK(BM_PointerAnalysisCallInLoop);

// Benchmark with lots of short-circuiting conditions and early returns.
// Most of the conditions are irrelevant to the pointers in the function:
// - pointers: `elt_ty`, `target`, the struct field `type`, the return value
//   of `lookup()` and `insert()`.
// - conditions: `elt_ty->isInteger()`, `elt_ty->isBoolean()`, etc.
void BM_PointerAnalysisShortCircuitingAndEarlyReturnsOnIrrelevantConditions(
    benchmark::State& State) {
  benchmarkAnalysisOnCode(State, R"cpp(
    struct Type {
      bool isInteger() const;
      bool isBoolean() const;
      bool isSigned() const;
      bool isFloat() const;
      bool isSpecial() const;
    };

    struct TargetInfo {
      bool hasFeatureA() const;
      bool hasFeatureB() const;
    };

    struct Key {
      const Type* type;
      unsigned num_elements;
      unsigned num_fields;
    };

    int* lookup(const Key& k);
    int* insert(const Key& k, int val);
    unsigned getTypeSize(const Type* t);

    int* Target(const Type* elt_ty, unsigned num_elts, unsigned num_fields,
                const TargetInfo* target) {
      Key k{elt_ty, num_elts, num_fields};
      if (int* cached = lookup(k)) return cached;

      if (target->hasFeatureA()) {
        unsigned size = getTypeSize(elt_ty);

#define CASE_A(ELS, BITS, NF, SIGNED, VAL)            \
      if (elt_ty->isInteger() && !elt_ty->isBoolean() &&  \
          elt_ty->isSigned() == SIGNED && size == BITS && \
          num_elts == (ELS * NF) && num_fields == NF) {   \
        return insert(k, VAL);                            \
      }
        CASE_A(16, 8, 1, true, 1)
        CASE_A(8, 16, 1, true, 2)
        CASE_A(4, 32, 1, true, 3)
        CASE_A(2, 64, 1, true, 4)
        CASE_A(16, 8, 1, false, 5)
        CASE_A(8, 16, 1, false, 6)
        CASE_A(4, 32, 1, false, 7)
        CASE_A(2, 64, 1, false, 8)
        CASE_A(16, 8, 2, true, 9)
        CASE_A(8, 16, 2, true, 10)
        CASE_A(4, 32, 2, true, 11)
        CASE_A(2, 64, 2, true, 12)
        CASE_A(16, 8, 2, false, 13)
        CASE_A(8, 16, 2, false, 14)
        CASE_A(4, 32, 2, false, 15)
        CASE_A(2, 64, 2, false, 16)
#undef CASE_A
      } else if (target->hasFeatureB()) {
        unsigned size = getTypeSize(elt_ty);

#define CASE_B(ELS, BITS, NF, SIGNED, VAL)                      \
      if (!elt_ty->isBoolean() &&                                   \
          ((elt_ty->isInteger() && elt_ty->isSigned() == SIGNED) || \
           (elt_ty->isFloat() && !elt_ty->isSpecial())) &&          \
          size == BITS && num_elts == ELS && num_fields == NF) {    \
        return insert(k, VAL);                                      \
      }
        CASE_B(1, 8, 1, true, 101)
        CASE_B(2, 8, 1, true, 102)
        CASE_B(4, 8, 1, true, 103)
        CASE_B(8, 8, 1, true, 104)
        CASE_B(16, 8, 1, true, 105)
        CASE_B(32, 8, 1, true, 106)
        CASE_B(64, 8, 1, true, 107)
        CASE_B(1, 8, 1, false, 108)
        CASE_B(2, 8, 1, false, 109)
        CASE_B(4, 8, 1, false, 110)
        CASE_B(8, 8, 1, false, 111)
        CASE_B(16, 8, 1, false, 112)
        CASE_B(32, 8, 1, false, 113)
        CASE_B(64, 8, 1, false, 114)
#undef CASE_B
      }
      return nullptr;
    }
  )cpp");
}
BENCHMARK(
    BM_PointerAnalysisShortCircuitingAndEarlyReturnsOnIrrelevantConditions);

// Benchmark with batch member pointer initialization in a factory function
// (could be a constructor too).
void BM_PointerAnalysisBatchMemberPointerInit(benchmark::State& State) {
  benchmarkAnalysisOnCode(State, R"cpp(
    struct Metric {
      void increment();
      void add(long long v);
    };

    struct Context {
      Metric* getMetric(const char* name);
    };

    struct PipelineService {
      Metric* m1_;
      Metric* m2_;
      Metric* m3_;
      Metric* m4_;
      Metric* m5_;
      Metric* m6_;
      Metric* m7_;
      Metric* m8_;
      Metric* m9_;
      Metric* m10_;
      Metric* m11_;
      Metric* m12_;
      Metric* m13_;
      Metric* m14_;
      Metric* m15_;
      Metric* m16_;
      Metric* m17_;
      Metric* m18_;
      Metric* m19_;
      Metric* m20_;
      Metric* m21_;
      Metric* m22_;
      Metric* m23_;
      Metric* m24_;
      Metric* m25_;
      Metric* m26_;
      Metric* m27_;
      Metric* m28_;
      Metric* m29_;
      Metric* m30_;
      Metric* m31_;
      Metric* m32_;
      Metric* m33_;
      Metric* m34_;
      Metric* m35_;
      Metric* m36_;
      Metric* m37_;
      Metric* m38_;
      Metric* m39_;
      Metric* m40_;
      Metric* m41_;
      Metric* m42_;
      Metric* m43_;
      Metric* m44_;
      Metric* m45_;
      Metric* m46_;
      Metric* m47_;
      Metric* m48_;
      Metric* m49_;
      Metric* m50_;
    };

    void Target(PipelineService* _Nullable self, Context* _Nullable ctx) {
      if (!self || !ctx) return;
      self->m1_ = ctx->getMetric("m1");
      self->m2_ = ctx->getMetric("m2");
      self->m3_ = ctx->getMetric("m3");
      self->m4_ = ctx->getMetric("m4");
      self->m5_ = ctx->getMetric("m5");
      self->m6_ = ctx->getMetric("m6");
      self->m7_ = ctx->getMetric("m7");
      self->m8_ = ctx->getMetric("m8");
      self->m9_ = ctx->getMetric("m9");
      self->m10_ = ctx->getMetric("m10");
      self->m11_ = ctx->getMetric("m11");
      self->m12_ = ctx->getMetric("m12");
      self->m13_ = ctx->getMetric("m13");
      self->m14_ = ctx->getMetric("m14");
      self->m15_ = ctx->getMetric("m15");
      self->m16_ = ctx->getMetric("m16");
      self->m17_ = ctx->getMetric("m17");
      self->m18_ = ctx->getMetric("m18");
      self->m19_ = ctx->getMetric("m19");
      self->m20_ = ctx->getMetric("m20");
      self->m21_ = ctx->getMetric("m21");
      self->m22_ = ctx->getMetric("m22");
      self->m23_ = ctx->getMetric("m23");
      self->m24_ = ctx->getMetric("m24");
      self->m25_ = ctx->getMetric("m25");
      self->m26_ = ctx->getMetric("m26");
      self->m27_ = ctx->getMetric("m27");
      self->m28_ = ctx->getMetric("m28");
      self->m29_ = ctx->getMetric("m29");
      self->m30_ = ctx->getMetric("m30");
      self->m31_ = ctx->getMetric("m31");
      self->m32_ = ctx->getMetric("m32");
      self->m33_ = ctx->getMetric("m33");
      self->m34_ = ctx->getMetric("m34");
      self->m35_ = ctx->getMetric("m35");
      self->m36_ = ctx->getMetric("m36");
      self->m37_ = ctx->getMetric("m37");
      self->m38_ = ctx->getMetric("m38");
      self->m39_ = ctx->getMetric("m39");
      self->m40_ = ctx->getMetric("m40");
      self->m41_ = ctx->getMetric("m41");
      self->m42_ = ctx->getMetric("m42");
      self->m43_ = ctx->getMetric("m43");
      self->m44_ = ctx->getMetric("m44");
      self->m45_ = ctx->getMetric("m45");
      self->m46_ = ctx->getMetric("m46");
      self->m47_ = ctx->getMetric("m47");
      self->m48_ = ctx->getMetric("m48");
      self->m49_ = ctx->getMetric("m49");
      self->m50_ = ctx->getMetric("m50");
    }
  )cpp");
}
BENCHMARK(BM_PointerAnalysisBatchMemberPointerInit);

// Benchmark with a large static array initializer.
void BM_PointerAnalysisLargeStaticArrayInitializer(benchmark::State& State) {
  benchmarkAnalysisOnCode(State, R"cpp(
    struct Span {
      const unsigned char* data;
      unsigned size;
    };

    Span Target() {
      static const unsigned char kDataArray[] = {
          0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
          0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
          0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
          0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
          0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
          0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41,
          0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c,
          0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
          0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62,
          0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d,
          0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
          0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83,
          0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e,
          0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
          0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
          0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
          0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba,
          0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5,
          0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0,
          0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb,
          0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6,
          0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1,
          0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc,
          0xfd, 0xfe, 0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
          0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12,
          0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
          0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
          0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33,
          0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e,
          0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
          0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
          0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
          0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
          0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
          0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80,
          0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b,
          0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
          0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1,
          0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac,
          0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
          0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2,
          0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd,
          0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8,
          0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3,
          0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee,
          0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
          0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0x00, 0x01, 0x02, 0x03, 0x04,
          0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
          0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
          0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
          0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
          0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
          0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
          0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
          0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c,
          0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
          0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72,
          0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d,
          0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88,
          0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93,
          0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
          0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
          0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4,
          0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
          0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca,
          0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5,
          0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0,
          0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb,
          0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6,
          0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff};
      return Span{kDataArray, sizeof(kDataArray)};
    }
  )cpp");
}
BENCHMARK(BM_PointerAnalysisLargeStaticArrayInitializer);

}  // namespace
}  // namespace clang::tidy::nullability

int main(int argc, char **absl_nonnull argv) {
  benchmark::Initialize(&argc, argv);
  benchmark::RunSpecifiedBenchmarks();
  return 0;
}