lib/CodeGen/SelectionDAG/InstrEmitter.cpp

   1 //==--- InstrEmitter.cpp - Emit MachineInstrs for the SelectionDAG class ---==//
   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 // This implements the Emit routines for the SelectionDAG class, which creates
  11 // MachineInstrs based on the decisions of the SelectionDAG instruction
  12 // selection.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #define DEBUG_TYPE "instr-emitter"
  17 #include "InstrEmitter.h"
  18 #include "SDNodeDbgValue.h"
  19 #include "llvm/ADT/Statistic.h"
  20 #include "llvm/CodeGen/MachineConstantPool.h"
  21 #include "llvm/CodeGen/MachineFunction.h"
  22 #include "llvm/CodeGen/MachineInstrBuilder.h"
  23 #include "llvm/CodeGen/MachineRegisterInfo.h"
  24 #include "llvm/CodeGen/StackMaps.h"
  25 #include "llvm/IR/DataLayout.h"
  26 #include "llvm/Support/Debug.h"
  27 #include "llvm/Support/ErrorHandling.h"
  28 #include "llvm/Support/MathExtras.h"
  29 #include "llvm/Target/TargetInstrInfo.h"
  30 #include "llvm/Target/TargetLowering.h"
  31 #include "llvm/Target/TargetMachine.h"
  32 using namespace llvm;
  33
  34 /// MinRCSize - Smallest register class we allow when constraining virtual
  35 /// registers.  If satisfying all register class constraints would require
  36 /// using a smaller register class, emit a COPY to a new virtual register
  37 /// instead.
  38 const unsigned MinRCSize = 4;
  39
  40 /// CountResults - The results of target nodes have register or immediate
  41 /// operands first, then an optional chain, and optional glue operands (which do
  42 /// not go into the resulting MachineInstr).
  43 unsigned InstrEmitter::CountResults(SDNode *Node) {
  44   unsigned N = Node->getNumValues();
  45   while (N && Node->getValueType(N - 1) == MVT::Glue)
  46     --N;
  47   if (N && Node->getValueType(N - 1) == MVT::Other)
  48     --N;    // Skip over chain result.
  49   return N;
  50 }
  51
  52 /// countOperands - The inputs to target nodes have any actual inputs first,
  53 /// followed by an optional chain operand, then an optional glue operand.
  54 /// Compute the number of actual operands that will go into the resulting
  55 /// MachineInstr.
  56 ///
  57 /// Also count physreg RegisterSDNode and RegisterMaskSDNode operands preceding
  58 /// the chain and glue. These operands may be implicit on the machine instr.
  59 static unsigned countOperands(SDNode *Node, unsigned NumExpUses,
  60                               unsigned &NumImpUses) {
  61   unsigned N = Node->getNumOperands();
  62   while (N && Node->getOperand(N - 1).getValueType() == MVT::Glue)
  63     --N;
  64   if (N && Node->getOperand(N - 1).getValueType() == MVT::Other)
  65     --N; // Ignore chain if it exists.
  66
  67   // Count RegisterSDNode and RegisterMaskSDNode operands for NumImpUses.
  68   NumImpUses = N - NumExpUses;
  69   for (unsigned I = N; I > NumExpUses; --I) {
  70     if (isa<RegisterMaskSDNode>(Node->getOperand(I - 1)))
  71       continue;
  72     if (RegisterSDNode *RN = dyn_cast<RegisterSDNode>(Node->getOperand(I - 1)))
  73       if (TargetRegisterInfo::isPhysicalRegister(RN->getReg()))
  74         continue;
  75     NumImpUses = N - I;
  76     break;
  77   }
  78
  79   return N;
  80 }
  81
  82 /// EmitCopyFromReg - Generate machine code for an CopyFromReg node or an
  83 /// implicit physical register output.
  84 void InstrEmitter::
  85 EmitCopyFromReg(SDNode *Node, unsigned ResNo, bool IsClone, bool IsCloned,
  86                 unsigned SrcReg, DenseMap<SDValue, unsigned> &VRBaseMap) {
  87   unsigned VRBase = 0;
  88   if (TargetRegisterInfo::isVirtualRegister(SrcReg)) {
  89     // Just use the input register directly!
  90     SDValue Op(Node, ResNo);
  91     if (IsClone)
  92       VRBaseMap.erase(Op);
  93     bool isNew = VRBaseMap.insert(std::make_pair(Op, SrcReg)).second;
  94     (void)isNew; // Silence compiler warning.
  95     assert(isNew && "Node emitted out of order - early");
  96     return;
  97   }
  98
  99   // If the node is only used by a CopyToReg and the dest reg is a vreg, use
 100   // the CopyToReg'd destination register instead of creating a new vreg.
 101   bool MatchReg = true;
 102   const TargetRegisterClass *UseRC = nullptr;
 103   MVT VT = Node->getSimpleValueType(ResNo);
 104
 105   // Stick to the preferred register classes for legal types.
 106   if (TLI->isTypeLegal(VT))
 107     UseRC = TLI->getRegClassFor(VT);
 108
 109   if (!IsClone && !IsCloned)
 110     for (SDNode *User : Node->uses()) {
 111       bool Match = true;
 112       if (User->getOpcode() == ISD::CopyToReg &&
 113           User->getOperand(2).getNode() == Node &&
 114           User->getOperand(2).getResNo() == ResNo) {
 115         unsigned DestReg = cast<RegisterSDNode>(User->getOperand(1))->getReg();
 116         if (TargetRegisterInfo::isVirtualRegister(DestReg)) {
 117           VRBase = DestReg;
 118           Match = false;
 119         } else if (DestReg != SrcReg)
 120           Match = false;
 121       } else {
 122         for (unsigned i = 0, e = User->getNumOperands(); i != e; ++i) {
 123           SDValue Op = User->getOperand(i);
 124           if (Op.getNode() != Node || Op.getResNo() != ResNo)
 125             continue;
 126           MVT VT = Node->getSimpleValueType(Op.getResNo());
 127           if (VT == MVT::Other || VT == MVT::Glue)
 128             continue;
 129           Match = false;
 130           if (User->isMachineOpcode()) {
 131             const MCInstrDesc &II = TII->get(User->getMachineOpcode());
 132             const TargetRegisterClass *RC = nullptr;
 133             if (i+II.getNumDefs() < II.getNumOperands()) {
 134               RC = TRI->getAllocatableClass(
 135                 TII->getRegClass(II, i+II.getNumDefs(), TRI, *MF));
 136             }
 137             if (!UseRC)
 138               UseRC = RC;
 139             else if (RC) {
 140               const TargetRegisterClass *ComRC =
 141                 TRI->getCommonSubClass(UseRC, RC);
 142               // If multiple uses expect disjoint register classes, we emit
 143               // copies in AddRegisterOperand.
 144               if (ComRC)
 145                 UseRC = ComRC;
 146             }
 147           }
 148         }
 149       }
 150       MatchReg &= Match;
 151       if (VRBase)
 152         break;
 153     }
 154
 155   const TargetRegisterClass *SrcRC = nullptr, *DstRC = nullptr;
 156   SrcRC = TRI->getMinimalPhysRegClass(SrcReg, VT);
 157
 158   // Figure out the register class to create for the destreg.
 159   if (VRBase) {
 160     DstRC = MRI->getRegClass(VRBase);
 161   } else if (UseRC) {
 162     assert(UseRC->hasType(VT) && "Incompatible phys register def and uses!");
 163     DstRC = UseRC;
 164   } else {
 165     DstRC = TLI->getRegClassFor(VT);
 166   }
 167
 168   // If all uses are reading from the src physical register and copying the
 169   // register is either impossible or very expensive, then don't create a copy.
 170   if (MatchReg && SrcRC->getCopyCost() < 0) {
 171     VRBase = SrcReg;
 172   } else {
 173     // Create the reg, emit the copy.
 174     VRBase = MRI->createVirtualRegister(DstRC);
 175     BuildMI(*MBB, InsertPos, Node->getDebugLoc(), TII->get(TargetOpcode::COPY),
 176             VRBase).addReg(SrcReg);
 177   }
 178
 179   SDValue Op(Node, ResNo);
 180   if (IsClone)
 181     VRBaseMap.erase(Op);
 182   bool isNew = VRBaseMap.insert(std::make_pair(Op, VRBase)).second;
 183   (void)isNew; // Silence compiler warning.
 184   assert(isNew && "Node emitted out of order - early");
 185 }
 186
 187 /// getDstOfCopyToRegUse - If the only use of the specified result number of
 188 /// node is a CopyToReg, return its destination register. Return 0 otherwise.
 189 unsigned InstrEmitter::getDstOfOnlyCopyToRegUse(SDNode *Node,
 190                                                 unsigned ResNo) const {
 191   if (!Node->hasOneUse())
 192     return 0;
 193
 194   SDNode *User = *Node->use_begin();
 195   if (User->getOpcode() == ISD::CopyToReg &&
 196       User->getOperand(2).getNode() == Node &&
 197       User->getOperand(2).getResNo() == ResNo) {
 198     unsigned Reg = cast<RegisterSDNode>(User->getOperand(1))->getReg();
 199     if (TargetRegisterInfo::isVirtualRegister(Reg))
 200       return Reg;
 201   }
 202   return 0;
 203 }
 204
 205 void InstrEmitter::CreateVirtualRegisters(SDNode *Node,
 206                                        MachineInstrBuilder &MIB,
 207                                        const MCInstrDesc &II,
 208                                        bool IsClone, bool IsCloned,
 209                                        DenseMap<SDValue, unsigned> &VRBaseMap) {
 210   assert(Node->getMachineOpcode() != TargetOpcode::IMPLICIT_DEF &&
 211          "IMPLICIT_DEF should have been handled as a special case elsewhere!");
 212
 213   unsigned NumResults = CountResults(Node);
 214   for (unsigned i = 0; i < II.getNumDefs(); ++i) {
 215     // If the specific node value is only used by a CopyToReg and the dest reg
 216     // is a vreg in the same register class, use the CopyToReg'd destination
 217     // register instead of creating a new vreg.
 218     unsigned VRBase = 0;
 219     const TargetRegisterClass *RC =
 220       TRI->getAllocatableClass(TII->getRegClass(II, i, TRI, *MF));
 221     // Always let the value type influence the used register class. The
 222     // constraints on the instruction may be too lax to represent the value
 223     // type correctly. For example, a 64-bit float (X86::FR64) can't live in
 224     // the 32-bit float super-class (X86::FR32).
 225     if (i < NumResults && TLI->isTypeLegal(Node->getSimpleValueType(i))) {
 226       const TargetRegisterClass *VTRC =
 227         TLI->getRegClassFor(Node->getSimpleValueType(i));
 228       if (RC)
 229         VTRC = TRI->getCommonSubClass(RC, VTRC);
 230       if (VTRC)
 231         RC = VTRC;
 232     }
 233
 234     if (II.OpInfo[i].isOptionalDef()) {
 235       // Optional def must be a physical register.
 236       unsigned NumResults = CountResults(Node);
 237       VRBase = cast<RegisterSDNode>(Node->getOperand(i-NumResults))->getReg();
 238       assert(TargetRegisterInfo::isPhysicalRegister(VRBase));
 239       MIB.addReg(VRBase, RegState::Define);
 240     }
 241
 242     if (!VRBase && !IsClone && !IsCloned)
 243       for (SDNode *User : Node->uses()) {
 244         if (User->getOpcode() == ISD::CopyToReg &&
 245             User->getOperand(2).getNode() == Node &&
 246             User->getOperand(2).getResNo() == i) {
 247           unsigned Reg = cast<RegisterSDNode>(User->getOperand(1))->getReg();
 248           if (TargetRegisterInfo::isVirtualRegister(Reg)) {
 249             const TargetRegisterClass *RegRC = MRI->getRegClass(Reg);
 250             if (RegRC == RC) {
 251               VRBase = Reg;
 252               MIB.addReg(VRBase, RegState::Define);
 253               break;
 254             }
 255           }
 256         }
 257       }
 258
 259     // Create the result registers for this node and add the result regs to
 260     // the machine instruction.
 261     if (VRBase == 0) {
 262       assert(RC && "Isn't a register operand!");
 263       VRBase = MRI->createVirtualRegister(RC);
 264       MIB.addReg(VRBase, RegState::Define);
 265     }
 266
 267     SDValue Op(Node, i);
 268     if (IsClone)
 269       VRBaseMap.erase(Op);
 270     bool isNew = VRBaseMap.insert(std::make_pair(Op, VRBase)).second;
 271     (void)isNew; // Silence compiler warning.
 272     assert(isNew && "Node emitted out of order - early");
 273   }
 274 }
 275
 276 /// getVR - Return the virtual register corresponding to the specified result
 277 /// of the specified node.
 278 unsigned InstrEmitter::getVR(SDValue Op,
 279                              DenseMap<SDValue, unsigned> &VRBaseMap) {
 280   if (Op.isMachineOpcode() &&
 281       Op.getMachineOpcode() == TargetOpcode::IMPLICIT_DEF) {
 282     // Add an IMPLICIT_DEF instruction before every use.
 283     unsigned VReg = getDstOfOnlyCopyToRegUse(Op.getNode(), Op.getResNo());
 284     // IMPLICIT_DEF can produce any type of result so its MCInstrDesc
 285     // does not include operand register class info.
 286     if (!VReg) {
 287       const TargetRegisterClass *RC =
 288         TLI->getRegClassFor(Op.getSimpleValueType());
 289       VReg = MRI->createVirtualRegister(RC);
 290     }
 291     BuildMI(*MBB, InsertPos, Op.getDebugLoc(),
 292             TII->get(TargetOpcode::IMPLICIT_DEF), VReg);
 293     return VReg;
 294   }
 295
 296   DenseMap<SDValue, unsigned>::iterator I = VRBaseMap.find(Op);
 297   assert(I != VRBaseMap.end() && "Node emitted out of order - late");
 298   return I->second;
 299 }
 300
 301
 302 /// AddRegisterOperand - Add the specified register as an operand to the
 303 /// specified machine instr. Insert register copies if the register is
 304 /// not in the required register class.
 305 void
 306 InstrEmitter::AddRegisterOperand(MachineInstrBuilder &MIB,
 307                                  SDValue Op,
 308                                  unsigned IIOpNum,
 309                                  const MCInstrDesc *II,
 310                                  DenseMap<SDValue, unsigned> &VRBaseMap,
 311                                  bool IsDebug, bool IsClone, bool IsCloned) {
 312   assert(Op.getValueType() != MVT::Other &&
 313          Op.getValueType() != MVT::Glue &&
 314          "Chain and glue operands should occur at end of operand list!");
 315   // Get/emit the operand.
 316   unsigned VReg = getVR(Op, VRBaseMap);
 317   assert(TargetRegisterInfo::isVirtualRegister(VReg) && "Not a vreg?");
 318
 319   const MCInstrDesc &MCID = MIB->getDesc();
 320   bool isOptDef = IIOpNum < MCID.getNumOperands() &&
 321     MCID.OpInfo[IIOpNum].isOptionalDef();
 322
 323   // If the instruction requires a register in a different class, create
 324   // a new virtual register and copy the value into it, but first attempt to
 325   // shrink VReg's register class within reason.  For example, if VReg == GR32
 326   // and II requires a GR32_NOSP, just constrain VReg to GR32_NOSP.
 327   if (II) {
 328     const TargetRegisterClass *DstRC = nullptr;
 329     if (IIOpNum < II->getNumOperands())
 330       DstRC = TRI->getAllocatableClass(TII->getRegClass(*II,IIOpNum,TRI,*MF));
 331     if (DstRC && !MRI->constrainRegClass(VReg, DstRC, MinRCSize)) {
 332       unsigned NewVReg = MRI->createVirtualRegister(DstRC);
 333       BuildMI(*MBB, InsertPos, Op.getNode()->getDebugLoc(),
 334               TII->get(TargetOpcode::COPY), NewVReg).addReg(VReg);
 335       VReg = NewVReg;
 336     }
 337   }
 338
 339   // If this value has only one use, that use is a kill. This is a
 340   // conservative approximation. InstrEmitter does trivial coalescing
 341   // with CopyFromReg nodes, so don't emit kill flags for them.
 342   // Avoid kill flags on Schedule cloned nodes, since there will be
 343   // multiple uses.
 344   // Tied operands are never killed, so we need to check that. And that
 345   // means we need to determine the index of the operand.
 346   bool isKill = Op.hasOneUse() &&
 347                 Op.getNode()->getOpcode() != ISD::CopyFromReg &&
 348                 !IsDebug &&
 349                 !(IsClone || IsCloned);
 350   if (isKill) {
 351     unsigned Idx = MIB->getNumOperands();
 352     while (Idx > 0 &&
 353            MIB->getOperand(Idx-1).isReg() &&
 354            MIB->getOperand(Idx-1).isImplicit())
 355       --Idx;
 356     bool isTied = MCID.getOperandConstraint(Idx, MCOI::TIED_TO) != -1;
 357     if (isTied)
 358       isKill = false;
 359   }
 360
 361   MIB.addReg(VReg, getDefRegState(isOptDef) | getKillRegState(isKill) |
 362              getDebugRegState(IsDebug));
 363 }
 364
 365 /// AddOperand - Add the specified operand to the specified machine instr.  II
 366 /// specifies the instruction information for the node, and IIOpNum is the
 367 /// operand number (in the II) that we are adding.
 368 void InstrEmitter::AddOperand(MachineInstrBuilder &MIB,
 369                               SDValue Op,
 370                               unsigned IIOpNum,
 371                               const MCInstrDesc *II,
 372                               DenseMap<SDValue, unsigned> &VRBaseMap,
 373                               bool IsDebug, bool IsClone, bool IsCloned) {
 374   if (Op.isMachineOpcode()) {
 375     AddRegisterOperand(MIB, Op, IIOpNum, II, VRBaseMap,
 376                        IsDebug, IsClone, IsCloned);
 377   } else if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) {
 378     MIB.addImm(C->getSExtValue());
 379   } else if (ConstantFPSDNode *F = dyn_cast<ConstantFPSDNode>(Op)) {
 380     MIB.addFPImm(F->getConstantFPValue());
 381   } else if (RegisterSDNode *R = dyn_cast<RegisterSDNode>(Op)) {
 382     // Turn additional physreg operands into implicit uses on non-variadic
 383     // instructions. This is used by call and return instructions passing
 384     // arguments in registers.
 385     bool Imp = II && (IIOpNum >= II->getNumOperands() && !II->isVariadic());
 386     MIB.addReg(R->getReg(), getImplRegState(Imp));
 387   } else if (RegisterMaskSDNode *RM = dyn_cast<RegisterMaskSDNode>(Op)) {
 388     MIB.addRegMask(RM->getRegMask());
 389   } else if (GlobalAddressSDNode *TGA = dyn_cast<GlobalAddressSDNode>(Op)) {
 390     MIB.addGlobalAddress(TGA->getGlobal(), TGA->getOffset(),
 391                          TGA->getTargetFlags());
 392   } else if (BasicBlockSDNode *BBNode = dyn_cast<BasicBlockSDNode>(Op)) {
 393     MIB.addMBB(BBNode->getBasicBlock());
 394   } else if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Op)) {
 395     MIB.addFrameIndex(FI->getIndex());
 396   } else if (JumpTableSDNode *JT = dyn_cast<JumpTableSDNode>(Op)) {
 397     MIB.addJumpTableIndex(JT->getIndex(), JT->getTargetFlags());
 398   } else if (ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(Op)) {
 399     int Offset = CP->getOffset();
 400     unsigned Align = CP->getAlignment();
 401     Type *Type = CP->getType();
 402     // MachineConstantPool wants an explicit alignment.
 403     if (Align == 0) {
 404       Align = TM->getDataLayout()->getPrefTypeAlignment(Type);
 405       if (Align == 0) {
 406         // Alignment of vector types.  FIXME!
 407         Align = TM->getDataLayout()->getTypeAllocSize(Type);
 408       }
 409     }
 410
 411     unsigned Idx;
 412     MachineConstantPool *MCP = MF->getConstantPool();
 413     if (CP->isMachineConstantPoolEntry())
 414       Idx = MCP->getConstantPoolIndex(CP->getMachineCPVal(), Align);
 415     else
 416       Idx = MCP->getConstantPoolIndex(CP->getConstVal(), Align);
 417     MIB.addConstantPoolIndex(Idx, Offset, CP->getTargetFlags());
 418   } else if (ExternalSymbolSDNode *ES = dyn_cast<ExternalSymbolSDNode>(Op)) {
 419     MIB.addExternalSymbol(ES->getSymbol(), ES->getTargetFlags());
 420   } else if (BlockAddressSDNode *BA = dyn_cast<BlockAddressSDNode>(Op)) {
 421     MIB.addBlockAddress(BA->getBlockAddress(),
 422                         BA->getOffset(),
 423                         BA->getTargetFlags());
 424   } else if (TargetIndexSDNode *TI = dyn_cast<TargetIndexSDNode>(Op)) {
 425     MIB.addTargetIndex(TI->getIndex(), TI->getOffset(), TI->getTargetFlags());
 426   } else {
 427     assert(Op.getValueType() != MVT::Other &&
 428            Op.getValueType() != MVT::Glue &&
 429            "Chain and glue operands should occur at end of operand list!");
 430     AddRegisterOperand(MIB, Op, IIOpNum, II, VRBaseMap,
 431                        IsDebug, IsClone, IsCloned);
 432   }
 433 }
 434
 435 unsigned InstrEmitter::ConstrainForSubReg(unsigned VReg, unsigned SubIdx,
 436                                           MVT VT, DebugLoc DL) {
 437   const TargetRegisterClass *VRC = MRI->getRegClass(VReg);
 438   const TargetRegisterClass *RC = TRI->getSubClassWithSubReg(VRC, SubIdx);
 439
 440   // RC is a sub-class of VRC that supports SubIdx.  Try to constrain VReg
 441   // within reason.
 442   if (RC && RC != VRC)
 443     RC = MRI->constrainRegClass(VReg, RC, MinRCSize);
 444
 445   // VReg has been adjusted.  It can be used with SubIdx operands now.
 446   if (RC)
 447     return VReg;
 448
 449   // VReg couldn't be reasonably constrained.  Emit a COPY to a new virtual
 450   // register instead.
 451   RC = TRI->getSubClassWithSubReg(TLI->getRegClassFor(VT), SubIdx);
 452   assert(RC && "No legal register class for VT supports that SubIdx");
 453   unsigned NewReg = MRI->createVirtualRegister(RC);
 454   BuildMI(*MBB, InsertPos, DL, TII->get(TargetOpcode::COPY), NewReg)
 455     .addReg(VReg);
 456   return NewReg;
 457 }
 458
 459 /// EmitSubregNode - Generate machine code for subreg nodes.
 460 ///
 461 void InstrEmitter::EmitSubregNode(SDNode *Node,
 462                                   DenseMap<SDValue, unsigned> &VRBaseMap,
 463                                   bool IsClone, bool IsCloned) {
 464   unsigned VRBase = 0;
 465   unsigned Opc = Node->getMachineOpcode();
 466
 467   // If the node is only used by a CopyToReg and the dest reg is a vreg, use
 468   // the CopyToReg'd destination register instead of creating a new vreg.
 469   for (SDNode *User : Node->uses()) {
 470     if (User->getOpcode() == ISD::CopyToReg &&
 471         User->getOperand(2).getNode() == Node) {
 472       unsigned DestReg = cast<RegisterSDNode>(User->getOperand(1))->getReg();
 473       if (TargetRegisterInfo::isVirtualRegister(DestReg)) {
 474         VRBase = DestReg;
 475         break;
 476       }
 477     }
 478   }
 479
 480   if (Opc == TargetOpcode::EXTRACT_SUBREG) {
 481     // EXTRACT_SUBREG is lowered as %dst = COPY %src:sub.  There are no
 482     // constraints on the %dst register, COPY can target all legal register
 483     // classes.
 484     unsigned SubIdx = cast<ConstantSDNode>(Node->getOperand(1))->getZExtValue();
 485     const TargetRegisterClass *TRC =
 486       TLI->getRegClassFor(Node->getSimpleValueType(0));
 487
 488     unsigned VReg = getVR(Node->getOperand(0), VRBaseMap);
 489     MachineInstr *DefMI = MRI->getVRegDef(VReg);
 490     unsigned SrcReg, DstReg, DefSubIdx;
 491     if (DefMI &&
 492         TII->isCoalescableExtInstr(*DefMI, SrcReg, DstReg, DefSubIdx) &&
 493         SubIdx == DefSubIdx &&
 494         TRC == MRI->getRegClass(SrcReg)) {
 495       // Optimize these:
 496       // r1025 = s/zext r1024, 4
 497       // r1026 = extract_subreg r1025, 4
 498       // to a copy
 499       // r1026 = copy r1024
 500       VRBase = MRI->createVirtualRegister(TRC);
 501       BuildMI(*MBB, InsertPos, Node->getDebugLoc(),
 502               TII->get(TargetOpcode::COPY), VRBase).addReg(SrcReg);
 503       MRI->clearKillFlags(SrcReg);
 504     } else {
 505       // VReg may not support a SubIdx sub-register, and we may need to
 506       // constrain its register class or issue a COPY to a compatible register
 507       // class.
 508       VReg = ConstrainForSubReg(VReg, SubIdx,
 509                                 Node->getOperand(0).getSimpleValueType(),
 510                                 Node->getDebugLoc());
 511
 512       // Create the destreg if it is missing.
 513       if (VRBase == 0)
 514         VRBase = MRI->createVirtualRegister(TRC);
 515
 516       // Create the extract_subreg machine instruction.
 517       BuildMI(*MBB, InsertPos, Node->getDebugLoc(),
 518               TII->get(TargetOpcode::COPY), VRBase).addReg(VReg, 0, SubIdx);
 519     }
 520   } else if (Opc == TargetOpcode::INSERT_SUBREG ||
 521              Opc == TargetOpcode::SUBREG_TO_REG) {
 522     SDValue N0 = Node->getOperand(0);
 523     SDValue N1 = Node->getOperand(1);
 524     SDValue N2 = Node->getOperand(2);
 525     unsigned SubIdx = cast<ConstantSDNode>(N2)->getZExtValue();
 526
 527     // Figure out the register class to create for the destreg.  It should be
 528     // the largest legal register class supporting SubIdx sub-registers.
 529     // RegisterCoalescer will constrain it further if it decides to eliminate
 530     // the INSERT_SUBREG instruction.
 531     //
 532     //   %dst = INSERT_SUBREG %src, %sub, SubIdx
 533     //
 534     // is lowered by TwoAddressInstructionPass to:
 535     //
 536     //   %dst = COPY %src
 537     //   %dst:SubIdx = COPY %sub
 538     //
 539     // There is no constraint on the %src register class.
 540     //
 541     const TargetRegisterClass *SRC = TLI->getRegClassFor(Node->getSimpleValueType(0));
 542     SRC = TRI->getSubClassWithSubReg(SRC, SubIdx);
 543     assert(SRC && "No register class supports VT and SubIdx for INSERT_SUBREG");
 544
 545     if (VRBase == 0 || !SRC->hasSubClassEq(MRI->getRegClass(VRBase)))
 546       VRBase = MRI->createVirtualRegister(SRC);
 547
 548     // Create the insert_subreg or subreg_to_reg machine instruction.
 549     MachineInstrBuilder MIB =
 550       BuildMI(*MF, Node->getDebugLoc(), TII->get(Opc), VRBase);
 551
 552     // If creating a subreg_to_reg, then the first input operand
 553     // is an implicit value immediate, otherwise it's a register
 554     if (Opc == TargetOpcode::SUBREG_TO_REG) {
 555       const ConstantSDNode *SD = cast<ConstantSDNode>(N0);
 556       MIB.addImm(SD->getZExtValue());
 557     } else
 558       AddOperand(MIB, N0, 0, nullptr, VRBaseMap, /*IsDebug=*/false,
 559                  IsClone, IsCloned);
 560     // Add the subregster being inserted
 561     AddOperand(MIB, N1, 0, nullptr, VRBaseMap, /*IsDebug=*/false,
 562                IsClone, IsCloned);
 563     MIB.addImm(SubIdx);
 564     MBB->insert(InsertPos, MIB);
 565   } else
 566     llvm_unreachable("Node is not insert_subreg, extract_subreg, or subreg_to_reg");
 567
 568   SDValue Op(Node, 0);
 569   bool isNew = VRBaseMap.insert(std::make_pair(Op, VRBase)).second;
 570   (void)isNew; // Silence compiler warning.
 571   assert(isNew && "Node emitted out of order - early");
 572 }
 573
 574 /// EmitCopyToRegClassNode - Generate machine code for COPY_TO_REGCLASS nodes.
 575 /// COPY_TO_REGCLASS is just a normal copy, except that the destination
 576 /// register is constrained to be in a particular register class.
 577 ///
 578 void
 579 InstrEmitter::EmitCopyToRegClassNode(SDNode *Node,
 580                                      DenseMap<SDValue, unsigned> &VRBaseMap) {
 581   unsigned VReg = getVR(Node->getOperand(0), VRBaseMap);
 582
 583   // Create the new VReg in the destination class and emit a copy.
 584   unsigned DstRCIdx = cast<ConstantSDNode>(Node->getOperand(1))->getZExtValue();
 585   const TargetRegisterClass *DstRC =
 586     TRI->getAllocatableClass(TRI->getRegClass(DstRCIdx));
 587   unsigned NewVReg = MRI->createVirtualRegister(DstRC);
 588   BuildMI(*MBB, InsertPos, Node->getDebugLoc(), TII->get(TargetOpcode::COPY),
 589     NewVReg).addReg(VReg);
 590
 591   SDValue Op(Node, 0);
 592   bool isNew = VRBaseMap.insert(std::make_pair(Op, NewVReg)).second;
 593   (void)isNew; // Silence compiler warning.
 594   assert(isNew && "Node emitted out of order - early");
 595 }
 596
 597 /// EmitRegSequence - Generate machine code for REG_SEQUENCE nodes.
 598 ///
 599 void InstrEmitter::EmitRegSequence(SDNode *Node,
 600                                   DenseMap<SDValue, unsigned> &VRBaseMap,
 601                                   bool IsClone, bool IsCloned) {
 602   unsigned DstRCIdx = cast<ConstantSDNode>(Node->getOperand(0))->getZExtValue();
 603   const TargetRegisterClass *RC = TRI->getRegClass(DstRCIdx);
 604   unsigned NewVReg = MRI->createVirtualRegister(TRI->getAllocatableClass(RC));
 605   const MCInstrDesc &II = TII->get(TargetOpcode::REG_SEQUENCE);
 606   MachineInstrBuilder MIB = BuildMI(*MF, Node->getDebugLoc(), II, NewVReg);
 607   unsigned NumOps = Node->getNumOperands();
 608   assert((NumOps & 1) == 1 &&
 609          "REG_SEQUENCE must have an odd number of operands!");
 610   for (unsigned i = 1; i != NumOps; ++i) {
 611     SDValue Op = Node->getOperand(i);
 612     if ((i & 1) == 0) {
 613       RegisterSDNode *R = dyn_cast<RegisterSDNode>(Node->getOperand(i-1));
 614       // Skip physical registers as they don't have a vreg to get and we'll
 615       // insert copies for them in TwoAddressInstructionPass anyway.
 616       if (!R || !TargetRegisterInfo::isPhysicalRegister(R->getReg())) {
 617         unsigned SubIdx = cast<ConstantSDNode>(Op)->getZExtValue();
 618         unsigned SubReg = getVR(Node->getOperand(i-1), VRBaseMap);
 619         const TargetRegisterClass *TRC = MRI->getRegClass(SubReg);
 620         const TargetRegisterClass *SRC =
 621         TRI->getMatchingSuperRegClass(RC, TRC, SubIdx);
 622         if (SRC && SRC != RC) {
 623           MRI->setRegClass(NewVReg, SRC);
 624           RC = SRC;
 625         }
 626       }
 627     }
 628     AddOperand(MIB, Op, i+1, &II, VRBaseMap, /*IsDebug=*/false,
 629                IsClone, IsCloned);
 630   }
 631
 632   MBB->insert(InsertPos, MIB);
 633   SDValue Op(Node, 0);
 634   bool isNew = VRBaseMap.insert(std::make_pair(Op, NewVReg)).second;
 635   (void)isNew; // Silence compiler warning.
 636   assert(isNew && "Node emitted out of order - early");
 637 }
 638
 639 /// EmitDbgValue - Generate machine instruction for a dbg_value node.
 640 ///
 641 MachineInstr *
 642 InstrEmitter::EmitDbgValue(SDDbgValue *SD,
 643                            DenseMap<SDValue, unsigned> &VRBaseMap) {
 644   uint64_t Offset = SD->getOffset();
 645   MDNode* MDPtr = SD->getMDPtr();
 646   DebugLoc DL = SD->getDebugLoc();
 647
 648   if (SD->getKind() == SDDbgValue::FRAMEIX) {
 649     // Stack address; this needs to be lowered in target-dependent fashion.
 650     // EmitTargetCodeForFrameDebugValue is responsible for allocation.
 651     return BuildMI(*MF, DL, TII->get(TargetOpcode::DBG_VALUE))
 652         .addFrameIndex(SD->getFrameIx()).addImm(Offset).addMetadata(MDPtr);
 653   }
 654   // Otherwise, we're going to create an instruction here.
 655   const MCInstrDesc &II = TII->get(TargetOpcode::DBG_VALUE);
 656   MachineInstrBuilder MIB = BuildMI(*MF, DL, II);
 657   if (SD->getKind() == SDDbgValue::SDNODE) {
 658     SDNode *Node = SD->getSDNode();
 659     SDValue Op = SDValue(Node, SD->getResNo());
 660     // It's possible we replaced this SDNode with other(s) and therefore
 661     // didn't generate code for it.  It's better to catch these cases where
 662     // they happen and transfer the debug info, but trying to guarantee that
 663     // in all cases would be very fragile; this is a safeguard for any
 664     // that were missed.
 665     DenseMap<SDValue, unsigned>::iterator I = VRBaseMap.find(Op);
 666     if (I==VRBaseMap.end())
 667       MIB.addReg(0U);       // undef
 668     else
 669       AddOperand(MIB, Op, (*MIB).getNumOperands(), &II, VRBaseMap,
 670                  /*IsDebug=*/true, /*IsClone=*/false, /*IsCloned=*/false);
 671   } else if (SD->getKind() == SDDbgValue::CONST) {
 672     const Value *V = SD->getConst();
 673     if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
 674       if (CI->getBitWidth() > 64)
 675         MIB.addCImm(CI);
 676       else
 677         MIB.addImm(CI->getSExtValue());
 678     } else if (const ConstantFP *CF = dyn_cast<ConstantFP>(V)) {
 679       MIB.addFPImm(CF);
 680     } else {
 681       // Could be an Undef.  In any case insert an Undef so we can see what we
 682       // dropped.
 683       MIB.addReg(0U);
 684     }
 685   } else {
 686     // Insert an Undef so we can see what we dropped.
 687     MIB.addReg(0U);
 688   }
 689
 690   if (Offset != 0) // Indirect addressing.
 691     MIB.addImm(Offset);
 692   else
 693     MIB.addReg(0U, RegState::Debug);
 694
 695   MIB.addMetadata(MDPtr);
 696
 697   return &*MIB;
 698 }
 699
 700 /// EmitMachineNode - Generate machine code for a target-specific node and
 701 /// needed dependencies.
 702 ///
 703 void InstrEmitter::
 704 EmitMachineNode(SDNode *Node, bool IsClone, bool IsCloned,
 705                 DenseMap<SDValue, unsigned> &VRBaseMap) {
 706   unsigned Opc = Node->getMachineOpcode();
 707
 708   // Handle subreg insert/extract specially
 709   if (Opc == TargetOpcode::EXTRACT_SUBREG ||
 710       Opc == TargetOpcode::INSERT_SUBREG ||
 711       Opc == TargetOpcode::SUBREG_TO_REG) {
 712     EmitSubregNode(Node, VRBaseMap, IsClone, IsCloned);
 713     return;
 714   }
 715
 716   // Handle COPY_TO_REGCLASS specially.
 717   if (Opc == TargetOpcode::COPY_TO_REGCLASS) {
 718     EmitCopyToRegClassNode(Node, VRBaseMap);
 719     return;
 720   }
 721
 722   // Handle REG_SEQUENCE specially.
 723   if (Opc == TargetOpcode::REG_SEQUENCE) {
 724     EmitRegSequence(Node, VRBaseMap, IsClone, IsCloned);
 725     return;
 726   }
 727
 728   if (Opc == TargetOpcode::IMPLICIT_DEF)
 729     // We want a unique VR for each IMPLICIT_DEF use.
 730     return;
 731
 732   const MCInstrDesc &II = TII->get(Opc);
 733   unsigned NumResults = CountResults(Node);
 734   unsigned NumDefs = II.getNumDefs();
 735   const MCPhysReg *ScratchRegs = nullptr;
 736
 737   // Handle STACKMAP and PATCHPOINT specially and then use the generic code.
 738   if (Opc == TargetOpcode::STACKMAP || Opc == TargetOpcode::PATCHPOINT) {
 739     // Stackmaps do not have arguments and do not preserve their calling
 740     // convention. However, to simplify runtime support, they clobber the same
 741     // scratch registers as AnyRegCC.
 742     unsigned CC = CallingConv::AnyReg;
 743     if (Opc == TargetOpcode::PATCHPOINT) {
 744       CC = Node->getConstantOperandVal(PatchPointOpers::CCPos);
 745       NumDefs = NumResults;
 746     }
 747     ScratchRegs = TLI->getScratchRegisters((CallingConv::ID) CC);
 748   }
 749
 750   unsigned NumImpUses = 0;
 751   unsigned NodeOperands =
 752     countOperands(Node, II.getNumOperands() - NumDefs, NumImpUses);
 753   bool HasPhysRegOuts = NumResults > NumDefs && II.getImplicitDefs()!=nullptr;
 754 #ifndef NDEBUG
 755   unsigned NumMIOperands = NodeOperands + NumResults;
 756   if (II.isVariadic())
 757     assert(NumMIOperands >= II.getNumOperands() &&
 758            "Too few operands for a variadic node!");
 759   else
 760     assert(NumMIOperands >= II.getNumOperands() &&
 761            NumMIOperands <= II.getNumOperands() + II.getNumImplicitDefs() +
 762                             NumImpUses &&
 763            "#operands for dag node doesn't match .td file!");
 764 #endif
 765
 766   // Create the new machine instruction.
 767   MachineInstrBuilder MIB = BuildMI(*MF, Node->getDebugLoc(), II);
 768
 769   // Add result register values for things that are defined by this
 770   // instruction.
 771   if (NumResults)
 772     CreateVirtualRegisters(Node, MIB, II, IsClone, IsCloned, VRBaseMap);
 773
 774   // Emit all of the actual operands of this instruction, adding them to the
 775   // instruction as appropriate.
 776   bool HasOptPRefs = NumDefs > NumResults;
 777   assert((!HasOptPRefs || !HasPhysRegOuts) &&
 778          "Unable to cope with optional defs and phys regs defs!");
 779   unsigned NumSkip = HasOptPRefs ? NumDefs - NumResults : 0;
 780   for (unsigned i = NumSkip; i != NodeOperands; ++i)
 781     AddOperand(MIB, Node->getOperand(i), i-NumSkip+NumDefs, &II,
 782                VRBaseMap, /*IsDebug=*/false, IsClone, IsCloned);
 783
 784   // Add scratch registers as implicit def and early clobber
 785   if (ScratchRegs)
 786     for (unsigned i = 0; ScratchRegs[i]; ++i)
 787       MIB.addReg(ScratchRegs[i], RegState::ImplicitDefine |
 788                                  RegState::EarlyClobber);
 789
 790   // Transfer all of the memory reference descriptions of this instruction.
 791   MIB.setMemRefs(cast<MachineSDNode>(Node)->memoperands_begin(),
 792                  cast<MachineSDNode>(Node)->memoperands_end());
 793
 794   // Insert the instruction into position in the block. This needs to
 795   // happen before any custom inserter hook is called so that the
 796   // hook knows where in the block to insert the replacement code.
 797   MBB->insert(InsertPos, MIB);
 798
 799   // The MachineInstr may also define physregs instead of virtregs.  These
 800   // physreg values can reach other instructions in different ways:
 801   //
 802   // 1. When there is a use of a Node value beyond the explicitly defined
 803   //    virtual registers, we emit a CopyFromReg for one of the implicitly
 804   //    defined physregs.  This only happens when HasPhysRegOuts is true.
 805   //
 806   // 2. A CopyFromReg reading a physreg may be glued to this instruction.
 807   //
 808   // 3. A glued instruction may implicitly use a physreg.
 809   //
 810   // 4. A glued instruction may use a RegisterSDNode operand.
 811   //
 812   // Collect all the used physreg defs, and make sure that any unused physreg
 813   // defs are marked as dead.
 814   SmallVector<unsigned, 8> UsedRegs;
 815
 816   // Additional results must be physical register defs.
 817   if (HasPhysRegOuts) {
 818     for (unsigned i = NumDefs; i < NumResults; ++i) {
 819       unsigned Reg = II.getImplicitDefs()[i - NumDefs];
 820       if (!Node->hasAnyUseOfValue(i))
 821         continue;
 822       // This implicitly defined physreg has a use.
 823       UsedRegs.push_back(Reg);
 824       EmitCopyFromReg(Node, i, IsClone, IsCloned, Reg, VRBaseMap);
 825     }
 826   }
 827
 828   // Scan the glue chain for any used physregs.
 829   if (Node->getValueType(Node->getNumValues()-1) == MVT::Glue) {
 830     for (SDNode *F = Node->getGluedUser(); F; F = F->getGluedUser()) {
 831       if (F->getOpcode() == ISD::CopyFromReg) {
 832         UsedRegs.push_back(cast<RegisterSDNode>(F->getOperand(1))->getReg());
 833         continue;
 834       } else if (F->getOpcode() == ISD::CopyToReg) {
 835         // Skip CopyToReg nodes that are internal to the glue chain.
 836         continue;
 837       }
 838       // Collect declared implicit uses.
 839       const MCInstrDesc &MCID = TII->get(F->getMachineOpcode());
 840       UsedRegs.append(MCID.getImplicitUses(),
 841                       MCID.getImplicitUses() + MCID.getNumImplicitUses());
 842       // In addition to declared implicit uses, we must also check for
 843       // direct RegisterSDNode operands.
 844       for (unsigned i = 0, e = F->getNumOperands(); i != e; ++i)
 845         if (RegisterSDNode *R = dyn_cast<RegisterSDNode>(F->getOperand(i))) {
 846           unsigned Reg = R->getReg();
 847           if (TargetRegisterInfo::isPhysicalRegister(Reg))
 848             UsedRegs.push_back(Reg);
 849         }
 850     }
 851   }
 852
 853   // Finally mark unused registers as dead.
 854   if (!UsedRegs.empty() || II.getImplicitDefs())
 855     MIB->setPhysRegsDeadExcept(UsedRegs, *TRI);
 856
 857   // Run post-isel target hook to adjust this instruction if needed.
 858 #ifdef NDEBUG
 859   if (II.hasPostISelHook())
 860 #endif
 861     TLI->AdjustInstrPostInstrSelection(MIB, Node);
 862 }
 863
 864 /// EmitSpecialNode - Generate machine code for a target-independent node and
 865 /// needed dependencies.
 866 void InstrEmitter::
 867 EmitSpecialNode(SDNode *Node, bool IsClone, bool IsCloned,
 868                 DenseMap<SDValue, unsigned> &VRBaseMap) {
 869   switch (Node->getOpcode()) {
 870   default:
 871 #ifndef NDEBUG
 872     Node->dump();
 873 #endif
 874     llvm_unreachable("This target-independent node should have been selected!");
 875   case ISD::EntryToken:
 876     llvm_unreachable("EntryToken should have been excluded from the schedule!");
 877   case ISD::MERGE_VALUES:
 878   case ISD::TokenFactor: // fall thru
 879     break;
 880   case ISD::CopyToReg: {
 881     unsigned SrcReg;
 882     SDValue SrcVal = Node->getOperand(2);
 883     if (RegisterSDNode *R = dyn_cast<RegisterSDNode>(SrcVal))
 884       SrcReg = R->getReg();
 885     else
 886       SrcReg = getVR(SrcVal, VRBaseMap);
 887
 888     unsigned DestReg = cast<RegisterSDNode>(Node->getOperand(1))->getReg();
 889     if (SrcReg == DestReg) // Coalesced away the copy? Ignore.
 890       break;
 891
 892     BuildMI(*MBB, InsertPos, Node->getDebugLoc(), TII->get(TargetOpcode::COPY),
 893             DestReg).addReg(SrcReg);
 894     break;
 895   }
 896   case ISD::CopyFromReg: {
 897     unsigned SrcReg = cast<RegisterSDNode>(Node->getOperand(1))->getReg();
 898     EmitCopyFromReg(Node, 0, IsClone, IsCloned, SrcReg, VRBaseMap);
 899     break;
 900   }
 901   case ISD::EH_LABEL: {
 902     MCSymbol *S = cast<EHLabelSDNode>(Node)->getLabel();
 903     BuildMI(*MBB, InsertPos, Node->getDebugLoc(),
 904             TII->get(TargetOpcode::EH_LABEL)).addSym(S);
 905     break;
 906   }
 907
 908   case ISD::LIFETIME_START:
 909   case ISD::LIFETIME_END: {
 910     unsigned TarOp = (Node->getOpcode() == ISD::LIFETIME_START) ?
 911     TargetOpcode::LIFETIME_START : TargetOpcode::LIFETIME_END;
 912
 913     FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Node->getOperand(1));
 914     BuildMI(*MBB, InsertPos, Node->getDebugLoc(), TII->get(TarOp))
 915     .addFrameIndex(FI->getIndex());
 916     break;
 917   }
 918
 919   case ISD::INLINEASM: {
 920     unsigned NumOps = Node->getNumOperands();
 921     if (Node->getOperand(NumOps-1).getValueType() == MVT::Glue)
 922       --NumOps;  // Ignore the glue operand.
 923
 924     // Create the inline asm machine instruction.
 925     MachineInstrBuilder MIB = BuildMI(*MF, Node->getDebugLoc(),
 926                                       TII->get(TargetOpcode::INLINEASM));
 927
 928     // Add the asm string as an external symbol operand.
 929     SDValue AsmStrV = Node->getOperand(InlineAsm::Op_AsmString);
 930     const char *AsmStr = cast<ExternalSymbolSDNode>(AsmStrV)->getSymbol();
 931     MIB.addExternalSymbol(AsmStr);
 932
 933     // Add the HasSideEffect, isAlignStack, AsmDialect, MayLoad and MayStore
 934     // bits.
 935     int64_t ExtraInfo =
 936       cast<ConstantSDNode>(Node->getOperand(InlineAsm::Op_ExtraInfo))->
 937                           getZExtValue();
 938     MIB.addImm(ExtraInfo);
 939
 940     // Remember to operand index of the group flags.
 941     SmallVector<unsigned, 8> GroupIdx;
 942
 943     // Add all of the operand registers to the instruction.
 944     for (unsigned i = InlineAsm::Op_FirstOperand; i != NumOps;) {
 945       unsigned Flags =
 946         cast<ConstantSDNode>(Node->getOperand(i))->getZExtValue();
 947       const unsigned NumVals = InlineAsm::getNumOperandRegisters(Flags);
 948
 949       GroupIdx.push_back(MIB->getNumOperands());
 950       MIB.addImm(Flags);
 951       ++i;  // Skip the ID value.
 952
 953       switch (InlineAsm::getKind(Flags)) {
 954       default: llvm_unreachable("Bad flags!");
 955         case InlineAsm::Kind_RegDef:
 956         for (unsigned j = 0; j != NumVals; ++j, ++i) {
 957           unsigned Reg = cast<RegisterSDNode>(Node->getOperand(i))->getReg();
 958           // FIXME: Add dead flags for physical and virtual registers defined.
 959           // For now, mark physical register defs as implicit to help fast
 960           // regalloc. This makes inline asm look a lot like calls.
 961           MIB.addReg(Reg, RegState::Define |
 962                   getImplRegState(TargetRegisterInfo::isPhysicalRegister(Reg)));
 963         }
 964         break;
 965       case InlineAsm::Kind_RegDefEarlyClobber:
 966       case InlineAsm::Kind_Clobber:
 967         for (unsigned j = 0; j != NumVals; ++j, ++i) {
 968           unsigned Reg = cast<RegisterSDNode>(Node->getOperand(i))->getReg();
 969           MIB.addReg(Reg, RegState::Define | RegState::EarlyClobber |
 970                   getImplRegState(TargetRegisterInfo::isPhysicalRegister(Reg)));
 971         }
 972         break;
 973       case InlineAsm::Kind_RegUse:  // Use of register.
 974       case InlineAsm::Kind_Imm:  // Immediate.
 975       case InlineAsm::Kind_Mem:  // Addressing mode.
 976         // The addressing mode has been selected, just add all of the
 977         // operands to the machine instruction.
 978         for (unsigned j = 0; j != NumVals; ++j, ++i)
 979           AddOperand(MIB, Node->getOperand(i), 0, nullptr, VRBaseMap,
 980                      /*IsDebug=*/false, IsClone, IsCloned);
 981
 982         // Manually set isTied bits.
 983         if (InlineAsm::getKind(Flags) == InlineAsm::Kind_RegUse) {
 984           unsigned DefGroup = 0;
 985           if (InlineAsm::isUseOperandTiedToDef(Flags, DefGroup)) {
 986             unsigned DefIdx = GroupIdx[DefGroup] + 1;
 987             unsigned UseIdx = GroupIdx.back() + 1;
 988             for (unsigned j = 0; j != NumVals; ++j)
 989               MIB->tieOperands(DefIdx + j, UseIdx + j);
 990           }
 991         }
 992         break;
 993       }
 994     }
 995
 996     // Get the mdnode from the asm if it exists and add it to the instruction.
 997     SDValue MDV = Node->getOperand(InlineAsm::Op_MDNode);
 998     const MDNode *MD = cast<MDNodeSDNode>(MDV)->getMD();
 999     if (MD)
1000       MIB.addMetadata(MD);
1001
1002     MBB->insert(InsertPos, MIB);
1003     break;
1004   }
1005   }
1006 }
1007
1008 /// InstrEmitter - Construct an InstrEmitter and set it to start inserting
1009 /// at the given position in the given block.
1010 InstrEmitter::InstrEmitter(MachineBasicBlock *mbb,
1011                            MachineBasicBlock::iterator insertpos)
1012   : MF(mbb->getParent()),
1013     MRI(&MF->getRegInfo()),
1014     TM(&MF->getTarget()),
1015     TII(TM->getInstrInfo()),
1016     TRI(TM->getRegisterInfo()),
1017     TLI(TM->getTargetLowering()),
1018     MBB(mbb), InsertPos(insertpos) {
1019 }