...
Run Format

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

View as plain text