Export of internal Abseil changes

--
751781aa5b9e998f84a8a7e00789c80d3338730e by Abseil Team <absl-team@google.com>:

Fix attributes.h compilation with -Wundef flag in C

PiperOrigin-RevId: 347394915

--
66070a8166b0e1a61236b954d07fbb378f4f990b by Abseil Team <absl-team@google.com>:

Revert the usage of variant<> in Cord iterator and reader.

The introduction of the variant may lead to some missed compiler optimizations.

PiperOrigin-RevId: 347384869
GitOrigin-RevId: 751781aa5b9e998f84a8a7e00789c80d3338730e
Change-Id: Ibf1190d498a6f968f2ea9b89467ccfb5224dafa8

absl/base/attributes.h

@@ -646,7 +646,7 @@
 // Every usage of a deprecated entity will trigger a warning when compiled with
 // Every usage of a deprecated entity will trigger a warning when compiled with
 // clang's `-Wdeprecated-declarations` option. This option is turned off by
 // clang's `-Wdeprecated-declarations` option. This option is turned off by
 // default, but the warnings will be reported by clang-tidy.
 // default, but the warnings will be reported by clang-tidy.
-#if defined(__clang__) && __cplusplus >= 201103L
+#if defined(__clang__) && defined(__cplusplus) && __cplusplus >= 201103L
 #define ABSL_DEPRECATED(message) __attribute__((deprecated(message)))
 #define ABSL_DEPRECATED(message) __attribute__((deprecated(message)))
 #endif
 #endif
 
 

absl/strings/BUILD.bazel

@@ -311,7 +311,6 @@ cc_library(
         "//absl/functional:function_ref",
         "//absl/functional:function_ref",
         "//absl/meta:type_traits",
         "//absl/meta:type_traits",
         "//absl/types:optional",
         "//absl/types:optional",
-        "//absl/types:variant",
     ],
     ],
 )
 )
 
 

absl/strings/CMakeLists.txt

@@ -571,7 +571,6 @@ absl_cc_library(
     absl::function_ref
     absl::function_ref
     absl::inlined_vector
     absl::inlined_vector
     absl::optional
     absl::optional
-    absl::variant
     absl::raw_logging_internal
     absl::raw_logging_internal
     absl::strings
     absl::strings
     absl::strings_internal
     absl::strings_internal

absl/strings/cord.cc

@@ -1299,8 +1299,7 @@ void Cord::CopyToArraySlowPath(char* dst) const {
 }
 }
 
 
 Cord::ChunkIterator& Cord::ChunkIterator::AdvanceStack() {
 Cord::ChunkIterator& Cord::ChunkIterator::AdvanceStack() {
-  assert(absl::holds_alternative<Stack>(context_));
-  auto& stack_of_right_children = absl::get<Stack>(context_);
+  auto& stack_of_right_children = stack_of_right_children_;
   if (stack_of_right_children.empty()) {
   if (stack_of_right_children.empty()) {
     assert(!current_chunk_.empty());  // Called on invalid iterator.
     assert(!current_chunk_.empty());  // Called on invalid iterator.
     // We have reached the end of the Cord.
     // We have reached the end of the Cord.
@@ -1357,8 +1356,7 @@ Cord Cord::ChunkIterator::AdvanceAndReadBytes(size_t n) {
     }
     }
     return subcord;
     return subcord;
   }
   }
-  assert(absl::holds_alternative<Stack>(context_));
-  auto& stack_of_right_children = absl::get<Stack>(context_);
+  auto& stack_of_right_children = stack_of_right_children_;
   if (n < current_chunk_.size()) {
   if (n < current_chunk_.size()) {
     // Range to read is a proper subrange of the current chunk.
     // Range to read is a proper subrange of the current chunk.
     assert(current_leaf_ != nullptr);
     assert(current_leaf_ != nullptr);
@@ -1461,7 +1459,7 @@ void Cord::ChunkIterator::AdvanceBytesSlowPath(size_t n) {
   n -= current_chunk_.size();
   n -= current_chunk_.size();
   bytes_remaining_ -= current_chunk_.size();
   bytes_remaining_ -= current_chunk_.size();
 
 
-  if (!absl::holds_alternative<Stack>(context_)) {
+  if (stack_of_right_children_.empty()) {
     // We have reached the end of the Cord.
     // We have reached the end of the Cord.
     assert(bytes_remaining_ == 0);
     assert(bytes_remaining_ == 0);
     return;
     return;
@@ -1470,8 +1468,7 @@ void Cord::ChunkIterator::AdvanceBytesSlowPath(size_t n) {
   // Process the next node(s) on the stack, skipping whole subtrees depending on
   // Process the next node(s) on the stack, skipping whole subtrees depending on
   // their length and how many bytes we are advancing.
   // their length and how many bytes we are advancing.
   CordRep* node = nullptr;
   CordRep* node = nullptr;
-  assert(absl::holds_alternative<Stack>(context_));
-  auto& stack_of_right_children = absl::get<Stack>(context_);
+  auto& stack_of_right_children = stack_of_right_children_;
   while (!stack_of_right_children.empty()) {
   while (!stack_of_right_children.empty()) {
     node = stack_of_right_children.back();
     node = stack_of_right_children.back();
     stack_of_right_children.pop_back();
     stack_of_right_children.pop_back();

absl/strings/cord.h

@@ -82,7 +82,6 @@
 #include "absl/strings/internal/string_constant.h"
 #include "absl/strings/internal/string_constant.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "absl/types/optional.h"
-#include "absl/types/variant.h"
 
 
 namespace absl {
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 ABSL_NAMESPACE_BEGIN
@@ -362,7 +361,11 @@ class Cord {
     friend class CharIterator;
     friend class CharIterator;
 
 
    private:
    private:
-    using Stack = absl::InlinedVector<absl::cord_internal::CordRep*, 4>;
+    // Stack of right children of concat nodes that we have to visit.
+    // Keep this at the end of the structure to avoid cache-thrashing.
+    // TODO(jgm): Benchmark to see if there's a more optimal value than 47 for
+    // the inlined vector size (47 exists for backward compatibility).
+    using Stack = absl::InlinedVector<absl::cord_internal::CordRep*, 47>;
 
 
     // Constructs a `begin()` iterator from `cord`.
     // Constructs a `begin()` iterator from `cord`.
     explicit ChunkIterator(const Cord* cord);
     explicit ChunkIterator(const Cord* cord);
@@ -389,10 +392,8 @@ class Cord {
     absl::cord_internal::CordRep* current_leaf_ = nullptr;
     absl::cord_internal::CordRep* current_leaf_ = nullptr;
     // The number of bytes left in the `Cord` over which we are iterating.
     // The number of bytes left in the `Cord` over which we are iterating.
     size_t bytes_remaining_ = 0;
     size_t bytes_remaining_ = 0;
-    // Context of this chunk iterator, can be one of:
-    // - monostate: iterator holds only one chunk or is empty.
-    // - Stack    : iterator holds a concat / substring tree
-    absl::variant<absl::monostate, Stack> context_;
+    // See 'Stack' alias definition.
+    Stack stack_of_right_children_;
   };
   };
 
 
   // Cord::ChunkIterator::chunk_begin()
   // Cord::ChunkIterator::chunk_begin()
@@ -1108,8 +1109,7 @@ inline Cord::ChunkIterator::ChunkIterator(const Cord* cord)
     : bytes_remaining_(cord->size()) {
     : bytes_remaining_(cord->size()) {
   if (cord->empty()) return;
   if (cord->empty()) return;
   if (cord->contents_.is_tree()) {
   if (cord->contents_.is_tree()) {
-    Stack& stack_of_right_children = context_.emplace<Stack>();
-    stack_of_right_children.push_back(cord->contents_.tree());
+    stack_of_right_children_.push_back(cord->contents_.tree());
     operator++();
     operator++();
   } else {
   } else {
     current_chunk_ = absl::string_view(cord->contents_.data(), cord->size());
     current_chunk_ = absl::string_view(cord->contents_.data(), cord->size());
@@ -1122,9 +1122,7 @@ inline Cord::ChunkIterator& Cord::ChunkIterator::operator++() {
   assert(bytes_remaining_ >= current_chunk_.size());
   assert(bytes_remaining_ >= current_chunk_.size());
   bytes_remaining_ -= current_chunk_.size();
   bytes_remaining_ -= current_chunk_.size();
   if (bytes_remaining_ > 0) {
   if (bytes_remaining_ > 0) {
-    if (absl::holds_alternative<Stack>(context_)) {
     return AdvanceStack();
     return AdvanceStack();
-    }
   } else {
   } else {
     current_chunk_ = {};
     current_chunk_ = {};
   }
   }