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

   1 // Copyright 2016 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package arm
   6
   7 import (
   8         "fmt"
   9         "internal/buildcfg"
  10         "math"
  11         "math/bits"
  12
  13         "cmd/compile/internal/base"
  14         "cmd/compile/internal/ir"
  15         "cmd/compile/internal/logopt"
  16         "cmd/compile/internal/ssa"
  17         "cmd/compile/internal/ssagen"
  18         "cmd/compile/internal/types"
  19         "cmd/internal/obj"
  20         "cmd/internal/obj/arm"
  21 )
  22
  23 // loadByType returns the load instruction of the given type.
  24 func loadByType(t *types.Type) obj.As {
  25         if t.IsFloat() {
  26                 switch t.Size() {
  27                 case 4:
  28                         return arm.AMOVF
  29                 case 8:
  30                         return arm.AMOVD
  31                 }
  32         } else {
  33                 switch t.Size() {
  34                 case 1:
  35                         if t.IsSigned() {
  36                                 return arm.AMOVB
  37                         } else {
  38                                 return arm.AMOVBU
  39                         }
  40                 case 2:
  41                         if t.IsSigned() {
  42                                 return arm.AMOVH
  43                         } else {
  44                                 return arm.AMOVHU
  45                         }
  46                 case 4:
  47                         return arm.AMOVW
  48                 }
  49         }
  50         panic("bad load type")
  51 }
  52
  53 // storeByType returns the store instruction of the given type.
  54 func storeByType(t *types.Type) obj.As {
  55         if t.IsFloat() {
  56                 switch t.Size() {
  57                 case 4:
  58                         return arm.AMOVF
  59                 case 8:
  60                         return arm.AMOVD
  61                 }
  62         } else {
  63                 switch t.Size() {
  64                 case 1:
  65                         return arm.AMOVB
  66                 case 2:
  67                         return arm.AMOVH
  68                 case 4:
  69                         return arm.AMOVW
  70                 }
  71         }
  72         panic("bad store type")
  73 }
  74
  75 // shift type is used as Offset in obj.TYPE_SHIFT operands to encode shifted register operands
  76 type shift int64
  77
  78 // copied from ../../../internal/obj/util.go:/TYPE_SHIFT
  79 func (v shift) String() string {
  80         op := "<<>>->@>"[((v>>5)&3)<<1:]
  81         if v&(1<<4) != 0 {
  82                 // register shift
  83                 return fmt.Sprintf("R%d%c%cR%d", v&15, op[0], op[1], (v>>8)&15)
  84         } else {
  85                 // constant shift
  86                 return fmt.Sprintf("R%d%c%c%d", v&15, op[0], op[1], (v>>7)&31)
  87         }
  88 }
  89
  90 // makeshift encodes a register shifted by a constant
  91 func makeshift(reg int16, typ int64, s int64) shift {
  92         return shift(int64(reg&0xf) | typ | (s&31)<<7)
  93 }
  94
  95 // genshift generates a Prog for r = r0 op (r1 shifted by n)
  96 func genshift(s *ssagen.State, as obj.As, r0, r1, r int16, typ int64, n int64) *obj.Prog {
  97         p := s.Prog(as)
  98         p.From.Type = obj.TYPE_SHIFT
  99         p.From.Offset = int64(makeshift(r1, typ, n))
 100         p.Reg = r0
 101         if r != 0 {
 102                 p.To.Type = obj.TYPE_REG
 103                 p.To.Reg = r
 104         }
 105         return p
 106 }
 107
 108 // makeregshift encodes a register shifted by a register
 109 func makeregshift(r1 int16, typ int64, r2 int16) shift {
 110         return shift(int64(r1&0xf) | typ | int64(r2&0xf)<<8 | 1<<4)
 111 }
 112
 113 // genregshift generates a Prog for r = r0 op (r1 shifted by r2)
 114 func genregshift(s *ssagen.State, as obj.As, r0, r1, r2, r int16, typ int64) *obj.Prog {
 115         p := s.Prog(as)
 116         p.From.Type = obj.TYPE_SHIFT
 117         p.From.Offset = int64(makeregshift(r1, typ, r2))
 118         p.Reg = r0
 119         if r != 0 {
 120                 p.To.Type = obj.TYPE_REG
 121                 p.To.Reg = r
 122         }
 123         return p
 124 }
 125
 126 // find a (lsb, width) pair for BFC
 127 // lsb must be in [0, 31], width must be in [1, 32 - lsb]
 128 // return (0xffffffff, 0) if v is not a binary like 0...01...10...0
 129 func getBFC(v uint32) (uint32, uint32) {
 130         var m, l uint32
 131         // BFC is not applicable with zero
 132         if v == 0 {
 133                 return 0xffffffff, 0
 134         }
 135         // find the lowest set bit, for example l=2 for 0x3ffffffc
 136         l = uint32(bits.TrailingZeros32(v))
 137         // m-1 represents the highest set bit index, for example m=30 for 0x3ffffffc
 138         m = 32 - uint32(bits.LeadingZeros32(v))
 139         // check if v is a binary like 0...01...10...0
 140         if (1<<m)-(1<<l) == v {
 141                 // it must be m > l for non-zero v
 142                 return l, m - l
 143         }
 144         // invalid
 145         return 0xffffffff, 0
 146 }
 147
 148 func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 149         switch v.Op {
 150         case ssa.OpCopy, ssa.OpARMMOVWreg:
 151                 if v.Type.IsMemory() {
 152                         return
 153                 }
 154                 x := v.Args[0].Reg()
 155                 y := v.Reg()
 156                 if x == y {
 157                         return
 158                 }
 159                 as := arm.AMOVW
 160                 if v.Type.IsFloat() {
 161                         switch v.Type.Size() {
 162                         case 4:
 163                                 as = arm.AMOVF
 164                         case 8:
 165                                 as = arm.AMOVD
 166                         default:
 167                                 panic("bad float size")
 168                         }
 169                 }
 170                 p := s.Prog(as)
 171                 p.From.Type = obj.TYPE_REG
 172                 p.From.Reg = x
 173                 p.To.Type = obj.TYPE_REG
 174                 p.To.Reg = y
 175         case ssa.OpARMMOVWnop:
 176                 // nothing to do
 177         case ssa.OpLoadReg:
 178                 if v.Type.IsFlags() {
 179                         v.Fatalf("load flags not implemented: %v", v.LongString())
 180                         return
 181                 }
 182                 p := s.Prog(loadByType(v.Type))
 183                 ssagen.AddrAuto(&p.From, v.Args[0])
 184                 p.To.Type = obj.TYPE_REG
 185                 p.To.Reg = v.Reg()
 186         case ssa.OpStoreReg:
 187                 if v.Type.IsFlags() {
 188                         v.Fatalf("store flags not implemented: %v", v.LongString())
 189                         return
 190                 }
 191                 p := s.Prog(storeByType(v.Type))
 192                 p.From.Type = obj.TYPE_REG
 193                 p.From.Reg = v.Args[0].Reg()
 194                 ssagen.AddrAuto(&p.To, v)
 195         case ssa.OpARMADD,
 196                 ssa.OpARMADC,
 197                 ssa.OpARMSUB,
 198                 ssa.OpARMSBC,
 199                 ssa.OpARMRSB,
 200                 ssa.OpARMAND,
 201                 ssa.OpARMOR,
 202                 ssa.OpARMXOR,
 203                 ssa.OpARMBIC,
 204                 ssa.OpARMMUL,
 205                 ssa.OpARMADDF,
 206                 ssa.OpARMADDD,
 207                 ssa.OpARMSUBF,
 208                 ssa.OpARMSUBD,
 209                 ssa.OpARMSLL,
 210                 ssa.OpARMSRL,
 211                 ssa.OpARMSRA,
 212                 ssa.OpARMMULF,
 213                 ssa.OpARMMULD,
 214                 ssa.OpARMNMULF,
 215                 ssa.OpARMNMULD,
 216                 ssa.OpARMDIVF,
 217                 ssa.OpARMDIVD:
 218                 r := v.Reg()
 219                 r1 := v.Args[0].Reg()
 220                 r2 := v.Args[1].Reg()
 221                 p := s.Prog(v.Op.Asm())
 222                 p.From.Type = obj.TYPE_REG
 223                 p.From.Reg = r2
 224                 p.Reg = r1
 225                 p.To.Type = obj.TYPE_REG
 226                 p.To.Reg = r
 227         case ssa.OpARMSRR:
 228                 genregshift(s, arm.AMOVW, 0, v.Args[0].Reg(), v.Args[1].Reg(), v.Reg(), arm.SHIFT_RR)
 229         case ssa.OpARMMULAF, ssa.OpARMMULAD, ssa.OpARMMULSF, ssa.OpARMMULSD, ssa.OpARMFMULAD:
 230                 r := v.Reg()
 231                 r0 := v.Args[0].Reg()
 232                 r1 := v.Args[1].Reg()
 233                 r2 := v.Args[2].Reg()
 234                 if r != r0 {
 235                         v.Fatalf("result and addend are not in the same register: %v", v.LongString())
 236                 }
 237                 p := s.Prog(v.Op.Asm())
 238                 p.From.Type = obj.TYPE_REG
 239                 p.From.Reg = r2
 240                 p.Reg = r1
 241                 p.To.Type = obj.TYPE_REG
 242                 p.To.Reg = r
 243         case ssa.OpARMADDS,
 244                 ssa.OpARMSUBS:
 245                 r := v.Reg0()
 246                 r1 := v.Args[0].Reg()
 247                 r2 := v.Args[1].Reg()
 248                 p := s.Prog(v.Op.Asm())
 249                 p.Scond = arm.C_SBIT
 250                 p.From.Type = obj.TYPE_REG
 251                 p.From.Reg = r2
 252                 p.Reg = r1
 253                 p.To.Type = obj.TYPE_REG
 254                 p.To.Reg = r
 255         case ssa.OpARMSRAcond:
 256                 // ARM shift instructions uses only the low-order byte of the shift amount
 257                 // generate conditional instructions to deal with large shifts
 258                 // flag is already set
 259                 // SRA.HS       $31, Rarg0, Rdst // shift 31 bits to get the sign bit
 260                 // SRA.LO       Rarg1, Rarg0, Rdst
 261                 r := v.Reg()
 262                 r1 := v.Args[0].Reg()
 263                 r2 := v.Args[1].Reg()
 264                 p := s.Prog(arm.ASRA)
 265                 p.Scond = arm.C_SCOND_HS
 266                 p.From.Type = obj.TYPE_CONST
 267                 p.From.Offset = 31
 268                 p.Reg = r1
 269                 p.To.Type = obj.TYPE_REG
 270                 p.To.Reg = r
 271                 p = s.Prog(arm.ASRA)
 272                 p.Scond = arm.C_SCOND_LO
 273                 p.From.Type = obj.TYPE_REG
 274                 p.From.Reg = r2
 275                 p.Reg = r1
 276                 p.To.Type = obj.TYPE_REG
 277                 p.To.Reg = r
 278         case ssa.OpARMBFX, ssa.OpARMBFXU:
 279                 p := s.Prog(v.Op.Asm())
 280                 p.From.Type = obj.TYPE_CONST
 281                 p.From.Offset = v.AuxInt >> 8
 282                 p.SetFrom3Const(v.AuxInt & 0xff)
 283                 p.Reg = v.Args[0].Reg()
 284                 p.To.Type = obj.TYPE_REG
 285                 p.To.Reg = v.Reg()
 286         case ssa.OpARMANDconst, ssa.OpARMBICconst:
 287                 // try to optimize ANDconst and BICconst to BFC, which saves bytes and ticks
 288                 // BFC is only available on ARMv7, and its result and source are in the same register
 289                 if buildcfg.GOARM == 7 && v.Reg() == v.Args[0].Reg() {
 290                         var val uint32
 291                         if v.Op == ssa.OpARMANDconst {
 292                                 val = ^uint32(v.AuxInt)
 293                         } else { // BICconst
 294                                 val = uint32(v.AuxInt)
 295                         }
 296                         lsb, width := getBFC(val)
 297                         // omit BFC for ARM's imm12
 298                         if 8 < width && width < 24 {
 299                                 p := s.Prog(arm.ABFC)
 300                                 p.From.Type = obj.TYPE_CONST
 301                                 p.From.Offset = int64(width)
 302                                 p.SetFrom3Const(int64(lsb))
 303                                 p.To.Type = obj.TYPE_REG
 304                                 p.To.Reg = v.Reg()
 305                                 break
 306                         }
 307                 }
 308                 // fall back to ordinary form
 309                 fallthrough
 310         case ssa.OpARMADDconst,
 311                 ssa.OpARMADCconst,
 312                 ssa.OpARMSUBconst,
 313                 ssa.OpARMSBCconst,
 314                 ssa.OpARMRSBconst,
 315                 ssa.OpARMRSCconst,
 316                 ssa.OpARMORconst,
 317                 ssa.OpARMXORconst,
 318                 ssa.OpARMSLLconst,
 319                 ssa.OpARMSRLconst,
 320                 ssa.OpARMSRAconst:
 321                 p := s.Prog(v.Op.Asm())
 322                 p.From.Type = obj.TYPE_CONST
 323                 p.From.Offset = v.AuxInt
 324                 p.Reg = v.Args[0].Reg()
 325                 p.To.Type = obj.TYPE_REG
 326                 p.To.Reg = v.Reg()
 327         case ssa.OpARMADDSconst,
 328                 ssa.OpARMSUBSconst,
 329                 ssa.OpARMRSBSconst:
 330                 p := s.Prog(v.Op.Asm())
 331                 p.Scond = arm.C_SBIT
 332                 p.From.Type = obj.TYPE_CONST
 333                 p.From.Offset = v.AuxInt
 334                 p.Reg = v.Args[0].Reg()
 335                 p.To.Type = obj.TYPE_REG
 336                 p.To.Reg = v.Reg0()
 337         case ssa.OpARMSRRconst:
 338                 genshift(s, arm.AMOVW, 0, v.Args[0].Reg(), v.Reg(), arm.SHIFT_RR, v.AuxInt)
 339         case ssa.OpARMADDshiftLL,
 340                 ssa.OpARMADCshiftLL,
 341                 ssa.OpARMSUBshiftLL,
 342                 ssa.OpARMSBCshiftLL,
 343                 ssa.OpARMRSBshiftLL,
 344                 ssa.OpARMRSCshiftLL,
 345                 ssa.OpARMANDshiftLL,
 346                 ssa.OpARMORshiftLL,
 347                 ssa.OpARMXORshiftLL,
 348                 ssa.OpARMBICshiftLL:
 349                 genshift(s, v.Op.Asm(), v.Args[0].Reg(), v.Args[1].Reg(), v.Reg(), arm.SHIFT_LL, v.AuxInt)
 350         case ssa.OpARMADDSshiftLL,
 351                 ssa.OpARMSUBSshiftLL,
 352                 ssa.OpARMRSBSshiftLL:
 353                 p := genshift(s, v.Op.Asm(), v.Args[0].Reg(), v.Args[1].Reg(), v.Reg0(), arm.SHIFT_LL, v.AuxInt)
 354                 p.Scond = arm.C_SBIT
 355         case ssa.OpARMADDshiftRL,
 356                 ssa.OpARMADCshiftRL,
 357                 ssa.OpARMSUBshiftRL,
 358                 ssa.OpARMSBCshiftRL,
 359                 ssa.OpARMRSBshiftRL,
 360                 ssa.OpARMRSCshiftRL,
 361                 ssa.OpARMANDshiftRL,
 362                 ssa.OpARMORshiftRL,
 363                 ssa.OpARMXORshiftRL,
 364                 ssa.OpARMBICshiftRL:
 365                 genshift(s, v.Op.Asm(), v.Args[0].Reg(), v.Args[1].Reg(), v.Reg(), arm.SHIFT_LR, v.AuxInt)
 366         case ssa.OpARMADDSshiftRL,
 367                 ssa.OpARMSUBSshiftRL,
 368                 ssa.OpARMRSBSshiftRL:
 369                 p := genshift(s, v.Op.Asm(), v.Args[0].Reg(), v.Args[1].Reg(), v.Reg0(), arm.SHIFT_LR, v.AuxInt)
 370                 p.Scond = arm.C_SBIT
 371         case ssa.OpARMADDshiftRA,
 372                 ssa.OpARMADCshiftRA,
 373                 ssa.OpARMSUBshiftRA,
 374                 ssa.OpARMSBCshiftRA,
 375                 ssa.OpARMRSBshiftRA,
 376                 ssa.OpARMRSCshiftRA,
 377                 ssa.OpARMANDshiftRA,
 378                 ssa.OpARMORshiftRA,
 379                 ssa.OpARMXORshiftRA,
 380                 ssa.OpARMBICshiftRA:
 381                 genshift(s, v.Op.Asm(), v.Args[0].Reg(), v.Args[1].Reg(), v.Reg(), arm.SHIFT_AR, v.AuxInt)
 382         case ssa.OpARMADDSshiftRA,
 383                 ssa.OpARMSUBSshiftRA,
 384                 ssa.OpARMRSBSshiftRA:
 385                 p := genshift(s, v.Op.Asm(), v.Args[0].Reg(), v.Args[1].Reg(), v.Reg0(), arm.SHIFT_AR, v.AuxInt)
 386                 p.Scond = arm.C_SBIT
 387         case ssa.OpARMXORshiftRR:
 388                 genshift(s, v.Op.Asm(), v.Args[0].Reg(), v.Args[1].Reg(), v.Reg(), arm.SHIFT_RR, v.AuxInt)
 389         case ssa.OpARMMVNshiftLL:
 390                 genshift(s, v.Op.Asm(), 0, v.Args[0].Reg(), v.Reg(), arm.SHIFT_LL, v.AuxInt)
 391         case ssa.OpARMMVNshiftRL:
 392                 genshift(s, v.Op.Asm(), 0, v.Args[0].Reg(), v.Reg(), arm.SHIFT_LR, v.AuxInt)
 393         case ssa.OpARMMVNshiftRA:
 394                 genshift(s, v.Op.Asm(), 0, v.Args[0].Reg(), v.Reg(), arm.SHIFT_AR, v.AuxInt)
 395         case ssa.OpARMMVNshiftLLreg:
 396                 genregshift(s, v.Op.Asm(), 0, v.Args[0].Reg(), v.Args[1].Reg(), v.Reg(), arm.SHIFT_LL)
 397         case ssa.OpARMMVNshiftRLreg:
 398                 genregshift(s, v.Op.Asm(), 0, v.Args[0].Reg(), v.Args[1].Reg(), v.Reg(), arm.SHIFT_LR)
 399         case ssa.OpARMMVNshiftRAreg:
 400                 genregshift(s, v.Op.Asm(), 0, v.Args[0].Reg(), v.Args[1].Reg(), v.Reg(), arm.SHIFT_AR)
 401         case ssa.OpARMADDshiftLLreg,
 402                 ssa.OpARMADCshiftLLreg,
 403                 ssa.OpARMSUBshiftLLreg,
 404                 ssa.OpARMSBCshiftLLreg,
 405                 ssa.OpARMRSBshiftLLreg,
 406                 ssa.OpARMRSCshiftLLreg,
 407                 ssa.OpARMANDshiftLLreg,
 408                 ssa.OpARMORshiftLLreg,
 409                 ssa.OpARMXORshiftLLreg,
 410                 ssa.OpARMBICshiftLLreg:
 411                 genregshift(s, v.Op.Asm(), v.Args[0].Reg(), v.Args[1].Reg(), v.Args[2].Reg(), v.Reg(), arm.SHIFT_LL)
 412         case ssa.OpARMADDSshiftLLreg,
 413                 ssa.OpARMSUBSshiftLLreg,
 414                 ssa.OpARMRSBSshiftLLreg:
 415                 p := genregshift(s, v.Op.Asm(), v.Args[0].Reg(), v.Args[1].Reg(), v.Args[2].Reg(), v.Reg0(), arm.SHIFT_LL)
 416                 p.Scond = arm.C_SBIT
 417         case ssa.OpARMADDshiftRLreg,
 418                 ssa.OpARMADCshiftRLreg,
 419                 ssa.OpARMSUBshiftRLreg,
 420                 ssa.OpARMSBCshiftRLreg,
 421                 ssa.OpARMRSBshiftRLreg,
 422                 ssa.OpARMRSCshiftRLreg,
 423                 ssa.OpARMANDshiftRLreg,
 424                 ssa.OpARMORshiftRLreg,
 425                 ssa.OpARMXORshiftRLreg,
 426                 ssa.OpARMBICshiftRLreg:
 427                 genregshift(s, v.Op.Asm(), v.Args[0].Reg(), v.Args[1].Reg(), v.Args[2].Reg(), v.Reg(), arm.SHIFT_LR)
 428         case ssa.OpARMADDSshiftRLreg,
 429                 ssa.OpARMSUBSshiftRLreg,
 430                 ssa.OpARMRSBSshiftRLreg:
 431                 p := genregshift(s, v.Op.Asm(), v.Args[0].Reg(), v.Args[1].Reg(), v.Args[2].Reg(), v.Reg0(), arm.SHIFT_LR)
 432                 p.Scond = arm.C_SBIT
 433         case ssa.OpARMADDshiftRAreg,
 434                 ssa.OpARMADCshiftRAreg,
 435                 ssa.OpARMSUBshiftRAreg,
 436                 ssa.OpARMSBCshiftRAreg,
 437                 ssa.OpARMRSBshiftRAreg,
 438                 ssa.OpARMRSCshiftRAreg,
 439                 ssa.OpARMANDshiftRAreg,
 440                 ssa.OpARMORshiftRAreg,
 441                 ssa.OpARMXORshiftRAreg,
 442                 ssa.OpARMBICshiftRAreg:
 443                 genregshift(s, v.Op.Asm(), v.Args[0].Reg(), v.Args[1].Reg(), v.Args[2].Reg(), v.Reg(), arm.SHIFT_AR)
 444         case ssa.OpARMADDSshiftRAreg,
 445                 ssa.OpARMSUBSshiftRAreg,
 446                 ssa.OpARMRSBSshiftRAreg:
 447                 p := genregshift(s, v.Op.Asm(), v.Args[0].Reg(), v.Args[1].Reg(), v.Args[2].Reg(), v.Reg0(), arm.SHIFT_AR)
 448                 p.Scond = arm.C_SBIT
 449         case ssa.OpARMHMUL,
 450                 ssa.OpARMHMULU:
 451                 // 32-bit high multiplication
 452                 p := s.Prog(v.Op.Asm())
 453                 p.From.Type = obj.TYPE_REG
 454                 p.From.Reg = v.Args[0].Reg()
 455                 p.Reg = v.Args[1].Reg()
 456                 p.To.Type = obj.TYPE_REGREG
 457                 p.To.Reg = v.Reg()
 458                 p.To.Offset = arm.REGTMP // throw away low 32-bit into tmp register
 459         case ssa.OpARMMULLU:
 460                 // 32-bit multiplication, results 64-bit, high 32-bit in out0, low 32-bit in out1
 461                 p := s.Prog(v.Op.Asm())
 462                 p.From.Type = obj.TYPE_REG
 463                 p.From.Reg = v.Args[0].Reg()
 464                 p.Reg = v.Args[1].Reg()
 465                 p.To.Type = obj.TYPE_REGREG
 466                 p.To.Reg = v.Reg0()           // high 32-bit
 467                 p.To.Offset = int64(v.Reg1()) // low 32-bit
 468         case ssa.OpARMMULA, ssa.OpARMMULS:
 469                 p := s.Prog(v.Op.Asm())
 470                 p.From.Type = obj.TYPE_REG
 471                 p.From.Reg = v.Args[0].Reg()
 472                 p.Reg = v.Args[1].Reg()
 473                 p.To.Type = obj.TYPE_REGREG2
 474                 p.To.Reg = v.Reg()                   // result
 475                 p.To.Offset = int64(v.Args[2].Reg()) // addend
 476         case ssa.OpARMMOVWconst:
 477                 p := s.Prog(v.Op.Asm())
 478                 p.From.Type = obj.TYPE_CONST
 479                 p.From.Offset = v.AuxInt
 480                 p.To.Type = obj.TYPE_REG
 481                 p.To.Reg = v.Reg()
 482         case ssa.OpARMMOVFconst,
 483                 ssa.OpARMMOVDconst:
 484                 p := s.Prog(v.Op.Asm())
 485                 p.From.Type = obj.TYPE_FCONST
 486                 p.From.Val = math.Float64frombits(uint64(v.AuxInt))
 487                 p.To.Type = obj.TYPE_REG
 488                 p.To.Reg = v.Reg()
 489         case ssa.OpARMCMP,
 490                 ssa.OpARMCMN,
 491                 ssa.OpARMTST,
 492                 ssa.OpARMTEQ,
 493                 ssa.OpARMCMPF,
 494                 ssa.OpARMCMPD:
 495                 p := s.Prog(v.Op.Asm())
 496                 p.From.Type = obj.TYPE_REG
 497                 // Special layout in ARM assembly
 498                 // Comparing to x86, the operands of ARM's CMP are reversed.
 499                 p.From.Reg = v.Args[1].Reg()
 500                 p.Reg = v.Args[0].Reg()
 501         case ssa.OpARMCMPconst,
 502                 ssa.OpARMCMNconst,
 503                 ssa.OpARMTSTconst,
 504                 ssa.OpARMTEQconst:
 505                 // Special layout in ARM assembly
 506                 p := s.Prog(v.Op.Asm())
 507                 p.From.Type = obj.TYPE_CONST
 508                 p.From.Offset = v.AuxInt
 509                 p.Reg = v.Args[0].Reg()
 510         case ssa.OpARMCMPF0,
 511                 ssa.OpARMCMPD0:
 512                 p := s.Prog(v.Op.Asm())
 513                 p.From.Type = obj.TYPE_REG
 514                 p.From.Reg = v.Args[0].Reg()
 515         case ssa.OpARMCMPshiftLL, ssa.OpARMCMNshiftLL, ssa.OpARMTSTshiftLL, ssa.OpARMTEQshiftLL:
 516                 genshift(s, v.Op.Asm(), v.Args[0].Reg(), v.Args[1].Reg(), 0, arm.SHIFT_LL, v.AuxInt)
 517         case ssa.OpARMCMPshiftRL, ssa.OpARMCMNshiftRL, ssa.OpARMTSTshiftRL, ssa.OpARMTEQshiftRL:
 518                 genshift(s, v.Op.Asm(), v.Args[0].Reg(), v.Args[1].Reg(), 0, arm.SHIFT_LR, v.AuxInt)
 519         case ssa.OpARMCMPshiftRA, ssa.OpARMCMNshiftRA, ssa.OpARMTSTshiftRA, ssa.OpARMTEQshiftRA:
 520                 genshift(s, v.Op.Asm(), v.Args[0].Reg(), v.Args[1].Reg(), 0, arm.SHIFT_AR, v.AuxInt)
 521         case ssa.OpARMCMPshiftLLreg, ssa.OpARMCMNshiftLLreg, ssa.OpARMTSTshiftLLreg, ssa.OpARMTEQshiftLLreg:
 522                 genregshift(s, v.Op.Asm(), v.Args[0].Reg(), v.Args[1].Reg(), v.Args[2].Reg(), 0, arm.SHIFT_LL)
 523         case ssa.OpARMCMPshiftRLreg, ssa.OpARMCMNshiftRLreg, ssa.OpARMTSTshiftRLreg, ssa.OpARMTEQshiftRLreg:
 524                 genregshift(s, v.Op.Asm(), v.Args[0].Reg(), v.Args[1].Reg(), v.Args[2].Reg(), 0, arm.SHIFT_LR)
 525         case ssa.OpARMCMPshiftRAreg, ssa.OpARMCMNshiftRAreg, ssa.OpARMTSTshiftRAreg, ssa.OpARMTEQshiftRAreg:
 526                 genregshift(s, v.Op.Asm(), v.Args[0].Reg(), v.Args[1].Reg(), v.Args[2].Reg(), 0, arm.SHIFT_AR)
 527         case ssa.OpARMMOVWaddr:
 528                 p := s.Prog(arm.AMOVW)
 529                 p.From.Type = obj.TYPE_ADDR
 530                 p.From.Reg = v.Args[0].Reg()
 531                 p.To.Type = obj.TYPE_REG
 532                 p.To.Reg = v.Reg()
 533
 534                 var wantreg string
 535                 // MOVW $sym+off(base), R
 536                 // the assembler expands it as the following:
 537                 // - base is SP: add constant offset to SP (R13)
 538                 //               when constant is large, tmp register (R11) may be used
 539                 // - base is SB: load external address from constant pool (use relocation)
 540                 switch v.Aux.(type) {
 541                 default:
 542                         v.Fatalf("aux is of unknown type %T", v.Aux)
 543                 case *obj.LSym:
 544                         wantreg = "SB"
 545                         ssagen.AddAux(&p.From, v)
 546                 case *ir.Name:
 547                         wantreg = "SP"
 548                         ssagen.AddAux(&p.From, v)
 549                 case nil:
 550                         // No sym, just MOVW $off(SP), R
 551                         wantreg = "SP"
 552                         p.From.Offset = v.AuxInt
 553                 }
 554                 if reg := v.Args[0].RegName(); reg != wantreg {
 555                         v.Fatalf("bad reg %s for symbol type %T, want %s", reg, v.Aux, wantreg)
 556                 }
 557
 558         case ssa.OpARMMOVBload,
 559                 ssa.OpARMMOVBUload,
 560                 ssa.OpARMMOVHload,
 561                 ssa.OpARMMOVHUload,
 562                 ssa.OpARMMOVWload,
 563                 ssa.OpARMMOVFload,
 564                 ssa.OpARMMOVDload:
 565                 p := s.Prog(v.Op.Asm())
 566                 p.From.Type = obj.TYPE_MEM
 567                 p.From.Reg = v.Args[0].Reg()
 568                 ssagen.AddAux(&p.From, v)
 569                 p.To.Type = obj.TYPE_REG
 570                 p.To.Reg = v.Reg()
 571         case ssa.OpARMMOVBstore,
 572                 ssa.OpARMMOVHstore,
 573                 ssa.OpARMMOVWstore,
 574                 ssa.OpARMMOVFstore,
 575                 ssa.OpARMMOVDstore:
 576                 p := s.Prog(v.Op.Asm())
 577                 p.From.Type = obj.TYPE_REG
 578                 p.From.Reg = v.Args[1].Reg()
 579                 p.To.Type = obj.TYPE_MEM
 580                 p.To.Reg = v.Args[0].Reg()
 581                 ssagen.AddAux(&p.To, v)
 582         case ssa.OpARMMOVWloadidx, ssa.OpARMMOVBUloadidx, ssa.OpARMMOVBloadidx, ssa.OpARMMOVHUloadidx, ssa.OpARMMOVHloadidx:
 583                 // this is just shift 0 bits
 584                 fallthrough
 585         case ssa.OpARMMOVWloadshiftLL:
 586                 p := genshift(s, v.Op.Asm(), 0, v.Args[1].Reg(), v.Reg(), arm.SHIFT_LL, v.AuxInt)
 587                 p.From.Reg = v.Args[0].Reg()
 588         case ssa.OpARMMOVWloadshiftRL:
 589                 p := genshift(s, v.Op.Asm(), 0, v.Args[1].Reg(), v.Reg(), arm.SHIFT_LR, v.AuxInt)
 590                 p.From.Reg = v.Args[0].Reg()
 591         case ssa.OpARMMOVWloadshiftRA:
 592                 p := genshift(s, v.Op.Asm(), 0, v.Args[1].Reg(), v.Reg(), arm.SHIFT_AR, v.AuxInt)
 593                 p.From.Reg = v.Args[0].Reg()
 594         case ssa.OpARMMOVWstoreidx, ssa.OpARMMOVBstoreidx, ssa.OpARMMOVHstoreidx:
 595                 // this is just shift 0 bits
 596                 fallthrough
 597         case ssa.OpARMMOVWstoreshiftLL:
 598                 p := s.Prog(v.Op.Asm())
 599                 p.From.Type = obj.TYPE_REG
 600                 p.From.Reg = v.Args[2].Reg()
 601                 p.To.Type = obj.TYPE_SHIFT
 602                 p.To.Reg = v.Args[0].Reg()
 603                 p.To.Offset = int64(makeshift(v.Args[1].Reg(), arm.SHIFT_LL, v.AuxInt))
 604         case ssa.OpARMMOVWstoreshiftRL:
 605                 p := s.Prog(v.Op.Asm())
 606                 p.From.Type = obj.TYPE_REG
 607                 p.From.Reg = v.Args[2].Reg()
 608                 p.To.Type = obj.TYPE_SHIFT
 609                 p.To.Reg = v.Args[0].Reg()
 610                 p.To.Offset = int64(makeshift(v.Args[1].Reg(), arm.SHIFT_LR, v.AuxInt))
 611         case ssa.OpARMMOVWstoreshiftRA:
 612                 p := s.Prog(v.Op.Asm())
 613                 p.From.Type = obj.TYPE_REG
 614                 p.From.Reg = v.Args[2].Reg()
 615                 p.To.Type = obj.TYPE_SHIFT
 616                 p.To.Reg = v.Args[0].Reg()
 617                 p.To.Offset = int64(makeshift(v.Args[1].Reg(), arm.SHIFT_AR, v.AuxInt))
 618         case ssa.OpARMMOVBreg,
 619                 ssa.OpARMMOVBUreg,
 620                 ssa.OpARMMOVHreg,
 621                 ssa.OpARMMOVHUreg:
 622                 a := v.Args[0]
 623                 for a.Op == ssa.OpCopy || a.Op == ssa.OpARMMOVWreg || a.Op == ssa.OpARMMOVWnop {
 624                         a = a.Args[0]
 625                 }
 626                 if a.Op == ssa.OpLoadReg {
 627                         t := a.Type
 628                         switch {
 629                         case v.Op == ssa.OpARMMOVBreg && t.Size() == 1 && t.IsSigned(),
 630                                 v.Op == ssa.OpARMMOVBUreg && t.Size() == 1 && !t.IsSigned(),
 631                                 v.Op == ssa.OpARMMOVHreg && t.Size() == 2 && t.IsSigned(),
 632                                 v.Op == ssa.OpARMMOVHUreg && t.Size() == 2 && !t.IsSigned():
 633                                 // arg is a proper-typed load, already zero/sign-extended, don't extend again
 634                                 if v.Reg() == v.Args[0].Reg() {
 635                                         return
 636                                 }
 637                                 p := s.Prog(arm.AMOVW)
 638                                 p.From.Type = obj.TYPE_REG
 639                                 p.From.Reg = v.Args[0].Reg()
 640                                 p.To.Type = obj.TYPE_REG
 641                                 p.To.Reg = v.Reg()
 642                                 return
 643                         default:
 644                         }
 645                 }
 646                 if buildcfg.GOARM >= 6 {
 647                         // generate more efficient "MOVB/MOVBU/MOVH/MOVHU Reg@>0, Reg" on ARMv6 & ARMv7
 648                         genshift(s, v.Op.Asm(), 0, v.Args[0].Reg(), v.Reg(), arm.SHIFT_RR, 0)
 649                         return
 650                 }
 651                 fallthrough
 652         case ssa.OpARMMVN,
 653                 ssa.OpARMCLZ,
 654                 ssa.OpARMREV,
 655                 ssa.OpARMREV16,
 656                 ssa.OpARMRBIT,
 657                 ssa.OpARMSQRTF,
 658                 ssa.OpARMSQRTD,
 659                 ssa.OpARMNEGF,
 660                 ssa.OpARMNEGD,
 661                 ssa.OpARMABSD,
 662                 ssa.OpARMMOVWF,
 663                 ssa.OpARMMOVWD,
 664                 ssa.OpARMMOVFW,
 665                 ssa.OpARMMOVDW,
 666                 ssa.OpARMMOVFD,
 667                 ssa.OpARMMOVDF:
 668                 p := s.Prog(v.Op.Asm())
 669                 p.From.Type = obj.TYPE_REG
 670                 p.From.Reg = v.Args[0].Reg()
 671                 p.To.Type = obj.TYPE_REG
 672                 p.To.Reg = v.Reg()
 673         case ssa.OpARMMOVWUF,
 674                 ssa.OpARMMOVWUD,
 675                 ssa.OpARMMOVFWU,
 676                 ssa.OpARMMOVDWU:
 677                 p := s.Prog(v.Op.Asm())
 678                 p.Scond = arm.C_UBIT
 679                 p.From.Type = obj.TYPE_REG
 680                 p.From.Reg = v.Args[0].Reg()
 681                 p.To.Type = obj.TYPE_REG
 682                 p.To.Reg = v.Reg()
 683         case ssa.OpARMCMOVWHSconst:
 684                 p := s.Prog(arm.AMOVW)
 685                 p.Scond = arm.C_SCOND_HS
 686                 p.From.Type = obj.TYPE_CONST
 687                 p.From.Offset = v.AuxInt
 688                 p.To.Type = obj.TYPE_REG
 689                 p.To.Reg = v.Reg()
 690         case ssa.OpARMCMOVWLSconst:
 691                 p := s.Prog(arm.AMOVW)
 692                 p.Scond = arm.C_SCOND_LS
 693                 p.From.Type = obj.TYPE_CONST
 694                 p.From.Offset = v.AuxInt
 695                 p.To.Type = obj.TYPE_REG
 696                 p.To.Reg = v.Reg()
 697         case ssa.OpARMCALLstatic, ssa.OpARMCALLclosure, ssa.OpARMCALLinter:
 698                 s.Call(v)
 699         case ssa.OpARMCALLudiv:
 700                 p := s.Prog(obj.ACALL)
 701                 p.To.Type = obj.TYPE_MEM
 702                 p.To.Name = obj.NAME_EXTERN
 703                 p.To.Sym = ir.Syms.Udiv
 704         case ssa.OpARMLoweredWB:
 705                 p := s.Prog(obj.ACALL)
 706                 p.To.Type = obj.TYPE_MEM
 707                 p.To.Name = obj.NAME_EXTERN
 708                 p.To.Sym = v.Aux.(*obj.LSym)
 709         case ssa.OpARMLoweredPanicBoundsA, ssa.OpARMLoweredPanicBoundsB, ssa.OpARMLoweredPanicBoundsC:
 710                 p := s.Prog(obj.ACALL)
 711                 p.To.Type = obj.TYPE_MEM
 712                 p.To.Name = obj.NAME_EXTERN
 713                 p.To.Sym = ssagen.BoundsCheckFunc[v.AuxInt]
 714                 s.UseArgs(8) // space used in callee args area by assembly stubs
 715         case ssa.OpARMLoweredPanicExtendA, ssa.OpARMLoweredPanicExtendB, ssa.OpARMLoweredPanicExtendC:
 716                 p := s.Prog(obj.ACALL)
 717                 p.To.Type = obj.TYPE_MEM
 718                 p.To.Name = obj.NAME_EXTERN
 719                 p.To.Sym = ssagen.ExtendCheckFunc[v.AuxInt]
 720                 s.UseArgs(12) // space used in callee args area by assembly stubs
 721         case ssa.OpARMDUFFZERO:
 722                 p := s.Prog(obj.ADUFFZERO)
 723                 p.To.Type = obj.TYPE_MEM
 724                 p.To.Name = obj.NAME_EXTERN
 725                 p.To.Sym = ir.Syms.Duffzero
 726                 p.To.Offset = v.AuxInt
 727         case ssa.OpARMDUFFCOPY:
 728                 p := s.Prog(obj.ADUFFCOPY)
 729                 p.To.Type = obj.TYPE_MEM
 730                 p.To.Name = obj.NAME_EXTERN
 731                 p.To.Sym = ir.Syms.Duffcopy
 732                 p.To.Offset = v.AuxInt
 733         case ssa.OpARMLoweredNilCheck:
 734                 // Issue a load which will fault if arg is nil.
 735                 p := s.Prog(arm.AMOVB)
 736                 p.From.Type = obj.TYPE_MEM
 737                 p.From.Reg = v.Args[0].Reg()
 738                 ssagen.AddAux(&p.From, v)
 739                 p.To.Type = obj.TYPE_REG
 740                 p.To.Reg = arm.REGTMP
 741                 if logopt.Enabled() {
 742                         logopt.LogOpt(v.Pos, "nilcheck", "genssa", v.Block.Func.Name)
 743                 }
 744                 if base.Debug.Nil != 0 && v.Pos.Line() > 1 { // v.Pos.Line()==1 in generated wrappers
 745                         base.WarnfAt(v.Pos, "generated nil check")
 746                 }
 747         case ssa.OpARMLoweredZero:
 748                 // MOVW.P       Rarg2, 4(R1)
 749                 // CMP  Rarg1, R1
 750                 // BLE  -2(PC)
 751                 // arg1 is the address of the last element to zero
 752                 // arg2 is known to be zero
 753                 // auxint is alignment
 754                 var sz int64
 755                 var mov obj.As
 756                 switch {
 757                 case v.AuxInt%4 == 0:
 758                         sz = 4
 759                         mov = arm.AMOVW
 760                 case v.AuxInt%2 == 0:
 761                         sz = 2
 762                         mov = arm.AMOVH
 763                 default:
 764                         sz = 1
 765                         mov = arm.AMOVB
 766                 }
 767                 p := s.Prog(mov)
 768                 p.Scond = arm.C_PBIT
 769                 p.From.Type = obj.TYPE_REG
 770                 p.From.Reg = v.Args[2].Reg()
 771                 p.To.Type = obj.TYPE_MEM
 772                 p.To.Reg = arm.REG_R1
 773                 p.To.Offset = sz
 774                 p2 := s.Prog(arm.ACMP)
 775                 p2.From.Type = obj.TYPE_REG
 776                 p2.From.Reg = v.Args[1].Reg()
 777                 p2.Reg = arm.REG_R1
 778                 p3 := s.Prog(arm.ABLE)
 779                 p3.To.Type = obj.TYPE_BRANCH
 780                 p3.To.SetTarget(p)
 781         case ssa.OpARMLoweredMove:
 782                 // MOVW.P       4(R1), Rtmp
 783                 // MOVW.P       Rtmp, 4(R2)
 784                 // CMP  Rarg2, R1
 785                 // BLE  -3(PC)
 786                 // arg2 is the address of the last element of src
 787                 // auxint is alignment
 788                 var sz int64
 789                 var mov obj.As
 790                 switch {
 791                 case v.AuxInt%4 == 0:
 792                         sz = 4
 793                         mov = arm.AMOVW
 794                 case v.AuxInt%2 == 0:
 795                         sz = 2
 796                         mov = arm.AMOVH
 797                 default:
 798                         sz = 1
 799                         mov = arm.AMOVB
 800                 }
 801                 p := s.Prog(mov)
 802                 p.Scond = arm.C_PBIT
 803                 p.From.Type = obj.TYPE_MEM
 804                 p.From.Reg = arm.REG_R1
 805                 p.From.Offset = sz
 806                 p.To.Type = obj.TYPE_REG
 807                 p.To.Reg = arm.REGTMP
 808                 p2 := s.Prog(mov)
 809                 p2.Scond = arm.C_PBIT
 810                 p2.From.Type = obj.TYPE_REG
 811                 p2.From.Reg = arm.REGTMP
 812                 p2.To.Type = obj.TYPE_MEM
 813                 p2.To.Reg = arm.REG_R2
 814                 p2.To.Offset = sz
 815                 p3 := s.Prog(arm.ACMP)
 816                 p3.From.Type = obj.TYPE_REG
 817                 p3.From.Reg = v.Args[2].Reg()
 818                 p3.Reg = arm.REG_R1
 819                 p4 := s.Prog(arm.ABLE)
 820                 p4.To.Type = obj.TYPE_BRANCH
 821                 p4.To.SetTarget(p)
 822         case ssa.OpARMEqual,
 823                 ssa.OpARMNotEqual,
 824                 ssa.OpARMLessThan,
 825                 ssa.OpARMLessEqual,
 826                 ssa.OpARMGreaterThan,
 827                 ssa.OpARMGreaterEqual,
 828                 ssa.OpARMLessThanU,
 829                 ssa.OpARMLessEqualU,
 830                 ssa.OpARMGreaterThanU,
 831                 ssa.OpARMGreaterEqualU:
 832                 // generate boolean values
 833                 // use conditional move
 834                 p := s.Prog(arm.AMOVW)
 835                 p.From.Type = obj.TYPE_CONST
 836                 p.From.Offset = 0
 837                 p.To.Type = obj.TYPE_REG
 838                 p.To.Reg = v.Reg()
 839                 p = s.Prog(arm.AMOVW)
 840                 p.Scond = condBits[v.Op]
 841                 p.From.Type = obj.TYPE_CONST
 842                 p.From.Offset = 1
 843                 p.To.Type = obj.TYPE_REG
 844                 p.To.Reg = v.Reg()
 845         case ssa.OpARMLoweredGetClosurePtr:
 846                 // Closure pointer is R7 (arm.REGCTXT).
 847                 ssagen.CheckLoweredGetClosurePtr(v)
 848         case ssa.OpARMLoweredGetCallerSP:
 849                 // caller's SP is FixedFrameSize below the address of the first arg
 850                 p := s.Prog(arm.AMOVW)
 851                 p.From.Type = obj.TYPE_ADDR
 852                 p.From.Offset = -base.Ctxt.FixedFrameSize()
 853                 p.From.Name = obj.NAME_PARAM
 854                 p.To.Type = obj.TYPE_REG
 855                 p.To.Reg = v.Reg()
 856         case ssa.OpARMLoweredGetCallerPC:
 857                 p := s.Prog(obj.AGETCALLERPC)
 858                 p.To.Type = obj.TYPE_REG
 859                 p.To.Reg = v.Reg()
 860         case ssa.OpARMFlagConstant:
 861                 v.Fatalf("FlagConstant op should never make it to codegen %v", v.LongString())
 862         case ssa.OpARMInvertFlags:
 863                 v.Fatalf("InvertFlags should never make it to codegen %v", v.LongString())
 864         case ssa.OpClobber, ssa.OpClobberReg:
 865                 // TODO: implement for clobberdead experiment. Nop is ok for now.
 866         default:
 867                 v.Fatalf("genValue not implemented: %s", v.LongString())
 868         }
 869 }
 870
 871 var condBits = map[ssa.Op]uint8{
 872         ssa.OpARMEqual:         arm.C_SCOND_EQ,
 873         ssa.OpARMNotEqual:      arm.C_SCOND_NE,
 874         ssa.OpARMLessThan:      arm.C_SCOND_LT,
 875         ssa.OpARMLessThanU:     arm.C_SCOND_LO,
 876         ssa.OpARMLessEqual:     arm.C_SCOND_LE,
 877         ssa.OpARMLessEqualU:    arm.C_SCOND_LS,
 878         ssa.OpARMGreaterThan:   arm.C_SCOND_GT,
 879         ssa.OpARMGreaterThanU:  arm.C_SCOND_HI,
 880         ssa.OpARMGreaterEqual:  arm.C_SCOND_GE,
 881         ssa.OpARMGreaterEqualU: arm.C_SCOND_HS,
 882 }
 883
 884 var blockJump = map[ssa.BlockKind]struct {
 885         asm, invasm obj.As
 886 }{
 887         ssa.BlockARMEQ:     {arm.ABEQ, arm.ABNE},
 888         ssa.BlockARMNE:     {arm.ABNE, arm.ABEQ},
 889         ssa.BlockARMLT:     {arm.ABLT, arm.ABGE},
 890         ssa.BlockARMGE:     {arm.ABGE, arm.ABLT},
 891         ssa.BlockARMLE:     {arm.ABLE, arm.ABGT},
 892         ssa.BlockARMGT:     {arm.ABGT, arm.ABLE},
 893         ssa.BlockARMULT:    {arm.ABLO, arm.ABHS},
 894         ssa.BlockARMUGE:    {arm.ABHS, arm.ABLO},
 895         ssa.BlockARMUGT:    {arm.ABHI, arm.ABLS},
 896         ssa.BlockARMULE:    {arm.ABLS, arm.ABHI},
 897         ssa.BlockARMLTnoov: {arm.ABMI, arm.ABPL},
 898         ssa.BlockARMGEnoov: {arm.ABPL, arm.ABMI},
 899 }
 900
 901 // To model a 'LEnoov' ('<=' without overflow checking) branching
 902 var leJumps = [2][2]ssagen.IndexJump{
 903         {{Jump: arm.ABEQ, Index: 0}, {Jump: arm.ABPL, Index: 1}}, // next == b.Succs[0]
 904         {{Jump: arm.ABMI, Index: 0}, {Jump: arm.ABEQ, Index: 0}}, // next == b.Succs[1]
 905 }
 906
 907 // To model a 'GTnoov' ('>' without overflow checking) branching
 908 var gtJumps = [2][2]ssagen.IndexJump{
 909         {{Jump: arm.ABMI, Index: 1}, {Jump: arm.ABEQ, Index: 1}}, // next == b.Succs[0]
 910         {{Jump: arm.ABEQ, Index: 1}, {Jump: arm.ABPL, Index: 0}}, // next == b.Succs[1]
 911 }
 912
 913 func ssaGenBlock(s *ssagen.State, b, next *ssa.Block) {
 914         switch b.Kind {
 915         case ssa.BlockPlain:
 916                 if b.Succs[0].Block() != next {
 917                         p := s.Prog(obj.AJMP)
 918                         p.To.Type = obj.TYPE_BRANCH
 919                         s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
 920                 }
 921
 922         case ssa.BlockDefer:
 923                 // defer returns in R0:
 924                 // 0 if we should continue executing
 925                 // 1 if we should jump to deferreturn call
 926                 p := s.Prog(arm.ACMP)
 927                 p.From.Type = obj.TYPE_CONST
 928                 p.From.Offset = 0
 929                 p.Reg = arm.REG_R0
 930                 p = s.Prog(arm.ABNE)
 931                 p.To.Type = obj.TYPE_BRANCH
 932                 s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[1].Block()})
 933                 if b.Succs[0].Block() != next {
 934                         p := s.Prog(obj.AJMP)
 935                         p.To.Type = obj.TYPE_BRANCH
 936                         s.Branches = append(s.Branches, ssagen.Branch{P: p, B: b.Succs[0].Block()})
 937                 }
 938
 939         case ssa.BlockExit:
 940
 941         case ssa.BlockRet:
 942                 s.Prog(obj.ARET)
 943
 944         case ssa.BlockRetJmp:
 945                 p := s.Prog(obj.ARET)
 946                 p.To.Type = obj.TYPE_MEM
 947                 p.To.Name = obj.NAME_EXTERN
 948                 p.To.Sym = b.Aux.(*obj.LSym)
 949
 950         case ssa.BlockARMEQ, ssa.BlockARMNE,
 951                 ssa.BlockARMLT, ssa.BlockARMGE,
 952                 ssa.BlockARMLE, ssa.BlockARMGT,
 953                 ssa.BlockARMULT, ssa.BlockARMUGT,
 954                 ssa.BlockARMULE, ssa.BlockARMUGE,
 955                 ssa.BlockARMLTnoov, ssa.BlockARMGEnoov:
 956                 jmp := blockJump[b.Kind]
 957                 switch next {
 958                 case b.Succs[0].Block():
 959                         s.Br(jmp.invasm, b.Succs[1].Block())
 960                 case b.Succs[1].Block():
 961                         s.Br(jmp.asm, b.Succs[0].Block())
 962                 default:
 963                         if b.Likely != ssa.BranchUnlikely {
 964                                 s.Br(jmp.asm, b.Succs[0].Block())
 965                                 s.Br(obj.AJMP, b.Succs[1].Block())
 966                         } else {
 967                                 s.Br(jmp.invasm, b.Succs[1].Block())
 968                                 s.Br(obj.AJMP, b.Succs[0].Block())
 969                         }
 970                 }
 971
 972         case ssa.BlockARMLEnoov:
 973                 s.CombJump(b, next, &leJumps)
 974
 975         case ssa.BlockARMGTnoov:
 976                 s.CombJump(b, next, &gtJumps)
 977
 978         default:
 979                 b.Fatalf("branch not implemented: %s", b.LongString())
 980         }
 981 }