summaryrefslogtreecommitdiff
path: root/debian/patches
diff options
context:
space:
mode:
Diffstat (limited to 'debian/patches')
-rw-r--r--debian/patches/hppa-symbolize.diff103
-rw-r--r--debian/patches/series2
-rw-r--r--debian/patches/str-format-convert-test-printf.diff103
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)));
+ }
+ }
+