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

// This file contains rules to decompose [u]int64 types on 32-bit
// architectures. These rules work together with the decomposeBuiltin
// pass which handles phis of these typ.

(Last ___) => v.Args[len(v.Args)-1]

(Int64Hi (Int64Make hi _)) => hi
(Int64Lo (Int64Make _ lo)) => lo
(Select0 (MakeTuple x y)) => x
(Select1 (MakeTuple x y)) => y

(Load <t> ptr mem) && ssa.Is64BitInt(t) && !config.BigEndian && t.IsSigned() =>
	(Int64Make
		(Load <typ.Int32> (OffPtr <typ.Int32Ptr> [4] ptr) mem)
		(Load <typ.UInt32> ptr mem))

(Load <t> ptr mem) && ssa.Is64BitInt(t) && !config.BigEndian && !t.IsSigned() =>
	(Int64Make
		(Load <typ.UInt32> (OffPtr <typ.UInt32Ptr> [4] ptr) mem)
		(Load <typ.UInt32> ptr mem))

(Load <t> ptr mem) && ssa.Is64BitInt(t) && config.BigEndian && t.IsSigned() =>
	(Int64Make
		(Load <typ.Int32> ptr mem)
		(Load <typ.UInt32> (OffPtr <typ.UInt32Ptr> [4] ptr) mem))

(Load <t> ptr mem) && ssa.Is64BitInt(t) && config.BigEndian && !t.IsSigned() =>
	(Int64Make
		(Load <typ.UInt32> ptr mem)
		(Load <typ.UInt32> (OffPtr <typ.UInt32Ptr> [4] ptr) mem))

(Store {t} dst (Int64Make hi lo) mem) && t.Size() == 8 && !config.BigEndian =>
	(Store {hi.Type}
		(OffPtr <hi.Type.PtrTo()> [4] dst)
		hi
		(Store {lo.Type} dst lo mem))

(Store {t} dst (Int64Make hi lo) mem) && t.Size() == 8 && config.BigEndian =>
	(Store {lo.Type}
		(OffPtr <lo.Type.PtrTo()> [4] dst)
		lo
		(Store {hi.Type} dst hi mem))

// These are not enabled during decomposeBuiltin if late call expansion, but they are always enabled for softFloat
(Arg {n} [off]) && ssa.Is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(b.Func.Pass.Name == "decompose builtin") =>
  (Int64Make
    (Arg <typ.Int32> {n} [off+4])
    (Arg <typ.UInt32> {n} [off]))
(Arg {n} [off]) && ssa.Is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(b.Func.Pass.Name == "decompose builtin")  =>
  (Int64Make
    (Arg <typ.UInt32> {n} [off+4])
    (Arg <typ.UInt32> {n} [off]))

(Arg {n} [off]) && ssa.Is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(b.Func.Pass.Name == "decompose builtin") =>
  (Int64Make
    (Arg <typ.Int32> {n} [off])
    (Arg <typ.UInt32> {n} [off+4]))
(Arg {n} [off]) && ssa.Is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(b.Func.Pass.Name == "decompose builtin") =>
  (Int64Make
    (Arg <typ.UInt32> {n} [off])
    (Arg <typ.UInt32> {n} [off+4]))

(Add64 <t> x y) =>
	(Last <t>
		x0: (Int64Lo x)
		x1: (Int64Hi x)
		y0: (Int64Lo y)
		y1: (Int64Hi y)
		add: (Add32carry x0 y0)
		(Int64Make
			(Add32withcarry <typ.UInt32> x1 y1 (Select1 <types.TypeFlags> add))
			(Select0 <typ.UInt32> add)))

(Sub64 <t> x y) =>
	(Last <t>
		x0: (Int64Lo x)
		x1: (Int64Hi x)
		y0: (Int64Lo y)
		y1: (Int64Hi y)
		sub: (Sub32carry x0 y0)
		(Int64Make
			(Sub32withcarry <typ.UInt32> x1 y1 (Select1 <types.TypeFlags> sub))
			(Select0 <typ.UInt32> sub)))

(Mul64 <t> x y) =>
	(Last <t>
		x0: (Int64Lo x)
		x1: (Int64Hi x)
		y0: (Int64Lo y)
		y1: (Int64Hi y)
		x0y0: (Mul32uhilo x0 y0)
		x0y0Hi: (Select0 <typ.UInt32> x0y0)
		x0y0Lo: (Select1 <typ.UInt32> x0y0)
		(Int64Make
			(Add32 <typ.UInt32> x0y0Hi
				(Add32 <typ.UInt32>
					(Mul32 <typ.UInt32> x0 y1)
					(Mul32 <typ.UInt32> x1 y0)))
			x0y0Lo))

(Mul64uhilo <t> x y) =>
	(Last <t>
		x0: (Int64Lo x)
		x1: (Int64Hi x)
		y0: (Int64Lo y)
		y1: (Int64Hi y)
		x0y0: (Mul32uhilo x0 y0)
		x0y1: (Mul32uhilo x0 y1)
		x1y0: (Mul32uhilo x1 y0)
		x1y1: (Mul32uhilo x1 y1)
		x0y0Hi: (Select0 <typ.UInt32> x0y0)
		x0y0Lo: (Select1 <typ.UInt32> x0y0)
		x0y1Hi: (Select0 <typ.UInt32> x0y1)
		x0y1Lo: (Select1 <typ.UInt32> x0y1)
		x1y0Hi: (Select0 <typ.UInt32> x1y0)
		x1y0Lo: (Select1 <typ.UInt32> x1y0)
		x1y1Hi: (Select0 <typ.UInt32> x1y1)
		x1y1Lo: (Select1 <typ.UInt32> x1y1)
		w1a: (Add32carry x0y0Hi x0y1Lo)
		w2a: (Add32carrywithcarry x0y1Hi x1y0Hi (Select1 <types.TypeFlags> w1a))
		w3a: (Add32withcarry <typ.UInt32> x1y1Hi (Const32 <typ.UInt32> [0]) (Select1 <types.TypeFlags> w2a))
		w1b: (Add32carry x1y0Lo (Select0 <typ.UInt32> w1a))
		w2b: (Add32carrywithcarry x1y1Lo (Select0 <typ.UInt32> w2a) (Select1 <types.TypeFlags> w1b))
		w3b: (Add32withcarry <typ.UInt32> w3a (Const32 <typ.UInt32> [0]) (Select1 <types.TypeFlags> w2b))
		(MakeTuple <types.NewTuple(typ.UInt64,typ.UInt64)>
			(Int64Make w3b (Select0 <typ.UInt32> w2b))
			(Int64Make (Select0 <typ.UInt32> w1b) x0y0Lo)))

(Hmul64u x y) => (Select0 (Mul64uhilo x y))

// Hacker's Delight p. 175: signed hmul = unsigned hmul - (x<0)&y - (y<0)&x.
(Hmul64 x y) =>
	(Last
		p: (Hmul64u <typ.UInt64> x y)
		xSign: (Int64Make xs:(Rsh32x32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [31])) xs)
		ySign: (Int64Make ys:(Rsh32x32 <typ.UInt32> (Int64Hi y) (Const32 <typ.UInt32> [31])) ys)
		(Sub64 <typ.Int64> (Sub64 <typ.Int64> p (And64 <typ.Int64> xSign y)) (And64 <typ.Int64> ySign x)))

// (x+y)/2 => (x-y)/2 + y
(Avg64u <t> x y) => (Add64 (Rsh64Ux32 <t> (Sub64 <t> x y) (Const32 <typ.UInt32> [1])) y)


(And64 x y) =>
	(Int64Make
		(And32 <typ.UInt32> (Int64Hi x) (Int64Hi y))
		(And32 <typ.UInt32> (Int64Lo x) (Int64Lo y)))

(Or64 x y) =>
	(Int64Make
		(Or32 <typ.UInt32> (Int64Hi x) (Int64Hi y))
		(Or32 <typ.UInt32> (Int64Lo x) (Int64Lo y)))

(Xor64 x y) =>
	(Int64Make
		(Xor32 <typ.UInt32> (Int64Hi x) (Int64Hi y))
		(Xor32 <typ.UInt32> (Int64Lo x) (Int64Lo y)))

(Neg64 <t> x) => (Sub64 (Const64 <t> [0]) x)

(Com64 x) =>
	(Int64Make
		(Com32 <typ.UInt32> (Int64Hi x))
		(Com32 <typ.UInt32> (Int64Lo x)))

// Sadly, just because we know that x is non-zero,
// we don't know whether either component is,
// so just treat Ctz64NonZero the same as Ctz64.
(Ctz64NonZero ...) => (Ctz64 ...)

(Ctz64 x) =>
	(Add32 <typ.UInt32>
		(Ctz32 <typ.UInt32> (Int64Lo x))
		(And32 <typ.UInt32>
			(Com32 <typ.UInt32> (Zeromask (Int64Lo x)))
			(Ctz32 <typ.UInt32> (Int64Hi x))))

(BitLen64 x) =>
	(Add32 <typ.Int>
		(BitLen32 <typ.Int> (Int64Hi x))
		(BitLen32 <typ.Int>
			(Or32 <typ.UInt32>
				(Int64Lo x)
				(Zeromask (Int64Hi x)))))

(Bswap64 x) =>
	(Int64Make
		(Bswap32 <typ.UInt32> (Int64Lo x))
		(Bswap32 <typ.UInt32> (Int64Hi x)))

(SignExt32to64 x) => (Int64Make (Signmask x) x)
(SignExt16to64 x) => (SignExt32to64 (SignExt16to32 x))
(SignExt8to64 x) => (SignExt32to64 (SignExt8to32 x))

(ZeroExt32to64 x) => (Int64Make (Const32 <typ.UInt32> [0]) x)
(ZeroExt16to64 x) => (ZeroExt32to64 (ZeroExt16to32 x))
(ZeroExt8to64 x) => (ZeroExt32to64 (ZeroExt8to32 x))

(Trunc64to32 (Int64Make _ lo)) => lo
(Trunc64to16 (Int64Make _ lo)) => (Trunc32to16 lo)
(Trunc64to8 (Int64Make _ lo)) => (Trunc32to8 lo)
// Most general
(Trunc64to32 x) => (Int64Lo x)
(Trunc64to16 x) => (Trunc32to16 (Int64Lo x))
(Trunc64to8 x) => (Trunc32to8 (Int64Lo x))

(Lsh32x64 _ (Int64Make (Const32 [c]) _)) && c != 0 => (Const32 [0])
(Rsh32x64 x (Int64Make (Const32 [c]) _)) && c != 0 => (Signmask x)
(Rsh32Ux64 _ (Int64Make (Const32 [c]) _)) && c != 0 => (Const32 [0])
(Lsh16x64 _ (Int64Make (Const32 [c]) _)) && c != 0 => (Const32 [0])
(Rsh16x64 x (Int64Make (Const32 [c]) _)) && c != 0 => (Signmask (SignExt16to32 x))
(Rsh16Ux64 _ (Int64Make (Const32 [c]) _)) && c != 0 => (Const32 [0])
(Lsh8x64 _ (Int64Make (Const32 [c]) _)) && c != 0 => (Const32 [0])
(Rsh8x64 x (Int64Make (Const32 [c]) _)) && c != 0 => (Signmask (SignExt8to32 x))
(Rsh8Ux64 _ (Int64Make (Const32 [c]) _)) && c != 0 => (Const32 [0])

(Lsh32x64 [c] x (Int64Make (Const32 [0]) lo)) => (Lsh32x32 [c] x lo)
(Rsh32x64 [c] x (Int64Make (Const32 [0]) lo)) => (Rsh32x32 [c] x lo)
(Rsh32Ux64 [c] x (Int64Make (Const32 [0]) lo)) => (Rsh32Ux32 [c] x lo)
(Lsh16x64 [c] x (Int64Make (Const32 [0]) lo)) => (Lsh16x32 [c] x lo)
(Rsh16x64 [c] x (Int64Make (Const32 [0]) lo)) => (Rsh16x32 [c] x lo)
(Rsh16Ux64 [c] x (Int64Make (Const32 [0]) lo)) => (Rsh16Ux32 [c] x lo)
(Lsh8x64 [c] x (Int64Make (Const32 [0]) lo)) => (Lsh8x32 [c] x lo)
(Rsh8x64 [c] x (Int64Make (Const32 [0]) lo)) => (Rsh8x32 [c] x lo)
(Rsh8Ux64 [c] x (Int64Make (Const32 [0]) lo)) => (Rsh8Ux32 [c] x lo)

(Lsh64x64 _ (Int64Make (Const32 [c]) _)) && c != 0 => (Const64 [0])
(Rsh64x64 x (Int64Make (Const32 [c]) _)) && c != 0 => (Int64Make (Signmask (Int64Hi x)) (Signmask (Int64Hi x)))
(Rsh64Ux64 _ (Int64Make (Const32 [c]) _)) && c != 0 => (Const64 [0])

(Lsh64x64 [c] x (Int64Make (Const32 [0]) lo)) => (Lsh64x32 [c] x lo)
(Rsh64x64 [c] x (Int64Make (Const32 [0]) lo)) => (Rsh64x32 [c] x lo)
(Rsh64Ux64 [c] x (Int64Make (Const32 [0]) lo)) => (Rsh64Ux32 [c] x lo)

// turn x64 non-constant shifts to x32 shifts
// if high 32-bit of the shift is nonzero, make a huge shift
(Lsh64x64 x (Int64Make hi lo)) && hi.Op != ssaop.OpConst32 =>
       (Lsh64x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
(Rsh64x64 x (Int64Make hi lo)) && hi.Op != ssaop.OpConst32 =>
       (Rsh64x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
(Rsh64Ux64 x (Int64Make hi lo)) && hi.Op != ssaop.OpConst32 =>
       (Rsh64Ux32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
(Lsh32x64 x (Int64Make hi lo)) && hi.Op != ssaop.OpConst32 =>
       (Lsh32x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
(Rsh32x64 x (Int64Make hi lo)) && hi.Op != ssaop.OpConst32 =>
       (Rsh32x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
(Rsh32Ux64 x (Int64Make hi lo)) && hi.Op != ssaop.OpConst32 =>
       (Rsh32Ux32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
(Lsh16x64 x (Int64Make hi lo)) && hi.Op != ssaop.OpConst32 =>
       (Lsh16x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
(Rsh16x64 x (Int64Make hi lo)) && hi.Op != ssaop.OpConst32 =>
       (Rsh16x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
(Rsh16Ux64 x (Int64Make hi lo)) && hi.Op != ssaop.OpConst32 =>
       (Rsh16Ux32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
(Lsh8x64 x (Int64Make hi lo)) && hi.Op != ssaop.OpConst32 =>
       (Lsh8x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
(Rsh8x64 x (Int64Make hi lo)) && hi.Op != ssaop.OpConst32 =>
       (Rsh8x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
(Rsh8Ux64 x (Int64Make hi lo)) && hi.Op != ssaop.OpConst32 =>
       (Rsh8Ux32 x (Or32 <typ.UInt32> (Zeromask hi) lo))

// Most general
(Lsh64x64 x y)  => (Lsh64x32  x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
(Rsh64x64 x y)  => (Rsh64x32  x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
(Rsh64Ux64 x y) => (Rsh64Ux32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
(Lsh32x64 x y)  => (Lsh32x32  x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
(Rsh32x64 x y)  => (Rsh32x32  x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
(Rsh32Ux64 x y) => (Rsh32Ux32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
(Lsh16x64 x y)  => (Lsh16x32  x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
(Rsh16x64 x y)  => (Rsh16x32  x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
(Rsh16Ux64 x y) => (Rsh16Ux32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
(Lsh8x64 x y)   => (Lsh8x32   x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
(Rsh8x64 x y)   => (Rsh8x32   x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
(Rsh8Ux64 x y)  => (Rsh8Ux32  x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))


(RotateLeft64 x (Int64Make hi lo)) => (RotateLeft64 x lo)
(RotateLeft32 x (Int64Make hi lo)) => (RotateLeft32 x lo)
(RotateLeft16 x (Int64Make hi lo)) => (RotateLeft16 x lo)
(RotateLeft8  x (Int64Make hi lo)) => (RotateLeft8  x lo)

// RotateLeft64 by constant, for use in divmod.
(RotateLeft64 <t> x (Const(64|32|16|8) [c])) && c&63 == 0 => x
(RotateLeft64 <t> x (Const(64|32|16|8) [c])) && c&63 == 32 => (Int64Make <t> (Int64Lo x) (Int64Hi x))
(RotateLeft64 <t> x (Const(64|32|16|8) [c])) && 0 < c&63 && c&63 < 32 =>
	(Int64Make <t>
		(Or32 <typ.UInt32>
			(Lsh32x32  <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(c&31)]))
			(Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(32-c&31)])))
		(Or32 <typ.UInt32>
			(Lsh32x32  <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(c&31)]))
			(Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(32-c&31)]))))
(RotateLeft64 <t> x (Const(64|32|16|8) [c])) && 32 < c&63 && c&63 < 64 =>
	(Int64Make <t>
		(Or32 <typ.UInt32>
			(Lsh32x32  <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(c&31)]))
			(Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(32-c&31)])))
		(Or32 <typ.UInt32>
			(Lsh32x32  <typ.UInt32> (Int64Hi x) (Const32 <typ.UInt32> [int32(c&31)]))
			(Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Const32 <typ.UInt32> [int32(32-c&31)]))))

// Clean up constants a little
(Or32 <typ.UInt32> (Zeromask (Const32 [c])) y) && c == 0 => y
(Or32 <typ.UInt32> (Zeromask (Const32 [c])) y) && c != 0 => (Const32 <typ.UInt32> [-1])

// 64x left shift
// result.hi = hi<<s | lo>>(32-s) | lo<<(s-32) // >> is unsigned, large shifts result 0
// result.lo = lo<<s
(Lsh64x32 x s) =>
	(Int64Make
		(Or32 <typ.UInt32>
			(Or32 <typ.UInt32>
				(Lsh32x32 <typ.UInt32> (Int64Hi x) s)
				(Rsh32Ux32 <typ.UInt32>
					(Int64Lo x)
					(Sub32 <typ.UInt32> (Const32 <typ.UInt32> [32]) s)))
			(Lsh32x32 <typ.UInt32>
				(Int64Lo x)
				(Sub32 <typ.UInt32> s (Const32 <typ.UInt32> [32]))))
		(Lsh32x32 <typ.UInt32> (Int64Lo x) s))
(Lsh64x16 x s) =>
	(Int64Make
		(Or32 <typ.UInt32>
			(Or32 <typ.UInt32>
				(Lsh32x16 <typ.UInt32> (Int64Hi x) s)
				(Rsh32Ux16 <typ.UInt32>
					(Int64Lo x)
					(Sub16 <typ.UInt16> (Const16 <typ.UInt16> [32]) s)))
			(Lsh32x16 <typ.UInt32>
				(Int64Lo x)
				(Sub16 <typ.UInt16> s (Const16 <typ.UInt16> [32]))))
		(Lsh32x16 <typ.UInt32> (Int64Lo x) s))
(Lsh64x8 x s) =>
	(Int64Make
		(Or32 <typ.UInt32>
			(Or32 <typ.UInt32>
				(Lsh32x8 <typ.UInt32> (Int64Hi x) s)
				(Rsh32Ux8 <typ.UInt32>
					(Int64Lo x)
					(Sub8 <typ.UInt8> (Const8 <typ.UInt8> [32]) s)))
			(Lsh32x8 <typ.UInt32>
				(Int64Lo x)
				(Sub8 <typ.UInt8> s (Const8 <typ.UInt8> [32]))))
		(Lsh32x8 <typ.UInt32> (Int64Lo x) s))

// 64x unsigned right shift
// result.hi = hi>>s
// result.lo = lo>>s | hi<<(32-s) | hi>>(s-32) // >> is unsigned, large shifts result 0
(Rsh64Ux32 x s) =>
	(Int64Make
		(Rsh32Ux32 <typ.UInt32> (Int64Hi x) s)
		(Or32 <typ.UInt32>
			(Or32 <typ.UInt32>
				(Rsh32Ux32 <typ.UInt32> (Int64Lo x) s)
				(Lsh32x32 <typ.UInt32>
					(Int64Hi x)
					(Sub32 <typ.UInt32> (Const32 <typ.UInt32> [32]) s)))
			(Rsh32Ux32 <typ.UInt32>
				(Int64Hi x)
				(Sub32 <typ.UInt32> s (Const32 <typ.UInt32> [32])))))
(Rsh64Ux16 x s) =>
	(Int64Make
		(Rsh32Ux16 <typ.UInt32> (Int64Hi x) s)
		(Or32 <typ.UInt32>
			(Or32 <typ.UInt32>
				(Rsh32Ux16 <typ.UInt32> (Int64Lo x) s)
				(Lsh32x16 <typ.UInt32>
					(Int64Hi x)
					(Sub16 <typ.UInt16> (Const16 <typ.UInt16> [32]) s)))
			(Rsh32Ux16 <typ.UInt32>
				(Int64Hi x)
				(Sub16 <typ.UInt16> s (Const16 <typ.UInt16> [32])))))
(Rsh64Ux8 x s) =>
	(Int64Make
		(Rsh32Ux8 <typ.UInt32> (Int64Hi x) s)
		(Or32 <typ.UInt32>
			(Or32 <typ.UInt32>
				(Rsh32Ux8 <typ.UInt32> (Int64Lo x) s)
				(Lsh32x8 <typ.UInt32>
					(Int64Hi x)
					(Sub8 <typ.UInt8> (Const8 <typ.UInt8> [32]) s)))
			(Rsh32Ux8 <typ.UInt32>
				(Int64Hi x)
				(Sub8 <typ.UInt8> s (Const8 <typ.UInt8> [32])))))

// 64x signed right shift
// result.hi = hi>>s
// result.lo = lo>>s | hi<<(32-s) | (hi>>(s-32))&zeromask(s>>5) // hi>>(s-32) is signed, large shifts result 0/-1
(Rsh64x32 x s) =>
	(Int64Make
		(Rsh32x32 <typ.UInt32> (Int64Hi x) s)
		(Or32 <typ.UInt32>
			(Or32 <typ.UInt32>
				(Rsh32Ux32 <typ.UInt32> (Int64Lo x) s)
				(Lsh32x32 <typ.UInt32>
					(Int64Hi x)
					(Sub32 <typ.UInt32> (Const32 <typ.UInt32> [32]) s)))
			(And32 <typ.UInt32>
				(Rsh32x32 <typ.UInt32>
					(Int64Hi x)
					(Sub32 <typ.UInt32> s (Const32 <typ.UInt32> [32])))
				(Zeromask
					(Rsh32Ux32 <typ.UInt32> s (Const32 <typ.UInt32> [5]))))))
(Rsh64x16 x s) =>
	(Int64Make
		(Rsh32x16 <typ.UInt32> (Int64Hi x) s)
		(Or32 <typ.UInt32>
			(Or32 <typ.UInt32>
				(Rsh32Ux16 <typ.UInt32> (Int64Lo x) s)
				(Lsh32x16 <typ.UInt32>
					(Int64Hi x)
					(Sub16 <typ.UInt16> (Const16 <typ.UInt16> [32]) s)))
			(And32 <typ.UInt32>
				(Rsh32x16 <typ.UInt32>
					(Int64Hi x)
					(Sub16 <typ.UInt16> s (Const16 <typ.UInt16> [32])))
				(Zeromask
					(ZeroExt16to32
						(Rsh16Ux32 <typ.UInt16> s (Const32 <typ.UInt32> [5])))))))
(Rsh64x8 x s) =>
	(Int64Make
		(Rsh32x8 <typ.UInt32> (Int64Hi x) s)
		(Or32 <typ.UInt32>
			(Or32 <typ.UInt32>
				(Rsh32Ux8 <typ.UInt32> (Int64Lo x) s)
				(Lsh32x8 <typ.UInt32>
					(Int64Hi x)
					(Sub8 <typ.UInt8> (Const8 <typ.UInt8> [32]) s)))
			(And32 <typ.UInt32>
				(Rsh32x8 <typ.UInt32>
					(Int64Hi x)
					(Sub8 <typ.UInt8> s (Const8 <typ.UInt8> [32])))
				(Zeromask
					(ZeroExt8to32
						(Rsh8Ux32 <typ.UInt8> s (Const32 <typ.UInt32> [5])))))))

(Const64 <t> [c]) && t.IsSigned() =>
	(Int64Make (Const32 <typ.Int32> [int32(c>>32)]) (Const32 <typ.UInt32> [int32(c)]))
(Const64 <t> [c]) && !t.IsSigned() =>
	(Int64Make (Const32 <typ.UInt32> [int32(c>>32)]) (Const32 <typ.UInt32> [int32(c)]))

(Eq64 x y) =>
	(AndB
		(Eq32 (Int64Hi x) (Int64Hi y))
		(Eq32 (Int64Lo x) (Int64Lo y)))

(Neq64 x y) =>
	(OrB
		(Neq32 (Int64Hi x) (Int64Hi y))
		(Neq32 (Int64Lo x) (Int64Lo y)))

(Less64U x y) =>
	(OrB
		(Less32U (Int64Hi x) (Int64Hi y))
		(AndB
			(Eq32 (Int64Hi x) (Int64Hi y))
			(Less32U (Int64Lo x) (Int64Lo y))))

(Leq64U x y) =>
	(OrB
		(Less32U (Int64Hi x) (Int64Hi y))
		(AndB
			(Eq32 (Int64Hi x) (Int64Hi y))
			(Leq32U (Int64Lo x) (Int64Lo y))))

(Less64 x y) =>
	(OrB
		(Less32 (Int64Hi x) (Int64Hi y))
		(AndB
			(Eq32 (Int64Hi x) (Int64Hi y))
			(Less32U (Int64Lo x) (Int64Lo y))))

(Leq64 x y) =>
	(OrB
		(Less32 (Int64Hi x) (Int64Hi y))
		(AndB
			(Eq32 (Int64Hi x) (Int64Hi y))
			(Leq32U (Int64Lo x) (Int64Lo y))))