Couple of last-minute things for rc3...

The following changes since commit d15532d91be177e7528310e0110e39f915779a99:

Merge remote-tracking branch 'remotes/aperard/tags/pull-xen-20200804' into staging (2020-08-04 11:53:20 +0100)

https://git.linaro.org/people/pmaydell/qemu-arm.git tags/pull-target-arm-20200804

for you to fetch changes up to d250bb19ced3b702c7c37731855f6876d0cc7995:

target/arm: Fix decode of LDRA[AB] instructions (2020-08-04 16:40:19 +0100)

target-arm queue:

* Fix decode of LDRA[AB] instructions

* docs/devel: Document decodetree no-overlap groups

Peter Collingbourne (1):

target/arm: Fix decode of LDRA[AB] instructions

Richard Henderson (1):

docs/devel: Document decodetree no-overlap groups

docs/devel/decodetree.rst | 29 ++++++++++++++++++-----------

target/arm/translate-a64.c | 6 ++++--

2 files changed, 22 insertions(+), 13 deletions(-)

From: Peter Collingbourne <pcc@google.com>

These instructions use zero as the discriminator, not SP.

Signed-off-by: Peter Collingbourne <pcc@google.com>

Message-id: 20200804002849.30268-1-pcc@google.com

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>

target/arm/translate-a64.c | 6 ++++--

1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/target/arm/translate-a64.c b/target/arm/translate-a64.c

--- a/target/arm/translate-a64.c

+++ b/target/arm/translate-a64.c

@@ -XXX,XX +XXX,XX @@ static void disas_ldst_pac(DisasContext *s, uint32_t insn,

if (s->pauth_active) {

if (use_key_a) {

- gen_helper_autda(dirty_addr, cpu_env, dirty_addr, cpu_X[31]);

+ gen_helper_autda(dirty_addr, cpu_env, dirty_addr,

+ new_tmp_a64_zero(s));

} else {

- gen_helper_autdb(dirty_addr, cpu_env, dirty_addr, cpu_X[31]);

+ gen_helper_autdb(dirty_addr, cpu_env, dirty_addr,

+ new_tmp_a64_zero(s));

}

2.20.1

When support for this feature went in, the update to the

documentation was forgotten.

Fixes: 067e8b0f45d6

Reported-by: Peter Maydell <peter.maydell@linaro.org>

Message-id: 20200803205708.315829-1-richard.henderson@linaro.org

docs/devel/decodetree.rst | 29 ++++++++++++++++++-----------

1 file changed, 18 insertions(+), 11 deletions(-)

diff --git a/docs/devel/decodetree.rst b/docs/devel/decodetree.rst

--- a/docs/devel/decodetree.rst

+++ b/docs/devel/decodetree.rst

@@ -XXX,XX +XXX,XX @@ Pattern Groups

Syntax::

- group := '{' ( pat_def | group )+ '}'

+ group := overlap_group | no_overlap_group

+ overlap_group := '{' ( pat_def | group )+ '}'

+ no_overlap_group := '[' ( pat_def | group )+ ']'

-A *group* begins with a lone open-brace, with all subsequent lines

-indented two spaces, and ending with a lone close-brace. Groups

-may be nested, increasing the required indentation of the lines

-within the nested group to two spaces per nesting level.

+A *group* begins with a lone open-brace or open-bracket, with all

+subsequent lines indented two spaces, and ending with a lone

+close-brace or close-bracket. Groups may be nested, increasing the

+required indentation of the lines within the nested group to two

+spaces per nesting level.

-Unlike ungrouped patterns, grouped patterns are allowed to overlap.

-Conflicts are resolved by selecting the patterns in order. If all

-of the fixedbits for a pattern match, its translate function will

-be called. If the translate function returns false, then subsequent

-patterns within the group will be matched.

+Patterns within overlap groups are allowed to overlap. Conflicts are

+resolved by selecting the patterns in order. If all of the fixedbits

+for a pattern match, its translate function will be called. If the

+translate function returns false, then subsequent patterns within the

+group will be matched.

+

+Patterns within no-overlap groups are not allowed to overlap, just

+the same as ungrouped patterns. Thus no-overlap groups are intended

+to be nested inside overlap groups.

The following example from PA-RISC shows specialization of the *or*

instruction::

@@ -XXX,XX +XXX,XX @@ instruction::

When the *cf* field is zero, the instruction has no side effects,

and may be specialized. When the *rt* field is zero, the output

is discarded and so the instruction has no effect. When the *rt2*

-field is zero, the operation is ``reg[rt] | 0`` and so encodes

+field is zero, the operation is ``reg[r1] | 0`` and so encodes

the canonical register copy operation.

The output from the generator might look like::

2.20.1