Subversion Repositories openrisc

// $G $D/$F.go && $L $F.$A && ./$A.out

// Copyright 2009 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 main

// check for correct heap-moving of escaped variables.
// it is hard to check for the allocations, but it is easy
// to check that if you call the function twice at the
// same stack level, the pointers returned should be
// different.

var bad = false

var allptr = make([]*int, 0, 100)

func noalias(p, q *int, s string) {
        n := len(allptr)
        *p = -(n+1)
        *q = -(n+2)
        allptr = allptr[0:n+2]
        allptr[n] = p
        allptr[n+1] = q
        n += 2
        for i := 0; i < n; i++ {
                if allptr[i] != nil && *allptr[i] != -(i+1) {
                        println("aliased pointers", -(i+1), *allptr[i], "after", s)
                        allptr[i] = nil
                        bad = true
                }
        }
}

func val(p, q *int, v int, s string) {
        if *p != v {
                println("wrong value want", v, "got", *p, "after", s)
                bad = true
        }
        if *q != v+1 {
                println("wrong value want", v+1, "got", *q, "after", s)
                bad = true
        }
}

func chk(p, q *int, v int, s string) {
        val(p, q, v, s)
        noalias(p, q, s)
}

func chkalias(p, q *int, v int, s string) {
        if p != q {
                println("want aliased pointers but got different after", s)
        }
        if *q != v+1 {
                println("wrong value want", v+1, "got", *q, "after", s)
        }
}

func i_escapes(x int) *int {
        var i int
        i = x
        return &i
}

func j_escapes(x int) *int {
        var j int = x
        j = x
        return &j
}

func k_escapes(x int) *int {
        k := x
        return &k
}

func in_escapes(x int) *int {
        return &x
}

func send(c chan int, x int) {
        c <- x
}

func select_escapes(x int) *int {
        c := make(chan int)
        go send(c, x)
        select {
        case req := <-c:
                return &req
        }
        return nil
}

func select_escapes1(x int, y int) (*int, *int) {
        c := make(chan int)
        var a [2]int
        var p [2]*int
        a[0] = x
        a[1] = y
        for i := 0; i < 2; i++ {
                go send(c, a[i])
                select {
                case req := <-c:
                        p[i] = &req
                }
        }
        return p[0], p[1]
}

func range_escapes(x int) *int {
        var a [1]int
        a[0] = x
        for _, v := range a {
                return &v
        }
        return nil
}

// *is* aliased
func range_escapes2(x, y int) (*int, *int) {
        var a [2]int
        var p [2]*int
        a[0] = x
        a[1] = y
        for k, v := range a {
                p[k] = &v
        }
        return p[0], p[1]
}

// *is* aliased
func for_escapes2(x int, y int) (*int, *int) {
        var p [2]*int
        n := 0
        for i := x; n < 2; i = y {
                p[n] = &i
                n++
        }
        return p[0], p[1]
}

func out_escapes(i int) (x int, p *int) {
        x = i
        p = &x  // ERROR "address of out parameter"
        return
}

func out_escapes_2(i int) (x int, p *int) {
        x = i
        return x, &x    // ERROR "address of out parameter"
}

func defer1(i int) (x int) {
        c := make(chan int)
        go func() { x = i; c <- 1 }()
        <-c
        return
}

func main() {
        p, q := i_escapes(1), i_escapes(2)
        chk(p, q, 1, "i_escapes")

        p, q = j_escapes(3), j_escapes(4)
        chk(p, q, 3, "j_escapes")

        p, q = k_escapes(5), k_escapes(6)
        chk(p, q, 5, "k_escapes")

        p, q = in_escapes(7), in_escapes(8)
        chk(p, q, 7, "in_escapes")

        p, q = select_escapes(9), select_escapes(10)
        chk(p, q, 9, "select_escapes")

        p, q = select_escapes1(11, 12)
        chk(p, q, 11, "select_escapes1")

        p, q = range_escapes(13), range_escapes(14)
        chk(p, q, 13, "range_escapes")

        p, q = range_escapes2(101, 102)
        chkalias(p, q, 101, "range_escapes2")

        p, q = for_escapes2(103, 104)
        chkalias(p, q, 103, "for_escapes2")

        _, p = out_escapes(15)
        _, q = out_escapes(16)
        chk(p, q, 15, "out_escapes")

        _, p = out_escapes_2(17)
        _, q = out_escapes_2(18)
        chk(p, q, 17, "out_escapes_2")

        x := defer1(20)
        if x != 20 {
                println("defer failed", x)
                bad = true
        }

        if bad {
                panic("BUG: no escape")
        }
}