diff --git a/valgrind-3.12-beta1-ppc64be.patch b/valgrind-3.12-beta1-ppc64be.patch new file mode 100644 index 0000000..88f01b1 --- /dev/null +++ b/valgrind-3.12-beta1-ppc64be.patch @@ -0,0 +1,465 @@ +From 8ba68463102c2ae537b27e8fd6ea6d6777ed7bb1 Mon Sep 17 00:00:00 2001 +From: Carl Love +Date: Wed, 28 Sep 2016 12:16:14 -0400 +Subject: [PATCH] Fix for clean helpers on BE + +This patch adds the missing fnptr_to_fnentry() wrapper call for the +clean helpers introduced in the ISA 3.0 support. + +Signed-off-by: Carl Love +--- + VEX/priv/guest_ppc_helpers.c | 5 +++ + VEX/priv/guest_ppc_toIR.c | 105 ++++++++++++++++++++++++++----------------- + 2 files changed, 68 insertions(+), 42 deletions(-) + +diff --git a/VEX/priv/guest_ppc_helpers.c b/VEX/priv/guest_ppc_helpers.c +index 1d79eed..0a4a31c 100644 +--- a/VEX/priv/guest_ppc_helpers.c ++++ b/VEX/priv/guest_ppc_helpers.c +@@ -220,6 +220,11 @@ IRExpr* guest_ppc64_spechelper ( const HChar* function_name, + /*--- Misc BCD clean helpers. ---*/ + /*---------------------------------------------------------------*/ + ++/* NOTE, the clean and dirty helpers need to called using the ++ * fnptr_to_fnentry() function wrapper to handle the Big Endian ++ * pointer-to-function ABI and the Little Endian ABI. ++ */ ++ + /* This C-helper takes a 128-bit BCD value as two 64-bit pieces. + * It checks the string to see if it is a valid 128-bit BCD value. + * A valid BCD value has a sign value in bits [3:0] between 0xA +diff --git a/VEX/priv/guest_ppc_toIR.c b/VEX/priv/guest_ppc_toIR.c +index 6bd6e8f..712d2d5 100644 +--- a/VEX/priv/guest_ppc_toIR.c ++++ b/VEX/priv/guest_ppc_toIR.c +@@ -4321,7 +4321,8 @@ static IRExpr * CmpGT128U ( IRExpr *src1, IRExpr *src2 ) + } + + +-static IRExpr * is_BCDstring128 (UInt Signed, IRExpr *src) ++static IRExpr * is_BCDstring128 ( const VexAbiInfo* vbi, ++ UInt Signed, IRExpr *src ) + { + + IRTemp valid = newTemp( Ity_I64 ); +@@ -4338,7 +4339,7 @@ static IRExpr * is_BCDstring128 (UInt Signed, IRExpr *src) + assign( valid, + mkIRExprCCall( Ity_I64, 0 /*regparms*/, + "is_BCDstring128_helper", +- &is_BCDstring128_helper, ++ fnptr_to_fnentry( vbi, &is_BCDstring128_helper ), + mkIRExprVec_3( mkU64( Signed ), + unop( Iop_V128HIto64, src ), + unop( Iop_V128to64, src ) ) ) ); +@@ -4383,7 +4384,8 @@ static IRExpr * check_BCD_round (IRExpr *src, IRTemp shift) + mkU64( 0xF ) ) ); + } + +-static IRTemp increment_BCDstring (IRExpr *src, IRExpr *carry_in) ++static IRTemp increment_BCDstring ( const VexAbiInfo* vbi, ++ IRExpr *src, IRExpr *carry_in ) + { + /* The src is a 128-bit value containing 31 BCD digits with the sign in + * the least significant byte. The bytes are BCD values between 0x0 and 0x9. +@@ -4418,7 +4420,8 @@ static IRTemp increment_BCDstring (IRExpr *src, IRExpr *carry_in) + assign( bcd_result0, + mkIRExprCCall( Ity_I64, 0 /*regparms*/, + "increment_BCDstring32_helper", +- &increment_BCDstring32_helper, ++ fnptr_to_fnentry( vbi, ++ &increment_BCDstring32_helper ), + mkIRExprVec_3( mkU64( True /*Signed*/ ), + bcd_string0, + binop( Iop_32HLto64, mkU32( 0 ), +@@ -4427,7 +4430,8 @@ static IRTemp increment_BCDstring (IRExpr *src, IRExpr *carry_in) + assign( bcd_result1, + mkIRExprCCall( Ity_I64, 0 /*regparms*/, + "increment_BCDstring32_helper", +- &increment_BCDstring32_helper, ++ fnptr_to_fnentry( vbi, ++ &increment_BCDstring32_helper ), + mkIRExprVec_3( mkU64( False /*Unsigned*/ ), + bcd_string1, + binop( Iop_Shr64, +@@ -4436,7 +4440,8 @@ static IRTemp increment_BCDstring (IRExpr *src, IRExpr *carry_in) + assign( bcd_result2, + mkIRExprCCall( Ity_I64, 0 /*regparms*/, + "increment_BCDstring32_helper", +- &increment_BCDstring32_helper, ++ fnptr_to_fnentry( vbi, ++ &increment_BCDstring32_helper ), + mkIRExprVec_3( mkU64( False /*Unsigned*/ ), + bcd_string2, + binop( Iop_Shr64, +@@ -4445,7 +4450,8 @@ static IRTemp increment_BCDstring (IRExpr *src, IRExpr *carry_in) + assign( bcd_result3, + mkIRExprCCall( Ity_I64, 0 /*regparms*/, + "increment_BCDstring32_helper", +- &increment_BCDstring32_helper, ++ fnptr_to_fnentry( vbi, ++ &increment_BCDstring32_helper ), + mkIRExprVec_3( mkU64( False /*Unsigned*/ ), + bcd_string3, + binop( Iop_Shr64, +@@ -4470,7 +4476,8 @@ static IRTemp increment_BCDstring (IRExpr *src, IRExpr *carry_in) + return bcd_result; + } + +-static IRExpr * convert_to_zoned ( IRExpr *src, IRExpr *upper_byte ) ++static IRExpr * convert_to_zoned ( const VexAbiInfo* vbi, ++ IRExpr *src, IRExpr *upper_byte ) + { + /* The function takes a V128 packed decimal value and returns + * the value in zoned format. Note, the sign of the value is ignored. +@@ -4486,7 +4493,7 @@ static IRExpr * convert_to_zoned ( IRExpr *src, IRExpr *upper_byte ) + assign( result_low, + mkIRExprCCall( Ity_I64, 0 /*regparms*/, + "convert_to_zoned_helper", +- &convert_to_zoned_helper, ++ fnptr_to_fnentry( vbi, &convert_to_zoned_helper ), + mkIRExprVec_4( unop( Iop_V128HIto64, src ), + unop( Iop_V128to64, src ), + upper_byte, +@@ -4495,7 +4502,7 @@ static IRExpr * convert_to_zoned ( IRExpr *src, IRExpr *upper_byte ) + assign( result_hi, + mkIRExprCCall( Ity_I64, 0 /*regparms*/, + "convert_to_zoned_helper", +- &convert_to_zoned_helper, ++ fnptr_to_fnentry( vbi, &convert_to_zoned_helper ), + mkIRExprVec_4( unop( Iop_V128HIto64, src ), + unop( Iop_V128to64, src ), + upper_byte, +@@ -4508,7 +4515,7 @@ static IRExpr * convert_to_zoned ( IRExpr *src, IRExpr *upper_byte ) + return mkexpr( result ); + } + +-static IRExpr * convert_to_national ( IRExpr *src ) { ++static IRExpr * convert_to_national ( const VexAbiInfo* vbi, IRExpr *src ) { + /* The function takes 128-bit value which has a 64-bit packed decimal + * value in the lower 64-bits of the source. The packed decimal is + * converted to the national format via a clean helper. The clean +@@ -4528,14 +4535,14 @@ static IRExpr * convert_to_national ( IRExpr *src ) { + assign( result_low, + mkIRExprCCall( Ity_I64, 0 /*regparms*/, + "convert_to_national_helper", +- &convert_to_national_helper, ++ fnptr_to_fnentry( vbi, &convert_to_national_helper ), + mkIRExprVec_2( unop( Iop_V128to64, src ), + mkU64( 0 ) ) ) ); + + assign( result_hi, + mkIRExprCCall( Ity_I64, 0 /*regparms*/, + "convert_to_national_helper", +- &convert_to_national_helper, ++ fnptr_to_fnentry( vbi, &convert_to_national_helper ), + mkIRExprVec_2( unop( Iop_V128to64, src ), + mkU64( 1 ) ) ) ); + +@@ -4545,7 +4552,7 @@ static IRExpr * convert_to_national ( IRExpr *src ) { + return mkexpr( result ); + } + +-static IRExpr * convert_from_zoned ( IRExpr *src ) { ++static IRExpr * convert_from_zoned ( const VexAbiInfo* vbi, IRExpr *src ) { + /* The function takes 128-bit zoned value and returns a signless 64-bit + * packed decimal value in the lower 64-bits of the 128-bit result. + */ +@@ -4557,7 +4564,8 @@ static IRExpr * convert_from_zoned ( IRExpr *src ) { + mkU64( 0 ), + mkIRExprCCall( Ity_I64, 0 /*regparms*/, + "convert_from_zoned_helper", +- &convert_from_zoned_helper, ++ fnptr_to_fnentry( vbi, ++ &convert_from_zoned_helper ), + mkIRExprVec_2( unop( Iop_V128HIto64, + src ), + unop( Iop_V128to64, +@@ -4567,7 +4575,7 @@ static IRExpr * convert_from_zoned ( IRExpr *src ) { + return mkexpr( result ); + } + +-static IRExpr * convert_from_national ( IRExpr *src ) { ++static IRExpr * convert_from_national ( const VexAbiInfo* vbi, IRExpr *src ) { + /* The function takes 128-bit national value and returns a 64-bit + * packed decimal value. + */ +@@ -4576,7 +4584,8 @@ static IRExpr * convert_from_national ( IRExpr *src ) { + assign( result, + mkIRExprCCall( Ity_I64, 0 /*regparms*/, + "convert_from_national_helper", +- &convert_from_national_helper, ++ fnptr_to_fnentry( vbi, ++ &convert_from_national_helper ), + mkIRExprVec_2( unop( Iop_V128HIto64, + src ), + unop( Iop_V128to64, +@@ -22076,7 +22085,7 @@ static Bool dis_av_load ( const VexAbiInfo* vbi, UInt theInstr ) + d = unsafeIRDirty_0_N ( + 0/*regparms*/, + "ppc64g_dirtyhelper_LVS", +- &ppc64g_dirtyhelper_LVS, ++ fnptr_to_fnentry( vbi, &ppc64g_dirtyhelper_LVS ), + args_le ); + } + DIP("lvsl v%d,r%u,r%u\n", vD_addr, rA_addr, rB_addr); +@@ -22126,7 +22135,7 @@ static Bool dis_av_load ( const VexAbiInfo* vbi, UInt theInstr ) + d = unsafeIRDirty_0_N ( + 0/*regparms*/, + "ppc64g_dirtyhelper_LVS", +- &ppc64g_dirtyhelper_LVS, ++ fnptr_to_fnentry( vbi, &ppc64g_dirtyhelper_LVS ), + args_le ); + } + DIP("lvsr v%d,r%u,r%u\n", vD_addr, rA_addr, rB_addr); +@@ -25035,7 +25044,7 @@ static IRExpr * bcd_sign_code_adjust( UInt ps, IRExpr * tmp) + except when an overflow occurs. But since we can't be 100% accurate + in our emulation of CR6, it seems best to just not support it all. + */ +-static Bool dis_av_bcd_misc ( UInt theInstr ) ++static Bool dis_av_bcd_misc ( UInt theInstr, const VexAbiInfo* vbi ) + { + UChar opc1 = ifieldOPC(theInstr); + UChar vRT_addr = ifieldRegDS(theInstr); +@@ -25087,8 +25096,10 @@ static Bool dis_av_bcd_misc ( UInt theInstr ) + valid = + unop( Iop_64to32, + binop( Iop_And64, +- is_BCDstring128( /*Signed*/True, mkexpr( vA ) ), +- is_BCDstring128( /*Signed*/True, mkexpr( vB ) ) ) ); ++ is_BCDstring128( vbi, ++ /*Signed*/True, mkexpr( vA ) ), ++ is_BCDstring128( vbi, ++ /*Signed*/True, mkexpr( vB ) ) ) ); + + sign_vb = binop( Iop_AndV128, + binop( Iop_64HLtoV128, +@@ -25149,7 +25160,7 @@ static Bool dis_av_bcd_misc ( UInt theInstr ) + return True; + } + +-static Bool dis_av_bcd ( UInt theInstr ) ++static Bool dis_av_bcd ( UInt theInstr, const VexAbiInfo* vbi ) + { + /* VX-Form */ + UChar opc1 = ifieldOPC(theInstr); +@@ -25221,8 +25232,10 @@ static Bool dis_av_bcd ( UInt theInstr ) + valid = + unop( Iop_64to32, + binop( Iop_And64, +- is_BCDstring128( /* Signed */True, mkexpr( vA ) ), +- is_BCDstring128( /* Signed */True, mkexpr( vB ) ) ) ); ++ is_BCDstring128( vbi, ++ /* Signed */True, mkexpr( vA ) ), ++ is_BCDstring128( vbi, ++ /* Signed */True, mkexpr( vB ) ) ) ); + + /* src A */ + zeroA = BCDstring_zero( binop( Iop_AndV128, +@@ -25440,7 +25453,7 @@ static Bool dis_av_bcd ( UInt theInstr ) + + valid = + unop( Iop_64to32, +- is_BCDstring128( /* Signed */True, mkexpr( vB ) ) ); ++ is_BCDstring128( vbi, /* Signed */True, mkexpr( vB ) ) ); + + } else { + /* string is an unsigned BCD value */ +@@ -25450,7 +25463,8 @@ static Bool dis_av_bcd ( UInt theInstr ) + + valid = + unop( Iop_64to32, +- is_BCDstring128( /* Unsigned */False, mkexpr( vB ) ) ); ++ is_BCDstring128( vbi, /* Unsigned */False, ++ mkexpr( vB ) ) ); + } + + /* if PS = 0 +@@ -25507,7 +25521,7 @@ static Bool dis_av_bcd ( UInt theInstr ) + new_sign_val ), + binop( Iop_AndV128, + not_excess_shift_mask, +- mkexpr( increment_BCDstring( result, ++ mkexpr( increment_BCDstring( vbi, result, + mkexpr( round) + ) ) ) ) ); + } else { // bcdus. +@@ -25623,7 +25637,7 @@ static Bool dis_av_bcd ( UInt theInstr ) + } + valid = + unop( Iop_64to32, +- is_BCDstring128( /* Signed */True, mkexpr( vB ) ) ); ++ is_BCDstring128( vbi, /* Signed */True, mkexpr( vB ) ) ); + + } else { // bcdutrunc. + /* Check if all of the digits are zero */ +@@ -25636,7 +25650,8 @@ static Bool dis_av_bcd ( UInt theInstr ) + pos = mkNOT1( zero ); + valid = + unop( Iop_64to32, +- is_BCDstring128( /* Unsigned */False, mkexpr( vB ) ) ); ++ is_BCDstring128( vbi, /* Unsigned */False, ++ mkexpr( vB ) ) ); + } + + /* If vB is not valid, the result is undefined, but we need to +@@ -25708,7 +25723,8 @@ static Bool dis_av_bcd ( UInt theInstr ) + /* Check each of the nibbles for a valid digit 0 to 9 */ + valid = + unop( Iop_64to32, +- is_BCDstring128( /* Signed */True, mkexpr( vB ) ) ); ++ is_BCDstring128( vbi, /* Signed */True, ++ mkexpr( vB ) ) ); + overflow = mkU1( 0 ); // not used + } + break; +@@ -25863,7 +25879,8 @@ static Bool dis_av_bcd ( UInt theInstr ) + pos = mkAND1( mkNOT1( sign ), mkNOT1( zero ) ); + + assign( tmp, +- convert_to_zoned( mkexpr( vB ), mkU64( upper_byte ) ) ); ++ convert_to_zoned( vbi, mkexpr( vB ), ++ mkU64( upper_byte ) ) ); + + /* Insert the sign based on ps and sign of vB + * in the lower byte. +@@ -25906,7 +25923,8 @@ static Bool dis_av_bcd ( UInt theInstr ) + */ + valid = + unop( Iop_64to32, +- is_BCDstring128( /* Signed */True, mkexpr( vB ) ) ); ++ is_BCDstring128( vbi, /* Signed */True, ++ mkexpr( vB ) ) ); + } + break; + +@@ -25940,7 +25958,8 @@ static Bool dis_av_bcd ( UInt theInstr ) + */ + valid = + unop( Iop_64to32, +- is_BCDstring128( /* Signed */True, mkexpr( vB ) ) ); ++ is_BCDstring128( vbi, /* Signed */True, ++ mkexpr( vB ) ) ); + + /* Upper 24 hex digits of VB, i.e. hex ditgits vB[0:23], + * must be zero for the ox_flag to be zero. This goes +@@ -26001,7 +26020,7 @@ static Bool dis_av_bcd ( UInt theInstr ) + pos = mkAND1( mkNOT1( sign ), mkNOT1( zero ) ); + + assign( tmp, +- convert_to_national( mkexpr( vB ) ) ); ++ convert_to_national( vbi, mkexpr( vB ) ) ); + + /* If vB is positive insert sign value 0x002B, otherwise + * insert 0x002D for negative. Have to use sign not neg +@@ -26009,7 +26028,7 @@ static Bool dis_av_bcd ( UInt theInstr ) + * OR'd with (sign << 1 | NOT sign) << 1. + * sign = 1 if vB is negative. + */ +- putVReg(vRT_addr, ++ putVReg( vRT_addr, + binop( Iop_OrV128, + mkexpr( tmp ), + binop( Iop_64HLtoV128, +@@ -26033,7 +26052,8 @@ static Bool dis_av_bcd ( UInt theInstr ) + */ + valid = + unop( Iop_64to32, +- is_BCDstring128( /* Signed */True, mkexpr( vB ) ) ); ++ is_BCDstring128( vbi, /* Signed */True, ++ mkexpr( vB ) ) ); + + overflow = ox_flag; + } +@@ -26049,7 +26069,7 @@ static Bool dis_av_bcd ( UInt theInstr ) + valid = unop( Iop_1Uto32, is_Zoned_decimal( vB, ps ) ); + + assign( tmp, +- convert_from_zoned( mkexpr( vB ) ) ); ++ convert_from_zoned( vbi, mkexpr( vB ) ) ); + + /* If the result of checking the lower 4 bits of each 8-bit + * value is zero, then the "number" was zero. +@@ -26129,7 +26149,7 @@ static Bool dis_av_bcd ( UInt theInstr ) + /* sign = 1 if vB is negative */ + sign = binop( Iop_CmpEQ64, mkexpr( hword_7 ), mkU64( 0x002D ) ); + +- assign( tmp, convert_from_national( mkexpr( vB ) ) ); ++ assign( tmp, convert_from_national( vbi, mkexpr( vB ) ) ); + + /* If the result of checking the lower 4 bits of each 16-bit + * value is zero, then the "number" was zero. +@@ -26221,7 +26241,8 @@ static Bool dis_av_bcd ( UInt theInstr ) + + valid = + unop( Iop_64to32, +- is_BCDstring128( /* Signed */True, mkexpr( vB ) ) ); ++ is_BCDstring128( vbi, /* Signed */True, ++ mkexpr( vB ) ) ); + + /* if PS = 0 + vB positive, sign is C +@@ -28388,7 +28409,7 @@ DisResult disInstr_PPC_WRK ( + case 0x181: // bcdcfn., bcdcfz. + // bcdctz., bcdcfsq., bcdctsq. + if (!allow_isa_2_07) goto decode_noP8; +- if (dis_av_bcd( theInstr )) goto decode_success; ++ if (dis_av_bcd( theInstr, abiinfo )) goto decode_success; + goto decode_failure; + default: + break; // Fall through... +@@ -28401,7 +28422,7 @@ DisResult disInstr_PPC_WRK ( + case 0x341: // bcdcpsgn + + if (!allow_isa_2_07) goto decode_noP8; +- if (dis_av_bcd_misc( theInstr )) goto decode_success; ++ if (dis_av_bcd_misc( theInstr, abiinfo )) goto decode_success; + goto decode_failure; + + +-- +2.1.0 + +Fix the expected output file for jm_int_isa_2_07 + +By convention the file jm_int_isa_2_07.stdout.exp is the big endian reuslts. + +If the little endian results differ, the file has -LE appended to it. + +Signed-off-by: Carl Love +--- + none/tests/ppc64/jm_int_isa_2_07.stdout.exp | 16 ++++++++-------- + 1 file changed, 8 insertions(+), 8 deletions(-) + +diff --git a/none/tests/ppc64/jm_int_isa_2_07.stdout.exp b/none/tests/ppc64/jm_int_isa_2_07.stdout.exp +index 5876128..e31b973 100644 +--- a/none/tests/ppc64/jm_int_isa_2_07.stdout.exp ++++ b/none/tests/ppc64/jm_int_isa_2_07.stdout.exp +@@ -1,17 +1,17 @@ +-stq abcdef0123456789,1133557722446688, 0 => 1133557722446688,abcdef0123456789) ++stq abcdef0123456789,1133557722446688, 0 => abcdef0123456789,1133557722446688) + +-lq (0xaaccee0011335577, 0xabcdef0123456789) => (reg_pair = 0xabcdef0123456789, 0xaaccee0011335577) ++lq (0xaaccee0011335577, 0xabcdef0123456789) => (reg_pair = 0xaaccee0011335577, 0xabcdef0123456789) + +-lbarx (0xaaccee0011335577, 0xabcdef0123456789) => (reg_pair = 0x0000000000000077, 0x0000000000000000) ++lbarx (0xaaccee0011335577, 0xabcdef0123456789) => (reg_pair = 0x00000000000000aa, 0x0000000000000000) + +-lharx (0xaaccee0011335577, 0xabcdef0123456789) => (reg_pair = 0x0000000000005577, 0x0000000000000000) ++lharx (0xaaccee0011335577, 0xabcdef0123456789) => (reg_pair = 0x000000000000aacc, 0x0000000000000000) + +-lqarx (0xaaccee0011335577, 0xabcdef0123456789) => (reg_pair = 0xabcdef0123456789, 0xaaccee0011335577) ++lqarx (0xaaccee0011335577, 0xabcdef0123456789) => (reg_pair = 0xaaccee0011335577, 0xabcdef0123456789) + +-stbcx. abefcd0145236789,1155337744226688 => 0000000000000089,0000000000000001; CR=20000000 ++stbcx. abefcd0145236789,1155337744226688 => 8900000000000000,0000000000000001; CR=20000000 + +-sthcx. abefcd0145236789,1155337744226688 => 0000000000006789,0000000000000001; CR=20000000 ++sthcx. abefcd0145236789,1155337744226688 => 6789000000000000,0000000000000001; CR=20000000 + +-stqcx. abefcd0145236789,1155337744226688 => 1155337744226688,abefcd0145236789; CR=20000000 ++stqcx. abefcd0145236789,1155337744226688 => abefcd0145236789,1155337744226688; CR=20000000 + + All done. Tested 8 different instructions +-- +1.8.3.1 + diff --git a/valgrind.spec b/valgrind.spec index aa343d6..b65183d 100644 --- a/valgrind.spec +++ b/valgrind.spec @@ -3,7 +3,7 @@ Summary: Tool for finding memory management bugs in programs Name: %{?scl_prefix}valgrind Version: 3.12.0 -Release: 0.1.BETA1%{?dist} +Release: 0.2.BETA1%{?dist} Epoch: 1 License: GPLv2+ URL: http://www.valgrind.org/ @@ -70,6 +70,10 @@ Patch2: valgrind-3.9.0-helgrind-race-supp.patch # Make ld.so supressions slightly less specific. Patch3: valgrind-3.9.0-ldso-supp.patch +# KDE#369175 jm_vec_isa_2_07 test crashes on ppc64 +# KDE#369169 ppc64 fails jm_int_isa_2_07 test +Patch4: valgrind-3.12-beta1-ppc64be.patch + %if %{build_multilib} # Ensure glibc{,-devel} is installed for both multilib arches BuildRequires: /lib/libc.so.6 /usr/lib/libc.so /lib64/libc.so.6 /usr/lib64/libc.so @@ -182,6 +186,7 @@ Valgrind User Manual for details. %patch1 -p1 %patch2 -p1 %patch3 -p1 +%patch4 -p1 %build # We need to use the software collection compiler and binutils if available. @@ -382,6 +387,9 @@ echo ===============END TESTING=============== %endif %changelog +* Thu Sep 29 2016 Mark Wielaard - 3.12.0-0.2-BETA1 +- Add valgrind-3.12-beta1-ppc64be.patch. + * Tue Sep 20 2016 Mark Wielaard - 3.12.0-0.1-BETA1 - Update to valgrind 3.12.0 pre-release. - Drop upstreamed patches.