go/test/codegen
Paul E. Murphy 5cdb132228 cmd/compile/internal/ssa: improve masking codegen on PPC64
Generate RLDIC[LR] instead of MOVD mask, Rx; AND Rx, Ry, Rz.
This helps reduce code size, and reduces the latency caused
by the constant load.

Similarly, for smaller-than-register values, truncate constants
which exceed the range of the value's type to avoid needing to
load a constant.

Change-Id: I6019684795eb8962d4fd6d9585d08b17c15e7d64
Reviewed-on: https://go-review.googlesource.com/c/go/+/515576
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
Run-TryBot: Paul Murphy <murp@ibm.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
2023-09-06 16:34:20 +00:00
..
addrcalc.go cmd/compile: use ADDQ instead of LEAQ when we can 2020-02-24 21:33:53 +00:00
alloc.go cmd/compile: don't generate newobject call for 0-sized types 2019-02-26 23:08:15 +00:00
arithmetic.go cmd/compile: add rewrite rules for arithmetic operations 2023-03-20 15:42:09 +00:00
bitfield.go cmd/internal/obj/arm64: remove the transition from $0 to ZR 2022-08-23 06:11:32 +00:00
bits.go cmd/compile/internal/ssa: improve masking codegen on PPC64 2023-09-06 16:34:20 +00:00
bmi.go cmd/compile: AMD64v3 remove unnecessary TEST comparision in isPowerOfTwo 2023-01-20 04:58:59 +00:00
bool.go cmd/compile: add rules to emit SETBC/R instructions on power10 2023-02-06 12:49:53 +00:00
clobberdead.go cmd/compile: set LocalPkg.Path to -p flag 2022-05-16 18:19:47 +00:00
clobberdeadreg.go test: make codegen tests work with both ABIs 2021-04-12 21:59:59 +00:00
compare_and_branch.go cmd/compile: try to rewrite loops to count down 2023-07-31 18:33:29 +00:00
comparisons.go cmd/compile: remove memequal call from string compares in more cases 2023-04-18 21:31:33 +00:00
condmove.go test/codegen: accept ppc64x as alias for ppc64le and ppc64 arches 2023-01-24 22:55:18 +00:00
copy.go test/codegen: merge identical ppc64 and ppc64le tests 2023-01-27 19:03:02 +00:00
floats.go cmd/compile: add single-precision FMA code generation for riscv64 2023-08-22 12:05:36 +00:00
fuse.go cmd/compile: optimize integer-in-range checks 2020-03-03 14:30:26 +00:00
ifaces.go cmd/compile/internal/noder: allow OCONVNOP for identical iface conversions 2022-09-02 18:26:02 +00:00
issue22703.go test: port a nil-check interface test from asm_test 2018-03-03 20:20:54 +00:00
issue25378.go test: make codegen tests work with both ABIs 2021-04-12 21:59:59 +00:00
issue31618.go cmd/compile: always mark atColumn1 results as statements 2019-04-23 17:39:11 +00:00
issue33580.go cmd/compile: reuse dead register before reusing register holding constant 2019-10-07 15:16:26 +00:00
issue38554.go cmd/compile: optimize Move with all-zero ro sym src to Zero 2020-04-24 23:58:10 +00:00
issue42610.go test/codegen: combine trivial PPC64 tests into ppc64x 2023-01-27 18:24:12 +00:00
issue48054.go test/codegen: fix package name for test case 2021-09-08 14:51:40 +00:00
issue52635.go cmd/compile: inline known-size memclrNoHeapPointers calls 2023-01-31 18:11:24 +00:00
issue54467.go cmd/compile: use stricter rule for possible partial overlap 2022-09-27 20:09:33 +00:00
issue56440.go cmd/compile: add rule for post-decomposed growslice optimization 2022-10-31 21:40:49 +00:00
issue58166.go cmd/compile: schedule values with no in-block uses later 2023-02-01 18:41:07 +00:00
issue60324.go cmd/compile: incorporate inlined function names into closure naming 2023-05-22 22:47:15 +00:00
issue60673.go cmd/compile: use callsite as line number for argument marshaling 2023-06-12 20:34:37 +00:00
issue61356.go cmd/compile: get rid of special case in scheduler for entry block 2023-07-26 17:19:14 +00:00
logic.go cmd/compile: add De Morgan's rewrite rule 2023-05-10 16:32:25 +00:00
mapaccess.go cmd/compile: stop using VARKILL 2022-08-18 17:36:38 +00:00
maps.go internal/abi,runtime: refactor map constants into one place 2023-01-23 15:51:32 +00:00
math.go cmd/compile: fix FMA negative commutativity of riscv64 2023-07-05 22:05:44 +00:00
mathbits.go cmd/compile: don't use BTS when OR works, add direct memory BTS operations 2023-08-04 16:40:24 +00:00
memcombine.go cmd/compile: memcombine if values being stored are from consecutive loads 2023-07-21 19:06:53 +00:00
memops.go cmd/compile: don't use BTS when OR works, add direct memory BTS operations 2023-08-04 16:40:24 +00:00
memops_bigoffset.go cmd/compile: update rules to generate more prefixed instructions 2023-05-15 18:20:54 +00:00
noextend.go cmd/compile: remove more extension ops when not needed 2023-08-21 20:52:15 +00:00
race.go cmd/compile: remove racefuncenterfp when it is not needed 2020-11-02 03:03:16 +00:00
README all: fix typos 2023-07-18 19:55:29 +00:00
regabi_regalloc.go cmd/compile: reduce redundant register moves for regabi calls 2021-04-19 16:21:39 +00:00
retpoline.go cmd/compile: turn off jump tables when spectre retpolines are on 2022-12-06 05:12:12 +00:00
rotate.go test/codegen: combine trivial PPC64 tests into ppc64x 2023-01-27 18:24:12 +00:00
select.go cmd/compile: set LocalPkg.Path to -p flag 2022-05-16 18:19:47 +00:00
shift.go test/codegen: merge identical ppc64 and ppc64le tests 2023-01-27 19:03:02 +00:00
shortcircuit.go cmd/compile: handle some additional phis in shortcircuit 2020-04-08 22:13:38 +00:00
slices.go cmd/compile: inline constant sized memclrNoHeapPointers calls on PPC64 2023-02-23 18:57:27 +00:00
smallintiface.go cmd/compile: use staticuint64s instead of staticbytes 2020-03-04 21:43:01 +00:00
spectre.go [dev.regabi] cmd/compile: make ordering for InvertFlags more stable 2021-01-13 02:40:43 +00:00
stack.go test/codegen: combine trivial PPC64 tests into ppc64x 2023-01-27 18:24:12 +00:00
strings.go cmd/compile: optimize s==s for strings 2023-07-26 17:17:28 +00:00
structs.go cmd/internal/testdir: pass if GOEXPERIMENT=cgocheck2 is set 2023-06-01 18:30:44 +00:00
switch.go cmd/compile: use jump tables for large type switches 2023-08-23 00:30:54 +00:00
writebarrier.go cmd/compile: allow non-pointer writes in the middle of a write barrier 2023-08-23 00:16:06 +00:00
zerosize.go cmd/compile: set LocalPkg.Path to -p flag 2022-05-16 18:19:47 +00:00

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

The codegen directory contains code generation tests for the gc
compiler.


- Introduction

The test harness compiles Go code inside files in this directory and
matches the generated assembly (the output of `go tool compile -S`)
against a set of regexps to be specified in comments that follow a
special syntax (described below). The test driver is implemented as
an action within the GOROOT/test test suite, called "asmcheck".

The codegen harness is part of the all.bash test suite, but for
performance reasons only the codegen tests for the host machine's
GOARCH are enabled by default, and only on GOOS=linux.

To perform comprehensive tests for all the supported architectures
(even on a non-Linux system), one can run the following command:

  $ ../../bin/go test cmd/internal/testdir -run='Test/codegen' -all_codegen -v

This is recommended after any change that affect the compiler's code.

The test harness compiles the tests with the same go toolchain that is
used to run the test. After writing tests for a newly added codegen
transformation, it can be useful to first run the test harness with a
toolchain from a released Go version (and verify that the new tests
fail), and then re-running the tests using the devel toolchain.


- Regexps comments syntax

Instructions to match are specified inside plain comments that start
with an architecture tag, followed by a colon and a quoted Go-style
regexp to be matched. For example, the following test:

  func Sqrt(x float64) float64 {
  	   // amd64:"SQRTSD"
  	   // arm64:"FSQRTD"
  	   return math.Sqrt(x)
  }

verifies that math.Sqrt calls are intrinsified to a SQRTSD instruction
on amd64, and to a FSQRTD instruction on arm64.

It is possible to put multiple architectures checks into the same
line, as:

  // amd64:"SQRTSD" arm64:"FSQRTD"

although this form should be avoided when doing so would make the
regexps line excessively long and difficult to read.

Comments that are on their own line will be matched against the first
subsequent non-comment line. Inline comments are also supported; the
regexp will be matched against the code found on the same line:

  func Sqrt(x float64) float64 {
  	   return math.Sqrt(x) // arm:"SQRTD"
  }

It's possible to specify a comma-separated list of regexps to be
matched. For example, the following test:

  func TZ8(n uint8) int {
  	   // amd64:"BSFQ","ORQ\t\\$256"
  	   return bits.TrailingZeros8(n)
  }

verifies that the code generated for a bits.TrailingZeros8 call on
amd64 contains both a "BSFQ" instruction and an "ORQ $256".

Note how the ORQ regex includes a tab char (\t). In the Go assembly
syntax, operands are separated from opcodes by a tabulation.

Regexps can be quoted using either " or `. Special characters must be
escaped accordingly. Both of these are accepted, and equivalent:

  // amd64:"ADDQ\t\\$3"
  // amd64:`ADDQ\t\$3`

and they'll match this assembly line:

  ADDQ	$3

Negative matches can be specified using a - before the quoted regexp.
For example:

  func MoveSmall() {
  	   x := [...]byte{1, 2, 3, 4, 5, 6, 7}
  	   copy(x[1:], x[:]) // arm64:-".*memmove"
  }

verifies that NO memmove call is present in the assembly generated for
the copy() line.


- Architecture specifiers

There are three different ways to specify on which architecture a test
should be run:

* Specify only the architecture (eg: "amd64"). This indicates that the
  check should be run on all the supported architecture variants. For
  instance, arm checks will be run against all supported GOARM
  variations (5,6,7).
* Specify both the architecture and a variant, separated by a slash
  (eg: "arm/7"). This means that the check will be run only on that
  specific variant.
* Specify the operating system, the architecture and the variant,
  separated by slashes (eg: "plan9/386/sse2", "plan9/amd64/"). This is
  needed in the rare case that you need to do a codegen test affected
  by a specific operating system; by default, tests are compiled only
  targeting linux.


- Remarks, and Caveats

-- Write small test functions

As a general guideline, test functions should be small, to avoid
possible interactions between unrelated lines of code that may be
introduced, for example, by the compiler's optimization passes.

Any given line of Go code could get assigned more instructions than it
may appear from reading the source. In particular, matching all MOV
instructions should be avoided; the compiler may add them for
unrelated reasons and this may render the test ineffective.

-- Line matching logic

Regexps are always matched from the start of the instructions line.
This means, for example, that the "MULQ" regexp is equivalent to
"^MULQ" (^ representing the start of the line), and it will NOT match
the following assembly line:

  IMULQ	$99, AX

To force a match at any point of the line, ".*MULQ" should be used.

For the same reason, a negative regexp like -"memmove" is not enough
to make sure that no memmove call is included in the assembly. A
memmove call looks like this:

  CALL	runtime.memmove(SB)

To make sure that the "memmove" symbol does not appear anywhere in the
assembly, the negative regexp to be used is -".*memmove".