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

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

View as plain text