lib/Target/X86/X86ExpandPseudo.cpp

   1 //===------- X86ExpandPseudo.cpp - Expand pseudo instructions -------------===//\r
   2 //\r
   3 //                     The LLVM Compiler Infrastructure\r
   4 //\r
   5 // This file is distributed under the University of Illinois Open Source\r
   6 // License. See LICENSE.TXT for details.\r
   7 //\r
   8 //===----------------------------------------------------------------------===//\r
   9 //\r
  10 // This file contains a pass that expands pseudo instructions into target\r
  11 // instructions to allow proper scheduling, if-conversion, other late\r
  12 // optimizations, or simply the encoding of the instructions.\r
  13 //\r
  14 //===----------------------------------------------------------------------===//\r
  15 \r
  16 #include "X86.h"\r
  17 #include "X86FrameLowering.h"\r
  18 #include "X86InstrBuilder.h"\r
  19 #include "X86InstrInfo.h"\r
  20 #include "X86MachineFunctionInfo.h"\r
  21 #include "X86Subtarget.h"\r
  22 #include "llvm/Analysis/EHPersonalities.h"\r
  23 #include "llvm/CodeGen/MachineFunctionPass.h"\r
  24 #include "llvm/CodeGen/MachineInstrBuilder.h"\r
  25 #include "llvm/CodeGen/Passes.h" // For IDs of passes that are preserved.\r
  26 #include "llvm/IR/GlobalValue.h"\r
  27 using namespace llvm;\r
  28 \r
  29 #define DEBUG_TYPE "x86-pseudo"\r
  30 \r
  31 namespace {\r
  32 class X86ExpandPseudo : public MachineFunctionPass {\r
  33 public:\r
  34   static char ID;\r
  35   X86ExpandPseudo() : MachineFunctionPass(ID) {}\r
  36 \r
  37   void getAnalysisUsage(AnalysisUsage &AU) const override {\r
  38     AU.setPreservesCFG();\r
  39     AU.addPreservedID(MachineLoopInfoID);\r
  40     AU.addPreservedID(MachineDominatorsID);\r
  41     MachineFunctionPass::getAnalysisUsage(AU);\r
  42   }\r
  43 \r
  44   const X86Subtarget *STI;\r
  45   const X86InstrInfo *TII;\r
  46   const X86RegisterInfo *TRI;\r
  47   const X86FrameLowering *X86FL;\r
  48 \r
  49   bool runOnMachineFunction(MachineFunction &Fn) override;\r
  50 \r
  51   const char *getPassName() const override {\r
  52     return "X86 pseudo instruction expansion pass";\r
  53   }\r
  54 \r
  55 private:\r
  56   bool ExpandMI(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI);\r
  57   bool ExpandMBB(MachineBasicBlock &MBB);\r
  58 };\r
  59 char X86ExpandPseudo::ID = 0;\r
  60 } // End anonymous namespace.\r
  61 \r
  62 /// If \p MBBI is a pseudo instruction, this method expands\r
  63 /// it to the corresponding (sequence of) actual instruction(s).\r
  64 /// \returns true if \p MBBI has been expanded.\r
  65 bool X86ExpandPseudo::ExpandMI(MachineBasicBlock &MBB,\r
  66                                MachineBasicBlock::iterator MBBI) {\r
  67   MachineInstr &MI = *MBBI;\r
  68   unsigned Opcode = MI.getOpcode();\r
  69   DebugLoc DL = MBBI->getDebugLoc();\r
  70   switch (Opcode) {\r
  71   default:\r
  72     return false;\r
  73   case X86::TCRETURNdi:\r
  74   case X86::TCRETURNri:\r
  75   case X86::TCRETURNmi:\r
  76   case X86::TCRETURNdi64:\r
  77   case X86::TCRETURNri64:\r
  78   case X86::TCRETURNmi64: {\r
  79     bool isMem = Opcode == X86::TCRETURNmi || Opcode == X86::TCRETURNmi64;\r
  80     MachineOperand &JumpTarget = MBBI->getOperand(0);\r
  81     MachineOperand &StackAdjust = MBBI->getOperand(isMem ? 5 : 1);\r
  82     assert(StackAdjust.isImm() && "Expecting immediate value.");\r
  83 \r
  84     // Adjust stack pointer.\r
  85     int StackAdj = StackAdjust.getImm();\r
  86 \r
  87     if (StackAdj) {\r
  88       // Check for possible merge with preceding ADD instruction.\r
  89       StackAdj += X86FL->mergeSPUpdates(MBB, MBBI, true);\r
  90       X86FL->emitSPUpdate(MBB, MBBI, StackAdj, /*InEpilogue=*/true);\r
  91     }\r
  92 \r
  93     // Jump to label or value in register.\r
  94     bool IsWin64 = STI->isTargetWin64();\r
  95     if (Opcode == X86::TCRETURNdi || Opcode == X86::TCRETURNdi64) {\r
  96       unsigned Op = (Opcode == X86::TCRETURNdi)\r
  97                         ? X86::TAILJMPd\r
  98                         : (IsWin64 ? X86::TAILJMPd64_REX : X86::TAILJMPd64);\r
  99       MachineInstrBuilder MIB = BuildMI(MBB, MBBI, DL, TII->get(Op));\r
 100       if (JumpTarget.isGlobal())\r
 101         MIB.addGlobalAddress(JumpTarget.getGlobal(), JumpTarget.getOffset(),\r
 102                              JumpTarget.getTargetFlags());\r
 103       else {\r
 104         assert(JumpTarget.isSymbol());\r
 105         MIB.addExternalSymbol(JumpTarget.getSymbolName(),\r
 106                               JumpTarget.getTargetFlags());\r
 107       }\r
 108     } else if (Opcode == X86::TCRETURNmi || Opcode == X86::TCRETURNmi64) {\r
 109       unsigned Op = (Opcode == X86::TCRETURNmi)\r
 110                         ? X86::TAILJMPm\r
 111                         : (IsWin64 ? X86::TAILJMPm64_REX : X86::TAILJMPm64);\r
 112       MachineInstrBuilder MIB = BuildMI(MBB, MBBI, DL, TII->get(Op));\r
 113       for (unsigned i = 0; i != 5; ++i)\r
 114         MIB.addOperand(MBBI->getOperand(i));\r
 115     } else if (Opcode == X86::TCRETURNri64) {\r
 116       BuildMI(MBB, MBBI, DL,\r
 117               TII->get(IsWin64 ? X86::TAILJMPr64_REX : X86::TAILJMPr64))\r
 118           .addReg(JumpTarget.getReg(), RegState::Kill);\r
 119     } else {\r
 120       BuildMI(MBB, MBBI, DL, TII->get(X86::TAILJMPr))\r
 121           .addReg(JumpTarget.getReg(), RegState::Kill);\r
 122     }\r
 123 \r
 124     MachineInstr *NewMI = std::prev(MBBI);\r
 125     NewMI->copyImplicitOps(*MBBI->getParent()->getParent(), MBBI);\r
 126 \r
 127     // Delete the pseudo instruction TCRETURN.\r
 128     MBB.erase(MBBI);\r
 129 \r
 130     return true;\r
 131   }\r
 132   case X86::EH_RETURN:\r
 133   case X86::EH_RETURN64: {\r
 134     MachineOperand &DestAddr = MBBI->getOperand(0);\r
 135     assert(DestAddr.isReg() && "Offset should be in register!");\r
 136     const bool Uses64BitFramePtr =\r
 137         STI->isTarget64BitLP64() || STI->isTargetNaCl64();\r
 138     unsigned StackPtr = TRI->getStackRegister();\r
 139     BuildMI(MBB, MBBI, DL,\r
 140             TII->get(Uses64BitFramePtr ? X86::MOV64rr : X86::MOV32rr), StackPtr)\r
 141         .addReg(DestAddr.getReg());\r
 142     // The EH_RETURN pseudo is really removed during the MC Lowering.\r
 143     return true;\r
 144   }\r
 145   case X86::IRET: {\r
 146     // Adjust stack to erase error code\r
 147     int64_t StackAdj = MBBI->getOperand(0).getImm();\r
 148     X86FL->emitSPUpdate(MBB, MBBI, StackAdj, true);\r
 149     // Replace pseudo with machine iret\r
 150     BuildMI(MBB, MBBI, DL,\r
 151             TII->get(STI->is64Bit() ? X86::IRET64 : X86::IRET32));\r
 152     MBB.erase(MBBI);\r
 153     return true;\r
 154   }\r
 155   case X86::EH_RESTORE: {\r
 156     // Restore ESP and EBP, and optionally ESI if required.\r
 157     bool IsSEH = isAsynchronousEHPersonality(classifyEHPersonality(\r
 158         MBB.getParent()->getFunction()->getPersonalityFn()));\r
 159     X86FL->restoreWin32EHStackPointers(MBB, MBBI, DL, /*RestoreSP=*/IsSEH);\r
 160     MBBI->eraseFromParent();\r
 161     return true;\r
 162   }\r
 163   }\r
 164   llvm_unreachable("Previous switch has a fallthrough?");\r
 165 }\r
 166 \r
 167 /// Expand all pseudo instructions contained in \p MBB.\r
 168 /// \returns true if any expansion occurred for \p MBB.\r
 169 bool X86ExpandPseudo::ExpandMBB(MachineBasicBlock &MBB) {\r
 170   bool Modified = false;\r
 171 \r
 172   // MBBI may be invalidated by the expansion.\r
 173   MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();\r
 174   while (MBBI != E) {\r
 175     MachineBasicBlock::iterator NMBBI = std::next(MBBI);\r
 176     Modified |= ExpandMI(MBB, MBBI);\r
 177     MBBI = NMBBI;\r
 178   }\r
 179 \r
 180   return Modified;\r
 181 }\r
 182 \r
 183 bool X86ExpandPseudo::runOnMachineFunction(MachineFunction &MF) {\r
 184   STI = &static_cast<const X86Subtarget &>(MF.getSubtarget());\r
 185   TII = STI->getInstrInfo();\r
 186   TRI = STI->getRegisterInfo();\r
 187   X86FL = STI->getFrameLowering();\r
 188 \r
 189   bool Modified = false;\r
 190   for (MachineBasicBlock &MBB : MF)\r
 191     Modified |= ExpandMBB(MBB);\r
 192   return Modified;\r
 193 }\r
 194 \r
 195 /// Returns an instance of the pseudo instruction expansion pass.\r
 196 FunctionPass *llvm::createX86ExpandPseudoPass() {\r
 197   return new X86ExpandPseudo();\r
 198 }\r