Export of internal Abseil changes.

--
f9f068aa8a260dc576398e47b8e4540902e41358 by Derek Mauro <dmauro@google.com>:

Fix test string with embedded NUL. Currently parses as octal.

PiperOrigin-RevId: 237088193

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

Make symbolizer examine any mapping with read+exec permission regardless of 'w' bit.

PiperOrigin-RevId: 237056461

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

Switch comments referencing base:: CondVar and Mutex to absl::.

PiperOrigin-RevId: 236917884

--
c624d5d1c0bdb917bff5e651ba40599472f84e0e by Gennadiy Rozental <rogeeff@google.com>:

Internal change

PiperOrigin-RevId: 236898300

--
3cdc82429af964846d1152f49148abc61d196a4b by Samuel Benzaquen <sbenza@google.com>:

Make the `long double` overload if AbslHashValue a template to avoid invalid
conversions with implicit operators.

This overload was never meant to capture anything other than `long double` and any current caller to it that wasn't a `long double` is potentially a bug.
In particular, any type with an implicit `bool` conversion is calling this
overload instead of trying to find a hash<> specialization, thus causing
pretty bad hash behavior.

PiperOrigin-RevId: 236877073
GitOrigin-RevId: f9f068aa8a260dc576398e47b8e4540902e41358
Change-Id: If9cc008dd814f0ca06ed881f612c06575f1f7137

absl/time/BUILD.bazel

@@ -110,6 +110,7 @@ cc_test(
         ":test_util",
         ":time",
         "//absl/base",
+        "//absl/base:core_headers",
         "//absl/hash",
         "@com_github_google_benchmark//:benchmark_main",
     ],

absl/time/civil_time.cc

@@ -38,7 +38,8 @@ std::string FormatYearAnd(string_view fmt, CivilSecond cs) {
                         cs.hour(), cs.minute(), cs.second());
   const TimeZone utc = UTCTimeZone();
   // TODO(absl-team): Avoid conversion of fmt std::string.
-  return StrCat(cs.year(), FormatTime(std::string(fmt), FromCivil(ncs, utc), utc));
+  return StrCat(cs.year(),
+                FormatTime(std::string(fmt), FromCivil(ncs, utc), utc));
 }
 
 }  // namespace
@@ -52,15 +53,9 @@ std::string FormatCivilTime(CivilMinute c) {
 std::string FormatCivilTime(CivilHour c) {
   return FormatYearAnd("-%m-%dT%H", c);
 }
-std::string FormatCivilTime(CivilDay c) {
-  return FormatYearAnd("-%m-%d", c);
-}
-std::string FormatCivilTime(CivilMonth c) {
-  return FormatYearAnd("-%m", c);
-}
-std::string FormatCivilTime(CivilYear c) {
-  return FormatYearAnd("", c);
-}
+std::string FormatCivilTime(CivilDay c) { return FormatYearAnd("-%m-%d", c); }
+std::string FormatCivilTime(CivilMonth c) { return FormatYearAnd("-%m", c); }
+std::string FormatCivilTime(CivilYear c) { return FormatYearAnd("", c); }
 
 namespace time_internal {
 

absl/time/civil_time.h

@@ -451,7 +451,7 @@ inline int GetYearDay(CivilDay cd) {
 // Example:
 //
 //   absl::CivilDay d = absl::CivilDay(1969, 7, 20);
-//   string day_string = absl::FormatCivilTime(d);          // "1969-07-20"
+//   std::string day_string = absl::FormatCivilTime(d);  // "1969-07-20"
 //
 std::string FormatCivilTime(CivilSecond c);
 std::string FormatCivilTime(CivilMinute c);

absl/time/duration.cc

@@ -751,7 +751,7 @@ void AppendNumberUnit(std::string* out, double n, DisplayUnit unit) {
 
 // From Go's doc at http://golang.org/pkg/time/#Duration.String
 //   [FormatDuration] returns a string representing the duration in the
-//   form "72h3m0.5s".  Leading zero units are omitted.  As a special
+//   form "72h3m0.5s". Leading zero units are omitted.  As a special
 //   case, durations less than one second format use a smaller unit
 //   (milli-, micro-, or nanoseconds) to ensure that the leading digit
 //   is non-zero.  The zero duration formats as 0, with no unit.
@@ -856,7 +856,7 @@ bool ConsumeDurationUnit(const char** start, Duration* unit) {
 }  // namespace
 
 // From Go's doc at http://golang.org/pkg/time/#ParseDuration
-//   [ParseDuration] parses a duration string.  A duration string is
+//   [ParseDuration] parses a duration string. A duration string is
 //   a possibly signed sequence of decimal numbers, each with optional
 //   fraction and a unit suffix, such as "300ms", "-1.5h" or "2h45m".
 //   Valid time units are "ns", "us" "ms", "s", "m", "h".

absl/time/duration_benchmark.cc

@@ -17,6 +17,7 @@
 #include <ctime>
 #include <string>
 
+#include "absl/base/attributes.h"
 #include "absl/time/time.h"
 #include "benchmark/benchmark.h"
 

absl/time/duration_test.cc

@@ -1771,7 +1771,7 @@ TEST(Duration, ParseDuration) {
 TEST(Duration, FormatParseRoundTrip) {
 #define TEST_PARSE_ROUNDTRIP(d)                \
   do {                                         \
-    std::string s = absl::FormatDuration(d);        \
+    std::string s = absl::FormatDuration(d);   \
     absl::Duration dur;                        \
     EXPECT_TRUE(absl::ParseDuration(s, &dur)); \
     EXPECT_EQ(d, dur);                         \

absl/time/format.cc

@@ -67,7 +67,8 @@ absl::Time Join(const cctz_parts& parts) {
 
 }  // namespace
 
-std::string FormatTime(const std::string& format, absl::Time t, absl::TimeZone tz) {
+std::string FormatTime(const std::string& format, absl::Time t,
+                       absl::TimeZone tz) {
   if (t == absl::InfiniteFuture()) return kInfiniteFutureStr;
   if (t == absl::InfinitePast()) return kInfinitePastStr;
   const auto parts = Split(t);
@@ -83,15 +84,15 @@ std::string FormatTime(absl::Time t) {
   return absl::FormatTime(RFC3339_full, t, absl::LocalTimeZone());
 }
 
-bool ParseTime(const std::string& format, const std::string& input, absl::Time* time,
-               std::string* err) {
+bool ParseTime(const std::string& format, const std::string& input,
+               absl::Time* time, std::string* err) {
   return absl::ParseTime(format, input, absl::UTCTimeZone(), time, err);
 }
 
 // If the input string does not contain an explicit UTC offset, interpret
 // the fields with respect to the given TimeZone.
-bool ParseTime(const std::string& format, const std::string& input, absl::TimeZone tz,
-               absl::Time* time, std::string* err) {
+bool ParseTime(const std::string& format, const std::string& input,
+               absl::TimeZone tz, absl::Time* time, std::string* err) {
   const char* data = input.c_str();
   while (std::isspace(*data)) ++data;
 

absl/time/format_test.cc

@@ -27,8 +27,8 @@ namespace {
 
 // A helper that tests the given format specifier by itself, and with leading
 // and trailing characters.  For example: TestFormatSpecifier(t, "%a", "Thu").
-void TestFormatSpecifier(absl::Time t, absl::TimeZone tz, const std::string& fmt,
-                         const std::string& ans) {
+void TestFormatSpecifier(absl::Time t, absl::TimeZone tz,
+                         const std::string& fmt, const std::string& ans) {
   EXPECT_EQ(ans, absl::FormatTime(fmt, t, tz));
   EXPECT_EQ("xxx " + ans, absl::FormatTime("xxx " + fmt, t, tz));
   EXPECT_EQ(ans + " yyy", absl::FormatTime(fmt + " yyy", t, tz));
@@ -375,7 +375,8 @@ TEST(FormatParse, RoundTrip) {
   // RFC3339, which renders subseconds.
   {
     absl::Time out;
-    const std::string s = absl::FormatTime(absl::RFC3339_full, in + subseconds, lax);
+    const std::string s =
+        absl::FormatTime(absl::RFC3339_full, in + subseconds, lax);
     EXPECT_TRUE(absl::ParseTime(absl::RFC3339_full, s, &out, &err))
         << s << ": " << err;
     EXPECT_EQ(in + subseconds, out);  // RFC3339_full includes %Ez

absl/time/time.h

@@ -77,7 +77,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/base/port.h"  // Needed for string vs std::string
 #include "absl/strings/string_view.h"
 #include "absl/time/civil_time.h"
 #include "absl/time/internal/cctz/include/cctz/time_zone.h"
@@ -1222,7 +1221,7 @@ extern const char RFC1123_no_wday[];  // %d %b %E4Y %H:%M:%S %z
 //
 //   absl::CivilSecond cs(2013, 1, 2, 3, 4, 5);
 //   absl::Time t = absl::FromCivil(cs, lax);
-//   string f = absl::FormatTime("%H:%M:%S", t, lax);  // "03:04:05"
+//   std::string f = absl::FormatTime("%H:%M:%S", t, lax);  // "03:04:05"
 //   f = absl::FormatTime("%H:%M:%E3S", t, lax);  // "03:04:05.000"
 //
 // Note: If the given `absl::Time` is `absl::InfiniteFuture()`, the returned