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

Documentation: cmd/compile/internal/ssa

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

View as plain text