contrib/llvm/lib/Target/Hexagon/HexagonBitTracker.cpp

   1 //===--- HexagonBitTracker.cpp --------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "Hexagon.h"
  11 #include "HexagonBitTracker.h"
  12 #include "HexagonInstrInfo.h"
  13 #include "HexagonRegisterInfo.h"
  14 #include "HexagonTargetMachine.h"
  15 #include "llvm/CodeGen/MachineFunction.h"
  16 #include "llvm/CodeGen/MachineInstr.h"
  17 #include "llvm/CodeGen/MachineOperand.h"
  18 #include "llvm/CodeGen/MachineRegisterInfo.h"
  19 #include "llvm/IR/Argument.h"
  20 #include "llvm/IR/Attributes.h"
  21 #include "llvm/IR/Function.h"
  22 #include "llvm/IR/Type.h"
  23 #include "llvm/Support/Debug.h"
  24 #include "llvm/Support/ErrorHandling.h"
  25 #include "llvm/Support/MathExtras.h"
  26 #include "llvm/Support/raw_ostream.h"
  27 #include "llvm/Target/TargetRegisterInfo.h"
  28 #include <cassert>
  29 #include <cstddef>
  30 #include <cstdint>
  31 #include <cstdlib>
  32 #include <utility>
  33 #include <vector>
  34
  35 using namespace llvm;
  36
  37 typedef BitTracker BT;
  38
  39 HexagonEvaluator::HexagonEvaluator(const HexagonRegisterInfo &tri,
  40                                    MachineRegisterInfo &mri,
  41                                    const HexagonInstrInfo &tii,
  42                                    MachineFunction &mf)
  43     : MachineEvaluator(tri, mri), MF(mf), MFI(mf.getFrameInfo()), TII(tii) {
  44   // Populate the VRX map (VR to extension-type).
  45   // Go over all the formal parameters of the function. If a given parameter
  46   // P is sign- or zero-extended, locate the virtual register holding that
  47   // parameter and create an entry in the VRX map indicating the type of ex-
  48   // tension (and the source type).
  49   // This is a bit complicated to do accurately, since the memory layout in-
  50   // formation is necessary to precisely determine whether an aggregate para-
  51   // meter will be passed in a register or in memory. What is given in MRI
  52   // is the association between the physical register that is live-in (i.e.
  53   // holds an argument), and the virtual register that this value will be
  54   // copied into. This, by itself, is not sufficient to map back the virtual
  55   // register to a formal parameter from Function (since consecutive live-ins
  56   // from MRI may not correspond to consecutive formal parameters from Func-
  57   // tion). To avoid the complications with in-memory arguments, only consi-
  58   // der the initial sequence of formal parameters that are known to be
  59   // passed via registers.
  60   unsigned AttrIdx = 0;
  61   unsigned InVirtReg, InPhysReg = 0;
  62   const Function &F = *MF.getFunction();
  63   typedef Function::const_arg_iterator arg_iterator;
  64   for (arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; ++I) {
  65     AttrIdx++;
  66     const Argument &Arg = *I;
  67     Type *ATy = Arg.getType();
  68     unsigned Width = 0;
  69     if (ATy->isIntegerTy())
  70       Width = ATy->getIntegerBitWidth();
  71     else if (ATy->isPointerTy())
  72       Width = 32;
  73     // If pointer size is not set through target data, it will default to
  74     // Module::AnyPointerSize.
  75     if (Width == 0 || Width > 64)
  76       break;
  77     AttributeList Attrs = F.getAttributes();
  78     if (Attrs.hasAttribute(AttrIdx, Attribute::ByVal))
  79       continue;
  80     InPhysReg = getNextPhysReg(InPhysReg, Width);
  81     if (!InPhysReg)
  82       break;
  83     InVirtReg = getVirtRegFor(InPhysReg);
  84     if (!InVirtReg)
  85       continue;
  86     if (Attrs.hasAttribute(AttrIdx, Attribute::SExt))
  87       VRX.insert(std::make_pair(InVirtReg, ExtType(ExtType::SExt, Width)));
  88     else if (Attrs.hasAttribute(AttrIdx, Attribute::ZExt))
  89       VRX.insert(std::make_pair(InVirtReg, ExtType(ExtType::ZExt, Width)));
  90   }
  91 }
  92
  93 BT::BitMask HexagonEvaluator::mask(unsigned Reg, unsigned Sub) const {
  94   using namespace Hexagon;
  95
  96   if (Sub == 0)
  97     return MachineEvaluator::mask(Reg, 0);
  98   const TargetRegisterClass *RC = MRI.getRegClass(Reg);
  99   unsigned ID = RC->getID();
 100   uint16_t RW = getRegBitWidth(RegisterRef(Reg, Sub));
 101   auto &HRI = static_cast<const HexagonRegisterInfo&>(TRI);
 102   bool IsSubLo = (Sub == HRI.getHexagonSubRegIndex(RC, Hexagon::ps_sub_lo));
 103   switch (ID) {
 104     case DoubleRegsRegClassID:
 105     case VecDblRegsRegClassID:
 106     case VecDblRegs128BRegClassID:
 107       return IsSubLo ? BT::BitMask(0, RW-1)
 108                      : BT::BitMask(RW, 2*RW-1);
 109     default:
 110       break;
 111   }
 112 #ifndef NDEBUG
 113   dbgs() << PrintReg(Reg, &TRI, Sub) << '\n';
 114 #endif
 115   llvm_unreachable("Unexpected register/subregister");
 116 }
 117
 118 namespace {
 119
 120 class RegisterRefs {
 121   std::vector<BT::RegisterRef> Vector;
 122
 123 public:
 124   RegisterRefs(const MachineInstr &MI) : Vector(MI.getNumOperands()) {
 125     for (unsigned i = 0, n = Vector.size(); i < n; ++i) {
 126       const MachineOperand &MO = MI.getOperand(i);
 127       if (MO.isReg())
 128         Vector[i] = BT::RegisterRef(MO);
 129       // For indices that don't correspond to registers, the entry will
 130       // remain constructed via the default constructor.
 131     }
 132   }
 133
 134   size_t size() const { return Vector.size(); }
 135
 136   const BT::RegisterRef &operator[](unsigned n) const {
 137     // The main purpose of this operator is to assert with bad argument.
 138     assert(n < Vector.size());
 139     return Vector[n];
 140   }
 141 };
 142
 143 } // end anonymous namespace
 144
 145 bool HexagonEvaluator::evaluate(const MachineInstr &MI,
 146                                 const CellMapType &Inputs,
 147                                 CellMapType &Outputs) const {
 148   using namespace Hexagon;
 149
 150   unsigned NumDefs = 0;
 151
 152   // Sanity verification: there should not be any defs with subregisters.
 153   for (unsigned i = 0, n = MI.getNumOperands(); i < n; ++i) {
 154     const MachineOperand &MO = MI.getOperand(i);
 155     if (!MO.isReg() || !MO.isDef())
 156       continue;
 157     NumDefs++;
 158     assert(MO.getSubReg() == 0);
 159   }
 160
 161   if (NumDefs == 0)
 162     return false;
 163
 164   unsigned Opc = MI.getOpcode();
 165
 166   if (MI.mayLoad()) {
 167     switch (Opc) {
 168       // These instructions may be marked as mayLoad, but they are generating
 169       // immediate values, so skip them.
 170       case CONST32:
 171       case CONST64:
 172         break;
 173       default:
 174         return evaluateLoad(MI, Inputs, Outputs);
 175     }
 176   }
 177
 178   // Check COPY instructions that copy formal parameters into virtual
 179   // registers. Such parameters can be sign- or zero-extended at the
 180   // call site, and we should take advantage of this knowledge. The MRI
 181   // keeps a list of pairs of live-in physical and virtual registers,
 182   // which provides information about which virtual registers will hold
 183   // the argument values. The function will still contain instructions
 184   // defining those virtual registers, and in practice those are COPY
 185   // instructions from a physical to a virtual register. In such cases,
 186   // applying the argument extension to the virtual register can be seen
 187   // as simply mirroring the extension that had already been applied to
 188   // the physical register at the call site. If the defining instruction
 189   // was not a COPY, it would not be clear how to mirror that extension
 190   // on the callee's side. For that reason, only check COPY instructions
 191   // for potential extensions.
 192   if (MI.isCopy()) {
 193     if (evaluateFormalCopy(MI, Inputs, Outputs))
 194       return true;
 195   }
 196
 197   // Beyond this point, if any operand is a global, skip that instruction.
 198   // The reason is that certain instructions that can take an immediate
 199   // operand can also have a global symbol in that operand. To avoid
 200   // checking what kind of operand a given instruction has individually
 201   // for each instruction, do it here. Global symbols as operands gene-
 202   // rally do not provide any useful information.
 203   for (unsigned i = 0, n = MI.getNumOperands(); i < n; ++i) {
 204     const MachineOperand &MO = MI.getOperand(i);
 205     if (MO.isGlobal() || MO.isBlockAddress() || MO.isSymbol() || MO.isJTI() ||
 206         MO.isCPI())
 207       return false;
 208   }
 209
 210   RegisterRefs Reg(MI);
 211 #define op(i) MI.getOperand(i)
 212 #define rc(i) RegisterCell::ref(getCell(Reg[i], Inputs))
 213 #define im(i) MI.getOperand(i).getImm()
 214
 215   // If the instruction has no register operands, skip it.
 216   if (Reg.size() == 0)
 217     return false;
 218
 219   // Record result for register in operand 0.
 220   auto rr0 = [this,Reg] (const BT::RegisterCell &Val, CellMapType &Outputs)
 221         -> bool {
 222     putCell(Reg[0], Val, Outputs);
 223     return true;
 224   };
 225   // Get the cell corresponding to the N-th operand.
 226   auto cop = [this, &Reg, &MI, &Inputs](unsigned N,
 227                                         uint16_t W) -> BT::RegisterCell {
 228     const MachineOperand &Op = MI.getOperand(N);
 229     if (Op.isImm())
 230       return eIMM(Op.getImm(), W);
 231     if (!Op.isReg())
 232       return RegisterCell::self(0, W);
 233     assert(getRegBitWidth(Reg[N]) == W && "Register width mismatch");
 234     return rc(N);
 235   };
 236   // Extract RW low bits of the cell.
 237   auto lo = [this] (const BT::RegisterCell &RC, uint16_t RW)
 238         -> BT::RegisterCell {
 239     assert(RW <= RC.width());
 240     return eXTR(RC, 0, RW);
 241   };
 242   // Extract RW high bits of the cell.
 243   auto hi = [this] (const BT::RegisterCell &RC, uint16_t RW)
 244         -> BT::RegisterCell {
 245     uint16_t W = RC.width();
 246     assert(RW <= W);
 247     return eXTR(RC, W-RW, W);
 248   };
 249   // Extract N-th halfword (counting from the least significant position).
 250   auto half = [this] (const BT::RegisterCell &RC, unsigned N)
 251         -> BT::RegisterCell {
 252     assert(N*16+16 <= RC.width());
 253     return eXTR(RC, N*16, N*16+16);
 254   };
 255   // Shuffle bits (pick even/odd from cells and merge into result).
 256   auto shuffle = [this] (const BT::RegisterCell &Rs, const BT::RegisterCell &Rt,
 257                          uint16_t BW, bool Odd) -> BT::RegisterCell {
 258     uint16_t I = Odd, Ws = Rs.width();
 259     assert(Ws == Rt.width());
 260     RegisterCell RC = eXTR(Rt, I*BW, I*BW+BW).cat(eXTR(Rs, I*BW, I*BW+BW));
 261     I += 2;
 262     while (I*BW < Ws) {
 263       RC.cat(eXTR(Rt, I*BW, I*BW+BW)).cat(eXTR(Rs, I*BW, I*BW+BW));
 264       I += 2;
 265     }
 266     return RC;
 267   };
 268
 269   // The bitwidth of the 0th operand. In most (if not all) of the
 270   // instructions below, the 0th operand is the defined register.
 271   // Pre-compute the bitwidth here, because it is needed in many cases
 272   // cases below.
 273   uint16_t W0 = (Reg[0].Reg != 0) ? getRegBitWidth(Reg[0]) : 0;
 274
 275   // Register id of the 0th operand. It can be 0.
 276   unsigned Reg0 = Reg[0].Reg;
 277
 278   switch (Opc) {
 279     // Transfer immediate:
 280
 281     case A2_tfrsi:
 282     case A2_tfrpi:
 283     case CONST32:
 284     case CONST64:
 285       return rr0(eIMM(im(1), W0), Outputs);
 286     case PS_false:
 287       return rr0(RegisterCell(W0).fill(0, W0, BT::BitValue::Zero), Outputs);
 288     case PS_true:
 289       return rr0(RegisterCell(W0).fill(0, W0, BT::BitValue::One), Outputs);
 290     case PS_fi: {
 291       int FI = op(1).getIndex();
 292       int Off = op(2).getImm();
 293       unsigned A = MFI.getObjectAlignment(FI) + std::abs(Off);
 294       unsigned L = Log2_32(A);
 295       RegisterCell RC = RegisterCell::self(Reg[0].Reg, W0);
 296       RC.fill(0, L, BT::BitValue::Zero);
 297       return rr0(RC, Outputs);
 298     }
 299
 300     // Transfer register:
 301
 302     case A2_tfr:
 303     case A2_tfrp:
 304     case C2_pxfer_map:
 305       return rr0(rc(1), Outputs);
 306     case C2_tfrpr: {
 307       uint16_t RW = W0;
 308       uint16_t PW = 8; // XXX Pred size: getRegBitWidth(Reg[1]);
 309       assert(PW <= RW);
 310       RegisterCell PC = eXTR(rc(1), 0, PW);
 311       RegisterCell RC = RegisterCell(RW).insert(PC, BT::BitMask(0, PW-1));
 312       RC.fill(PW, RW, BT::BitValue::Zero);
 313       return rr0(RC, Outputs);
 314     }
 315     case C2_tfrrp: {
 316       RegisterCell RC = RegisterCell::self(Reg[0].Reg, W0);
 317       W0 = 8; // XXX Pred size
 318       return rr0(eINS(RC, eXTR(rc(1), 0, W0), 0), Outputs);
 319     }
 320
 321     // Arithmetic:
 322
 323     case A2_abs:
 324     case A2_absp:
 325       // TODO
 326       break;
 327
 328     case A2_addsp: {
 329       uint16_t W1 = getRegBitWidth(Reg[1]);
 330       assert(W0 == 64 && W1 == 32);
 331       RegisterCell CW = RegisterCell(W0).insert(rc(1), BT::BitMask(0, W1-1));
 332       RegisterCell RC = eADD(eSXT(CW, W1), rc(2));
 333       return rr0(RC, Outputs);
 334     }
 335     case A2_add:
 336     case A2_addp:
 337       return rr0(eADD(rc(1), rc(2)), Outputs);
 338     case A2_addi:
 339       return rr0(eADD(rc(1), eIMM(im(2), W0)), Outputs);
 340     case S4_addi_asl_ri: {
 341       RegisterCell RC = eADD(eIMM(im(1), W0), eASL(rc(2), im(3)));
 342       return rr0(RC, Outputs);
 343     }
 344     case S4_addi_lsr_ri: {
 345       RegisterCell RC = eADD(eIMM(im(1), W0), eLSR(rc(2), im(3)));
 346       return rr0(RC, Outputs);
 347     }
 348     case S4_addaddi: {
 349       RegisterCell RC = eADD(rc(1), eADD(rc(2), eIMM(im(3), W0)));
 350       return rr0(RC, Outputs);
 351     }
 352     case M4_mpyri_addi: {
 353       RegisterCell M = eMLS(rc(2), eIMM(im(3), W0));
 354       RegisterCell RC = eADD(eIMM(im(1), W0), lo(M, W0));
 355       return rr0(RC, Outputs);
 356     }
 357     case M4_mpyrr_addi: {
 358       RegisterCell M = eMLS(rc(2), rc(3));
 359       RegisterCell RC = eADD(eIMM(im(1), W0), lo(M, W0));
 360       return rr0(RC, Outputs);
 361     }
 362     case M4_mpyri_addr_u2: {
 363       RegisterCell M = eMLS(eIMM(im(2), W0), rc(3));
 364       RegisterCell RC = eADD(rc(1), lo(M, W0));
 365       return rr0(RC, Outputs);
 366     }
 367     case M4_mpyri_addr: {
 368       RegisterCell M = eMLS(rc(2), eIMM(im(3), W0));
 369       RegisterCell RC = eADD(rc(1), lo(M, W0));
 370       return rr0(RC, Outputs);
 371     }
 372     case M4_mpyrr_addr: {
 373       RegisterCell M = eMLS(rc(2), rc(3));
 374       RegisterCell RC = eADD(rc(1), lo(M, W0));
 375       return rr0(RC, Outputs);
 376     }
 377     case S4_subaddi: {
 378       RegisterCell RC = eADD(rc(1), eSUB(eIMM(im(2), W0), rc(3)));
 379       return rr0(RC, Outputs);
 380     }
 381     case M2_accii: {
 382       RegisterCell RC = eADD(rc(1), eADD(rc(2), eIMM(im(3), W0)));
 383       return rr0(RC, Outputs);
 384     }
 385     case M2_acci: {
 386       RegisterCell RC = eADD(rc(1), eADD(rc(2), rc(3)));
 387       return rr0(RC, Outputs);
 388     }
 389     case M2_subacc: {
 390       RegisterCell RC = eADD(rc(1), eSUB(rc(2), rc(3)));
 391       return rr0(RC, Outputs);
 392     }
 393     case S2_addasl_rrri: {
 394       RegisterCell RC = eADD(rc(1), eASL(rc(2), im(3)));
 395       return rr0(RC, Outputs);
 396     }
 397     case C4_addipc: {
 398       RegisterCell RPC = RegisterCell::self(Reg[0].Reg, W0);
 399       RPC.fill(0, 2, BT::BitValue::Zero);
 400       return rr0(eADD(RPC, eIMM(im(2), W0)), Outputs);
 401     }
 402     case A2_sub:
 403     case A2_subp:
 404       return rr0(eSUB(rc(1), rc(2)), Outputs);
 405     case A2_subri:
 406       return rr0(eSUB(eIMM(im(1), W0), rc(2)), Outputs);
 407     case S4_subi_asl_ri: {
 408       RegisterCell RC = eSUB(eIMM(im(1), W0), eASL(rc(2), im(3)));
 409       return rr0(RC, Outputs);
 410     }
 411     case S4_subi_lsr_ri: {
 412       RegisterCell RC = eSUB(eIMM(im(1), W0), eLSR(rc(2), im(3)));
 413       return rr0(RC, Outputs);
 414     }
 415     case M2_naccii: {
 416       RegisterCell RC = eSUB(rc(1), eADD(rc(2), eIMM(im(3), W0)));
 417       return rr0(RC, Outputs);
 418     }
 419     case M2_nacci: {
 420       RegisterCell RC = eSUB(rc(1), eADD(rc(2), rc(3)));
 421       return rr0(RC, Outputs);
 422     }
 423     // 32-bit negation is done by "Rd = A2_subri 0, Rs"
 424     case A2_negp:
 425       return rr0(eSUB(eIMM(0, W0), rc(1)), Outputs);
 426
 427     case M2_mpy_up: {
 428       RegisterCell M = eMLS(rc(1), rc(2));
 429       return rr0(hi(M, W0), Outputs);
 430     }
 431     case M2_dpmpyss_s0:
 432       return rr0(eMLS(rc(1), rc(2)), Outputs);
 433     case M2_dpmpyss_acc_s0:
 434       return rr0(eADD(rc(1), eMLS(rc(2), rc(3))), Outputs);
 435     case M2_dpmpyss_nac_s0:
 436       return rr0(eSUB(rc(1), eMLS(rc(2), rc(3))), Outputs);
 437     case M2_mpyi: {
 438       RegisterCell M = eMLS(rc(1), rc(2));
 439       return rr0(lo(M, W0), Outputs);
 440     }
 441     case M2_macsip: {
 442       RegisterCell M = eMLS(rc(2), eIMM(im(3), W0));
 443       RegisterCell RC = eADD(rc(1), lo(M, W0));
 444       return rr0(RC, Outputs);
 445     }
 446     case M2_macsin: {
 447       RegisterCell M = eMLS(rc(2), eIMM(im(3), W0));
 448       RegisterCell RC = eSUB(rc(1), lo(M, W0));
 449       return rr0(RC, Outputs);
 450     }
 451     case M2_maci: {
 452       RegisterCell M = eMLS(rc(2), rc(3));
 453       RegisterCell RC = eADD(rc(1), lo(M, W0));
 454       return rr0(RC, Outputs);
 455     }
 456     case M2_mpysmi: {
 457       RegisterCell M = eMLS(rc(1), eIMM(im(2), W0));
 458       return rr0(lo(M, 32), Outputs);
 459     }
 460     case M2_mpysin: {
 461       RegisterCell M = eMLS(rc(1), eIMM(-im(2), W0));
 462       return rr0(lo(M, 32), Outputs);
 463     }
 464     case M2_mpysip: {
 465       RegisterCell M = eMLS(rc(1), eIMM(im(2), W0));
 466       return rr0(lo(M, 32), Outputs);
 467     }
 468     case M2_mpyu_up: {
 469       RegisterCell M = eMLU(rc(1), rc(2));
 470       return rr0(hi(M, W0), Outputs);
 471     }
 472     case M2_dpmpyuu_s0:
 473       return rr0(eMLU(rc(1), rc(2)), Outputs);
 474     case M2_dpmpyuu_acc_s0:
 475       return rr0(eADD(rc(1), eMLU(rc(2), rc(3))), Outputs);
 476     case M2_dpmpyuu_nac_s0:
 477       return rr0(eSUB(rc(1), eMLU(rc(2), rc(3))), Outputs);
 478     //case M2_mpysu_up:
 479
 480     // Logical/bitwise:
 481
 482     case A2_andir:
 483       return rr0(eAND(rc(1), eIMM(im(2), W0)), Outputs);
 484     case A2_and:
 485     case A2_andp:
 486       return rr0(eAND(rc(1), rc(2)), Outputs);
 487     case A4_andn:
 488     case A4_andnp:
 489       return rr0(eAND(rc(1), eNOT(rc(2))), Outputs);
 490     case S4_andi_asl_ri: {
 491       RegisterCell RC = eAND(eIMM(im(1), W0), eASL(rc(2), im(3)));
 492       return rr0(RC, Outputs);
 493     }
 494     case S4_andi_lsr_ri: {
 495       RegisterCell RC = eAND(eIMM(im(1), W0), eLSR(rc(2), im(3)));
 496       return rr0(RC, Outputs);
 497     }
 498     case M4_and_and:
 499       return rr0(eAND(rc(1), eAND(rc(2), rc(3))), Outputs);
 500     case M4_and_andn:
 501       return rr0(eAND(rc(1), eAND(rc(2), eNOT(rc(3)))), Outputs);
 502     case M4_and_or:
 503       return rr0(eAND(rc(1), eORL(rc(2), rc(3))), Outputs);
 504     case M4_and_xor:
 505       return rr0(eAND(rc(1), eXOR(rc(2), rc(3))), Outputs);
 506     case A2_orir:
 507       return rr0(eORL(rc(1), eIMM(im(2), W0)), Outputs);
 508     case A2_or:
 509     case A2_orp:
 510       return rr0(eORL(rc(1), rc(2)), Outputs);
 511     case A4_orn:
 512     case A4_ornp:
 513       return rr0(eORL(rc(1), eNOT(rc(2))), Outputs);
 514     case S4_ori_asl_ri: {
 515       RegisterCell RC = eORL(eIMM(im(1), W0), eASL(rc(2), im(3)));
 516       return rr0(RC, Outputs);
 517     }
 518     case S4_ori_lsr_ri: {
 519       RegisterCell RC = eORL(eIMM(im(1), W0), eLSR(rc(2), im(3)));
 520       return rr0(RC, Outputs);
 521     }
 522     case M4_or_and:
 523       return rr0(eORL(rc(1), eAND(rc(2), rc(3))), Outputs);
 524     case M4_or_andn:
 525       return rr0(eORL(rc(1), eAND(rc(2), eNOT(rc(3)))), Outputs);
 526     case S4_or_andi:
 527     case S4_or_andix: {
 528       RegisterCell RC = eORL(rc(1), eAND(rc(2), eIMM(im(3), W0)));
 529       return rr0(RC, Outputs);
 530     }
 531     case S4_or_ori: {
 532       RegisterCell RC = eORL(rc(1), eORL(rc(2), eIMM(im(3), W0)));
 533       return rr0(RC, Outputs);
 534     }
 535     case M4_or_or:
 536       return rr0(eORL(rc(1), eORL(rc(2), rc(3))), Outputs);
 537     case M4_or_xor:
 538       return rr0(eORL(rc(1), eXOR(rc(2), rc(3))), Outputs);
 539     case A2_xor:
 540     case A2_xorp:
 541       return rr0(eXOR(rc(1), rc(2)), Outputs);
 542     case M4_xor_and:
 543       return rr0(eXOR(rc(1), eAND(rc(2), rc(3))), Outputs);
 544     case M4_xor_andn:
 545       return rr0(eXOR(rc(1), eAND(rc(2), eNOT(rc(3)))), Outputs);
 546     case M4_xor_or:
 547       return rr0(eXOR(rc(1), eORL(rc(2), rc(3))), Outputs);
 548     case M4_xor_xacc:
 549       return rr0(eXOR(rc(1), eXOR(rc(2), rc(3))), Outputs);
 550     case A2_not:
 551     case A2_notp:
 552       return rr0(eNOT(rc(1)), Outputs);
 553
 554     case S2_asl_i_r:
 555     case S2_asl_i_p:
 556       return rr0(eASL(rc(1), im(2)), Outputs);
 557     case A2_aslh:
 558       return rr0(eASL(rc(1), 16), Outputs);
 559     case S2_asl_i_r_acc:
 560     case S2_asl_i_p_acc:
 561       return rr0(eADD(rc(1), eASL(rc(2), im(3))), Outputs);
 562     case S2_asl_i_r_nac:
 563     case S2_asl_i_p_nac:
 564       return rr0(eSUB(rc(1), eASL(rc(2), im(3))), Outputs);
 565     case S2_asl_i_r_and:
 566     case S2_asl_i_p_and:
 567       return rr0(eAND(rc(1), eASL(rc(2), im(3))), Outputs);
 568     case S2_asl_i_r_or:
 569     case S2_asl_i_p_or:
 570       return rr0(eORL(rc(1), eASL(rc(2), im(3))), Outputs);
 571     case S2_asl_i_r_xacc:
 572     case S2_asl_i_p_xacc:
 573       return rr0(eXOR(rc(1), eASL(rc(2), im(3))), Outputs);
 574     case S2_asl_i_vh:
 575     case S2_asl_i_vw:
 576       // TODO
 577       break;
 578
 579     case S2_asr_i_r:
 580     case S2_asr_i_p:
 581       return rr0(eASR(rc(1), im(2)), Outputs);
 582     case A2_asrh:
 583       return rr0(eASR(rc(1), 16), Outputs);
 584     case S2_asr_i_r_acc:
 585     case S2_asr_i_p_acc:
 586       return rr0(eADD(rc(1), eASR(rc(2), im(3))), Outputs);
 587     case S2_asr_i_r_nac:
 588     case S2_asr_i_p_nac:
 589       return rr0(eSUB(rc(1), eASR(rc(2), im(3))), Outputs);
 590     case S2_asr_i_r_and:
 591     case S2_asr_i_p_and:
 592       return rr0(eAND(rc(1), eASR(rc(2), im(3))), Outputs);
 593     case S2_asr_i_r_or:
 594     case S2_asr_i_p_or:
 595       return rr0(eORL(rc(1), eASR(rc(2), im(3))), Outputs);
 596     case S2_asr_i_r_rnd: {
 597       // The input is first sign-extended to 64 bits, then the output
 598       // is truncated back to 32 bits.
 599       assert(W0 == 32);
 600       RegisterCell XC = eSXT(rc(1).cat(eIMM(0, W0)), W0);
 601       RegisterCell RC = eASR(eADD(eASR(XC, im(2)), eIMM(1, 2*W0)), 1);
 602       return rr0(eXTR(RC, 0, W0), Outputs);
 603     }
 604     case S2_asr_i_r_rnd_goodsyntax: {
 605       int64_t S = im(2);
 606       if (S == 0)
 607         return rr0(rc(1), Outputs);
 608       // Result: S2_asr_i_r_rnd Rs, u5-1
 609       RegisterCell XC = eSXT(rc(1).cat(eIMM(0, W0)), W0);
 610       RegisterCell RC = eLSR(eADD(eASR(XC, S-1), eIMM(1, 2*W0)), 1);
 611       return rr0(eXTR(RC, 0, W0), Outputs);
 612     }
 613     case S2_asr_r_vh:
 614     case S2_asr_i_vw:
 615     case S2_asr_i_svw_trun:
 616       // TODO
 617       break;
 618
 619     case S2_lsr_i_r:
 620     case S2_lsr_i_p:
 621       return rr0(eLSR(rc(1), im(2)), Outputs);
 622     case S2_lsr_i_r_acc:
 623     case S2_lsr_i_p_acc:
 624       return rr0(eADD(rc(1), eLSR(rc(2), im(3))), Outputs);
 625     case S2_lsr_i_r_nac:
 626     case S2_lsr_i_p_nac:
 627       return rr0(eSUB(rc(1), eLSR(rc(2), im(3))), Outputs);
 628     case S2_lsr_i_r_and:
 629     case S2_lsr_i_p_and:
 630       return rr0(eAND(rc(1), eLSR(rc(2), im(3))), Outputs);
 631     case S2_lsr_i_r_or:
 632     case S2_lsr_i_p_or:
 633       return rr0(eORL(rc(1), eLSR(rc(2), im(3))), Outputs);
 634     case S2_lsr_i_r_xacc:
 635     case S2_lsr_i_p_xacc:
 636       return rr0(eXOR(rc(1), eLSR(rc(2), im(3))), Outputs);
 637
 638     case S2_clrbit_i: {
 639       RegisterCell RC = rc(1);
 640       RC[im(2)] = BT::BitValue::Zero;
 641       return rr0(RC, Outputs);
 642     }
 643     case S2_setbit_i: {
 644       RegisterCell RC = rc(1);
 645       RC[im(2)] = BT::BitValue::One;
 646       return rr0(RC, Outputs);
 647     }
 648     case S2_togglebit_i: {
 649       RegisterCell RC = rc(1);
 650       uint16_t BX = im(2);
 651       RC[BX] = RC[BX].is(0) ? BT::BitValue::One
 652                             : RC[BX].is(1) ? BT::BitValue::Zero
 653                                            : BT::BitValue::self();
 654       return rr0(RC, Outputs);
 655     }
 656
 657     case A4_bitspliti: {
 658       uint16_t W1 = getRegBitWidth(Reg[1]);
 659       uint16_t BX = im(2);
 660       // Res.uw[1] = Rs[bx+1:], Res.uw[0] = Rs[0:bx]
 661       const BT::BitValue Zero = BT::BitValue::Zero;
 662       RegisterCell RZ = RegisterCell(W0).fill(BX, W1, Zero)
 663                                         .fill(W1+(W1-BX), W0, Zero);
 664       RegisterCell BF1 = eXTR(rc(1), 0, BX), BF2 = eXTR(rc(1), BX, W1);
 665       RegisterCell RC = eINS(eINS(RZ, BF1, 0), BF2, W1);
 666       return rr0(RC, Outputs);
 667     }
 668     case S4_extract:
 669     case S4_extractp:
 670     case S2_extractu:
 671     case S2_extractup: {
 672       uint16_t Wd = im(2), Of = im(3);
 673       assert(Wd <= W0);
 674       if (Wd == 0)
 675         return rr0(eIMM(0, W0), Outputs);
 676       // If the width extends beyond the register size, pad the register
 677       // with 0 bits.
 678       RegisterCell Pad = (Wd+Of > W0) ? rc(1).cat(eIMM(0, Wd+Of-W0)) : rc(1);
 679       RegisterCell Ext = eXTR(Pad, Of, Wd+Of);
 680       // Ext is short, need to extend it with 0s or sign bit.
 681       RegisterCell RC = RegisterCell(W0).insert(Ext, BT::BitMask(0, Wd-1));
 682       if (Opc == S2_extractu || Opc == S2_extractup)
 683         return rr0(eZXT(RC, Wd), Outputs);
 684       return rr0(eSXT(RC, Wd), Outputs);
 685     }
 686     case S2_insert:
 687     case S2_insertp: {
 688       uint16_t Wd = im(3), Of = im(4);
 689       assert(Wd < W0 && Of < W0);
 690       // If Wd+Of exceeds W0, the inserted bits are truncated.
 691       if (Wd+Of > W0)
 692         Wd = W0-Of;
 693       if (Wd == 0)
 694         return rr0(rc(1), Outputs);
 695       return rr0(eINS(rc(1), eXTR(rc(2), 0, Wd), Of), Outputs);
 696     }
 697
 698     // Bit permutations:
 699
 700     case A2_combineii:
 701     case A4_combineii:
 702     case A4_combineir:
 703     case A4_combineri:
 704     case A2_combinew:
 705     case V6_vcombine:
 706     case V6_vcombine_128B:
 707       assert(W0 % 2 == 0);
 708       return rr0(cop(2, W0/2).cat(cop(1, W0/2)), Outputs);
 709     case A2_combine_ll:
 710     case A2_combine_lh:
 711     case A2_combine_hl:
 712     case A2_combine_hh: {
 713       assert(W0 == 32);
 714       assert(getRegBitWidth(Reg[1]) == 32 && getRegBitWidth(Reg[2]) == 32);
 715       // Low half in the output is 0 for _ll and _hl, 1 otherwise:
 716       unsigned LoH = !(Opc == A2_combine_ll || Opc == A2_combine_hl);
 717       // High half in the output is 0 for _ll and _lh, 1 otherwise:
 718       unsigned HiH = !(Opc == A2_combine_ll || Opc == A2_combine_lh);
 719       RegisterCell R1 = rc(1);
 720       RegisterCell R2 = rc(2);
 721       RegisterCell RC = half(R2, LoH).cat(half(R1, HiH));
 722       return rr0(RC, Outputs);
 723     }
 724     case S2_packhl: {
 725       assert(W0 == 64);
 726       assert(getRegBitWidth(Reg[1]) == 32 && getRegBitWidth(Reg[2]) == 32);
 727       RegisterCell R1 = rc(1);
 728       RegisterCell R2 = rc(2);
 729       RegisterCell RC = half(R2, 0).cat(half(R1, 0)).cat(half(R2, 1))
 730                                    .cat(half(R1, 1));
 731       return rr0(RC, Outputs);
 732     }
 733     case S2_shuffeb: {
 734       RegisterCell RC = shuffle(rc(1), rc(2), 8, false);
 735       return rr0(RC, Outputs);
 736     }
 737     case S2_shuffeh: {
 738       RegisterCell RC = shuffle(rc(1), rc(2), 16, false);
 739       return rr0(RC, Outputs);
 740     }
 741     case S2_shuffob: {
 742       RegisterCell RC = shuffle(rc(1), rc(2), 8, true);
 743       return rr0(RC, Outputs);
 744     }
 745     case S2_shuffoh: {
 746       RegisterCell RC = shuffle(rc(1), rc(2), 16, true);
 747       return rr0(RC, Outputs);
 748     }
 749     case C2_mask: {
 750       uint16_t WR = W0;
 751       uint16_t WP = 8; // XXX Pred size: getRegBitWidth(Reg[1]);
 752       assert(WR == 64 && WP == 8);
 753       RegisterCell R1 = rc(1);
 754       RegisterCell RC(WR);
 755       for (uint16_t i = 0; i < WP; ++i) {
 756         const BT::BitValue &V = R1[i];
 757         BT::BitValue F = (V.is(0) || V.is(1)) ? V : BT::BitValue::self();
 758         RC.fill(i*8, i*8+8, F);
 759       }
 760       return rr0(RC, Outputs);
 761     }
 762
 763     // Mux:
 764
 765     case C2_muxii:
 766     case C2_muxir:
 767     case C2_muxri:
 768     case C2_mux: {
 769       BT::BitValue PC0 = rc(1)[0];
 770       RegisterCell R2 = cop(2, W0);
 771       RegisterCell R3 = cop(3, W0);
 772       if (PC0.is(0) || PC0.is(1))
 773         return rr0(RegisterCell::ref(PC0 ? R2 : R3), Outputs);
 774       R2.meet(R3, Reg[0].Reg);
 775       return rr0(R2, Outputs);
 776     }
 777     case C2_vmux:
 778       // TODO
 779       break;
 780
 781     // Sign- and zero-extension:
 782
 783     case A2_sxtb:
 784       return rr0(eSXT(rc(1), 8), Outputs);
 785     case A2_sxth:
 786       return rr0(eSXT(rc(1), 16), Outputs);
 787     case A2_sxtw: {
 788       uint16_t W1 = getRegBitWidth(Reg[1]);
 789       assert(W0 == 64 && W1 == 32);
 790       RegisterCell RC = eSXT(rc(1).cat(eIMM(0, W1)), W1);
 791       return rr0(RC, Outputs);
 792     }
 793     case A2_zxtb:
 794       return rr0(eZXT(rc(1), 8), Outputs);
 795     case A2_zxth:
 796       return rr0(eZXT(rc(1), 16), Outputs);
 797
 798     // Saturations
 799
 800     case A2_satb:
 801       return rr0(eSXT(RegisterCell::self(0, W0).regify(Reg0), 8), Outputs);
 802     case A2_sath:
 803       return rr0(eSXT(RegisterCell::self(0, W0).regify(Reg0), 16), Outputs);
 804     case A2_satub:
 805       return rr0(eZXT(RegisterCell::self(0, W0).regify(Reg0), 8), Outputs);
 806     case A2_satuh:
 807       return rr0(eZXT(RegisterCell::self(0, W0).regify(Reg0), 16), Outputs);
 808
 809     // Bit count:
 810
 811     case S2_cl0:
 812     case S2_cl0p:
 813       // Always produce a 32-bit result.
 814       return rr0(eCLB(rc(1), false/*bit*/, 32), Outputs);
 815     case S2_cl1:
 816     case S2_cl1p:
 817       return rr0(eCLB(rc(1), true/*bit*/, 32), Outputs);
 818     case S2_clb:
 819     case S2_clbp: {
 820       uint16_t W1 = getRegBitWidth(Reg[1]);
 821       RegisterCell R1 = rc(1);
 822       BT::BitValue TV = R1[W1-1];
 823       if (TV.is(0) || TV.is(1))
 824         return rr0(eCLB(R1, TV, 32), Outputs);
 825       break;
 826     }
 827     case S2_ct0:
 828     case S2_ct0p:
 829       return rr0(eCTB(rc(1), false/*bit*/, 32), Outputs);
 830     case S2_ct1:
 831     case S2_ct1p:
 832       return rr0(eCTB(rc(1), true/*bit*/, 32), Outputs);
 833     case S5_popcountp:
 834       // TODO
 835       break;
 836
 837     case C2_all8: {
 838       RegisterCell P1 = rc(1);
 839       bool Has0 = false, All1 = true;
 840       for (uint16_t i = 0; i < 8/*XXX*/; ++i) {
 841         if (!P1[i].is(1))
 842           All1 = false;
 843         if (!P1[i].is(0))
 844           continue;
 845         Has0 = true;
 846         break;
 847       }
 848       if (!Has0 && !All1)
 849         break;
 850       RegisterCell RC(W0);
 851       RC.fill(0, W0, (All1 ? BT::BitValue::One : BT::BitValue::Zero));
 852       return rr0(RC, Outputs);
 853     }
 854     case C2_any8: {
 855       RegisterCell P1 = rc(1);
 856       bool Has1 = false, All0 = true;
 857       for (uint16_t i = 0; i < 8/*XXX*/; ++i) {
 858         if (!P1[i].is(0))
 859           All0 = false;
 860         if (!P1[i].is(1))
 861           continue;
 862         Has1 = true;
 863         break;
 864       }
 865       if (!Has1 && !All0)
 866         break;
 867       RegisterCell RC(W0);
 868       RC.fill(0, W0, (Has1 ? BT::BitValue::One : BT::BitValue::Zero));
 869       return rr0(RC, Outputs);
 870     }
 871     case C2_and:
 872       return rr0(eAND(rc(1), rc(2)), Outputs);
 873     case C2_andn:
 874       return rr0(eAND(rc(1), eNOT(rc(2))), Outputs);
 875     case C2_not:
 876       return rr0(eNOT(rc(1)), Outputs);
 877     case C2_or:
 878       return rr0(eORL(rc(1), rc(2)), Outputs);
 879     case C2_orn:
 880       return rr0(eORL(rc(1), eNOT(rc(2))), Outputs);
 881     case C2_xor:
 882       return rr0(eXOR(rc(1), rc(2)), Outputs);
 883     case C4_and_and:
 884       return rr0(eAND(rc(1), eAND(rc(2), rc(3))), Outputs);
 885     case C4_and_andn:
 886       return rr0(eAND(rc(1), eAND(rc(2), eNOT(rc(3)))), Outputs);
 887     case C4_and_or:
 888       return rr0(eAND(rc(1), eORL(rc(2), rc(3))), Outputs);
 889     case C4_and_orn:
 890       return rr0(eAND(rc(1), eORL(rc(2), eNOT(rc(3)))), Outputs);
 891     case C4_or_and:
 892       return rr0(eORL(rc(1), eAND(rc(2), rc(3))), Outputs);
 893     case C4_or_andn:
 894       return rr0(eORL(rc(1), eAND(rc(2), eNOT(rc(3)))), Outputs);
 895     case C4_or_or:
 896       return rr0(eORL(rc(1), eORL(rc(2), rc(3))), Outputs);
 897     case C4_or_orn:
 898       return rr0(eORL(rc(1), eORL(rc(2), eNOT(rc(3)))), Outputs);
 899     case C2_bitsclr:
 900     case C2_bitsclri:
 901     case C2_bitsset:
 902     case C4_nbitsclr:
 903     case C4_nbitsclri:
 904     case C4_nbitsset:
 905       // TODO
 906       break;
 907     case S2_tstbit_i:
 908     case S4_ntstbit_i: {
 909       BT::BitValue V = rc(1)[im(2)];
 910       if (V.is(0) || V.is(1)) {
 911         // If instruction is S2_tstbit_i, test for 1, otherwise test for 0.
 912         bool TV = (Opc == S2_tstbit_i);
 913         BT::BitValue F = V.is(TV) ? BT::BitValue::One : BT::BitValue::Zero;
 914         return rr0(RegisterCell(W0).fill(0, W0, F), Outputs);
 915       }
 916       break;
 917     }
 918
 919     default:
 920       return MachineEvaluator::evaluate(MI, Inputs, Outputs);
 921   }
 922   #undef im
 923   #undef rc
 924   #undef op
 925   return false;
 926 }
 927
 928 bool HexagonEvaluator::evaluate(const MachineInstr &BI,
 929                                 const CellMapType &Inputs,
 930                                 BranchTargetList &Targets,
 931                                 bool &FallsThru) const {
 932   // We need to evaluate one branch at a time. TII::analyzeBranch checks
 933   // all the branches in a basic block at once, so we cannot use it.
 934   unsigned Opc = BI.getOpcode();
 935   bool SimpleBranch = false;
 936   bool Negated = false;
 937   switch (Opc) {
 938     case Hexagon::J2_jumpf:
 939     case Hexagon::J2_jumpfpt:
 940     case Hexagon::J2_jumpfnew:
 941     case Hexagon::J2_jumpfnewpt:
 942       Negated = true;
 943     case Hexagon::J2_jumpt:
 944     case Hexagon::J2_jumptpt:
 945     case Hexagon::J2_jumptnew:
 946     case Hexagon::J2_jumptnewpt:
 947       // Simple branch:  if([!]Pn) jump ...
 948       // i.e. Op0 = predicate, Op1 = branch target.
 949       SimpleBranch = true;
 950       break;
 951     case Hexagon::J2_jump:
 952       Targets.insert(BI.getOperand(0).getMBB());
 953       FallsThru = false;
 954       return true;
 955     default:
 956       // If the branch is of unknown type, assume that all successors are
 957       // executable.
 958       return false;
 959   }
 960
 961   if (!SimpleBranch)
 962     return false;
 963
 964   // BI is a conditional branch if we got here.
 965   RegisterRef PR = BI.getOperand(0);
 966   RegisterCell PC = getCell(PR, Inputs);
 967   const BT::BitValue &Test = PC[0];
 968
 969   // If the condition is neither true nor false, then it's unknown.
 970   if (!Test.is(0) && !Test.is(1))
 971     return false;
 972
 973   // "Test.is(!Negated)" means "branch condition is true".
 974   if (!Test.is(!Negated)) {
 975     // Condition known to be false.
 976     FallsThru = true;
 977     return true;
 978   }
 979
 980   Targets.insert(BI.getOperand(1).getMBB());
 981   FallsThru = false;
 982   return true;
 983 }
 984
 985 bool HexagonEvaluator::evaluateLoad(const MachineInstr &MI,
 986                                     const CellMapType &Inputs,
 987                                     CellMapType &Outputs) const {
 988   using namespace Hexagon;
 989
 990   if (TII.isPredicated(MI))
 991     return false;
 992   assert(MI.mayLoad() && "A load that mayn't?");
 993   unsigned Opc = MI.getOpcode();
 994
 995   uint16_t BitNum;
 996   bool SignEx;
 997
 998   switch (Opc) {
 999     default:
1000       return false;
1001
1002 #if 0
1003     // memb_fifo
1004     case L2_loadalignb_pbr:
1005     case L2_loadalignb_pcr:
1006     case L2_loadalignb_pi:
1007     // memh_fifo
1008     case L2_loadalignh_pbr:
1009     case L2_loadalignh_pcr:
1010     case L2_loadalignh_pi:
1011     // membh
1012     case L2_loadbsw2_pbr:
1013     case L2_loadbsw2_pci:
1014     case L2_loadbsw2_pcr:
1015     case L2_loadbsw2_pi:
1016     case L2_loadbsw4_pbr:
1017     case L2_loadbsw4_pci:
1018     case L2_loadbsw4_pcr:
1019     case L2_loadbsw4_pi:
1020     // memubh
1021     case L2_loadbzw2_pbr:
1022     case L2_loadbzw2_pci:
1023     case L2_loadbzw2_pcr:
1024     case L2_loadbzw2_pi:
1025     case L2_loadbzw4_pbr:
1026     case L2_loadbzw4_pci:
1027     case L2_loadbzw4_pcr:
1028     case L2_loadbzw4_pi:
1029 #endif
1030
1031     case L2_loadrbgp:
1032     case L2_loadrb_io:
1033     case L2_loadrb_pbr:
1034     case L2_loadrb_pci:
1035     case L2_loadrb_pcr:
1036     case L2_loadrb_pi:
1037     case PS_loadrbabs:
1038     case L4_loadrb_ap:
1039     case L4_loadrb_rr:
1040     case L4_loadrb_ur:
1041       BitNum = 8;
1042       SignEx = true;
1043       break;
1044
1045     case L2_loadrubgp:
1046     case L2_loadrub_io:
1047     case L2_loadrub_pbr:
1048     case L2_loadrub_pci:
1049     case L2_loadrub_pcr:
1050     case L2_loadrub_pi:
1051     case PS_loadrubabs:
1052     case L4_loadrub_ap:
1053     case L4_loadrub_rr:
1054     case L4_loadrub_ur:
1055       BitNum = 8;
1056       SignEx = false;
1057       break;
1058
1059     case L2_loadrhgp:
1060     case L2_loadrh_io:
1061     case L2_loadrh_pbr:
1062     case L2_loadrh_pci:
1063     case L2_loadrh_pcr:
1064     case L2_loadrh_pi:
1065     case PS_loadrhabs:
1066     case L4_loadrh_ap:
1067     case L4_loadrh_rr:
1068     case L4_loadrh_ur:
1069       BitNum = 16;
1070       SignEx = true;
1071       break;
1072
1073     case L2_loadruhgp:
1074     case L2_loadruh_io:
1075     case L2_loadruh_pbr:
1076     case L2_loadruh_pci:
1077     case L2_loadruh_pcr:
1078     case L2_loadruh_pi:
1079     case L4_loadruh_rr:
1080     case PS_loadruhabs:
1081     case L4_loadruh_ap:
1082     case L4_loadruh_ur:
1083       BitNum = 16;
1084       SignEx = false;
1085       break;
1086
1087     case L2_loadrigp:
1088     case L2_loadri_io:
1089     case L2_loadri_pbr:
1090     case L2_loadri_pci:
1091     case L2_loadri_pcr:
1092     case L2_loadri_pi:
1093     case L2_loadw_locked:
1094     case PS_loadriabs:
1095     case L4_loadri_ap:
1096     case L4_loadri_rr:
1097     case L4_loadri_ur:
1098     case LDriw_pred:
1099       BitNum = 32;
1100       SignEx = true;
1101       break;
1102
1103     case L2_loadrdgp:
1104     case L2_loadrd_io:
1105     case L2_loadrd_pbr:
1106     case L2_loadrd_pci:
1107     case L2_loadrd_pcr:
1108     case L2_loadrd_pi:
1109     case L4_loadd_locked:
1110     case PS_loadrdabs:
1111     case L4_loadrd_ap:
1112     case L4_loadrd_rr:
1113     case L4_loadrd_ur:
1114       BitNum = 64;
1115       SignEx = true;
1116       break;
1117   }
1118
1119   const MachineOperand &MD = MI.getOperand(0);
1120   assert(MD.isReg() && MD.isDef());
1121   RegisterRef RD = MD;
1122
1123   uint16_t W = getRegBitWidth(RD);
1124   assert(W >= BitNum && BitNum > 0);
1125   RegisterCell Res(W);
1126
1127   for (uint16_t i = 0; i < BitNum; ++i)
1128     Res[i] = BT::BitValue::self(BT::BitRef(RD.Reg, i));
1129
1130   if (SignEx) {
1131     const BT::BitValue &Sign = Res[BitNum-1];
1132     for (uint16_t i = BitNum; i < W; ++i)
1133       Res[i] = BT::BitValue::ref(Sign);
1134   } else {
1135     for (uint16_t i = BitNum; i < W; ++i)
1136       Res[i] = BT::BitValue::Zero;
1137   }
1138
1139   putCell(RD, Res, Outputs);
1140   return true;
1141 }
1142
1143 bool HexagonEvaluator::evaluateFormalCopy(const MachineInstr &MI,
1144                                           const CellMapType &Inputs,
1145                                           CellMapType &Outputs) const {
1146   // If MI defines a formal parameter, but is not a copy (loads are handled
1147   // in evaluateLoad), then it's not clear what to do.
1148   assert(MI.isCopy());
1149
1150   RegisterRef RD = MI.getOperand(0);
1151   RegisterRef RS = MI.getOperand(1);
1152   assert(RD.Sub == 0);
1153   if (!TargetRegisterInfo::isPhysicalRegister(RS.Reg))
1154     return false;
1155   RegExtMap::const_iterator F = VRX.find(RD.Reg);
1156   if (F == VRX.end())
1157     return false;
1158
1159   uint16_t EW = F->second.Width;
1160   // Store RD's cell into the map. This will associate the cell with a virtual
1161   // register, and make zero-/sign-extends possible (otherwise we would be ex-
1162   // tending "self" bit values, which will have no effect, since "self" values
1163   // cannot be references to anything).
1164   putCell(RD, getCell(RS, Inputs), Outputs);
1165
1166   RegisterCell Res;
1167   // Read RD's cell from the outputs instead of RS's cell from the inputs:
1168   if (F->second.Type == ExtType::SExt)
1169     Res = eSXT(getCell(RD, Outputs), EW);
1170   else if (F->second.Type == ExtType::ZExt)
1171     Res = eZXT(getCell(RD, Outputs), EW);
1172
1173   putCell(RD, Res, Outputs);
1174   return true;
1175 }
1176
1177 unsigned HexagonEvaluator::getNextPhysReg(unsigned PReg, unsigned Width) const {
1178   using namespace Hexagon;
1179
1180   bool Is64 = DoubleRegsRegClass.contains(PReg);
1181   assert(PReg == 0 || Is64 || IntRegsRegClass.contains(PReg));
1182
1183   static const unsigned Phys32[] = { R0, R1, R2, R3, R4, R5 };
1184   static const unsigned Phys64[] = { D0, D1, D2 };
1185   const unsigned Num32 = sizeof(Phys32)/sizeof(unsigned);
1186   const unsigned Num64 = sizeof(Phys64)/sizeof(unsigned);
1187
1188   // Return the first parameter register of the required width.
1189   if (PReg == 0)
1190     return (Width <= 32) ? Phys32[0] : Phys64[0];
1191
1192   // Set Idx32, Idx64 in such a way that Idx+1 would give the index of the
1193   // next register.
1194   unsigned Idx32 = 0, Idx64 = 0;
1195   if (!Is64) {
1196     while (Idx32 < Num32) {
1197       if (Phys32[Idx32] == PReg)
1198         break;
1199       Idx32++;
1200     }
1201     Idx64 = Idx32/2;
1202   } else {
1203     while (Idx64 < Num64) {
1204       if (Phys64[Idx64] == PReg)
1205         break;
1206       Idx64++;
1207     }
1208     Idx32 = Idx64*2+1;
1209   }
1210
1211   if (Width <= 32)
1212     return (Idx32+1 < Num32) ? Phys32[Idx32+1] : 0;
1213   return (Idx64+1 < Num64) ? Phys64[Idx64+1] : 0;
1214 }
1215
1216 unsigned HexagonEvaluator::getVirtRegFor(unsigned PReg) const {
1217   typedef MachineRegisterInfo::livein_iterator iterator;
1218   for (iterator I = MRI.livein_begin(), E = MRI.livein_end(); I != E; ++I) {
1219     if (I->first == PReg)
1220       return I->second;
1221   }
1222   return 0;
1223 }