コード例 #1
0
ファイル: sgfdb.go プロジェクト: Ken1JF/sgfdb
func PrintSgfDbTypeSizes() {
	// sgfdb.go
	var tr TraceRec
	var cdr DirectoryProcessRequest
	printSizeAlign("TraceRec", unsafe.Sizeof(tr), unsafe.Alignof(tr))
	printSizeAlign("DirectoryProcessRequest", unsafe.Sizeof(cdr), unsafe.Alignof(cdr))
}
コード例 #2
0
ファイル: issue4654.go プロジェクト: qunhu/go_src_comment
func f() {
	defer int(0)             // ERROR "defer requires function call, not conversion"
	go string([]byte("abc")) // ERROR "go requires function call, not conversion"

	var c complex128
	var f float64
	var t struct{ X int }

	var x []int
	defer append(x, 1)         // ERROR "defer discards result of append"
	defer cap(x)               // ERROR "defer discards result of cap"
	defer complex(1, 2)        // ERROR "defer discards result of complex"
	defer complex(f, 1)        // ERROR "defer discards result of complex"
	defer imag(1i)             // ERROR "defer discards result of imag"
	defer imag(c)              // ERROR "defer discards result of imag"
	defer len(x)               // ERROR "defer discards result of len"
	defer make([]int, 1)       // ERROR "defer discards result of make"
	defer make(chan bool)      // ERROR "defer discards result of make"
	defer make(map[string]int) // ERROR "defer discards result of make"
	defer new(int)             // ERROR "defer discards result of new"
	defer real(1i)             // ERROR "defer discards result of real"
	defer real(c)              // ERROR "defer discards result of real"
	defer append(x, 1)         // ERROR "defer discards result of append"
	defer append(x, 1)         // ERROR "defer discards result of append"
	defer unsafe.Alignof(t.X)  // ERROR "defer discards result of unsafe.Alignof"
	defer unsafe.Offsetof(t.X) // ERROR "defer discards result of unsafe.Offsetof"
	defer unsafe.Sizeof(t)     // ERROR "defer discards result of unsafe.Sizeof"

	defer copy(x, x) // ok
	m := make(map[int]int)
	defer delete(m, 1) // ok
	defer panic(1)     // ok
	defer print(1)     // ok
	defer println(1)   // ok
	defer recover()    // ok

	int(0)                // ERROR "int\(0\) evaluated but not used"
	string([]byte("abc")) // ERROR "string\(.*\) evaluated but not used"

	append(x, 1)         // ERROR "not used"
	cap(x)               // ERROR "not used"
	complex(1, 2)        // ERROR "not used"
	complex(f, 1)        // ERROR "not used"
	imag(1i)             // ERROR "not used"
	imag(c)              // ERROR "not used"
	len(x)               // ERROR "not used"
	make([]int, 1)       // ERROR "not used"
	make(chan bool)      // ERROR "not used"
	make(map[string]int) // ERROR "not used"
	new(int)             // ERROR "not used"
	real(1i)             // ERROR "not used"
	real(c)              // ERROR "not used"
	append(x, 1)         // ERROR "not used"
	append(x, 1)         // ERROR "not used"
	unsafe.Alignof(t.X)  // ERROR "not used"
	unsafe.Offsetof(t.X) // ERROR "not used"
	unsafe.Sizeof(t)     // ERROR "not used"
}
コード例 #3
0
ファイル: out_message.go プロジェクト: horzadome/gcsfuse
// Make sure alignment works out correctly, at least for the header.
func init() {
	a := unsafe.Alignof(OutMessage{})
	o := unsafe.Offsetof(OutMessage{}.storage)
	e := unsafe.Alignof(fusekernel.OutHeader{})

	if a%e != 0 || o%e != 0 {
		log.Panicf("Bad alignment or offset: %d, %d, need %d", a, o, e)
	}
}
コード例 #4
0
func (endianSupport) little(idx uint32) uint32 {
	if idx < 0 || idx >= 6 {
		return 0
	}
	return uint32(unsafe.Offsetof(secData.args)) +
		uint32(unsafe.Alignof(secData.args[0]))*idx + uint32(unsafe.Sizeof(secData.arch))
}
コード例 #5
0
ファイル: sizeof.go プロジェクト: qunhu/go_src_comment
func main() {
	// Test unsafe.Sizeof, unsafe.Alignof, and unsafe.Offsetof all return uintptr.
	isUintptr(unsafe.Sizeof(t))
	isUintptr(unsafe.Alignof(t))
	isUintptr(unsafe.Offsetof(t.X))

	// Test correctness of Offsetof with respect to embedded fields (issue 4909).
	if unsafe.Offsetof(t2.C) != 8 {
		println(unsafe.Offsetof(t2.C), "!= 8")
		panic("unsafe.Offsetof(t2.C) != 8")
	}
	if unsafe.Offsetof(p2.C) != 8 {
		println(unsafe.Offsetof(p2.C), "!= 8")
		panic("unsafe.Offsetof(p2.C) != 8")
	}
	if unsafe.Offsetof(t2.U2.C) != 4 {
		println(unsafe.Offsetof(t2.U2.C), "!= 4")
		panic("unsafe.Offsetof(t2.U2.C) != 4")
	}
	if unsafe.Offsetof(p2.U2.C) != 4 {
		println(unsafe.Offsetof(p2.U2.C), "!= 4")
		panic("unsafe.Offsetof(p2.U2.C) != 4")
	}
	testDeep()
	testNotEmbedded()
}
コード例 #6
0
ファイル: memory-footprint2.go プロジェクト: sthapaun/ex
func main() {
	example := &Example{
		BoolValue: true,
	}

	exampleNext := &Example{
		BoolValue: true,
	}

	alignmentBoundary := unsafe.Alignof(example)

	sizeBool := unsafe.Sizeof(example.BoolValue)
	offsetBool := unsafe.Offsetof(example.BoolValue)

	sizeBoolNext := unsafe.Sizeof(exampleNext.BoolValue)
	offsetBoolNext := unsafe.Offsetof(exampleNext.BoolValue)

	fmt.Printf("Alignment Boundary: %d\n", alignmentBoundary)

	fmt.Printf("BoolValue = Size: %d Offset: %d Addr: %v\n",
		sizeBool, offsetBool, &example.BoolValue)

	fmt.Printf("Next = Size: %d Offset: %d Addr: %v\n",
		sizeBoolNext, offsetBoolNext, &exampleNext.BoolValue)
}
コード例 #7
0
ファイル: example1.go プロジェクト: JacobJohansen/gotraining
// main is the entry point for the application.
func main() {
	var e example

	alignmentBoundary := unsafe.Alignof(e)
	sizeE := unsafe.Sizeof(e)

	sizeBool := unsafe.Sizeof(e.flag)
	offsetBool := unsafe.Offsetof(e.flag)

	sizeInt := unsafe.Sizeof(e.counter)
	offsetInt := unsafe.Offsetof(e.counter)

	sizeBool2 := unsafe.Sizeof(e.flag2)
	offsetBool2 := unsafe.Offsetof(e.flag2)

	sizeFloat := unsafe.Sizeof(e.pi)
	offsetFloat := unsafe.Offsetof(e.pi)

	fmt.Printf("Alignment(%d):\tSize: %d\n", alignmentBoundary, sizeE)

	fmt.Printf("flag:\t\tSize: %d\t\tOffset: %d\tAddr: %v\n",
		sizeBool, offsetBool, &e.flag)

	fmt.Printf("counter:\tSize: %d\t\tOffset: %d\tAddr: %v\n",
		sizeInt, offsetInt, &e.counter)

	fmt.Printf("flag1:\t\tSize: %d\t\tOffset: %d\tAddr: %v\n",
		sizeBool2, offsetBool2, &e.flag2)

	fmt.Printf("pi\t\tSize: %d\t\tOffset: %d\tAddr: %v\n",
		sizeFloat, offsetFloat, &e.pi)
}
コード例 #8
0
ファイル: slice.go プロジェクト: 0x9e3779b9/golang_lab
func main() {
	s := []int{1, 2, 3, 4, 5, 6}
	p := unsafe.Pointer(&s)
	size := *(*int)(unsafe.Pointer(uintptr(p) + uintptr(unsafe.Alignof(reflect.SliceHeader.Len))))
	fmt.Printf("sizeof = %d\n", size)
	//p2 := (*[]byte)(unsafe.Pointer(uintptr(p)))
	//fmt.Printf("str = %v\n", string(*p2))
}
コード例 #9
0
ファイル: main.go プロジェクト: zacheryph/gocode
func newBuffer(b []byte) *buffer {
	buf := &buffer{
		b: align(b, unsafe.Alignof((*C.char)(nil))),
	}
	if buf.b == nil {
		buf.err = syscall.ERANGE
	}
	return buf
}
コード例 #10
0
ファイル: siphash_test.go プロジェクト: enceve/crypto
func unalignBytes(in []byte) []byte {
	out := make([]byte, len(in)+1)
	if uintptr(unsafe.Pointer(&out[0]))&(unsafe.Alignof(uint32(0))-1) == 0 {
		out = out[1:]
	} else {
		out = out[:len(in)]
	}
	copy(out, in)
	return out
}
コード例 #11
0
ファイル: bug279.go プロジェクト: 2thetop/go
func main() {
	n := unsafe.Sizeof(0)
	if n != 4 && n != 8 {
		println("BUG sizeof 0", n)
		return
	}
	n = unsafe.Alignof(0)
	if n != 4 && n != 8 {
		println("BUG alignof 0", n)
		return
	}

	n = unsafe.Sizeof("")
	if n != 8 && n != 16 {
		println("BUG sizeof \"\"", n)
		return
	}
	n = unsafe.Alignof("")
	if n != 4 && n != 8 {
		println("BUG alignof \"\"", n)
		return
	}
}
コード例 #12
0
ファイル: md5_test.go プロジェクト: gnanderson/go
func benchmarkSize(b *testing.B, size int, unaligned bool) {
	b.SetBytes(int64(size))
	buf := buf
	if unaligned {
		if uintptr(unsafe.Pointer(&buf[0]))&(unsafe.Alignof(uint32(0))-1) == 0 {
			buf = buf[1:]
		}
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		bench.Reset()
		bench.Write(buf[:size])
		bench.Sum(sum[:0])
	}
}
コード例 #13
0
ファイル: example1.go プロジェクト: gaurav36/gotraining
// main is the entry point for the application.
func main() {
	// Declare variable of type example and init using
	// a struct literal.
	e := example{
		flag:    true,
		counter: 10,
		pi:      3.141592,
	}

	// Declare variable of type example and init using
	// a struct literal.
	eNext := example{
		flag:    true,
		counter: 10,
		pi:      3.141592,
	}

	// By placing both value one after the other on the stack
	// we can see the actual padding and where it is located.

	alignmentBoundary := unsafe.Alignof(e)

	sizeBool := unsafe.Sizeof(e.flag)
	offsetBool := unsafe.Offsetof(e.flag)

	sizeInt := unsafe.Sizeof(e.counter)
	offsetInt := unsafe.Offsetof(e.counter)

	sizeFloat := unsafe.Sizeof(e.pi)
	offsetFloat := unsafe.Offsetof(e.pi)

	sizeBoolNext := unsafe.Sizeof(eNext.flag)
	offsetBoolNext := unsafe.Offsetof(eNext.flag)

	fmt.Printf("Alignment Boundary: %d\n", alignmentBoundary)

	fmt.Printf("flag = Size: %d Offset: %d Addr: %v\n",
		sizeBool, offsetBool, &e.flag)

	fmt.Printf("counter = Size: %d Offset: %d Addr: %v\n",
		sizeInt, offsetInt, &e.counter)

	fmt.Printf("pi = Size: %d Offset: %d Addr: %v\n",
		sizeFloat, offsetFloat, &e.pi)

	fmt.Printf("Next = Size: %d Offset: %d Addr: %v\n",
		sizeBoolNext, offsetBoolNext, &eNext.flag)
}
コード例 #14
0
ファイル: sorted.go プロジェクト: postfix/fslm
func (m *Sorted) WriteBinary(path string) (err error) {
	w, err := os.Create(path)
	if err != nil {
		return
	}
	defer w.Close()
	bw := byteblock.NewByteBlockWriter(w)
	if err = bw.WriteString(MAGIC_SORTED, 0); err != nil {
		return
	}
	// Header
	header, err := m.header()
	if err != nil {
		return
	}
	if err = bw.Write(header, 0); err != nil {
		return
	}
	// Raw entries.

	// Go over the transitions to see how many entries there are in total.
	numEntries := int64(0)
	for _, i := range m.transitions {
		numEntries += int64(len(i))
	}
	// Ask for a large new block and then incrementally write out the
	// data.
	align := int64(unsafe.Alignof(xqwEntry{}))
	size := int64(unsafe.Sizeof(xqwEntry{}))
	if err = bw.NewBlock(align, size*numEntries); err != nil {
		return
	}
	for _, i := range m.transitions {
		iHeader := (*reflect.SliceHeader)(unsafe.Pointer(&i))
		var bytes []byte
		bytesHeader := (*reflect.SliceHeader)(unsafe.Pointer(&bytes))
		bytesHeader.Data = iHeader.Data
		bytesHeader.Len = int(int64(iHeader.Len) * size)
		bytesHeader.Cap = bytesHeader.Len
		if err = bw.Append(bytes); err != nil {
			return
		}
	}
	return nil
}
コード例 #15
0
ファイル: memory-footprint.go プロジェクト: sthapaun/ex
func main() {
	example := &Example{
		BoolValue:  true,
		IntValue:   10,
		FloatValue: 3.141592,
	}

	exampleNext := &Example{
		BoolValue:  true,
		IntValue:   10,
		FloatValue: 3.141592,
	}

	alignmentBoundary := unsafe.Alignof(example)

	sizeBool := unsafe.Sizeof(example.BoolValue)
	offsetBool := unsafe.Offsetof(example.BoolValue)

	sizeInt := unsafe.Sizeof(example.IntValue)
	offsetInt := unsafe.Offsetof(example.IntValue)

	sizeFloat := unsafe.Sizeof(example.FloatValue)
	offsetFloat := unsafe.Offsetof(example.FloatValue)

	sizeBoolNext := unsafe.Sizeof(exampleNext.BoolValue)
	offsetBoolNext := unsafe.Offsetof(exampleNext.BoolValue)

	fmt.Printf("Alignment Boundary: %d\n", alignmentBoundary)

	fmt.Printf("BoolValue = Size: %d Offset: %d Addr: %v\n",
		sizeBool, offsetBool, &example.BoolValue)

	fmt.Printf("IntValue = Size: %d Offset: %d Addr: %v\n",
		sizeInt, offsetInt, &example.IntValue)

	fmt.Printf("FloatValue = Size: %d Offset: %d Addr: %v\n",
		sizeFloat, offsetFloat, &example.FloatValue)

	fmt.Printf("Next = Size: %d Offset: %d Addr: %v\n",
		sizeBoolNext, offsetBoolNext, &exampleNext.BoolValue)
}
コード例 #16
0
ファイル: ldcache.go プロジェクト: CadeLaRen/nvidia-docker
func (c *LDCache) parse() error {
	var header Header1

	// Check for the old format (< glibc-2.2)
	if c.Len() <= int(unsafe.Sizeof(header)) {
		return ErrInvalidCache
	}
	if strn(c.data, len(magicString1)) == magicString1 {
		if err := binary.Read(c, binary.LittleEndian, &header); err != nil {
			return err
		}
		n := int64(header.NLibs) * int64(unsafe.Sizeof(Entry1{}))
		offset, err := c.Seek(n, 1) // skip old entries
		if err != nil {
			return err
		}
		n = (-offset) & int64(unsafe.Alignof(c.header)-1)
		_, err = c.Seek(n, 1) // skip padding
		if err != nil {
			return err
		}
	}

	c.libs = c.data[c.Size()-int64(c.Len()):] // kv offsets start here
	if err := binary.Read(c, binary.LittleEndian, &c.header); err != nil {
		return err
	}
	if c.Magic() != magicString2 || c.Version() != magicVersion {
		return ErrInvalidCache
	}
	c.entries = make([]Entry2, c.header.NLibs)
	if err := binary.Read(c, binary.LittleEndian, &c.entries); err != nil {
		return err
	}
	return nil
}
コード例 #17
0
ファイル: sizeof_basic.go プロジェクト: glycerine/llgo
func main() {
	var b bool
	var i int
	var i8 int8
	var i16 int16
	var i32 int32
	var i64 int64
	var u uint
	var u8 uint8
	var u16 uint16
	var u32 uint32
	var u64 uint64
	var f32 float32
	var f64 float64
	var c64 complex64
	var c128 complex128
	var s string
	var p unsafe.Pointer
	var up uintptr

	println(unsafe.Sizeof(b))
	println(unsafe.Sizeof(i))
	println(unsafe.Sizeof(i8))
	println(unsafe.Sizeof(i16))
	println(unsafe.Sizeof(i32))
	println(unsafe.Sizeof(i64))
	println(unsafe.Sizeof(u))
	println(unsafe.Sizeof(u8))
	println(unsafe.Sizeof(u16))
	println(unsafe.Sizeof(u32))
	println(unsafe.Sizeof(u64))
	println(unsafe.Sizeof(f32))
	println(unsafe.Sizeof(f64))
	println(unsafe.Sizeof(c64))
	println(unsafe.Sizeof(c128))
	println(unsafe.Sizeof(s))
	println(unsafe.Sizeof(p))
	println(unsafe.Sizeof(up))

	println(unsafe.Alignof(b))
	println(unsafe.Alignof(i))
	println(unsafe.Alignof(i8))
	println(unsafe.Alignof(i16))
	println(unsafe.Alignof(i32))
	println(unsafe.Alignof(i64))
	println(unsafe.Alignof(u))
	println(unsafe.Alignof(u8))
	println(unsafe.Alignof(u16))
	println(unsafe.Alignof(u32))
	println(unsafe.Alignof(u64))
	println(unsafe.Alignof(f32))
	println(unsafe.Alignof(f64))
	println(unsafe.Alignof(c64))
	println(unsafe.Alignof(c128))
	println(unsafe.Alignof(s))
	println(unsafe.Alignof(p))
	println(unsafe.Alignof(up))
}
コード例 #18
0
ファイル: sizeof.go プロジェクト: kostyll/gccpy
func main() {
	isUintptr(unsafe.Sizeof(t))
	isUintptr(unsafe.Alignof(t))
	isUintptr(unsafe.Offsetof(t.X))
}
コード例 #19
0
ファイル: update.go プロジェクト: Ken1JF/ah
func PrintAhTypeSizes() {
	// board.go
	var d Direction
	var pt PointType
	var cv ColValue
	var rv RowValue
	var csz ColSize
	var rsz RowSize
	var nl NodeLoc
	var nll NodeLocList
	var m MoveRecord
	//var bp BoardPoint
	var b Board
	var ss SearchStack
	var gnlf GraphNodeLocFunc
	var nlfb NodeLocFuncBool
	printSizeAlign("Direction", unsafe.Sizeof(d), unsafe.Alignof(d))
	printSizeAlign("PointType", unsafe.Sizeof(pt), unsafe.Alignof(pt))
	printSizeAlign("ColValue", unsafe.Sizeof(cv), unsafe.Alignof(cv))
	printSizeAlign("RowValue", unsafe.Sizeof(rv), unsafe.Alignof(rv))
	printSizeAlign("ColSize", unsafe.Sizeof(csz), unsafe.Alignof(csz))
	printSizeAlign("RowSize", unsafe.Sizeof(rsz), unsafe.Alignof(rsz))
	printSizeAlign("NodeLoc", unsafe.Sizeof(nl), unsafe.Alignof(nl))
	printSizeAlign("NodeLocList", unsafe.Sizeof(nll), unsafe.Alignof(nll))
	printSizeAlign("MoveRecord", unsafe.Sizeof(m), unsafe.Alignof(m))
	//	printSizeAlign("BoardPoint", unsafe.Sizeof(bp), unsafe.Alignof(bp))
	printSizeAlign("Board", unsafe.Sizeof(b), unsafe.Alignof(b))
	printSizeAlign("SearchStack", unsafe.Sizeof(ss), unsafe.Alignof(ss))
	printSizeAlign("GraphNodeLocFunc", unsafe.Sizeof(gnlf), unsafe.Alignof(gnlf))
	printSizeAlign("NodeLocFuncBool", unsafe.Sizeof(nlfb), unsafe.Alignof(nlfb))
	// trans.go
	var bt BoardTrans
	printSizeAlign("BoardTrans", unsafe.Sizeof(bt), unsafe.Alignof(bt))
	// graph.go
	var ai ArcIdx
	var gm GraphMark
	var gn GraphNode
	var ga GraphArc
	var csf CompStateFunc
	var chreq ChangeRequest
	var g Graph
	var glnf NodeLocFunc
	var af ArcFunc
	printSizeAlign("ArcIdx", unsafe.Sizeof(ai), unsafe.Alignof(ai))
	printSizeAlign("GraphMark", unsafe.Sizeof(gm), unsafe.Alignof(gm))
	printSizeAlign("GraphNode", unsafe.Sizeof(gn), unsafe.Alignof(gn))
	printSizeAlign("GraphArc", unsafe.Sizeof(ga), unsafe.Alignof(ga))
	printSizeAlign("CompStateFunc", unsafe.Sizeof(csf), unsafe.Alignof(csf))
	printSizeAlign("ChangeRequest", unsafe.Sizeof(chreq), unsafe.Alignof(chreq))
	printSizeAlign("Graph", unsafe.Sizeof(g), unsafe.Alignof(g))
	printSizeAlign("NodeLocFunc", unsafe.Sizeof(glnf), unsafe.Alignof(glnf))
	printSizeAlign("ArcFunc", unsafe.Sizeof(af), unsafe.Alignof(af))
	// comp.go
	var ps PointStatus
	printSizeAlign("PointStatus", unsafe.Sizeof(ps), unsafe.Alignof(ps))
	// update.go
	var gl GraphLevel
	var ah AbstHier
	var ns NodeStatus
	printSizeAlign("GraphLevel", unsafe.Sizeof(gl), unsafe.Alignof(gl))
	printSizeAlign("AbstHier", unsafe.Sizeof(ah), unsafe.Alignof(ah))
	printSizeAlign("NodeStatus", unsafe.Sizeof(ns), unsafe.Alignof(ns))
	// gostrings.go
	var sst StringStatus
	printSizeAlign("StringStatus", unsafe.Sizeof(sst), unsafe.Alignof(sst))
}
コード例 #20
0
ファイル: sgf.go プロジェクト: Ken1JF/sgf
func PrintSGFTypeSizes() {
	// token.go
	var t Token
	var pos ah.Position
	printSizeAlign("Token", unsafe.Sizeof(t), unsafe.Alignof(t))
	printSizeAlign("ah.Position", unsafe.Sizeof(pos), unsafe.Alignof(pos))
	// tree.go
	var tnt TreeNodeType
	var tni TreeNodeIdx
	var pi PropIdx
	var tn TreeNode
	var pv PropertyValue
	printSizeAlign("TreeNodeType", unsafe.Sizeof(tnt), unsafe.Alignof(tnt))
	printSizeAlign("TreeNodeIdx", unsafe.Sizeof(tni), unsafe.Alignof(tni))
	printSizeAlign("PropIdx", unsafe.Sizeof(pi), unsafe.Alignof(pi))
	printSizeAlign("TreeNode", unsafe.Sizeof(tn), unsafe.Alignof(tn))
	printSizeAlign("PropertyValue", unsafe.Sizeof(pv), unsafe.Alignof(pv))
	// parser.go
	var pt GameTree
	var pr Parser
	var pyi PlayerInfo
	var dbs DBStatistics
	printSizeAlign("GameTree", unsafe.Sizeof(pt), unsafe.Alignof(pt))
	printSizeAlign("Parser", unsafe.Sizeof(pr), unsafe.Alignof(pr))
	printSizeAlign("PlayerInfo", unsafe.Sizeof(pyi), unsafe.Alignof(pyi))
	printSizeAlign("DBStatistics", unsafe.Sizeof(dbs), unsafe.Alignof(dbs))
	// sgf.go
	var ff4n FF4Note
	var sgfpnt SGFPropNodeType
	var qt QualifierType
	var vt PropValueType
	var prop Property
	var pdi PropertyDefIdx
	var idca ID_CountArray
	printSizeAlign("FF4Note", unsafe.Sizeof(ff4n), unsafe.Alignof(ff4n))
	printSizeAlign("SGFPropNodeType", unsafe.Sizeof(sgfpnt), unsafe.Alignof(sgfpnt))
	printSizeAlign("QualifierType", unsafe.Sizeof(qt), unsafe.Alignof(qt))
	printSizeAlign("PropValueType", unsafe.Sizeof(vt), unsafe.Alignof(vt))
	printSizeAlign("Property", unsafe.Sizeof(prop), unsafe.Alignof(prop))
	printSizeAlign("PropertyDefIdx", unsafe.Sizeof(pdi), unsafe.Alignof(pdi))
	printSizeAlign("ID_CountArray", unsafe.Sizeof(idca), unsafe.Alignof(idca))
	// scanner.go
	var s Scanner
	printSizeAlign("Scanner", unsafe.Sizeof(s), unsafe.Alignof(s))
	// errors.go
	var eh ErrorHandler
	var el ah.ErrorList
	printSizeAlign("ErrorHandler", unsafe.Sizeof(eh), unsafe.Alignof(eh))
	printSizeAlign("ah.ErrorList", unsafe.Sizeof(el), unsafe.Alignof(el))
	// game.go
	var k Komi
	var r Result
	printSizeAlign("Komi", unsafe.Sizeof(k), unsafe.Alignof(k))
	printSizeAlign("Result", unsafe.Sizeof(r), unsafe.Alignof(r))
}
コード例 #21
0
ファイル: data_test.go プロジェクト: ToadKing/golisp
func (s *SizeSuite) TestSize(c *C) {
	d := *IntegerWithValue(42)
	fmt.Printf("Data size is %d bytes\n", unsafe.Sizeof(d))
	fmt.Printf("Data alignment is %d\n", unsafe.Alignof(d))
}
コード例 #22
0
ファイル: properties.go プロジェクト: ashokgelal/gorilla
// Initialize the fields for encoding and decoding.
func (p *Properties) setEncAndDec(typ reflect.Type) {
	var vbool bool
	var vbyte byte
	var vint32 int32
	var vint64 int64
	var vfloat32 float32
	var vfloat64 float64
	var vstring string
	var vslice []byte

	p.enc = nil
	p.dec = nil

	switch t1 := typ; t1.Kind() {
	default:
		fmt.Fprintf(os.Stderr, "proto: no coders for %T\n", t1)
		break

	case reflect.Ptr:
		switch t2 := t1.Elem(); t2.Kind() {
		default:
			fmt.Fprintf(os.Stderr, "proto: no encoder function for %T -> %T\n", t1, t2)
			break
		case reflect.Bool:
			p.enc = (*Buffer).enc_bool
			p.dec = (*Buffer).dec_bool
			p.alignof = unsafe.Alignof(vbool)
			p.sizeof = unsafe.Sizeof(vbool)
		case reflect.Int32, reflect.Uint32:
			p.enc = (*Buffer).enc_int32
			p.dec = (*Buffer).dec_int32
			p.alignof = unsafe.Alignof(vint32)
			p.sizeof = unsafe.Sizeof(vint32)
		case reflect.Int64, reflect.Uint64:
			p.enc = (*Buffer).enc_int64
			p.dec = (*Buffer).dec_int64
			p.alignof = unsafe.Alignof(vint64)
			p.sizeof = unsafe.Sizeof(vint64)
		case reflect.Float32:
			p.enc = (*Buffer).enc_int32 // can just treat them as bits
			p.dec = (*Buffer).dec_int32
			p.alignof = unsafe.Alignof(vfloat32)
			p.sizeof = unsafe.Sizeof(vfloat32)
		case reflect.Float64:
			p.enc = (*Buffer).enc_int64 // can just treat them as bits
			p.dec = (*Buffer).dec_int64
			p.alignof = unsafe.Alignof(vfloat64)
			p.sizeof = unsafe.Sizeof(vfloat64)
		case reflect.String:
			p.enc = (*Buffer).enc_string
			p.dec = (*Buffer).dec_string
			p.alignof = unsafe.Alignof(vstring)
			p.sizeof = unsafe.Sizeof(vstring) + startSize*unsafe.Sizeof(vbyte)
		case reflect.Struct:
			p.stype = t1
			if p.Wire == "bytes" {
				p.enc = (*Buffer).enc_struct_message
				p.dec = (*Buffer).dec_struct_message
			} else {
				p.enc = (*Buffer).enc_struct_group
				p.dec = (*Buffer).dec_struct_group
			}
		}

	case reflect.Slice:
		switch t2 := t1.Elem(); t2.Kind() {
		default:
			logNoSliceEnc(t1, t2)
			break
		case reflect.Bool:
			if p.Packed {
				p.enc = (*Buffer).enc_slice_packed_bool
			} else {
				p.enc = (*Buffer).enc_slice_bool
			}
			p.dec = (*Buffer).dec_slice_bool
			p.packedDec = (*Buffer).dec_slice_packed_bool
			p.alignof = unsafe.Alignof(vbool)
			p.sizeof = startSize * unsafe.Sizeof(vbool)
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
			switch t2.Bits() {
			case 32:
				if p.Packed {
					p.enc = (*Buffer).enc_slice_packed_int32
				} else {
					p.enc = (*Buffer).enc_slice_int32
				}
				p.dec = (*Buffer).dec_slice_int32
				p.packedDec = (*Buffer).dec_slice_packed_int32
				p.alignof = unsafe.Alignof(vint32)
				p.sizeof = startSize * unsafe.Sizeof(vint32)
			case 64:
				if p.Packed {
					p.enc = (*Buffer).enc_slice_packed_int64
				} else {
					p.enc = (*Buffer).enc_slice_int64
				}
				p.dec = (*Buffer).dec_slice_int64
				p.packedDec = (*Buffer).dec_slice_packed_int64
				p.alignof = unsafe.Alignof(vint64)
				p.sizeof = startSize * unsafe.Sizeof(vint64)
			case 8:
				if t2.Kind() == reflect.Uint8 {
					p.enc = (*Buffer).enc_slice_byte
					p.dec = (*Buffer).dec_slice_byte
					p.alignof = unsafe.Alignof(vbyte)
					p.sizeof = startSize * unsafe.Sizeof(vbyte)
				}
			default:
				logNoSliceEnc(t1, t2)
				break
			}
		case reflect.Float32, reflect.Float64:
			switch t2.Bits() {
			case 32:
				// can just treat them as bits
				if p.Packed {
					p.enc = (*Buffer).enc_slice_packed_int32
				} else {
					p.enc = (*Buffer).enc_slice_int32
				}
				p.dec = (*Buffer).dec_slice_int32
				p.packedDec = (*Buffer).dec_slice_packed_int32
				p.alignof = unsafe.Alignof(vfloat32)
				p.sizeof = startSize * unsafe.Sizeof(vfloat32)
			case 64:
				// can just treat them as bits
				if p.Packed {
					p.enc = (*Buffer).enc_slice_packed_int64
				} else {
					p.enc = (*Buffer).enc_slice_int64
				}
				p.dec = (*Buffer).dec_slice_int64
				p.packedDec = (*Buffer).dec_slice_packed_int64
				p.alignof = unsafe.Alignof(vfloat64)
				p.sizeof = startSize * unsafe.Sizeof(vfloat64)
			default:
				logNoSliceEnc(t1, t2)
				break
			}
		case reflect.String:
			p.enc = (*Buffer).enc_slice_string
			p.dec = (*Buffer).dec_slice_string
			p.alignof = unsafe.Alignof(vstring)
			p.sizeof = startSize * unsafe.Sizeof(vstring)
		case reflect.Ptr:
			switch t3 := t2.Elem(); t3.Kind() {
			default:
				fmt.Fprintf(os.Stderr, "proto: no ptr oenc for %T -> %T -> %T\n", t1, t2, t3)
				break
			case reflect.Struct:
				p.stype = t2
				p.enc = (*Buffer).enc_slice_struct_group
				p.dec = (*Buffer).dec_slice_struct_group
				if p.Wire == "bytes" {
					p.enc = (*Buffer).enc_slice_struct_message
					p.dec = (*Buffer).dec_slice_struct_message
				}
				p.alignof = unsafe.Alignof(vslice)
				p.sizeof = startSize * unsafe.Sizeof(vslice)
			}
		case reflect.Slice:
			switch t2.Elem().Kind() {
			default:
				fmt.Fprintf(os.Stderr, "proto: no slice elem oenc for %T -> %T -> %T\n", t1, t2, t2.Elem())
				break
			case reflect.Uint8:
				p.enc = (*Buffer).enc_slice_slice_byte
				p.dec = (*Buffer).dec_slice_slice_byte
				p.alignof = unsafe.Alignof(vslice)
				p.sizeof = startSize * unsafe.Sizeof(vslice)
			}
		}
	}

	// precalculate tag code
	wire := p.WireType
	if p.Packed {
		wire = WireBytes
	}
	x := uint32(p.Tag)<<3 | uint32(wire)
	i := 0
	for i = 0; x > 127; i++ {
		p.tagbuf[i] = 0x80 | uint8(x&0x7F)
		x >>= 7
	}
	p.tagbuf[i] = uint8(x)
	p.tagcode = p.tagbuf[0 : i+1]
}
コード例 #23
0
ファイル: properties.go プロジェクト: ashokgelal/gorilla
// GetProperties returns the list of properties for the type represented by t.
func GetProperties(t reflect.Type) *StructProperties {
	mutex.Lock()
	if prop, ok := propertiesMap[t]; ok {
		mutex.Unlock()
		stats.Chit++
		return prop
	}
	stats.Cmiss++

	prop := new(StructProperties)

	// build properties
	prop.Prop = make([]*Properties, t.NumField())
	prop.order = make([]int, t.NumField())
	for i := 0; i < t.NumField(); i++ {
		f := t.Field(i)
		p := new(Properties)
		p.Init(f.Type, f.Name, f.Tag.Get("protobuf"), f.Offset)
		if f.Name == "XXX_extensions" { // special case
			var vmap map[int32][]byte
			p.enc = (*Buffer).enc_map
			p.dec = nil // not needed
			p.alignof = unsafe.Alignof(vmap)
			p.sizeof = unsafe.Sizeof(vmap)
		}
		prop.Prop[i] = p
		prop.order[i] = i
		if debug {
			print(i, " ", f.Name, " ", t.String(), " ")
			if p.Tag > 0 {
				print(p.String())
			}
			print("\n")
		}
		if p.enc == nil && !strings.HasPrefix(f.Name, "XXX_") {
			fmt.Fprintln(os.Stderr, "proto: no encoder for", f.Name, f.Type.String(), "[GetProperties]")
		}
	}

	// Re-order prop.order.
	sort.Sort(prop)

	// build required counts
	// build scratch offsets
	// build tags
	reqCount := 0
	scratch := uintptr(0)
	prop.tags = make(map[int]int)
	prop.origNames = make(map[string]int)
	for i, p := range prop.Prop {
		if p.Required {
			reqCount++
		}
		scratch = align(scratch, p.alignof)
		p.scratch = scratch
		scratch += p.sizeof
		prop.tags[p.Tag] = i
		prop.origNames[p.OrigName] = i
	}
	prop.reqCount = reqCount
	prop.nscratch = scratch

	propertiesMap[t] = prop
	mutex.Unlock()
	return prop
}
コード例 #24
0
ファイル: md5block.go プロジェクト: redcatmiss/gcc
func block(dig *digest, p []byte) {
	a := dig.s[0]
	b := dig.s[1]
	c := dig.s[2]
	d := dig.s[3]
	var X *[16]uint32
	var xbuf [16]uint32
	for len(p) >= chunk {
		aa, bb, cc, dd := a, b, c, d

		// This is a constant condition - it is not evaluated on each iteration.
		if runtime.GOARCH == "amd64" || runtime.GOARCH == "386" {
			// MD5 was designed so that x86 processors can just iterate
			// over the block data directly as uint32s, and we generate
			// less code and run 1.3x faster if we take advantage of that.
			// My apologies.
			X = (*[16]uint32)(unsafe.Pointer(&p[0]))
		} else if uintptr(unsafe.Pointer(&p[0]))&(unsafe.Alignof(uint32(0))-1) == 0 {
			X = (*[16]uint32)(unsafe.Pointer(&p[0]))
		} else {
			X = &xbuf
			j := 0
			for i := 0; i < 16; i++ {
				X[i&15] = uint32(p[j]) | uint32(p[j+1])<<8 | uint32(p[j+2])<<16 | uint32(p[j+3])<<24
				j += 4
			}
		}

		// Round 1.

		a += (((c ^ d) & b) ^ d) + X[0] + 3614090360
		a = a<<7 | a>>(32-7) + b

		d += (((b ^ c) & a) ^ c) + X[1] + 3905402710
		d = d<<12 | d>>(32-12) + a

		c += (((a ^ b) & d) ^ b) + X[2] + 606105819
		c = c<<17 | c>>(32-17) + d

		b += (((d ^ a) & c) ^ a) + X[3] + 3250441966
		b = b<<22 | b>>(32-22) + c

		a += (((c ^ d) & b) ^ d) + X[4] + 4118548399
		a = a<<7 | a>>(32-7) + b

		d += (((b ^ c) & a) ^ c) + X[5] + 1200080426
		d = d<<12 | d>>(32-12) + a

		c += (((a ^ b) & d) ^ b) + X[6] + 2821735955
		c = c<<17 | c>>(32-17) + d

		b += (((d ^ a) & c) ^ a) + X[7] + 4249261313
		b = b<<22 | b>>(32-22) + c

		a += (((c ^ d) & b) ^ d) + X[8] + 1770035416
		a = a<<7 | a>>(32-7) + b

		d += (((b ^ c) & a) ^ c) + X[9] + 2336552879
		d = d<<12 | d>>(32-12) + a

		c += (((a ^ b) & d) ^ b) + X[10] + 4294925233
		c = c<<17 | c>>(32-17) + d

		b += (((d ^ a) & c) ^ a) + X[11] + 2304563134
		b = b<<22 | b>>(32-22) + c

		a += (((c ^ d) & b) ^ d) + X[12] + 1804603682
		a = a<<7 | a>>(32-7) + b

		d += (((b ^ c) & a) ^ c) + X[13] + 4254626195
		d = d<<12 | d>>(32-12) + a

		c += (((a ^ b) & d) ^ b) + X[14] + 2792965006
		c = c<<17 | c>>(32-17) + d

		b += (((d ^ a) & c) ^ a) + X[15] + 1236535329
		b = b<<22 | b>>(32-22) + c

		// Round 2.

		a += (((b ^ c) & d) ^ c) + X[(1+5*0)&15] + 4129170786
		a = a<<5 | a>>(32-5) + b

		d += (((a ^ b) & c) ^ b) + X[(1+5*1)&15] + 3225465664
		d = d<<9 | d>>(32-9) + a

		c += (((d ^ a) & b) ^ a) + X[(1+5*2)&15] + 643717713
		c = c<<14 | c>>(32-14) + d

		b += (((c ^ d) & a) ^ d) + X[(1+5*3)&15] + 3921069994
		b = b<<20 | b>>(32-20) + c

		a += (((b ^ c) & d) ^ c) + X[(1+5*4)&15] + 3593408605
		a = a<<5 | a>>(32-5) + b

		d += (((a ^ b) & c) ^ b) + X[(1+5*5)&15] + 38016083
		d = d<<9 | d>>(32-9) + a

		c += (((d ^ a) & b) ^ a) + X[(1+5*6)&15] + 3634488961
		c = c<<14 | c>>(32-14) + d

		b += (((c ^ d) & a) ^ d) + X[(1+5*7)&15] + 3889429448
		b = b<<20 | b>>(32-20) + c

		a += (((b ^ c) & d) ^ c) + X[(1+5*8)&15] + 568446438
		a = a<<5 | a>>(32-5) + b

		d += (((a ^ b) & c) ^ b) + X[(1+5*9)&15] + 3275163606
		d = d<<9 | d>>(32-9) + a

		c += (((d ^ a) & b) ^ a) + X[(1+5*10)&15] + 4107603335
		c = c<<14 | c>>(32-14) + d

		b += (((c ^ d) & a) ^ d) + X[(1+5*11)&15] + 1163531501
		b = b<<20 | b>>(32-20) + c

		a += (((b ^ c) & d) ^ c) + X[(1+5*12)&15] + 2850285829
		a = a<<5 | a>>(32-5) + b

		d += (((a ^ b) & c) ^ b) + X[(1+5*13)&15] + 4243563512
		d = d<<9 | d>>(32-9) + a

		c += (((d ^ a) & b) ^ a) + X[(1+5*14)&15] + 1735328473
		c = c<<14 | c>>(32-14) + d

		b += (((c ^ d) & a) ^ d) + X[(1+5*15)&15] + 2368359562
		b = b<<20 | b>>(32-20) + c

		// Round 3.

		a += (b ^ c ^ d) + X[(5+3*0)&15] + 4294588738
		a = a<<4 | a>>(32-4) + b

		d += (a ^ b ^ c) + X[(5+3*1)&15] + 2272392833
		d = d<<11 | d>>(32-11) + a

		c += (d ^ a ^ b) + X[(5+3*2)&15] + 1839030562
		c = c<<16 | c>>(32-16) + d

		b += (c ^ d ^ a) + X[(5+3*3)&15] + 4259657740
		b = b<<23 | b>>(32-23) + c

		a += (b ^ c ^ d) + X[(5+3*4)&15] + 2763975236
		a = a<<4 | a>>(32-4) + b

		d += (a ^ b ^ c) + X[(5+3*5)&15] + 1272893353
		d = d<<11 | d>>(32-11) + a

		c += (d ^ a ^ b) + X[(5+3*6)&15] + 4139469664
		c = c<<16 | c>>(32-16) + d

		b += (c ^ d ^ a) + X[(5+3*7)&15] + 3200236656
		b = b<<23 | b>>(32-23) + c

		a += (b ^ c ^ d) + X[(5+3*8)&15] + 681279174
		a = a<<4 | a>>(32-4) + b

		d += (a ^ b ^ c) + X[(5+3*9)&15] + 3936430074
		d = d<<11 | d>>(32-11) + a

		c += (d ^ a ^ b) + X[(5+3*10)&15] + 3572445317
		c = c<<16 | c>>(32-16) + d

		b += (c ^ d ^ a) + X[(5+3*11)&15] + 76029189
		b = b<<23 | b>>(32-23) + c

		a += (b ^ c ^ d) + X[(5+3*12)&15] + 3654602809
		a = a<<4 | a>>(32-4) + b

		d += (a ^ b ^ c) + X[(5+3*13)&15] + 3873151461
		d = d<<11 | d>>(32-11) + a

		c += (d ^ a ^ b) + X[(5+3*14)&15] + 530742520
		c = c<<16 | c>>(32-16) + d

		b += (c ^ d ^ a) + X[(5+3*15)&15] + 3299628645
		b = b<<23 | b>>(32-23) + c

		// Round 4.

		a += (c ^ (b | ^d)) + X[(7*0)&15] + 4096336452
		a = a<<6 | a>>(32-6) + b

		d += (b ^ (a | ^c)) + X[(7*1)&15] + 1126891415
		d = d<<10 | d>>(32-10) + a

		c += (a ^ (d | ^b)) + X[(7*2)&15] + 2878612391
		c = c<<15 | c>>(32-15) + d

		b += (d ^ (c | ^a)) + X[(7*3)&15] + 4237533241
		b = b<<21 | b>>(32-21) + c

		a += (c ^ (b | ^d)) + X[(7*4)&15] + 1700485571
		a = a<<6 | a>>(32-6) + b

		d += (b ^ (a | ^c)) + X[(7*5)&15] + 2399980690
		d = d<<10 | d>>(32-10) + a

		c += (a ^ (d | ^b)) + X[(7*6)&15] + 4293915773
		c = c<<15 | c>>(32-15) + d

		b += (d ^ (c | ^a)) + X[(7*7)&15] + 2240044497
		b = b<<21 | b>>(32-21) + c

		a += (c ^ (b | ^d)) + X[(7*8)&15] + 1873313359
		a = a<<6 | a>>(32-6) + b

		d += (b ^ (a | ^c)) + X[(7*9)&15] + 4264355552
		d = d<<10 | d>>(32-10) + a

		c += (a ^ (d | ^b)) + X[(7*10)&15] + 2734768916
		c = c<<15 | c>>(32-15) + d

		b += (d ^ (c | ^a)) + X[(7*11)&15] + 1309151649
		b = b<<21 | b>>(32-21) + c

		a += (c ^ (b | ^d)) + X[(7*12)&15] + 4149444226
		a = a<<6 | a>>(32-6) + b

		d += (b ^ (a | ^c)) + X[(7*13)&15] + 3174756917
		d = d<<10 | d>>(32-10) + a

		c += (a ^ (d | ^b)) + X[(7*14)&15] + 718787259
		c = c<<15 | c>>(32-15) + d

		b += (d ^ (c | ^a)) + X[(7*15)&15] + 3951481745
		b = b<<21 | b>>(32-21) + c

		a += aa
		b += bb
		c += cc
		d += dd

		p = p[chunk:]
	}

	dig.s[0] = a
	dig.s[1] = b
	dig.s[2] = c
	dig.s[3] = d
}
コード例 #25
0
ファイル: bug381.go プロジェクト: RajibTheKing/gcc
func main() {
	unsafe.Alignof(0) // ERROR "unsafe\.Alignof|value computed is not used"
	f(time.Wednesday) // ERROR "time.Wednesday|incompatible type"
}
コード例 #26
0
ファイル: ffi.cgo1.go プロジェクト: beoran/ffidll
func ffi_type_for(typ CType, elements **_C_ffi_type) _C_ffi_type {
	// I'm hoping here that GO's alignof gives us the right result
	var aid_uint8 uint8
	var aid_uint16 uint16
	var aid_uint32 uint32
	var aid_uint64 uint64
	var aid_sint8 int8
	var aid_sint16 int16
	var aid_sint32 int32
	var aid_sint64 int64
	var aid_float float32
	var aid_double float64
	var aid_pointer unsafe.Pointer

	var uint8_align = unsafe.Alignof(aid_uint8)
	var uint16_align = unsafe.Alignof(aid_uint16)
	var uint32_align = unsafe.Alignof(aid_uint32)
	var uint64_align = unsafe.Alignof(aid_uint64)
	var sint8_align = unsafe.Alignof(aid_sint8)
	var sint16_align = unsafe.Alignof(aid_sint16)
	var sint32_align = unsafe.Alignof(aid_sint32)
	var sint64_align = unsafe.Alignof(aid_sint64)
	var pointer_align = unsafe.Alignof(aid_pointer)
	var double_align = unsafe.Alignof(aid_double)
	var float_align = unsafe.Alignof(aid_float)

	var uint8_size = unsafe.Sizeof(aid_uint8)
	var uint16_size = unsafe.Sizeof(aid_uint16)
	var uint32_size = unsafe.Sizeof(aid_uint32)
	var uint64_size = unsafe.Sizeof(aid_uint64)
	var sint8_size = unsafe.Sizeof(aid_sint8)
	var sint16_size = unsafe.Sizeof(aid_sint16)
	var sint32_size = unsafe.Sizeof(aid_sint32)
	var sint64_size = unsafe.Sizeof(aid_sint64)
	var pointer_size = unsafe.Sizeof(aid_pointer)
	var double_size = unsafe.Sizeof(aid_double)
	var float_size = unsafe.Sizeof(aid_float)

	switch typ {
	case TYPE_VOID:
		return ffi_type_make(1, 1, typ, nil)
	case TYPE_POINTER:
		return ffi_type_make(pointer_size, pointer_align, typ, nil)
	case TYPE_UINT8:
		return ffi_type_make(uint8_size, uint8_align, typ, nil)
	case TYPE_SINT8:
		return ffi_type_make(sint8_size, sint8_align, typ, nil)
	case TYPE_UINT16:
		return ffi_type_make(uint16_size, uint16_align, typ, nil)
	case TYPE_SINT16:
		return ffi_type_make(sint16_size, sint16_align, typ, nil)
	case TYPE_UINT32:
		return ffi_type_make(uint32_size, uint32_align, typ, nil)
	case TYPE_SINT32:
		return ffi_type_make(sint32_size, sint32_align, typ, nil)
	case TYPE_UINT64:
		return ffi_type_make(uint64_size, uint64_align, typ, nil)
	case TYPE_SINT64:
		return ffi_type_make(sint64_size, sint64_align, typ, nil)
	case TYPE_FLOAT:
		return ffi_type_make(float_size, float_align, typ, nil)
	case TYPE_DOUBLE:
		return ffi_type_make(double_size, double_align, typ, nil)
	default: // struct
		return ffi_type_make(0, 0, typ, elements)
	}
	// we cannot get here, but go complains, so ...
	return ffi_type_make(1, 1, typ, nil)

}
コード例 #27
0
ファイル: issue4463.go プロジェクト: qunhu/go_src_comment
func F() {
	var a []int
	var c chan int
	var m map[int]int
	var s struct{ f int }

	append(a, 0)         // ERROR "not used"
	cap(a)               // ERROR "not used"
	complex(1, 2)        // ERROR "not used"
	imag(1i)             // ERROR "not used"
	len(a)               // ERROR "not used"
	make([]int, 10)      // ERROR "not used"
	new(int)             // ERROR "not used"
	real(1i)             // ERROR "not used"
	unsafe.Alignof(a)    // ERROR "not used"
	unsafe.Offsetof(s.f) // ERROR "not used"
	unsafe.Sizeof(a)     // ERROR "not used"

	close(c)
	copy(a, a)
	delete(m, 0)
	panic(0)
	print("foo")
	println("bar")
	recover()

	(close(c))
	(copy(a, a))
	(delete(m, 0))
	(panic(0))
	(print("foo"))
	(println("bar"))
	(recover())

	go append(a, 0)         // ERROR "discards result"
	go cap(a)               // ERROR "discards result"
	go complex(1, 2)        // ERROR "discards result"
	go imag(1i)             // ERROR "discards result"
	go len(a)               // ERROR "discards result"
	go make([]int, 10)      // ERROR "discards result"
	go new(int)             // ERROR "discards result"
	go real(1i)             // ERROR "discards result"
	go unsafe.Alignof(a)    // ERROR "discards result"
	go unsafe.Offsetof(s.f) // ERROR "discards result"
	go unsafe.Sizeof(a)     // ERROR "discards result"

	go close(c)
	go copy(a, a)
	go delete(m, 0)
	go panic(0)
	go print("foo")
	go println("bar")
	go recover()

	defer append(a, 0)         // ERROR "discards result"
	defer cap(a)               // ERROR "discards result"
	defer complex(1, 2)        // ERROR "discards result"
	defer imag(1i)             // ERROR "discards result"
	defer len(a)               // ERROR "discards result"
	defer make([]int, 10)      // ERROR "discards result"
	defer new(int)             // ERROR "discards result"
	defer real(1i)             // ERROR "discards result"
	defer unsafe.Alignof(a)    // ERROR "discards result"
	defer unsafe.Offsetof(s.f) // ERROR "discards result"
	defer unsafe.Sizeof(a)     // ERROR "discards result"

	defer close(c)
	defer copy(a, a)
	defer delete(m, 0)
	defer panic(0)
	defer print("foo")
	defer println("bar")
	defer recover()
}
コード例 #28
0
ファイル: tasker-cortexm.go プロジェクト: rjammala/emgo
func (ts *taskSched) init() {
	var vt []exce.Vector
	vtlen := 1 << irtExp()
	vtsize := vtlen * int(unsafe.Sizeof(exce.Vector{}))

	Heap = allocTop(
		unsafe.Pointer(&vt), Heap,
		vtlen, unsafe.Sizeof(exce.Vector{}), unsafe.Alignof(exce.Vector{}),
		uintptr(vtsize),
	)
	if Heap == nil {
		panicMemory()
	}

	Heap = allocTop(
		unsafe.Pointer(&ts.tasks), Heap,
		MaxTasks(), unsafe.Sizeof(taskInfo{}), unsafe.Alignof(taskInfo{}),
		unsafe.Alignof(taskInfo{}),
	)
	if Heap == nil {
		panicMemory()
	}

	// Set taskInfo for initial (current) task.
	ts.tasks[0].prio = 255
	ts.tasks[0].setState(taskReady)

	// Use PSP as stack pointer for thread mode.
	cortexm.SetPSP(unsafe.Pointer(cortexm.MSP()))
	barrier.Sync()
	cortexm.SetCtrl(cortexm.Ctrl() | cortexm.UsePSP)
	cortexm.ISB()

	// Now MSP is used only by exceptions handlers.
	cortexm.SetMSP(unsafe.Pointer(initSP(len(ts.tasks))))

	// Setup interrupt table.
	// Consider setup at link time using GCC weak functions to support Cortex-M0
	// and (in case of Cortex-M3,4) to allow vector load on the ICode bus
	// simultaneously with registers stacking on DCode bus.
	vt[exce.NMI] = exce.VectorFor(nmiHandler)
	vt[exce.HardFault] = exce.VectorFor(hardFaultHandler)
	vt[exce.MemFault] = exce.VectorFor(memFaultHandler)
	vt[exce.BusFault] = exce.VectorFor(busFaultHandler)
	vt[exce.UsageFault] = exce.VectorFor(usageFaultHandler)
	vt[exce.SVCall] = exce.VectorFor(svcHandler)
	vt[exce.PendSV] = exce.VectorFor(pendSVHandler)
	vt[exce.SysTick] = exce.VectorFor(sysTickHandler)
	exce.UseTable(vt)

	exce.MemFault.Enable()
	exce.BusFault.Enable()
	exce.UsageFault.Enable()

	exce.SVCall.SetPrio(exce.Lowest)
	exce.PendSV.SetPrio(exce.Lowest)

	sysTickStart()
	tasker.forceNext = -1
	tasker.run()
}
コード例 #29
0
func main() {
	unsafe.Alignof(0) // ERROR "unsafe\.Alignof|value computed is not used"
}