Handle Iop_NegF16, Iop_AbsF16 and Iop_SqrtF16 as non-trapping.

Add Iop_NegF16, Iop_AbsF16 and Iop_SqrtF16 to VEX/priv/ir_defs.c
primopMightTrap. Also rewrite case statement slightly so GCC will warn
if an enumeration value is missed.

Bug 432161 Addition of arm64 v8.2 FADDP, FNEG and FSQRT

This patch adds FP half-precision support for the following:
FABS <Hd>, <Hn>
FABS <Vd>.<T>, <Vn>.<T>
FNEG <Hd>, <Hn>
FNEG <Vd>.<T>, <Vn>.<T>
FSQRT <Hd>, <Hn>
FSQRT <Vd>.<T>, <Vn>.<T>

Fixes https://bugs.kde.org/show_bug.cgi?id=432161

Add support for DWARF5 as produced by GCC11

Implement DWARF5 in readdwarf.c and readdwarf3.c

Since gcc11 will default to DWARF5 by default it is time for
valgrind to support it. The patch handles everything gcc11 produces
(except for the new DWARF expressions).

There is some duplication in the patch since we actually have two DWARF
readers which use slightly different abstractions (Slices vs Cursors).
It would be nice if we could merge these somehow. The reader in
readdwarf3.c is only used when --read-var-info=yes is used (which
drd uses to provide the allocation context).

The handling of DW_FORM_implicit_const is tricky with the current design.
An abbrev which contains an attribute encoded with DW_FORM_implicit_const
has its value also in the abbrev. The code in readdwarf3.c assumed it
always could simply get the data from the .debug_info/current Cursor.
For now I added a value field to the name_form field that holds the
associated value. This is slightly wasteful since the extra field is
not necessary for other forms.

Tested against GCC10 (defaulting to DWARF4) and GCC11 (defaulting to
DWARF5) on x86_64. No regressions in the regtests.

https://bugs.kde.org/show_bug.cgi?id=432102

Define AT as UChar in VEX/priv/guest_ppc_toIR.c (dis_vsx_accumulator_prefix)

GCC notices that AT is passed around as char, specifically as %u argument
to DIP. But ifieldAT returns an UChar and vsx_matrix_ger takes AT as UChar.
This causes lots of format string warnings when building with GCC11.

Simply declare AT as UChar instead of char.

Fix indentation in coregrind/m_debuginfo/readpdb.c (DEBUG_SnarfLinetab)

GCC warns:

readpdb.c:1631:16: warning: this 'if' clause does not guard...
  [-Wmisleading-indentation]
 1631 |                if (debug)
      |                ^~
In file included from ./pub_core_basics.h:38,
                 from m_debuginfo/readpdb.c:38:
../include/pub_tool_basics.h:69:30: note: ...this statement, but the latter
  is misleadingly indented as if it were guarded by the 'if'
   69 | #define ML_(str)    VGAPPEND(vgModuleLocal_,    str)
      |                              ^~~~~~~~~~~~~~
../include/pub_tool_basics.h:66:29: note: in definition of macro 'VGAPPEND'
   66 | #define VGAPPEND(str1,str2) str1##str2
      |                             ^~~~
m_debuginfo/readpdb.c:1636:19: note: in expansion of macro 'ML_'
 1636 |                   ML_(addLineInfo)(
      |                   ^~~

The warning message is slightly hard to read because of the macro expansion.
But GCC is right that the indentation is misleading. Fixed by reindenting.

Bug 431556 - Complete arm64 FADDP v8.2 instruction support started in 413547.

Patch from/by Assad Hashmi (assad.hashmi@linaro.org).

PPC64: Fix load store instructions

This patch fixes numerous errors in the ISA support.

The word and prefix versions of the instructions do not use the same mask
to extract the immediate values.  The prefix instructions should all use
the DFOM_IMMASK.

The parsing of prefix instructions has been fixed to ensure the ISA 3.1
instructions all have the ISA_3_1_PREFIX_CHECK check.

Fixed the commenting to improve the comments for the instruction parsing.

Fixed the parsing of the plxv instruction.

General code cleanup.

PPC64: Fix EA calculation for prefixed instructions

The effective address (EA) calculation for the prefixed instructions
concatenate an 18-bit immediate value from the prefix word and a 16-bit
immediate value fro the instruction word.  This results in a 34-bit value.
The concatenated value must be stored into a long long int not a 32-bit
integer.

PPC64: Fix for VG_MAX_INSTR_SZB, max instruction size is now 8bytes for prefix inst

The ISA 3.1 support has both word instructions of length 4-bytes and prefixed
instruction of length 8-bytes.  The following fix is needed when Valgrind
is compiled using an ISA 3.1 compiler.

Fix a couple of comment / crash-message typos.  No functional change.

Bug 413547 - regression test does not check for Arm 64 features.

Patches from/by Assad Hashmi (assad.hashmi@linaro.org).

Bug 391853 - Makefile.all.am:L247 and @SOLARIS_UNDEF_LARGESOURCE@ being empty

arm64 isel: in a couple places, use `xzr` as a source rather than loading zero into a reg.

Reduces code size by 0.27% for /usr/bin/date.

arm64 insn selector: improved handling of Or1/And1 trees.

This is the exact analog of cadd90993504678607a4f95dfe5d1df5207c1eb0, to the
point of almost being a copy-n-paste.  That commit split (amd64) iselCondCode
into two functions, iselCondCode_C (existing) and iselCondCode_R (new).  The
latter computes an I1-typed expression into a register rather than a condition
code.  The two functions cooperate so as to minimise between conversions between
a condition-code value and a value in a register.

More arm64 isel tuning: create {and,orr,eor,add,sub} reg,reg,reg-shifted-by-imm

Thus far the arm64 isel can't generate instructions of the form

   {and,or,xor,add,sub} reg,reg,reg-shifted-by-imm

and hence sometimes winds up generating pairs like

   lsh x2, x1, #13 ; orr x4, x3, x2

when instead it could just have generated

   orr x4, x3, x1, lsh #13

This commit fixes that, although only for the 64-bit case, not the 32-bit
case.  Specifically, it can transform the IR forms

  {Add,Sub,And,Or,Xor}(E1, {Shl,Shr,Sar}(E2, immediate))   and
  {Add,And,Or,Xor}({Shl,Shr,Sar}(E1, immediate), E2)

into a single arm64 instruction.  Note that `Sub` is not included in the
second line, because shifting the first operand requires inverting the arg
order in the arm64 instruction, which isn't allowable with `Sub`, since it's
not commutative and arm64 doesn't offer us a reverse-subtract instruction to
use instead.

This gives a 1.1% reduction generated code size when running
/usr/bin/date on Memcheck.

A bit of tuning of the arm64 isel: do PUT(..) = 0x0:I64 in a single insn.

When running Memcheck, most blocks will do one and often two of `PUT(..) =
0x0:I64`, as a result of the way the front end models arm64 condition codes.
The arm64 isel would generate `mov xN, #0 ; str xN, [xBaseblock, #imm]`,
which is pretty stupid.  This patch changes it to a single insn:
`str xzr, [xBaseblock, #imm]`.

This is a special-case for `PUT(..) = 0x0:I64`.  General-case integer stores
of 0x0:I64 are unchanged.

This gives a 1.9% reduction in generated code size when running
/usr/bin/date on Memcheck.

Add an extra suppression.

On Fedora 33 with gcc (GCC) 10.2.1 20201125 (Red Hat 10.2.1-9)
it looks like fun:__static_initialization_and_destruction_0 is
now inlined which causes the existing suppression for the
same reachable to no longer match.

expr_is_guardable doesn't handle Iex_Qop

IRExpr_Qop uses the Iex_Qop tag, which expr_is_guardable didn't handle.

https://bugs.kde.org/show_bug.cgi?id=430485

arm64 front end: sfbm: handle sign-extends explicitly

This is a follow-on to 41504d33dec8773c591d45192d1dda6e9c670031.

For the cases of sfbm that are actually just sign-extensions to a wider width,
emit that directly and do disassembly-printing accordingly.  No functional
change.

Fix 397605 - Add support for Linux FICLONE ioctl

Fix magic cookie reference in mc-manual.

The URL to the original C++ front-end for GCC internals document
disappeared. Replace it with an URL that still has a description of
the original magic cookie added by operator new [] by that frontend.

arm64 front end: ufbm/sfbm: handle plain shifts explicitly

The ufbm and sfbm instructions implement some kind of semi-magical rotate,
mask and sign/zero-extend functionality.  Boring old left and right shifts are
special cases of it.  The existing translation into IR is correct, but has the
disadvantage that the IR optimiser isn't clever enough to simplify the
resulting IR back into a single shift in the case where the instruction is
used simply to encode a shift.  This induces inefficiency and it also makes
the resulting disassembly pretty difficult to read, if you're into that kind
of thing.

This commit does the obvious thing: detects cases where the required behaviour
is just a single shift, and emits IR and disassembly-printing accordingly.
All other cases fall through to the existing general-case handling and so are
unchanged.

arm64 VEX frontend and backend support for Iop_M{Add,Sub}F{32,64}

The arm64 frontend used to implement the scalar fmadd, fmsub, fnmadd
and fnmsub iinstructions into separate addition/substraction and
multiplication instructions, which caused rounding issues.

This patch turns them into Iop_M{Add,Sub}F{32,64} instructions
(with some arguments negated). And the backend now emits fmadd or fmsub
instructions.

Alexandra Hajkova <ahajkova@redhat.com> added tests and fixed up the
implementation to make sure rounding (and sign) are correct now.

https://bugs.kde.org/show_bug.cgi?id=426014

ppc stxsibx and stxsihx instructions write too much data

stxsibx (Store VSX Scalar as Integer Byte Indexed X-form) is implemented
by first reading a whole word, merging in the new byte, and then writing
out the whole word. Causing memcheck to warn when the destination might
have room for less than 8 bytes.

The stxsihx (Store VSX Scalar as Integer Halfword Indexed X-form)
instruction does something similar reading and then writing a full
word instead of a half word.

The code can be simplified (and made more correct) by storing the byte
(or half-word) directly, IRStmt_Store seems fine to store byte or half
word sized data, and so seems the ppc backend.

https://bugs.kde.org/show_bug.cgi?id=430354

Bug 414268 - Enable AArch64 feature detection and decoding for v8.x instructions (where x>0).

Patch from Assad Hashmi <assad.hashmi@linaro.org>.

Initial change for Bug 429952 didn't work well with older GCC. Use the __clang__ macro instead.

Fix dhat/tests/copy on Solaris

Bug 404076 - s390x: Implement z14 vector instructions

Implement the new instructions/features that were added to z/Architecture
with the vector-enhancements facility 1.  Also cover the instructions from
the vector-packed-decimal facility that are defined outside the chapter
"Vector Decimal Instructions", but not the ones from that chapter itself.

For a detailed list of newly supported instructions see the updates to
`docs/internals/s390-opcodes.csv'.

Since the miscellaneous instruction extensions facility 2 was already
addressed by Bug 404406, this completes the support necessary to run
general programs built with `--march=z14' under Valgrind.  The
vector-packed-decimal facility is currently not exploited by the standard
toolchain and libraries.

Bug 408663 - Patch: Suppression file for musl libc

Bug 429952 - Errors when building regtest with clang

dhat/tests/Makefile.am: Add filter_copy to dist_noinst_SCRIPTS

Make sure that make dist includes all needed test filters.

check_headers_and_includes: Add dhat/dhat.h to tool_export_header

dhat now has a public header dhat/dhat.h, this header may include
valgrind.h directly. Make sure check_headers_and_includes knows.

Bug 429864 - s390: Use Iop_CasCmp* to fix memcheck false positives

Compare-and-swap instructions can cause memcheck false positives when
operating on partially uninitialized data.  An example is where a 1-byte
lock is allocated on the stack and then manipulated using CS on the
surrounding word.  This is correct, and the uninitialized data has no
influence on the result, but memcheck still complains.

This is caused by logic in the s390 backend, where the expected and actual
memory values are compared using Iop_Sub32.  Fix this by using
Iop_CasCmpNE32 instead.

Add support for copy and ad hoc profiling to DHAT.

Bug 428909 - helgrind: need to intercept duplicate libc definitions for Fedora 33

Add a comment to previous commit.

Fix wcscpy wrapper.

wcscpy deals with wchar_t, which has a size of 4, so the adjustment in
the wrapper must be +4 instead of +1.

lmw, lswi and related PowerPC insns aren't allowed on ppc64le

Newer binutils produce an error when the assembly contains lmw, stmw,
lswi, lswx, stswi, or stswx instructions in little-endian mode.

Only build and run the lsw and ldst_multiple testcases on ppc64[be].

https://bugs.kde.org/show_bug.cgi?id=427870

Fix an obscure problem with peak finding.

Currently, if there are multiple equal global peaks, `intro_Block` and
`resize_Block` record the first one while `check_for_peak` records the
last one. This could lead to inconsistent output, though it's unlikely
in practice.

This commit fixes things so that all functions record the last peak.

Hook up unhandled ppc64le-linux syscall: 147 (getsid)

https://bugs.kde.org/show_bug.cgi?id=429692

PowerPC, fix for conv_f16_to_double xscvhpdp assembler code

The previous commit:

  commit eb82a294573d15c1be663673d55b559a82ca29d3
  Author: Julian Seward <jseward@acm.org>
  Date:   Tue Nov 10 21:10:48 2020 +0100

      Add a missing ifdef, whose absence caused build breakage on non-POWER targets.

fixed the compile issue in conv_f16_to_double() where non-Power platforms
do not support the power xscvhpdp assembly instructions.  The instruction
is supported by ISA 3.0 platforms.  Older Power platforms still fail to
compile with the assembly instruction.  This patch fixes the if def for
power systems that do not support ISA 3.0.

memcheck: on arm64, use expensive instrumentation for Cmp{EQ,NE}64 by default.

Add a missing ifdef, whose absence caused build breakage on non-POWER targets.

Reduced Precision Outer Product Operation tests

Fix, add ISA 3.1 check to set ISA 3.1 in Valgrind hwcaps value

ISA 3.1 Reduced-Precision: Outer Product Operations

Add support for:

 pmxvf16ger2 Prefixed Masked VSX Vector 16-bit Floating-Point GER (rank-2 update)
 pmxvf16ger2nn Prefixed Masked VSX Vector 16-bit Floating-Point GER (rank-2 update) (Negative multiply, Negative accumulate)
 pmxvf16ger2np Prefixed Masked VSX Vector 16-bit Floating-Point GER (rank-2 update) (Negative multiply, Positive accumulate)
 pmxvf16ger2pn Prefixed Masked VSX Vector 16-bit Floating-Point GER (rank-2 update) (Positive multiply, Negative accumulate)
 pmxvf16ger2pp Prefixed Masked VSX Vector 16-bit Floating-Point GER (rank-2 update) (Positive multiply, Positive accumulate)
 pmxvf32ger Prefixed Masked VSX Vector 32-bit Floating-Point GER (rank-1 update)
 pmxvf32gernn Prefixed Masked VSX Vector 32-bit Floating-Point GER (rank-1 update) (Negative multiply, Negative accumulate)
 pmxvf32gernp Prefixed Masked VSX Vector 32-bit Floating-Point GER (rank-1 update) (Negative multiply, Positive accumulate)
 pmxvf32gerpn Prefixed Masked VSX Vector 32-bit Floating-Point GER (rank-1 update) (Positive multiply, Negative accumulate)
 pmxvf32gerpp Prefixed Masked VSX Vector 32-bit Floating-Point GER (rank-1 update) (Positive multiply, Positive accumulate)
 pmxvf64ger Prefixed Masked VSX Vector 64-bit Floating-Point GER (rank-1 update)
 pmxvf64gernn Prefixed Masked VSX Vector 64-bit Floating-Point GER (rank-1 update) (Negative multiply, Negative accumulate)
 pmxvf64gernp Prefixed Masked VSX Vector 64-bit Floating-Point GER (rank-1 update) (Negative multiply, Positive accumulate)
 pmxvf64gerpn Prefixed Masked VSX Vector 64-bit Floating-Point GER (rank-1 update) (Positive multiply, Negative accumulate)
 pmxvf64gerpp Prefixed Masked VSX Vector 64-bit Floating-Point GER (rank-1 update) (Positive multiply, Positive accumulate)
 pmxvi16ger2s Prefixed Masked VSX Vector 16-bit Signed Integer GER (rank-2 update) with Saturation
 pmxvi16ger2spp Prefixed Masked VSX Vector 16-bit Signed Integer GER (rank-2 update) with Saturation (Positive multiply, Positive accumulate)
 pmxvi4ger8 Prefixed Masked VSX Vector 4-bit Signed Integer GER (rank-8 update)
 pmxvi4ger8pp Prefixed Masked VSX Vector 4-bit Signed Integer GER (rank-8 update) (Positive multiply, Positive accumulate)
 pmxvi8ger4 Prefixed Masked VSX Vector 8-bit Signed/Unsigned Integer GER (rank-4 update)
 pmxvi8ger4pp Prefixed Masked VSX Vector 8-bit Signed/Unsigned Integer GER (rank-4 update) (Positive multiply, Positive accumulate)

 xvf16ger2 VSX Vector 16-bit Floating-Point GER (rank-2 update)
 xvf16ger2nn VSX Vector 16-bit Floating-Point GER (rank-2 update) (Positive multiply, Positive accumulate)
 xvf16ger2np VSX Vector 16-bit Floating-Point GER (rank-2 update) (Negative multiply, Positive accumulate)
 xvf16ger2pn VSX Vector 16-bit Floating-Point GER (rank-2 update) (Positive multiply, Negative accumulate)
 xvf16ger2pp VSX Vector 16-bit Floating-Point GER (rank-2 update) (Positive multiply, Positive accumulate)
 xvf32ger VSX Vector 32-bit Floating-Point GER (rank-1 update)
 xvf32gernn VSX Vector 32-bit Floating-Point GER (rank-1 update) (Negative multiply, Negative accumulate)
 xvf32gernp VSX Vector 32-bit Floating-Point GER (rank-1 update) (Negative multiply, Positive accumulate)
 xvf32gerpn VSX Vector 32-bit Floating-Point GER (rank-1 update) (Positive multiply, Negative accumulate)
 xvf32gerpp VSX Vector 32-bit Floating-Point GER (rank-1 update) (Positive multiply, Positive accumulate)
 xvf64ger VSX Vector 64-bit Floating-Point GER (rank-1 update)
 xvf64gernn VSX Vector 64-bit Floating-Point GER (rank-1 update) (Negative multiply, Negative accumulate)
 xvf64gernp VSX Vector 64-bit Floating-Point GER (rank-1 update) (Negative multiply, Positive accumulate)
 xvf64gerpn VSX Vector 64-bit Floating-Point GER (rank-1 update) (Positive multiply, Negative accumulate)
 xvf64gerpp VSX Vector 64-bit Floating-Point GER (rank-1 update) (Positive multiply, Positive accumulate)
 xvi16ger2s VSX Vector 16-bit Signed Integer GER (rank-2 update) with Saturation
 xvi16ger2spp VSX Vector 16-bit Signed Integer GER (rank-2 update) with Saturation (Positive multiply, Positive accumulate)
 xvi4ger8 VSX Vector 4-bit Signed Integer GER (rank-8 update)
 xvi4ger8pp VSX Vector 4-bit Signed Integer GER (rank-8 update) (Positive multiply, Positive accumulate)
 xvi8ger4 VSX Vector 8-bit Signed/Unsigned Integer GER (rank-4 update)
 xvi8ger4pp VSX Vector 8-bit Signed/Unsigned Integer GER (rank-4 update) (Positive multiply, Positive accumulate)

 xxmfacc VSX Move From ACC
 xxmtacc VSX Move To ACC
 xxsetaccz VSX Set ACC to Zero

Make memcheck/tests/sized_delete conditional upon the compiler having -fsized-deallocators, add 384729 to NEWS

VSX Load/Store rightmost element operation tests

Test LSB by Byte operation tests

String operation tests

ISA 3.1 VSX Load/Store Rightmost Element Operations

Add support for:

lxvrbx Load VSX Vector Rightmost Byte Indexed
lxvrdx Load VSX Vector Rightmost Doubleword Indexed
lxvrhx Load VSX Vector Rightmost Halfword Indexed
lxvrwx Load VSX Vector Rightmost Word Indexed
stxvrbx Store VSX Vector Rightmost Byte Indexed
stxvrdx Store VSX Vector Rightmost Doubleword Indexed
stxvrhx Store VSX Vector Rightmost Halfword Indexed
stxvrwx Store VSX Vector Rightmost Word Indexed

ISA 3.1 Test LSB by Byte Operation

Add support for:

xvtlsbb

ISA 3.1 String Operations

Add support for:

vclrlb Vector Clear Leftmost Bytes
vclrrb Vector Clear Rightmost Bytes
vstribl[.] Vector String Isolate Byte Left -Justified
vstribr[.] Vector String Isolate Byte Right -Justified
vstrihl[.] Vector String Isolate Halfword Left -Justified
vstrihr[.] Vector String Isolate Halfword Right -Justified

Bit Manipulation Operation tests

128-bit Binary Integer Operation tests

VSX Scalar Min/Max/Compare Quad-Precision operation tests

ISA 3.1 Bit-Manipulation Operations

Add support for:

cfuged Centrifuge Doubleword
cntlzdm Count Leading Zeros Doubleword under bit Mask
cnttzdm Count Trailing Zeros Doubleword under bit Mask
pdepd Parallel Bits Deposit Doubleword
pextd Parallel Bits Extract Doubleword
vcfuged Vector Centrifuge Doubleword
vclzdm Vector Count Leading Zeros Doubleword under bit Mask
vctzdm Vector Count Trailing Zeros Doubleword under bit Mask
vgnb Vector Gather every Nth Bit
vpdepd Vector Parallel Bits Deposit Doubleword
vpextd Vector Parallel Bits Extract Doubleword
xxeval VSX Vector Evaluate

dependent on RFC2609 patch being applied first.

ISA 3.1 128-bit Binary Integer Operations

Add support for:

vmuleud, vmuloud, vmulesd, vmulosd
vextsd2q, vcmpuq, vcmpsq
vcmpequq, vcmpequq., vcmpgtuq, vcmpgtuq., vcmpgtsq, vcmpgtsq.
vrlq, vrlqnm, vlqmi, vslq, vsrq, vsraq

ISA 3.1 VSX Scalar Minimum/Maximum/Compare Quad-Precision Operations

Add support for:

xscmpeqqp VSX Scalar Compare Equal Quad-Precision
xscmpgeqp VSX Scalar Compare Greater Than or Equal Quad-Precision
xscmpgtqp VSX Scalar Compare Greater Than Quad-Precision
xsmaxcqp VSX Scalar Maximum Type-C Quad-Precision
xsmincqp VSX Scalar Minimum Type-C Quad-Precision

Bug 384729 - __libc_freeres inhibits cross-platform valgrind

Pushed binary by mistake

Add testcase for C++14 sized delete

Bug 424012 - fix crash if readv/writev have invalid but not NULL arg2 iovec pointer

Bug 478716 - cppcheck detects potential leak in VEX/useful/smchash.c

Fix build on Solaris 11.3 - ar does not like empty object files.

Bug 428648 - s390x: Force 12-bit amode for vector loads in isel

Similar to Bug 417452, where the instruction selector sometimes attempted
to generate vector stores with a 20-bit displacement, the same problem has
now been reported with vector loads.

The problem is caused in s390_isel_vec_expr_wrk(), where the addressing
mode is generated with s390_isel_amode() instead of
s390_isel_amode_short().  This is fixed.

arm64 front end: mark a couple of vector load/store insns as "verbose".

Mark
   LD3/ST3 (multiple 3-elem structs to/from 3 regs
   LD4/ST4 (multiple 4-elem structs to/from 4 regs
as "verbose", since they can generate so much IR that a long sequence
of them causes later stages of the JIT to run out of space.

drd: Unbreak the musl build

See also https://bugs.kde.org/show_bug.cgi?id=428035.

Reported-by: Stacy <stacy.gaikovaia@windriver.com>
Fixes: 15330adf7c24 ("drd: Port to Fedora 33")

Support new faccessat2 linux syscall (439)

faccessat2 is a new syscall in linux 5.8 and will be used by glibc 2.33.
faccessat2 is simply faccessat with a new flag argument. It has
a common number across all linux arches.

https://bugs.kde.org/427787

drd: Update copyright notices

SIMD Permute-Class operations powerpc tests

ISA 3.1 SIMD Permute-Class Operations

Add support for:

vxvkq Load VSX Vector Special Value Quadword
vextddvlx Vector Extract Double Dword to VSR Left-Indexed
vextddvrx Vector Extract Double Dword to VSR Right-Indexed
vextdubvlx Vector Extract Double Unsigned Byte to VR Left-Indexed
vextdubvrx Vector Extract Double Unsigned Byte to VR Right-Indexed
vextduhvlx Vector Extract Double Unsigned Hword to VR Left-Indexed
vextduhvrx Vector Extract Double Unsigned Hword to VR Right-Indexed
vextduwvlx Vector Extract Double Unsigned Word to VR Left-Indexed
vextduwvrx Vector Extract Double Unsigned Word to VR Right-Indexed
vinsblx Vector Insert Byte from GPR Left-Indexed
vinsbrx Vector Insert Byte from GPR Right-Indexed
vinsbvlx Vector Insert Byte from VSR Left-Indexed
vinsbvrx Vector Insert Byte from VSR Right-Indexed
vinsd Vector Insert Dword from GPR
vinsdlx Vector Insert Dword from GPR Left-Indexed
vinsdrx Vector Insert Dword from GPR Right-Indexed
vinshlx Vector Insert Hword from GPR Left-Indexed
vinshrx Vector Insert Hword from GPR Right-Indexed
vinshvlx Vector Insert Hword from VSR Left-Indexed
vinshvrx Vector Insert Hword from VSR Right-Indexed
vinsw Vector Insert Word from GPR
vinswlx Vector Insert Word from GPR Left-Indexed
vinswrx Vector Insert Word from GPR Right-Indexed
vinswvlx Vector Insert Word from VSR Left-Indexed
vinswvrx Vector Insert Word from VSR Right-Indexed
vsldbi Vector Shift Left Double by Bit Immediate
vsrdbi Vector Shift Right Double by Bit Immediate
xxblendvb VSX Vector Blend Variable Byte
xxblendvd VSX Vector Blend Variable Dword
xxblendvh VSX Vector Blend Variable Hword
xxblendvw VSX Vector Blend Variable Word
xxpermx VSX Vector Permute Extended
xxsplti32dx VSX Vector Splat Immediate32 Dword Indexed
xxspltidp VSX Vector Splat Immediate DP
xxspltiw VSX Vector Splat Immediate Word

Vector Integer Multiply/Divide/Modulo Instruction tests

VSX 32-byte storage access operations

Set boolean support tests

Add byte reverse tests ; cleanups to foundation patch.

Add ISA 3.1 Vector Integer Multiply/Divide/Modulo Instructions

Add support for:

vdivesd Vector Divide Extended Signed Doubleword
vdivesw Vector Divide Extended Signed Word
vdiveud Vector Divide Extended Unsigned Doubleword
vdiveuw Vector Divide Extended Unsigned Word
vdivsd Vector Divide Signed Doubleword
vdivsw Vector Divide Signed Word
vdivud Vector Divide Unsigned Doubleword
vdivuw Vector Divide Unsigned Word
vmodsd Vector Modulo Signed Doubleword
vmodsw Vector Modulo Signed Word
vmodud Vector Modulo Unsigned Doubleword
vmoduw Vector Modulo Unsigned Word
vmulhsd Vector Multiply High Signed Doubleword
vmulhsw Vector Multiply High Signed Word
vmulhud Vector Multiply High Unsigned Doubleword
vmulhuw Vector Multiply High Unsigned Word
vmulld Vector Multiply Low Doubleword

Add ISA 3.1 VSX 32-byte Storage Access Operations

Add support for the new ISA 3.1 load and store
instructions:

lxvpx Load VSX Vector Paired Indexed
plxvp Prefixed Load VSX Vector Paired
pstxvp Prefixed Store VSX Vector Paired
stxvpx Store VSX Vector Paired Indexed

Update the parsing of the lxvp and stxvp instructions that
were previously added.

lxvp Load VSX Vector Paired
stxvp Store VSX Vector Paired

A couple of format changes for the arguments to the
calculate_prefix_EA function.

Add comments to the else if and case statement to
clarify which instructions meet this condition.

Add ISA 3.1 Set Boolean Extension instruction support

Add support for the new ISA 3.1 set boolean condition
word instructions:

setbc Set Boolean Condition
setbcr Set Boolean Condition Reverse
setnbc Set Negative Boolean Condition
setnbcr Set Negative Boolean Condition Reverse.

Add ISA 3.1 Byte-Reverse Instruction support

Add support for the new ISA 3.1 word instructions:

brd Byte-Reverse Doubleword
brh Byte-Reverse Halfword
brw Byte-Reverse Word

Update .gitignore with none/tests/amd64/rdseed

PPC64 tests Makefile.am cleanup

Fix the file consistency check in none/tests/ppc64/Makefile.am.  Subsequent
patches for the PPC ISA 3.1 support will fully add the additional tests.

ir_defs.c: Iop_MAddF32 and Iop_MSubF32 are no (longer) s390 specific.

VEX/priv/guest_arm64_toIR.c: Fix vpanic messages mixup in mkDIVF.

Fix isa 3.1 test code on ppc64.

On ppc64 [old big endian] altivec.h can not be included directly.
Move the HAS_ISA_3_1 guard around so the include is only done when
the full test (and test_list_t) are build.

Fix common isa 3.1 test code

The code in test_isa_3_1_common.c should only be included
if ISA 3.1 support exists.

Prefixed load-store support

valgrind isa 3.1 foundation

header files and other common parts associated with the initial isa v3.1
support

Add prefixed support for the following word instructions.

addi    Add Immediate
lbz     Load Byte & Zero
ld      Load Doubleword
lfd     Load Floating Double
lfs     Load Floating Single
lha     Load Halfword Algebraic
lhz     Load Halfword & Zero
lq      Load Quadword
lwa     Load Word Algebraic
lwz     Load Word & Zero
lxsd    Load VSX Scalar Doubleword
lxssp   Load VSX Scalar Single-Precision
lxv     Load VSX Vector
stb     Store Byte
std     Store Doubleword
stfd    Store Floating Double
stfs    Store Floating Single
sth     Store Halfword
stq     Store Quadword
stw     Store Word
stxsd   Store VSX Scalar Doubleword
stxssp  Store VSX Scalar Single-Precision
stxv    Store VSX Vector

Instruction Prefix Support

Add check for isa 3.1 support

drd: Port to Fedora 33

Apparently on Fedora 33 the POSIX thread functions exist in both libc and
libpthread. Hence this patch that intercepts the pthread functions in
libc. See also https://bugs.kde.org/show_bug.cgi?id=426144 .

On amd64, use by default the expensive instrumentation scheme for Iop_Add32.

This is necessary to avoid some false positives in code compiled by clang 10
at -O2.  Some very crude measurements suggest the increase in generated code
size is around 0.2%, viz, insignificant.

Bug 425820 - Failure to recognize vpcmpeqq as a dependency breaking idiom.

In the IR optimiser (ir_opt.c): Recognise the following IROps as
dependency-breaking ops that generate an all-ones output: Iop_CmpEQ16x4
Iop_CmpEQ32x2 Iop_CmpEQ64x2 Iop_CmpEQ8x32 Iop_CmpEQ16x16 Iop_CmpEQ64x4.  I
think this fixes all the known cases for sizes 32 bits to 256 bits.  It also
fixes bug 425820.

amd64: Implement RDSEED

This commit implements amd64 RDSEED instruction, on hosts that have it
and adds the new test case - none/tests/amd64/rdseed based on the existing
rdrand support.

https://bugs.kde.org/show_bug.cgi?id=424298

Correct vpanic message in guest_arm64_toIR.c for mkABSF/mkSQRTF.

I didn't actually see these vpanics, so they might never trigger. But
both would vpanic as if for mkNEGF, which is clearly wrong and confusing.

Incorrect call-graph tracking due to new _dl_runtime_resolve_xsave*

Newer glibc have alternate ld.so _ld_runtime_resolve functions.
Namely _dl_runtime_resolve_xsave and _dl_runtime_resolve_xsavec

This patch recognizes the xsave, xsvec and fxsave variants and
changes callgrind so that any variant counts as _dl_runtime_resolve.

Original patch by paulo.cesar.pereira.de.andrade@gmail.com
https://bugs.kde.org/show_bug.cgi?id=415293

Fix epoll_ctl setting of array event and data fields.

Fix for https://bugs.kde.org/show_bug.cgi?id=422623 in commit ecf5ba119
epoll_ctl warns for uninitialized padding on non-amd64 64bit arches
contained a bug. A pointer to an array is not a pointer to a pointer to
an array. Found by a Fedora user:
https://bugzilla.redhat.com/show_bug.cgi?id=1844778#c10

Handle REX prefixed JMP instruction.

The NET Core runtime might generate a JMP with a REX prefix.
For Jv (32bit offset) and Jb (8bit offset) this is valid.
Prefixes that change operand size are ignored for such JMPs.
So remove the check for sz == 4 and force sz = 4 for Jv.

https://bugs.kde.org/show_bug.cgi?id=422174

Fix warning in syswrap sched_getattr print format.

m_syswrap/syswrap-linux.c:3716:10: warning: format '%ld' expects argument of type 'long int', but argument 4 has type 'RegWord' {aka 'long unsigned int'} [-Wformat=]