src/compiler/codegen/arm/utility_arm.cc

/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "arm_lir.h"
#include "../codegen_util.h"
#include "../ralloc_util.h"

namespace art {

/* This file contains codegen for the Thumb ISA. */

static int EncodeImmSingle(int value)
{
  int res;
  int bitA =  (value & 0x80000000) >> 31;
  int notBitB = (value & 0x40000000) >> 30;
  int bitB =  (value & 0x20000000) >> 29;
  int bSmear =  (value & 0x3e000000) >> 25;
  int slice =   (value & 0x01f80000) >> 19;
  int zeroes =  (value & 0x0007ffff);
  if (zeroes != 0)
    return -1;
  if (bitB) {
    if ((notBitB != 0) || (bSmear != 0x1f))
      return -1;
  } else {
    if ((notBitB != 1) || (bSmear != 0x0))
      return -1;
  }
  res = (bitA << 7) | (bitB << 6) | slice;
  return res;
}

static LIR* LoadFPConstantValue(CompilationUnit* cUnit, int rDest, int value)
{
  int encodedImm = EncodeImmSingle(value);
  DCHECK(ARM_SINGLEREG(rDest));
  if (encodedImm >= 0) {
    return NewLIR2(cUnit, kThumb2Vmovs_IMM8, rDest, encodedImm);
  }
  LIR* dataTarget = ScanLiteralPool(cUnit->literalList, value, 0);
  if (dataTarget == NULL) {
    dataTarget = AddWordData(cUnit, &cUnit->literalList, value);
  }
  LIR* loadPcRel = RawLIR(cUnit, cUnit->currentDalvikOffset, kThumb2Vldrs,
                          rDest, r15pc, 0, 0, 0, dataTarget);
  SetMemRefType(loadPcRel, true, kLiteral);
  loadPcRel->aliasInfo = reinterpret_cast<uintptr_t>(dataTarget);
  AppendLIR(cUnit, loadPcRel);
  return loadPcRel;
}

static int LeadingZeros(uint32_t val)
{
  uint32_t alt;
  int n;
  int count;

  count = 16;
  n = 32;
  do {
    alt = val >> count;
    if (alt != 0) {
      n = n - count;
      val = alt;
    }
    count >>= 1;
  } while (count);
  return n - val;
}

/*
 * Determine whether value can be encoded as a Thumb2 modified
 * immediate.  If not, return -1.  If so, return i:imm3:a:bcdefgh form.
 */
int ModifiedImmediate(uint32_t value)
{
   int zLeading;
   int zTrailing;
   uint32_t b0 = value & 0xff;

   /* Note: case of value==0 must use 0:000:0:0000000 encoding */
   if (value <= 0xFF)
     return b0;  // 0:000:a:bcdefgh
   if (value == ((b0 << 16) | b0))
     return (0x1 << 8) | b0; /* 0:001:a:bcdefgh */
   if (value == ((b0 << 24) | (b0 << 16) | (b0 << 8) | b0))
     return (0x3 << 8) | b0; /* 0:011:a:bcdefgh */
   b0 = (value >> 8) & 0xff;
   if (value == ((b0 << 24) | (b0 << 8)))
     return (0x2 << 8) | b0; /* 0:010:a:bcdefgh */
   /* Can we do it with rotation? */
   zLeading = LeadingZeros(value);
   zTrailing = 32 - LeadingZeros(~value & (value - 1));
   /* A run of eight or fewer active bits? */
   if ((zLeading + zTrailing) < 24)
     return -1;  /* No - bail */
   /* left-justify the constant, discarding msb (known to be 1) */
   value <<= zLeading + 1;
   /* Create bcdefgh */
   value >>= 25;
   /* Put it all together */
   return value | ((0x8 + zLeading) << 7); /* [01000..11111]:bcdefgh */
}

/*
 * Load a immediate using a shortcut if possible; otherwise
 * grab from the per-translation literal pool.
 *
 * No additional register clobbering operation performed. Use this version when
 * 1) rDest is freshly returned from AllocTemp or
 * 2) The codegen is under fixed register usage
 */
LIR* LoadConstantNoClobber(CompilationUnit* cUnit, int rDest, int value)
{
  LIR* res;
  int modImm;

  if (ARM_FPREG(rDest)) {
    return LoadFPConstantValue(cUnit, rDest, value);
  }

  /* See if the value can be constructed cheaply */
  if (ARM_LOWREG(rDest) && (value >= 0) && (value <= 255)) {
    return NewLIR2(cUnit, kThumbMovImm, rDest, value);
  }
  /* Check Modified immediate special cases */
  modImm = ModifiedImmediate(value);
  if (modImm >= 0) {
    res = NewLIR2(cUnit, kThumb2MovImmShift, rDest, modImm);
    return res;
  }
  modImm = ModifiedImmediate(~value);
  if (modImm >= 0) {
    res = NewLIR2(cUnit, kThumb2MvnImm12, rDest, modImm);
    return res;
  }
  /* 16-bit immediate? */
  if ((value & 0xffff) == value) {
    res = NewLIR2(cUnit, kThumb2MovImm16, rDest, value);
    return res;
  }
  /* No shortcut - go ahead and use literal pool */
  LIR* dataTarget = ScanLiteralPool(cUnit->literalList, value, 0);
  if (dataTarget == NULL) {
    dataTarget = AddWordData(cUnit, &cUnit->literalList, value);
  }
  LIR* loadPcRel = RawLIR(cUnit, cUnit->currentDalvikOffset,
                          kThumb2LdrPcRel12, rDest, 0, 0, 0, 0, dataTarget);
  SetMemRefType(loadPcRel, true, kLiteral);
  loadPcRel->aliasInfo = reinterpret_cast<uintptr_t>(dataTarget);
  res = loadPcRel;
  AppendLIR(cUnit, loadPcRel);

  /*
   * To save space in the constant pool, we use the ADD_RRI8 instruction to
   * add up to 255 to an existing constant value.
   */
  if (dataTarget->operands[0] != value) {
    OpRegImm(cUnit, kOpAdd, rDest, value - dataTarget->operands[0]);
  }
  return res;
}

LIR* OpBranchUnconditional(CompilationUnit* cUnit, OpKind op)
{
  DCHECK_EQ(op, kOpUncondBr);
  return NewLIR1(cUnit, kThumbBUncond, 0 /* offset to be patched */);
}

LIR* OpCondBranch(CompilationUnit* cUnit, ConditionCode cc, LIR* target)
{
  LIR* branch = NewLIR2(cUnit, kThumb2BCond, 0 /* offset to be patched */,
                        ArmConditionEncoding(cc));
  branch->target = target;
  return branch;
}

LIR* OpReg(CompilationUnit* cUnit, OpKind op, int rDestSrc)
{
  ArmOpcode opcode = kThumbBkpt;
  switch (op) {
    case kOpBlx:
      opcode = kThumbBlxR;
      break;
    default:
      LOG(FATAL) << "Bad opcode " << op;
  }
  return NewLIR1(cUnit, opcode, rDestSrc);
}

LIR* OpRegRegShift(CompilationUnit* cUnit, OpKind op, int rDestSrc1,
                   int rSrc2, int shift)
{
  bool thumbForm = ((shift == 0) && ARM_LOWREG(rDestSrc1) && ARM_LOWREG(rSrc2));
  ArmOpcode opcode = kThumbBkpt;
  switch (op) {
    case kOpAdc:
      opcode = (thumbForm) ? kThumbAdcRR : kThumb2AdcRRR;
      break;
    case kOpAnd:
      opcode = (thumbForm) ? kThumbAndRR : kThumb2AndRRR;
      break;
    case kOpBic:
      opcode = (thumbForm) ? kThumbBicRR : kThumb2BicRRR;
      break;
    case kOpCmn:
      DCHECK_EQ(shift, 0);
      opcode = (thumbForm) ? kThumbCmnRR : kThumb2CmnRR;
      break;
    case kOpCmp:
      if (thumbForm)
        opcode = kThumbCmpRR;
      else if ((shift == 0) && !ARM_LOWREG(rDestSrc1) && !ARM_LOWREG(rSrc2))
        opcode = kThumbCmpHH;
      else if ((shift == 0) && ARM_LOWREG(rDestSrc1))
        opcode = kThumbCmpLH;
      else if (shift == 0)
        opcode = kThumbCmpHL;
      else
        opcode = kThumb2CmpRR;
      break;
    case kOpXor:
      opcode = (thumbForm) ? kThumbEorRR : kThumb2EorRRR;
      break;
    case kOpMov:
      DCHECK_EQ(shift, 0);
      if (ARM_LOWREG(rDestSrc1) && ARM_LOWREG(rSrc2))
        opcode = kThumbMovRR;
      else if (!ARM_LOWREG(rDestSrc1) && !ARM_LOWREG(rSrc2))
        opcode = kThumbMovRR_H2H;
      else if (ARM_LOWREG(rDestSrc1))
        opcode = kThumbMovRR_H2L;
      else
        opcode = kThumbMovRR_L2H;
      break;
    case kOpMul:
      DCHECK_EQ(shift, 0);
      opcode = (thumbForm) ? kThumbMul : kThumb2MulRRR;
      break;
    case kOpMvn:
      opcode = (thumbForm) ? kThumbMvn : kThumb2MnvRR;
      break;
    case kOpNeg:
      DCHECK_EQ(shift, 0);
      opcode = (thumbForm) ? kThumbNeg : kThumb2NegRR;
      break;
    case kOpOr:
      opcode = (thumbForm) ? kThumbOrr : kThumb2OrrRRR;
      break;
    case kOpSbc:
      opcode = (thumbForm) ? kThumbSbc : kThumb2SbcRRR;
      break;
    case kOpTst:
      opcode = (thumbForm) ? kThumbTst : kThumb2TstRR;
      break;
    case kOpLsl:
      DCHECK_EQ(shift, 0);
      opcode = (thumbForm) ? kThumbLslRR : kThumb2LslRRR;
      break;
    case kOpLsr:
      DCHECK_EQ(shift, 0);
      opcode = (thumbForm) ? kThumbLsrRR : kThumb2LsrRRR;
      break;
    case kOpAsr:
      DCHECK_EQ(shift, 0);
      opcode = (thumbForm) ? kThumbAsrRR : kThumb2AsrRRR;
      break;
    case kOpRor:
      DCHECK_EQ(shift, 0);
      opcode = (thumbForm) ? kThumbRorRR : kThumb2RorRRR;
      break;
    case kOpAdd:
      opcode = (thumbForm) ? kThumbAddRRR : kThumb2AddRRR;
      break;
    case kOpSub:
      opcode = (thumbForm) ? kThumbSubRRR : kThumb2SubRRR;
      break;
    case kOp2Byte:
      DCHECK_EQ(shift, 0);
      return NewLIR4(cUnit, kThumb2Sbfx, rDestSrc1, rSrc2, 0, 8);
    case kOp2Short:
      DCHECK_EQ(shift, 0);
      return NewLIR4(cUnit, kThumb2Sbfx, rDestSrc1, rSrc2, 0, 16);
    case kOp2Char:
      DCHECK_EQ(shift, 0);
      return NewLIR4(cUnit, kThumb2Ubfx, rDestSrc1, rSrc2, 0, 16);
    default:
      LOG(FATAL) << "Bad opcode: " << op;
      break;
  }
  DCHECK_GE(static_cast<int>(opcode), 0);
  if (EncodingMap[opcode].flags & IS_BINARY_OP)
    return NewLIR2(cUnit, opcode, rDestSrc1, rSrc2);
  else if (EncodingMap[opcode].flags & IS_TERTIARY_OP) {
    if (EncodingMap[opcode].fieldLoc[2].kind == kFmtShift)
      return NewLIR3(cUnit, opcode, rDestSrc1, rSrc2, shift);
    else
      return NewLIR3(cUnit, opcode, rDestSrc1, rDestSrc1, rSrc2);
  } else if (EncodingMap[opcode].flags & IS_QUAD_OP)
    return NewLIR4(cUnit, opcode, rDestSrc1, rDestSrc1, rSrc2, shift);
  else {
    LOG(FATAL) << "Unexpected encoding operand count";
    return NULL;
  }
}

LIR* OpRegReg(CompilationUnit* cUnit, OpKind op, int rDestSrc1, int rSrc2)
{
  return OpRegRegShift(cUnit, op, rDestSrc1, rSrc2, 0);
}

LIR* OpRegRegRegShift(CompilationUnit* cUnit, OpKind op, int rDest, int rSrc1,
            int rSrc2, int shift)
{
  ArmOpcode opcode = kThumbBkpt;
  bool thumbForm = (shift == 0) && ARM_LOWREG(rDest) && ARM_LOWREG(rSrc1) &&
      ARM_LOWREG(rSrc2);
  switch (op) {
    case kOpAdd:
      opcode = (thumbForm) ? kThumbAddRRR : kThumb2AddRRR;
      break;
    case kOpSub:
      opcode = (thumbForm) ? kThumbSubRRR : kThumb2SubRRR;
      break;
    case kOpRsub:
      opcode = kThumb2RsubRRR;
      break;
    case kOpAdc:
      opcode = kThumb2AdcRRR;
      break;
    case kOpAnd:
      opcode = kThumb2AndRRR;
      break;
    case kOpBic:
      opcode = kThumb2BicRRR;
      break;
    case kOpXor:
      opcode = kThumb2EorRRR;
      break;
    case kOpMul:
      DCHECK_EQ(shift, 0);
      opcode = kThumb2MulRRR;
      break;
    case kOpOr:
      opcode = kThumb2OrrRRR;
      break;
    case kOpSbc:
      opcode = kThumb2SbcRRR;
      break;
    case kOpLsl:
      DCHECK_EQ(shift, 0);
      opcode = kThumb2LslRRR;
      break;
    case kOpLsr:
      DCHECK_EQ(shift, 0);
      opcode = kThumb2LsrRRR;
      break;
    case kOpAsr:
      DCHECK_EQ(shift, 0);
      opcode = kThumb2AsrRRR;
      break;
    case kOpRor:
      DCHECK_EQ(shift, 0);
      opcode = kThumb2RorRRR;
      break;
    default:
      LOG(FATAL) << "Bad opcode: " << op;
      break;
  }
  DCHECK_GE(static_cast<int>(opcode), 0);
  if (EncodingMap[opcode].flags & IS_QUAD_OP)
    return NewLIR4(cUnit, opcode, rDest, rSrc1, rSrc2, shift);
  else {
    DCHECK(EncodingMap[opcode].flags & IS_TERTIARY_OP);
    return NewLIR3(cUnit, opcode, rDest, rSrc1, rSrc2);
  }
}

LIR* OpRegRegReg(CompilationUnit* cUnit, OpKind op, int rDest, int rSrc1,
                 int rSrc2)
{
  return OpRegRegRegShift(cUnit, op, rDest, rSrc1, rSrc2, 0);
}

LIR* OpRegRegImm(CompilationUnit* cUnit, OpKind op, int rDest, int rSrc1,
                 int value)
{
  LIR* res;
  bool neg = (value < 0);
  int absValue = (neg) ? -value : value;
  ArmOpcode opcode = kThumbBkpt;
  ArmOpcode altOpcode = kThumbBkpt;
  bool allLowRegs = (ARM_LOWREG(rDest) && ARM_LOWREG(rSrc1));
  int modImm = ModifiedImmediate(value);
  int modImmNeg = ModifiedImmediate(-value);

  switch (op) {
    case kOpLsl:
      if (allLowRegs)
        return NewLIR3(cUnit, kThumbLslRRI5, rDest, rSrc1, value);
      else
        return NewLIR3(cUnit, kThumb2LslRRI5, rDest, rSrc1, value);
    case kOpLsr:
      if (allLowRegs)
        return NewLIR3(cUnit, kThumbLsrRRI5, rDest, rSrc1, value);
      else
        return NewLIR3(cUnit, kThumb2LsrRRI5, rDest, rSrc1, value);
    case kOpAsr:
      if (allLowRegs)
        return NewLIR3(cUnit, kThumbAsrRRI5, rDest, rSrc1, value);
      else
        return NewLIR3(cUnit, kThumb2AsrRRI5, rDest, rSrc1, value);
    case kOpRor:
      return NewLIR3(cUnit, kThumb2RorRRI5, rDest, rSrc1, value);
    case kOpAdd:
      if (ARM_LOWREG(rDest) && (rSrc1 == r13sp) &&
        (value <= 1020) && ((value & 0x3)==0)) {
        return NewLIR3(cUnit, kThumbAddSpRel, rDest, rSrc1, value >> 2);
      } else if (ARM_LOWREG(rDest) && (rSrc1 == r15pc) &&
          (value <= 1020) && ((value & 0x3)==0)) {
        return NewLIR3(cUnit, kThumbAddPcRel, rDest, rSrc1, value >> 2);
      }
      // Note: intentional fallthrough
    case kOpSub:
      if (allLowRegs && ((absValue & 0x7) == absValue)) {
        if (op == kOpAdd)
          opcode = (neg) ? kThumbSubRRI3 : kThumbAddRRI3;
        else
          opcode = (neg) ? kThumbAddRRI3 : kThumbSubRRI3;
        return NewLIR3(cUnit, opcode, rDest, rSrc1, absValue);
      } else if ((absValue & 0xff) == absValue) {
        if (op == kOpAdd)
          opcode = (neg) ? kThumb2SubRRI12 : kThumb2AddRRI12;
        else
          opcode = (neg) ? kThumb2AddRRI12 : kThumb2SubRRI12;
        return NewLIR3(cUnit, opcode, rDest, rSrc1, absValue);
      }
      if (modImmNeg >= 0) {
        op = (op == kOpAdd) ? kOpSub : kOpAdd;
        modImm = modImmNeg;
      }
      if (op == kOpSub) {
        opcode = kThumb2SubRRI8;
        altOpcode = kThumb2SubRRR;
      } else {
        opcode = kThumb2AddRRI8;
        altOpcode = kThumb2AddRRR;
      }
      break;
    case kOpAdc:
      opcode = kThumb2AdcRRI8;
      altOpcode = kThumb2AdcRRR;
      break;
    case kOpSbc:
      opcode = kThumb2SbcRRI8;
      altOpcode = kThumb2SbcRRR;
      break;
    case kOpOr:
      opcode = kThumb2OrrRRI8;
      altOpcode = kThumb2OrrRRR;
      break;
    case kOpAnd:
      opcode = kThumb2AndRRI8;
      altOpcode = kThumb2AndRRR;
      break;
    case kOpXor:
      opcode = kThumb2EorRRI8;
      altOpcode = kThumb2EorRRR;
      break;
    case kOpMul:
      //TUNING: power of 2, shift & add
      modImm = -1;
      altOpcode = kThumb2MulRRR;
      break;
    case kOpCmp: {
      int modImm = ModifiedImmediate(value);
      LIR* res;
      if (modImm >= 0) {
        res = NewLIR2(cUnit, kThumb2CmpRI8, rSrc1, modImm);
      } else {
        int rTmp = AllocTemp(cUnit);
        res = LoadConstant(cUnit, rTmp, value);
        OpRegReg(cUnit, kOpCmp, rSrc1, rTmp);
        FreeTemp(cUnit, rTmp);
      }
      return res;
    }
    default:
      LOG(FATAL) << "Bad opcode: " << op;
  }

  if (modImm >= 0) {
    return NewLIR3(cUnit, opcode, rDest, rSrc1, modImm);
  } else {
    int rScratch = AllocTemp(cUnit);
    LoadConstant(cUnit, rScratch, value);
    if (EncodingMap[altOpcode].flags & IS_QUAD_OP)
      res = NewLIR4(cUnit, altOpcode, rDest, rSrc1, rScratch, 0);
    else
      res = NewLIR3(cUnit, altOpcode, rDest, rSrc1, rScratch);
    FreeTemp(cUnit, rScratch);
    return res;
  }
}

/* Handle Thumb-only variants here - otherwise punt to OpRegRegImm */
LIR* OpRegImm(CompilationUnit* cUnit, OpKind op, int rDestSrc1, int value)
{
  bool neg = (value < 0);
  int absValue = (neg) ? -value : value;
  bool shortForm = (((absValue & 0xff) == absValue) && ARM_LOWREG(rDestSrc1));
  ArmOpcode opcode = kThumbBkpt;
  switch (op) {
    case kOpAdd:
      if ( !neg && (rDestSrc1 == r13sp) && (value <= 508)) { /* sp */
        DCHECK_EQ((value & 0x3), 0);
        return NewLIR1(cUnit, kThumbAddSpI7, value >> 2);
      } else if (shortForm) {
        opcode = (neg) ? kThumbSubRI8 : kThumbAddRI8;
      }
      break;
    case kOpSub:
      if (!neg && (rDestSrc1 == r13sp) && (value <= 508)) { /* sp */
        DCHECK_EQ((value & 0x3), 0);
        return NewLIR1(cUnit, kThumbSubSpI7, value >> 2);
      } else if (shortForm) {
        opcode = (neg) ? kThumbAddRI8 : kThumbSubRI8;
      }
      break;
    case kOpCmp:
      if (ARM_LOWREG(rDestSrc1) && shortForm)
        opcode = (shortForm) ?  kThumbCmpRI8 : kThumbCmpRR;
      else if (ARM_LOWREG(rDestSrc1))
        opcode = kThumbCmpRR;
      else {
        shortForm = false;
        opcode = kThumbCmpHL;
      }
      break;
    default:
      /* Punt to OpRegRegImm - if bad case catch it there */
      shortForm = false;
      break;
  }
  if (shortForm)
    return NewLIR2(cUnit, opcode, rDestSrc1, absValue);
  else {
    return OpRegRegImm(cUnit, op, rDestSrc1, rDestSrc1, value);
  }
}

/*
 * Determine whether value can be encoded as a Thumb2 floating point
 * immediate.  If not, return -1.  If so return encoded 8-bit value.
 */
static int EncodeImmDoubleHigh(int value)
{
  int res;
  int bitA =  (value & 0x80000000) >> 31;
  int notBitB = (value & 0x40000000) >> 30;
  int bitB =  (value & 0x20000000) >> 29;
  int bSmear =  (value & 0x3fc00000) >> 22;
  int slice =   (value & 0x003f0000) >> 16;
  int zeroes =  (value & 0x0000ffff);
  if (zeroes != 0)
    return -1;
  if (bitB) {
    if ((notBitB != 0) || (bSmear != 0xff))
      return -1;
  } else {
    if ((notBitB != 1) || (bSmear != 0x0))
      return -1;
  }
  res = (bitA << 7) | (bitB << 6) | slice;
  return res;
}

static int EncodeImmDouble(int valLo, int valHi)
{
  int res = -1;
  if (valLo == 0)
    res = EncodeImmDoubleHigh(valHi);
  return res;
}

LIR* LoadConstantValueWide(CompilationUnit* cUnit, int rDestLo, int rDestHi,
               int valLo, int valHi)
{
  int encodedImm = EncodeImmDouble(valLo, valHi);
  LIR* res;
  if (ARM_FPREG(rDestLo)) {
    if (encodedImm >= 0) {
      res = NewLIR2(cUnit, kThumb2Vmovd_IMM8, S2d(rDestLo, rDestHi),
              encodedImm);
    } else {
      LIR* dataTarget = ScanLiteralPoolWide(cUnit->literalList, valLo, valHi);
      if (dataTarget == NULL) {
        dataTarget = AddWideData(cUnit, &cUnit->literalList, valLo, valHi);
      }
      LIR* loadPcRel =
          RawLIR(cUnit, cUnit->currentDalvikOffset, kThumb2Vldrd,
                 S2d(rDestLo, rDestHi), r15pc, 0, 0, 0, dataTarget);
      SetMemRefType(loadPcRel, true, kLiteral);
      loadPcRel->aliasInfo = reinterpret_cast<uintptr_t>(dataTarget);
      AppendLIR(cUnit, loadPcRel);
      res = loadPcRel;
    }
  } else {
    res = LoadConstantNoClobber(cUnit, rDestLo, valLo);
    LoadConstantNoClobber(cUnit, rDestHi, valHi);
  }
  return res;
}

int EncodeShift(int code, int amount) {
  return ((amount & 0x1f) << 2) | code;
}

LIR* LoadBaseIndexed(CompilationUnit* cUnit, int rBase, int rIndex, int rDest,
                     int scale, OpSize size)
{
  bool allLowRegs = ARM_LOWREG(rBase) && ARM_LOWREG(rIndex) && ARM_LOWREG(rDest);
  LIR* load;
  ArmOpcode opcode = kThumbBkpt;
  bool thumbForm = (allLowRegs && (scale == 0));
  int regPtr;

  if (ARM_FPREG(rDest)) {
    if (ARM_SINGLEREG(rDest)) {
      DCHECK((size == kWord) || (size == kSingle));
      opcode = kThumb2Vldrs;
      size = kSingle;
    } else {
      DCHECK(ARM_DOUBLEREG(rDest));
      DCHECK((size == kLong) || (size == kDouble));
      DCHECK_EQ((rDest & 0x1), 0);
      opcode = kThumb2Vldrd;
      size = kDouble;
    }
  } else {
    if (size == kSingle)
      size = kWord;
  }

  switch (size) {
    case kDouble: // fall-through
    case kSingle:
      regPtr = AllocTemp(cUnit);
      if (scale) {
        NewLIR4(cUnit, kThumb2AddRRR, regPtr, rBase, rIndex,
                EncodeShift(kArmLsl, scale));
      } else {
        OpRegRegReg(cUnit, kOpAdd, regPtr, rBase, rIndex);
      }
      load = NewLIR3(cUnit, opcode, rDest, regPtr, 0);
      FreeTemp(cUnit, regPtr);
      return load;
    case kWord:
      opcode = (thumbForm) ? kThumbLdrRRR : kThumb2LdrRRR;
      break;
    case kUnsignedHalf:
      opcode = (thumbForm) ? kThumbLdrhRRR : kThumb2LdrhRRR;
      break;
    case kSignedHalf:
      opcode = (thumbForm) ? kThumbLdrshRRR : kThumb2LdrshRRR;
      break;
    case kUnsignedByte:
      opcode = (thumbForm) ? kThumbLdrbRRR : kThumb2LdrbRRR;
      break;
    case kSignedByte:
      opcode = (thumbForm) ? kThumbLdrsbRRR : kThumb2LdrsbRRR;
      break;
    default:
      LOG(FATAL) << "Bad size: " << size;
  }
  if (thumbForm)
    load = NewLIR3(cUnit, opcode, rDest, rBase, rIndex);
  else
    load = NewLIR4(cUnit, opcode, rDest, rBase, rIndex, scale);

  return load;
}

LIR* StoreBaseIndexed(CompilationUnit* cUnit, int rBase, int rIndex, int rSrc,
                      int scale, OpSize size)
{
  bool allLowRegs = ARM_LOWREG(rBase) && ARM_LOWREG(rIndex) && ARM_LOWREG(rSrc);
  LIR* store;
  ArmOpcode opcode = kThumbBkpt;
  bool thumbForm = (allLowRegs && (scale == 0));
  int regPtr;

  if (ARM_FPREG(rSrc)) {
    if (ARM_SINGLEREG(rSrc)) {
      DCHECK((size == kWord) || (size == kSingle));
      opcode = kThumb2Vstrs;
      size = kSingle;
    } else {
      DCHECK(ARM_DOUBLEREG(rSrc));
      DCHECK((size == kLong) || (size == kDouble));
      DCHECK_EQ((rSrc & 0x1), 0);
      opcode = kThumb2Vstrd;
      size = kDouble;
    }
  } else {
    if (size == kSingle)
      size = kWord;
  }

  switch (size) {
    case kDouble: // fall-through
    case kSingle:
      regPtr = AllocTemp(cUnit);
      if (scale) {
        NewLIR4(cUnit, kThumb2AddRRR, regPtr, rBase, rIndex,
                EncodeShift(kArmLsl, scale));
      } else {
        OpRegRegReg(cUnit, kOpAdd, regPtr, rBase, rIndex);
      }
      store = NewLIR3(cUnit, opcode, rSrc, regPtr, 0);
      FreeTemp(cUnit, regPtr);
      return store;
    case kWord:
      opcode = (thumbForm) ? kThumbStrRRR : kThumb2StrRRR;
      break;
    case kUnsignedHalf:
    case kSignedHalf:
      opcode = (thumbForm) ? kThumbStrhRRR : kThumb2StrhRRR;
      break;
    case kUnsignedByte:
    case kSignedByte:
      opcode = (thumbForm) ? kThumbStrbRRR : kThumb2StrbRRR;
      break;
    default:
      LOG(FATAL) << "Bad size: " << size;
  }
  if (thumbForm)
    store = NewLIR3(cUnit, opcode, rSrc, rBase, rIndex);
  else
    store = NewLIR4(cUnit, opcode, rSrc, rBase, rIndex, scale);

  return store;
}

/*
 * Load value from base + displacement.  Optionally perform null check
 * on base (which must have an associated sReg and MIR).  If not
 * performing null check, incoming MIR can be null.
 */
LIR* LoadBaseDispBody(CompilationUnit* cUnit, int rBase,
                      int displacement, int rDest, int rDestHi, OpSize size,
                      int sReg)
{
  LIR* res;
  LIR* load;
  ArmOpcode opcode = kThumbBkpt;
  bool shortForm = false;
  bool thumb2Form = (displacement < 4092 && displacement >= 0);
  bool allLowRegs = (ARM_LOWREG(rBase) && ARM_LOWREG(rDest));
  int encodedDisp = displacement;
  bool is64bit = false;
  switch (size) {
    case kDouble:
    case kLong:
      is64bit = true;
      if (ARM_FPREG(rDest)) {
        if (ARM_SINGLEREG(rDest)) {
          DCHECK(ARM_FPREG(rDestHi));
          rDest = S2d(rDest, rDestHi);
        }
        opcode = kThumb2Vldrd;
        if (displacement <= 1020) {
          shortForm = true;
          encodedDisp >>= 2;
        }
        break;
      } else {
        res = LoadBaseDispBody(cUnit, rBase, displacement, rDest,
                               -1, kWord, sReg);
        LoadBaseDispBody(cUnit, rBase, displacement + 4, rDestHi,
                         -1, kWord, INVALID_SREG);
        return res;
      }
    case kSingle:
    case kWord:
      if (ARM_FPREG(rDest)) {
        opcode = kThumb2Vldrs;
        if (displacement <= 1020) {
          shortForm = true;
          encodedDisp >>= 2;
        }
        break;
      }
      if (ARM_LOWREG(rDest) && (rBase == r15pc) &&
          (displacement <= 1020) && (displacement >= 0)) {
        shortForm = true;
        encodedDisp >>= 2;
        opcode = kThumbLdrPcRel;
      } else if (ARM_LOWREG(rDest) && (rBase == r13sp) &&
          (displacement <= 1020) && (displacement >= 0)) {
        shortForm = true;
        encodedDisp >>= 2;
        opcode = kThumbLdrSpRel;
      } else if (allLowRegs && displacement < 128 && displacement >= 0) {
        DCHECK_EQ((displacement & 0x3), 0);
        shortForm = true;
        encodedDisp >>= 2;
        opcode = kThumbLdrRRI5;
      } else if (thumb2Form) {
        shortForm = true;
        opcode = kThumb2LdrRRI12;
      }
      break;
    case kUnsignedHalf:
      if (allLowRegs && displacement < 64 && displacement >= 0) {
        DCHECK_EQ((displacement & 0x1), 0);
        shortForm = true;
        encodedDisp >>= 1;
        opcode = kThumbLdrhRRI5;
      } else if (displacement < 4092 && displacement >= 0) {
        shortForm = true;
        opcode = kThumb2LdrhRRI12;
      }
      break;
    case kSignedHalf:
      if (thumb2Form) {
        shortForm = true;
        opcode = kThumb2LdrshRRI12;
      }
      break;
    case kUnsignedByte:
      if (allLowRegs && displacement < 32 && displacement >= 0) {
        shortForm = true;
        opcode = kThumbLdrbRRI5;
      } else if (thumb2Form) {
        shortForm = true;
        opcode = kThumb2LdrbRRI12;
      }
      break;
    case kSignedByte:
      if (thumb2Form) {
        shortForm = true;
        opcode = kThumb2LdrsbRRI12;
      }
      break;
    default:
      LOG(FATAL) << "Bad size: " << size;
  }

  if (shortForm) {
    load = res = NewLIR3(cUnit, opcode, rDest, rBase, encodedDisp);
  } else {
    int regOffset = AllocTemp(cUnit);
    res = LoadConstant(cUnit, regOffset, encodedDisp);
    load = LoadBaseIndexed(cUnit, rBase, regOffset, rDest, 0, size);
    FreeTemp(cUnit, regOffset);
  }

  // TODO: in future may need to differentiate Dalvik accesses w/ spills
  if (rBase == rARM_SP) {
    AnnotateDalvikRegAccess(load, displacement >> 2, true /* isLoad */, is64bit);
  }
  return load;
}

LIR* LoadBaseDisp(CompilationUnit* cUnit, int rBase,
                  int displacement, int rDest, OpSize size, int sReg)
{
  return LoadBaseDispBody(cUnit, rBase, displacement, rDest, -1, size,
                          sReg);
}

 LIR* LoadBaseDispWide(CompilationUnit* cUnit, int rBase,
                       int displacement, int rDestLo, int rDestHi, int sReg)
{
  return LoadBaseDispBody(cUnit, rBase, displacement, rDestLo, rDestHi,
                          kLong, sReg);
}


LIR* StoreBaseDispBody(CompilationUnit* cUnit, int rBase, int displacement,
                       int rSrc, int rSrcHi, OpSize size)
{
  LIR* res, *store;
  ArmOpcode opcode = kThumbBkpt;
  bool shortForm = false;
  bool thumb2Form = (displacement < 4092 && displacement >= 0);
  bool allLowRegs = (ARM_LOWREG(rBase) && ARM_LOWREG(rSrc));
  int encodedDisp = displacement;
  bool is64bit = false;
  switch (size) {
    case kLong:
    case kDouble:
      is64bit = true;
      if (!ARM_FPREG(rSrc)) {
        res = StoreBaseDispBody(cUnit, rBase, displacement, rSrc, -1, kWord);
        StoreBaseDispBody(cUnit, rBase, displacement + 4, rSrcHi, -1, kWord);
        return res;
      }
      if (ARM_SINGLEREG(rSrc)) {
        DCHECK(ARM_FPREG(rSrcHi));
        rSrc = S2d(rSrc, rSrcHi);
      }
      opcode = kThumb2Vstrd;
      if (displacement <= 1020) {
        shortForm = true;
        encodedDisp >>= 2;
      }
      break;
    case kSingle:
    case kWord:
      if (ARM_FPREG(rSrc)) {
        DCHECK(ARM_SINGLEREG(rSrc));
        opcode = kThumb2Vstrs;
        if (displacement <= 1020) {
          shortForm = true;
          encodedDisp >>= 2;
        }
      break;
      }
      if (allLowRegs && displacement < 128 && displacement >= 0) {
        DCHECK_EQ((displacement & 0x3), 0);
        shortForm = true;
        encodedDisp >>= 2;
        opcode = kThumbStrRRI5;
      } else if (thumb2Form) {
        shortForm = true;
        opcode = kThumb2StrRRI12;
      }
      break;
    case kUnsignedHalf:
    case kSignedHalf:
      if (allLowRegs && displacement < 64 && displacement >= 0) {
        DCHECK_EQ((displacement & 0x1), 0);
        shortForm = true;
        encodedDisp >>= 1;
        opcode = kThumbStrhRRI5;
      } else if (thumb2Form) {
        shortForm = true;
        opcode = kThumb2StrhRRI12;
      }
      break;
    case kUnsignedByte:
    case kSignedByte:
      if (allLowRegs && displacement < 32 && displacement >= 0) {
        shortForm = true;
        opcode = kThumbStrbRRI5;
      } else if (thumb2Form) {
        shortForm = true;
        opcode = kThumb2StrbRRI12;
      }
      break;
    default:
      LOG(FATAL) << "Bad size: " << size;
  }
  if (shortForm) {
    store = res = NewLIR3(cUnit, opcode, rSrc, rBase, encodedDisp);
  } else {
    int rScratch = AllocTemp(cUnit);
    res = LoadConstant(cUnit, rScratch, encodedDisp);
    store = StoreBaseIndexed(cUnit, rBase, rScratch, rSrc, 0, size);
    FreeTemp(cUnit, rScratch);
  }

  // TODO: In future, may need to differentiate Dalvik & spill accesses
  if (rBase == rARM_SP) {
    AnnotateDalvikRegAccess(store, displacement >> 2, false /* isLoad */,
                            is64bit);
  }
  return res;
}

LIR* StoreBaseDisp(CompilationUnit* cUnit, int rBase, int displacement,
                   int rSrc, OpSize size)
{
  return StoreBaseDispBody(cUnit, rBase, displacement, rSrc, -1, size);
}

LIR* StoreBaseDispWide(CompilationUnit* cUnit, int rBase, int displacement,
                       int rSrcLo, int rSrcHi)
{
  return StoreBaseDispBody(cUnit, rBase, displacement, rSrcLo, rSrcHi, kLong);
}

void LoadPair(CompilationUnit* cUnit, int base, int lowReg, int highReg)
{
  LoadBaseDispWide(cUnit, base, 0, lowReg, highReg, INVALID_SREG);
}

LIR* FpRegCopy(CompilationUnit* cUnit, int rDest, int rSrc)
{
  int opcode;
  DCHECK_EQ(ARM_DOUBLEREG(rDest), ARM_DOUBLEREG(rSrc));
  if (ARM_DOUBLEREG(rDest)) {
    opcode = kThumb2Vmovd;
  } else {
    if (ARM_SINGLEREG(rDest)) {
      opcode = ARM_SINGLEREG(rSrc) ? kThumb2Vmovs : kThumb2Fmsr;
    } else {
      DCHECK(ARM_SINGLEREG(rSrc));
      opcode = kThumb2Fmrs;
    }
  }
  LIR* res = RawLIR(cUnit, cUnit->currentDalvikOffset, opcode, rDest, rSrc);
  if (!(cUnit->disableOpt & (1 << kSafeOptimizations)) && rDest == rSrc) {
    res->flags.isNop = true;
  }
  return res;
}

LIR* OpThreadMem(CompilationUnit* cUnit, OpKind op, int threadOffset)
{
  LOG(FATAL) << "Unexpected use of OpThreadMem for Arm";
  return NULL;
}

LIR* OpMem(CompilationUnit* cUnit, OpKind op, int rBase, int disp)
{
  LOG(FATAL) << "Unexpected use of OpMem for Arm";
  return NULL;
}

LIR* StoreBaseIndexedDisp(CompilationUnit *cUnit,
                          int rBase, int rIndex, int scale, int displacement,
                          int rSrc, int rSrcHi,
                          OpSize size, int sReg)
{
  LOG(FATAL) << "Unexpected use of StoreBaseIndexedDisp for Arm";
  return NULL;
}

LIR* OpRegMem(CompilationUnit *cUnit, OpKind op, int rDest, int rBase,
              int offset)
{
  LOG(FATAL) << "Unexpected use of OpRegMem for Arm";
  return NULL;
}

LIR* LoadBaseIndexedDisp(CompilationUnit *cUnit,
                         int rBase, int rIndex, int scale, int displacement,
                         int rDest, int rDestHi,
                         OpSize size, int sReg)
{
  LOG(FATAL) << "Unexpected use of LoadBaseIndexedDisp for Arm";
  return NULL;
}

}  // namespace art