Reenable unit tests on hppa

3 files changed, 208 insertions, 0 deletions

diff --git a/debian/patches/hppa-symbolize.diff b/debian/patches/hppa-symbolize.diff
new file mode 100644
index 00000000..8c039df9
--- /dev/null
+++ b/debian/patches/hppa-symbolize.diff
@@ -0,0 +1,103 @@
+From: Benjamin Barenblat <bbaren@google.com>
+Subject: Support symbolization on PA-RISC
+Forwarded: yes
+Applied-Upstream: https://github.com/abseil/abseil-cpp/commit/7f850b3167fb38e6b4a9ce1824e6fabd733b5d62
+
+Null out supervisor bits in PA-RISC addresses before symbolizing, and
+handle function descriptor tables correctly.
+
+Change symbolize_test.cc to use 32-bit aligned addresses, allowing that
+test to pass on PA-RISC.
+
+The author works at Google. Upstream applied this patch as Piper
+revision 428590564 and exported it to GitHub; the Applied-Upstream URL
+above points to the exported commit.
+
+--- a/absl/debugging/symbolize_elf.inc
++++ b/absl/debugging/symbolize_elf.inc
+@@ -319,6 +319,7 @@
+                                            const ptrdiff_t relocation,
+                                            char *out, int out_size,
+                                            char *tmp_buf, int tmp_buf_size);
++  const char *GetUncachedSymbol(const void *pc);
+ 
+   enum {
+     SYMBOL_BUF_SIZE = 3072,
+@@ -1329,13 +1330,7 @@
+ // they are called here as well.
+ // To keep stack consumption low, we would like this function to not
+ // get inlined.
+-const char *Symbolizer::GetSymbol(const void *const pc) {
+-  const char *entry = FindSymbolInCache(pc);
+-  if (entry != nullptr) {
+-    return entry;
+-  }
+-  symbol_buf_[0] = '\0';
+-
++const char *Symbolizer::GetUncachedSymbol(const void *pc) {
+   ObjFile *const obj = FindObjFile(pc, 1);
+   ptrdiff_t relocation = 0;
+   int fd = -1;
+@@ -1423,6 +1418,42 @@
+   return InsertSymbolInCache(pc, symbol_buf_);
+ }
+ 
++const char *Symbolizer::GetSymbol(const void *pc) {
++  const char *entry = FindSymbolInCache(pc);
++  if (entry != nullptr) {
++    return entry;
++  }
++  symbol_buf_[0] = '\0';
++
++#ifdef __hppa__
++  {
++    // In some contexts (e.g., return addresses), PA-RISC uses the lowest two
++    // bits of the address to indicate the privilege level. Clear those bits
++    // before trying to symbolize.
++    const auto pc_bits = reinterpret_cast<uintptr_t>(pc);
++    const auto address = pc_bits & ~0x3;
++    entry = GetUncachedSymbol(reinterpret_cast<const void *>(address));
++    if (entry != nullptr) {
++      return entry;
++    }
++
++    // In some contexts, PA-RISC also uses bit 1 of the address to indicate that
++    // this is a cross-DSO function pointer. Such function pointers actually
++    // point to a procedure label, a struct whose first 32-bit (pointer) element
++    // actually points to the function text. With no symbol found for this
++    // address so far, try interpreting it as a cross-DSO function pointer and
++    // see how that goes.
++    if (pc_bits & 0x2) {
++      return GetUncachedSymbol(*reinterpret_cast<const void *const *>(address));
++    }
++
++    return nullptr;
++  }
++#else
++  return GetUncachedSymbol(pc);
++#endif
++}
++
+ bool RemoveAllSymbolDecorators(void) {
+   if (!g_decorators_mu.TryLock()) {
+     // Someone else is using decorators. Get out.
+--- a/absl/debugging/symbolize_test.cc
++++ b/absl/debugging/symbolize_test.cc
+@@ -378,12 +378,14 @@
+                 DummySymbolDecorator, &c_message),
+             0);
+ 
+-  char *address = reinterpret_cast<char *>(1);
+-  EXPECT_STREQ("abc", TrySymbolize(address++));
++  // Use addresses 4 and 8 here to ensure that we always use valid addresses
++  // even on systems that require instructions to be 32-bit aligned.
++  char *address = reinterpret_cast<char *>(4);
++  EXPECT_STREQ("abc", TrySymbolize(address));
+ 
+   EXPECT_TRUE(absl::debugging_internal::RemoveSymbolDecorator(ticket_b));
+ 
+-  EXPECT_STREQ("ac", TrySymbolize(address++));
++  EXPECT_STREQ("ac", TrySymbolize(address + 4));
+ 
+   // Cleanup: remove all remaining decorators so other stack traces don't
+   // get mystery "ac" decoration.
diff --git a/debian/patches/series b/debian/patches/series
index 6a2a842b..f4bed7f4 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -14,3 +14,5 @@ big-endian-random2.diff
 big-endian-random3.diff
 big-endian-random4.diff
 disable-nominalcpufrequency-test.diff
+hppa-symbolize.diff
+str-format-convert-test-printf.diff
diff --git a/debian/patches/str-format-convert-test-printf.diff b/debian/patches/str-format-convert-test-printf.diff
new file mode 100644
index 00000000..1808f2e1
--- /dev/null
+++ b/debian/patches/str-format-convert-test-printf.diff
@@ -0,0 +1,103 @@
+From: Benjamin Barenblat <bbaren@google.com>
+Subject: Check printf format strings in str_format_convert_test
+Forwarded: yes
+Applied-Upstream: https://github.com/abseil/abseil-cpp/commit/9fed77a6fea29b8c8468bd41c6259c7f67163a65
+
+Add ABSL_PRINTF_ATTRIBUTE to appropriate functions in
+strings/internal/str_format/convert_test. Correct
+TypedFormatConvertTest.Char, which was accidentally passing values of
+types larger than int to StrPrint.
+
+The author works at Google. Upstream applied this patch as Piper
+revision 439388148 and exported it to GitHub; the Applied-Upstream URL
+above points to the exported commit.
+
+--- a/absl/strings/BUILD.bazel
++++ b/absl/strings/BUILD.bazel
+@@ -787,6 +787,7 @@
+     deps = [
+         ":str_format_internal",
+         ":strings",
++        "//absl/base:core_headers",
+         "//absl/base:raw_logging_internal",
+         "//absl/types:optional",
+         "@com_google_googletest//:gtest_main",
+--- a/absl/strings/CMakeLists.txt
++++ b/absl/strings/CMakeLists.txt
+@@ -492,6 +492,7 @@
+   DEPS
+     absl::strings
+     absl::str_format_internal
++    absl::core_headers
+     absl::raw_logging_internal
+     absl::int128
+     gmock_main
+--- a/absl/strings/internal/str_format/convert_test.cc
++++ b/absl/strings/internal/str_format/convert_test.cc
+@@ -24,6 +24,7 @@
+ 
+ #include "gmock/gmock.h"
+ #include "gtest/gtest.h"
++#include "absl/base/attributes.h"
+ #include "absl/base/internal/raw_logging.h"
+ #include "absl/strings/internal/str_format/bind.h"
+ #include "absl/strings/match.h"
+@@ -124,6 +125,7 @@
+   delete[] buf;
+ }
+ 
++void StrAppend(std::string *, const char *, ...) ABSL_PRINTF_ATTRIBUTE(2, 3);
+ void StrAppend(std::string *out, const char *format, ...) {
+   va_list ap;
+   va_start(ap, format);
+@@ -131,6 +133,7 @@
+   va_end(ap);
+ }
+ 
++std::string StrPrint(const char *, ...) ABSL_PRINTF_ATTRIBUTE(1, 2);
+ std::string StrPrint(const char *format, ...) {
+   va_list ap;
+   va_start(ap, format);
+@@ -452,21 +455,32 @@
+ }
+ 
+ TYPED_TEST_P(TypedFormatConvertTest, Char) {
++  // Pass a bunch of values of type TypeParam to both FormatPack and libc's
++  // vsnprintf("%c", ...) (wrapped in StrPrint) to make sure we get the same
++  // value.
+   typedef TypeParam T;
+   using remove_volatile_t = typename std::remove_volatile<T>::type;
+-  static const T kMin = std::numeric_limits<remove_volatile_t>::min();
+-  static const T kMax = std::numeric_limits<remove_volatile_t>::max();
+-  T kVals[] = {
+-    remove_volatile_t(1), remove_volatile_t(2), remove_volatile_t(10),
+-    remove_volatile_t(-1), remove_volatile_t(-2), remove_volatile_t(-10),
+-    remove_volatile_t(0),
+-    kMin + remove_volatile_t(1), kMin,
+-    kMax - remove_volatile_t(1), kMax
++  std::vector<remove_volatile_t> vals = {
++      remove_volatile_t(1),  remove_volatile_t(2),  remove_volatile_t(10),   //
++      remove_volatile_t(-1), remove_volatile_t(-2), remove_volatile_t(-10),  //
++      remove_volatile_t(0),
+   };
+-  for (const T &c : kVals) {
++
++  // We'd like to test values near std::numeric_limits::min() and
++  // std::numeric_limits::max(), too, but vsnprintf("%c", ...) can't handle
++  // anything larger than an int. Add in the most extreme values we can without
++  // exceeding that range.
++  static const T kMin =
++      static_cast<remove_volatile_t>(std::numeric_limits<int>::min());
++  static const T kMax =
++      static_cast<remove_volatile_t>(std::numeric_limits<int>::max());
++  vals.insert(vals.end(), {kMin + 1, kMin, kMax - 1, kMax});
++
++  for (const T c : vals) {
+     const FormatArgImpl args[] = {FormatArgImpl(c)};
+     UntypedFormatSpecImpl format("%c");
+-    EXPECT_EQ(StrPrint("%c", c), FormatPack(format, absl::MakeSpan(args)));
++    EXPECT_EQ(StrPrint("%c", static_cast<int>(c)),
++              FormatPack(format, absl::MakeSpan(args)));
+   }
+ }
+