src/cmd/compile/internal/ssa/rewritePPC64latelower.go

   1 // Code generated from _gen/PPC64latelower.rules using 'go generate'; DO NOT EDIT.
   2
   3 package ssa
   4
   5 import "internal/buildcfg"
   6 import "cmd/compile/internal/types"
   7
   8 func rewriteValuePPC64latelower(v *Value) bool {
   9         switch v.Op {
  10         case OpPPC64AND:
  11                 return rewriteValuePPC64latelower_OpPPC64AND(v)
  12         case OpPPC64ISEL:
  13                 return rewriteValuePPC64latelower_OpPPC64ISEL(v)
  14         case OpPPC64RLDICL:
  15                 return rewriteValuePPC64latelower_OpPPC64RLDICL(v)
  16         case OpPPC64SETBC:
  17                 return rewriteValuePPC64latelower_OpPPC64SETBC(v)
  18         case OpPPC64SETBCR:
  19                 return rewriteValuePPC64latelower_OpPPC64SETBCR(v)
  20         }
  21         return false
  22 }
  23 func rewriteValuePPC64latelower_OpPPC64AND(v *Value) bool {
  24         v_1 := v.Args[1]
  25         v_0 := v.Args[0]
  26         b := v.Block
  27         typ := &b.Func.Config.Types
  28         // match: (AND <t> x:(MOVDconst [m]) n)
  29         // cond: t.Size() <= 2
  30         // result: (Select0 (ANDCCconst [int64(int16(m))] n))
  31         for {
  32                 t := v.Type
  33                 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  34                         x := v_0
  35                         if x.Op != OpPPC64MOVDconst {
  36                                 continue
  37                         }
  38                         m := auxIntToInt64(x.AuxInt)
  39                         n := v_1
  40                         if !(t.Size() <= 2) {
  41                                 continue
  42                         }
  43                         v.reset(OpSelect0)
  44                         v0 := b.NewValue0(v.Pos, OpPPC64ANDCCconst, types.NewTuple(typ.Int, types.TypeFlags))
  45                         v0.AuxInt = int64ToAuxInt(int64(int16(m)))
  46                         v0.AddArg(n)
  47                         v.AddArg(v0)
  48                         return true
  49                 }
  50                 break
  51         }
  52         // match: (AND x:(MOVDconst [m]) n)
  53         // cond: isPPC64ValidShiftMask(m)
  54         // result: (RLDICL [encodePPC64RotateMask(0,m,64)] n)
  55         for {
  56                 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  57                         x := v_0
  58                         if x.Op != OpPPC64MOVDconst {
  59                                 continue
  60                         }
  61                         m := auxIntToInt64(x.AuxInt)
  62                         n := v_1
  63                         if !(isPPC64ValidShiftMask(m)) {
  64                                 continue
  65                         }
  66                         v.reset(OpPPC64RLDICL)
  67                         v.AuxInt = int64ToAuxInt(encodePPC64RotateMask(0, m, 64))
  68                         v.AddArg(n)
  69                         return true
  70                 }
  71                 break
  72         }
  73         // match: (AND x:(MOVDconst [m]) n)
  74         // cond: m != 0 && isPPC64ValidShiftMask(^m)
  75         // result: (RLDICR [encodePPC64RotateMask(0,m,64)] n)
  76         for {
  77                 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  78                         x := v_0
  79                         if x.Op != OpPPC64MOVDconst {
  80                                 continue
  81                         }
  82                         m := auxIntToInt64(x.AuxInt)
  83                         n := v_1
  84                         if !(m != 0 && isPPC64ValidShiftMask(^m)) {
  85                                 continue
  86                         }
  87                         v.reset(OpPPC64RLDICR)
  88                         v.AuxInt = int64ToAuxInt(encodePPC64RotateMask(0, m, 64))
  89                         v.AddArg(n)
  90                         return true
  91                 }
  92                 break
  93         }
  94         // match: (AND <t> x:(MOVDconst [m]) n)
  95         // cond: t.Size() == 4 && isPPC64WordRotateMask(m)
  96         // result: (RLWINM [encodePPC64RotateMask(0,m,32)] n)
  97         for {
  98                 t := v.Type
  99                 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 100                         x := v_0
 101                         if x.Op != OpPPC64MOVDconst {
 102                                 continue
 103                         }
 104                         m := auxIntToInt64(x.AuxInt)
 105                         n := v_1
 106                         if !(t.Size() == 4 && isPPC64WordRotateMask(m)) {
 107                                 continue
 108                         }
 109                         v.reset(OpPPC64RLWINM)
 110                         v.AuxInt = int64ToAuxInt(encodePPC64RotateMask(0, m, 32))
 111                         v.AddArg(n)
 112                         return true
 113                 }
 114                 break
 115         }
 116         return false
 117 }
 118 func rewriteValuePPC64latelower_OpPPC64ISEL(v *Value) bool {
 119         v_2 := v.Args[2]
 120         v_1 := v.Args[1]
 121         v_0 := v.Args[0]
 122         // match: (ISEL [a] x (MOVDconst [0]) z)
 123         // result: (ISELZ [a] x z)
 124         for {
 125                 a := auxIntToInt32(v.AuxInt)
 126                 x := v_0
 127                 if v_1.Op != OpPPC64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
 128                         break
 129                 }
 130                 z := v_2
 131                 v.reset(OpPPC64ISELZ)
 132                 v.AuxInt = int32ToAuxInt(a)
 133                 v.AddArg2(x, z)
 134                 return true
 135         }
 136         // match: (ISEL [a] (MOVDconst [0]) y z)
 137         // result: (ISELZ [a^0x4] y z)
 138         for {
 139                 a := auxIntToInt32(v.AuxInt)
 140                 if v_0.Op != OpPPC64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
 141                         break
 142                 }
 143                 y := v_1
 144                 z := v_2
 145                 v.reset(OpPPC64ISELZ)
 146                 v.AuxInt = int32ToAuxInt(a ^ 0x4)
 147                 v.AddArg2(y, z)
 148                 return true
 149         }
 150         return false
 151 }
 152 func rewriteValuePPC64latelower_OpPPC64RLDICL(v *Value) bool {
 153         v_0 := v.Args[0]
 154         // match: (RLDICL [em] x:(SRDconst [s] a))
 155         // cond: (em&0xFF0000)==0
 156         // result: (RLDICL [mergePPC64RLDICLandSRDconst(em, s)] a)
 157         for {
 158                 em := auxIntToInt64(v.AuxInt)
 159                 x := v_0
 160                 if x.Op != OpPPC64SRDconst {
 161                         break
 162                 }
 163                 s := auxIntToInt64(x.AuxInt)
 164                 a := x.Args[0]
 165                 if !((em & 0xFF0000) == 0) {
 166                         break
 167                 }
 168                 v.reset(OpPPC64RLDICL)
 169                 v.AuxInt = int64ToAuxInt(mergePPC64RLDICLandSRDconst(em, s))
 170                 v.AddArg(a)
 171                 return true
 172         }
 173         return false
 174 }
 175 func rewriteValuePPC64latelower_OpPPC64SETBC(v *Value) bool {
 176         v_0 := v.Args[0]
 177         b := v.Block
 178         typ := &b.Func.Config.Types
 179         // match: (SETBC [2] cmp)
 180         // cond: buildcfg.GOPPC64 <= 9
 181         // result: (ISELZ [2] (MOVDconst [1]) cmp)
 182         for {
 183                 if auxIntToInt32(v.AuxInt) != 2 {
 184                         break
 185                 }
 186                 cmp := v_0
 187                 if !(buildcfg.GOPPC64 <= 9) {
 188                         break
 189                 }
 190                 v.reset(OpPPC64ISELZ)
 191                 v.AuxInt = int32ToAuxInt(2)
 192                 v0 := b.NewValue0(v.Pos, OpPPC64MOVDconst, typ.Int64)
 193                 v0.AuxInt = int64ToAuxInt(1)
 194                 v.AddArg2(v0, cmp)
 195                 return true
 196         }
 197         // match: (SETBC [0] cmp)
 198         // cond: buildcfg.GOPPC64 <= 9
 199         // result: (ISELZ [0] (MOVDconst [1]) cmp)
 200         for {
 201                 if auxIntToInt32(v.AuxInt) != 0 {
 202                         break
 203                 }
 204                 cmp := v_0
 205                 if !(buildcfg.GOPPC64 <= 9) {
 206                         break
 207                 }
 208                 v.reset(OpPPC64ISELZ)
 209                 v.AuxInt = int32ToAuxInt(0)
 210                 v0 := b.NewValue0(v.Pos, OpPPC64MOVDconst, typ.Int64)
 211                 v0.AuxInt = int64ToAuxInt(1)
 212                 v.AddArg2(v0, cmp)
 213                 return true
 214         }
 215         // match: (SETBC [1] cmp)
 216         // cond: buildcfg.GOPPC64 <= 9
 217         // result: (ISELZ [1] (MOVDconst [1]) cmp)
 218         for {
 219                 if auxIntToInt32(v.AuxInt) != 1 {
 220                         break
 221                 }
 222                 cmp := v_0
 223                 if !(buildcfg.GOPPC64 <= 9) {
 224                         break
 225                 }
 226                 v.reset(OpPPC64ISELZ)
 227                 v.AuxInt = int32ToAuxInt(1)
 228                 v0 := b.NewValue0(v.Pos, OpPPC64MOVDconst, typ.Int64)
 229                 v0.AuxInt = int64ToAuxInt(1)
 230                 v.AddArg2(v0, cmp)
 231                 return true
 232         }
 233         return false
 234 }
 235 func rewriteValuePPC64latelower_OpPPC64SETBCR(v *Value) bool {
 236         v_0 := v.Args[0]
 237         b := v.Block
 238         typ := &b.Func.Config.Types
 239         // match: (SETBCR [2] cmp)
 240         // cond: buildcfg.GOPPC64 <= 9
 241         // result: (ISELZ [6] (MOVDconst [1]) cmp)
 242         for {
 243                 if auxIntToInt32(v.AuxInt) != 2 {
 244                         break
 245                 }
 246                 cmp := v_0
 247                 if !(buildcfg.GOPPC64 <= 9) {
 248                         break
 249                 }
 250                 v.reset(OpPPC64ISELZ)
 251                 v.AuxInt = int32ToAuxInt(6)
 252                 v0 := b.NewValue0(v.Pos, OpPPC64MOVDconst, typ.Int64)
 253                 v0.AuxInt = int64ToAuxInt(1)
 254                 v.AddArg2(v0, cmp)
 255                 return true
 256         }
 257         // match: (SETBCR [0] cmp)
 258         // cond: buildcfg.GOPPC64 <= 9
 259         // result: (ISELZ [4] (MOVDconst [1]) cmp)
 260         for {
 261                 if auxIntToInt32(v.AuxInt) != 0 {
 262                         break
 263                 }
 264                 cmp := v_0
 265                 if !(buildcfg.GOPPC64 <= 9) {
 266                         break
 267                 }
 268                 v.reset(OpPPC64ISELZ)
 269                 v.AuxInt = int32ToAuxInt(4)
 270                 v0 := b.NewValue0(v.Pos, OpPPC64MOVDconst, typ.Int64)
 271                 v0.AuxInt = int64ToAuxInt(1)
 272                 v.AddArg2(v0, cmp)
 273                 return true
 274         }
 275         // match: (SETBCR [1] cmp)
 276         // cond: buildcfg.GOPPC64 <= 9
 277         // result: (ISELZ [5] (MOVDconst [1]) cmp)
 278         for {
 279                 if auxIntToInt32(v.AuxInt) != 1 {
 280                         break
 281                 }
 282                 cmp := v_0
 283                 if !(buildcfg.GOPPC64 <= 9) {
 284                         break
 285                 }
 286                 v.reset(OpPPC64ISELZ)
 287                 v.AuxInt = int32ToAuxInt(5)
 288                 v0 := b.NewValue0(v.Pos, OpPPC64MOVDconst, typ.Int64)
 289                 v0.AuxInt = int64ToAuxInt(1)
 290                 v.AddArg2(v0, cmp)
 291                 return true
 292         }
 293         return false
 294 }
 295 func rewriteBlockPPC64latelower(b *Block) bool {
 296         return false
 297 }