diff --git a/.gitignore b/.gitignore index e6e4e89..eac4938 100644 --- a/.gitignore +++ b/.gitignore @@ -6,3 +6,4 @@ /gcc-10.0.1-20200126.tar.xz /gcc-10.0.1-20200130.tar.xz /gcc-10.0.1-20200216.tar.xz +/gcc-10.0.1-20200311.tar.xz diff --git a/gcc.spec b/gcc.spec index ef4de19..aa0b27f 100644 --- a/gcc.spec +++ b/gcc.spec @@ -1,10 +1,10 @@ -%global DATE 20200216 -%global gitrev e192529cb03e8c4fb50bff9ce451d0f9e12b863f +%global DATE 20200311 +%global gitrev 61bcda69ca5dc9e9d5e25de7b914dd3a86089244 %global gcc_version 10.0.1 %global gcc_major 10 # Note, gcc_release must be integer, if you want to add suffixes to # %%{release}, append them after %%{gcc_release} on Release: line. -%global gcc_release 0.8 +%global gcc_release 0.9 %global nvptx_tools_gitrev 5f6f343a302d620b0868edab376c00b15741e39e %global newlib_cygwin_gitrev 50e2a63b04bdd018484605fbb954fd1bd5147fa0 %global _unpackaged_files_terminate_build 0 @@ -264,6 +264,8 @@ Patch8: gcc10-foffload-default.patch Patch9: gcc10-Wno-format-security.patch Patch10: gcc10-rh1574936.patch Patch11: gcc10-d-shared-libphobos.patch +Patch12: gcc10-pr94015.patch +Patch13: gcc10-pr94130.patch # On ARM EABI systems, we do want -gnueabi to be part of the # target triple. @@ -775,6 +777,8 @@ to NVidia PTX capable devices if available. %patch10 -p0 -b .rh1574936~ %endif %patch11 -p0 -b .d-shared-libphobos~ +%patch12 -p0 -b .pr94015~ +%patch13 -p0 -b .pr94130~ echo 'Red Hat %{version}-%{gcc_release}' > gcc/DEV-PHASE @@ -3003,6 +3007,66 @@ end %endif %changelog +* Wed Mar 11 2020 Jakub Jelinek 10.0.1-0.9 +- update from trunk + - PRs ada/91100, analyzer/93032, analyzer/93388, analyzer/93692, + analyzer/93774, analyzer/93775, analyzer/93777, analyzer/93778, + analyzer/93779, analyzer/93899, analyzer/93947, analyzer/93950, + analyzer/93959, analyzer/93993, analyzer/94028, bootstrap/93962, + c++/52320, c++/66139, c++/90432, c++/90467, c++/90505, c++/90938, + c++/91465, c++/92031, c++/92721, c++/93169, c++/93676, c++/93712, + c++/93729, c++/93789, c++/93801, c++/93803, c++/93804, c++/93817, + c++/93862, c++/93869, c++/93870, c++/93882, c++/93901, c++/93905, + c++/93907, c++/93922, c++/93933, c++/93956, c++/93958, c++/93998, + c++/94027, c++/94041, c++/94068, c++/94074, c++/94117, c++/94124, + c/86134, c/93577, c/93812, c/93858, c/93886, c/93887, c/93949, + debug/93888, driver/47785, driver/93796, fortran/92785, fortran/92959, + fortran/92976, fortran/93486, fortran/93552, fortran/93580, + fortran/93581, fortran/93599, fortran/93601, fortran/93603, + fortran/93604, fortran/93714, fortran/93792, fortran/93825, + fortran/93835, fortran/93889, fortran/93890, gcov-profile/93753, + inline-asm/94095, ipa/92518, ipa/92548, ipa/92924, ipa/93583, + ipa/93707, ipa/93760, ipa/93797, libstdc++/92546, libstdc++/93244, + libstdc++/93818, libstdc++/93872, libstdc++/93884, libstdc++/93936, + libstdc++/93972, libstdc++/93978, libstdc++/94013, libstdc++/94017, + libstdc++/94051, libstdc++/94063, libstdc++/94069, lto/78353, + middle-end/81401, middle-end/92152, middle-end/93399, + middle-end/93829, middle-end/93843, middle-end/93874, + middle-end/93926, middle-end/93961, middle-end/94111, other/55930, + other/93756, other/93912, other/93965, rtl-optimization/93564, + rtl-optimization/93996, rtl-optimization/94002, + rtl-optimization/94045, rtl-optimization/PR92989, sanitizer/93731, + target/26877, target/87560, target/87612, target/89229, target/89346, + target/90311, target/90763, target/91276, target/91598, target/93047, + target/93658, target/93709, target/93743, target/93800, target/93828, + target/93860, target/93913, target/93932, target/93937, target/93995, + target/93997, target/94046, target/94065, target/94088, target/94121, + target/94134, testsuite/91797, testsuite/91799, testsuite/94019, + testsuite/94023, translation/93755, translation/93759, + translation/93830, translation/93831, translation/93838, + translation/93841, translation/93864, tree-optimization/90883, + tree-optimization/91890, tree-optimization/92128, + tree-optimization/92982, tree-optimization/93508, + tree-optimization/93586, tree-optimization/93667, + tree-optimization/93767, tree-optimization/93776, + tree-optimization/93780, tree-optimization/93820, + tree-optimization/93845, tree-optimization/93868, + tree-optimization/93927, tree-optimization/93945, + tree-optimization/93946, tree-optimization/93953, + tree-optimization/93964, tree-optimization/93986, + tree-optimization/94001, tree-optimization/94114 + - fix ICE on rotate with -Wconversion (#1810941, PR c++/94067) + - fix -fcf-protection -flto -g interaction (#1808484, PR lto/93966) + - fix git miscompilation on s390x with -O2 -march=zEC12 -mtune=z13 + (#1799408, PR rtl-optimization/93908) + - fix ICE in in propagate_vals_across_arith_jfunc (#1806466, PR ipa/93763) + - ARM ABI alignment fix for classes derived from user aligned empty + bases (PR c++/94050) +- strlen pass fixes (PR tree-optimization/94015) +- fix {memset,memcpy,memmove,strncpy} head trimming if the result is used + (PR tree-optimization/94130) +- drop python2-devel Requires + * Sun Feb 16 2020 Jakub Jelinek 10.0.1-0.8 - update from trunk - PRs analyzer/93212, analyzer/93288, analyzer/93350, analyzer/93356, diff --git a/gcc10-pr94015.patch b/gcc10-pr94015.patch new file mode 100644 index 0000000..822db72 --- /dev/null +++ b/gcc10-pr94015.patch @@ -0,0 +1,414 @@ +2020-03-03 Jakub Jelinek + + PR tree-optimization/94015 + * tree-ssa-strlen.c (count_nonzero_bytes): Split portions of the + function where EXP is address of the bytes being stored rather than + the bytes themselves into count_nonzero_bytes_addr. Punt on zero + sized MEM_REF. Use VAR_P macro and handle CONST_DECL like VAR_DECLs. + Use ctor_for_folding instead of looking at DECL_INITIAL. Punt before + calling native_encode_expr if host or target doesn't have 8-bit + chars. Formatting fixes. + (count_nonzero_bytes_addr): New function. + + * gcc.dg/pr94015.c: New test. + +--- gcc/tree-ssa-strlen.c.jj 2020-03-03 07:57:22.324124042 +0100 ++++ gcc/tree-ssa-strlen.c 2020-03-03 18:37:29.382722923 +0100 +@@ -4585,6 +4585,11 @@ int ssa_name_limit_t::next_ssa_name (tre + return 0; + } + ++static bool ++count_nonzero_bytes_addr (tree, unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, ++ unsigned [3], bool *, bool *, bool *, ++ const vr_values *, ssa_name_limit_t &); ++ + /* Determines the minimum and maximum number of leading non-zero bytes + in the representation of EXP and set LENRANGE[0] and LENRANGE[1] + to each. +@@ -4607,102 +4612,6 @@ count_nonzero_bytes (tree exp, unsigned + bool *allnul, bool *allnonnul, const vr_values *rvals, + ssa_name_limit_t &snlim) + { +- int idx = get_stridx (exp); +- if (idx > 0) +- { +- strinfo *si = get_strinfo (idx); +- if (!si) +- return false; +- +- /* Handle both constant lengths as well non-constant lengths +- in some range. */ +- unsigned HOST_WIDE_INT minlen, maxlen; +- if (tree_fits_shwi_p (si->nonzero_chars)) +- minlen = maxlen = tree_to_shwi (si->nonzero_chars); +- else if (nbytes +- && si->nonzero_chars +- && TREE_CODE (si->nonzero_chars) == SSA_NAME) +- { +- const value_range_equiv *vr +- = CONST_CAST (class vr_values *, rvals) +- ->get_value_range (si->nonzero_chars); +- if (vr->kind () != VR_RANGE +- || !range_int_cst_p (vr)) +- return false; +- +- minlen = tree_to_uhwi (vr->min ()); +- maxlen = tree_to_uhwi (vr->max ()); +- } +- else +- return false; +- +- if (maxlen < offset) +- return false; +- +- minlen = minlen < offset ? 0 : minlen - offset; +- maxlen -= offset; +- if (maxlen + 1 < nbytes) +- return false; +- +- if (!nbytes +- && TREE_CODE (si->ptr) == SSA_NAME +- && !POINTER_TYPE_P (TREE_TYPE (si->ptr))) +- { +- /* SI->PTR is an SSA_NAME with a DEF_STMT like +- _1 = MEM [(char * {ref-all})s_4(D)]; */ +- gimple *stmt = SSA_NAME_DEF_STMT (exp); +- if (gimple_assign_single_p (stmt) +- && gimple_assign_rhs_code (stmt) == MEM_REF) +- { +- tree rhs = gimple_assign_rhs1 (stmt); +- if (tree refsize = TYPE_SIZE_UNIT (TREE_TYPE (rhs))) +- if (tree_fits_uhwi_p (refsize)) +- { +- nbytes = tree_to_uhwi (refsize); +- maxlen = nbytes; +- } +- } +- +- if (!nbytes) +- return false; +- } +- +- if (nbytes <= minlen) +- *nulterm = false; +- +- if (nbytes < minlen) +- { +- minlen = nbytes; +- if (nbytes < maxlen) +- maxlen = nbytes; +- } +- +- if (minlen < lenrange[0]) +- lenrange[0] = minlen; +- if (lenrange[1] < maxlen) +- lenrange[1] = maxlen; +- +- if (lenrange[2] < nbytes) +- lenrange[2] = nbytes; +- +- /* Since only the length of the string are known and not its contents, +- clear ALLNUL and ALLNONNUL purely on the basis of the length. */ +- *allnul = false; +- if (minlen < nbytes) +- *allnonnul = false; +- +- return true; +- } +- +- if (TREE_CODE (exp) == ADDR_EXPR) +- { +- /* If the size of the access hasn't been determined yet it's that +- of a pointer. */ +- if (!nbytes) +- nbytes = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (exp))); +- exp = TREE_OPERAND (exp, 0); +- } +- + if (TREE_CODE (exp) == SSA_NAME) + { + /* Handle non-zero single-character stores specially. */ +@@ -4758,8 +4667,7 @@ count_nonzero_bytes (tree exp, unsigned + tree arg = TREE_OPERAND (exp, 0); + tree off = TREE_OPERAND (exp, 1); + +- if (TREE_CODE (off) != INTEGER_CST +- || !tree_fits_uhwi_p (off)) ++ if (TREE_CODE (off) != INTEGER_CST || !tree_fits_uhwi_p (off)) + return false; + + unsigned HOST_WIDE_INT wioff = tree_to_uhwi (off); +@@ -4776,15 +4684,17 @@ count_nonzero_bytes (tree exp, unsigned + if (!typesize || !tree_fits_uhwi_p (typesize)) + return false; + nbytes = tree_to_uhwi (typesize); ++ if (!nbytes) ++ return false; + + /* Handle MEM_REF = SSA_NAME types of assignments. */ +- return count_nonzero_bytes (arg, offset, nbytes, lenrange, nulterm, +- allnul, allnonnul, rvals, snlim); ++ return count_nonzero_bytes_addr (arg, offset, nbytes, lenrange, nulterm, ++ allnul, allnonnul, rvals, snlim); + } + +- if (TREE_CODE (exp) == VAR_DECL && TREE_READONLY (exp)) ++ if (VAR_P (exp) || TREE_CODE (exp) == CONST_DECL) + { +- exp = DECL_INITIAL (exp); ++ exp = ctor_for_folding (exp); + if (!exp) + return false; + } +@@ -4809,6 +4719,8 @@ count_nonzero_bytes (tree exp, unsigned + unsigned char buf[256]; + if (!prep) + { ++ if (CHAR_BIT != 8 || BITS_PER_UNIT != 8) ++ return false; + /* If the pointer to representation hasn't been set above + for STRING_CST point it at the buffer. */ + prep = reinterpret_cast (buf); +@@ -4852,8 +4764,8 @@ count_nonzero_bytes (tree exp, unsigned + if (n) + { + /* When the initial number of non-zero bytes N is non-zero, reset +- *ALLNUL; if N is less than that the size of the representation +- also clear *ALLNONNUL. */ ++ *ALLNUL; if N is less than that the size of the representation ++ also clear *ALLNONNUL. */ + *allnul = false; + if (n < nbytes) + *allnonnul = false; +@@ -4879,6 +4791,120 @@ count_nonzero_bytes (tree exp, unsigned + return true; + } + ++/* Like count_nonzero_bytes, but instead of counting bytes in EXP, count ++ bytes that are pointed to by EXP, which should be a pointer. */ ++ ++static bool ++count_nonzero_bytes_addr (tree exp, unsigned HOST_WIDE_INT offset, ++ unsigned HOST_WIDE_INT nbytes, ++ unsigned lenrange[3], bool *nulterm, ++ bool *allnul, bool *allnonnul, ++ const vr_values *rvals, ssa_name_limit_t &snlim) ++{ ++ int idx = get_stridx (exp); ++ if (idx > 0) ++ { ++ strinfo *si = get_strinfo (idx); ++ if (!si) ++ return false; ++ ++ /* Handle both constant lengths as well non-constant lengths ++ in some range. */ ++ unsigned HOST_WIDE_INT minlen, maxlen; ++ if (tree_fits_shwi_p (si->nonzero_chars)) ++ minlen = maxlen = tree_to_shwi (si->nonzero_chars); ++ else if (si->nonzero_chars ++ && TREE_CODE (si->nonzero_chars) == SSA_NAME) ++ { ++ vr_values *v = CONST_CAST (vr_values *, rvals); ++ const value_range_equiv *vr = v->get_value_range (si->nonzero_chars); ++ if (vr->kind () != VR_RANGE || !range_int_cst_p (vr)) ++ return false; ++ ++ minlen = tree_to_uhwi (vr->min ()); ++ maxlen = tree_to_uhwi (vr->max ()); ++ } ++ else ++ return false; ++ ++ if (maxlen < offset) ++ return false; ++ ++ minlen = minlen < offset ? 0 : minlen - offset; ++ maxlen -= offset; ++ if (maxlen + 1 < nbytes) ++ return false; ++ ++ if (nbytes <= minlen) ++ *nulterm = false; ++ ++ if (nbytes < minlen) ++ { ++ minlen = nbytes; ++ if (nbytes < maxlen) ++ maxlen = nbytes; ++ } ++ ++ if (minlen < lenrange[0]) ++ lenrange[0] = minlen; ++ if (lenrange[1] < maxlen) ++ lenrange[1] = maxlen; ++ ++ if (lenrange[2] < nbytes) ++ lenrange[2] = nbytes; ++ ++ /* Since only the length of the string are known and not its contents, ++ clear ALLNUL and ALLNONNUL purely on the basis of the length. */ ++ *allnul = false; ++ if (minlen < nbytes) ++ *allnonnul = false; ++ ++ return true; ++ } ++ ++ if (TREE_CODE (exp) == ADDR_EXPR) ++ return count_nonzero_bytes (TREE_OPERAND (exp, 0), offset, nbytes, ++ lenrange, nulterm, allnul, allnonnul, rvals, ++ snlim); ++ ++ if (TREE_CODE (exp) == SSA_NAME) ++ { ++ gimple *stmt = SSA_NAME_DEF_STMT (exp); ++ if (gimple_code (stmt) == GIMPLE_PHI) ++ { ++ /* Avoid processing an SSA_NAME that has already been visited ++ or if an SSA_NAME limit has been reached. Indicate success ++ if the former and failure if the latter. */ ++ if (int res = snlim.next_ssa_name (exp)) ++ return res > 0; ++ ++ /* Determine the minimum and maximum from the PHI arguments. */ ++ unsigned int n = gimple_phi_num_args (stmt); ++ for (unsigned i = 0; i != n; i++) ++ { ++ tree def = gimple_phi_arg_def (stmt, i); ++ if (!count_nonzero_bytes_addr (def, offset, nbytes, lenrange, ++ nulterm, allnul, allnonnul, rvals, ++ snlim)) ++ return false; ++ } ++ ++ return true; ++ } ++ } ++ ++ /* Otherwise we don't know anything. */ ++ lenrange[0] = 0; ++ if (lenrange[1] < nbytes) ++ lenrange[1] = nbytes; ++ if (lenrange[2] < nbytes) ++ lenrange[2] = nbytes; ++ *nulterm = false; ++ *allnul = false; ++ *allnonnul = false; ++ return true; ++} ++ + /* Same as above except with an implicit SSA_NAME limit. RVALS is used + to determine ranges of dynamically computed string lengths (the results + of strlen). */ +--- gcc/testsuite/gcc.dg/pr94015.c.jj 2020-03-03 18:04:47.928594261 +0100 ++++ gcc/testsuite/gcc.dg/pr94015.c 2020-03-03 18:04:34.345794259 +0100 +@@ -0,0 +1,107 @@ ++/* PR tree-optimization/94015 */ ++/* { dg-do run } */ ++/* { dg-options "-O2" } */ ++ ++char buf[10] = "AAAAAAAAA"; ++ ++__attribute__((noipa)) char * ++alloc (void) ++{ ++ return buf; ++} ++ ++__attribute__((noipa)) void ++f1 (void) ++{ ++ char *s = alloc (); ++ *(char **)s = "1234567"; ++ s[7] = '\0'; ++} ++ ++__attribute__((noipa)) void ++f2 (void) ++{ ++ char *s = alloc (); ++ *(char **)s = "123456"; ++ s[6] = '\0'; ++} ++ ++__attribute__((noipa)) void ++f3 (void) ++{ ++ char *s = alloc (); ++ *(char **)s = "12345"; ++ s[5] = '\0'; ++} ++ ++__attribute__((noipa)) void ++f4 (void) ++{ ++ char *s = alloc (); ++ *(char **)s = "1234"; ++ s[4] = '\0'; ++} ++ ++__attribute__((noipa)) void ++f5 (void) ++{ ++ char *s = alloc (); ++ *(char **)s = "123"; ++ s[3] = '\0'; ++} ++ ++__attribute__((noipa)) void ++f6 (void) ++{ ++ char *s = alloc (); ++ *(char **)s = "12"; ++ s[2] = '\0'; ++} ++ ++__attribute__((noipa)) void ++f7 (void) ++{ ++ char *s = alloc (); ++ *(char **)s = "1"; ++ s[1] = '\0'; ++} ++ ++__attribute__((noipa)) void ++f8 (void) ++{ ++ char *s = alloc (); ++ *(char **)s = ""; ++ s[0] = '\0'; ++} ++ ++int ++main () ++{ ++ if (sizeof (char *) > 8) ++ return 0; ++ f1 (); ++ if (buf[7] != 0) ++ __builtin_abort (); ++ f2 (); ++ if (buf[6] != 0) ++ __builtin_abort (); ++ f3 (); ++ if (buf[5] != 0) ++ __builtin_abort (); ++ f4 (); ++ if (buf[4] != 0) ++ __builtin_abort (); ++ f5 (); ++ if (buf[3] != 0) ++ __builtin_abort (); ++ f6 (); ++ if (buf[2] != 0) ++ __builtin_abort (); ++ f7 (); ++ if (buf[1] != 0) ++ __builtin_abort (); ++ f8 (); ++ if (buf[0] != 0) ++ __builtin_abort (); ++ return 0; ++} diff --git a/gcc10-pr94130.patch b/gcc10-pr94130.patch new file mode 100644 index 0000000..10cbc0a --- /dev/null +++ b/gcc10-pr94130.patch @@ -0,0 +1,85 @@ +2020-03-11 Jakub Jelinek + + PR tree-optimization/94130 + * tree-ssa-dse.c: Include gimplify.h. + (increment_start_addr): If stmt has lhs, drop the lhs from call and + set it after the call to the original value of the first argument. + Formatting fixes. + (decrement_count): Formatting fix. + + * gcc.c-torture/execute/pr94130.c: New test. + +--- gcc/tree-ssa-dse.c.jj 2020-03-03 11:04:46.367821907 +0100 ++++ gcc/tree-ssa-dse.c 2020-03-11 13:57:38.671845186 +0100 +@@ -38,6 +38,7 @@ along with GCC; see the file COPYING3. + #include "tree-ssa-dse.h" + #include "builtins.h" + #include "gimple-fold.h" ++#include "gimplify.h" + + /* This file implements dead store elimination. + +@@ -422,29 +423,38 @@ decrement_count (gimple *stmt, int decre + gcc_assert (TREE_CODE (*countp) == INTEGER_CST); + *countp = wide_int_to_tree (TREE_TYPE (*countp), (TREE_INT_CST_LOW (*countp) + - decrement)); +- + } + + static void + increment_start_addr (gimple *stmt, tree *where, int increment) + { ++ if (tree lhs = gimple_call_lhs (stmt)) ++ if (where == gimple_call_arg_ptr (stmt, 0)) ++ { ++ gassign *newop = gimple_build_assign (lhs, unshare_expr (*where)); ++ gimple_stmt_iterator gsi = gsi_for_stmt (stmt); ++ gsi_insert_after (&gsi, newop, GSI_SAME_STMT); ++ gimple_call_set_lhs (stmt, NULL_TREE); ++ update_stmt (stmt); ++ } ++ + if (TREE_CODE (*where) == SSA_NAME) + { + tree tem = make_ssa_name (TREE_TYPE (*where)); + gassign *newop +- = gimple_build_assign (tem, POINTER_PLUS_EXPR, *where, ++ = gimple_build_assign (tem, POINTER_PLUS_EXPR, *where, + build_int_cst (sizetype, increment)); + gimple_stmt_iterator gsi = gsi_for_stmt (stmt); + gsi_insert_before (&gsi, newop, GSI_SAME_STMT); + *where = tem; +- update_stmt (gsi_stmt (gsi)); ++ update_stmt (stmt); + return; + } + + *where = build_fold_addr_expr (fold_build2 (MEM_REF, char_type_node, +- *where, +- build_int_cst (ptr_type_node, +- increment))); ++ *where, ++ build_int_cst (ptr_type_node, ++ increment))); + } + + /* STMT is builtin call that writes bytes in bitmap ORIG, some bytes are dead +--- gcc/testsuite/gcc.c-torture/execute/pr94130.c.jj 2020-03-11 14:01:49.431180291 +0100 ++++ gcc/testsuite/gcc.c-torture/execute/pr94130.c 2020-03-11 14:01:37.654352419 +0100 +@@ -0,0 +1,16 @@ ++/* PR tree-optimization/94130 */ ++ ++int ++main () ++{ ++ int a[8]; ++ char *b = __builtin_memset (a, 0, sizeof (a)); ++ a[0] = 1; ++ a[1] = 2; ++ a[2] = 3; ++ if (b != (char *) a) ++ __builtin_abort (); ++ else ++ asm volatile ("" : : "g" (a) : "memory"); ++ return 0; ++} diff --git a/sources b/sources index 385d0e9..c6f9b84 100644 --- a/sources +++ b/sources @@ -1,3 +1,3 @@ -SHA512 (gcc-10.0.1-20200216.tar.xz) = 56507e273b00e85ed4145e80df65d9b4e4791f23e7cb5d931f85b9420cbf3a7125ba49978dc73c2987c0a6101f741dc5a60a08cb3346d4c5082400cbcfcdd008 +SHA512 (gcc-10.0.1-20200311.tar.xz) = b2b730beaf28b75409d4cef72fd9cae20b910442b8b8d4d91911a80bed6e2a63228f08bb31b783f58e31e714be3f3a9f6ceded1f351b4fdded1671e1468eaca7 SHA512 (newlib-cygwin-50e2a63b04bdd018484605fbb954fd1bd5147fa0.tar.xz) = 9ceea0b883185fe489724d54a7e909bb6ed4785fcadf80162033dc6a133e2657337175601278e4155d1f8fac275ff9c8a02572aea876166c608774c809f832e9 SHA512 (nvptx-tools-5f6f343a302d620b0868edab376c00b15741e39e.tar.xz) = f6d10db94fa1570ae0f94df073fa3c73c8e5ee16d59070b53d94f7db0de8a031bc44d7f3f1852533da04b625ce758e022263855ed43cfc6867e0708d001e53c7