github.com/llvm-mirror/llgo@v0.0.0-20190322182713-bf6f0a60fce1/test/execution/operators/basics.go (about)

     1  // RUN: llgo -o %t %s
     2  // RUN: %t 2>&1 | FileCheck %s
     3  
     4  // CHECK: 4096
     5  // CHECK-NEXT: 256
     6  // CHECK-NEXT: 0
     7  // CHECK-NEXT: 0
     8  // CHECK-NEXT: 4096
     9  // CHECK-NEXT: 256
    10  // CHECK-NEXT: 0
    11  // CHECK-NEXT: 0
    12  // CHECK-NEXT: 65280
    13  // CHECK-NEXT: 0
    14  // CHECK-NEXT: 0
    15  // CHECK-NEXT: 0
    16  // CHECK-NEXT: 61184
    17  // CHECK-NEXT: 65024
    18  // CHECK-NEXT: 65296
    19  // CHECK-NEXT: 65281
    20  // CHECK-NEXT: 61184
    21  // CHECK-NEXT: 65024
    22  // CHECK-NEXT: 65296
    23  // CHECK-NEXT: 65281
    24  // CHECK-NEXT: -62
    25  // CHECK-NEXT: -246
    26  // CHECK-NEXT: +1.224560e+002
    27  // CHECK-NEXT: 3
    28  // CHECK-NEXT: 3
    29  // CHECK-NEXT: 4
    30  // CHECK-NEXT: 122
    31  // CHECK-NEXT: -124
    32  // CHECK-NEXT: 120
    33  // CHECK-NEXT: 18446744073709547520
    34  // CHECK-NEXT: false
    35  // CHECK-NEXT: 2147483648
    36  // CHECK-NEXT: 9223372036854775808
    37  // CHECK-NEXT: 2147483648 2147483648
    38  // CHECK-NEXT: 9223372036854775808 9223372036854775808
    39  
    40  package main
    41  
    42  import "unsafe"
    43  
    44  var global string
    45  
    46  var hi = 0xFF00
    47  var lo = 0xFF00
    48  
    49  // borrowed from math package to avoid dependency on standard library
    50  func float32bits(f float32) uint32 { return *(*uint32)(unsafe.Pointer(&f)) }
    51  func float64bits(f float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }
    52  
    53  func main() {
    54  	println(hi & 0x1000)
    55  	println(hi & 0x0100)
    56  	println(hi & 0x0010)
    57  	println(hi & 0x0001)
    58  	println(lo & 0x1000)
    59  	println(lo & 0x0100)
    60  	println(lo & 0x0010)
    61  	println(lo & 0x0001)
    62  	println(hi | lo)
    63  	println(hi ^ hi)
    64  	println(hi ^ lo)
    65  	println(lo ^ lo)
    66  	println(hi ^ 0x1000)
    67  	println(hi ^ 0x0100)
    68  	println(hi ^ 0x0010)
    69  	println(hi ^ 0x0001)
    70  	println(lo ^ 0x1000)
    71  	println(lo ^ 0x0100)
    72  	println(lo ^ 0x0010)
    73  	println(lo ^ 0x0001)
    74  	println(-123 >> 1)
    75  	println(-123 << 1)
    76  
    77  	var f float64 = 123.456
    78  	f--
    79  	println(f)
    80  
    81  	// context of '&' op is used to type the untyped lhs
    82  	// operand of the shift expression.
    83  	shift := uint(2)
    84  	println(uint64(0xFFFFFFFF) & (1<<shift - 1))
    85  	println((1<<shift - 1) & uint64(0xFFFFFFFF))
    86  
    87  	// rhs' type is converted lhs'
    88  	println(uint32(1) << uint64(2))
    89  	{
    90  		var _uint64 uint64
    91  		var _uint uint
    92  		x := _uint64 >> (63 - _uint)
    93  		if x == 2<<_uint {
    94  			println("!")
    95  		}
    96  	}
    97  
    98  	// There was a bug related to compound expressions involving
    99  	// multiple binary logical operators.
   100  	var a, b, c int
   101  	if a == 0 && (b != 0 || c != 0) {
   102  		println("!")
   103  	}
   104  
   105  	var si int = -123
   106  	var ui int = 123
   107  	println(^si)
   108  	println(^ui)
   109  	println(ui &^ 3)
   110  
   111  	// test case from math/modf.go
   112  	var x uint64 = 0xFFFFFFFFFFFFFFFF
   113  	var e uint = 40
   114  	x &^= 1<<(64-12-e) - 1
   115  	println(x)
   116  
   117  	// compare global to non-global
   118  	println(new(string) == &global)
   119  
   120  	// negative zero
   121  	var f32 float32
   122  	var f64 float64
   123  	var c64 complex64
   124  	var c128 complex128
   125  	f32 = -f32
   126  	f64 = -f64
   127  	c64 = -c64
   128  	c128 = -c128
   129  	println(float32bits(f32))
   130  	println(float64bits(f64))
   131  	println(float32bits(real(c64)), float32bits(imag(c64)))
   132  	println(float64bits(real(c128)), float64bits(imag(c128)))
   133  }