mirror of
https://github.com/golang/go
synced 2024-11-22 11:54:50 -07:00
b72bbaebf9
Convert expand calls into a smaller number of focused recursive rewrites, and rely on an enhanced version of "decompose" to clean up afterwards. Debugging information seems to emerge intact. Change-Id: Ic46da4207e3a4da5c8e2c47b637b0e35abbe56bb Reviewed-on: https://go-review.googlesource.com/c/go/+/507295 Run-TryBot: David Chase <drchase@google.com> Reviewed-by: Cherry Mui <cherryyz@google.com> Reviewed-by: Keith Randall <khr@golang.org> TryBot-Result: Gopher Robot <gobot@golang.org>
454 lines
6.2 KiB
Go
454 lines
6.2 KiB
Go
// asmcheck
|
|
|
|
// 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.
|
|
|
|
package codegen
|
|
|
|
func cmovint(c int) int {
|
|
x := c + 4
|
|
if x < 0 {
|
|
x = 182
|
|
}
|
|
// amd64:"CMOVQLT"
|
|
// arm64:"CSEL\tLT"
|
|
// ppc64x:"ISEL\t[$]0"
|
|
// wasm:"Select"
|
|
return x
|
|
}
|
|
|
|
func cmovchan(x, y chan int) chan int {
|
|
if x != y {
|
|
x = y
|
|
}
|
|
// amd64:"CMOVQNE"
|
|
// arm64:"CSEL\tNE"
|
|
// ppc64x:"ISEL\t[$]2"
|
|
// wasm:"Select"
|
|
return x
|
|
}
|
|
|
|
func cmovuintptr(x, y uintptr) uintptr {
|
|
if x < y {
|
|
x = -y
|
|
}
|
|
// amd64:"CMOVQ(HI|CS)"
|
|
// arm64:"CSNEG\tLS"
|
|
// ppc64x:"ISEL\t[$]1"
|
|
// wasm:"Select"
|
|
return x
|
|
}
|
|
|
|
func cmov32bit(x, y uint32) uint32 {
|
|
if x < y {
|
|
x = -y
|
|
}
|
|
// amd64:"CMOVL(HI|CS)"
|
|
// arm64:"CSNEG\t(LS|HS)"
|
|
// ppc64x:"ISEL\t[$]1"
|
|
// wasm:"Select"
|
|
return x
|
|
}
|
|
|
|
func cmov16bit(x, y uint16) uint16 {
|
|
if x < y {
|
|
x = -y
|
|
}
|
|
// amd64:"CMOVW(HI|CS)"
|
|
// arm64:"CSNEG\t(LS|HS)"
|
|
// ppc64x:"ISEL\t[$][01]"
|
|
// wasm:"Select"
|
|
return x
|
|
}
|
|
|
|
// Floating point comparison. For EQ/NE, we must
|
|
// generate special code to handle NaNs.
|
|
func cmovfloateq(x, y float64) int {
|
|
a := 128
|
|
if x == y {
|
|
a = 256
|
|
}
|
|
// amd64:"CMOVQNE","CMOVQPC"
|
|
// arm64:"CSEL\tEQ"
|
|
// ppc64x:"ISEL\t[$]2"
|
|
// wasm:"Select"
|
|
return a
|
|
}
|
|
|
|
func cmovfloatne(x, y float64) int {
|
|
a := 128
|
|
if x != y {
|
|
a = 256
|
|
}
|
|
// amd64:"CMOVQNE","CMOVQPS"
|
|
// arm64:"CSEL\tNE"
|
|
// ppc64x:"ISEL\t[$]2"
|
|
// wasm:"Select"
|
|
return a
|
|
}
|
|
|
|
//go:noinline
|
|
func frexp(f float64) (frac float64, exp int) {
|
|
return 1.0, 4
|
|
}
|
|
|
|
//go:noinline
|
|
func ldexp(frac float64, exp int) float64 {
|
|
return 1.0
|
|
}
|
|
|
|
// Generate a CMOV with a floating comparison and integer move.
|
|
func cmovfloatint2(x, y float64) float64 {
|
|
yfr, yexp := 4.0, 5
|
|
|
|
r := x
|
|
for r >= y {
|
|
rfr, rexp := frexp(r)
|
|
if rfr < yfr {
|
|
rexp = rexp - 1
|
|
}
|
|
// amd64:"CMOVQHI"
|
|
// arm64:"CSEL\tMI"
|
|
// ppc64x:"ISEL\t[$]0"
|
|
// wasm:"Select"
|
|
r = r - ldexp(y, rexp-yexp)
|
|
}
|
|
return r
|
|
}
|
|
|
|
func cmovloaded(x [4]int, y int) int {
|
|
if x[2] != 0 {
|
|
y = x[2]
|
|
} else {
|
|
y = y >> 2
|
|
}
|
|
// amd64:"CMOVQNE"
|
|
// arm64:"CSEL\tNE"
|
|
// ppc64x:"ISEL\t[$]2"
|
|
// wasm:"Select"
|
|
return y
|
|
}
|
|
|
|
func cmovuintptr2(x, y uintptr) uintptr {
|
|
a := x * 2
|
|
if a == 0 {
|
|
a = 256
|
|
}
|
|
// amd64:"CMOVQEQ"
|
|
// arm64:"CSEL\tEQ"
|
|
// ppc64x:"ISEL\t[$]2"
|
|
// wasm:"Select"
|
|
return a
|
|
}
|
|
|
|
// Floating point CMOVs are not supported by amd64/arm64/ppc64x
|
|
func cmovfloatmove(x, y int) float64 {
|
|
a := 1.0
|
|
if x <= y {
|
|
a = 2.0
|
|
}
|
|
// amd64:-"CMOV"
|
|
// arm64:-"CSEL"
|
|
// ppc64x:-"ISEL"
|
|
// wasm:-"Select"
|
|
return a
|
|
}
|
|
|
|
// On amd64, the following patterns trigger comparison inversion.
|
|
// Test that we correctly invert the CMOV condition
|
|
var gsink int64
|
|
var gusink uint64
|
|
|
|
func cmovinvert1(x, y int64) int64 {
|
|
if x < gsink {
|
|
y = -y
|
|
}
|
|
// amd64:"CMOVQGT"
|
|
return y
|
|
}
|
|
func cmovinvert2(x, y int64) int64 {
|
|
if x <= gsink {
|
|
y = -y
|
|
}
|
|
// amd64:"CMOVQGE"
|
|
return y
|
|
}
|
|
func cmovinvert3(x, y int64) int64 {
|
|
if x == gsink {
|
|
y = -y
|
|
}
|
|
// amd64:"CMOVQEQ"
|
|
return y
|
|
}
|
|
func cmovinvert4(x, y int64) int64 {
|
|
if x != gsink {
|
|
y = -y
|
|
}
|
|
// amd64:"CMOVQNE"
|
|
return y
|
|
}
|
|
func cmovinvert5(x, y uint64) uint64 {
|
|
if x > gusink {
|
|
y = -y
|
|
}
|
|
// amd64:"CMOVQCS"
|
|
return y
|
|
}
|
|
func cmovinvert6(x, y uint64) uint64 {
|
|
if x >= gusink {
|
|
y = -y
|
|
}
|
|
// amd64:"CMOVQLS"
|
|
return y
|
|
}
|
|
|
|
func cmovload(a []int, i int, b bool) int {
|
|
if b {
|
|
i++
|
|
}
|
|
// See issue 26306
|
|
// amd64:-"CMOVQNE"
|
|
return a[i]
|
|
}
|
|
|
|
func cmovstore(a []int, i int, b bool) {
|
|
if b {
|
|
i++
|
|
}
|
|
// amd64:"CMOVQNE"
|
|
a[i] = 7
|
|
}
|
|
|
|
var r0, r1, r2, r3, r4, r5 int
|
|
|
|
func cmovinc(cond bool, a, b, c int) {
|
|
var x0, x1 int
|
|
|
|
if cond {
|
|
x0 = a
|
|
} else {
|
|
x0 = b + 1
|
|
}
|
|
// arm64:"CSINC\tNE", -"CSEL"
|
|
r0 = x0
|
|
|
|
if cond {
|
|
x1 = b + 1
|
|
} else {
|
|
x1 = a
|
|
}
|
|
// arm64:"CSINC\tEQ", -"CSEL"
|
|
r1 = x1
|
|
|
|
if cond {
|
|
c++
|
|
}
|
|
// arm64:"CSINC\tEQ", -"CSEL"
|
|
r2 = c
|
|
}
|
|
|
|
func cmovinv(cond bool, a, b int) {
|
|
var x0, x1 int
|
|
|
|
if cond {
|
|
x0 = a
|
|
} else {
|
|
x0 = ^b
|
|
}
|
|
// arm64:"CSINV\tNE", -"CSEL"
|
|
r0 = x0
|
|
|
|
if cond {
|
|
x1 = ^b
|
|
} else {
|
|
x1 = a
|
|
}
|
|
// arm64:"CSINV\tEQ", -"CSEL"
|
|
r1 = x1
|
|
}
|
|
|
|
func cmovneg(cond bool, a, b, c int) {
|
|
var x0, x1 int
|
|
|
|
if cond {
|
|
x0 = a
|
|
} else {
|
|
x0 = -b
|
|
}
|
|
// arm64:"CSNEG\tNE", -"CSEL"
|
|
r0 = x0
|
|
|
|
if cond {
|
|
x1 = -b
|
|
} else {
|
|
x1 = a
|
|
}
|
|
// arm64:"CSNEG\tEQ", -"CSEL"
|
|
r1 = x1
|
|
}
|
|
|
|
func cmovsetm(cond bool, x int) {
|
|
var x0, x1 int
|
|
|
|
if cond {
|
|
x0 = -1
|
|
} else {
|
|
x0 = 0
|
|
}
|
|
// arm64:"CSETM\tNE", -"CSEL"
|
|
r0 = x0
|
|
|
|
if cond {
|
|
x1 = 0
|
|
} else {
|
|
x1 = -1
|
|
}
|
|
// arm64:"CSETM\tEQ", -"CSEL"
|
|
r1 = x1
|
|
}
|
|
|
|
func cmovFcmp0(s, t float64, a, b int) {
|
|
var x0, x1, x2, x3, x4, x5 int
|
|
|
|
if s < t {
|
|
x0 = a
|
|
} else {
|
|
x0 = b + 1
|
|
}
|
|
// arm64:"CSINC\tMI", -"CSEL"
|
|
r0 = x0
|
|
|
|
if s <= t {
|
|
x1 = a
|
|
} else {
|
|
x1 = ^b
|
|
}
|
|
// arm64:"CSINV\tLS", -"CSEL"
|
|
r1 = x1
|
|
|
|
if s > t {
|
|
x2 = a
|
|
} else {
|
|
x2 = -b
|
|
}
|
|
// arm64:"CSNEG\tMI", -"CSEL"
|
|
r2 = x2
|
|
|
|
if s >= t {
|
|
x3 = -1
|
|
} else {
|
|
x3 = 0
|
|
}
|
|
// arm64:"CSETM\tLS", -"CSEL"
|
|
r3 = x3
|
|
|
|
if s == t {
|
|
x4 = a
|
|
} else {
|
|
x4 = b + 1
|
|
}
|
|
// arm64:"CSINC\tEQ", -"CSEL"
|
|
r4 = x4
|
|
|
|
if s != t {
|
|
x5 = a
|
|
} else {
|
|
x5 = b + 1
|
|
}
|
|
// arm64:"CSINC\tNE", -"CSEL"
|
|
r5 = x5
|
|
}
|
|
|
|
func cmovFcmp1(s, t float64, a, b int) {
|
|
var x0, x1, x2, x3, x4, x5 int
|
|
|
|
if s < t {
|
|
x0 = b + 1
|
|
} else {
|
|
x0 = a
|
|
}
|
|
// arm64:"CSINC\tPL", -"CSEL"
|
|
r0 = x0
|
|
|
|
if s <= t {
|
|
x1 = ^b
|
|
} else {
|
|
x1 = a
|
|
}
|
|
// arm64:"CSINV\tHI", -"CSEL"
|
|
r1 = x1
|
|
|
|
if s > t {
|
|
x2 = -b
|
|
} else {
|
|
x2 = a
|
|
}
|
|
// arm64:"CSNEG\tPL", -"CSEL"
|
|
r2 = x2
|
|
|
|
if s >= t {
|
|
x3 = 0
|
|
} else {
|
|
x3 = -1
|
|
}
|
|
// arm64:"CSETM\tHI", -"CSEL"
|
|
r3 = x3
|
|
|
|
if s == t {
|
|
x4 = b + 1
|
|
} else {
|
|
x4 = a
|
|
}
|
|
// arm64:"CSINC\tNE", -"CSEL"
|
|
r4 = x4
|
|
|
|
if s != t {
|
|
x5 = b + 1
|
|
} else {
|
|
x5 = a
|
|
}
|
|
// arm64:"CSINC\tEQ", -"CSEL"
|
|
r5 = x5
|
|
}
|
|
|
|
func cmovzero1(c bool) int {
|
|
var x int
|
|
if c {
|
|
x = 182
|
|
}
|
|
// loong64:"MASKEQZ", -"MASKNEZ"
|
|
return x
|
|
}
|
|
|
|
func cmovzero2(c bool) int {
|
|
var x int
|
|
if !c {
|
|
x = 182
|
|
}
|
|
// loong64:"MASKNEZ", -"MASKEQZ"
|
|
return x
|
|
}
|
|
|
|
// Conditionally selecting between a value or 0 can be done without
|
|
// an extra load of 0 to a register on PPC64 by using R0 (which always
|
|
// holds the value $0) instead. Verify both cases where either arg1
|
|
// or arg2 is zero.
|
|
func cmovzeroreg0(a, b int) int {
|
|
x := 0
|
|
if a == b {
|
|
x = a
|
|
}
|
|
// ppc64x:"ISEL\t[$]2, R[0-9]+, R0, R[0-9]+"
|
|
return x
|
|
}
|
|
|
|
func cmovzeroreg1(a, b int) int {
|
|
x := a
|
|
if a == b {
|
|
x = 0
|
|
}
|
|
// ppc64x:"ISEL\t[$]2, R0, R[0-9]+, R[0-9]+"
|
|
return x
|
|
}
|