test/index.go - go.git - Git at Google

 // skip

 // Copyright 2010 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.

 // Generate test of index and slice bounds checks.
 // The actual tests are index0.go, index1.go, index2.go.

 package main

 import (
 	"bufio"
 	"fmt"
 	"os"
 	"unsafe"
 )

 const prolog = `

 package main

 import (
 	"runtime"
 )

 type quad struct { x, y, z, w int }

 const (
 	cj = 100011
 	ci int = 100012
 	ci8 int8 = 115
 	ci16 int16 = 10016
 	ci32 int32 = 100013
 	ci64 int64 = 100014
 	ci64big int64 = 1<<31
 	ci64bigger int64 = 1<<32
 	chuge = 1<<100
 	cfgood = 2.0
 	cfbad = 2.1

 	cnj = -2
 	cni int = -3
 	cni8 int8 = -6
 	cni16 int16 = -7
 	cni32 int32 = -4
 	cni64 int64 = -5
 	cni64big int64 = -1<<31
 	cni64bigger int64 = -1<<32
 	cnhuge = -1<<100
 	cnfgood = -2.0
 	cnfbad = -2.1
 )

 var j int = 100020
 var i int = 100021
 var i8 int8 = 126
 var i16 int16 = 10025
 var i32 int32 = 100022
 var i64 int64 = 100023
 var i64big int64 = 1<<31
 var i64bigger int64 = 1<<32
 var huge uint64 = 1<<64 - 1
 var fgood float64 = 2.0
 var fbad float64 = 2.1

 var nj int = -10
 var ni int = -11
 var ni8 int8 = -14
 var ni16 int16 = -15
 var ni32 int32 = -12
 var ni64 int64 = -13
 var ni64big int64 = -1<<31
 var ni64bigger int64 = -1<<32
 var nhuge int64 = -1<<63
 var nfgood float64 = -2.0
 var nfbad float64 = -2.1

 var si []int = make([]int, 10)
 var ai [10]int
 var pai *[10]int = &ai

 var sq []quad = make([]quad, 10)
 var aq [10]quad
 var paq *[10]quad = &aq

 var sib []int = make([]int, 100000)
 var aib [100000]int
 var paib *[100000]int = &aib

 var sqb []quad = make([]quad, 100000)
 var aqb [100000]quad
 var paqb *[100000]quad = &aqb

 type T struct {
 	si []int
 	ai [10]int
 	pai *[10]int
 	sq []quad
 	aq [10]quad
 	paq *[10]quad

 	sib []int
 	aib [100000]int
 	paib *[100000]int
 	sqb []quad
 	aqb [100000]quad
 	paqb *[100000]quad
 }

 var t = T{si, ai, pai, sq, aq, paq, sib, aib, paib, sqb, aqb, paqb}

 var pt = &T{si, ai, pai, sq, aq, paq, sib, aib, paib, sqb, aqb, paqb}

 // test that f panics
 func test(f func(), s string) {
 	defer func() {
 		if err := recover(); err == nil {
 			_, file, line, _ := runtime.Caller(2)
 			bug()
 			print(file, ":", line, ": ", s, " did not panic\n")
 		} else if !contains(err.(error).Error(), "out of range") {
 			_, file, line, _ := runtime.Caller(2)
 			bug()
 			print(file, ":", line, ": ", s, " unexpected panic: ", err.(error).Error(), "\n")
 		}
 	}()
 	f()
 }

 func contains(x, y string) bool {
 	for i := 0; i+len(y) <= len(x); i++ {
 		if x[i:i+len(y)] == y {
 			return true
 		}
 	}
 	return false
 }


 var X interface{}
 func use(y interface{}) {
 	X = y
 }

 var didBug = false

 func bug() {
 	if !didBug {
 		didBug = true
 		println("BUG")
 	}
 }

 func main() {
 `

 // pass variable set in index[012].go
 //	0 - dynamic checks
 //	1 - static checks of invalid constants (cannot assign to types)
 //	2 - static checks of array bounds

 func testExpr(b *bufio.Writer, expr string) {
 	if pass == 0 {
 		fmt.Fprintf(b, "\ttest(func(){use(%s)}, %q)\n", expr, expr)
 	} else {
 		fmt.Fprintf(b, "\tuse(%s)  // ERROR \"index|overflow|truncated|must be integer\"\n", expr)
 	}
 }

 func main() {
 	b := bufio.NewWriter(os.Stdout)

 	if pass == 0 {
 		fmt.Fprint(b, "// run\n\n")
 	} else {
 		fmt.Fprint(b, "// errorcheck\n\n")
 	}
 	fmt.Fprint(b, prolog)

 	var choices = [][]string{
 		// Direct value, fetch from struct, fetch from struct pointer.
 		// The last two cases get us to oindex_const_sudo in gsubr.c.
 		[]string{"", "t.", "pt."},

 		// Array, pointer to array, slice.
 		[]string{"a", "pa", "s"},

 		// Element is int, element is quad (struct).
 		// This controls whether we end up in gsubr.c (i) or cgen.c (q).
 		[]string{"i", "q"},

 		// Small or big len.
 		[]string{"", "b"},

 		// Variable or constant.
 		[]string{"", "c"},

 		// Positive or negative.
 		[]string{"", "n"},

 		// Size of index.
 		[]string{"j", "i", "i8", "i16", "i32", "i64", "i64big", "i64bigger", "huge", "fgood", "fbad"},
 	}

 	forall(choices, func(x []string) {
 		p, a, e, big, c, n, i := x[0], x[1], x[2], x[3], x[4], x[5], x[6]

 		// Pass: dynamic=0, static=1, 2.
 		// Which cases should be caught statically?
 		// Only constants, obviously.
 		// Beyond that, must be one of these:
 		//	indexing into array or pointer to array
 		//	negative constant
 		//	large constant
 		thisPass := 0
 		if c == "c" && (a == "a" || a == "pa" || n == "n" || i == "i64big" || i == "i64bigger" || i == "huge" || i == "fbad") {
 			if i == "huge" {
 				// Due to a detail of gc's internals,
 				// the huge constant errors happen in an
 				// earlier pass than the others and inhibits
 				// the next pass from running.
 				// So run it as a separate check.
 				thisPass = 1
 			} else if a == "s" && n == "" && (i == "i64big" || i == "i64bigger") && unsafe.Sizeof(int(0)) > 4 {
 				// If int is 64 bits, these huge
 				// numbers do fit in an int, so they
 				// are not rejected at compile time.
 				thisPass = 0
 			} else {
 				thisPass = 2
 			}
 		}

 		pae := p + a + e + big
 		cni := c + n + i

 		// If we're using the big-len data, positive int8 and int16 cannot overflow.
 		if big == "b" && n == "" && (i == "i8" || i == "i16") {
 			if pass == 0 {
 				fmt.Fprintf(b, "\tuse(%s[%s])\n", pae, cni)
 				fmt.Fprintf(b, "\tuse(%s[0:%s])\n", pae, cni)
 				fmt.Fprintf(b, "\tuse(%s[1:%s])\n", pae, cni)
 				fmt.Fprintf(b, "\tuse(%s[%s:])\n", pae, cni)
 				fmt.Fprintf(b, "\tuse(%s[%s:%s])\n", pae, cni, cni)
 			}
 			return
 		}

 		// Float variables cannot be used as indices.
 		if c == "" && (i == "fgood" || i == "fbad") {
 			return
 		}
 		// Integral float constant is ok.
 		if c == "c" && n == "" && i == "fgood" {
 			if pass == 0 {
 				fmt.Fprintf(b, "\tuse(%s[%s])\n", pae, cni)
 				fmt.Fprintf(b, "\tuse(%s[0:%s])\n", pae, cni)
 				fmt.Fprintf(b, "\tuse(%s[1:%s])\n", pae, cni)
 				fmt.Fprintf(b, "\tuse(%s[%s:])\n", pae, cni)
 				fmt.Fprintf(b, "\tuse(%s[%s:%s])\n", pae, cni, cni)
 			}
 			return
 		}

 		// Only print the test case if it is appropriate for this pass.
 		if thisPass == pass {
 			// Index operation
 			testExpr(b, pae+"["+cni+"]")

 			// Slice operation.
 			// Low index 0 is a special case in ggen.c
 			// so test both 0 and 1.
 			testExpr(b, pae+"[0:"+cni+"]")
 			testExpr(b, pae+"[1:"+cni+"]")
 			testExpr(b, pae+"["+cni+":]")
 			testExpr(b, pae+"["+cni+":"+cni+"]")
 		}
 	})

 	fmt.Fprintln(b, "}")
 	b.Flush()
 }

 func forall(choices [][]string, f func([]string)) {
 	x := make([]string, len(choices))

 	var recurse func(d int)
 	recurse = func(d int) {
 		if d >= len(choices) {
 			f(x)
 			return
 		}
 		for _, x[d] = range choices[d] {
 			recurse(d + 1)
 		}
 	}
 	recurse(0)
 }
	// skip

	// Copyright 2010 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.

	// Generate test of index and slice bounds checks.
	// The actual tests are index0.go, index1.go, index2.go.

	package main

	import (
	"bufio"
	"fmt"
	"os"
	"unsafe"
	)

	const prolog = `

	package main

	import (
	"runtime"
	)

	type quad struct { x, y, z, w int }

	const (
	cj = 100011
	ci int = 100012
	ci8 int8 = 115
	ci16 int16 = 10016
	ci32 int32 = 100013
	ci64 int64 = 100014
	ci64big int64 = 1<<31
	ci64bigger int64 = 1<<32
	chuge = 1<<100
	cfgood = 2.0
	cfbad = 2.1

	cnj = -2
	cni int = -3
	cni8 int8 = -6
	cni16 int16 = -7
	cni32 int32 = -4
	cni64 int64 = -5
	cni64big int64 = -1<<31
	cni64bigger int64 = -1<<32
	cnhuge = -1<<100
	cnfgood = -2.0
	cnfbad = -2.1
	)

	var j int = 100020
	var i int = 100021
	var i8 int8 = 126
	var i16 int16 = 10025
	var i32 int32 = 100022
	var i64 int64 = 100023
	var i64big int64 = 1<<31
	var i64bigger int64 = 1<<32
	var huge uint64 = 1<<64 - 1
	var fgood float64 = 2.0
	var fbad float64 = 2.1

	var nj int = -10
	var ni int = -11
	var ni8 int8 = -14
	var ni16 int16 = -15
	var ni32 int32 = -12
	var ni64 int64 = -13
	var ni64big int64 = -1<<31
	var ni64bigger int64 = -1<<32
	var nhuge int64 = -1<<63
	var nfgood float64 = -2.0
	var nfbad float64 = -2.1

	var si []int = make([]int, 10)
	var ai [10]int
	var pai *[10]int = &ai

	var sq []quad = make([]quad, 10)
	var aq [10]quad
	var paq *[10]quad = &aq

	var sib []int = make([]int, 100000)
	var aib [100000]int
	var paib *[100000]int = &aib

	var sqb []quad = make([]quad, 100000)
	var aqb [100000]quad
	var paqb *[100000]quad = &aqb

	type T struct {
	si []int
	ai [10]int
	pai *[10]int
	sq []quad
	aq [10]quad
	paq *[10]quad

	sib []int
	aib [100000]int
	paib *[100000]int
	sqb []quad
	aqb [100000]quad
	paqb *[100000]quad
	}

	var t = T{si, ai, pai, sq, aq, paq, sib, aib, paib, sqb, aqb, paqb}

	var pt = &T{si, ai, pai, sq, aq, paq, sib, aib, paib, sqb, aqb, paqb}

	// test that f panics
	func test(f func(), s string) {
	defer func() {
	if err := recover(); err == nil {
	_, file, line, _ := runtime.Caller(2)
	bug()
	print(file, ":", line, ": ", s, " did not panic\n")
	} else if !contains(err.(error).Error(), "out of range") {
	_, file, line, _ := runtime.Caller(2)
	bug()
	print(file, ":", line, ": ", s, " unexpected panic: ", err.(error).Error(), "\n")
	}
	}()
	f()
	}

	func contains(x, y string) bool {
	for i := 0; i+len(y) <= len(x); i++ {
	if x[i:i+len(y)] == y {
	return true
	}
	}
	return false
	}


	var X interface{}
	func use(y interface{}) {
	X = y
	}

	var didBug = false

	func bug() {
	if !didBug {
	didBug = true
	println("BUG")
	}
	}

	func main() {
	`

	// pass variable set in index[012].go
	// 0 - dynamic checks
	// 1 - static checks of invalid constants (cannot assign to types)
	// 2 - static checks of array bounds

	func testExpr(b *bufio.Writer, expr string) {
	if pass == 0 {
	fmt.Fprintf(b, "\ttest(func(){use(%s)}, %q)\n", expr, expr)
	} else {
	fmt.Fprintf(b, "\tuse(%s) // ERROR \"index\|overflow\|truncated\|must be integer\"\n", expr)
	}
	}

	func main() {
	b := bufio.NewWriter(os.Stdout)

	if pass == 0 {
	fmt.Fprint(b, "// run\n\n")
	} else {
	fmt.Fprint(b, "// errorcheck\n\n")
	}
	fmt.Fprint(b, prolog)

	var choices = [][]string{
	// Direct value, fetch from struct, fetch from struct pointer.
	// The last two cases get us to oindex_const_sudo in gsubr.c.
	[]string{"", "t.", "pt."},

	// Array, pointer to array, slice.
	[]string{"a", "pa", "s"},

	// Element is int, element is quad (struct).
	// This controls whether we end up in gsubr.c (i) or cgen.c (q).
	[]string{"i", "q"},

	// Small or big len.
	[]string{"", "b"},

	// Variable or constant.
	[]string{"", "c"},

	// Positive or negative.
	[]string{"", "n"},

	// Size of index.
	[]string{"j", "i", "i8", "i16", "i32", "i64", "i64big", "i64bigger", "huge", "fgood", "fbad"},
	}

	forall(choices, func(x []string) {
	p, a, e, big, c, n, i := x[0], x[1], x[2], x[3], x[4], x[5], x[6]

	// Pass: dynamic=0, static=1, 2.
	// Which cases should be caught statically?
	// Only constants, obviously.
	// Beyond that, must be one of these:
	// indexing into array or pointer to array
	// negative constant
	// large constant
	thisPass := 0
	if c == "c" && (a == "a" \|\| a == "pa" \|\| n == "n" \|\| i == "i64big" \|\| i == "i64bigger" \|\| i == "huge" \|\| i == "fbad") {
	if i == "huge" {
	// Due to a detail of gc's internals,
	// the huge constant errors happen in an
	// earlier pass than the others and inhibits
	// the next pass from running.
	// So run it as a separate check.
	thisPass = 1
	} else if a == "s" && n == "" && (i == "i64big" \|\| i == "i64bigger") && unsafe.Sizeof(int(0)) > 4 {
	// If int is 64 bits, these huge
	// numbers do fit in an int, so they
	// are not rejected at compile time.
	thisPass = 0
	} else {
	thisPass = 2
	}
	}

	pae := p + a + e + big
	cni := c + n + i

	// If we're using the big-len data, positive int8 and int16 cannot overflow.
	if big == "b" && n == "" && (i == "i8" \|\| i == "i16") {
	if pass == 0 {
	fmt.Fprintf(b, "\tuse(%s[%s])\n", pae, cni)
	fmt.Fprintf(b, "\tuse(%s[0:%s])\n", pae, cni)
	fmt.Fprintf(b, "\tuse(%s[1:%s])\n", pae, cni)
	fmt.Fprintf(b, "\tuse(%s[%s:])\n", pae, cni)
	fmt.Fprintf(b, "\tuse(%s[%s:%s])\n", pae, cni, cni)
	}
	return
	}

	// Float variables cannot be used as indices.
	if c == "" && (i == "fgood" \|\| i == "fbad") {
	return
	}
	// Integral float constant is ok.
	if c == "c" && n == "" && i == "fgood" {
	if pass == 0 {
	fmt.Fprintf(b, "\tuse(%s[%s])\n", pae, cni)
	fmt.Fprintf(b, "\tuse(%s[0:%s])\n", pae, cni)
	fmt.Fprintf(b, "\tuse(%s[1:%s])\n", pae, cni)
	fmt.Fprintf(b, "\tuse(%s[%s:])\n", pae, cni)
	fmt.Fprintf(b, "\tuse(%s[%s:%s])\n", pae, cni, cni)
	}
	return
	}

	// Only print the test case if it is appropriate for this pass.
	if thisPass == pass {
	// Index operation
	testExpr(b, pae+"["+cni+"]")

	// Slice operation.
	// Low index 0 is a special case in ggen.c
	// so test both 0 and 1.
	testExpr(b, pae+"[0:"+cni+"]")
	testExpr(b, pae+"[1:"+cni+"]")
	testExpr(b, pae+"["+cni+":]")
	testExpr(b, pae+"["+cni+":"+cni+"]")
	}
	})

	fmt.Fprintln(b, "}")
	b.Flush()
	}

	func forall(choices [][]string, f func([]string)) {
	x := make([]string, len(choices))

	var recurse func(d int)
	recurse = func(d int) {
	if d >= len(choices) {
	f(x)
	return
	}
	for _, x[d] = range choices[d] {
	recurse(d + 1)
	}
	}
	recurse(0)
	}