blob: 6f9001732e8f5095d222f147a6e88346293687c9 [file] [edit]
// errorcheck -0 -d=ssa/decompose_addr/debug=1
// Copyright 2026 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.
// Test for variables that can be decomposed by the decomposeAddr pass.
package main
import "unsafe"
type point struct {
x, y int
}
func simpleStruct(c bool) int {
p := point{10, 20} // ERROR "promoted p"
ptr := &p
if c {
ptr.x += 1
} else {
ptr.y += 1
}
return ptr.x + ptr.y
}
type inner struct {
a, b int
}
type outer struct {
in inner
c int
}
func nestedStruct(c bool) int {
o := outer{inner{1, 2}, 3} // ERROR "promoted o"
ptr := &o
if c {
ptr.in.a += 10
} else {
ptr.in.b += 20
}
return ptr.in.a + ptr.in.b + ptr.c
}
func array(c bool) int {
var a [3]int // ERROR "promoted a"
pa := &a
pa[0] = 10
pa[1] = 20
pa[2] = 30
if c {
pa[1] += 5
}
return pa[0] + pa[1] + pa[2]
}
func zeroStruct(c bool) int {
var p point // ERROR "promoted p"
ptr := &p
if c {
ptr.x = 10
} else {
ptr.y = 20
}
return ptr.x + ptr.y
}
func moveStruct(x, y int, c bool) int {
p1 := point{x, y} // ERROR "promoted p1"
var p2 point // ERROR "promoted p2"
ptr1 := &p1
ptr2 := &p2
if c {
*ptr2 = *ptr1
} else {
*ptr2 = point{30, 40}
}
return ptr2.x + ptr2.y + ptr1.x
}
type arrayStruct struct {
a [2]int
b int
}
func arrayStructAddr(c bool) int {
s := arrayStruct{[2]int{1, 2}, 3} // ERROR "promoted s"
ps := &s
if c {
ps.a[0] += 10
} else {
ps.b += 20
}
return ps.a[0] + ps.a[1] + ps.b
}
func partialZero() int {
type T struct {
a int
b [2]int
c int
}
t := T{a: 9, c: 9} // ERROR "promoted t"
p := &t.b // OffPtr
*p = [2]int{} // Zero
return t.a
}
func partialMove() int {
type T struct {
a int
b [2]int
c int
}
b2 := [2]int{1, 2} // ERROR "promoted b2"
t := T{a: 9, c: 9} // ERROR "promoted t"
p := &t.b // OffPtr
*p = b2 // Move
return t.a
}
type bigStruct struct {
a, b, c, d, e int
f [30]int
g, h, i, j, k int
}
func partialActiveBigStruct(branch bool) {
// branch is used to fool opt.
var x, y bigStruct // ERROR "promoted x"
xp := &x
yp := &y
if branch {
xp.a = 1
xp.b = 2
} else {
xp.a = 4
xp.b = 5
}
xp.f = [30]int{3, 4}
xp.c = xp.a + xp.b // 2 leaves of x are active
if branch {
yp.c = 1
yp.d = 2
yp.e = 3
yp.f[5] = 4
yp.g = 5
} else {
yp.c = 4
yp.d = 5
yp.e = 6
yp.f[5] = 7
yp.g = 8
}
yp.h = yp.c + yp.d + yp.e + yp.f[5] + yp.g // 5 leaves of y are used
}
// x looks at the Move first and would rule y out (y's leaves do not line
// up with x's), but x then gives up on itself because of the 2-byte read
// that load forwarding created on it. Giving up must also take back the
// verdict on y: y is then free to break the Move down by its own leaves.
func unsafeAliasMoveOrder(c bool) int {
var x [4]byte
x[0], x[1], x[2], x[3] = 1, 2, 3, 4
var y [2]uint16 // ERROR "promoted y"
y = *(*[2]uint16)(unsafe.Pointer(&x))
if c {
y[0]++
}
return int(y[0]) + int(y[1])
}
type paddedA struct {
a uint8
b, c, d, e, f uint32
}
type paddedB struct {
x, y uint8
b, c, d, e, f uint32
}
// a looks at the Move first. Every leaf of a lines up with a leaf of b,
// but b has a leaf (y) where a only has padding, so a breakdown of the
// Move by a's leaves would never write b.y. The Move must cover exactly
// the same leaves on both sides for both to be decomposed, so b is ruled
// out and stays in memory.
func unsafeAliasMovePadding(v uint8, c bool) (uint8, uint32) {
var a paddedA // ERROR "promoted a"
a.a = v
a.b, a.c = 1, 2
var b paddedB
b.x, b.y = 7, 9
b = *(*paddedB)(unsafe.Pointer(&a))
b.b++
if c {
b.c++
}
return b.y, b.b + b.c
}
type stringStruct struct {
s string
i int
}
func stringField(c bool) int {
// The string field splits into a pointer leaf and a length leaf.
ss := stringStruct{"hello", 10} // ERROR "promoted ss"
p := &ss
if c {
p.i += 5
}
return len(p.s) + p.i
}
type sliceStruct struct {
sl []int
i int
}
func sliceField(c bool, sl []int) int {
// The slice field splits into ptr/len/cap leaves.
ss := sliceStruct{sl, 10} // ERROR "promoted ss"
p := &ss
if c {
p.i += 5
}
return len(p.sl) + cap(p.sl) + p.i
}
type ifaceStruct struct {
e any
i int
}
func ifaceField(c bool, e any) int {
// The interface field splits into a type word and a data word.
is := ifaceStruct{e, 10} // ERROR "promoted is"
p := &is
if c {
p.i += 5
}
if p.e != nil {
p.i++
}
return p.i
}
type complexStruct struct {
z complex64
i int
}
func complexField(c bool) float32 {
// The complex field splits into two float leaves. complex64 rather
// than complex128 so the float leaves fit in a register on 32-bit
// platforms too.
cs := complexStruct{complex(3, 4), 10} // ERROR "promoted cs"
p := &cs
if c {
p.i += 5
}
return real(p.z) + imag(p.z) + float32(p.i)
}
func main() {}