grpc 1.75.0.pre1 → 1.76.0.pre1

data/src/core/tsi/ssl_transport_security.cc

@@ -53,7 +53,6 @@
 #include <optional>
 #include <string>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/match.h"
 #include "absl/strings/numbers.h"
@@ -71,6 +70,7 @@
 #include "src/core/tsi/transport_security_interface.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/env.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/match.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/useful.h"
@@ -324,7 +324,7 @@ static void init_openssl(void) {
 #if OPENSSL_VERSION_NUMBER < 0x10100000
   if (!CRYPTO_get_locking_callback()) {
     int num_locks = CRYPTO_num_locks();
-    CHECK_GT(num_locks, 0);
+    GRPC_CHECK_GT(num_locks, 0);
     g_openssl_mutexes = static_cast<gpr_mu*>(
         gpr_malloc(static_cast<size_t>(num_locks) * sizeof(gpr_mu)));
     for (int i = 0; i < num_locks; i++) {
@@ -338,19 +338,19 @@ static void init_openssl(void) {
 #endif
   g_ssl_ctx_ex_factory_index =
       SSL_CTX_get_ex_new_index(0, nullptr, nullptr, nullptr, nullptr);
-  CHECK_NE(g_ssl_ctx_ex_factory_index, -1);
+  GRPC_CHECK_NE(g_ssl_ctx_ex_factory_index, -1);
 
   g_ssl_ctx_ex_crl_provider_index =
       SSL_CTX_get_ex_new_index(0, nullptr, nullptr, nullptr, nullptr);
-  CHECK_NE(g_ssl_ctx_ex_crl_provider_index, -1);
+  GRPC_CHECK_NE(g_ssl_ctx_ex_crl_provider_index, -1);
 
   g_ssl_ctx_ex_spiffe_bundle_map_index =
       SSL_CTX_get_ex_new_index(0, nullptr, nullptr, nullptr, nullptr);
-  CHECK_NE(g_ssl_ctx_ex_spiffe_bundle_map_index, -1);
+  GRPC_CHECK_NE(g_ssl_ctx_ex_spiffe_bundle_map_index, -1);
 
   g_ssl_ex_verified_root_cert_index = SSL_get_ex_new_index(
       0, nullptr, nullptr, nullptr, verified_root_cert_free);
-  CHECK_NE(g_ssl_ex_verified_root_cert_index, -1);
+  GRPC_CHECK_NE(g_ssl_ex_verified_root_cert_index, -1);
 }
 
 // --- Ssl utils. ---
@@ -608,7 +608,7 @@ static tsi_result peer_from_x509(X509* cert, int include_certificate_type,
           : 0;
   size_t property_count;
   tsi_result result;
-  CHECK_GE(subject_alt_name_count, 0);
+  GRPC_CHECK_GE(subject_alt_name_count, 0);
   property_count = (include_certificate_type ? size_t{1} : 0) +
                    3 /* subject, common name, certificate */ +
                    static_cast<size_t>(subject_alt_name_count);
@@ -663,7 +663,7 @@ static tsi_result peer_from_x509(X509* cert, int include_certificate_type,
   }
   if (result != TSI_OK) tsi_peer_destruct(peer);
 
-  CHECK((int)peer->property_count == current_insert_index);
+  GRPC_CHECK((int)peer->property_count == current_insert_index);
   return result;
 }
 
@@ -674,7 +674,7 @@ static tsi_result ssl_ctx_use_certificate_chain(SSL_CTX* context,
   tsi_result result = TSI_OK;
   X509* certificate = nullptr;
   BIO* pem;
-  CHECK_LE(pem_cert_chain_size, static_cast<size_t>(INT_MAX));
+  GRPC_CHECK_LE(pem_cert_chain_size, static_cast<size_t>(INT_MAX));
   pem = BIO_new_mem_buf(pem_cert_chain, static_cast<int>(pem_cert_chain_size));
   if (pem == nullptr) return TSI_OUT_OF_RESOURCES;
 
@@ -794,7 +794,7 @@ static tsi_result ssl_ctx_use_pem_private_key(SSL_CTX* context,
   tsi_result result = TSI_OK;
   EVP_PKEY* private_key = nullptr;
   BIO* pem;
-  CHECK_LE(pem_key_size, static_cast<size_t>(INT_MAX));
+  GRPC_CHECK_LE(pem_key_size, static_cast<size_t>(INT_MAX));
   pem = BIO_new_mem_buf(pem_key, static_cast<int>(pem_key_size));
   if (pem == nullptr) return TSI_OUT_OF_RESOURCES;
   do {
@@ -839,7 +839,7 @@ static tsi_result x509_store_load_certs(X509_STORE* cert_store,
   X509* root = nullptr;
   X509_NAME* root_name = nullptr;
   BIO* pem;
-  CHECK_LE(pem_roots_size, static_cast<size_t>(INT_MAX));
+  GRPC_CHECK_LE(pem_roots_size, static_cast<size_t>(INT_MAX));
   pem = BIO_new_mem_buf(pem_roots, static_cast<int>(pem_roots_size));
   if (cert_store == nullptr) return TSI_INVALID_ARGUMENT;
   if (pem == nullptr) return TSI_OUT_OF_RESOURCES;
@@ -1240,7 +1240,7 @@ static int CheckChainRevocation(
 }
 
 static grpc_core::SpiffeBundleMap* GetSpiffeBundleMap(X509_STORE_CTX* ctx) {
-  CHECK(ctx != nullptr);
+  GRPC_CHECK(ctx != nullptr);
   ERR_clear_error();
   int ssl_index = SSL_get_ex_data_X509_STORE_CTX_idx();
   if (ssl_index < 0) {
@@ -1264,7 +1264,7 @@ static grpc_core::SpiffeBundleMap* GetSpiffeBundleMap(X509_STORE_CTX* ctx) {
 }
 
 static absl::StatusOr<std::string> GetSpiffeUriFromCert(X509* cert) {
-  CHECK(cert != nullptr);
+  GRPC_CHECK(cert != nullptr);
   GENERAL_NAMES* subject_alt_names = static_cast<GENERAL_NAMES*>(
       X509_get_ext_d2i(cert, NID_subject_alt_name, nullptr, nullptr));
   int uri_count = 0;
@@ -1301,7 +1301,7 @@ static absl::StatusOr<std::string> GetSpiffeUriFromCert(X509* cert) {
 }
 
 static absl::StatusOr<std::string> SpiffeTrustDomainFromCert(X509* cert) {
-  CHECK(cert != nullptr);
+  GRPC_CHECK(cert != nullptr);
   auto subject_name = GetSpiffeUriFromCert(cert);
   GRPC_RETURN_IF_ERROR(subject_name.status());
   auto spiffe_id = grpc_core::SpiffeId::FromString(*subject_name);
@@ -1315,7 +1315,7 @@ static absl::StatusOr<std::string> SpiffeTrustDomainFromCert(X509* cert) {
 // https://github.com/grpc/proposal/blob/master/A87-mtls-spiffe-support.md
 absl::Status ConfigureSpiffeRoots(
     X509_STORE_CTX* ctx, grpc_core::SpiffeBundleMap* spiffe_bundle_map) {
-  CHECK(ctx != nullptr);
+  GRPC_CHECK(ctx != nullptr);
   if (spiffe_bundle_map == nullptr) {
     return absl::InvalidArgumentError(
         "cannot configure spiffe roots with a nullptr spiffe_bundle_map.");
@@ -1338,7 +1338,8 @@ absl::Status ConfigureSpiffeRoots(
     return absl::InvalidArgumentError(
         "spiffe: root stack in the SPIFFE Bundle Map is nullptr.");
   }
-#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+// the boringSSL library objective-C used did not have this function defined
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(OPENSSL_APPLE)
   X509_STORE_CTX_set0_trusted_stack(ctx, *root_stack);
 #else
   X509_STORE_CTX_trusted_stack(ctx, *root_stack);
@@ -1353,7 +1354,7 @@ absl::Status ConfigureSpiffeRoots(
 // returns 1 on success, indicating a trusted chain to a root of trust was
 // found, 0 if a trusted chain could not be built.
 static int CustomVerificationFunction(X509_STORE_CTX* ctx, void* arg) {
-  CHECK(ctx != nullptr);
+  GRPC_CHECK(ctx != nullptr);
   grpc_core::SpiffeBundleMap* spiffe_bundle_map = GetSpiffeBundleMap(ctx);
   if (spiffe_bundle_map != nullptr) {
     // If a SPIFFE Bundle Map is configured, we'll use
@@ -1597,7 +1598,7 @@ static tsi_ssl_handshaker_factory_vtable handshaker_factory_vtable = {nullptr};
 // allocating memory for the factory.
 static void tsi_ssl_handshaker_factory_init(
     tsi_ssl_handshaker_factory* factory) {
-  CHECK_NE(factory, nullptr);
+  GRPC_CHECK_NE(factory, nullptr);
 
   factory->vtable = &handshaker_factory_vtable;
   gpr_ref_init(&factory->refcount, 1);
@@ -1824,7 +1825,7 @@ static tsi_result ssl_handshaker_get_bytes_to_send_to_peer(
     if (error != nullptr) *error = "invalid argument";
     return TSI_INVALID_ARGUMENT;
   }
-  CHECK_LE(*bytes_size, static_cast<size_t>(INT_MAX));
+  GRPC_CHECK_LE(*bytes_size, static_cast<size_t>(INT_MAX));
   bytes_read_from_ssl =
       BIO_read(impl->network_io, bytes, static_cast<int>(*bytes_size));
   if (bytes_read_from_ssl < 0) {
@@ -1902,7 +1903,7 @@ static tsi_result ssl_handshaker_process_bytes_from_peer(
     if (error != nullptr) *error = "invalid argument";
     return TSI_INVALID_ARGUMENT;
   }
-  CHECK_LE(*bytes_size, static_cast<size_t>(INT_MAX));
+  GRPC_CHECK_LE(*bytes_size, static_cast<size_t>(INT_MAX));
   bytes_written_into_ssl_size =
       BIO_write(impl->network_io, bytes, static_cast<int>(*bytes_size));
   if (bytes_written_into_ssl_size < 0) {
@@ -2401,7 +2402,7 @@ static int server_handshaker_factory_npn_advertised_callback(
   tsi_ssl_server_handshaker_factory* factory =
       static_cast<tsi_ssl_server_handshaker_factory*>(arg);
   *out = factory->alpn_protocol_list;
-  CHECK(factory->alpn_protocol_list_length <= UINT_MAX);
+  GRPC_CHECK(factory->alpn_protocol_list_length <= UINT_MAX);
   *outlen = static_cast<unsigned int>(factory->alpn_protocol_list_length);
   return SSL_TLSEXT_ERR_OK;
 }
@@ -2436,7 +2437,7 @@ static int server_handshaker_factory_new_session_callback(
 template <typename T>
 static void ssl_keylogging_callback(const SSL* ssl, const char* info) {
   SSL_CTX* ssl_context = SSL_get_SSL_CTX(ssl);
-  CHECK_NE(ssl_context, nullptr);
+  GRPC_CHECK_NE(ssl_context, nullptr);
   void* arg = SSL_CTX_get_ex_data(ssl_context, g_ssl_ctx_ex_factory_index);
   T* factory = static_cast<T*>(arg);
   factory->key_logger->LogSessionKeys(ssl_context, info);
@@ -2587,7 +2588,7 @@ tsi_result tsi_create_ssl_client_handshaker_factory_with_options(
         break;
       }
 #if TSI_OPENSSL_ALPN_SUPPORT
-      CHECK(impl->alpn_protocol_list_length < UINT_MAX);
+      GRPC_CHECK(impl->alpn_protocol_list_length < UINT_MAX);
       if (SSL_CTX_set_alpn_protos(
               ssl_context, impl->alpn_protocol_list,
               static_cast<unsigned int>(impl->alpn_protocol_list_length))) {
@@ -2944,8 +2945,8 @@ bool IsRootCertInfoEmpty(const RootCertInfo* root_cert_info) {
 const tsi_ssl_handshaker_factory_vtable* tsi_ssl_handshaker_factory_swap_vtable(
     tsi_ssl_handshaker_factory* factory,
     tsi_ssl_handshaker_factory_vtable* new_vtable) {
-  CHECK_NE(factory, nullptr);
-  CHECK_NE(factory->vtable, nullptr);
+  GRPC_CHECK_NE(factory, nullptr);
+  GRPC_CHECK_NE(factory->vtable, nullptr);
 
   const tsi_ssl_handshaker_factory_vtable* orig_vtable = factory->vtable;
   factory->vtable = new_vtable;

data/src/core/tsi/ssl_transport_security_utils.cc

@@ -30,11 +30,11 @@
 #include <openssl/x509.h>
 #include <openssl/x509v3.h>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "src/core/tsi/transport_security_interface.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -74,7 +74,7 @@ void LogSslErrorStack(void) {
 
 tsi_result DoSslWrite(SSL* ssl, unsigned char* unprotected_bytes,
                       size_t unprotected_bytes_size) {
-  CHECK_LE(unprotected_bytes_size, static_cast<size_t>(INT_MAX));
+  GRPC_CHECK_LE(unprotected_bytes_size, static_cast<size_t>(INT_MAX));
   ERR_clear_error();
   int ssl_write_result = SSL_write(ssl, unprotected_bytes,
                                    static_cast<int>(unprotected_bytes_size));
@@ -95,7 +95,7 @@ tsi_result DoSslWrite(SSL* ssl, unsigned char* unprotected_bytes,
 
 tsi_result DoSslRead(SSL* ssl, unsigned char* unprotected_bytes,
                      size_t* unprotected_bytes_size) {
-  CHECK_LE(*unprotected_bytes_size, static_cast<size_t>(INT_MAX));
+  GRPC_CHECK_LE(*unprotected_bytes_size, static_cast<size_t>(INT_MAX));
   ERR_clear_error();
   int read_from_ssl = SSL_read(ssl, unprotected_bytes,
                                static_cast<int>(*unprotected_bytes_size));
@@ -139,7 +139,7 @@ tsi_result SslProtectorProtect(const unsigned char* unprotected_bytes,
   int pending_in_ssl = static_cast<int>(BIO_pending(network_io));
   if (pending_in_ssl > 0) {
     *unprotected_bytes_size = 0;
-    CHECK_LE(*protected_output_frames_size, static_cast<size_t>(INT_MAX));
+    GRPC_CHECK_LE(*protected_output_frames_size, static_cast<size_t>(INT_MAX));
     read_from_ssl = BIO_read(network_io, protected_output_frames,
                              static_cast<int>(*protected_output_frames_size));
     if (read_from_ssl < 0) {
@@ -165,7 +165,7 @@ tsi_result SslProtectorProtect(const unsigned char* unprotected_bytes,
   result = DoSslWrite(ssl, buffer, buffer_size);
   if (result != TSI_OK) return result;
 
-  CHECK_LE(*protected_output_frames_size, static_cast<size_t>(INT_MAX));
+  GRPC_CHECK_LE(*protected_output_frames_size, static_cast<size_t>(INT_MAX));
   read_from_ssl = BIO_read(network_io, protected_output_frames,
                            static_cast<int>(*protected_output_frames_size));
   if (read_from_ssl < 0) {
@@ -195,11 +195,11 @@ tsi_result SslProtectorProtectFlush(size_t& buffer_offset,
   }
 
   pending = static_cast<int>(BIO_pending(network_io));
-  CHECK_GE(pending, 0);
+  GRPC_CHECK_GE(pending, 0);
   *still_pending_size = static_cast<size_t>(pending);
   if (*still_pending_size == 0) return TSI_OK;
 
-  CHECK_LE(*protected_output_frames_size, static_cast<size_t>(INT_MAX));
+  GRPC_CHECK_LE(*protected_output_frames_size, static_cast<size_t>(INT_MAX));
   read_from_ssl = BIO_read(network_io, protected_output_frames,
                            static_cast<int>(*protected_output_frames_size));
   if (read_from_ssl <= 0) {
@@ -208,7 +208,7 @@ tsi_result SslProtectorProtectFlush(size_t& buffer_offset,
   }
   *protected_output_frames_size = static_cast<size_t>(read_from_ssl);
   pending = static_cast<int>(BIO_pending(network_io));
-  CHECK_GE(pending, 0);
+  GRPC_CHECK_GE(pending, 0);
   *still_pending_size = static_cast<size_t>(pending);
   return TSI_OK;
 }
@@ -236,7 +236,7 @@ tsi_result SslProtectorUnprotect(const unsigned char* protected_frames_bytes,
   *unprotected_bytes_size = output_bytes_size - output_bytes_offset;
 
   // Then, try to write some data to ssl.
-  CHECK_LE(*protected_frames_bytes_size, static_cast<size_t>(INT_MAX));
+  GRPC_CHECK_LE(*protected_frames_bytes_size, static_cast<size_t>(INT_MAX));
   written_into_ssl = BIO_write(network_io, protected_frames_bytes,
                                static_cast<int>(*protected_frames_bytes_size));
   if (written_into_ssl < 0) {

data/src/core/util/chunked_vector.h

@@ -21,8 +21,8 @@
 #include <iterator>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "src/core/lib/resource_quota/arena.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/manual_constructor.h"
 
 namespace grpc_core {
@@ -86,9 +86,9 @@ class ChunkedVector {
 
   // Remove the last element and return it.
   T PopBack() {
-    CHECK_NE(append_, nullptr);
+    GRPC_CHECK_NE(append_, nullptr);
     if (append_->count == 0) {
-      CHECK(first_ != append_);
+      GRPC_CHECK(first_ != append_);
       Chunk* chunk = first_;
       while (chunk->next != append_) {
         chunk = chunk->next;
@@ -234,7 +234,7 @@ class ChunkedVector {
  private:
   ManualConstructor<T>* AppendSlot() {
     if (append_ == nullptr) {
-      CHECK_EQ(first_, nullptr);
+      GRPC_CHECK_EQ(first_, nullptr);
       first_ = arena_->New<Chunk>();
       append_ = first_;
     } else if (append_->count == kChunkSize) {

data/src/core/util/event_log.cc

@@ -19,16 +19,16 @@
 #include <algorithm>
 #include <atomic>
 
-#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
 std::atomic<EventLog*> EventLog::g_instance_{nullptr};
 
 EventLog::~EventLog() {
-  CHECK(g_instance_.load(std::memory_order_acquire) != this);
+  GRPC_CHECK_NE(g_instance_.load(std::memory_order_acquire), this);
 }
 
 void EventLog::BeginCollection() {

data/src/core/util/gcp_metadata_query.cc

@@ -27,7 +27,6 @@
 #include <memory>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -35,6 +34,7 @@
 #include "absl/strings/string_view.h"
 #include "src/core/credentials/transport/transport_credentials.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/time.h"
@@ -71,7 +71,7 @@ GcpMetadataQuery::GcpMetadataQuery(
   auto uri =
       URI::Create("http", /*user_info=*/"", std::move(metadata_server_name),
                   attribute_, {} /* query params */, "" /* fragment */);
-  CHECK(uri.ok());  // params are hardcoded
+  GRPC_CHECK(uri.ok());  // params are hardcoded
   grpc_http_request request;
   memset(&request, 0, sizeof(grpc_http_request));
   grpc_http_header header = {const_cast<char*>("Metadata-Flavor"),

data/src/core/util/grpc_check.cc

@@ -0,0 +1,22 @@
+// Copyright 2025 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifdef GRPC_POSTMORTEM_CHECKS
+#include "src/core/util/postmortem_emit.h"
+
+bool PostMortemEmitAndReturnTrue() {
+  grpc_core::PostMortemEmit();
+  return true;
+}
+#endif

data/src/core/util/grpc_check.h

@@ -0,0 +1,103 @@
+// Copyright 2025 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_UTIL_GRPC_CHECK_H
+#define GRPC_SRC_CORE_UTIL_GRPC_CHECK_H
+
+#ifdef GRPC_POSTMORTEM_CHECKS
+#include <limits.h>
+
+#include "absl/log/log.h"
+#include "src/core/util/postmortem_emit.h"
+
+bool PostMortemEmitAndReturnTrue();
+
+#define GRPC_CHECK(a)                           \
+  while (!(a) && PostMortemEmitAndReturnTrue()) \
+  LOG(FATAL) << "Failed GRPC_CHECK(" #a "). "
+
+#define GRPC_CHECK_EQ(a, b)                              \
+  while (!((a) == (b)) && PostMortemEmitAndReturnTrue()) \
+  LOG(FATAL) << "Failed GRPC_CHECK_EQ(" #a ", " #b "). "
+
+#define GRPC_CHECK_NE(a, b)                           \
+  while ((a) == (b) && PostMortemEmitAndReturnTrue()) \
+  LOG(FATAL) << "Failed GRPC_CHECK_NE(" #a ", " #b "). "
+
+#define GRPC_CHECK_GT(a, b)                           \
+  while ((a) <= (b) && PostMortemEmitAndReturnTrue()) \
+  LOG(FATAL) << "Failed GRPC_CHECK_GT(" #a ", " #b "). "
+
+#define GRPC_CHECK_LT(a, b)                           \
+  while ((a) >= (b) && PostMortemEmitAndReturnTrue()) \
+  LOG(FATAL) << "Failed GRPC_CHECK_LT(" #a ",  " #b "). "
+
+#define GRPC_CHECK_GE(a, b)                          \
+  while ((a) < (b) && PostMortemEmitAndReturnTrue()) \
+  LOG(FATAL) << "Failed GRPC_CHECK_GE(" #a ", " #b "). "
+
+#define GRPC_CHECK_LE(a, b)                          \
+  while ((a) > (b) && PostMortemEmitAndReturnTrue()) \
+  LOG(FATAL) << "Failed GRPC_CHECK_LE(" #a " vs " #b ")."
+
+#define GRPC_CHECK_OK(a)                             \
+  while (!(a).ok() && PostMortemEmitAndReturnTrue()) \
+  LOG(FATAL) << "Failed GRPC_CHECK_OK(" #a "). "
+
+#ifndef NDEBUG
+#define GRPC_DCHECK(a) GRPC_CHECK(a)
+#define GRPC_DCHECK_EQ(a, b) GRPC_CHECK_EQ(a, b)
+#define GRPC_DCHECK_GE(a, b) GRPC_CHECK_GE(a, b)
+#define GRPC_DCHECK_LE(a, b) GRPC_CHECK_LE(a, b)
+#define GRPC_DCHECK_GT(a, b) GRPC_CHECK_GT(a, b)
+#define GRPC_DCHECK_LT(a, b) GRPC_CHECK_LT(a, b)
+#define GRPC_DCHECK_NE(a, b) GRPC_CHECK_NE(a, b)
+#else  // NDEBUG
+#define GRPC_DCHECK(a) \
+  while (false) LOG(INFO)
+#define GRPC_DCHECK_EQ(a, b) \
+  while (false) LOG(INFO)
+#define GRPC_DCHECK_GE(a, b) \
+  while (false) LOG(INFO)
+#define GRPC_DCHECK_LE(a, b) \
+  while (false) LOG(INFO)
+#define GRPC_DCHECK_GT(a, b) \
+  while (false) LOG(INFO)
+#define GRPC_DCHECK_LT(a, b) \
+  while (false) LOG(INFO)
+#define GRPC_DCHECK_NE(a, b) \
+  while (false) LOG(INFO)
+#endif
+
+#else  // GRPC_POSTMORTEM_CHECKS
+#include "absl/log/check.h"
+
+#define GRPC_CHECK(a) CHECK(a)
+#define GRPC_CHECK_EQ(a, b) CHECK_EQ(a, b)
+#define GRPC_CHECK_NE(a, b) CHECK_NE(a, b)
+#define GRPC_CHECK_GT(a, b) CHECK_GT(a, b)
+#define GRPC_CHECK_LT(a, b) CHECK_LT(a, b)
+#define GRPC_CHECK_GE(a, b) CHECK_GE(a, b)
+#define GRPC_CHECK_LE(a, b) CHECK_LE(a, b)
+#define GRPC_CHECK_OK(a) CHECK_OK(a)
+#define GRPC_DCHECK(a) DCHECK(a)
+#define GRPC_DCHECK_EQ(a, b) DCHECK_EQ(a, b)
+#define GRPC_DCHECK_GE(a, b) DCHECK_GE(a, b)
+#define GRPC_DCHECK_LE(a, b) DCHECK_LE(a, b)
+#define GRPC_DCHECK_GT(a, b) DCHECK_GT(a, b)
+#define GRPC_DCHECK_LT(a, b) DCHECK_LT(a, b)
+#define GRPC_DCHECK_NE(a, b) DCHECK_NE(a, b)
+#endif  // GRPC_POSTMORTEM_CHECKS
+
+#endif  // GRPC_SRC_CORE_UTIL_GRPC_CHECK_H

data/src/core/util/http_client/httpcli.cc

@@ -28,7 +28,6 @@
 #include <utility>
 
 #include "absl/functional/bind_front.h"
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 #include "src/core/config/core_configuration.h"
@@ -49,6 +48,7 @@
 #include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/error_utils.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/http_client/format_request.h"
 #include "src/core/util/http_client/parser.h"
 #include "src/core/util/status_helper.h"
@@ -201,7 +201,7 @@ HttpRequest::HttpRequest(
                     ContinueDoneWriteAfterScheduleOnExecCtx, this,
                     grpc_schedule_on_exec_ctx);
   if (!grpc_event_engine::experimental::UsePollsetAlternative()) {
-    CHECK(pollent);
+    GRPC_CHECK(pollent);
     grpc_polling_entity_add_to_pollset_set(pollent, pollset_set_);
   }
 }
@@ -259,7 +259,7 @@ void HttpRequest::Start() {
 void HttpRequest::Orphan() {
   {
     MutexLock lock(&mu_);
-    CHECK(!cancelled_);
+    GRPC_CHECK(!cancelled_);
     cancelled_ = true;
     // cancel potentially pending DNS resolution.
     if (use_event_engine_dns_resolver_) {

data/src/core/util/http_client/parser.cc

@@ -24,9 +24,9 @@
 
 #include <algorithm>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
+#include "src/core/util/grpc_check.h"
 
 static char* buf2str(void* buffer, size_t length) {
   char* out = static_cast<char*>(gpr_malloc(length + 1));
@@ -175,7 +175,7 @@ static grpc_error_handle add_header(grpc_http_parser* parser) {
   grpc_http_header hdr = {nullptr, nullptr};
   grpc_error_handle error;
 
-  CHECK(cur != end);
+  GRPC_CHECK(cur != end);
 
   if (*cur == ' ' || *cur == '\t') {
     error = GRPC_ERROR_CREATE("Continued header lines not supported yet");
@@ -189,14 +189,14 @@ static grpc_error_handle add_header(grpc_http_parser* parser) {
     error = GRPC_ERROR_CREATE("Didn't find ':' in header string");
     goto done;
   }
-  CHECK(cur >= beg);
+  GRPC_CHECK(cur >= beg);
   hdr.key = buf2str(beg, static_cast<size_t>(cur - beg));
   cur++;  // skip :
 
   while (cur != end && (*cur == ' ' || *cur == '\t')) {
     cur++;
   }
-  CHECK((size_t)(end - cur) >= parser->cur_line_end_length);
+  GRPC_CHECK((size_t)(end - cur) >= parser->cur_line_end_length);
   size = static_cast<size_t>(end - cur) - parser->cur_line_end_length;
   if ((size != 0) && (cur[size - 1] == '\r')) {
     size--;

data/src/core/util/latent_see.h

@@ -229,11 +229,11 @@ class Flow {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Flow() : id_(0) {}
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit Flow(const Metadata* metadata) {
     Appender appender;
+    metadata_ = metadata;
     if (GPR_LIKELY(!appender.Enabled())) {
       id_ = 0;
       return;
     }
-    metadata_ = metadata;
     AppendBegin(appender);
   }
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~Flow() {
@@ -248,11 +248,11 @@ class Flow {
   Flow(Flow&& other) noexcept
       : metadata_(other.metadata_), id_(std::exchange(other.id_, 0)) {}
   Flow& operator=(Flow&& other) noexcept {
+    metadata_ = other.metadata_;
     if (id_ != 0) {
       Appender appender;
       if (GPR_LIKELY(!appender.Enabled())) AppendEnd(appender);
     }
-    metadata_ = other.metadata_;
     id_ = std::exchange(other.id_, 0);
     return *this;
   }
@@ -273,7 +273,10 @@ class Flow {
     metadata_ = metadata;
     AppendBegin(appender);
   }
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION void Begin() { Begin(metadata_); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION void Begin() {
+    DCHECK(metadata_ != nullptr);
+    Begin(metadata_);
+  }
 
  private:
   void AppendBegin(Appender& appender) {
@@ -285,7 +288,7 @@ class Flow {
     appender.Append(metadata_, -id_, -absl::GetCurrentTimeNanos());
     id_ = 0;
   }
-  const Metadata* metadata_;
+  const Metadata* metadata_ = nullptr;
   static inline std::atomic<int64_t> next_id_{1};
   int64_t id_;
 };

data/src/core/util/lru_cache.h

@@ -24,7 +24,7 @@
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -35,7 +35,7 @@ template <typename Key, typename Value>
 class LruCache {
  public:
   explicit LruCache(size_t max_size) : max_size_(max_size) {
-    CHECK_GT(max_size, 0UL);
+    GRPC_CHECK_GT(max_size, 0UL);
   }
 
   // Returns the value for key, or nullopt if not present.
@@ -110,9 +110,9 @@ void LruCache<Key, Value>::SetMaxSize(size_t max_size) {
 template <typename Key, typename Value>
 void LruCache<Key, Value>::RemoveOldestEntry() {
   auto lru_it = lru_list_.begin();
-  CHECK(lru_it != lru_list_.end());
+  GRPC_CHECK(lru_it != lru_list_.end());
   auto cache_it = cache_.find(*lru_it);
-  CHECK(cache_it != cache_.end());
+  GRPC_CHECK(cache_it != cache_.end());
   cache_.erase(cache_it);
   lru_list_.pop_front();
 }