Source file src/cmd/compile/internal/ssa/rewritedec64.go

Documentation: cmd/compile/internal/ssa

     1  // Code generated from _gen/dec64.rules using 'go generate'; DO NOT EDIT.
     2  
     3  package ssa
     4  
     5  import "cmd/compile/internal/types"
     6  
     7  func rewriteValuedec64(v *Value) bool {
     8  	switch v.Op {
     9  	case OpAdd64:
    10  		return rewriteValuedec64_OpAdd64(v)
    11  	case OpAnd64:
    12  		return rewriteValuedec64_OpAnd64(v)
    13  	case OpArg:
    14  		return rewriteValuedec64_OpArg(v)
    15  	case OpBitLen64:
    16  		return rewriteValuedec64_OpBitLen64(v)
    17  	case OpBswap64:
    18  		return rewriteValuedec64_OpBswap64(v)
    19  	case OpCom64:
    20  		return rewriteValuedec64_OpCom64(v)
    21  	case OpConst64:
    22  		return rewriteValuedec64_OpConst64(v)
    23  	case OpCtz64:
    24  		return rewriteValuedec64_OpCtz64(v)
    25  	case OpCtz64NonZero:
    26  		v.Op = OpCtz64
    27  		return true
    28  	case OpEq64:
    29  		return rewriteValuedec64_OpEq64(v)
    30  	case OpInt64Hi:
    31  		return rewriteValuedec64_OpInt64Hi(v)
    32  	case OpInt64Lo:
    33  		return rewriteValuedec64_OpInt64Lo(v)
    34  	case OpLeq64:
    35  		return rewriteValuedec64_OpLeq64(v)
    36  	case OpLeq64U:
    37  		return rewriteValuedec64_OpLeq64U(v)
    38  	case OpLess64:
    39  		return rewriteValuedec64_OpLess64(v)
    40  	case OpLess64U:
    41  		return rewriteValuedec64_OpLess64U(v)
    42  	case OpLoad:
    43  		return rewriteValuedec64_OpLoad(v)
    44  	case OpLsh16x64:
    45  		return rewriteValuedec64_OpLsh16x64(v)
    46  	case OpLsh32x64:
    47  		return rewriteValuedec64_OpLsh32x64(v)
    48  	case OpLsh64x16:
    49  		return rewriteValuedec64_OpLsh64x16(v)
    50  	case OpLsh64x32:
    51  		return rewriteValuedec64_OpLsh64x32(v)
    52  	case OpLsh64x64:
    53  		return rewriteValuedec64_OpLsh64x64(v)
    54  	case OpLsh64x8:
    55  		return rewriteValuedec64_OpLsh64x8(v)
    56  	case OpLsh8x64:
    57  		return rewriteValuedec64_OpLsh8x64(v)
    58  	case OpMul64:
    59  		return rewriteValuedec64_OpMul64(v)
    60  	case OpNeg64:
    61  		return rewriteValuedec64_OpNeg64(v)
    62  	case OpNeq64:
    63  		return rewriteValuedec64_OpNeq64(v)
    64  	case OpOr32:
    65  		return rewriteValuedec64_OpOr32(v)
    66  	case OpOr64:
    67  		return rewriteValuedec64_OpOr64(v)
    68  	case OpRotateLeft16:
    69  		return rewriteValuedec64_OpRotateLeft16(v)
    70  	case OpRotateLeft32:
    71  		return rewriteValuedec64_OpRotateLeft32(v)
    72  	case OpRotateLeft64:
    73  		return rewriteValuedec64_OpRotateLeft64(v)
    74  	case OpRotateLeft8:
    75  		return rewriteValuedec64_OpRotateLeft8(v)
    76  	case OpRsh16Ux64:
    77  		return rewriteValuedec64_OpRsh16Ux64(v)
    78  	case OpRsh16x64:
    79  		return rewriteValuedec64_OpRsh16x64(v)
    80  	case OpRsh32Ux64:
    81  		return rewriteValuedec64_OpRsh32Ux64(v)
    82  	case OpRsh32x64:
    83  		return rewriteValuedec64_OpRsh32x64(v)
    84  	case OpRsh64Ux16:
    85  		return rewriteValuedec64_OpRsh64Ux16(v)
    86  	case OpRsh64Ux32:
    87  		return rewriteValuedec64_OpRsh64Ux32(v)
    88  	case OpRsh64Ux64:
    89  		return rewriteValuedec64_OpRsh64Ux64(v)
    90  	case OpRsh64Ux8:
    91  		return rewriteValuedec64_OpRsh64Ux8(v)
    92  	case OpRsh64x16:
    93  		return rewriteValuedec64_OpRsh64x16(v)
    94  	case OpRsh64x32:
    95  		return rewriteValuedec64_OpRsh64x32(v)
    96  	case OpRsh64x64:
    97  		return rewriteValuedec64_OpRsh64x64(v)
    98  	case OpRsh64x8:
    99  		return rewriteValuedec64_OpRsh64x8(v)
   100  	case OpRsh8Ux64:
   101  		return rewriteValuedec64_OpRsh8Ux64(v)
   102  	case OpRsh8x64:
   103  		return rewriteValuedec64_OpRsh8x64(v)
   104  	case OpSignExt16to64:
   105  		return rewriteValuedec64_OpSignExt16to64(v)
   106  	case OpSignExt32to64:
   107  		return rewriteValuedec64_OpSignExt32to64(v)
   108  	case OpSignExt8to64:
   109  		return rewriteValuedec64_OpSignExt8to64(v)
   110  	case OpStore:
   111  		return rewriteValuedec64_OpStore(v)
   112  	case OpSub64:
   113  		return rewriteValuedec64_OpSub64(v)
   114  	case OpTrunc64to16:
   115  		return rewriteValuedec64_OpTrunc64to16(v)
   116  	case OpTrunc64to32:
   117  		return rewriteValuedec64_OpTrunc64to32(v)
   118  	case OpTrunc64to8:
   119  		return rewriteValuedec64_OpTrunc64to8(v)
   120  	case OpXor64:
   121  		return rewriteValuedec64_OpXor64(v)
   122  	case OpZeroExt16to64:
   123  		return rewriteValuedec64_OpZeroExt16to64(v)
   124  	case OpZeroExt32to64:
   125  		return rewriteValuedec64_OpZeroExt32to64(v)
   126  	case OpZeroExt8to64:
   127  		return rewriteValuedec64_OpZeroExt8to64(v)
   128  	}
   129  	return false
   130  }
   131  func rewriteValuedec64_OpAdd64(v *Value) bool {
   132  	v_1 := v.Args[1]
   133  	v_0 := v.Args[0]
   134  	b := v.Block
   135  	typ := &b.Func.Config.Types
   136  	// match: (Add64 x y)
   137  	// result: (Int64Make (Add32withcarry <typ.Int32> (Int64Hi x) (Int64Hi y) (Select1 <types.TypeFlags> (Add32carry (Int64Lo x) (Int64Lo y)))) (Select0 <typ.UInt32> (Add32carry (Int64Lo x) (Int64Lo y))))
   138  	for {
   139  		x := v_0
   140  		y := v_1
   141  		v.reset(OpInt64Make)
   142  		v0 := b.NewValue0(v.Pos, OpAdd32withcarry, typ.Int32)
   143  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   144  		v1.AddArg(x)
   145  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   146  		v2.AddArg(y)
   147  		v3 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
   148  		v4 := b.NewValue0(v.Pos, OpAdd32carry, types.NewTuple(typ.UInt32, types.TypeFlags))
   149  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   150  		v5.AddArg(x)
   151  		v6 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   152  		v6.AddArg(y)
   153  		v4.AddArg2(v5, v6)
   154  		v3.AddArg(v4)
   155  		v0.AddArg3(v1, v2, v3)
   156  		v7 := b.NewValue0(v.Pos, OpSelect0, typ.UInt32)
   157  		v7.AddArg(v4)
   158  		v.AddArg2(v0, v7)
   159  		return true
   160  	}
   161  }
   162  func rewriteValuedec64_OpAnd64(v *Value) bool {
   163  	v_1 := v.Args[1]
   164  	v_0 := v.Args[0]
   165  	b := v.Block
   166  	typ := &b.Func.Config.Types
   167  	// match: (And64 x y)
   168  	// result: (Int64Make (And32 <typ.UInt32> (Int64Hi x) (Int64Hi y)) (And32 <typ.UInt32> (Int64Lo x) (Int64Lo y)))
   169  	for {
   170  		x := v_0
   171  		y := v_1
   172  		v.reset(OpInt64Make)
   173  		v0 := b.NewValue0(v.Pos, OpAnd32, typ.UInt32)
   174  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   175  		v1.AddArg(x)
   176  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   177  		v2.AddArg(y)
   178  		v0.AddArg2(v1, v2)
   179  		v3 := b.NewValue0(v.Pos, OpAnd32, typ.UInt32)
   180  		v4 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   181  		v4.AddArg(x)
   182  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   183  		v5.AddArg(y)
   184  		v3.AddArg2(v4, v5)
   185  		v.AddArg2(v0, v3)
   186  		return true
   187  	}
   188  }
   189  func rewriteValuedec64_OpArg(v *Value) bool {
   190  	b := v.Block
   191  	config := b.Func.Config
   192  	typ := &b.Func.Config.Types
   193  	// match: (Arg {n} [off])
   194  	// cond: is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")
   195  	// result: (Int64Make (Arg <typ.Int32> {n} [off+4]) (Arg <typ.UInt32> {n} [off]))
   196  	for {
   197  		off := auxIntToInt32(v.AuxInt)
   198  		n := auxToSym(v.Aux)
   199  		if !(is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) {
   200  			break
   201  		}
   202  		v.reset(OpInt64Make)
   203  		v0 := b.NewValue0(v.Pos, OpArg, typ.Int32)
   204  		v0.AuxInt = int32ToAuxInt(off + 4)
   205  		v0.Aux = symToAux(n)
   206  		v1 := b.NewValue0(v.Pos, OpArg, typ.UInt32)
   207  		v1.AuxInt = int32ToAuxInt(off)
   208  		v1.Aux = symToAux(n)
   209  		v.AddArg2(v0, v1)
   210  		return true
   211  	}
   212  	// match: (Arg {n} [off])
   213  	// cond: is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")
   214  	// result: (Int64Make (Arg <typ.UInt32> {n} [off+4]) (Arg <typ.UInt32> {n} [off]))
   215  	for {
   216  		off := auxIntToInt32(v.AuxInt)
   217  		n := auxToSym(v.Aux)
   218  		if !(is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) {
   219  			break
   220  		}
   221  		v.reset(OpInt64Make)
   222  		v0 := b.NewValue0(v.Pos, OpArg, typ.UInt32)
   223  		v0.AuxInt = int32ToAuxInt(off + 4)
   224  		v0.Aux = symToAux(n)
   225  		v1 := b.NewValue0(v.Pos, OpArg, typ.UInt32)
   226  		v1.AuxInt = int32ToAuxInt(off)
   227  		v1.Aux = symToAux(n)
   228  		v.AddArg2(v0, v1)
   229  		return true
   230  	}
   231  	// match: (Arg {n} [off])
   232  	// cond: is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")
   233  	// result: (Int64Make (Arg <typ.Int32> {n} [off]) (Arg <typ.UInt32> {n} [off+4]))
   234  	for {
   235  		off := auxIntToInt32(v.AuxInt)
   236  		n := auxToSym(v.Aux)
   237  		if !(is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) {
   238  			break
   239  		}
   240  		v.reset(OpInt64Make)
   241  		v0 := b.NewValue0(v.Pos, OpArg, typ.Int32)
   242  		v0.AuxInt = int32ToAuxInt(off)
   243  		v0.Aux = symToAux(n)
   244  		v1 := b.NewValue0(v.Pos, OpArg, typ.UInt32)
   245  		v1.AuxInt = int32ToAuxInt(off + 4)
   246  		v1.Aux = symToAux(n)
   247  		v.AddArg2(v0, v1)
   248  		return true
   249  	}
   250  	// match: (Arg {n} [off])
   251  	// cond: is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")
   252  	// result: (Int64Make (Arg <typ.UInt32> {n} [off]) (Arg <typ.UInt32> {n} [off+4]))
   253  	for {
   254  		off := auxIntToInt32(v.AuxInt)
   255  		n := auxToSym(v.Aux)
   256  		if !(is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) {
   257  			break
   258  		}
   259  		v.reset(OpInt64Make)
   260  		v0 := b.NewValue0(v.Pos, OpArg, typ.UInt32)
   261  		v0.AuxInt = int32ToAuxInt(off)
   262  		v0.Aux = symToAux(n)
   263  		v1 := b.NewValue0(v.Pos, OpArg, typ.UInt32)
   264  		v1.AuxInt = int32ToAuxInt(off + 4)
   265  		v1.Aux = symToAux(n)
   266  		v.AddArg2(v0, v1)
   267  		return true
   268  	}
   269  	return false
   270  }
   271  func rewriteValuedec64_OpBitLen64(v *Value) bool {
   272  	v_0 := v.Args[0]
   273  	b := v.Block
   274  	typ := &b.Func.Config.Types
   275  	// match: (BitLen64 x)
   276  	// result: (Add32 <typ.Int> (BitLen32 <typ.Int> (Int64Hi x)) (BitLen32 <typ.Int> (Or32 <typ.UInt32> (Int64Lo x) (Zeromask (Int64Hi x)))))
   277  	for {
   278  		x := v_0
   279  		v.reset(OpAdd32)
   280  		v.Type = typ.Int
   281  		v0 := b.NewValue0(v.Pos, OpBitLen32, typ.Int)
   282  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   283  		v1.AddArg(x)
   284  		v0.AddArg(v1)
   285  		v2 := b.NewValue0(v.Pos, OpBitLen32, typ.Int)
   286  		v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
   287  		v4 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   288  		v4.AddArg(x)
   289  		v5 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
   290  		v5.AddArg(v1)
   291  		v3.AddArg2(v4, v5)
   292  		v2.AddArg(v3)
   293  		v.AddArg2(v0, v2)
   294  		return true
   295  	}
   296  }
   297  func rewriteValuedec64_OpBswap64(v *Value) bool {
   298  	v_0 := v.Args[0]
   299  	b := v.Block
   300  	typ := &b.Func.Config.Types
   301  	// match: (Bswap64 x)
   302  	// result: (Int64Make (Bswap32 <typ.UInt32> (Int64Lo x)) (Bswap32 <typ.UInt32> (Int64Hi x)))
   303  	for {
   304  		x := v_0
   305  		v.reset(OpInt64Make)
   306  		v0 := b.NewValue0(v.Pos, OpBswap32, typ.UInt32)
   307  		v1 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   308  		v1.AddArg(x)
   309  		v0.AddArg(v1)
   310  		v2 := b.NewValue0(v.Pos, OpBswap32, typ.UInt32)
   311  		v3 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   312  		v3.AddArg(x)
   313  		v2.AddArg(v3)
   314  		v.AddArg2(v0, v2)
   315  		return true
   316  	}
   317  }
   318  func rewriteValuedec64_OpCom64(v *Value) bool {
   319  	v_0 := v.Args[0]
   320  	b := v.Block
   321  	typ := &b.Func.Config.Types
   322  	// match: (Com64 x)
   323  	// result: (Int64Make (Com32 <typ.UInt32> (Int64Hi x)) (Com32 <typ.UInt32> (Int64Lo x)))
   324  	for {
   325  		x := v_0
   326  		v.reset(OpInt64Make)
   327  		v0 := b.NewValue0(v.Pos, OpCom32, typ.UInt32)
   328  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   329  		v1.AddArg(x)
   330  		v0.AddArg(v1)
   331  		v2 := b.NewValue0(v.Pos, OpCom32, typ.UInt32)
   332  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   333  		v3.AddArg(x)
   334  		v2.AddArg(v3)
   335  		v.AddArg2(v0, v2)
   336  		return true
   337  	}
   338  }
   339  func rewriteValuedec64_OpConst64(v *Value) bool {
   340  	b := v.Block
   341  	typ := &b.Func.Config.Types
   342  	// match: (Const64 <t> [c])
   343  	// cond: t.IsSigned()
   344  	// result: (Int64Make (Const32 <typ.Int32> [int32(c>>32)]) (Const32 <typ.UInt32> [int32(c)]))
   345  	for {
   346  		t := v.Type
   347  		c := auxIntToInt64(v.AuxInt)
   348  		if !(t.IsSigned()) {
   349  			break
   350  		}
   351  		v.reset(OpInt64Make)
   352  		v0 := b.NewValue0(v.Pos, OpConst32, typ.Int32)
   353  		v0.AuxInt = int32ToAuxInt(int32(c >> 32))
   354  		v1 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
   355  		v1.AuxInt = int32ToAuxInt(int32(c))
   356  		v.AddArg2(v0, v1)
   357  		return true
   358  	}
   359  	// match: (Const64 <t> [c])
   360  	// cond: !t.IsSigned()
   361  	// result: (Int64Make (Const32 <typ.UInt32> [int32(c>>32)]) (Const32 <typ.UInt32> [int32(c)]))
   362  	for {
   363  		t := v.Type
   364  		c := auxIntToInt64(v.AuxInt)
   365  		if !(!t.IsSigned()) {
   366  			break
   367  		}
   368  		v.reset(OpInt64Make)
   369  		v0 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
   370  		v0.AuxInt = int32ToAuxInt(int32(c >> 32))
   371  		v1 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
   372  		v1.AuxInt = int32ToAuxInt(int32(c))
   373  		v.AddArg2(v0, v1)
   374  		return true
   375  	}
   376  	return false
   377  }
   378  func rewriteValuedec64_OpCtz64(v *Value) bool {
   379  	v_0 := v.Args[0]
   380  	b := v.Block
   381  	typ := &b.Func.Config.Types
   382  	// match: (Ctz64 x)
   383  	// result: (Add32 <typ.UInt32> (Ctz32 <typ.UInt32> (Int64Lo x)) (And32 <typ.UInt32> (Com32 <typ.UInt32> (Zeromask (Int64Lo x))) (Ctz32 <typ.UInt32> (Int64Hi x))))
   384  	for {
   385  		x := v_0
   386  		v.reset(OpAdd32)
   387  		v.Type = typ.UInt32
   388  		v0 := b.NewValue0(v.Pos, OpCtz32, typ.UInt32)
   389  		v1 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   390  		v1.AddArg(x)
   391  		v0.AddArg(v1)
   392  		v2 := b.NewValue0(v.Pos, OpAnd32, typ.UInt32)
   393  		v3 := b.NewValue0(v.Pos, OpCom32, typ.UInt32)
   394  		v4 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
   395  		v4.AddArg(v1)
   396  		v3.AddArg(v4)
   397  		v5 := b.NewValue0(v.Pos, OpCtz32, typ.UInt32)
   398  		v6 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   399  		v6.AddArg(x)
   400  		v5.AddArg(v6)
   401  		v2.AddArg2(v3, v5)
   402  		v.AddArg2(v0, v2)
   403  		return true
   404  	}
   405  }
   406  func rewriteValuedec64_OpEq64(v *Value) bool {
   407  	v_1 := v.Args[1]
   408  	v_0 := v.Args[0]
   409  	b := v.Block
   410  	typ := &b.Func.Config.Types
   411  	// match: (Eq64 x y)
   412  	// result: (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Eq32 (Int64Lo x) (Int64Lo y)))
   413  	for {
   414  		x := v_0
   415  		y := v_1
   416  		v.reset(OpAndB)
   417  		v0 := b.NewValue0(v.Pos, OpEq32, typ.Bool)
   418  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   419  		v1.AddArg(x)
   420  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   421  		v2.AddArg(y)
   422  		v0.AddArg2(v1, v2)
   423  		v3 := b.NewValue0(v.Pos, OpEq32, typ.Bool)
   424  		v4 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   425  		v4.AddArg(x)
   426  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   427  		v5.AddArg(y)
   428  		v3.AddArg2(v4, v5)
   429  		v.AddArg2(v0, v3)
   430  		return true
   431  	}
   432  }
   433  func rewriteValuedec64_OpInt64Hi(v *Value) bool {
   434  	v_0 := v.Args[0]
   435  	// match: (Int64Hi (Int64Make hi _))
   436  	// result: hi
   437  	for {
   438  		if v_0.Op != OpInt64Make {
   439  			break
   440  		}
   441  		hi := v_0.Args[0]
   442  		v.copyOf(hi)
   443  		return true
   444  	}
   445  	return false
   446  }
   447  func rewriteValuedec64_OpInt64Lo(v *Value) bool {
   448  	v_0 := v.Args[0]
   449  	// match: (Int64Lo (Int64Make _ lo))
   450  	// result: lo
   451  	for {
   452  		if v_0.Op != OpInt64Make {
   453  			break
   454  		}
   455  		lo := v_0.Args[1]
   456  		v.copyOf(lo)
   457  		return true
   458  	}
   459  	return false
   460  }
   461  func rewriteValuedec64_OpLeq64(v *Value) bool {
   462  	v_1 := v.Args[1]
   463  	v_0 := v.Args[0]
   464  	b := v.Block
   465  	typ := &b.Func.Config.Types
   466  	// match: (Leq64 x y)
   467  	// result: (OrB (Less32 (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Leq32U (Int64Lo x) (Int64Lo y))))
   468  	for {
   469  		x := v_0
   470  		y := v_1
   471  		v.reset(OpOrB)
   472  		v0 := b.NewValue0(v.Pos, OpLess32, typ.Bool)
   473  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   474  		v1.AddArg(x)
   475  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   476  		v2.AddArg(y)
   477  		v0.AddArg2(v1, v2)
   478  		v3 := b.NewValue0(v.Pos, OpAndB, typ.Bool)
   479  		v4 := b.NewValue0(v.Pos, OpEq32, typ.Bool)
   480  		v4.AddArg2(v1, v2)
   481  		v5 := b.NewValue0(v.Pos, OpLeq32U, typ.Bool)
   482  		v6 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   483  		v6.AddArg(x)
   484  		v7 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   485  		v7.AddArg(y)
   486  		v5.AddArg2(v6, v7)
   487  		v3.AddArg2(v4, v5)
   488  		v.AddArg2(v0, v3)
   489  		return true
   490  	}
   491  }
   492  func rewriteValuedec64_OpLeq64U(v *Value) bool {
   493  	v_1 := v.Args[1]
   494  	v_0 := v.Args[0]
   495  	b := v.Block
   496  	typ := &b.Func.Config.Types
   497  	// match: (Leq64U x y)
   498  	// result: (OrB (Less32U (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Leq32U (Int64Lo x) (Int64Lo y))))
   499  	for {
   500  		x := v_0
   501  		y := v_1
   502  		v.reset(OpOrB)
   503  		v0 := b.NewValue0(v.Pos, OpLess32U, typ.Bool)
   504  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   505  		v1.AddArg(x)
   506  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   507  		v2.AddArg(y)
   508  		v0.AddArg2(v1, v2)
   509  		v3 := b.NewValue0(v.Pos, OpAndB, typ.Bool)
   510  		v4 := b.NewValue0(v.Pos, OpEq32, typ.Bool)
   511  		v4.AddArg2(v1, v2)
   512  		v5 := b.NewValue0(v.Pos, OpLeq32U, typ.Bool)
   513  		v6 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   514  		v6.AddArg(x)
   515  		v7 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   516  		v7.AddArg(y)
   517  		v5.AddArg2(v6, v7)
   518  		v3.AddArg2(v4, v5)
   519  		v.AddArg2(v0, v3)
   520  		return true
   521  	}
   522  }
   523  func rewriteValuedec64_OpLess64(v *Value) bool {
   524  	v_1 := v.Args[1]
   525  	v_0 := v.Args[0]
   526  	b := v.Block
   527  	typ := &b.Func.Config.Types
   528  	// match: (Less64 x y)
   529  	// result: (OrB (Less32 (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Less32U (Int64Lo x) (Int64Lo y))))
   530  	for {
   531  		x := v_0
   532  		y := v_1
   533  		v.reset(OpOrB)
   534  		v0 := b.NewValue0(v.Pos, OpLess32, typ.Bool)
   535  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   536  		v1.AddArg(x)
   537  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   538  		v2.AddArg(y)
   539  		v0.AddArg2(v1, v2)
   540  		v3 := b.NewValue0(v.Pos, OpAndB, typ.Bool)
   541  		v4 := b.NewValue0(v.Pos, OpEq32, typ.Bool)
   542  		v4.AddArg2(v1, v2)
   543  		v5 := b.NewValue0(v.Pos, OpLess32U, typ.Bool)
   544  		v6 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   545  		v6.AddArg(x)
   546  		v7 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   547  		v7.AddArg(y)
   548  		v5.AddArg2(v6, v7)
   549  		v3.AddArg2(v4, v5)
   550  		v.AddArg2(v0, v3)
   551  		return true
   552  	}
   553  }
   554  func rewriteValuedec64_OpLess64U(v *Value) bool {
   555  	v_1 := v.Args[1]
   556  	v_0 := v.Args[0]
   557  	b := v.Block
   558  	typ := &b.Func.Config.Types
   559  	// match: (Less64U x y)
   560  	// result: (OrB (Less32U (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Less32U (Int64Lo x) (Int64Lo y))))
   561  	for {
   562  		x := v_0
   563  		y := v_1
   564  		v.reset(OpOrB)
   565  		v0 := b.NewValue0(v.Pos, OpLess32U, typ.Bool)
   566  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   567  		v1.AddArg(x)
   568  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   569  		v2.AddArg(y)
   570  		v0.AddArg2(v1, v2)
   571  		v3 := b.NewValue0(v.Pos, OpAndB, typ.Bool)
   572  		v4 := b.NewValue0(v.Pos, OpEq32, typ.Bool)
   573  		v4.AddArg2(v1, v2)
   574  		v5 := b.NewValue0(v.Pos, OpLess32U, typ.Bool)
   575  		v6 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   576  		v6.AddArg(x)
   577  		v7 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   578  		v7.AddArg(y)
   579  		v5.AddArg2(v6, v7)
   580  		v3.AddArg2(v4, v5)
   581  		v.AddArg2(v0, v3)
   582  		return true
   583  	}
   584  }
   585  func rewriteValuedec64_OpLoad(v *Value) bool {
   586  	v_1 := v.Args[1]
   587  	v_0 := v.Args[0]
   588  	b := v.Block
   589  	config := b.Func.Config
   590  	typ := &b.Func.Config.Types
   591  	// match: (Load <t> ptr mem)
   592  	// cond: is64BitInt(t) && !config.BigEndian && t.IsSigned()
   593  	// result: (Int64Make (Load <typ.Int32> (OffPtr <typ.Int32Ptr> [4] ptr) mem) (Load <typ.UInt32> ptr mem))
   594  	for {
   595  		t := v.Type
   596  		ptr := v_0
   597  		mem := v_1
   598  		if !(is64BitInt(t) && !config.BigEndian && t.IsSigned()) {
   599  			break
   600  		}
   601  		v.reset(OpInt64Make)
   602  		v0 := b.NewValue0(v.Pos, OpLoad, typ.Int32)
   603  		v1 := b.NewValue0(v.Pos, OpOffPtr, typ.Int32Ptr)
   604  		v1.AuxInt = int64ToAuxInt(4)
   605  		v1.AddArg(ptr)
   606  		v0.AddArg2(v1, mem)
   607  		v2 := b.NewValue0(v.Pos, OpLoad, typ.UInt32)
   608  		v2.AddArg2(ptr, mem)
   609  		v.AddArg2(v0, v2)
   610  		return true
   611  	}
   612  	// match: (Load <t> ptr mem)
   613  	// cond: is64BitInt(t) && !config.BigEndian && !t.IsSigned()
   614  	// result: (Int64Make (Load <typ.UInt32> (OffPtr <typ.UInt32Ptr> [4] ptr) mem) (Load <typ.UInt32> ptr mem))
   615  	for {
   616  		t := v.Type
   617  		ptr := v_0
   618  		mem := v_1
   619  		if !(is64BitInt(t) && !config.BigEndian && !t.IsSigned()) {
   620  			break
   621  		}
   622  		v.reset(OpInt64Make)
   623  		v0 := b.NewValue0(v.Pos, OpLoad, typ.UInt32)
   624  		v1 := b.NewValue0(v.Pos, OpOffPtr, typ.UInt32Ptr)
   625  		v1.AuxInt = int64ToAuxInt(4)
   626  		v1.AddArg(ptr)
   627  		v0.AddArg2(v1, mem)
   628  		v2 := b.NewValue0(v.Pos, OpLoad, typ.UInt32)
   629  		v2.AddArg2(ptr, mem)
   630  		v.AddArg2(v0, v2)
   631  		return true
   632  	}
   633  	// match: (Load <t> ptr mem)
   634  	// cond: is64BitInt(t) && config.BigEndian && t.IsSigned()
   635  	// result: (Int64Make (Load <typ.Int32> ptr mem) (Load <typ.UInt32> (OffPtr <typ.UInt32Ptr> [4] ptr) mem))
   636  	for {
   637  		t := v.Type
   638  		ptr := v_0
   639  		mem := v_1
   640  		if !(is64BitInt(t) && config.BigEndian && t.IsSigned()) {
   641  			break
   642  		}
   643  		v.reset(OpInt64Make)
   644  		v0 := b.NewValue0(v.Pos, OpLoad, typ.Int32)
   645  		v0.AddArg2(ptr, mem)
   646  		v1 := b.NewValue0(v.Pos, OpLoad, typ.UInt32)
   647  		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.UInt32Ptr)
   648  		v2.AuxInt = int64ToAuxInt(4)
   649  		v2.AddArg(ptr)
   650  		v1.AddArg2(v2, mem)
   651  		v.AddArg2(v0, v1)
   652  		return true
   653  	}
   654  	// match: (Load <t> ptr mem)
   655  	// cond: is64BitInt(t) && config.BigEndian && !t.IsSigned()
   656  	// result: (Int64Make (Load <typ.UInt32> ptr mem) (Load <typ.UInt32> (OffPtr <typ.UInt32Ptr> [4] ptr) mem))
   657  	for {
   658  		t := v.Type
   659  		ptr := v_0
   660  		mem := v_1
   661  		if !(is64BitInt(t) && config.BigEndian && !t.IsSigned()) {
   662  			break
   663  		}
   664  		v.reset(OpInt64Make)
   665  		v0 := b.NewValue0(v.Pos, OpLoad, typ.UInt32)
   666  		v0.AddArg2(ptr, mem)
   667  		v1 := b.NewValue0(v.Pos, OpLoad, typ.UInt32)
   668  		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.UInt32Ptr)
   669  		v2.AuxInt = int64ToAuxInt(4)
   670  		v2.AddArg(ptr)
   671  		v1.AddArg2(v2, mem)
   672  		v.AddArg2(v0, v1)
   673  		return true
   674  	}
   675  	return false
   676  }
   677  func rewriteValuedec64_OpLsh16x64(v *Value) bool {
   678  	v_1 := v.Args[1]
   679  	v_0 := v.Args[0]
   680  	b := v.Block
   681  	typ := &b.Func.Config.Types
   682  	// match: (Lsh16x64 _ (Int64Make (Const32 [c]) _))
   683  	// cond: c != 0
   684  	// result: (Const32 [0])
   685  	for {
   686  		if v_1.Op != OpInt64Make {
   687  			break
   688  		}
   689  		v_1_0 := v_1.Args[0]
   690  		if v_1_0.Op != OpConst32 {
   691  			break
   692  		}
   693  		c := auxIntToInt32(v_1_0.AuxInt)
   694  		if !(c != 0) {
   695  			break
   696  		}
   697  		v.reset(OpConst32)
   698  		v.AuxInt = int32ToAuxInt(0)
   699  		return true
   700  	}
   701  	// match: (Lsh16x64 [c] x (Int64Make (Const32 [0]) lo))
   702  	// result: (Lsh16x32 [c] x lo)
   703  	for {
   704  		c := auxIntToBool(v.AuxInt)
   705  		x := v_0
   706  		if v_1.Op != OpInt64Make {
   707  			break
   708  		}
   709  		lo := v_1.Args[1]
   710  		v_1_0 := v_1.Args[0]
   711  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
   712  			break
   713  		}
   714  		v.reset(OpLsh16x32)
   715  		v.AuxInt = boolToAuxInt(c)
   716  		v.AddArg2(x, lo)
   717  		return true
   718  	}
   719  	// match: (Lsh16x64 x (Int64Make hi lo))
   720  	// cond: hi.Op != OpConst32
   721  	// result: (Lsh16x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
   722  	for {
   723  		x := v_0
   724  		if v_1.Op != OpInt64Make {
   725  			break
   726  		}
   727  		lo := v_1.Args[1]
   728  		hi := v_1.Args[0]
   729  		if !(hi.Op != OpConst32) {
   730  			break
   731  		}
   732  		v.reset(OpLsh16x32)
   733  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
   734  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
   735  		v1.AddArg(hi)
   736  		v0.AddArg2(v1, lo)
   737  		v.AddArg2(x, v0)
   738  		return true
   739  	}
   740  	// match: (Lsh16x64 x y)
   741  	// result: (Lsh16x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
   742  	for {
   743  		x := v_0
   744  		y := v_1
   745  		v.reset(OpLsh16x32)
   746  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
   747  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
   748  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   749  		v2.AddArg(y)
   750  		v1.AddArg(v2)
   751  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   752  		v3.AddArg(y)
   753  		v0.AddArg2(v1, v3)
   754  		v.AddArg2(x, v0)
   755  		return true
   756  	}
   757  }
   758  func rewriteValuedec64_OpLsh32x64(v *Value) bool {
   759  	v_1 := v.Args[1]
   760  	v_0 := v.Args[0]
   761  	b := v.Block
   762  	typ := &b.Func.Config.Types
   763  	// match: (Lsh32x64 _ (Int64Make (Const32 [c]) _))
   764  	// cond: c != 0
   765  	// result: (Const32 [0])
   766  	for {
   767  		if v_1.Op != OpInt64Make {
   768  			break
   769  		}
   770  		v_1_0 := v_1.Args[0]
   771  		if v_1_0.Op != OpConst32 {
   772  			break
   773  		}
   774  		c := auxIntToInt32(v_1_0.AuxInt)
   775  		if !(c != 0) {
   776  			break
   777  		}
   778  		v.reset(OpConst32)
   779  		v.AuxInt = int32ToAuxInt(0)
   780  		return true
   781  	}
   782  	// match: (Lsh32x64 [c] x (Int64Make (Const32 [0]) lo))
   783  	// result: (Lsh32x32 [c] x lo)
   784  	for {
   785  		c := auxIntToBool(v.AuxInt)
   786  		x := v_0
   787  		if v_1.Op != OpInt64Make {
   788  			break
   789  		}
   790  		lo := v_1.Args[1]
   791  		v_1_0 := v_1.Args[0]
   792  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
   793  			break
   794  		}
   795  		v.reset(OpLsh32x32)
   796  		v.AuxInt = boolToAuxInt(c)
   797  		v.AddArg2(x, lo)
   798  		return true
   799  	}
   800  	// match: (Lsh32x64 x (Int64Make hi lo))
   801  	// cond: hi.Op != OpConst32
   802  	// result: (Lsh32x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
   803  	for {
   804  		x := v_0
   805  		if v_1.Op != OpInt64Make {
   806  			break
   807  		}
   808  		lo := v_1.Args[1]
   809  		hi := v_1.Args[0]
   810  		if !(hi.Op != OpConst32) {
   811  			break
   812  		}
   813  		v.reset(OpLsh32x32)
   814  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
   815  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
   816  		v1.AddArg(hi)
   817  		v0.AddArg2(v1, lo)
   818  		v.AddArg2(x, v0)
   819  		return true
   820  	}
   821  	// match: (Lsh32x64 x y)
   822  	// result: (Lsh32x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
   823  	for {
   824  		x := v_0
   825  		y := v_1
   826  		v.reset(OpLsh32x32)
   827  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
   828  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
   829  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   830  		v2.AddArg(y)
   831  		v1.AddArg(v2)
   832  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   833  		v3.AddArg(y)
   834  		v0.AddArg2(v1, v3)
   835  		v.AddArg2(x, v0)
   836  		return true
   837  	}
   838  }
   839  func rewriteValuedec64_OpLsh64x16(v *Value) bool {
   840  	v_1 := v.Args[1]
   841  	v_0 := v.Args[0]
   842  	b := v.Block
   843  	typ := &b.Func.Config.Types
   844  	// match: (Lsh64x16 x s)
   845  	// result: (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))
   846  	for {
   847  		x := v_0
   848  		s := v_1
   849  		v.reset(OpInt64Make)
   850  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
   851  		v1 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
   852  		v2 := b.NewValue0(v.Pos, OpLsh32x16, typ.UInt32)
   853  		v3 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   854  		v3.AddArg(x)
   855  		v2.AddArg2(v3, s)
   856  		v4 := b.NewValue0(v.Pos, OpRsh32Ux16, typ.UInt32)
   857  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   858  		v5.AddArg(x)
   859  		v6 := b.NewValue0(v.Pos, OpSub16, typ.UInt16)
   860  		v7 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
   861  		v7.AuxInt = int16ToAuxInt(32)
   862  		v6.AddArg2(v7, s)
   863  		v4.AddArg2(v5, v6)
   864  		v1.AddArg2(v2, v4)
   865  		v8 := b.NewValue0(v.Pos, OpLsh32x16, typ.UInt32)
   866  		v9 := b.NewValue0(v.Pos, OpSub16, typ.UInt16)
   867  		v9.AddArg2(s, v7)
   868  		v8.AddArg2(v5, v9)
   869  		v0.AddArg2(v1, v8)
   870  		v10 := b.NewValue0(v.Pos, OpLsh32x16, typ.UInt32)
   871  		v10.AddArg2(v5, s)
   872  		v.AddArg2(v0, v10)
   873  		return true
   874  	}
   875  }
   876  func rewriteValuedec64_OpLsh64x32(v *Value) bool {
   877  	v_1 := v.Args[1]
   878  	v_0 := v.Args[0]
   879  	b := v.Block
   880  	typ := &b.Func.Config.Types
   881  	// match: (Lsh64x32 x s)
   882  	// result: (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))
   883  	for {
   884  		x := v_0
   885  		s := v_1
   886  		v.reset(OpInt64Make)
   887  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
   888  		v1 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
   889  		v2 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
   890  		v3 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   891  		v3.AddArg(x)
   892  		v2.AddArg2(v3, s)
   893  		v4 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
   894  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   895  		v5.AddArg(x)
   896  		v6 := b.NewValue0(v.Pos, OpSub32, typ.UInt32)
   897  		v7 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
   898  		v7.AuxInt = int32ToAuxInt(32)
   899  		v6.AddArg2(v7, s)
   900  		v4.AddArg2(v5, v6)
   901  		v1.AddArg2(v2, v4)
   902  		v8 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
   903  		v9 := b.NewValue0(v.Pos, OpSub32, typ.UInt32)
   904  		v9.AddArg2(s, v7)
   905  		v8.AddArg2(v5, v9)
   906  		v0.AddArg2(v1, v8)
   907  		v10 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
   908  		v10.AddArg2(v5, s)
   909  		v.AddArg2(v0, v10)
   910  		return true
   911  	}
   912  }
   913  func rewriteValuedec64_OpLsh64x64(v *Value) bool {
   914  	v_1 := v.Args[1]
   915  	v_0 := v.Args[0]
   916  	b := v.Block
   917  	typ := &b.Func.Config.Types
   918  	// match: (Lsh64x64 _ (Int64Make (Const32 [c]) _))
   919  	// cond: c != 0
   920  	// result: (Const64 [0])
   921  	for {
   922  		if v_1.Op != OpInt64Make {
   923  			break
   924  		}
   925  		v_1_0 := v_1.Args[0]
   926  		if v_1_0.Op != OpConst32 {
   927  			break
   928  		}
   929  		c := auxIntToInt32(v_1_0.AuxInt)
   930  		if !(c != 0) {
   931  			break
   932  		}
   933  		v.reset(OpConst64)
   934  		v.AuxInt = int64ToAuxInt(0)
   935  		return true
   936  	}
   937  	// match: (Lsh64x64 [c] x (Int64Make (Const32 [0]) lo))
   938  	// result: (Lsh64x32 [c] x lo)
   939  	for {
   940  		c := auxIntToBool(v.AuxInt)
   941  		x := v_0
   942  		if v_1.Op != OpInt64Make {
   943  			break
   944  		}
   945  		lo := v_1.Args[1]
   946  		v_1_0 := v_1.Args[0]
   947  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
   948  			break
   949  		}
   950  		v.reset(OpLsh64x32)
   951  		v.AuxInt = boolToAuxInt(c)
   952  		v.AddArg2(x, lo)
   953  		return true
   954  	}
   955  	// match: (Lsh64x64 x (Int64Make hi lo))
   956  	// cond: hi.Op != OpConst32
   957  	// result: (Lsh64x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
   958  	for {
   959  		x := v_0
   960  		if v_1.Op != OpInt64Make {
   961  			break
   962  		}
   963  		lo := v_1.Args[1]
   964  		hi := v_1.Args[0]
   965  		if !(hi.Op != OpConst32) {
   966  			break
   967  		}
   968  		v.reset(OpLsh64x32)
   969  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
   970  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
   971  		v1.AddArg(hi)
   972  		v0.AddArg2(v1, lo)
   973  		v.AddArg2(x, v0)
   974  		return true
   975  	}
   976  	// match: (Lsh64x64 x y)
   977  	// result: (Lsh64x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
   978  	for {
   979  		x := v_0
   980  		y := v_1
   981  		v.reset(OpLsh64x32)
   982  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
   983  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
   984  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
   985  		v2.AddArg(y)
   986  		v1.AddArg(v2)
   987  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
   988  		v3.AddArg(y)
   989  		v0.AddArg2(v1, v3)
   990  		v.AddArg2(x, v0)
   991  		return true
   992  	}
   993  }
   994  func rewriteValuedec64_OpLsh64x8(v *Value) bool {
   995  	v_1 := v.Args[1]
   996  	v_0 := v.Args[0]
   997  	b := v.Block
   998  	typ := &b.Func.Config.Types
   999  	// match: (Lsh64x8 x s)
  1000  	// result: (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))
  1001  	for {
  1002  		x := v_0
  1003  		s := v_1
  1004  		v.reset(OpInt64Make)
  1005  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1006  		v1 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1007  		v2 := b.NewValue0(v.Pos, OpLsh32x8, typ.UInt32)
  1008  		v3 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1009  		v3.AddArg(x)
  1010  		v2.AddArg2(v3, s)
  1011  		v4 := b.NewValue0(v.Pos, OpRsh32Ux8, typ.UInt32)
  1012  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1013  		v5.AddArg(x)
  1014  		v6 := b.NewValue0(v.Pos, OpSub8, typ.UInt8)
  1015  		v7 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
  1016  		v7.AuxInt = int8ToAuxInt(32)
  1017  		v6.AddArg2(v7, s)
  1018  		v4.AddArg2(v5, v6)
  1019  		v1.AddArg2(v2, v4)
  1020  		v8 := b.NewValue0(v.Pos, OpLsh32x8, typ.UInt32)
  1021  		v9 := b.NewValue0(v.Pos, OpSub8, typ.UInt8)
  1022  		v9.AddArg2(s, v7)
  1023  		v8.AddArg2(v5, v9)
  1024  		v0.AddArg2(v1, v8)
  1025  		v10 := b.NewValue0(v.Pos, OpLsh32x8, typ.UInt32)
  1026  		v10.AddArg2(v5, s)
  1027  		v.AddArg2(v0, v10)
  1028  		return true
  1029  	}
  1030  }
  1031  func rewriteValuedec64_OpLsh8x64(v *Value) bool {
  1032  	v_1 := v.Args[1]
  1033  	v_0 := v.Args[0]
  1034  	b := v.Block
  1035  	typ := &b.Func.Config.Types
  1036  	// match: (Lsh8x64 _ (Int64Make (Const32 [c]) _))
  1037  	// cond: c != 0
  1038  	// result: (Const32 [0])
  1039  	for {
  1040  		if v_1.Op != OpInt64Make {
  1041  			break
  1042  		}
  1043  		v_1_0 := v_1.Args[0]
  1044  		if v_1_0.Op != OpConst32 {
  1045  			break
  1046  		}
  1047  		c := auxIntToInt32(v_1_0.AuxInt)
  1048  		if !(c != 0) {
  1049  			break
  1050  		}
  1051  		v.reset(OpConst32)
  1052  		v.AuxInt = int32ToAuxInt(0)
  1053  		return true
  1054  	}
  1055  	// match: (Lsh8x64 [c] x (Int64Make (Const32 [0]) lo))
  1056  	// result: (Lsh8x32 [c] x lo)
  1057  	for {
  1058  		c := auxIntToBool(v.AuxInt)
  1059  		x := v_0
  1060  		if v_1.Op != OpInt64Make {
  1061  			break
  1062  		}
  1063  		lo := v_1.Args[1]
  1064  		v_1_0 := v_1.Args[0]
  1065  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
  1066  			break
  1067  		}
  1068  		v.reset(OpLsh8x32)
  1069  		v.AuxInt = boolToAuxInt(c)
  1070  		v.AddArg2(x, lo)
  1071  		return true
  1072  	}
  1073  	// match: (Lsh8x64 x (Int64Make hi lo))
  1074  	// cond: hi.Op != OpConst32
  1075  	// result: (Lsh8x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
  1076  	for {
  1077  		x := v_0
  1078  		if v_1.Op != OpInt64Make {
  1079  			break
  1080  		}
  1081  		lo := v_1.Args[1]
  1082  		hi := v_1.Args[0]
  1083  		if !(hi.Op != OpConst32) {
  1084  			break
  1085  		}
  1086  		v.reset(OpLsh8x32)
  1087  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1088  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  1089  		v1.AddArg(hi)
  1090  		v0.AddArg2(v1, lo)
  1091  		v.AddArg2(x, v0)
  1092  		return true
  1093  	}
  1094  	// match: (Lsh8x64 x y)
  1095  	// result: (Lsh8x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
  1096  	for {
  1097  		x := v_0
  1098  		y := v_1
  1099  		v.reset(OpLsh8x32)
  1100  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1101  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  1102  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1103  		v2.AddArg(y)
  1104  		v1.AddArg(v2)
  1105  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1106  		v3.AddArg(y)
  1107  		v0.AddArg2(v1, v3)
  1108  		v.AddArg2(x, v0)
  1109  		return true
  1110  	}
  1111  }
  1112  func rewriteValuedec64_OpMul64(v *Value) bool {
  1113  	v_1 := v.Args[1]
  1114  	v_0 := v.Args[0]
  1115  	b := v.Block
  1116  	typ := &b.Func.Config.Types
  1117  	// match: (Mul64 x y)
  1118  	// result: (Int64Make (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Int64Lo x) (Int64Hi y)) (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Int64Hi x) (Int64Lo y)) (Select0 <typ.UInt32> (Mul32uhilo (Int64Lo x) (Int64Lo y))))) (Select1 <typ.UInt32> (Mul32uhilo (Int64Lo x) (Int64Lo y))))
  1119  	for {
  1120  		x := v_0
  1121  		y := v_1
  1122  		v.reset(OpInt64Make)
  1123  		v0 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
  1124  		v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
  1125  		v2 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1126  		v2.AddArg(x)
  1127  		v3 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1128  		v3.AddArg(y)
  1129  		v1.AddArg2(v2, v3)
  1130  		v4 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32)
  1131  		v5 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
  1132  		v6 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1133  		v6.AddArg(x)
  1134  		v7 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1135  		v7.AddArg(y)
  1136  		v5.AddArg2(v6, v7)
  1137  		v8 := b.NewValue0(v.Pos, OpSelect0, typ.UInt32)
  1138  		v9 := b.NewValue0(v.Pos, OpMul32uhilo, types.NewTuple(typ.UInt32, typ.UInt32))
  1139  		v9.AddArg2(v2, v7)
  1140  		v8.AddArg(v9)
  1141  		v4.AddArg2(v5, v8)
  1142  		v0.AddArg2(v1, v4)
  1143  		v10 := b.NewValue0(v.Pos, OpSelect1, typ.UInt32)
  1144  		v10.AddArg(v9)
  1145  		v.AddArg2(v0, v10)
  1146  		return true
  1147  	}
  1148  }
  1149  func rewriteValuedec64_OpNeg64(v *Value) bool {
  1150  	v_0 := v.Args[0]
  1151  	b := v.Block
  1152  	// match: (Neg64 <t> x)
  1153  	// result: (Sub64 (Const64 <t> [0]) x)
  1154  	for {
  1155  		t := v.Type
  1156  		x := v_0
  1157  		v.reset(OpSub64)
  1158  		v0 := b.NewValue0(v.Pos, OpConst64, t)
  1159  		v0.AuxInt = int64ToAuxInt(0)
  1160  		v.AddArg2(v0, x)
  1161  		return true
  1162  	}
  1163  }
  1164  func rewriteValuedec64_OpNeq64(v *Value) bool {
  1165  	v_1 := v.Args[1]
  1166  	v_0 := v.Args[0]
  1167  	b := v.Block
  1168  	typ := &b.Func.Config.Types
  1169  	// match: (Neq64 x y)
  1170  	// result: (OrB (Neq32 (Int64Hi x) (Int64Hi y)) (Neq32 (Int64Lo x) (Int64Lo y)))
  1171  	for {
  1172  		x := v_0
  1173  		y := v_1
  1174  		v.reset(OpOrB)
  1175  		v0 := b.NewValue0(v.Pos, OpNeq32, typ.Bool)
  1176  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1177  		v1.AddArg(x)
  1178  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1179  		v2.AddArg(y)
  1180  		v0.AddArg2(v1, v2)
  1181  		v3 := b.NewValue0(v.Pos, OpNeq32, typ.Bool)
  1182  		v4 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1183  		v4.AddArg(x)
  1184  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1185  		v5.AddArg(y)
  1186  		v3.AddArg2(v4, v5)
  1187  		v.AddArg2(v0, v3)
  1188  		return true
  1189  	}
  1190  }
  1191  func rewriteValuedec64_OpOr32(v *Value) bool {
  1192  	v_1 := v.Args[1]
  1193  	v_0 := v.Args[0]
  1194  	b := v.Block
  1195  	typ := &b.Func.Config.Types
  1196  	// match: (Or32 <typ.UInt32> (Zeromask (Const32 [c])) y)
  1197  	// cond: c == 0
  1198  	// result: y
  1199  	for {
  1200  		if v.Type != typ.UInt32 {
  1201  			break
  1202  		}
  1203  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1204  			if v_0.Op != OpZeromask {
  1205  				continue
  1206  			}
  1207  			v_0_0 := v_0.Args[0]
  1208  			if v_0_0.Op != OpConst32 {
  1209  				continue
  1210  			}
  1211  			c := auxIntToInt32(v_0_0.AuxInt)
  1212  			y := v_1
  1213  			if !(c == 0) {
  1214  				continue
  1215  			}
  1216  			v.copyOf(y)
  1217  			return true
  1218  		}
  1219  		break
  1220  	}
  1221  	// match: (Or32 <typ.UInt32> (Zeromask (Const32 [c])) y)
  1222  	// cond: c != 0
  1223  	// result: (Const32 <typ.UInt32> [-1])
  1224  	for {
  1225  		if v.Type != typ.UInt32 {
  1226  			break
  1227  		}
  1228  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1229  			if v_0.Op != OpZeromask {
  1230  				continue
  1231  			}
  1232  			v_0_0 := v_0.Args[0]
  1233  			if v_0_0.Op != OpConst32 {
  1234  				continue
  1235  			}
  1236  			c := auxIntToInt32(v_0_0.AuxInt)
  1237  			if !(c != 0) {
  1238  				continue
  1239  			}
  1240  			v.reset(OpConst32)
  1241  			v.Type = typ.UInt32
  1242  			v.AuxInt = int32ToAuxInt(-1)
  1243  			return true
  1244  		}
  1245  		break
  1246  	}
  1247  	return false
  1248  }
  1249  func rewriteValuedec64_OpOr64(v *Value) bool {
  1250  	v_1 := v.Args[1]
  1251  	v_0 := v.Args[0]
  1252  	b := v.Block
  1253  	typ := &b.Func.Config.Types
  1254  	// match: (Or64 x y)
  1255  	// result: (Int64Make (Or32 <typ.UInt32> (Int64Hi x) (Int64Hi y)) (Or32 <typ.UInt32> (Int64Lo x) (Int64Lo y)))
  1256  	for {
  1257  		x := v_0
  1258  		y := v_1
  1259  		v.reset(OpInt64Make)
  1260  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1261  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1262  		v1.AddArg(x)
  1263  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1264  		v2.AddArg(y)
  1265  		v0.AddArg2(v1, v2)
  1266  		v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1267  		v4 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1268  		v4.AddArg(x)
  1269  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1270  		v5.AddArg(y)
  1271  		v3.AddArg2(v4, v5)
  1272  		v.AddArg2(v0, v3)
  1273  		return true
  1274  	}
  1275  }
  1276  func rewriteValuedec64_OpRotateLeft16(v *Value) bool {
  1277  	v_1 := v.Args[1]
  1278  	v_0 := v.Args[0]
  1279  	// match: (RotateLeft16 x (Int64Make hi lo))
  1280  	// result: (RotateLeft16 x lo)
  1281  	for {
  1282  		x := v_0
  1283  		if v_1.Op != OpInt64Make {
  1284  			break
  1285  		}
  1286  		lo := v_1.Args[1]
  1287  		v.reset(OpRotateLeft16)
  1288  		v.AddArg2(x, lo)
  1289  		return true
  1290  	}
  1291  	return false
  1292  }
  1293  func rewriteValuedec64_OpRotateLeft32(v *Value) bool {
  1294  	v_1 := v.Args[1]
  1295  	v_0 := v.Args[0]
  1296  	// match: (RotateLeft32 x (Int64Make hi lo))
  1297  	// result: (RotateLeft32 x lo)
  1298  	for {
  1299  		x := v_0
  1300  		if v_1.Op != OpInt64Make {
  1301  			break
  1302  		}
  1303  		lo := v_1.Args[1]
  1304  		v.reset(OpRotateLeft32)
  1305  		v.AddArg2(x, lo)
  1306  		return true
  1307  	}
  1308  	return false
  1309  }
  1310  func rewriteValuedec64_OpRotateLeft64(v *Value) bool {
  1311  	v_1 := v.Args[1]
  1312  	v_0 := v.Args[0]
  1313  	// match: (RotateLeft64 x (Int64Make hi lo))
  1314  	// result: (RotateLeft64 x lo)
  1315  	for {
  1316  		x := v_0
  1317  		if v_1.Op != OpInt64Make {
  1318  			break
  1319  		}
  1320  		lo := v_1.Args[1]
  1321  		v.reset(OpRotateLeft64)
  1322  		v.AddArg2(x, lo)
  1323  		return true
  1324  	}
  1325  	return false
  1326  }
  1327  func rewriteValuedec64_OpRotateLeft8(v *Value) bool {
  1328  	v_1 := v.Args[1]
  1329  	v_0 := v.Args[0]
  1330  	// match: (RotateLeft8 x (Int64Make hi lo))
  1331  	// result: (RotateLeft8 x lo)
  1332  	for {
  1333  		x := v_0
  1334  		if v_1.Op != OpInt64Make {
  1335  			break
  1336  		}
  1337  		lo := v_1.Args[1]
  1338  		v.reset(OpRotateLeft8)
  1339  		v.AddArg2(x, lo)
  1340  		return true
  1341  	}
  1342  	return false
  1343  }
  1344  func rewriteValuedec64_OpRsh16Ux64(v *Value) bool {
  1345  	v_1 := v.Args[1]
  1346  	v_0 := v.Args[0]
  1347  	b := v.Block
  1348  	typ := &b.Func.Config.Types
  1349  	// match: (Rsh16Ux64 _ (Int64Make (Const32 [c]) _))
  1350  	// cond: c != 0
  1351  	// result: (Const32 [0])
  1352  	for {
  1353  		if v_1.Op != OpInt64Make {
  1354  			break
  1355  		}
  1356  		v_1_0 := v_1.Args[0]
  1357  		if v_1_0.Op != OpConst32 {
  1358  			break
  1359  		}
  1360  		c := auxIntToInt32(v_1_0.AuxInt)
  1361  		if !(c != 0) {
  1362  			break
  1363  		}
  1364  		v.reset(OpConst32)
  1365  		v.AuxInt = int32ToAuxInt(0)
  1366  		return true
  1367  	}
  1368  	// match: (Rsh16Ux64 [c] x (Int64Make (Const32 [0]) lo))
  1369  	// result: (Rsh16Ux32 [c] x lo)
  1370  	for {
  1371  		c := auxIntToBool(v.AuxInt)
  1372  		x := v_0
  1373  		if v_1.Op != OpInt64Make {
  1374  			break
  1375  		}
  1376  		lo := v_1.Args[1]
  1377  		v_1_0 := v_1.Args[0]
  1378  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
  1379  			break
  1380  		}
  1381  		v.reset(OpRsh16Ux32)
  1382  		v.AuxInt = boolToAuxInt(c)
  1383  		v.AddArg2(x, lo)
  1384  		return true
  1385  	}
  1386  	// match: (Rsh16Ux64 x (Int64Make hi lo))
  1387  	// cond: hi.Op != OpConst32
  1388  	// result: (Rsh16Ux32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
  1389  	for {
  1390  		x := v_0
  1391  		if v_1.Op != OpInt64Make {
  1392  			break
  1393  		}
  1394  		lo := v_1.Args[1]
  1395  		hi := v_1.Args[0]
  1396  		if !(hi.Op != OpConst32) {
  1397  			break
  1398  		}
  1399  		v.reset(OpRsh16Ux32)
  1400  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1401  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  1402  		v1.AddArg(hi)
  1403  		v0.AddArg2(v1, lo)
  1404  		v.AddArg2(x, v0)
  1405  		return true
  1406  	}
  1407  	// match: (Rsh16Ux64 x y)
  1408  	// result: (Rsh16Ux32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
  1409  	for {
  1410  		x := v_0
  1411  		y := v_1
  1412  		v.reset(OpRsh16Ux32)
  1413  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1414  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  1415  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1416  		v2.AddArg(y)
  1417  		v1.AddArg(v2)
  1418  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1419  		v3.AddArg(y)
  1420  		v0.AddArg2(v1, v3)
  1421  		v.AddArg2(x, v0)
  1422  		return true
  1423  	}
  1424  }
  1425  func rewriteValuedec64_OpRsh16x64(v *Value) bool {
  1426  	v_1 := v.Args[1]
  1427  	v_0 := v.Args[0]
  1428  	b := v.Block
  1429  	typ := &b.Func.Config.Types
  1430  	// match: (Rsh16x64 x (Int64Make (Const32 [c]) _))
  1431  	// cond: c != 0
  1432  	// result: (Signmask (SignExt16to32 x))
  1433  	for {
  1434  		x := v_0
  1435  		if v_1.Op != OpInt64Make {
  1436  			break
  1437  		}
  1438  		v_1_0 := v_1.Args[0]
  1439  		if v_1_0.Op != OpConst32 {
  1440  			break
  1441  		}
  1442  		c := auxIntToInt32(v_1_0.AuxInt)
  1443  		if !(c != 0) {
  1444  			break
  1445  		}
  1446  		v.reset(OpSignmask)
  1447  		v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
  1448  		v0.AddArg(x)
  1449  		v.AddArg(v0)
  1450  		return true
  1451  	}
  1452  	// match: (Rsh16x64 [c] x (Int64Make (Const32 [0]) lo))
  1453  	// result: (Rsh16x32 [c] x lo)
  1454  	for {
  1455  		c := auxIntToBool(v.AuxInt)
  1456  		x := v_0
  1457  		if v_1.Op != OpInt64Make {
  1458  			break
  1459  		}
  1460  		lo := v_1.Args[1]
  1461  		v_1_0 := v_1.Args[0]
  1462  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
  1463  			break
  1464  		}
  1465  		v.reset(OpRsh16x32)
  1466  		v.AuxInt = boolToAuxInt(c)
  1467  		v.AddArg2(x, lo)
  1468  		return true
  1469  	}
  1470  	// match: (Rsh16x64 x (Int64Make hi lo))
  1471  	// cond: hi.Op != OpConst32
  1472  	// result: (Rsh16x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
  1473  	for {
  1474  		x := v_0
  1475  		if v_1.Op != OpInt64Make {
  1476  			break
  1477  		}
  1478  		lo := v_1.Args[1]
  1479  		hi := v_1.Args[0]
  1480  		if !(hi.Op != OpConst32) {
  1481  			break
  1482  		}
  1483  		v.reset(OpRsh16x32)
  1484  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1485  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  1486  		v1.AddArg(hi)
  1487  		v0.AddArg2(v1, lo)
  1488  		v.AddArg2(x, v0)
  1489  		return true
  1490  	}
  1491  	// match: (Rsh16x64 x y)
  1492  	// result: (Rsh16x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
  1493  	for {
  1494  		x := v_0
  1495  		y := v_1
  1496  		v.reset(OpRsh16x32)
  1497  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1498  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  1499  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1500  		v2.AddArg(y)
  1501  		v1.AddArg(v2)
  1502  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1503  		v3.AddArg(y)
  1504  		v0.AddArg2(v1, v3)
  1505  		v.AddArg2(x, v0)
  1506  		return true
  1507  	}
  1508  }
  1509  func rewriteValuedec64_OpRsh32Ux64(v *Value) bool {
  1510  	v_1 := v.Args[1]
  1511  	v_0 := v.Args[0]
  1512  	b := v.Block
  1513  	typ := &b.Func.Config.Types
  1514  	// match: (Rsh32Ux64 _ (Int64Make (Const32 [c]) _))
  1515  	// cond: c != 0
  1516  	// result: (Const32 [0])
  1517  	for {
  1518  		if v_1.Op != OpInt64Make {
  1519  			break
  1520  		}
  1521  		v_1_0 := v_1.Args[0]
  1522  		if v_1_0.Op != OpConst32 {
  1523  			break
  1524  		}
  1525  		c := auxIntToInt32(v_1_0.AuxInt)
  1526  		if !(c != 0) {
  1527  			break
  1528  		}
  1529  		v.reset(OpConst32)
  1530  		v.AuxInt = int32ToAuxInt(0)
  1531  		return true
  1532  	}
  1533  	// match: (Rsh32Ux64 [c] x (Int64Make (Const32 [0]) lo))
  1534  	// result: (Rsh32Ux32 [c] x lo)
  1535  	for {
  1536  		c := auxIntToBool(v.AuxInt)
  1537  		x := v_0
  1538  		if v_1.Op != OpInt64Make {
  1539  			break
  1540  		}
  1541  		lo := v_1.Args[1]
  1542  		v_1_0 := v_1.Args[0]
  1543  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
  1544  			break
  1545  		}
  1546  		v.reset(OpRsh32Ux32)
  1547  		v.AuxInt = boolToAuxInt(c)
  1548  		v.AddArg2(x, lo)
  1549  		return true
  1550  	}
  1551  	// match: (Rsh32Ux64 x (Int64Make hi lo))
  1552  	// cond: hi.Op != OpConst32
  1553  	// result: (Rsh32Ux32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
  1554  	for {
  1555  		x := v_0
  1556  		if v_1.Op != OpInt64Make {
  1557  			break
  1558  		}
  1559  		lo := v_1.Args[1]
  1560  		hi := v_1.Args[0]
  1561  		if !(hi.Op != OpConst32) {
  1562  			break
  1563  		}
  1564  		v.reset(OpRsh32Ux32)
  1565  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1566  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  1567  		v1.AddArg(hi)
  1568  		v0.AddArg2(v1, lo)
  1569  		v.AddArg2(x, v0)
  1570  		return true
  1571  	}
  1572  	// match: (Rsh32Ux64 x y)
  1573  	// result: (Rsh32Ux32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
  1574  	for {
  1575  		x := v_0
  1576  		y := v_1
  1577  		v.reset(OpRsh32Ux32)
  1578  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1579  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  1580  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1581  		v2.AddArg(y)
  1582  		v1.AddArg(v2)
  1583  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1584  		v3.AddArg(y)
  1585  		v0.AddArg2(v1, v3)
  1586  		v.AddArg2(x, v0)
  1587  		return true
  1588  	}
  1589  }
  1590  func rewriteValuedec64_OpRsh32x64(v *Value) bool {
  1591  	v_1 := v.Args[1]
  1592  	v_0 := v.Args[0]
  1593  	b := v.Block
  1594  	typ := &b.Func.Config.Types
  1595  	// match: (Rsh32x64 x (Int64Make (Const32 [c]) _))
  1596  	// cond: c != 0
  1597  	// result: (Signmask x)
  1598  	for {
  1599  		x := v_0
  1600  		if v_1.Op != OpInt64Make {
  1601  			break
  1602  		}
  1603  		v_1_0 := v_1.Args[0]
  1604  		if v_1_0.Op != OpConst32 {
  1605  			break
  1606  		}
  1607  		c := auxIntToInt32(v_1_0.AuxInt)
  1608  		if !(c != 0) {
  1609  			break
  1610  		}
  1611  		v.reset(OpSignmask)
  1612  		v.AddArg(x)
  1613  		return true
  1614  	}
  1615  	// match: (Rsh32x64 [c] x (Int64Make (Const32 [0]) lo))
  1616  	// result: (Rsh32x32 [c] x lo)
  1617  	for {
  1618  		c := auxIntToBool(v.AuxInt)
  1619  		x := v_0
  1620  		if v_1.Op != OpInt64Make {
  1621  			break
  1622  		}
  1623  		lo := v_1.Args[1]
  1624  		v_1_0 := v_1.Args[0]
  1625  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
  1626  			break
  1627  		}
  1628  		v.reset(OpRsh32x32)
  1629  		v.AuxInt = boolToAuxInt(c)
  1630  		v.AddArg2(x, lo)
  1631  		return true
  1632  	}
  1633  	// match: (Rsh32x64 x (Int64Make hi lo))
  1634  	// cond: hi.Op != OpConst32
  1635  	// result: (Rsh32x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
  1636  	for {
  1637  		x := v_0
  1638  		if v_1.Op != OpInt64Make {
  1639  			break
  1640  		}
  1641  		lo := v_1.Args[1]
  1642  		hi := v_1.Args[0]
  1643  		if !(hi.Op != OpConst32) {
  1644  			break
  1645  		}
  1646  		v.reset(OpRsh32x32)
  1647  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1648  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  1649  		v1.AddArg(hi)
  1650  		v0.AddArg2(v1, lo)
  1651  		v.AddArg2(x, v0)
  1652  		return true
  1653  	}
  1654  	// match: (Rsh32x64 x y)
  1655  	// result: (Rsh32x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
  1656  	for {
  1657  		x := v_0
  1658  		y := v_1
  1659  		v.reset(OpRsh32x32)
  1660  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1661  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  1662  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1663  		v2.AddArg(y)
  1664  		v1.AddArg(v2)
  1665  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1666  		v3.AddArg(y)
  1667  		v0.AddArg2(v1, v3)
  1668  		v.AddArg2(x, v0)
  1669  		return true
  1670  	}
  1671  }
  1672  func rewriteValuedec64_OpRsh64Ux16(v *Value) bool {
  1673  	v_1 := v.Args[1]
  1674  	v_0 := v.Args[0]
  1675  	b := v.Block
  1676  	typ := &b.Func.Config.Types
  1677  	// match: (Rsh64Ux16 x s)
  1678  	// result: (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])))))
  1679  	for {
  1680  		x := v_0
  1681  		s := v_1
  1682  		v.reset(OpInt64Make)
  1683  		v0 := b.NewValue0(v.Pos, OpRsh32Ux16, typ.UInt32)
  1684  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1685  		v1.AddArg(x)
  1686  		v0.AddArg2(v1, s)
  1687  		v2 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1688  		v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1689  		v4 := b.NewValue0(v.Pos, OpRsh32Ux16, typ.UInt32)
  1690  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1691  		v5.AddArg(x)
  1692  		v4.AddArg2(v5, s)
  1693  		v6 := b.NewValue0(v.Pos, OpLsh32x16, typ.UInt32)
  1694  		v7 := b.NewValue0(v.Pos, OpSub16, typ.UInt16)
  1695  		v8 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  1696  		v8.AuxInt = int16ToAuxInt(32)
  1697  		v7.AddArg2(v8, s)
  1698  		v6.AddArg2(v1, v7)
  1699  		v3.AddArg2(v4, v6)
  1700  		v9 := b.NewValue0(v.Pos, OpRsh32Ux16, typ.UInt32)
  1701  		v10 := b.NewValue0(v.Pos, OpSub16, typ.UInt16)
  1702  		v10.AddArg2(s, v8)
  1703  		v9.AddArg2(v1, v10)
  1704  		v2.AddArg2(v3, v9)
  1705  		v.AddArg2(v0, v2)
  1706  		return true
  1707  	}
  1708  }
  1709  func rewriteValuedec64_OpRsh64Ux32(v *Value) bool {
  1710  	v_1 := v.Args[1]
  1711  	v_0 := v.Args[0]
  1712  	b := v.Block
  1713  	typ := &b.Func.Config.Types
  1714  	// match: (Rsh64Ux32 x s)
  1715  	// result: (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])))))
  1716  	for {
  1717  		x := v_0
  1718  		s := v_1
  1719  		v.reset(OpInt64Make)
  1720  		v0 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1721  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1722  		v1.AddArg(x)
  1723  		v0.AddArg2(v1, s)
  1724  		v2 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1725  		v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1726  		v4 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1727  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1728  		v5.AddArg(x)
  1729  		v4.AddArg2(v5, s)
  1730  		v6 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  1731  		v7 := b.NewValue0(v.Pos, OpSub32, typ.UInt32)
  1732  		v8 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1733  		v8.AuxInt = int32ToAuxInt(32)
  1734  		v7.AddArg2(v8, s)
  1735  		v6.AddArg2(v1, v7)
  1736  		v3.AddArg2(v4, v6)
  1737  		v9 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1738  		v10 := b.NewValue0(v.Pos, OpSub32, typ.UInt32)
  1739  		v10.AddArg2(s, v8)
  1740  		v9.AddArg2(v1, v10)
  1741  		v2.AddArg2(v3, v9)
  1742  		v.AddArg2(v0, v2)
  1743  		return true
  1744  	}
  1745  }
  1746  func rewriteValuedec64_OpRsh64Ux64(v *Value) bool {
  1747  	v_1 := v.Args[1]
  1748  	v_0 := v.Args[0]
  1749  	b := v.Block
  1750  	typ := &b.Func.Config.Types
  1751  	// match: (Rsh64Ux64 _ (Int64Make (Const32 [c]) _))
  1752  	// cond: c != 0
  1753  	// result: (Const64 [0])
  1754  	for {
  1755  		if v_1.Op != OpInt64Make {
  1756  			break
  1757  		}
  1758  		v_1_0 := v_1.Args[0]
  1759  		if v_1_0.Op != OpConst32 {
  1760  			break
  1761  		}
  1762  		c := auxIntToInt32(v_1_0.AuxInt)
  1763  		if !(c != 0) {
  1764  			break
  1765  		}
  1766  		v.reset(OpConst64)
  1767  		v.AuxInt = int64ToAuxInt(0)
  1768  		return true
  1769  	}
  1770  	// match: (Rsh64Ux64 [c] x (Int64Make (Const32 [0]) lo))
  1771  	// result: (Rsh64Ux32 [c] x lo)
  1772  	for {
  1773  		c := auxIntToBool(v.AuxInt)
  1774  		x := v_0
  1775  		if v_1.Op != OpInt64Make {
  1776  			break
  1777  		}
  1778  		lo := v_1.Args[1]
  1779  		v_1_0 := v_1.Args[0]
  1780  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
  1781  			break
  1782  		}
  1783  		v.reset(OpRsh64Ux32)
  1784  		v.AuxInt = boolToAuxInt(c)
  1785  		v.AddArg2(x, lo)
  1786  		return true
  1787  	}
  1788  	// match: (Rsh64Ux64 x (Int64Make hi lo))
  1789  	// cond: hi.Op != OpConst32
  1790  	// result: (Rsh64Ux32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
  1791  	for {
  1792  		x := v_0
  1793  		if v_1.Op != OpInt64Make {
  1794  			break
  1795  		}
  1796  		lo := v_1.Args[1]
  1797  		hi := v_1.Args[0]
  1798  		if !(hi.Op != OpConst32) {
  1799  			break
  1800  		}
  1801  		v.reset(OpRsh64Ux32)
  1802  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1803  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  1804  		v1.AddArg(hi)
  1805  		v0.AddArg2(v1, lo)
  1806  		v.AddArg2(x, v0)
  1807  		return true
  1808  	}
  1809  	// match: (Rsh64Ux64 x y)
  1810  	// result: (Rsh64Ux32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
  1811  	for {
  1812  		x := v_0
  1813  		y := v_1
  1814  		v.reset(OpRsh64Ux32)
  1815  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1816  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  1817  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1818  		v2.AddArg(y)
  1819  		v1.AddArg(v2)
  1820  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1821  		v3.AddArg(y)
  1822  		v0.AddArg2(v1, v3)
  1823  		v.AddArg2(x, v0)
  1824  		return true
  1825  	}
  1826  }
  1827  func rewriteValuedec64_OpRsh64Ux8(v *Value) bool {
  1828  	v_1 := v.Args[1]
  1829  	v_0 := v.Args[0]
  1830  	b := v.Block
  1831  	typ := &b.Func.Config.Types
  1832  	// match: (Rsh64Ux8 x s)
  1833  	// result: (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])))))
  1834  	for {
  1835  		x := v_0
  1836  		s := v_1
  1837  		v.reset(OpInt64Make)
  1838  		v0 := b.NewValue0(v.Pos, OpRsh32Ux8, typ.UInt32)
  1839  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1840  		v1.AddArg(x)
  1841  		v0.AddArg2(v1, s)
  1842  		v2 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1843  		v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1844  		v4 := b.NewValue0(v.Pos, OpRsh32Ux8, typ.UInt32)
  1845  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1846  		v5.AddArg(x)
  1847  		v4.AddArg2(v5, s)
  1848  		v6 := b.NewValue0(v.Pos, OpLsh32x8, typ.UInt32)
  1849  		v7 := b.NewValue0(v.Pos, OpSub8, typ.UInt8)
  1850  		v8 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
  1851  		v8.AuxInt = int8ToAuxInt(32)
  1852  		v7.AddArg2(v8, s)
  1853  		v6.AddArg2(v1, v7)
  1854  		v3.AddArg2(v4, v6)
  1855  		v9 := b.NewValue0(v.Pos, OpRsh32Ux8, typ.UInt32)
  1856  		v10 := b.NewValue0(v.Pos, OpSub8, typ.UInt8)
  1857  		v10.AddArg2(s, v8)
  1858  		v9.AddArg2(v1, v10)
  1859  		v2.AddArg2(v3, v9)
  1860  		v.AddArg2(v0, v2)
  1861  		return true
  1862  	}
  1863  }
  1864  func rewriteValuedec64_OpRsh64x16(v *Value) bool {
  1865  	v_1 := v.Args[1]
  1866  	v_0 := v.Args[0]
  1867  	b := v.Block
  1868  	typ := &b.Func.Config.Types
  1869  	// match: (Rsh64x16 x s)
  1870  	// result: (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])))))))
  1871  	for {
  1872  		x := v_0
  1873  		s := v_1
  1874  		v.reset(OpInt64Make)
  1875  		v0 := b.NewValue0(v.Pos, OpRsh32x16, typ.UInt32)
  1876  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1877  		v1.AddArg(x)
  1878  		v0.AddArg2(v1, s)
  1879  		v2 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1880  		v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1881  		v4 := b.NewValue0(v.Pos, OpRsh32Ux16, typ.UInt32)
  1882  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1883  		v5.AddArg(x)
  1884  		v4.AddArg2(v5, s)
  1885  		v6 := b.NewValue0(v.Pos, OpLsh32x16, typ.UInt32)
  1886  		v7 := b.NewValue0(v.Pos, OpSub16, typ.UInt16)
  1887  		v8 := b.NewValue0(v.Pos, OpConst16, typ.UInt16)
  1888  		v8.AuxInt = int16ToAuxInt(32)
  1889  		v7.AddArg2(v8, s)
  1890  		v6.AddArg2(v1, v7)
  1891  		v3.AddArg2(v4, v6)
  1892  		v9 := b.NewValue0(v.Pos, OpAnd32, typ.UInt32)
  1893  		v10 := b.NewValue0(v.Pos, OpRsh32x16, typ.UInt32)
  1894  		v11 := b.NewValue0(v.Pos, OpSub16, typ.UInt16)
  1895  		v11.AddArg2(s, v8)
  1896  		v10.AddArg2(v1, v11)
  1897  		v12 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  1898  		v13 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
  1899  		v14 := b.NewValue0(v.Pos, OpRsh16Ux32, typ.UInt16)
  1900  		v15 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1901  		v15.AuxInt = int32ToAuxInt(5)
  1902  		v14.AddArg2(s, v15)
  1903  		v13.AddArg(v14)
  1904  		v12.AddArg(v13)
  1905  		v9.AddArg2(v10, v12)
  1906  		v2.AddArg2(v3, v9)
  1907  		v.AddArg2(v0, v2)
  1908  		return true
  1909  	}
  1910  }
  1911  func rewriteValuedec64_OpRsh64x32(v *Value) bool {
  1912  	v_1 := v.Args[1]
  1913  	v_0 := v.Args[0]
  1914  	b := v.Block
  1915  	typ := &b.Func.Config.Types
  1916  	// match: (Rsh64x32 x s)
  1917  	// result: (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]))))))
  1918  	for {
  1919  		x := v_0
  1920  		s := v_1
  1921  		v.reset(OpInt64Make)
  1922  		v0 := b.NewValue0(v.Pos, OpRsh32x32, typ.UInt32)
  1923  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1924  		v1.AddArg(x)
  1925  		v0.AddArg2(v1, s)
  1926  		v2 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1927  		v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  1928  		v4 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1929  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  1930  		v5.AddArg(x)
  1931  		v4.AddArg2(v5, s)
  1932  		v6 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32)
  1933  		v7 := b.NewValue0(v.Pos, OpSub32, typ.UInt32)
  1934  		v8 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1935  		v8.AuxInt = int32ToAuxInt(32)
  1936  		v7.AddArg2(v8, s)
  1937  		v6.AddArg2(v1, v7)
  1938  		v3.AddArg2(v4, v6)
  1939  		v9 := b.NewValue0(v.Pos, OpAnd32, typ.UInt32)
  1940  		v10 := b.NewValue0(v.Pos, OpRsh32x32, typ.UInt32)
  1941  		v11 := b.NewValue0(v.Pos, OpSub32, typ.UInt32)
  1942  		v11.AddArg2(s, v8)
  1943  		v10.AddArg2(v1, v11)
  1944  		v12 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  1945  		v13 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32)
  1946  		v14 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  1947  		v14.AuxInt = int32ToAuxInt(5)
  1948  		v13.AddArg2(s, v14)
  1949  		v12.AddArg(v13)
  1950  		v9.AddArg2(v10, v12)
  1951  		v2.AddArg2(v3, v9)
  1952  		v.AddArg2(v0, v2)
  1953  		return true
  1954  	}
  1955  }
  1956  func rewriteValuedec64_OpRsh64x64(v *Value) bool {
  1957  	v_1 := v.Args[1]
  1958  	v_0 := v.Args[0]
  1959  	b := v.Block
  1960  	typ := &b.Func.Config.Types
  1961  	// match: (Rsh64x64 x (Int64Make (Const32 [c]) _))
  1962  	// cond: c != 0
  1963  	// result: (Int64Make (Signmask (Int64Hi x)) (Signmask (Int64Hi x)))
  1964  	for {
  1965  		x := v_0
  1966  		if v_1.Op != OpInt64Make {
  1967  			break
  1968  		}
  1969  		v_1_0 := v_1.Args[0]
  1970  		if v_1_0.Op != OpConst32 {
  1971  			break
  1972  		}
  1973  		c := auxIntToInt32(v_1_0.AuxInt)
  1974  		if !(c != 0) {
  1975  			break
  1976  		}
  1977  		v.reset(OpInt64Make)
  1978  		v0 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
  1979  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  1980  		v1.AddArg(x)
  1981  		v0.AddArg(v1)
  1982  		v.AddArg2(v0, v0)
  1983  		return true
  1984  	}
  1985  	// match: (Rsh64x64 [c] x (Int64Make (Const32 [0]) lo))
  1986  	// result: (Rsh64x32 [c] x lo)
  1987  	for {
  1988  		c := auxIntToBool(v.AuxInt)
  1989  		x := v_0
  1990  		if v_1.Op != OpInt64Make {
  1991  			break
  1992  		}
  1993  		lo := v_1.Args[1]
  1994  		v_1_0 := v_1.Args[0]
  1995  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
  1996  			break
  1997  		}
  1998  		v.reset(OpRsh64x32)
  1999  		v.AuxInt = boolToAuxInt(c)
  2000  		v.AddArg2(x, lo)
  2001  		return true
  2002  	}
  2003  	// match: (Rsh64x64 x (Int64Make hi lo))
  2004  	// cond: hi.Op != OpConst32
  2005  	// result: (Rsh64x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
  2006  	for {
  2007  		x := v_0
  2008  		if v_1.Op != OpInt64Make {
  2009  			break
  2010  		}
  2011  		lo := v_1.Args[1]
  2012  		hi := v_1.Args[0]
  2013  		if !(hi.Op != OpConst32) {
  2014  			break
  2015  		}
  2016  		v.reset(OpRsh64x32)
  2017  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2018  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2019  		v1.AddArg(hi)
  2020  		v0.AddArg2(v1, lo)
  2021  		v.AddArg2(x, v0)
  2022  		return true
  2023  	}
  2024  	// match: (Rsh64x64 x y)
  2025  	// result: (Rsh64x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
  2026  	for {
  2027  		x := v_0
  2028  		y := v_1
  2029  		v.reset(OpRsh64x32)
  2030  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2031  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2032  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2033  		v2.AddArg(y)
  2034  		v1.AddArg(v2)
  2035  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2036  		v3.AddArg(y)
  2037  		v0.AddArg2(v1, v3)
  2038  		v.AddArg2(x, v0)
  2039  		return true
  2040  	}
  2041  }
  2042  func rewriteValuedec64_OpRsh64x8(v *Value) bool {
  2043  	v_1 := v.Args[1]
  2044  	v_0 := v.Args[0]
  2045  	b := v.Block
  2046  	typ := &b.Func.Config.Types
  2047  	// match: (Rsh64x8 x s)
  2048  	// result: (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])))))))
  2049  	for {
  2050  		x := v_0
  2051  		s := v_1
  2052  		v.reset(OpInt64Make)
  2053  		v0 := b.NewValue0(v.Pos, OpRsh32x8, typ.UInt32)
  2054  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2055  		v1.AddArg(x)
  2056  		v0.AddArg2(v1, s)
  2057  		v2 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2058  		v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2059  		v4 := b.NewValue0(v.Pos, OpRsh32Ux8, typ.UInt32)
  2060  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2061  		v5.AddArg(x)
  2062  		v4.AddArg2(v5, s)
  2063  		v6 := b.NewValue0(v.Pos, OpLsh32x8, typ.UInt32)
  2064  		v7 := b.NewValue0(v.Pos, OpSub8, typ.UInt8)
  2065  		v8 := b.NewValue0(v.Pos, OpConst8, typ.UInt8)
  2066  		v8.AuxInt = int8ToAuxInt(32)
  2067  		v7.AddArg2(v8, s)
  2068  		v6.AddArg2(v1, v7)
  2069  		v3.AddArg2(v4, v6)
  2070  		v9 := b.NewValue0(v.Pos, OpAnd32, typ.UInt32)
  2071  		v10 := b.NewValue0(v.Pos, OpRsh32x8, typ.UInt32)
  2072  		v11 := b.NewValue0(v.Pos, OpSub8, typ.UInt8)
  2073  		v11.AddArg2(s, v8)
  2074  		v10.AddArg2(v1, v11)
  2075  		v12 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2076  		v13 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
  2077  		v14 := b.NewValue0(v.Pos, OpRsh8Ux32, typ.UInt8)
  2078  		v15 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  2079  		v15.AuxInt = int32ToAuxInt(5)
  2080  		v14.AddArg2(s, v15)
  2081  		v13.AddArg(v14)
  2082  		v12.AddArg(v13)
  2083  		v9.AddArg2(v10, v12)
  2084  		v2.AddArg2(v3, v9)
  2085  		v.AddArg2(v0, v2)
  2086  		return true
  2087  	}
  2088  }
  2089  func rewriteValuedec64_OpRsh8Ux64(v *Value) bool {
  2090  	v_1 := v.Args[1]
  2091  	v_0 := v.Args[0]
  2092  	b := v.Block
  2093  	typ := &b.Func.Config.Types
  2094  	// match: (Rsh8Ux64 _ (Int64Make (Const32 [c]) _))
  2095  	// cond: c != 0
  2096  	// result: (Const32 [0])
  2097  	for {
  2098  		if v_1.Op != OpInt64Make {
  2099  			break
  2100  		}
  2101  		v_1_0 := v_1.Args[0]
  2102  		if v_1_0.Op != OpConst32 {
  2103  			break
  2104  		}
  2105  		c := auxIntToInt32(v_1_0.AuxInt)
  2106  		if !(c != 0) {
  2107  			break
  2108  		}
  2109  		v.reset(OpConst32)
  2110  		v.AuxInt = int32ToAuxInt(0)
  2111  		return true
  2112  	}
  2113  	// match: (Rsh8Ux64 [c] x (Int64Make (Const32 [0]) lo))
  2114  	// result: (Rsh8Ux32 [c] x lo)
  2115  	for {
  2116  		c := auxIntToBool(v.AuxInt)
  2117  		x := v_0
  2118  		if v_1.Op != OpInt64Make {
  2119  			break
  2120  		}
  2121  		lo := v_1.Args[1]
  2122  		v_1_0 := v_1.Args[0]
  2123  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
  2124  			break
  2125  		}
  2126  		v.reset(OpRsh8Ux32)
  2127  		v.AuxInt = boolToAuxInt(c)
  2128  		v.AddArg2(x, lo)
  2129  		return true
  2130  	}
  2131  	// match: (Rsh8Ux64 x (Int64Make hi lo))
  2132  	// cond: hi.Op != OpConst32
  2133  	// result: (Rsh8Ux32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
  2134  	for {
  2135  		x := v_0
  2136  		if v_1.Op != OpInt64Make {
  2137  			break
  2138  		}
  2139  		lo := v_1.Args[1]
  2140  		hi := v_1.Args[0]
  2141  		if !(hi.Op != OpConst32) {
  2142  			break
  2143  		}
  2144  		v.reset(OpRsh8Ux32)
  2145  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2146  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2147  		v1.AddArg(hi)
  2148  		v0.AddArg2(v1, lo)
  2149  		v.AddArg2(x, v0)
  2150  		return true
  2151  	}
  2152  	// match: (Rsh8Ux64 x y)
  2153  	// result: (Rsh8Ux32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
  2154  	for {
  2155  		x := v_0
  2156  		y := v_1
  2157  		v.reset(OpRsh8Ux32)
  2158  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2159  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2160  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2161  		v2.AddArg(y)
  2162  		v1.AddArg(v2)
  2163  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2164  		v3.AddArg(y)
  2165  		v0.AddArg2(v1, v3)
  2166  		v.AddArg2(x, v0)
  2167  		return true
  2168  	}
  2169  }
  2170  func rewriteValuedec64_OpRsh8x64(v *Value) bool {
  2171  	v_1 := v.Args[1]
  2172  	v_0 := v.Args[0]
  2173  	b := v.Block
  2174  	typ := &b.Func.Config.Types
  2175  	// match: (Rsh8x64 x (Int64Make (Const32 [c]) _))
  2176  	// cond: c != 0
  2177  	// result: (Signmask (SignExt8to32 x))
  2178  	for {
  2179  		x := v_0
  2180  		if v_1.Op != OpInt64Make {
  2181  			break
  2182  		}
  2183  		v_1_0 := v_1.Args[0]
  2184  		if v_1_0.Op != OpConst32 {
  2185  			break
  2186  		}
  2187  		c := auxIntToInt32(v_1_0.AuxInt)
  2188  		if !(c != 0) {
  2189  			break
  2190  		}
  2191  		v.reset(OpSignmask)
  2192  		v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
  2193  		v0.AddArg(x)
  2194  		v.AddArg(v0)
  2195  		return true
  2196  	}
  2197  	// match: (Rsh8x64 [c] x (Int64Make (Const32 [0]) lo))
  2198  	// result: (Rsh8x32 [c] x lo)
  2199  	for {
  2200  		c := auxIntToBool(v.AuxInt)
  2201  		x := v_0
  2202  		if v_1.Op != OpInt64Make {
  2203  			break
  2204  		}
  2205  		lo := v_1.Args[1]
  2206  		v_1_0 := v_1.Args[0]
  2207  		if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 {
  2208  			break
  2209  		}
  2210  		v.reset(OpRsh8x32)
  2211  		v.AuxInt = boolToAuxInt(c)
  2212  		v.AddArg2(x, lo)
  2213  		return true
  2214  	}
  2215  	// match: (Rsh8x64 x (Int64Make hi lo))
  2216  	// cond: hi.Op != OpConst32
  2217  	// result: (Rsh8x32 x (Or32 <typ.UInt32> (Zeromask hi) lo))
  2218  	for {
  2219  		x := v_0
  2220  		if v_1.Op != OpInt64Make {
  2221  			break
  2222  		}
  2223  		lo := v_1.Args[1]
  2224  		hi := v_1.Args[0]
  2225  		if !(hi.Op != OpConst32) {
  2226  			break
  2227  		}
  2228  		v.reset(OpRsh8x32)
  2229  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2230  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2231  		v1.AddArg(hi)
  2232  		v0.AddArg2(v1, lo)
  2233  		v.AddArg2(x, v0)
  2234  		return true
  2235  	}
  2236  	// match: (Rsh8x64 x y)
  2237  	// result: (Rsh8x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y)))
  2238  	for {
  2239  		x := v_0
  2240  		y := v_1
  2241  		v.reset(OpRsh8x32)
  2242  		v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32)
  2243  		v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32)
  2244  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2245  		v2.AddArg(y)
  2246  		v1.AddArg(v2)
  2247  		v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2248  		v3.AddArg(y)
  2249  		v0.AddArg2(v1, v3)
  2250  		v.AddArg2(x, v0)
  2251  		return true
  2252  	}
  2253  }
  2254  func rewriteValuedec64_OpSignExt16to64(v *Value) bool {
  2255  	v_0 := v.Args[0]
  2256  	b := v.Block
  2257  	typ := &b.Func.Config.Types
  2258  	// match: (SignExt16to64 x)
  2259  	// result: (SignExt32to64 (SignExt16to32 x))
  2260  	for {
  2261  		x := v_0
  2262  		v.reset(OpSignExt32to64)
  2263  		v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
  2264  		v0.AddArg(x)
  2265  		v.AddArg(v0)
  2266  		return true
  2267  	}
  2268  }
  2269  func rewriteValuedec64_OpSignExt32to64(v *Value) bool {
  2270  	v_0 := v.Args[0]
  2271  	b := v.Block
  2272  	typ := &b.Func.Config.Types
  2273  	// match: (SignExt32to64 x)
  2274  	// result: (Int64Make (Signmask x) x)
  2275  	for {
  2276  		x := v_0
  2277  		v.reset(OpInt64Make)
  2278  		v0 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
  2279  		v0.AddArg(x)
  2280  		v.AddArg2(v0, x)
  2281  		return true
  2282  	}
  2283  }
  2284  func rewriteValuedec64_OpSignExt8to64(v *Value) bool {
  2285  	v_0 := v.Args[0]
  2286  	b := v.Block
  2287  	typ := &b.Func.Config.Types
  2288  	// match: (SignExt8to64 x)
  2289  	// result: (SignExt32to64 (SignExt8to32 x))
  2290  	for {
  2291  		x := v_0
  2292  		v.reset(OpSignExt32to64)
  2293  		v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
  2294  		v0.AddArg(x)
  2295  		v.AddArg(v0)
  2296  		return true
  2297  	}
  2298  }
  2299  func rewriteValuedec64_OpStore(v *Value) bool {
  2300  	v_2 := v.Args[2]
  2301  	v_1 := v.Args[1]
  2302  	v_0 := v.Args[0]
  2303  	b := v.Block
  2304  	config := b.Func.Config
  2305  	// match: (Store {t} dst (Int64Make hi lo) mem)
  2306  	// cond: t.Size() == 8 && !config.BigEndian
  2307  	// result: (Store {hi.Type} (OffPtr <hi.Type.PtrTo()> [4] dst) hi (Store {lo.Type} dst lo mem))
  2308  	for {
  2309  		t := auxToType(v.Aux)
  2310  		dst := v_0
  2311  		if v_1.Op != OpInt64Make {
  2312  			break
  2313  		}
  2314  		lo := v_1.Args[1]
  2315  		hi := v_1.Args[0]
  2316  		mem := v_2
  2317  		if !(t.Size() == 8 && !config.BigEndian) {
  2318  			break
  2319  		}
  2320  		v.reset(OpStore)
  2321  		v.Aux = typeToAux(hi.Type)
  2322  		v0 := b.NewValue0(v.Pos, OpOffPtr, hi.Type.PtrTo())
  2323  		v0.AuxInt = int64ToAuxInt(4)
  2324  		v0.AddArg(dst)
  2325  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
  2326  		v1.Aux = typeToAux(lo.Type)
  2327  		v1.AddArg3(dst, lo, mem)
  2328  		v.AddArg3(v0, hi, v1)
  2329  		return true
  2330  	}
  2331  	// match: (Store {t} dst (Int64Make hi lo) mem)
  2332  	// cond: t.Size() == 8 && config.BigEndian
  2333  	// result: (Store {lo.Type} (OffPtr <lo.Type.PtrTo()> [4] dst) lo (Store {hi.Type} dst hi mem))
  2334  	for {
  2335  		t := auxToType(v.Aux)
  2336  		dst := v_0
  2337  		if v_1.Op != OpInt64Make {
  2338  			break
  2339  		}
  2340  		lo := v_1.Args[1]
  2341  		hi := v_1.Args[0]
  2342  		mem := v_2
  2343  		if !(t.Size() == 8 && config.BigEndian) {
  2344  			break
  2345  		}
  2346  		v.reset(OpStore)
  2347  		v.Aux = typeToAux(lo.Type)
  2348  		v0 := b.NewValue0(v.Pos, OpOffPtr, lo.Type.PtrTo())
  2349  		v0.AuxInt = int64ToAuxInt(4)
  2350  		v0.AddArg(dst)
  2351  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
  2352  		v1.Aux = typeToAux(hi.Type)
  2353  		v1.AddArg3(dst, hi, mem)
  2354  		v.AddArg3(v0, lo, v1)
  2355  		return true
  2356  	}
  2357  	return false
  2358  }
  2359  func rewriteValuedec64_OpSub64(v *Value) bool {
  2360  	v_1 := v.Args[1]
  2361  	v_0 := v.Args[0]
  2362  	b := v.Block
  2363  	typ := &b.Func.Config.Types
  2364  	// match: (Sub64 x y)
  2365  	// result: (Int64Make (Sub32withcarry <typ.Int32> (Int64Hi x) (Int64Hi y) (Select1 <types.TypeFlags> (Sub32carry (Int64Lo x) (Int64Lo y)))) (Select0 <typ.UInt32> (Sub32carry (Int64Lo x) (Int64Lo y))))
  2366  	for {
  2367  		x := v_0
  2368  		y := v_1
  2369  		v.reset(OpInt64Make)
  2370  		v0 := b.NewValue0(v.Pos, OpSub32withcarry, typ.Int32)
  2371  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2372  		v1.AddArg(x)
  2373  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2374  		v2.AddArg(y)
  2375  		v3 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
  2376  		v4 := b.NewValue0(v.Pos, OpSub32carry, types.NewTuple(typ.UInt32, types.TypeFlags))
  2377  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2378  		v5.AddArg(x)
  2379  		v6 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2380  		v6.AddArg(y)
  2381  		v4.AddArg2(v5, v6)
  2382  		v3.AddArg(v4)
  2383  		v0.AddArg3(v1, v2, v3)
  2384  		v7 := b.NewValue0(v.Pos, OpSelect0, typ.UInt32)
  2385  		v7.AddArg(v4)
  2386  		v.AddArg2(v0, v7)
  2387  		return true
  2388  	}
  2389  }
  2390  func rewriteValuedec64_OpTrunc64to16(v *Value) bool {
  2391  	v_0 := v.Args[0]
  2392  	b := v.Block
  2393  	typ := &b.Func.Config.Types
  2394  	// match: (Trunc64to16 (Int64Make _ lo))
  2395  	// result: (Trunc32to16 lo)
  2396  	for {
  2397  		if v_0.Op != OpInt64Make {
  2398  			break
  2399  		}
  2400  		lo := v_0.Args[1]
  2401  		v.reset(OpTrunc32to16)
  2402  		v.AddArg(lo)
  2403  		return true
  2404  	}
  2405  	// match: (Trunc64to16 x)
  2406  	// result: (Trunc32to16 (Int64Lo x))
  2407  	for {
  2408  		x := v_0
  2409  		v.reset(OpTrunc32to16)
  2410  		v0 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2411  		v0.AddArg(x)
  2412  		v.AddArg(v0)
  2413  		return true
  2414  	}
  2415  }
  2416  func rewriteValuedec64_OpTrunc64to32(v *Value) bool {
  2417  	v_0 := v.Args[0]
  2418  	// match: (Trunc64to32 (Int64Make _ lo))
  2419  	// result: lo
  2420  	for {
  2421  		if v_0.Op != OpInt64Make {
  2422  			break
  2423  		}
  2424  		lo := v_0.Args[1]
  2425  		v.copyOf(lo)
  2426  		return true
  2427  	}
  2428  	// match: (Trunc64to32 x)
  2429  	// result: (Int64Lo x)
  2430  	for {
  2431  		x := v_0
  2432  		v.reset(OpInt64Lo)
  2433  		v.AddArg(x)
  2434  		return true
  2435  	}
  2436  }
  2437  func rewriteValuedec64_OpTrunc64to8(v *Value) bool {
  2438  	v_0 := v.Args[0]
  2439  	b := v.Block
  2440  	typ := &b.Func.Config.Types
  2441  	// match: (Trunc64to8 (Int64Make _ lo))
  2442  	// result: (Trunc32to8 lo)
  2443  	for {
  2444  		if v_0.Op != OpInt64Make {
  2445  			break
  2446  		}
  2447  		lo := v_0.Args[1]
  2448  		v.reset(OpTrunc32to8)
  2449  		v.AddArg(lo)
  2450  		return true
  2451  	}
  2452  	// match: (Trunc64to8 x)
  2453  	// result: (Trunc32to8 (Int64Lo x))
  2454  	for {
  2455  		x := v_0
  2456  		v.reset(OpTrunc32to8)
  2457  		v0 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2458  		v0.AddArg(x)
  2459  		v.AddArg(v0)
  2460  		return true
  2461  	}
  2462  }
  2463  func rewriteValuedec64_OpXor64(v *Value) bool {
  2464  	v_1 := v.Args[1]
  2465  	v_0 := v.Args[0]
  2466  	b := v.Block
  2467  	typ := &b.Func.Config.Types
  2468  	// match: (Xor64 x y)
  2469  	// result: (Int64Make (Xor32 <typ.UInt32> (Int64Hi x) (Int64Hi y)) (Xor32 <typ.UInt32> (Int64Lo x) (Int64Lo y)))
  2470  	for {
  2471  		x := v_0
  2472  		y := v_1
  2473  		v.reset(OpInt64Make)
  2474  		v0 := b.NewValue0(v.Pos, OpXor32, typ.UInt32)
  2475  		v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2476  		v1.AddArg(x)
  2477  		v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32)
  2478  		v2.AddArg(y)
  2479  		v0.AddArg2(v1, v2)
  2480  		v3 := b.NewValue0(v.Pos, OpXor32, typ.UInt32)
  2481  		v4 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2482  		v4.AddArg(x)
  2483  		v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32)
  2484  		v5.AddArg(y)
  2485  		v3.AddArg2(v4, v5)
  2486  		v.AddArg2(v0, v3)
  2487  		return true
  2488  	}
  2489  }
  2490  func rewriteValuedec64_OpZeroExt16to64(v *Value) bool {
  2491  	v_0 := v.Args[0]
  2492  	b := v.Block
  2493  	typ := &b.Func.Config.Types
  2494  	// match: (ZeroExt16to64 x)
  2495  	// result: (ZeroExt32to64 (ZeroExt16to32 x))
  2496  	for {
  2497  		x := v_0
  2498  		v.reset(OpZeroExt32to64)
  2499  		v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
  2500  		v0.AddArg(x)
  2501  		v.AddArg(v0)
  2502  		return true
  2503  	}
  2504  }
  2505  func rewriteValuedec64_OpZeroExt32to64(v *Value) bool {
  2506  	v_0 := v.Args[0]
  2507  	b := v.Block
  2508  	typ := &b.Func.Config.Types
  2509  	// match: (ZeroExt32to64 x)
  2510  	// result: (Int64Make (Const32 <typ.UInt32> [0]) x)
  2511  	for {
  2512  		x := v_0
  2513  		v.reset(OpInt64Make)
  2514  		v0 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  2515  		v0.AuxInt = int32ToAuxInt(0)
  2516  		v.AddArg2(v0, x)
  2517  		return true
  2518  	}
  2519  }
  2520  func rewriteValuedec64_OpZeroExt8to64(v *Value) bool {
  2521  	v_0 := v.Args[0]
  2522  	b := v.Block
  2523  	typ := &b.Func.Config.Types
  2524  	// match: (ZeroExt8to64 x)
  2525  	// result: (ZeroExt32to64 (ZeroExt8to32 x))
  2526  	for {
  2527  		x := v_0
  2528  		v.reset(OpZeroExt32to64)
  2529  		v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
  2530  		v0.AddArg(x)
  2531  		v.AddArg(v0)
  2532  		return true
  2533  	}
  2534  }
  2535  func rewriteBlockdec64(b *Block) bool {
  2536  	return false
  2537  }
  2538  

View as plain text