go/test/codegen
Cherry Zhang 6b8e3e2d06 cmd/compile: reduce redundant register moves for regabi calls
Currently, if we have AX=a and BX=b, and we want to make a call
F(1, a, b), to move arguments into the desired registers it emits

	MOVQ AX, CX
	MOVL $1, AX // AX=1
	MOVQ BX, DX
	MOVQ CX, BX // BX=a
	MOVQ DX, CX // CX=b

This has a few redundant moves.

This is because we process inputs in order. First, allocate 1 to
AX, which kicks out a (in AX) to CX (a free register at the
moment). Then, allocate a to BX, which kicks out b (in BX) to DX.
Finally, put b to CX.

Notice that if we start with allocating CX=b, then BX=a, AX=1,
we will not have redundant moves. This CL reduces redundant moves
by allocating them in different order: First, for inpouts that are
already in place, keep them there. Then allocate free registers.
Then everything else.

                             before       after
cmd/compile binary size     23703888    23609680
            text size        8565899     8533291

(with regabiargs enabled.)

Change-Id: I69e1bdf745f2c90bb791f6d7c45b37384af1e874
Reviewed-on: https://go-review.googlesource.com/c/go/+/311371
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
2021-04-19 16:21:39 +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 test: make codegen tests work with both ABIs 2021-04-12 21:59:59 +00:00
bitfield.go cmd/compile: add arm64 rules to optimize go codes to constant 0 2021-03-26 01:57:35 +00:00
bits.go test: make codegen tests work with both ABIs 2021-04-12 21:59:59 +00:00
bool.go cmd/compile: optimize x & 1 != 0 to x & 1 on amd64 2020-04-23 17:52:28 +00:00
clobberdead.go cmd/compile: resurrect clobberdead mode 2021-03-17 17:50:50 +00:00
clobberdeadreg.go test: make codegen tests work with both ABIs 2021-04-12 21:59:59 +00:00
compare_and_branch.go test/codegen: go fmt 2020-11-08 12:19:55 +00:00
comparisons.go test: make codegen tests work with both ABIs 2021-04-12 21:59:59 +00:00
condmove.go cmd/compile: add rewrite rules for conditional instructions on arm64 2021-03-18 01:46:58 +00:00
copy.go test/codegen, runtime/pprof, runtime: apply fmt 2020-04-21 09:07:42 +00:00
floats.go cmd/compile: ARM64 optimize []float64 and []float32 access 2021-02-24 19:49:08 +00:00
fuse.go cmd/compile: optimize integer-in-range checks 2020-03-03 14:30:26 +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 cmd/compile: fix rules regression with shifts on PPC64 2020-11-17 13:20:20 +00:00
logic.go cmd/compile: don't rewrite (CMP (AND x y) 0) to TEST if AND has other uses 2020-08-17 22:00:44 +00:00
mapaccess.go cmd/compile/internal/gc: handle arith ops in samesafeexpr 2018-09-19 12:03:58 +00:00
maps.go test: make codegen tests work with both ABIs 2021-04-12 21:59:59 +00:00
math.go test: make codegen tests work with both ABIs 2021-04-12 21:59:59 +00:00
mathbits.go cmd/compile: rescue stmt boundaries from OpArgXXXReg and OpSelectN. 2021-04-14 18:46:08 +00:00
memcombine.go test: make codegen tests work with both ABIs 2021-04-12 21:59:59 +00:00
memops.go test: make codegen/memops.go work with both ABIs 2021-04-13 14:07:17 +00:00
noextend.go test/codegen: gofmt 2019-03-13 21:44:45 +00:00
race.go cmd/compile: remove racefuncenterfp when it is not needed 2020-11-02 03:03:16 +00:00
README test/codegen: mention in README that tests only run on Linux without -all_codegen 2020-03-11 16:17:08 +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/asm, cmd/compile, runtime: add -spectre=ret mode 2020-03-13 19:05:54 +00:00
rotate.go cmd/compile: rescue stmt boundaries from OpArgXXXReg and OpSelectN. 2021-04-14 18:46:08 +00:00
select.go cmd/compile,runtime: skip zero'ing order array for select statements 2020-08-29 08:02:52 +00:00
shift.go cmd/compile: optimize multi-register shifts on amd64 2021-03-11 19:11:46 +00:00
shortcircuit.go cmd/compile: handle some additional phis in shortcircuit 2020-04-08 22:13:38 +00:00
slices.go test: make codegen tests work with both ABIs 2021-04-12 21:59:59 +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: make codegen tests work with both ABIs 2021-04-12 21:59:59 +00:00
strings.go cmd/compile: loads from readonly globals into const for mips64x 2021-03-16 09:07:17 +00:00
structs.go [dev.regabi] cmd/compile: reserve X15 as zero register on AMD64 2021-02-03 22:44:53 +00:00
switch.go cmd/compile: optimize switch on strings 2019-09-18 05:33:05 +00:00
zerosize.go test: make codegen tests work with both ABIs 2021-04-12 21:59:59 +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 a
step of the top-level test/run.go 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 run run.go -all_codegen -v codegen

in the top-level test directory. 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 run.go. 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-runnig 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".