134 lines
2.7 KiB
Go
134 lines
2.7 KiB
Go
// RUN: llgo -o %t %s
|
|
// RUN: %t 2>&1 | FileCheck %s
|
|
|
|
// CHECK: 4096
|
|
// CHECK-NEXT: 256
|
|
// CHECK-NEXT: 0
|
|
// CHECK-NEXT: 0
|
|
// CHECK-NEXT: 4096
|
|
// CHECK-NEXT: 256
|
|
// CHECK-NEXT: 0
|
|
// CHECK-NEXT: 0
|
|
// CHECK-NEXT: 65280
|
|
// CHECK-NEXT: 0
|
|
// CHECK-NEXT: 0
|
|
// CHECK-NEXT: 0
|
|
// CHECK-NEXT: 61184
|
|
// CHECK-NEXT: 65024
|
|
// CHECK-NEXT: 65296
|
|
// CHECK-NEXT: 65281
|
|
// CHECK-NEXT: 61184
|
|
// CHECK-NEXT: 65024
|
|
// CHECK-NEXT: 65296
|
|
// CHECK-NEXT: 65281
|
|
// CHECK-NEXT: -62
|
|
// CHECK-NEXT: -246
|
|
// CHECK-NEXT: +1.224560e+002
|
|
// CHECK-NEXT: 3
|
|
// CHECK-NEXT: 3
|
|
// CHECK-NEXT: 4
|
|
// CHECK-NEXT: 122
|
|
// CHECK-NEXT: -124
|
|
// CHECK-NEXT: 120
|
|
// CHECK-NEXT: 18446744073709547520
|
|
// CHECK-NEXT: false
|
|
// CHECK-NEXT: 2147483648
|
|
// CHECK-NEXT: 9223372036854775808
|
|
// CHECK-NEXT: 2147483648 2147483648
|
|
// CHECK-NEXT: 9223372036854775808 9223372036854775808
|
|
|
|
package main
|
|
|
|
import "unsafe"
|
|
|
|
var global string
|
|
|
|
var hi = 0xFF00
|
|
var lo = 0xFF00
|
|
|
|
// borrowed from math package to avoid dependency on standard library
|
|
func float32bits(f float32) uint32 { return *(*uint32)(unsafe.Pointer(&f)) }
|
|
func float64bits(f float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
|
|
|
|
func main() {
|
|
println(hi & 0x1000)
|
|
println(hi & 0x0100)
|
|
println(hi & 0x0010)
|
|
println(hi & 0x0001)
|
|
println(lo & 0x1000)
|
|
println(lo & 0x0100)
|
|
println(lo & 0x0010)
|
|
println(lo & 0x0001)
|
|
println(hi | lo)
|
|
println(hi ^ hi)
|
|
println(hi ^ lo)
|
|
println(lo ^ lo)
|
|
println(hi ^ 0x1000)
|
|
println(hi ^ 0x0100)
|
|
println(hi ^ 0x0010)
|
|
println(hi ^ 0x0001)
|
|
println(lo ^ 0x1000)
|
|
println(lo ^ 0x0100)
|
|
println(lo ^ 0x0010)
|
|
println(lo ^ 0x0001)
|
|
println(-123 >> 1)
|
|
println(-123 << 1)
|
|
|
|
var f float64 = 123.456
|
|
f--
|
|
println(f)
|
|
|
|
// context of '&' op is used to type the untyped lhs
|
|
// operand of the shift expression.
|
|
shift := uint(2)
|
|
println(uint64(0xFFFFFFFF) & (1<<shift - 1))
|
|
println((1<<shift - 1) & uint64(0xFFFFFFFF))
|
|
|
|
// rhs' type is converted lhs'
|
|
println(uint32(1) << uint64(2))
|
|
{
|
|
var _uint64 uint64
|
|
var _uint uint
|
|
x := _uint64 >> (63 - _uint)
|
|
if x == 2<<_uint {
|
|
println("!")
|
|
}
|
|
}
|
|
|
|
// There was a bug related to compound expressions involving
|
|
// multiple binary logical operators.
|
|
var a, b, c int
|
|
if a == 0 && (b != 0 || c != 0) {
|
|
println("!")
|
|
}
|
|
|
|
var si int = -123
|
|
var ui int = 123
|
|
println(^si)
|
|
println(^ui)
|
|
println(ui &^ 3)
|
|
|
|
// test case from math/modf.go
|
|
var x uint64 = 0xFFFFFFFFFFFFFFFF
|
|
var e uint = 40
|
|
x &^= 1<<(64-12-e) - 1
|
|
println(x)
|
|
|
|
// compare global to non-global
|
|
println(new(string) == &global)
|
|
|
|
// negative zero
|
|
var f32 float32
|
|
var f64 float64
|
|
var c64 complex64
|
|
var c128 complex128
|
|
f32 = -f32
|
|
f64 = -f64
|
|
c64 = -c64
|
|
c128 = -c128
|
|
println(float32bits(f32))
|
|
println(float64bits(f64))
|
|
println(float32bits(real(c64)), float32bits(imag(c64)))
|
|
println(float64bits(real(c128)), float64bits(imag(c128)))
|
|
}
|