LLVM API Documentation

X86RegisterInfo.cpp

Go to the documentation of this file.
00001 //===- X86RegisterInfo.cpp - X86 Register Information -----------*- C++ -*-===//
00002 //
00003 //                     The LLVM Compiler Infrastructure
00004 //
00005 // This file is distributed under the University of Illinois Open Source
00006 // License. See LICENSE.TXT for details.
00007 //
00008 //===----------------------------------------------------------------------===//
00009 //
00010 // This file contains the X86 implementation of the TargetRegisterInfo class.
00011 // This file is responsible for the frame pointer elimination optimization
00012 // on X86.
00013 //
00014 //===----------------------------------------------------------------------===//
00015 
00016 #include "X86.h"
00017 #include "X86RegisterInfo.h"
00018 #include "X86InstrBuilder.h"
00019 #include "X86MachineFunctionInfo.h"
00020 #include "X86Subtarget.h"
00021 #include "X86TargetMachine.h"
00022 #include "llvm/Constants.h"
00023 #include "llvm/Function.h"
00024 #include "llvm/Type.h"
00025 #include "llvm/CodeGen/ValueTypes.h"
00026 #include "llvm/CodeGen/MachineInstrBuilder.h"
00027 #include "llvm/CodeGen/MachineFunction.h"
00028 #include "llvm/CodeGen/MachineFunctionPass.h"
00029 #include "llvm/CodeGen/MachineFrameInfo.h"
00030 #include "llvm/CodeGen/MachineLocation.h"
00031 #include "llvm/CodeGen/MachineModuleInfo.h"
00032 #include "llvm/CodeGen/MachineRegisterInfo.h"
00033 #include "llvm/Target/TargetAsmInfo.h"
00034 #include "llvm/Target/TargetFrameInfo.h"
00035 #include "llvm/Target/TargetInstrInfo.h"
00036 #include "llvm/Target/TargetMachine.h"
00037 #include "llvm/Target/TargetOptions.h"
00038 #include "llvm/ADT/BitVector.h"
00039 #include "llvm/ADT/STLExtras.h"
00040 #include "llvm/Support/CommandLine.h"
00041 #include "llvm/Support/Compiler.h"
00042 #include "llvm/Support/ErrorHandling.h"
00043 using namespace llvm;
00044 
00045 X86RegisterInfo::X86RegisterInfo(X86TargetMachine &tm,
00046                                  const TargetInstrInfo &tii)
00047   : X86GenRegisterInfo(tm.getSubtarget<X86Subtarget>().is64Bit() ?
00048                          X86::ADJCALLSTACKDOWN64 :
00049                          X86::ADJCALLSTACKDOWN32,
00050                        tm.getSubtarget<X86Subtarget>().is64Bit() ?
00051                          X86::ADJCALLSTACKUP64 :
00052                          X86::ADJCALLSTACKUP32),
00053     TM(tm), TII(tii) {
00054   // Cache some information.
00055   const X86Subtarget *Subtarget = &TM.getSubtarget<X86Subtarget>();
00056   Is64Bit = Subtarget->is64Bit();
00057   IsWin64 = Subtarget->isTargetWin64();
00058   StackAlign = TM.getFrameInfo()->getStackAlignment();
00059 
00060   if (Is64Bit) {
00061     SlotSize = 8;
00062     StackPtr = X86::RSP;
00063     FramePtr = X86::RBP;
00064   } else {
00065     SlotSize = 4;
00066     StackPtr = X86::ESP;
00067     FramePtr = X86::EBP;
00068   }
00069 }
00070 
00071 /// getDwarfRegNum - This function maps LLVM register identifiers to the DWARF
00072 /// specific numbering, used in debug info and exception tables.
00073 int X86RegisterInfo::getDwarfRegNum(unsigned RegNo, bool isEH) const {
00074   const X86Subtarget *Subtarget = &TM.getSubtarget<X86Subtarget>();
00075   unsigned Flavour = DWARFFlavour::X86_64;
00076 
00077   if (!Subtarget->is64Bit()) {
00078     if (Subtarget->isTargetDarwin()) {
00079       if (isEH)
00080         Flavour = DWARFFlavour::X86_32_DarwinEH;
00081       else
00082         Flavour = DWARFFlavour::X86_32_Generic;
00083     } else if (Subtarget->isTargetCygMing()) {
00084       // Unsupported by now, just quick fallback
00085       Flavour = DWARFFlavour::X86_32_Generic;
00086     } else {
00087       Flavour = DWARFFlavour::X86_32_Generic;
00088     }
00089   }
00090 
00091   return X86GenRegisterInfo::getDwarfRegNumFull(RegNo, Flavour);
00092 }
00093 
00094 /// getX86RegNum - This function maps LLVM register identifiers to their X86
00095 /// specific numbering, which is used in various places encoding instructions.
00096 unsigned X86RegisterInfo::getX86RegNum(unsigned RegNo) {
00097   switch(RegNo) {
00098   case X86::RAX: case X86::EAX: case X86::AX: case X86::AL: return N86::EAX;
00099   case X86::RCX: case X86::ECX: case X86::CX: case X86::CL: return N86::ECX;
00100   case X86::RDX: case X86::EDX: case X86::DX: case X86::DL: return N86::EDX;
00101   case X86::RBX: case X86::EBX: case X86::BX: case X86::BL: return N86::EBX;
00102   case X86::RSP: case X86::ESP: case X86::SP: case X86::SPL: case X86::AH:
00103     return N86::ESP;
00104   case X86::RBP: case X86::EBP: case X86::BP: case X86::BPL: case X86::CH:
00105     return N86::EBP;
00106   case X86::RSI: case X86::ESI: case X86::SI: case X86::SIL: case X86::DH:
00107     return N86::ESI;
00108   case X86::RDI: case X86::EDI: case X86::DI: case X86::DIL: case X86::BH:
00109     return N86::EDI;
00110 
00111   case X86::R8:  case X86::R8D:  case X86::R8W:  case X86::R8B:
00112     return N86::EAX;
00113   case X86::R9:  case X86::R9D:  case X86::R9W:  case X86::R9B:
00114     return N86::ECX;
00115   case X86::R10: case X86::R10D: case X86::R10W: case X86::R10B:
00116     return N86::EDX;
00117   case X86::R11: case X86::R11D: case X86::R11W: case X86::R11B:
00118     return N86::EBX;
00119   case X86::R12: case X86::R12D: case X86::R12W: case X86::R12B:
00120     return N86::ESP;
00121   case X86::R13: case X86::R13D: case X86::R13W: case X86::R13B:
00122     return N86::EBP;
00123   case X86::R14: case X86::R14D: case X86::R14W: case X86::R14B:
00124     return N86::ESI;
00125   case X86::R15: case X86::R15D: case X86::R15W: case X86::R15B:
00126     return N86::EDI;
00127 
00128   case X86::ST0: case X86::ST1: case X86::ST2: case X86::ST3:
00129   case X86::ST4: case X86::ST5: case X86::ST6: case X86::ST7:
00130     return RegNo-X86::ST0;
00131 
00132   case X86::XMM0: case X86::XMM8: case X86::MM0:
00133     return 0;
00134   case X86::XMM1: case X86::XMM9: case X86::MM1:
00135     return 1;
00136   case X86::XMM2: case X86::XMM10: case X86::MM2:
00137     return 2;
00138   case X86::XMM3: case X86::XMM11: case X86::MM3:
00139     return 3;
00140   case X86::XMM4: case X86::XMM12: case X86::MM4:
00141     return 4;
00142   case X86::XMM5: case X86::XMM13: case X86::MM5:
00143     return 5;
00144   case X86::XMM6: case X86::XMM14: case X86::MM6:
00145     return 6;
00146   case X86::XMM7: case X86::XMM15: case X86::MM7:
00147     return 7;
00148 
00149   default:
00150     assert(isVirtualRegister(RegNo) && "Unknown physical register!");
00151     llvm_unreachable("Register allocator hasn't allocated reg correctly yet!");
00152     return 0;
00153   }
00154 }
00155 
00156 const TargetRegisterClass *
00157 X86RegisterInfo::getMatchingSuperRegClass(const TargetRegisterClass *A,
00158                                           const TargetRegisterClass *B,
00159                                           unsigned SubIdx) const {
00160   switch (SubIdx) {
00161   default: return 0;
00162   case 1:
00163     // 8-bit
00164     if (B == &X86::GR8RegClass) {
00165       if (A->getSize() == 2 || A->getSize() == 4 || A->getSize() == 8)
00166         return A;
00167     } else if (B == &X86::GR8_ABCD_LRegClass || B == &X86::GR8_ABCD_HRegClass) {
00168       if (A == &X86::GR64RegClass || A == &X86::GR64_ABCDRegClass ||
00169           A == &X86::GR64_NOREXRegClass ||
00170           A == &X86::GR64_NOSPRegClass ||
00171           A == &X86::GR64_NOREX_NOSPRegClass)
00172         return &X86::GR64_ABCDRegClass;
00173       else if (A == &X86::GR32RegClass || A == &X86::GR32_ABCDRegClass ||
00174                A == &X86::GR32_NOREXRegClass ||
00175                A == &X86::GR32_NOSPRegClass)
00176         return &X86::GR32_ABCDRegClass;
00177       else if (A == &X86::GR16RegClass || A == &X86::GR16_ABCDRegClass ||
00178                A == &X86::GR16_NOREXRegClass)
00179         return &X86::GR16_ABCDRegClass;
00180     } else if (B == &X86::GR8_NOREXRegClass) {
00181       if (A == &X86::GR64RegClass || A == &X86::GR64_NOREXRegClass ||
00182           A == &X86::GR64_NOSPRegClass || A == &X86::GR64_NOREX_NOSPRegClass)
00183         return &X86::GR64_NOREXRegClass;
00184       else if (A == &X86::GR64_ABCDRegClass)
00185         return &X86::GR64_ABCDRegClass;
00186       else if (A == &X86::GR32RegClass || A == &X86::GR32_NOREXRegClass ||
00187                A == &X86::GR32_NOSPRegClass)
00188         return &X86::GR32_NOREXRegClass;
00189       else if (A == &X86::GR32_ABCDRegClass)
00190         return &X86::GR32_ABCDRegClass;
00191       else if (A == &X86::GR16RegClass || A == &X86::GR16_NOREXRegClass)
00192         return &X86::GR16_NOREXRegClass;
00193       else if (A == &X86::GR16_ABCDRegClass)
00194         return &X86::GR16_ABCDRegClass;
00195     }
00196     break;
00197   case 2:
00198     // 8-bit hi
00199     if (B == &X86::GR8_ABCD_HRegClass) {
00200       if (A == &X86::GR64RegClass || A == &X86::GR64_ABCDRegClass ||
00201           A == &X86::GR64_NOREXRegClass ||
00202           A == &X86::GR64_NOSPRegClass ||
00203           A == &X86::GR64_NOREX_NOSPRegClass)
00204         return &X86::GR64_ABCDRegClass;
00205       else if (A == &X86::GR32RegClass || A == &X86::GR32_ABCDRegClass ||
00206                A == &X86::GR32_NOREXRegClass || A == &X86::GR32_NOSPRegClass)
00207         return &X86::GR32_ABCDRegClass;
00208       else if (A == &X86::GR16RegClass || A == &X86::GR16_ABCDRegClass ||
00209                A == &X86::GR16_NOREXRegClass)
00210         return &X86::GR16_ABCDRegClass;
00211     }
00212     break;
00213   case 3:
00214     // 16-bit
00215     if (B == &X86::GR16RegClass) {
00216       if (A->getSize() == 4 || A->getSize() == 8)
00217         return A;
00218     } else if (B == &X86::GR16_ABCDRegClass) {
00219       if (A == &X86::GR64RegClass || A == &X86::GR64_ABCDRegClass ||
00220           A == &X86::GR64_NOREXRegClass ||
00221           A == &X86::GR64_NOSPRegClass ||
00222           A == &X86::GR64_NOREX_NOSPRegClass)
00223         return &X86::GR64_ABCDRegClass;
00224       else if (A == &X86::GR32RegClass || A == &X86::GR32_ABCDRegClass ||
00225                A == &X86::GR32_NOREXRegClass || A == &X86::GR32_NOSPRegClass)
00226         return &X86::GR32_ABCDRegClass;
00227     } else if (B == &X86::GR16_NOREXRegClass) {
00228       if (A == &X86::GR64RegClass || A == &X86::GR64_NOREXRegClass ||
00229           A == &X86::GR64_NOSPRegClass || A == &X86::GR64_NOREX_NOSPRegClass)
00230         return &X86::GR64_NOREXRegClass;
00231       else if (A == &X86::GR64_ABCDRegClass)
00232         return &X86::GR64_ABCDRegClass;
00233       else if (A == &X86::GR32RegClass || A == &X86::GR32_NOREXRegClass ||
00234                A == &X86::GR32_NOSPRegClass)
00235         return &X86::GR32_NOREXRegClass;
00236       else if (A == &X86::GR32_ABCDRegClass)
00237         return &X86::GR64_ABCDRegClass;
00238     }
00239     break;
00240   case 4:
00241     // 32-bit
00242     if (B == &X86::GR32RegClass || B == &X86::GR32_NOSPRegClass) {
00243       if (A->getSize() == 8)
00244         return A;
00245     } else if (B == &X86::GR32_ABCDRegClass) {
00246       if (A == &X86::GR64RegClass || A == &X86::GR64_ABCDRegClass ||
00247           A == &X86::GR64_NOREXRegClass ||
00248           A == &X86::GR64_NOSPRegClass ||
00249           A == &X86::GR64_NOREX_NOSPRegClass)
00250         return &X86::GR64_ABCDRegClass;
00251     } else if (B == &X86::GR32_NOREXRegClass) {
00252       if (A == &X86::GR64RegClass || A == &X86::GR64_NOREXRegClass ||
00253           A == &X86::GR64_NOSPRegClass || A == &X86::GR64_NOREX_NOSPRegClass)
00254         return &X86::GR64_NOREXRegClass;
00255       else if (A == &X86::GR64_ABCDRegClass)
00256         return &X86::GR64_ABCDRegClass;
00257     }
00258     break;
00259   }
00260   return 0;
00261 }
00262 
00263 const TargetRegisterClass *
00264 X86RegisterInfo::getPointerRegClass(unsigned Kind) const {
00265   switch (Kind) {
00266   default: llvm_unreachable("Unexpected Kind in getPointerRegClass!");
00267   case 0: // Normal GPRs.
00268     if (TM.getSubtarget<X86Subtarget>().is64Bit())
00269       return &X86::GR64RegClass;
00270     return &X86::GR32RegClass;
00271   case 1: // Normal GRPs except the stack pointer (for encoding reasons).
00272     if (TM.getSubtarget<X86Subtarget>().is64Bit())
00273       return &X86::GR64_NOSPRegClass;
00274     return &X86::GR32_NOSPRegClass;
00275   }
00276 }
00277 
00278 const TargetRegisterClass *
00279 X86RegisterInfo::getCrossCopyRegClass(const TargetRegisterClass *RC) const {
00280   if (RC == &X86::CCRRegClass) {
00281     if (Is64Bit)
00282       return &X86::GR64RegClass;
00283     else
00284       return &X86::GR32RegClass;
00285   }
00286   return NULL;
00287 }
00288 
00289 const unsigned *
00290 X86RegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) const {
00291   bool callsEHReturn = false;
00292 
00293   if (MF) {
00294     const MachineFrameInfo *MFI = MF->getFrameInfo();
00295     const MachineModuleInfo *MMI = MFI->getMachineModuleInfo();
00296     callsEHReturn = (MMI ? MMI->callsEHReturn() : false);
00297   }
00298 
00299   static const unsigned CalleeSavedRegs32Bit[] = {
00300     X86::ESI, X86::EDI, X86::EBX, X86::EBP,  0
00301   };
00302 
00303   static const unsigned CalleeSavedRegs32EHRet[] = {
00304     X86::EAX, X86::EDX, X86::ESI, X86::EDI, X86::EBX, X86::EBP,  0
00305   };
00306 
00307   static const unsigned CalleeSavedRegs64Bit[] = {
00308     X86::RBX, X86::R12, X86::R13, X86::R14, X86::R15, X86::RBP, 0
00309   };
00310 
00311   static const unsigned CalleeSavedRegs64EHRet[] = {
00312     X86::RAX, X86::RDX, X86::RBX, X86::R12,
00313     X86::R13, X86::R14, X86::R15, X86::RBP, 0
00314   };
00315 
00316   static const unsigned CalleeSavedRegsWin64[] = {
00317     X86::RBX,   X86::RBP,   X86::RDI,   X86::RSI,
00318     X86::R12,   X86::R13,   X86::R14,   X86::R15,
00319     X86::XMM6,  X86::XMM7,  X86::XMM8,  X86::XMM9,
00320     X86::XMM10, X86::XMM11, X86::XMM12, X86::XMM13,
00321     X86::XMM14, X86::XMM15, 0
00322   };
00323 
00324   if (Is64Bit) {
00325     if (IsWin64)
00326       return CalleeSavedRegsWin64;
00327     else
00328       return (callsEHReturn ? CalleeSavedRegs64EHRet : CalleeSavedRegs64Bit);
00329   } else {
00330     return (callsEHReturn ? CalleeSavedRegs32EHRet : CalleeSavedRegs32Bit);
00331   }
00332 }
00333 
00334 const TargetRegisterClass* const*
00335 X86RegisterInfo::getCalleeSavedRegClasses(const MachineFunction *MF) const {
00336   bool callsEHReturn = false;
00337 
00338   if (MF) {
00339     const MachineFrameInfo *MFI = MF->getFrameInfo();
00340     const MachineModuleInfo *MMI = MFI->getMachineModuleInfo();
00341     callsEHReturn = (MMI ? MMI->callsEHReturn() : false);
00342   }
00343 
00344   static const TargetRegisterClass * const CalleeSavedRegClasses32Bit[] = {
00345     &X86::GR32RegClass, &X86::GR32RegClass,
00346     &X86::GR32RegClass, &X86::GR32RegClass,  0
00347   };
00348   static const TargetRegisterClass * const CalleeSavedRegClasses32EHRet[] = {
00349     &X86::GR32RegClass, &X86::GR32RegClass,
00350     &X86::GR32RegClass, &X86::GR32RegClass,
00351     &X86::GR32RegClass, &X86::GR32RegClass,  0
00352   };
00353   static const TargetRegisterClass * const CalleeSavedRegClasses64Bit[] = {
00354     &X86::GR64RegClass, &X86::GR64RegClass,
00355     &X86::GR64RegClass, &X86::GR64RegClass,
00356     &X86::GR64RegClass, &X86::GR64RegClass, 0
00357   };
00358   static const TargetRegisterClass * const CalleeSavedRegClasses64EHRet[] = {
00359     &X86::GR64RegClass, &X86::GR64RegClass,
00360     &X86::GR64RegClass, &X86::GR64RegClass,
00361     &X86::GR64RegClass, &X86::GR64RegClass,
00362     &X86::GR64RegClass, &X86::GR64RegClass, 0
00363   };
00364   static const TargetRegisterClass * const CalleeSavedRegClassesWin64[] = {
00365     &X86::GR64RegClass,  &X86::GR64RegClass,
00366     &X86::GR64RegClass,  &X86::GR64RegClass,
00367     &X86::GR64RegClass,  &X86::GR64RegClass,
00368     &X86::GR64RegClass,  &X86::GR64RegClass,
00369     &X86::VR128RegClass, &X86::VR128RegClass,
00370     &X86::VR128RegClass, &X86::VR128RegClass,
00371     &X86::VR128RegClass, &X86::VR128RegClass,
00372     &X86::VR128RegClass, &X86::VR128RegClass,
00373     &X86::VR128RegClass, &X86::VR128RegClass, 0
00374   };
00375 
00376   if (Is64Bit) {
00377     if (IsWin64)
00378       return CalleeSavedRegClassesWin64;
00379     else
00380       return (callsEHReturn ?
00381               CalleeSavedRegClasses64EHRet : CalleeSavedRegClasses64Bit);
00382   } else {
00383     return (callsEHReturn ?
00384             CalleeSavedRegClasses32EHRet : CalleeSavedRegClasses32Bit);
00385   }
00386 }
00387 
00388 BitVector X86RegisterInfo::getReservedRegs(const MachineFunction &MF) const {
00389   BitVector Reserved(getNumRegs());
00390   // Set the stack-pointer register and its aliases as reserved.
00391   Reserved.set(X86::RSP);
00392   Reserved.set(X86::ESP);
00393   Reserved.set(X86::SP);
00394   Reserved.set(X86::SPL);
00395 
00396   // Set the frame-pointer register and its aliases as reserved if needed.
00397   if (hasFP(MF)) {
00398     Reserved.set(X86::RBP);
00399     Reserved.set(X86::EBP);
00400     Reserved.set(X86::BP);
00401     Reserved.set(X86::BPL);
00402   }
00403 
00404   // Mark the x87 stack registers as reserved, since they don't behave normally
00405   // with respect to liveness. We don't fully model the effects of x87 stack
00406   // pushes and pops after stackification.
00407   Reserved.set(X86::ST0);
00408   Reserved.set(X86::ST1);
00409   Reserved.set(X86::ST2);
00410   Reserved.set(X86::ST3);
00411   Reserved.set(X86::ST4);
00412   Reserved.set(X86::ST5);
00413   Reserved.set(X86::ST6);
00414   Reserved.set(X86::ST7);
00415   return Reserved;
00416 }
00417 
00418 //===----------------------------------------------------------------------===//
00419 // Stack Frame Processing methods
00420 //===----------------------------------------------------------------------===//
00421 
00422 static unsigned calculateMaxStackAlignment(const MachineFrameInfo *FFI) {
00423   unsigned MaxAlign = 0;
00424 
00425   for (int i = FFI->getObjectIndexBegin(),
00426          e = FFI->getObjectIndexEnd(); i != e; ++i) {
00427     if (FFI->isDeadObjectIndex(i))
00428       continue;
00429 
00430     unsigned Align = FFI->getObjectAlignment(i);
00431     MaxAlign = std::max(MaxAlign, Align);
00432   }
00433 
00434   return MaxAlign;
00435 }
00436 
00437 /// hasFP - Return true if the specified function should have a dedicated frame
00438 /// pointer register.  This is true if the function has variable sized allocas
00439 /// or if frame pointer elimination is disabled.
00440 bool X86RegisterInfo::hasFP(const MachineFunction &MF) const {
00441   const MachineFrameInfo *MFI = MF.getFrameInfo();
00442   const MachineModuleInfo *MMI = MFI->getMachineModuleInfo();
00443 
00444   return (NoFramePointerElim ||
00445           needsStackRealignment(MF) ||
00446           MFI->hasVarSizedObjects() ||
00447           MFI->isFrameAddressTaken() ||
00448           MF.getInfo<X86MachineFunctionInfo>()->getForceFramePointer() ||
00449           (MMI && MMI->callsUnwindInit()));
00450 }
00451 
00452 bool X86RegisterInfo::needsStackRealignment(const MachineFunction &MF) const {
00453   const MachineFrameInfo *MFI = MF.getFrameInfo();
00454 
00455   // FIXME: Currently we don't support stack realignment for functions with
00456   //        variable-sized allocas
00457   return (RealignStack &&
00458           (MFI->getMaxAlignment() > StackAlign &&
00459            !MFI->hasVarSizedObjects()));
00460 }
00461 
00462 bool X86RegisterInfo::hasReservedCallFrame(MachineFunction &MF) const {
00463   return !MF.getFrameInfo()->hasVarSizedObjects();
00464 }
00465 
00466 bool X86RegisterInfo::hasReservedSpillSlot(MachineFunction &MF, unsigned Reg,
00467                                            int &FrameIdx) const {
00468   if (Reg == FramePtr && hasFP(MF)) {
00469     FrameIdx = MF.getFrameInfo()->getObjectIndexBegin();
00470     return true;
00471   }
00472   return false;
00473 }
00474 
00475 int
00476 X86RegisterInfo::getFrameIndexOffset(MachineFunction &MF, int FI) const {
00477   const TargetFrameInfo &TFI = *MF.getTarget().getFrameInfo();
00478   MachineFrameInfo *MFI = MF.getFrameInfo();
00479   int Offset = MFI->getObjectOffset(FI) - TFI.getOffsetOfLocalArea();
00480   uint64_t StackSize = MFI->getStackSize();
00481 
00482   if (needsStackRealignment(MF)) {
00483     if (FI < 0) {
00484       // Skip the saved EBP.
00485       Offset += SlotSize;
00486     } else {
00487       unsigned Align = MFI->getObjectAlignment(FI);
00488       assert( (-(Offset + StackSize)) % Align == 0);
00489       Align = 0;
00490       return Offset + StackSize;
00491     }
00492     // FIXME: Support tail calls
00493   } else {
00494     if (!hasFP(MF))
00495       return Offset + StackSize;
00496 
00497     // Skip the saved EBP.
00498     Offset += SlotSize;
00499 
00500     // Skip the RETADDR move area
00501     X86MachineFunctionInfo *X86FI = MF.getInfo<X86MachineFunctionInfo>();
00502     int TailCallReturnAddrDelta = X86FI->getTCReturnAddrDelta();
00503     if (TailCallReturnAddrDelta < 0)
00504       Offset -= TailCallReturnAddrDelta;
00505   }
00506 
00507   return Offset;
00508 }
00509 
00510 void X86RegisterInfo::
00511 eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
00512                               MachineBasicBlock::iterator I) const {
00513   if (!hasReservedCallFrame(MF)) {
00514     // If the stack pointer can be changed after prologue, turn the
00515     // adjcallstackup instruction into a 'sub ESP, <amt>' and the
00516     // adjcallstackdown instruction into 'add ESP, <amt>'
00517     // TODO: consider using push / pop instead of sub + store / add
00518     MachineInstr *Old = I;
00519     uint64_t Amount = Old->getOperand(0).getImm();
00520     if (Amount != 0) {
00521       // We need to keep the stack aligned properly.  To do this, we round the
00522       // amount of space needed for the outgoing arguments up to the next
00523       // alignment boundary.
00524       Amount = (Amount + StackAlign - 1) / StackAlign * StackAlign;
00525 
00526       MachineInstr *New = 0;
00527       if (Old->getOpcode() == getCallFrameSetupOpcode()) {
00528         New = BuildMI(MF, Old->getDebugLoc(),
00529                       TII.get(Is64Bit ? X86::SUB64ri32 : X86::SUB32ri),
00530                       StackPtr)
00531           .addReg(StackPtr)
00532           .addImm(Amount);
00533       } else {
00534         assert(Old->getOpcode() == getCallFrameDestroyOpcode());
00535 
00536         // Factor out the amount the callee already popped.
00537         uint64_t CalleeAmt = Old->getOperand(1).getImm();
00538         Amount -= CalleeAmt;
00539   
00540       if (Amount) {
00541           unsigned Opc = (Amount < 128) ?
00542             (Is64Bit ? X86::ADD64ri8 : X86::ADD32ri8) :
00543             (Is64Bit ? X86::ADD64ri32 : X86::ADD32ri);
00544           New = BuildMI(MF, Old->getDebugLoc(), TII.get(Opc), StackPtr)
00545             .addReg(StackPtr)
00546             .addImm(Amount);
00547         }
00548       }
00549 
00550       if (New) {
00551         // The EFLAGS implicit def is dead.
00552         New->getOperand(3).setIsDead();
00553 
00554         // Replace the pseudo instruction with a new instruction.
00555         MBB.insert(I, New);
00556       }
00557     }
00558   } else if (I->getOpcode() == getCallFrameDestroyOpcode()) {
00559     // If we are performing frame pointer elimination and if the callee pops
00560     // something off the stack pointer, add it back.  We do this until we have
00561     // more advanced stack pointer tracking ability.
00562     if (uint64_t CalleeAmt = I->getOperand(1).getImm()) {
00563       unsigned Opc = (CalleeAmt < 128) ?
00564         (Is64Bit ? X86::SUB64ri8 : X86::SUB32ri8) :
00565         (Is64Bit ? X86::SUB64ri32 : X86::SUB32ri);
00566       MachineInstr *Old = I;
00567       MachineInstr *New =
00568         BuildMI(MF, Old->getDebugLoc(), TII.get(Opc), 
00569                 StackPtr)
00570           .addReg(StackPtr)
00571           .addImm(CalleeAmt);
00572 
00573       // The EFLAGS implicit def is dead.
00574       New->getOperand(3).setIsDead();
00575       MBB.insert(I, New);
00576     }
00577   }
00578 
00579   MBB.erase(I);
00580 }
00581 
00582 void X86RegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
00583                                           int SPAdj, RegScavenger *RS) const{
00584   assert(SPAdj == 0 && "Unexpected");
00585 
00586   unsigned i = 0;
00587   MachineInstr &MI = *II;
00588   MachineFunction &MF = *MI.getParent()->getParent();
00589 
00590   while (!MI.getOperand(i).isFI()) {
00591     ++i;
00592     assert(i < MI.getNumOperands() && "Instr doesn't have FrameIndex operand!");
00593   }
00594 
00595   int FrameIndex = MI.getOperand(i).getIndex();
00596   unsigned BasePtr;
00597 
00598   if (needsStackRealignment(MF))
00599     BasePtr = (FrameIndex < 0 ? FramePtr : StackPtr);
00600   else
00601     BasePtr = (hasFP(MF) ? FramePtr : StackPtr);
00602 
00603   // This must be part of a four operand memory reference.  Replace the
00604   // FrameIndex with base register with EBP.  Add an offset to the offset.
00605   MI.getOperand(i).ChangeToRegister(BasePtr, false);
00606 
00607   // Now add the frame object offset to the offset from EBP.
00608   if (MI.getOperand(i+3).isImm()) {
00609     // Offset is a 32-bit integer.
00610     int Offset = getFrameIndexOffset(MF, FrameIndex) +
00611       (int)(MI.getOperand(i + 3).getImm());
00612   
00613      MI.getOperand(i + 3).ChangeToImmediate(Offset);
00614   } else {
00615     // Offset is symbolic. This is extremely rare.
00616     uint64_t Offset = getFrameIndexOffset(MF, FrameIndex) +
00617                       (uint64_t)MI.getOperand(i+3).getOffset();
00618     MI.getOperand(i+3).setOffset(Offset);
00619   }
00620 }
00621 
00622 void
00623 X86RegisterInfo::processFunctionBeforeCalleeSavedScan(MachineFunction &MF,
00624                                                       RegScavenger *RS) const {
00625   MachineFrameInfo *MFI = MF.getFrameInfo();
00626 
00627   // Calculate and set max stack object alignment early, so we can decide
00628   // whether we will need stack realignment (and thus FP).
00629   unsigned MaxAlign = std::max(MFI->getMaxAlignment(),
00630                                calculateMaxStackAlignment(MFI));
00631 
00632   MFI->setMaxAlignment(MaxAlign);
00633 
00634   X86MachineFunctionInfo *X86FI = MF.getInfo<X86MachineFunctionInfo>();
00635   int32_t TailCallReturnAddrDelta = X86FI->getTCReturnAddrDelta();
00636 
00637   if (TailCallReturnAddrDelta < 0) {
00638     // create RETURNADDR area
00639     //   arg
00640     //   arg
00641     //   RETADDR
00642     //   { ...
00643     //     RETADDR area
00644     //     ...
00645     //   }
00646     //   [EBP]
00647     MFI->CreateFixedObject(-TailCallReturnAddrDelta,
00648                            (-1*SlotSize)+TailCallReturnAddrDelta);
00649   }
00650 
00651   if (hasFP(MF)) {
00652     assert((TailCallReturnAddrDelta <= 0) &&
00653            "The Delta should always be zero or negative");
00654     const TargetFrameInfo &TFI = *MF.getTarget().getFrameInfo();
00655 
00656     // Create a frame entry for the EBP register that must be saved.
00657     int FrameIdx = MFI->CreateFixedObject(SlotSize,
00658                                           -(int)SlotSize +
00659                                           TFI.getOffsetOfLocalArea() +
00660                                           TailCallReturnAddrDelta);
00661     assert(FrameIdx == MFI->getObjectIndexBegin() &&
00662            "Slot for EBP register must be last in order to be found!");
00663     FrameIdx = 0;
00664   }
00665 }
00666 
00667 /// emitSPUpdate - Emit a series of instructions to increment / decrement the
00668 /// stack pointer by a constant value.
00669 static
00670 void emitSPUpdate(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
00671                   unsigned StackPtr, int64_t NumBytes, bool Is64Bit,
00672                   const TargetInstrInfo &TII) {
00673   bool isSub = NumBytes < 0;
00674   uint64_t Offset = isSub ? -NumBytes : NumBytes;
00675   unsigned Opc = isSub
00676     ? ((Offset < 128) ?
00677        (Is64Bit ? X86::SUB64ri8 : X86::SUB32ri8) :
00678        (Is64Bit ? X86::SUB64ri32 : X86::SUB32ri))
00679     : ((Offset < 128) ?
00680        (Is64Bit ? X86::ADD64ri8 : X86::ADD32ri8) :
00681        (Is64Bit ? X86::ADD64ri32 : X86::ADD32ri));
00682   uint64_t Chunk = (1LL << 31) - 1;
00683   DebugLoc DL = (MBBI != MBB.end() ? MBBI->getDebugLoc() :
00684                  DebugLoc::getUnknownLoc());
00685 
00686   while (Offset) {
00687     uint64_t ThisVal = (Offset > Chunk) ? Chunk : Offset;
00688     MachineInstr *MI =
00689       BuildMI(MBB, MBBI, DL, TII.get(Opc), StackPtr)
00690         .addReg(StackPtr)
00691         .addImm(ThisVal);
00692     MI->getOperand(3).setIsDead(); // The EFLAGS implicit def is dead.
00693     Offset -= ThisVal;
00694   }
00695 }
00696 
00697 /// mergeSPUpdatesUp - Merge two stack-manipulating instructions upper iterator.
00698 static
00699 void mergeSPUpdatesUp(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
00700                       unsigned StackPtr, uint64_t *NumBytes = NULL) {
00701   if (MBBI == MBB.begin()) return;
00702 
00703   MachineBasicBlock::iterator PI = prior(MBBI);
00704   unsigned Opc = PI->getOpcode();
00705   if ((Opc == X86::ADD64ri32 || Opc == X86::ADD64ri8 ||
00706        Opc == X86::ADD32ri || Opc == X86::ADD32ri8) &&
00707       PI->getOperand(0).getReg() == StackPtr) {
00708     if (NumBytes)
00709       *NumBytes += PI->getOperand(2).getImm();
00710     MBB.erase(PI);
00711   } else if ((Opc == X86::SUB64ri32 || Opc == X86::SUB64ri8 ||
00712               Opc == X86::SUB32ri || Opc == X86::SUB32ri8) &&
00713              PI->getOperand(0).getReg() == StackPtr) {
00714     if (NumBytes)
00715       *NumBytes -= PI->getOperand(2).getImm();
00716     MBB.erase(PI);
00717   }
00718 }
00719 
00720 /// mergeSPUpdatesUp - Merge two stack-manipulating instructions lower iterator.
00721 static
00722 void mergeSPUpdatesDown(MachineBasicBlock &MBB,
00723                         MachineBasicBlock::iterator &MBBI,
00724                         unsigned StackPtr, uint64_t *NumBytes = NULL) {
00725   // FIXME: THIS ISN'T RUN!!!
00726   return;
00727 
00728   if (MBBI == MBB.end()) return;
00729 
00730   MachineBasicBlock::iterator NI = next(MBBI);
00731   if (NI == MBB.end()) return;
00732 
00733   unsigned Opc = NI->getOpcode();
00734   if ((Opc == X86::ADD64ri32 || Opc == X86::ADD64ri8 ||
00735        Opc == X86::ADD32ri || Opc == X86::ADD32ri8) &&
00736       NI->getOperand(0).getReg() == StackPtr) {
00737     if (NumBytes)
00738       *NumBytes -= NI->getOperand(2).getImm();
00739     MBB.erase(NI);
00740     MBBI = NI;
00741   } else if ((Opc == X86::SUB64ri32 || Opc == X86::SUB64ri8 ||
00742               Opc == X86::SUB32ri || Opc == X86::SUB32ri8) &&
00743              NI->getOperand(0).getReg() == StackPtr) {
00744     if (NumBytes)
00745       *NumBytes += NI->getOperand(2).getImm();
00746     MBB.erase(NI);
00747     MBBI = NI;
00748   }
00749 }
00750 
00751 /// mergeSPUpdates - Checks the instruction before/after the passed
00752 /// instruction. If it is an ADD/SUB instruction it is deleted argument and the
00753 /// stack adjustment is returned as a positive value for ADD and a negative for
00754 /// SUB.
00755 static int mergeSPUpdates(MachineBasicBlock &MBB,
00756                            MachineBasicBlock::iterator &MBBI,
00757                            unsigned StackPtr,
00758                            bool doMergeWithPrevious) {
00759   if ((doMergeWithPrevious && MBBI == MBB.begin()) ||
00760       (!doMergeWithPrevious && MBBI == MBB.end()))
00761     return 0;
00762 
00763   MachineBasicBlock::iterator PI = doMergeWithPrevious ? prior(MBBI) : MBBI;
00764   MachineBasicBlock::iterator NI = doMergeWithPrevious ? 0 : next(MBBI);
00765   unsigned Opc = PI->getOpcode();
00766   int Offset = 0;
00767 
00768   if ((Opc == X86::ADD64ri32 || Opc == X86::ADD64ri8 ||
00769        Opc == X86::ADD32ri || Opc == X86::ADD32ri8) &&
00770       PI->getOperand(0).getReg() == StackPtr){
00771     Offset += PI->getOperand(2).getImm();
00772     MBB.erase(PI);
00773     if (!doMergeWithPrevious) MBBI = NI;
00774   } else if ((Opc == X86::SUB64ri32 || Opc == X86::SUB64ri8 ||
00775               Opc == X86::SUB32ri || Opc == X86::SUB32ri8) &&
00776              PI->getOperand(0).getReg() == StackPtr) {
00777     Offset -= PI->getOperand(2).getImm();
00778     MBB.erase(PI);
00779     if (!doMergeWithPrevious) MBBI = NI;
00780   }
00781 
00782   return Offset;
00783 }
00784 
00785 void X86RegisterInfo::emitCalleeSavedFrameMoves(MachineFunction &MF,
00786                                                 unsigned LabelId,
00787                                                 unsigned FramePtr) const {
00788   MachineFrameInfo *MFI = MF.getFrameInfo();
00789   MachineModuleInfo *MMI = MFI->getMachineModuleInfo();
00790   if (!MMI) return;
00791 
00792   // Add callee saved registers to move list.
00793   const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo();
00794   if (CSI.empty()) return;
00795 
00796   std::vector<MachineMove> &Moves = MMI->getFrameMoves();
00797   const TargetData *TD = MF.getTarget().getTargetData();
00798   bool HasFP = hasFP(MF);
00799 
00800   // Calculate amount of bytes used for return address storing.
00801   int stackGrowth =
00802     (MF.getTarget().getFrameInfo()->getStackGrowthDirection() ==
00803      TargetFrameInfo::StackGrowsUp ?
00804      TD->getPointerSize() : -TD->getPointerSize());
00805 
00806   // FIXME: This is dirty hack. The code itself is pretty mess right now.
00807   // It should be rewritten from scratch and generalized sometimes.
00808 
00809   // Determine maximum offset (minumum due to stack growth).
00810   int64_t MaxOffset = 0;
00811   for (std::vector<CalleeSavedInfo>::const_iterator
00812          I = CSI.begin(), E = CSI.end(); I != E; ++I)
00813     MaxOffset = std::min(MaxOffset,
00814                          MFI->getObjectOffset(I->getFrameIdx()));
00815 
00816   // Calculate offsets.
00817   int64_t saveAreaOffset = (HasFP ? 3 : 2) * stackGrowth;
00818   for (std::vector<CalleeSavedInfo>::const_iterator
00819          I = CSI.begin(), E = CSI.end(); I != E; ++I) {
00820     int64_t Offset = MFI->getObjectOffset(I->getFrameIdx());
00821     unsigned Reg = I->getReg();
00822     Offset = MaxOffset - Offset + saveAreaOffset;
00823 
00824     // Don't output a new machine move if we're re-saving the frame
00825     // pointer. This happens when the PrologEpilogInserter has inserted an extra
00826     // "PUSH" of the frame pointer -- the "emitPrologue" method automatically
00827     // generates one when frame pointers are used. If we generate a "machine
00828     // move" for this extra "PUSH", the linker will lose track of the fact that
00829     // the frame pointer should have the value of the first "PUSH" when it's
00830     // trying to unwind.
00831     // 
00832     // FIXME: This looks inelegant. It's possibly correct, but it's covering up
00833     //        another bug. I.e., one where we generate a prolog like this:
00834     //
00835     //          pushl  %ebp
00836     //          movl   %esp, %ebp
00837     //          pushl  %ebp
00838     //          pushl  %esi
00839     //           ...
00840     //
00841     //        The immediate re-push of EBP is unnecessary. At the least, it's an
00842     //        optimization bug. EBP can be used as a scratch register in certain
00843     //        cases, but probably not when we have a frame pointer.
00844     if (HasFP && FramePtr == Reg)
00845       continue;
00846 
00847     MachineLocation CSDst(MachineLocation::VirtualFP, Offset);
00848     MachineLocation CSSrc(Reg);
00849     Moves.push_back(MachineMove(LabelId, CSDst, CSSrc));
00850   }
00851 }
00852 
00853 /// emitPrologue - Push callee-saved registers onto the stack, which
00854 /// automatically adjust the stack pointer. Adjust the stack pointer to allocate
00855 /// space for local variables. Also emit labels used by the exception handler to
00856 /// generate the exception handling frames.
00857 void X86RegisterInfo::emitPrologue(MachineFunction &MF) const {
00858   MachineBasicBlock &MBB = MF.front(); // Prologue goes in entry BB.
00859   MachineBasicBlock::iterator MBBI = MBB.begin();
00860   MachineFrameInfo *MFI = MF.getFrameInfo();
00861   const Function *Fn = MF.getFunction();
00862   const X86Subtarget *Subtarget = &MF.getTarget().getSubtarget<X86Subtarget>();
00863   MachineModuleInfo *MMI = MFI->getMachineModuleInfo();
00864   X86MachineFunctionInfo *X86FI = MF.getInfo<X86MachineFunctionInfo>();
00865   bool needsFrameMoves = (MMI && MMI->hasDebugInfo()) ||
00866                           !Fn->doesNotThrow() || UnwindTablesMandatory;
00867   uint64_t MaxAlign  = MFI->getMaxAlignment(); // Desired stack alignment.
00868   uint64_t StackSize = MFI->getStackSize();    // Number of bytes to allocate.
00869   bool HasFP = hasFP(MF);
00870   DebugLoc DL;
00871 
00872   // Add RETADDR move area to callee saved frame size.
00873   int TailCallReturnAddrDelta = X86FI->getTCReturnAddrDelta();
00874   if (TailCallReturnAddrDelta < 0)
00875     X86FI->setCalleeSavedFrameSize(
00876       X86FI->getCalleeSavedFrameSize() - TailCallReturnAddrDelta);
00877 
00878   // If this is x86-64 and the Red Zone is not disabled, if we are a leaf
00879   // function, and use up to 128 bytes of stack space, don't have a frame
00880   // pointer, calls, or dynamic alloca then we do not need to adjust the
00881   // stack pointer (we fit in the Red Zone).
00882   if (Is64Bit && !Fn->hasFnAttr(Attribute::NoRedZone) &&
00883       !needsStackRealignment(MF) &&
00884       !MFI->hasVarSizedObjects() &&                // No dynamic alloca.
00885       !MFI->hasCalls() &&                          // No calls.
00886       !Subtarget->isTargetWin64()) {               // Win64 has no Red Zone
00887     uint64_t MinSize = X86FI->getCalleeSavedFrameSize();
00888     if (HasFP) MinSize += SlotSize;
00889     StackSize = std::max(MinSize, StackSize > 128 ? StackSize - 128 : 0);
00890     MFI->setStackSize(StackSize);
00891   } else if (Subtarget->isTargetWin64()) {
00892     // We need to always allocate 32 bytes as register spill area.
00893     // FIXME: We might reuse these 32 bytes for leaf functions.
00894     StackSize += 32;
00895     MFI->setStackSize(StackSize);
00896   }
00897 
00898   // Insert stack pointer adjustment for later moving of return addr.  Only
00899   // applies to tail call optimized functions where the callee argument stack
00900   // size is bigger than the callers.
00901   if (TailCallReturnAddrDelta < 0) {
00902     MachineInstr *MI =
00903       BuildMI(MBB, MBBI, DL, TII.get(Is64Bit? X86::SUB64ri32 : X86::SUB32ri),
00904               StackPtr)
00905         .addReg(StackPtr)
00906         .addImm(-TailCallReturnAddrDelta);
00907     MI->getOperand(3).setIsDead(); // The EFLAGS implicit def is dead.
00908   }
00909 
00910   // Mapping for machine moves:
00911   //
00912   //   DST: VirtualFP AND
00913   //        SRC: VirtualFP              => DW_CFA_def_cfa_offset
00914   //        ELSE                        => DW_CFA_def_cfa
00915   //
00916   //   SRC: VirtualFP AND
00917   //        DST: Register               => DW_CFA_def_cfa_register
00918   //
00919   //   ELSE
00920   //        OFFSET < 0                  => DW_CFA_offset_extended_sf
00921   //        REG < 64                    => DW_CFA_offset + Reg
00922   //        ELSE                        => DW_CFA_offset_extended
00923 
00924   std::vector<MachineMove> &Moves = MMI->getFrameMoves();
00925   const TargetData *TD = MF.getTarget().getTargetData();
00926   uint64_t NumBytes = 0;
00927   int stackGrowth =
00928     (MF.getTarget().getFrameInfo()->getStackGrowthDirection() ==
00929      TargetFrameInfo::StackGrowsUp ?
00930        TD->getPointerSize() : -TD->getPointerSize());
00931 
00932   if (HasFP) {
00933     // Calculate required stack adjustment.
00934     uint64_t FrameSize = StackSize - SlotSize;
00935     if (needsStackRealignment(MF))
00936       FrameSize = (FrameSize + MaxAlign - 1) / MaxAlign * MaxAlign;
00937 
00938     NumBytes = FrameSize - X86FI->getCalleeSavedFrameSize();
00939 
00940     // Get the offset of the stack slot for the EBP register, which is
00941     // guaranteed to be the last slot by processFunctionBeforeFrameFinalized.
00942     // Update the frame offset adjustment.
00943     MFI->setOffsetAdjustment(-NumBytes);
00944 
00945     // Save EBP/RBP into the appropriate stack slot.
00946     BuildMI(MBB, MBBI, DL, TII.get(Is64Bit ? X86::PUSH64r : X86::PUSH32r))
00947       .addReg(FramePtr, RegState::Kill);
00948 
00949     if (needsFrameMoves) {
00950       // Mark the place where EBP/RBP was saved.
00951       unsigned FrameLabelId = MMI->NextLabelID();
00952       BuildMI(MBB, MBBI, DL, TII.get(X86::DBG_LABEL)).addImm(FrameLabelId);
00953 
00954       // Define the current CFA rule to use the provided offset.
00955       if (StackSize) {
00956         MachineLocation SPDst(MachineLocation::VirtualFP);
00957         MachineLocation SPSrc(MachineLocation::VirtualFP, 2 * stackGrowth);
00958         Moves.push_back(MachineMove(FrameLabelId, SPDst, SPSrc));
00959       } else {
00960         // FIXME: Verify & implement for FP
00961         MachineLocation SPDst(StackPtr);
00962         MachineLocation SPSrc(StackPtr, stackGrowth);
00963         Moves.push_back(MachineMove(FrameLabelId, SPDst, SPSrc));
00964       }
00965 
00966       // Change the rule for the FramePtr to be an "offset" rule.
00967       MachineLocation FPDst(MachineLocation::VirtualFP,
00968                             2 * stackGrowth);
00969       MachineLocation FPSrc(FramePtr);
00970       Moves.push_back(MachineMove(FrameLabelId, FPDst, FPSrc));
00971     }
00972 
00973     // Update EBP with the new base value...
00974     BuildMI(MBB, MBBI, DL,
00975             TII.get(Is64Bit ? X86::MOV64rr : X86::MOV32rr), FramePtr)
00976         .addReg(StackPtr);
00977 
00978     if (needsFrameMoves) {
00979       // Mark effective beginning of when frame pointer becomes valid.
00980       unsigned FrameLabelId = MMI->NextLabelID();
00981       BuildMI(MBB, MBBI, DL, TII.get(X86::DBG_LABEL)).addImm(FrameLabelId);
00982 
00983       // Define the current CFA to use the EBP/RBP register.
00984       MachineLocation FPDst(FramePtr);
00985       MachineLocation FPSrc(MachineLocation::VirtualFP);
00986       Moves.push_back(MachineMove(FrameLabelId, FPDst, FPSrc));
00987     }
00988 
00989     // Mark the FramePtr as live-in in every block except the entry.
00990     for (MachineFunction::iterator I = next(MF.begin()), E = MF.end();
00991          I != E; ++I)
00992       I->addLiveIn(FramePtr);
00993 
00994     // Realign stack
00995     if (needsStackRealignment(MF)) {
00996       MachineInstr *MI =
00997         BuildMI(MBB, MBBI, DL,
00998                 TII.get(Is64Bit ? X86::AND64ri32 : X86::AND32ri),
00999                 StackPtr).addReg(StackPtr).addImm(-MaxAlign);
01000 
01001       // The EFLAGS implicit def is dead.
01002       MI->getOperand(3).setIsDead();
01003     }
01004   } else {
01005     NumBytes = StackSize - X86FI->getCalleeSavedFrameSize();
01006   }
01007 
01008   // Skip the callee-saved push instructions.
01009   bool PushedRegs = false;
01010   int StackOffset = 2 * stackGrowth;
01011 
01012   while (MBBI != MBB.end() &&
01013          (MBBI->getOpcode() == X86::PUSH32r ||
01014           MBBI->getOpcode() == X86::PUSH64r)) {
01015     PushedRegs = true;
01016     ++MBBI;
01017 
01018     if (!HasFP && needsFrameMoves) {
01019       // Mark callee-saved push instruction.
01020       unsigned LabelId = MMI->NextLabelID();
01021       BuildMI(MBB, MBBI, DL, TII.get(X86::DBG_LABEL)).addImm(LabelId);
01022 
01023       // Define the current CFA rule to use the provided offset.
01024       unsigned Ptr = StackSize ?
01025         MachineLocation::VirtualFP : StackPtr;
01026       MachineLocation SPDst(Ptr);
01027       MachineLocation SPSrc(Ptr, StackOffset);
01028       Moves.push_back(MachineMove(LabelId, SPDst, SPSrc));
01029       StackOffset += stackGrowth;
01030     }
01031   }
01032 
01033   if (MBBI != MBB.end())
01034     DL = MBBI->getDebugLoc();
01035 
01036   // Adjust stack pointer: ESP -= numbytes.
01037   if (NumBytes >= 4096 && Subtarget->isTargetCygMing()) {
01038     // Check, whether EAX is livein for this function.
01039     bool isEAXAlive = false;
01040     for (MachineRegisterInfo::livein_iterator
01041            II = MF.getRegInfo().livein_begin(),
01042            EE = MF.getRegInfo().livein_end(); (II != EE) && !isEAXAlive; ++II) {
01043       unsigned Reg = II->first;
01044       isEAXAlive = (Reg == X86::EAX || Reg == X86::AX ||
01045                     Reg == X86::AH || Reg == X86::AL);
01046     }
01047 
01048     // Function prologue calls _alloca to probe the stack when allocating more
01049     // than 4k bytes in one go. Touching the stack at 4K increments is necessary
01050     // to ensure that the guard pages used by the OS virtual memory manager are
01051     // allocated in correct sequence.
01052     if (!isEAXAlive) {
01053       BuildMI(MBB, MBBI, DL, TII.get(X86::MOV32ri), X86::EAX)
01054         .addImm(NumBytes);
01055       BuildMI(MBB, MBBI, DL, TII.get(X86::CALLpcrel32))
01056         .addExternalSymbol("_alloca");
01057     } else {
01058       // Save EAX
01059       BuildMI(MBB, MBBI, DL, TII.get(X86::PUSH32r))
01060         .addReg(X86::EAX, RegState::Kill);
01061 
01062       // Allocate NumBytes-4 bytes on stack. We'll also use 4 already
01063       // allocated bytes for EAX.
01064       BuildMI(MBB, MBBI, DL, TII.get(X86::MOV32ri), X86::EAX)
01065         .addImm(NumBytes - 4);
01066       BuildMI(MBB, MBBI, DL, TII.get(X86::CALLpcrel32))
01067         .addExternalSymbol("_alloca");
01068 
01069       // Restore EAX
01070       MachineInstr *MI = addRegOffset(BuildMI(MF, DL, TII.get(X86::MOV32rm),
01071                                               X86::EAX),
01072                                       StackPtr, false, NumBytes - 4);
01073       MBB.insert(MBBI, MI);
01074     }
01075   } else if (NumBytes) {
01076     // If there is an SUB32ri of ESP immediately before this instruction, merge
01077     // the two. This can be the case when tail call elimination is enabled and
01078     // the callee has more arguments then the caller.
01079     NumBytes -= mergeSPUpdates(MBB, MBBI, StackPtr, true);
01080 
01081     // If there is an ADD32ri or SUB32ri of ESP immediately after this
01082     // instruction, merge the two instructions.
01083     mergeSPUpdatesDown(MBB, MBBI, StackPtr, &NumBytes);
01084 
01085     if (NumBytes)
01086       emitSPUpdate(MBB, MBBI, StackPtr, -(int64_t)NumBytes, Is64Bit, TII);
01087   }
01088 
01089   if ((NumBytes || PushedRegs) && needsFrameMoves) {
01090     // Mark end of stack pointer adjustment.
01091     unsigned LabelId = MMI->NextLabelID();
01092     BuildMI(MBB, MBBI, DL, TII.get(X86::DBG_LABEL)).addImm(LabelId);
01093 
01094     if (!HasFP && NumBytes) {
01095       // Define the current CFA rule to use the provided offset.
01096       if (StackSize) {
01097         MachineLocation SPDst(MachineLocation::VirtualFP);
01098         MachineLocation SPSrc(MachineLocation::VirtualFP,
01099                               -StackSize + stackGrowth);
01100         Moves.push_back(MachineMove(LabelId, SPDst, SPSrc));
01101       } else {
01102         // FIXME: Verify & implement for FP
01103         MachineLocation SPDst(StackPtr);
01104         MachineLocation SPSrc(StackPtr, stackGrowth);
01105         Moves.push_back(MachineMove(LabelId, SPDst, SPSrc));
01106       }
01107     }
01108 
01109     // Emit DWARF info specifying the offsets of the callee-saved registers.
01110     if (PushedRegs)
01111       emitCalleeSavedFrameMoves(MF, LabelId, HasFP ? FramePtr : StackPtr);
01112   }
01113 }
01114 
01115 void X86RegisterInfo::emitEpilogue(MachineFunction &MF,
01116                                    MachineBasicBlock &MBB) const {
01117   const MachineFrameInfo *MFI = MF.getFrameInfo();
01118   X86MachineFunctionInfo *X86FI = MF.getInfo<X86MachineFunctionInfo>();
01119   MachineBasicBlock::iterator MBBI = prior(MBB.end());
01120   unsigned RetOpcode = MBBI->getOpcode();
01121   DebugLoc DL = MBBI->getDebugLoc();
01122 
01123   switch (RetOpcode) {
01124   default:
01125     llvm_unreachable("Can only insert epilog into returning blocks");
01126   case X86::RET:
01127   case X86::RETI:
01128   case X86::TCRETURNdi:
01129   case X86::TCRETURNri:
01130   case X86::TCRETURNri64:
01131   case X86::TCRETURNdi64:
01132   case X86::EH_RETURN:
01133   case X86::EH_RETURN64:
01134   case X86::TAILJMPd:
01135   case X86::TAILJMPr:
01136   case X86::TAILJMPm:
01137     break;  // These are ok
01138   }
01139 
01140   // Get the number of bytes to allocate from the FrameInfo.
01141   uint64_t StackSize = MFI->getStackSize();
01142   uint64_t MaxAlign  = MFI->getMaxAlignment();
01143   unsigned CSSize = X86FI->getCalleeSavedFrameSize();
01144   uint64_t NumBytes = 0;
01145 
01146   if (hasFP(MF)) {
01147     // Calculate required stack adjustment.
01148     uint64_t FrameSize = StackSize - SlotSize;
01149     if (needsStackRealignment(MF))
01150       FrameSize = (FrameSize + MaxAlign - 1)/MaxAlign*MaxAlign;
01151 
01152     NumBytes = FrameSize - CSSize;
01153 
01154     // Pop EBP.
01155     BuildMI(MBB, MBBI, DL,
01156             TII.get(Is64Bit ? X86::POP64r : X86::POP32r), FramePtr);
01157   } else {
01158     NumBytes = StackSize - CSSize;
01159   }
01160 
01161   // Skip the callee-saved pop instructions.
01162   MachineBasicBlock::iterator LastCSPop = MBBI;
01163   while (MBBI != MBB.begin()) {
01164     MachineBasicBlock::iterator PI = prior(MBBI);
01165     unsigned Opc = PI->getOpcode();
01166 
01167     if (Opc != X86::POP32r && Opc != X86::POP64r &&
01168         !PI->getDesc().isTerminator())
01169       break;
01170 
01171     --MBBI;
01172   }
01173 
01174   DL = MBBI->getDebugLoc();
01175 
01176   // If there is an ADD32ri or SUB32ri of ESP immediately before this
01177   // instruction, merge the two instructions.
01178   if (NumBytes || MFI->hasVarSizedObjects())
01179     mergeSPUpdatesUp(MBB, MBBI, StackPtr, &NumBytes);
01180 
01181   // If dynamic alloca is used, then reset esp to point to the last callee-saved
01182   // slot before popping them off! Same applies for the case, when stack was
01183   // realigned.
01184   if (needsStackRealignment(MF)) {
01185     // We cannot use LEA here, because stack pointer was realigned. We need to
01186     // deallocate local frame back.
01187     if (CSSize) {
01188       emitSPUpdate(MBB, MBBI, StackPtr, NumBytes, Is64Bit, TII);
01189       MBBI = prior(LastCSPop);
01190     }
01191 
01192     BuildMI(MBB, MBBI, DL,
01193             TII.get(Is64Bit ? X86::MOV64rr : X86::MOV32rr),
01194             StackPtr).addReg(FramePtr);
01195   } else if (MFI->hasVarSizedObjects()) {
01196     if (CSSize) {
01197       unsigned Opc = Is64Bit ? X86::LEA64r : X86::LEA32r;
01198       MachineInstr *MI =
01199         addLeaRegOffset(BuildMI(MF, DL, TII.get(Opc), StackPtr),
01200                         FramePtr, false, -CSSize);
01201       MBB.insert(MBBI, MI);
01202     } else {
01203       BuildMI(MBB, MBBI, DL,
01204               TII.get(Is64Bit ? X86::MOV64rr : X86::MOV32rr), StackPtr)
01205         .addReg(FramePtr);
01206     }
01207   } else if (NumBytes) {
01208     // Adjust stack pointer back: ESP += numbytes.
01209     emitSPUpdate(MBB, MBBI, StackPtr, NumBytes, Is64Bit, TII);
01210   }
01211 
01212   // We're returning from function via eh_return.
01213   if (RetOpcode == X86::EH_RETURN || RetOpcode == X86::EH_RETURN64) {
01214     MBBI = prior(MBB.end());
01215     MachineOperand &DestAddr  = MBBI->getOperand(0);
01216     assert(DestAddr.isReg() && "Offset should be in register!");
01217     BuildMI(MBB, MBBI, DL,
01218             TII.get(Is64Bit ? X86::MOV64rr : X86::MOV32rr),
01219             StackPtr).addReg(DestAddr.getReg());
01220   } else if (RetOpcode == X86::TCRETURNri || RetOpcode == X86::TCRETURNdi ||
01221              RetOpcode== X86::TCRETURNri64 || RetOpcode == X86::TCRETURNdi64) {
01222     // Tail call return: adjust the stack pointer and jump to callee.
01223     MBBI = prior(MBB.end());
01224     MachineOperand &JumpTarget = MBBI->getOperand(0);
01225     MachineOperand &StackAdjust = MBBI->getOperand(1);
01226     assert(StackAdjust.isImm() && "Expecting immediate value.");
01227 
01228     // Adjust stack pointer.
01229     int StackAdj = StackAdjust.getImm();
01230     int MaxTCDelta = X86FI->getTCReturnAddrDelta();
01231     int Offset = 0;
01232     assert(MaxTCDelta <= 0 && "MaxTCDelta should never be positive");
01233 
01234     // Incoporate the retaddr area.
01235     Offset = StackAdj-MaxTCDelta;
01236     assert(Offset >= 0 && "Offset should never be negative");
01237 
01238     if (Offset) {
01239       // Check for possible merge with preceeding ADD instruction.
01240       Offset += mergeSPUpdates(MBB, MBBI, StackPtr, true);
01241       emitSPUpdate(MBB, MBBI, StackPtr, Offset, Is64Bit, TII);
01242     }
01243 
01244     // Jump to label or value in register.
01245     if (RetOpcode == X86::TCRETURNdi|| RetOpcode == X86::TCRETURNdi64)
01246       BuildMI(MBB, MBBI, DL, TII.get(X86::TAILJMPd)).
01247         addGlobalAddress(JumpTarget.getGlobal(), JumpTarget.getOffset());
01248     else if (RetOpcode== X86::TCRETURNri64)
01249       BuildMI(MBB, MBBI, DL, TII.get(X86::TAILJMPr64), JumpTarget.getReg());
01250     else
01251        BuildMI(MBB, MBBI, DL, TII.get(X86::TAILJMPr), JumpTarget.getReg());
01252 
01253     // Delete the pseudo instruction TCRETURN.
01254     MBB.erase(MBBI);
01255   } else if ((RetOpcode == X86::RET || RetOpcode == X86::RETI) &&
01256              (X86FI->getTCReturnAddrDelta() < 0)) {
01257     // Add the return addr area delta back since we are not tail calling.
01258     int delta = -1*X86FI->getTCReturnAddrDelta();
01259     MBBI = prior(MBB.end());
01260 
01261     // Check for possible merge with preceeding ADD instruction.
01262     delta += mergeSPUpdates(MBB, MBBI, StackPtr, true);
01263     emitSPUpdate(MBB, MBBI, StackPtr, delta, Is64Bit, TII);
01264   }
01265 }
01266 
01267 unsigned X86RegisterInfo::getRARegister() const {
01268   return Is64Bit ? X86::RIP     // Should have dwarf #16.
01269                  : X86::EIP;    // Should have dwarf #8.
01270 }
01271 
01272 unsigned X86RegisterInfo::getFrameRegister(MachineFunction &MF) const {
01273   return hasFP(MF) ? FramePtr : StackPtr;
01274 }
01275 
01276 void
01277 X86RegisterInfo::getInitialFrameState(std::vector<MachineMove> &Moves) const {
01278   // Calculate amount of bytes used for return address storing
01279   int stackGrowth = (Is64Bit ? -8 : -4);
01280 
01281   // Initial state of the frame pointer is esp+4.
01282   MachineLocation Dst(MachineLocation::VirtualFP);
01283   MachineLocation Src(StackPtr, stackGrowth);
01284   Moves.push_back(MachineMove(0, Dst, Src));
01285 
01286   // Add return address to move list
01287   MachineLocation CSDst(StackPtr, stackGrowth);
01288   MachineLocation CSSrc(getRARegister());
01289   Moves.push_back(MachineMove(0, CSDst, CSSrc));
01290 }
01291 
01292 unsigned X86RegisterInfo::getEHExceptionRegister() const {
01293   llvm_unreachable("What is the exception register");
01294   return 0;
01295 }
01296 
01297 unsigned X86RegisterInfo::getEHHandlerRegister() const {
01298   llvm_unreachable("What is the exception handler register");
01299   return 0;
01300 }
01301 
01302 namespace llvm {
01303 unsigned getX86SubSuperRegister(unsigned Reg, EVT VT, bool High) {
01304   switch (VT.getSimpleVT().SimpleTy) {
01305   default: return Reg;
01306   case MVT::i8:
01307     if (High) {
01308       switch (Reg) {
01309       default: return 0;
01310       case X86::AH: case X86::AL: case X86::AX: case X86::EAX: case X86::RAX:
01311         return X86::AH;
01312       case X86::DH: case X86::DL: case X86::DX: case X86::EDX: case X86::RDX:
01313         return X86::DH;
01314       case X86::CH: case X86::CL: case X86::CX: case X86::ECX: case X86::RCX:
01315         return X86::CH;
01316       case X86::BH: case X86::BL: case X86::BX: case X86::EBX: case X86::RBX:
01317         return X86::BH;
01318       }
01319     } else {
01320       switch (Reg) {
01321       default: return 0;
01322       case X86::AH: case X86::AL: case X86::AX: case X86::EAX: case X86::RAX:
01323         return X86::AL;
01324       case X86::DH: case X86::DL: case X86::DX: case X86::EDX: case X86::RDX:
01325         return X86::DL;
01326       case X86::CH: case X86::CL: case X86::CX: case X86::ECX: case X86::RCX:
01327         return X86::CL;
01328       case X86::BH: case X86::BL: case X86::BX: case X86::EBX: case X86::RBX:
01329         return X86::BL;
01330       case X86::SIL: case X86::SI: case X86::ESI: case X86::RSI:
01331         return X86::SIL;
01332       case X86::DIL: case X86::DI: case X86::EDI: case X86::RDI:
01333         return X86::DIL;
01334       case X86::BPL: case X86::BP: case X86::EBP: case X86::RBP:
01335         return X86::BPL;
01336       case X86::SPL: case X86::SP: case X86::ESP: case X86::RSP:
01337         return X86::SPL;
01338       case X86::R8B: case X86::R8W: case X86::R8D: case X86::R8:
01339         return X86::R8B;
01340       case X86::R9B: case X86::R9W: case X86::R9D: case X86::R9:
01341         return X86::R9B;
01342       case X86::R10B: case X86::R10W: case X86::R10D: case X86::R10:
01343         return X86::R10B;
01344       case X86::R11B: case X86::R11W: case X86::R11D: case X86::R11:
01345         return X86::R11B;
01346       case X86::R12B: case X86::R12W: case X86::R12D: case X86::R12:
01347         return X86::R12B;
01348       case X86::R13B: case X86::R13W: case X86::R13D: case X86::R13:
01349         return X86::R13B;
01350       case X86::R14B: case X86::R14W: case X86::R14D: case X86::R14:
01351         return X86::R14B;
01352       case X86::R15B: case X86::R15W: case X86::R15D: case X86::R15:
01353         return X86::R15B;
01354       }
01355     }
01356   case MVT::i16:
01357     switch (Reg) {
01358     default: return Reg;
01359     case X86::AH: case X86::AL: case X86::AX: case X86::EAX: case X86::RAX:
01360       return X86::AX;
01361     case X86::DH: case X86::DL: case X86::DX: case X86::EDX: case X86::RDX:
01362       return X86::DX;
01363     case X86::CH: case X86::CL: case X86::CX: case X86::ECX: case X86::RCX:
01364       return X86::CX;
01365     case X86::BH: case X86::BL: case X86::BX: case X86::EBX: case X86::RBX:
01366       return X86::BX;
01367     case X86::SIL: case X86::SI: case X86::ESI: case X86::RSI:
01368       return X86::SI;
01369     case X86::DIL: case X86::DI: case X86::EDI: case X86::RDI:
01370       return X86::DI;
01371     case X86::BPL: case X86::BP: case X86::EBP: case X86::RBP:
01372       return X86::BP;
01373     case X86::SPL: case X86::SP: case X86::ESP: case X86::RSP:
01374       return X86::SP;
01375     case X86::R8B: case X86::R8W: case X86::R8D: case X86::R8:
01376       return X86::R8W;
01377     case X86::R9B: case X86::R9W: case X86::R9D: case X86::R9:
01378       return X86::R9W;
01379     case X86::R10B: case X86::R10W: case X86::R10D: case X86::R10:
01380       return X86::R10W;
01381     case X86::R11B: case X86::R11W: case X86::R11D: case X86::R11:
01382       return X86::R11W;
01383     case X86::R12B: case X86::R12W: case X86::R12D: case X86::R12:
01384       return X86::R12W;
01385     case X86::R13B: case X86::R13W: case X86::R13D: case X86::R13:
01386       return X86::R13W;
01387     case X86::R14B: case X86::R14W: case X86::R14D: case X86::R14:
01388       return X86::R14W;
01389     case X86::R15B: case X86::R15W: case X86::R15D: case X86::R15:
01390       return X86::R15W;
01391     }
01392   case MVT::i32:
01393     switch (Reg) {
01394     default: return Reg;
01395     case X86::AH: case X86::AL: case X86::AX: case X86::EAX: case X86::RAX:
01396       return X86::EAX;
01397     case X86::DH: case X86::DL: case X86::DX: case X86::EDX: case X86::RDX:
01398       return X86::EDX;
01399     case X86::CH: case X86::CL: case X86::CX: case X86::ECX: case X86::RCX:
01400       return X86::ECX;
01401     case X86::BH: case X86::BL: case X86::BX: case X86::EBX: case X86::RBX:
01402       return X86::EBX;
01403     case X86::SIL: case X86::SI: case X86::ESI: case X86::RSI:
01404       return X86::ESI;
01405     case X86::DIL: case X86::DI: case X86::EDI: case X86::RDI:
01406       return X86::EDI;
01407     case X86::BPL: case X86::BP: case X86::EBP: case X86::RBP:
01408       return X86::EBP;
01409     case X86::SPL: case X86::SP: case X86::ESP: case X86::RSP:
01410       return X86::ESP;
01411     case X86::R8B: case X86::R8W: case X86::R8D: case X86::R8:
01412       return X86::R8D;
01413     case X86::R9B: case X86::R9W: case X86::R9D: case X86::R9:
01414       return X86::R9D;
01415     case X86::R10B: case X86::R10W: case X86::R10D: case X86::R10:
01416       return X86::R10D;
01417     case X86::R11B: case X86::R11W: case X86::R11D: case X86::R11:
01418       return X86::R11D;
01419     case X86::R12B: case X86::R12W: case X86::R12D: case X86::R12:
01420       return X86::R12D;
01421     case X86::R13B: case X86::R13W: case X86::R13D: case X86::R13:
01422       return X86::R13D;
01423     case X86::R14B: case X86::R14W: case X86::R14D: case X86::R14:
01424       return X86::R14D;
01425     case X86::R15B: case X86::R15W: case X86::R15D: case X86::R15:
01426       return X86::R15D;
01427     }
01428   case MVT::i64:
01429     switch (Reg) {
01430     default: return Reg;
01431     case X86::AH: case X86::AL: case X86::AX: case X86::EAX: case X86::RAX:
01432       return X86::RAX;
01433     case X86::DH: case X86::DL: case X86::DX: case X86::EDX: case X86::RDX:
01434       return X86::RDX;
01435     case X86::CH: case X86::CL: case X86::CX: case X86::ECX: case X86::RCX:
01436       return X86::RCX;
01437     case X86::BH: case X86::BL: case X86::BX: case X86::EBX: case X86::RBX:
01438       return X86::RBX;
01439     case X86::SIL: case X86::SI: case X86::ESI: case X86::RSI:
01440       return X86::RSI;
01441     case X86::DIL: case X86::DI: case X86::EDI: case X86::RDI:
01442       return X86::RDI;
01443     case X86::BPL: case X86::BP: case X86::EBP: case X86::RBP:
01444       return X86::RBP;
01445     case X86::SPL: case X86::SP: case X86::ESP: case X86::RSP:
01446       return X86::RSP;
01447     case X86::R8B: case X86::R8W: case X86::R8D: case X86::R8:
01448       return X86::R8;
01449     case X86::R9B: case X86::R9W: case X86::R9D: case X86::R9:
01450       return X86::R9;
01451     case X86::R10B: case X86::R10W: case X86::R10D: case X86::R10:
01452       return X86::R10;
01453     case X86::R11B: case X86::R11W: case X86::R11D: case X86::R11:
01454       return X86::R11;
01455     case X86::R12B: case X86::R12W: case X86::R12D: case X86::R12:
01456       return X86::R12;
01457     case X86::R13B: case X86::R13W: case X86::R13D: case X86::R13:
01458       return X86::R13;
01459     case X86::R14B: case X86::R14W: case X86::R14D: case X86::R14:
01460       return X86::R14;
01461     case X86::R15B: case X86::R15W: case X86::R15D: case X86::R15:
01462       return X86::R15;
01463     }
01464   }
01465 
01466   return Reg;
01467 }
01468 }
01469 
01470 #include "X86GenRegisterInfo.inc"
01471 
01472 namespace {
01473   struct VISIBILITY_HIDDEN MSAC : public MachineFunctionPass {
01474     static char ID;
01475     MSAC() : MachineFunctionPass(&ID) {}
01476 
01477     virtual bool runOnMachineFunction(MachineFunction &MF) {
01478       MachineFrameInfo *FFI = MF.getFrameInfo();
01479       MachineRegisterInfo &RI = MF.getRegInfo();
01480 
01481       // Calculate max stack alignment of all already allocated stack objects.
01482       unsigned MaxAlign = calculateMaxStackAlignment(FFI);
01483 
01484       // Be over-conservative: scan over all vreg defs and find, whether vector
01485       // registers are used. If yes - there is probability, that vector register
01486       // will be spilled and thus stack needs to be aligned properly.
01487       for (unsigned RegNum = TargetRegisterInfo::FirstVirtualRegister;
01488            RegNum < RI.getLastVirtReg(); ++RegNum)
01489         MaxAlign = std::max(MaxAlign, RI.getRegClass(RegNum)->getAlignment());
01490 
01491       if (FFI->getMaxAlignment() == MaxAlign)
01492         return false;
01493 
01494       FFI->setMaxAlignment(MaxAlign);
01495       return true;
01496     }
01497 
01498     virtual const char *getPassName() const {
01499       return "X86 Maximal Stack Alignment Calculator";
01500     }
01501 
01502     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
01503       AU.setPreservesCFG();
01504       MachineFunctionPass::getAnalysisUsage(AU);
01505     }
01506   };
01507 
01508   char MSAC::ID = 0;
01509 }
01510 
01511 FunctionPass*
01512 llvm::createX86MaxStackAlignmentCalculatorPass() { return new MSAC(); }