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