lib/Target/X86/X86RegisterInfo.cpp

   1 //===- X86RegisterInfo.cpp - X86 Register Information -----------*- C++ -*-===//
   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 file contains the X86 implementation of the TargetRegisterInfo class.
  11 // This file is responsible for the frame pointer elimination optimization
  12 // on X86.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "X86.h"
  17 #include "X86RegisterInfo.h"
  18 #include "X86InstrBuilder.h"
  19 #include "X86MachineFunctionInfo.h"
  20 #include "X86Subtarget.h"
  21 #include "X86TargetMachine.h"
  22 #include "llvm/Constants.h"
  23 #include "llvm/Function.h"
  24 #include "llvm/Type.h"
  25 #include "llvm/CodeGen/ValueTypes.h"
  26 #include "llvm/CodeGen/MachineInstrBuilder.h"
  27 #include "llvm/CodeGen/MachineFunction.h"
  28 #include "llvm/CodeGen/MachineFunctionPass.h"
  29 #include "llvm/CodeGen/MachineFrameInfo.h"
  30 #include "llvm/CodeGen/MachineLocation.h"
  31 #include "llvm/CodeGen/MachineModuleInfo.h"
  32 #include "llvm/CodeGen/MachineRegisterInfo.h"
  33 #include "llvm/MC/MCAsmInfo.h"
  34 #include "llvm/Target/TargetFrameInfo.h"
  35 #include "llvm/Target/TargetInstrInfo.h"
  36 #include "llvm/Target/TargetMachine.h"
  37 #include "llvm/Target/TargetOptions.h"
  38 #include "llvm/ADT/BitVector.h"
  39 #include "llvm/ADT/STLExtras.h"
  40 #include "llvm/Support/ErrorHandling.h"
  41 #include "llvm/Support/CommandLine.h"
  42 using namespace llvm;
  43
  44 static cl::opt<bool>
  45 ForceStackAlign("force-align-stack",
  46                  cl::desc("Force align the stack to the minimum alignment"
  47                            " needed for the function."),
  48                  cl::init(false), cl::Hidden);
  49
  50 X86RegisterInfo::X86RegisterInfo(X86TargetMachine &tm,
  51                                  const TargetInstrInfo &tii)
  52   : X86GenRegisterInfo(tm.getSubtarget<X86Subtarget>().is64Bit() ?
  53                          X86::ADJCALLSTACKDOWN64 :
  54                          X86::ADJCALLSTACKDOWN32,
  55                        tm.getSubtarget<X86Subtarget>().is64Bit() ?
  56                          X86::ADJCALLSTACKUP64 :
  57                          X86::ADJCALLSTACKUP32),
  58     TM(tm), TII(tii) {
  59   // Cache some information.
  60   const X86Subtarget *Subtarget = &TM.getSubtarget<X86Subtarget>();
  61   Is64Bit = Subtarget->is64Bit();
  62   IsWin64 = Subtarget->isTargetWin64();
  63   StackAlign = TM.getFrameInfo()->getStackAlignment();
  64
  65   if (Is64Bit) {
  66     SlotSize = 8;
  67     StackPtr = X86::RSP;
  68     FramePtr = X86::RBP;
  69   } else {
  70     SlotSize = 4;
  71     StackPtr = X86::ESP;
  72     FramePtr = X86::EBP;
  73   }
  74 }
  75
  76 /// getDwarfRegNum - This function maps LLVM register identifiers to the DWARF
  77 /// specific numbering, used in debug info and exception tables.
  78 int X86RegisterInfo::getDwarfRegNum(unsigned RegNo, bool isEH) const {
  79   const X86Subtarget *Subtarget = &TM.getSubtarget<X86Subtarget>();
  80   unsigned Flavour = DWARFFlavour::X86_64;
  81
  82   if (!Subtarget->is64Bit()) {
  83     if (Subtarget->isTargetDarwin()) {
  84       if (isEH)
  85         Flavour = DWARFFlavour::X86_32_DarwinEH;
  86       else
  87         Flavour = DWARFFlavour::X86_32_Generic;
  88     } else if (Subtarget->isTargetCygMing()) {
  89       // Unsupported by now, just quick fallback
  90       Flavour = DWARFFlavour::X86_32_Generic;
  91     } else {
  92       Flavour = DWARFFlavour::X86_32_Generic;
  93     }
  94   }
  95
  96   return X86GenRegisterInfo::getDwarfRegNumFull(RegNo, Flavour);
  97 }
  98
  99 /// getX86RegNum - This function maps LLVM register identifiers to their X86
 100 /// specific numbering, which is used in various places encoding instructions.
 101 unsigned X86RegisterInfo::getX86RegNum(unsigned RegNo) {
 102   switch(RegNo) {
 103   case X86::RAX: case X86::EAX: case X86::AX: case X86::AL: return N86::EAX;
 104   case X86::RCX: case X86::ECX: case X86::CX: case X86::CL: return N86::ECX;
 105   case X86::RDX: case X86::EDX: case X86::DX: case X86::DL: return N86::EDX;
 106   case X86::RBX: case X86::EBX: case X86::BX: case X86::BL: return N86::EBX;
 107   case X86::RSP: case X86::ESP: case X86::SP: case X86::SPL: case X86::AH:
 108     return N86::ESP;
 109   case X86::RBP: case X86::EBP: case X86::BP: case X86::BPL: case X86::CH:
 110     return N86::EBP;
 111   case X86::RSI: case X86::ESI: case X86::SI: case X86::SIL: case X86::DH:
 112     return N86::ESI;
 113   case X86::RDI: case X86::EDI: case X86::DI: case X86::DIL: case X86::BH:
 114     return N86::EDI;
 115
 116   case X86::R8:  case X86::R8D:  case X86::R8W:  case X86::R8B:
 117     return N86::EAX;
 118   case X86::R9:  case X86::R9D:  case X86::R9W:  case X86::R9B:
 119     return N86::ECX;
 120   case X86::R10: case X86::R10D: case X86::R10W: case X86::R10B:
 121     return N86::EDX;
 122   case X86::R11: case X86::R11D: case X86::R11W: case X86::R11B:
 123     return N86::EBX;
 124   case X86::R12: case X86::R12D: case X86::R12W: case X86::R12B:
 125     return N86::ESP;
 126   case X86::R13: case X86::R13D: case X86::R13W: case X86::R13B:
 127     return N86::EBP;
 128   case X86::R14: case X86::R14D: case X86::R14W: case X86::R14B:
 129     return N86::ESI;
 130   case X86::R15: case X86::R15D: case X86::R15W: case X86::R15B:
 131     return N86::EDI;
 132
 133   case X86::ST0: case X86::ST1: case X86::ST2: case X86::ST3:
 134   case X86::ST4: case X86::ST5: case X86::ST6: case X86::ST7:
 135     return RegNo-X86::ST0;
 136
 137   case X86::XMM0: case X86::XMM8:
 138   case X86::YMM0: case X86::YMM8: case X86::MM0:
 139     return 0;
 140   case X86::XMM1: case X86::XMM9:
 141   case X86::YMM1: case X86::YMM9: case X86::MM1:
 142     return 1;
 143   case X86::XMM2: case X86::XMM10:
 144   case X86::YMM2: case X86::YMM10: case X86::MM2:
 145     return 2;
 146   case X86::XMM3: case X86::XMM11:
 147   case X86::YMM3: case X86::YMM11: case X86::MM3:
 148     return 3;
 149   case X86::XMM4: case X86::XMM12:
 150   case X86::YMM4: case X86::YMM12: case X86::MM4:
 151     return 4;
 152   case X86::XMM5: case X86::XMM13:
 153   case X86::YMM5: case X86::YMM13: case X86::MM5:
 154     return 5;
 155   case X86::XMM6: case X86::XMM14:
 156   case X86::YMM6: case X86::YMM14: case X86::MM6:
 157     return 6;
 158   case X86::XMM7: case X86::XMM15:
 159   case X86::YMM7: case X86::YMM15: case X86::MM7:
 160     return 7;
 161
 162   case X86::ES:
 163     return 0;
 164   case X86::CS:
 165     return 1;
 166   case X86::SS:
 167     return 2;
 168   case X86::DS:
 169     return 3;
 170   case X86::FS:
 171     return 4;
 172   case X86::GS:
 173     return 5;
 174
 175   case X86::CR0:
 176     return 0;
 177   case X86::CR1:
 178     return 1;
 179   case X86::CR2:
 180     return 2;
 181   case X86::CR3:
 182     return 3;
 183   case X86::CR4:
 184     return 4;
 185
 186   case X86::DR0:
 187     return 0;
 188   case X86::DR1:
 189     return 1;
 190   case X86::DR2:
 191     return 2;
 192   case X86::DR3:
 193     return 3;
 194   case X86::DR4:
 195     return 4;
 196   case X86::DR5:
 197     return 5;
 198   case X86::DR6:
 199     return 6;
 200   case X86::DR7:
 201     return 7;
 202
 203   // Pseudo index registers are equivalent to a "none"
 204   // scaled index (See Intel Manual 2A, table 2-3)
 205   case X86::EIZ:
 206   case X86::RIZ:
 207     return 4;
 208
 209   default:
 210     assert(isVirtualRegister(RegNo) && "Unknown physical register!");
 211     llvm_unreachable("Register allocator hasn't allocated reg correctly yet!");
 212     return 0;
 213   }
 214 }
 215
 216 const TargetRegisterClass *
 217 X86RegisterInfo::getMatchingSuperRegClass(const TargetRegisterClass *A,
 218                                           const TargetRegisterClass *B,
 219                                           unsigned SubIdx) const {
 220   switch (SubIdx) {
 221   default: return 0;
 222   case X86::sub_8bit:
 223     if (B == &X86::GR8RegClass) {
 224       if (A->getSize() == 2 || A->getSize() == 4 || A->getSize() == 8)
 225         return A;
 226     } else if (B == &X86::GR8_ABCD_LRegClass || B == &X86::GR8_ABCD_HRegClass) {
 227       if (A == &X86::GR64RegClass || A == &X86::GR64_ABCDRegClass ||
 228           A == &X86::GR64_NOREXRegClass ||
 229           A == &X86::GR64_NOSPRegClass ||
 230           A == &X86::GR64_NOREX_NOSPRegClass)
 231         return &X86::GR64_ABCDRegClass;
 232       else if (A == &X86::GR32RegClass || A == &X86::GR32_ABCDRegClass ||
 233                A == &X86::GR32_NOREXRegClass ||
 234                A == &X86::GR32_NOSPRegClass)
 235         return &X86::GR32_ABCDRegClass;
 236       else if (A == &X86::GR16RegClass || A == &X86::GR16_ABCDRegClass ||
 237                A == &X86::GR16_NOREXRegClass)
 238         return &X86::GR16_ABCDRegClass;
 239     } else if (B == &X86::GR8_NOREXRegClass) {
 240       if (A == &X86::GR64RegClass || A == &X86::GR64_NOREXRegClass ||
 241           A == &X86::GR64_NOSPRegClass || A == &X86::GR64_NOREX_NOSPRegClass)
 242         return &X86::GR64_NOREXRegClass;
 243       else if (A == &X86::GR64_ABCDRegClass)
 244         return &X86::GR64_ABCDRegClass;
 245       else if (A == &X86::GR32RegClass || A == &X86::GR32_NOREXRegClass ||
 246                A == &X86::GR32_NOSPRegClass)
 247         return &X86::GR32_NOREXRegClass;
 248       else if (A == &X86::GR32_ABCDRegClass)
 249         return &X86::GR32_ABCDRegClass;
 250       else if (A == &X86::GR16RegClass || A == &X86::GR16_NOREXRegClass)
 251         return &X86::GR16_NOREXRegClass;
 252       else if (A == &X86::GR16_ABCDRegClass)
 253         return &X86::GR16_ABCDRegClass;
 254     }
 255     break;
 256   case X86::sub_8bit_hi:
 257     if (B == &X86::GR8_ABCD_HRegClass) {
 258       if (A == &X86::GR64RegClass || A == &X86::GR64_ABCDRegClass ||
 259           A == &X86::GR64_NOREXRegClass ||
 260           A == &X86::GR64_NOSPRegClass ||
 261           A == &X86::GR64_NOREX_NOSPRegClass)
 262         return &X86::GR64_ABCDRegClass;
 263       else if (A == &X86::GR32RegClass || A == &X86::GR32_ABCDRegClass ||
 264                A == &X86::GR32_NOREXRegClass || A == &X86::GR32_NOSPRegClass)
 265         return &X86::GR32_ABCDRegClass;
 266       else if (A == &X86::GR16RegClass || A == &X86::GR16_ABCDRegClass ||
 267                A == &X86::GR16_NOREXRegClass)
 268         return &X86::GR16_ABCDRegClass;
 269     }
 270     break;
 271   case X86::sub_16bit:
 272     if (B == &X86::GR16RegClass) {
 273       if (A->getSize() == 4 || A->getSize() == 8)
 274         return A;
 275     } else if (B == &X86::GR16_ABCDRegClass) {
 276       if (A == &X86::GR64RegClass || A == &X86::GR64_ABCDRegClass ||
 277           A == &X86::GR64_NOREXRegClass ||
 278           A == &X86::GR64_NOSPRegClass ||
 279           A == &X86::GR64_NOREX_NOSPRegClass)
 280         return &X86::GR64_ABCDRegClass;
 281       else if (A == &X86::GR32RegClass || A == &X86::GR32_ABCDRegClass ||
 282                A == &X86::GR32_NOREXRegClass || A == &X86::GR32_NOSPRegClass)
 283         return &X86::GR32_ABCDRegClass;
 284     } else if (B == &X86::GR16_NOREXRegClass) {
 285       if (A == &X86::GR64RegClass || A == &X86::GR64_NOREXRegClass ||
 286           A == &X86::GR64_NOSPRegClass || A == &X86::GR64_NOREX_NOSPRegClass)
 287         return &X86::GR64_NOREXRegClass;
 288       else if (A == &X86::GR64_ABCDRegClass)
 289         return &X86::GR64_ABCDRegClass;
 290       else if (A == &X86::GR32RegClass || A == &X86::GR32_NOREXRegClass ||
 291                A == &X86::GR32_NOSPRegClass)
 292         return &X86::GR32_NOREXRegClass;
 293       else if (A == &X86::GR32_ABCDRegClass)
 294         return &X86::GR64_ABCDRegClass;
 295     }
 296     break;
 297   case X86::sub_32bit:
 298     if (B == &X86::GR32RegClass || B == &X86::GR32_NOSPRegClass) {
 299       if (A->getSize() == 8)
 300         return A;
 301     } else if (B == &X86::GR32_ABCDRegClass) {
 302       if (A == &X86::GR64RegClass || A == &X86::GR64_ABCDRegClass ||
 303           A == &X86::GR64_NOREXRegClass ||
 304           A == &X86::GR64_NOSPRegClass ||
 305           A == &X86::GR64_NOREX_NOSPRegClass)
 306         return &X86::GR64_ABCDRegClass;
 307     } else if (B == &X86::GR32_NOREXRegClass) {
 308       if (A == &X86::GR64RegClass || A == &X86::GR64_NOREXRegClass ||
 309           A == &X86::GR64_NOSPRegClass || A == &X86::GR64_NOREX_NOSPRegClass)
 310         return &X86::GR64_NOREXRegClass;
 311       else if (A == &X86::GR64_ABCDRegClass)
 312         return &X86::GR64_ABCDRegClass;
 313     }
 314     break;
 315   case X86::sub_ss:
 316     if (B == &X86::FR32RegClass)
 317       return A;
 318     break;
 319   case X86::sub_sd:
 320     if (B == &X86::FR64RegClass)
 321       return A;
 322     break;
 323   case X86::sub_xmm:
 324     if (B == &X86::VR128RegClass)
 325       return A;
 326     break;
 327   }
 328   return 0;
 329 }
 330
 331 const TargetRegisterClass *
 332 X86RegisterInfo::getPointerRegClass(unsigned Kind) const {
 333   switch (Kind) {
 334   default: llvm_unreachable("Unexpected Kind in getPointerRegClass!");
 335   case 0: // Normal GPRs.
 336     if (TM.getSubtarget<X86Subtarget>().is64Bit())
 337       return &X86::GR64RegClass;
 338     return &X86::GR32RegClass;
 339   case 1: // Normal GRPs except the stack pointer (for encoding reasons).
 340     if (TM.getSubtarget<X86Subtarget>().is64Bit())
 341       return &X86::GR64_NOSPRegClass;
 342     return &X86::GR32_NOSPRegClass;
 343   }
 344 }
 345
 346 const TargetRegisterClass *
 347 X86RegisterInfo::getCrossCopyRegClass(const TargetRegisterClass *RC) const {
 348   if (RC == &X86::CCRRegClass) {
 349     if (Is64Bit)
 350       return &X86::GR64RegClass;
 351     else
 352       return &X86::GR32RegClass;
 353   }
 354   return NULL;
 355 }
 356
 357 const unsigned *
 358 X86RegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) const {
 359   bool callsEHReturn = false;
 360   bool ghcCall = false;
 361
 362   if (MF) {
 363     callsEHReturn = MF->getMMI().callsEHReturn();
 364     const Function *F = MF->getFunction();
 365     ghcCall = (F ? F->getCallingConv() == CallingConv::GHC : false);
 366   }
 367
 368   static const unsigned GhcCalleeSavedRegs[] = {
 369     0
 370   };
 371
 372   static const unsigned CalleeSavedRegs32Bit[] = {
 373     X86::ESI, X86::EDI, X86::EBX, X86::EBP,  0
 374   };
 375
 376   static const unsigned CalleeSavedRegs32EHRet[] = {
 377     X86::EAX, X86::EDX, X86::ESI, X86::EDI, X86::EBX, X86::EBP,  0
 378   };
 379
 380   static const unsigned CalleeSavedRegs64Bit[] = {
 381     X86::RBX, X86::R12, X86::R13, X86::R14, X86::R15, X86::RBP, 0
 382   };
 383
 384   static const unsigned CalleeSavedRegs64EHRet[] = {
 385     X86::RAX, X86::RDX, X86::RBX, X86::R12,
 386     X86::R13, X86::R14, X86::R15, X86::RBP, 0
 387   };
 388
 389   static const unsigned CalleeSavedRegsWin64[] = {
 390     X86::RBX,   X86::RBP,   X86::RDI,   X86::RSI,
 391     X86::R12,   X86::R13,   X86::R14,   X86::R15,
 392     X86::XMM6,  X86::XMM7,  X86::XMM8,  X86::XMM9,
 393     X86::XMM10, X86::XMM11, X86::XMM12, X86::XMM13,
 394     X86::XMM14, X86::XMM15, 0
 395   };
 396
 397   if (ghcCall) {
 398     return GhcCalleeSavedRegs;
 399   } else if (Is64Bit) {
 400     if (IsWin64)
 401       return CalleeSavedRegsWin64;
 402     else
 403       return (callsEHReturn ? CalleeSavedRegs64EHRet : CalleeSavedRegs64Bit);
 404   } else {
 405     return (callsEHReturn ? CalleeSavedRegs32EHRet : CalleeSavedRegs32Bit);
 406   }
 407 }
 408
 409 BitVector X86RegisterInfo::getReservedRegs(const MachineFunction &MF) const {
 410   BitVector Reserved(getNumRegs());
 411   // Set the stack-pointer register and its aliases as reserved.
 412   Reserved.set(X86::RSP);
 413   Reserved.set(X86::ESP);
 414   Reserved.set(X86::SP);
 415   Reserved.set(X86::SPL);
 416
 417   // Set the instruction pointer register and its aliases as reserved.
 418   Reserved.set(X86::RIP);
 419   Reserved.set(X86::EIP);
 420   Reserved.set(X86::IP);
 421
 422   // Set the frame-pointer register and its aliases as reserved if needed.
 423   if (hasFP(MF)) {
 424     Reserved.set(X86::RBP);
 425     Reserved.set(X86::EBP);
 426     Reserved.set(X86::BP);
 427     Reserved.set(X86::BPL);
 428   }
 429
 430   // Mark the x87 stack registers as reserved, since they don't behave normally
 431   // with respect to liveness. We don't fully model the effects of x87 stack
 432   // pushes and pops after stackification.
 433   Reserved.set(X86::ST0);
 434   Reserved.set(X86::ST1);
 435   Reserved.set(X86::ST2);
 436   Reserved.set(X86::ST3);
 437   Reserved.set(X86::ST4);
 438   Reserved.set(X86::ST5);
 439   Reserved.set(X86::ST6);
 440   Reserved.set(X86::ST7);
 441   return Reserved;
 442 }
 443
 444 //===----------------------------------------------------------------------===//
 445 // Stack Frame Processing methods
 446 //===----------------------------------------------------------------------===//
 447
 448 /// hasFP - Return true if the specified function should have a dedicated frame
 449 /// pointer register.  This is true if the function has variable sized allocas
 450 /// or if frame pointer elimination is disabled.
 451 bool X86RegisterInfo::hasFP(const MachineFunction &MF) const {
 452   const MachineFrameInfo *MFI = MF.getFrameInfo();
 453   const MachineModuleInfo &MMI = MF.getMMI();
 454
 455   return (DisableFramePointerElim(MF) ||
 456           needsStackRealignment(MF) ||
 457           MFI->hasVarSizedObjects() ||
 458           MFI->isFrameAddressTaken() ||
 459           MF.getInfo<X86MachineFunctionInfo>()->getForceFramePointer() ||
 460           MMI.callsUnwindInit());
 461 }
 462
 463 bool X86RegisterInfo::canRealignStack(const MachineFunction &MF) const {
 464   const MachineFrameInfo *MFI = MF.getFrameInfo();
 465   return (RealignStack &&
 466           !MFI->hasVarSizedObjects());
 467 }
 468
 469 bool X86RegisterInfo::needsStackRealignment(const MachineFunction &MF) const {
 470   const MachineFrameInfo *MFI = MF.getFrameInfo();
 471   const Function *F = MF.getFunction();
 472   bool requiresRealignment = ((MFI->getMaxAlignment() > StackAlign) ||
 473                                F->hasFnAttr(Attribute::StackAlignment));
 474
 475   // FIXME: Currently we don't support stack realignment for functions with
 476   //        variable-sized allocas.
 477   // FIXME: It's more complicated than this...
 478   if (0 && requiresRealignment && MFI->hasVarSizedObjects())
 479     report_fatal_error(
 480       "Stack realignment in presense of dynamic allocas is not supported");
 481
 482   // If we've requested that we force align the stack do so now.
 483   if (ForceStackAlign)
 484     return canRealignStack(MF);
 485
 486   return requiresRealignment && canRealignStack(MF);
 487 }
 488
 489 bool X86RegisterInfo::hasReservedCallFrame(const MachineFunction &MF) const {
 490   return !MF.getFrameInfo()->hasVarSizedObjects();
 491 }
 492
 493 bool X86RegisterInfo::hasReservedSpillSlot(const MachineFunction &MF,
 494                                            unsigned Reg, int &FrameIdx) const {
 495   if (Reg == FramePtr && hasFP(MF)) {
 496     FrameIdx = MF.getFrameInfo()->getObjectIndexBegin();
 497     return true;
 498   }
 499   return false;
 500 }
 501
 502 int
 503 X86RegisterInfo::getFrameIndexOffset(const MachineFunction &MF, int FI) const {
 504   const TargetFrameInfo &TFI = *MF.getTarget().getFrameInfo();
 505   const MachineFrameInfo *MFI = MF.getFrameInfo();
 506   int Offset = MFI->getObjectOffset(FI) - TFI.getOffsetOfLocalArea();
 507   uint64_t StackSize = MFI->getStackSize();
 508
 509   if (needsStackRealignment(MF)) {
 510     if (FI < 0) {
 511       // Skip the saved EBP.
 512       Offset += SlotSize;
 513     } else {
 514       unsigned Align = MFI->getObjectAlignment(FI);
 515       assert((-(Offset + StackSize)) % Align == 0);
 516       Align = 0;
 517       return Offset + StackSize;
 518     }
 519     // FIXME: Support tail calls
 520   } else {
 521     if (!hasFP(MF))
 522       return Offset + StackSize;
 523
 524     // Skip the saved EBP.
 525     Offset += SlotSize;
 526
 527     // Skip the RETADDR move area
 528     const X86MachineFunctionInfo *X86FI = MF.getInfo<X86MachineFunctionInfo>();
 529     int TailCallReturnAddrDelta = X86FI->getTCReturnAddrDelta();
 530     if (TailCallReturnAddrDelta < 0)
 531       Offset -= TailCallReturnAddrDelta;
 532   }
 533
 534   return Offset;
 535 }
 536
 537 static unsigned getSUBriOpcode(unsigned is64Bit, int64_t Imm) {
 538   if (is64Bit) {
 539     if (isInt<8>(Imm))
 540       return X86::SUB64ri8;
 541     return X86::SUB64ri32;
 542   } else {
 543     if (isInt<8>(Imm))
 544       return X86::SUB32ri8;
 545     return X86::SUB32ri;
 546   }
 547 }
 548
 549 static unsigned getADDriOpcode(unsigned is64Bit, int64_t Imm) {
 550   if (is64Bit) {
 551     if (isInt<8>(Imm))
 552       return X86::ADD64ri8;
 553     return X86::ADD64ri32;
 554   } else {
 555     if (isInt<8>(Imm))
 556       return X86::ADD32ri8;
 557     return X86::ADD32ri;
 558   }
 559 }
 560
 561 void X86RegisterInfo::
 562 eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
 563                               MachineBasicBlock::iterator I) const {
 564   if (!hasReservedCallFrame(MF)) {
 565     // If the stack pointer can be changed after prologue, turn the
 566     // adjcallstackup instruction into a 'sub ESP, <amt>' and the
 567     // adjcallstackdown instruction into 'add ESP, <amt>'
 568     // TODO: consider using push / pop instead of sub + store / add
 569     MachineInstr *Old = I;
 570     uint64_t Amount = Old->getOperand(0).getImm();
 571     if (Amount != 0) {
 572       // We need to keep the stack aligned properly.  To do this, we round the
 573       // amount of space needed for the outgoing arguments up to the next
 574       // alignment boundary.
 575       Amount = (Amount + StackAlign - 1) / StackAlign * StackAlign;
 576
 577       MachineInstr *New = 0;
 578       if (Old->getOpcode() == getCallFrameSetupOpcode()) {
 579         New = BuildMI(MF, Old->getDebugLoc(),
 580                       TII.get(getSUBriOpcode(Is64Bit, Amount)),
 581                       StackPtr)
 582           .addReg(StackPtr)
 583           .addImm(Amount);
 584       } else {
 585         assert(Old->getOpcode() == getCallFrameDestroyOpcode());
 586
 587         // Factor out the amount the callee already popped.
 588         uint64_t CalleeAmt = Old->getOperand(1).getImm();
 589         Amount -= CalleeAmt;
 590
 591       if (Amount) {
 592           unsigned Opc = getADDriOpcode(Is64Bit, Amount);
 593           New = BuildMI(MF, Old->getDebugLoc(), TII.get(Opc), StackPtr)
 594             .addReg(StackPtr)
 595             .addImm(Amount);
 596         }
 597       }
 598
 599       if (New) {
 600         // The EFLAGS implicit def is dead.
 601         New->getOperand(3).setIsDead();
 602
 603         // Replace the pseudo instruction with a new instruction.
 604         MBB.insert(I, New);
 605       }
 606     }
 607   } else if (I->getOpcode() == getCallFrameDestroyOpcode()) {
 608     // If we are performing frame pointer elimination and if the callee pops
 609     // something off the stack pointer, add it back.  We do this until we have
 610     // more advanced stack pointer tracking ability.
 611     if (uint64_t CalleeAmt = I->getOperand(1).getImm()) {
 612       unsigned Opc = getSUBriOpcode(Is64Bit, CalleeAmt);
 613       MachineInstr *Old = I;
 614       MachineInstr *New =
 615         BuildMI(MF, Old->getDebugLoc(), TII.get(Opc),
 616                 StackPtr)
 617           .addReg(StackPtr)
 618           .addImm(CalleeAmt);
 619
 620       // The EFLAGS implicit def is dead.
 621       New->getOperand(3).setIsDead();
 622       MBB.insert(I, New);
 623     }
 624   }
 625
 626   MBB.erase(I);
 627 }
 628
 629 unsigned
 630 X86RegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
 631                                      int SPAdj, FrameIndexValue *Value,
 632                                      RegScavenger *RS) const{
 633   assert(SPAdj == 0 && "Unexpected");
 634
 635   unsigned i = 0;
 636   MachineInstr &MI = *II;
 637   MachineFunction &MF = *MI.getParent()->getParent();
 638
 639   while (!MI.getOperand(i).isFI()) {
 640     ++i;
 641     assert(i < MI.getNumOperands() && "Instr doesn't have FrameIndex operand!");
 642   }
 643
 644   int FrameIndex = MI.getOperand(i).getIndex();
 645   unsigned BasePtr;
 646
 647   unsigned Opc = MI.getOpcode();
 648   bool AfterFPPop = Opc == X86::TAILJMPm64 || Opc == X86::TAILJMPm;
 649   if (needsStackRealignment(MF))
 650     BasePtr = (FrameIndex < 0 ? FramePtr : StackPtr);
 651   else if (AfterFPPop)
 652     BasePtr = StackPtr;
 653   else
 654     BasePtr = (hasFP(MF) ? FramePtr : StackPtr);
 655
 656   // This must be part of a four operand memory reference.  Replace the
 657   // FrameIndex with base register with EBP.  Add an offset to the offset.
 658   MI.getOperand(i).ChangeToRegister(BasePtr, false);
 659
 660   // Now add the frame object offset to the offset from EBP.
 661   int FIOffset;
 662   if (AfterFPPop) {
 663     // Tail call jmp happens after FP is popped.
 664     const TargetFrameInfo &TFI = *MF.getTarget().getFrameInfo();
 665     const MachineFrameInfo *MFI = MF.getFrameInfo();
 666     FIOffset = MFI->getObjectOffset(FrameIndex) - TFI.getOffsetOfLocalArea();
 667   } else
 668     FIOffset = getFrameIndexOffset(MF, FrameIndex);
 669
 670   if (MI.getOperand(i+3).isImm()) {
 671     // Offset is a 32-bit integer.
 672     int Offset = FIOffset + (int)(MI.getOperand(i + 3).getImm());
 673     MI.getOperand(i + 3).ChangeToImmediate(Offset);
 674   } else {
 675     // Offset is symbolic. This is extremely rare.
 676     uint64_t Offset = FIOffset + (uint64_t)MI.getOperand(i+3).getOffset();
 677     MI.getOperand(i+3).setOffset(Offset);
 678   }
 679   return 0;
 680 }
 681
 682 void
 683 X86RegisterInfo::processFunctionBeforeCalleeSavedScan(MachineFunction &MF,
 684                                                       RegScavenger *RS) const {
 685   MachineFrameInfo *MFI = MF.getFrameInfo();
 686
 687   X86MachineFunctionInfo *X86FI = MF.getInfo<X86MachineFunctionInfo>();
 688   int32_t TailCallReturnAddrDelta = X86FI->getTCReturnAddrDelta();
 689
 690   if (TailCallReturnAddrDelta < 0) {
 691     // create RETURNADDR area
 692     //   arg
 693     //   arg
 694     //   RETADDR
 695     //   { ...
 696     //     RETADDR area
 697     //     ...
 698     //   }
 699     //   [EBP]
 700     MFI->CreateFixedObject(-TailCallReturnAddrDelta,
 701                            (-1U*SlotSize)+TailCallReturnAddrDelta, true);
 702   }
 703
 704   if (hasFP(MF)) {
 705     assert((TailCallReturnAddrDelta <= 0) &&
 706            "The Delta should always be zero or negative");
 707     const TargetFrameInfo &TFI = *MF.getTarget().getFrameInfo();
 708
 709     // Create a frame entry for the EBP register that must be saved.
 710     int FrameIdx = MFI->CreateFixedObject(SlotSize,
 711                                           -(int)SlotSize +
 712                                           TFI.getOffsetOfLocalArea() +
 713                                           TailCallReturnAddrDelta,
 714                                           true);
 715     assert(FrameIdx == MFI->getObjectIndexBegin() &&
 716            "Slot for EBP register must be last in order to be found!");
 717     FrameIdx = 0;
 718   }
 719 }
 720
 721 /// emitSPUpdate - Emit a series of instructions to increment / decrement the
 722 /// stack pointer by a constant value.
 723 static
 724 void emitSPUpdate(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
 725                   unsigned StackPtr, int64_t NumBytes, bool Is64Bit,
 726                   const TargetInstrInfo &TII) {
 727   bool isSub = NumBytes < 0;
 728   uint64_t Offset = isSub ? -NumBytes : NumBytes;
 729   unsigned Opc = isSub ?
 730     getSUBriOpcode(Is64Bit, Offset) :
 731     getADDriOpcode(Is64Bit, Offset);
 732   uint64_t Chunk = (1LL << 31) - 1;
 733   DebugLoc DL = MBB.findDebugLoc(MBBI);
 734
 735   while (Offset) {
 736     uint64_t ThisVal = (Offset > Chunk) ? Chunk : Offset;
 737     MachineInstr *MI =
 738       BuildMI(MBB, MBBI, DL, TII.get(Opc), StackPtr)
 739         .addReg(StackPtr)
 740         .addImm(ThisVal);
 741     MI->getOperand(3).setIsDead(); // The EFLAGS implicit def is dead.
 742     Offset -= ThisVal;
 743   }
 744 }
 745
 746 /// mergeSPUpdatesUp - Merge two stack-manipulating instructions upper iterator.
 747 static
 748 void mergeSPUpdatesUp(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
 749                       unsigned StackPtr, uint64_t *NumBytes = NULL) {
 750   if (MBBI == MBB.begin()) return;
 751
 752   MachineBasicBlock::iterator PI = prior(MBBI);
 753   unsigned Opc = PI->getOpcode();
 754   if ((Opc == X86::ADD64ri32 || Opc == X86::ADD64ri8 ||
 755        Opc == X86::ADD32ri || Opc == X86::ADD32ri8) &&
 756       PI->getOperand(0).getReg() == StackPtr) {
 757     if (NumBytes)
 758       *NumBytes += PI->getOperand(2).getImm();
 759     MBB.erase(PI);
 760   } else if ((Opc == X86::SUB64ri32 || Opc == X86::SUB64ri8 ||
 761               Opc == X86::SUB32ri || Opc == X86::SUB32ri8) &&
 762              PI->getOperand(0).getReg() == StackPtr) {
 763     if (NumBytes)
 764       *NumBytes -= PI->getOperand(2).getImm();
 765     MBB.erase(PI);
 766   }
 767 }
 768
 769 /// mergeSPUpdatesUp - Merge two stack-manipulating instructions lower iterator.
 770 static
 771 void mergeSPUpdatesDown(MachineBasicBlock &MBB,
 772                         MachineBasicBlock::iterator &MBBI,
 773                         unsigned StackPtr, uint64_t *NumBytes = NULL) {
 774   // FIXME: THIS ISN'T RUN!!!
 775   return;
 776
 777   if (MBBI == MBB.end()) return;
 778
 779   MachineBasicBlock::iterator NI = llvm::next(MBBI);
 780   if (NI == MBB.end()) return;
 781
 782   unsigned Opc = NI->getOpcode();
 783   if ((Opc == X86::ADD64ri32 || Opc == X86::ADD64ri8 ||
 784        Opc == X86::ADD32ri || Opc == X86::ADD32ri8) &&
 785       NI->getOperand(0).getReg() == StackPtr) {
 786     if (NumBytes)
 787       *NumBytes -= NI->getOperand(2).getImm();
 788     MBB.erase(NI);
 789     MBBI = NI;
 790   } else if ((Opc == X86::SUB64ri32 || Opc == X86::SUB64ri8 ||
 791               Opc == X86::SUB32ri || Opc == X86::SUB32ri8) &&
 792              NI->getOperand(0).getReg() == StackPtr) {
 793     if (NumBytes)
 794       *NumBytes += NI->getOperand(2).getImm();
 795     MBB.erase(NI);
 796     MBBI = NI;
 797   }
 798 }
 799
 800 /// mergeSPUpdates - Checks the instruction before/after the passed
 801 /// instruction. If it is an ADD/SUB instruction it is deleted argument and the
 802 /// stack adjustment is returned as a positive value for ADD and a negative for
 803 /// SUB.
 804 static int mergeSPUpdates(MachineBasicBlock &MBB,
 805                            MachineBasicBlock::iterator &MBBI,
 806                            unsigned StackPtr,
 807                            bool doMergeWithPrevious) {
 808   if ((doMergeWithPrevious && MBBI == MBB.begin()) ||
 809       (!doMergeWithPrevious && MBBI == MBB.end()))
 810     return 0;
 811
 812   MachineBasicBlock::iterator PI = doMergeWithPrevious ? prior(MBBI) : MBBI;
 813   MachineBasicBlock::iterator NI = doMergeWithPrevious ? 0 : llvm::next(MBBI);
 814   unsigned Opc = PI->getOpcode();
 815   int Offset = 0;
 816
 817   if ((Opc == X86::ADD64ri32 || Opc == X86::ADD64ri8 ||
 818        Opc == X86::ADD32ri || Opc == X86::ADD32ri8) &&
 819       PI->getOperand(0).getReg() == StackPtr){
 820     Offset += PI->getOperand(2).getImm();
 821     MBB.erase(PI);
 822     if (!doMergeWithPrevious) MBBI = NI;
 823   } else if ((Opc == X86::SUB64ri32 || Opc == X86::SUB64ri8 ||
 824               Opc == X86::SUB32ri || Opc == X86::SUB32ri8) &&
 825              PI->getOperand(0).getReg() == StackPtr) {
 826     Offset -= PI->getOperand(2).getImm();
 827     MBB.erase(PI);
 828     if (!doMergeWithPrevious) MBBI = NI;
 829   }
 830
 831   return Offset;
 832 }
 833
 834 void X86RegisterInfo::emitCalleeSavedFrameMoves(MachineFunction &MF,
 835                                                 MCSymbol *Label,
 836                                                 unsigned FramePtr) const {
 837   MachineFrameInfo *MFI = MF.getFrameInfo();
 838   MachineModuleInfo &MMI = MF.getMMI();
 839
 840   // Add callee saved registers to move list.
 841   const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo();
 842   if (CSI.empty()) return;
 843
 844   std::vector<MachineMove> &Moves = MMI.getFrameMoves();
 845   const TargetData *TD = MF.getTarget().getTargetData();
 846   bool HasFP = hasFP(MF);
 847
 848   // Calculate amount of bytes used for return address storing.
 849   int stackGrowth =
 850     (MF.getTarget().getFrameInfo()->getStackGrowthDirection() ==
 851      TargetFrameInfo::StackGrowsUp ?
 852      TD->getPointerSize() : -TD->getPointerSize());
 853
 854   // FIXME: This is dirty hack. The code itself is pretty mess right now.
 855   // It should be rewritten from scratch and generalized sometimes.
 856
 857   // Determine maximum offset (minumum due to stack growth).
 858   int64_t MaxOffset = 0;
 859   for (std::vector<CalleeSavedInfo>::const_iterator
 860          I = CSI.begin(), E = CSI.end(); I != E; ++I)
 861     MaxOffset = std::min(MaxOffset,
 862                          MFI->getObjectOffset(I->getFrameIdx()));
 863
 864   // Calculate offsets.
 865   int64_t saveAreaOffset = (HasFP ? 3 : 2) * stackGrowth;
 866   for (std::vector<CalleeSavedInfo>::const_iterator
 867          I = CSI.begin(), E = CSI.end(); I != E; ++I) {
 868     int64_t Offset = MFI->getObjectOffset(I->getFrameIdx());
 869     unsigned Reg = I->getReg();
 870     Offset = MaxOffset - Offset + saveAreaOffset;
 871
 872     // Don't output a new machine move if we're re-saving the frame
 873     // pointer. This happens when the PrologEpilogInserter has inserted an extra
 874     // "PUSH" of the frame pointer -- the "emitPrologue" method automatically
 875     // generates one when frame pointers are used. If we generate a "machine
 876     // move" for this extra "PUSH", the linker will lose track of the fact that
 877     // the frame pointer should have the value of the first "PUSH" when it's
 878     // trying to unwind.
 879     //
 880     // FIXME: This looks inelegant. It's possibly correct, but it's covering up
 881     //        another bug. I.e., one where we generate a prolog like this:
 882     //
 883     //          pushl  %ebp
 884     //          movl   %esp, %ebp
 885     //          pushl  %ebp
 886     //          pushl  %esi
 887     //           ...
 888     //
 889     //        The immediate re-push of EBP is unnecessary. At the least, it's an
 890     //        optimization bug. EBP can be used as a scratch register in certain
 891     //        cases, but probably not when we have a frame pointer.
 892     if (HasFP && FramePtr == Reg)
 893       continue;
 894
 895     MachineLocation CSDst(MachineLocation::VirtualFP, Offset);
 896     MachineLocation CSSrc(Reg);
 897     Moves.push_back(MachineMove(Label, CSDst, CSSrc));
 898   }
 899 }
 900
 901 /// emitPrologue - Push callee-saved registers onto the stack, which
 902 /// automatically adjust the stack pointer. Adjust the stack pointer to allocate
 903 /// space for local variables. Also emit labels used by the exception handler to
 904 /// generate the exception handling frames.
 905 void X86RegisterInfo::emitPrologue(MachineFunction &MF) const {
 906   MachineBasicBlock &MBB = MF.front(); // Prologue goes in entry BB.
 907   MachineBasicBlock::iterator MBBI = MBB.begin();
 908   MachineFrameInfo *MFI = MF.getFrameInfo();
 909   const Function *Fn = MF.getFunction();
 910   const X86Subtarget *Subtarget = &MF.getTarget().getSubtarget<X86Subtarget>();
 911   MachineModuleInfo &MMI = MF.getMMI();
 912   X86MachineFunctionInfo *X86FI = MF.getInfo<X86MachineFunctionInfo>();
 913   bool needsFrameMoves = MMI.hasDebugInfo() ||
 914                           !Fn->doesNotThrow() || UnwindTablesMandatory;
 915   uint64_t MaxAlign  = MFI->getMaxAlignment(); // Desired stack alignment.
 916   uint64_t StackSize = MFI->getStackSize();    // Number of bytes to allocate.
 917   bool HasFP = hasFP(MF);
 918   DebugLoc DL;
 919
 920   // If we're forcing a stack realignment we can't rely on just the frame
 921   // info, we need to know the ABI stack alignment as well in case we
 922   // have a call out.  Otherwise just make sure we have some alignment - we'll
 923   // go with the minimum SlotSize.
 924   if (ForceStackAlign) {
 925     if (MFI->hasCalls())
 926       MaxAlign = (StackAlign > MaxAlign) ? StackAlign : MaxAlign;
 927     else if (MaxAlign < SlotSize)
 928       MaxAlign = SlotSize;
 929   }
 930
 931   // Add RETADDR move area to callee saved frame size.
 932   int TailCallReturnAddrDelta = X86FI->getTCReturnAddrDelta();
 933   if (TailCallReturnAddrDelta < 0)
 934     X86FI->setCalleeSavedFrameSize(
 935       X86FI->getCalleeSavedFrameSize() - TailCallReturnAddrDelta);
 936
 937   // If this is x86-64 and the Red Zone is not disabled, if we are a leaf
 938   // function, and use up to 128 bytes of stack space, don't have a frame
 939   // pointer, calls, or dynamic alloca then we do not need to adjust the
 940   // stack pointer (we fit in the Red Zone).
 941   if (Is64Bit && !Fn->hasFnAttr(Attribute::NoRedZone) &&
 942       !needsStackRealignment(MF) &&
 943       !MFI->hasVarSizedObjects() &&                // No dynamic alloca.
 944       !MFI->adjustsStack() &&                      // No calls.
 945       !Subtarget->isTargetWin64()) {               // Win64 has no Red Zone
 946     uint64_t MinSize = X86FI->getCalleeSavedFrameSize();
 947     if (HasFP) MinSize += SlotSize;
 948     StackSize = std::max(MinSize, StackSize > 128 ? StackSize - 128 : 0);
 949     MFI->setStackSize(StackSize);
 950   } else if (Subtarget->isTargetWin64()) {
 951     // We need to always allocate 32 bytes as register spill area.
 952     // FIXME: We might reuse these 32 bytes for leaf functions.
 953     StackSize += 32;
 954     MFI->setStackSize(StackSize);
 955   }
 956
 957   // Insert stack pointer adjustment for later moving of return addr.  Only
 958   // applies to tail call optimized functions where the callee argument stack
 959   // size is bigger than the callers.
 960   if (TailCallReturnAddrDelta < 0) {
 961     MachineInstr *MI =
 962       BuildMI(MBB, MBBI, DL,
 963               TII.get(getSUBriOpcode(Is64Bit, -TailCallReturnAddrDelta)),
 964               StackPtr)
 965         .addReg(StackPtr)
 966         .addImm(-TailCallReturnAddrDelta);
 967     MI->getOperand(3).setIsDead(); // The EFLAGS implicit def is dead.
 968   }
 969
 970   // Mapping for machine moves:
 971   //
 972   //   DST: VirtualFP AND
 973   //        SRC: VirtualFP              => DW_CFA_def_cfa_offset
 974   //        ELSE                        => DW_CFA_def_cfa
 975   //
 976   //   SRC: VirtualFP AND
 977   //        DST: Register               => DW_CFA_def_cfa_register
 978   //
 979   //   ELSE
 980   //        OFFSET < 0                  => DW_CFA_offset_extended_sf
 981   //        REG < 64                    => DW_CFA_offset + Reg
 982   //        ELSE                        => DW_CFA_offset_extended
 983
 984   std::vector<MachineMove> &Moves = MMI.getFrameMoves();
 985   const TargetData *TD = MF.getTarget().getTargetData();
 986   uint64_t NumBytes = 0;
 987   int stackGrowth = -TD->getPointerSize();
 988
 989   if (HasFP) {
 990     // Calculate required stack adjustment.
 991     uint64_t FrameSize = StackSize - SlotSize;
 992     if (needsStackRealignment(MF))
 993       FrameSize = (FrameSize + MaxAlign - 1) / MaxAlign * MaxAlign;
 994
 995     NumBytes = FrameSize - X86FI->getCalleeSavedFrameSize();
 996
 997     // Get the offset of the stack slot for the EBP register, which is
 998     // guaranteed to be the last slot by processFunctionBeforeFrameFinalized.
 999     // Update the frame offset adjustment.
1000     MFI->setOffsetAdjustment(-NumBytes);
1001
1002     // Save EBP/RBP into the appropriate stack slot.
1003     BuildMI(MBB, MBBI, DL, TII.get(Is64Bit ? X86::PUSH64r : X86::PUSH32r))
1004       .addReg(FramePtr, RegState::Kill);
1005
1006     if (needsFrameMoves) {
1007       // Mark the place where EBP/RBP was saved.
1008       MCSymbol *FrameLabel = MMI.getContext().CreateTempSymbol();
1009       BuildMI(MBB, MBBI, DL, TII.get(X86::PROLOG_LABEL)).addSym(FrameLabel);
1010
1011       // Define the current CFA rule to use the provided offset.
1012       if (StackSize) {
1013         MachineLocation SPDst(MachineLocation::VirtualFP);
1014         MachineLocation SPSrc(MachineLocation::VirtualFP, 2 * stackGrowth);
1015         Moves.push_back(MachineMove(FrameLabel, SPDst, SPSrc));
1016       } else {
1017         // FIXME: Verify & implement for FP
1018         MachineLocation SPDst(StackPtr);
1019         MachineLocation SPSrc(StackPtr, stackGrowth);
1020         Moves.push_back(MachineMove(FrameLabel, SPDst, SPSrc));
1021       }
1022
1023       // Change the rule for the FramePtr to be an "offset" rule.
1024       MachineLocation FPDst(MachineLocation::VirtualFP, 2 * stackGrowth);
1025       MachineLocation FPSrc(FramePtr);
1026       Moves.push_back(MachineMove(FrameLabel, FPDst, FPSrc));
1027     }
1028
1029     // Update EBP with the new base value...
1030     BuildMI(MBB, MBBI, DL,
1031             TII.get(Is64Bit ? X86::MOV64rr : X86::MOV32rr), FramePtr)
1032         .addReg(StackPtr);
1033
1034     if (needsFrameMoves) {
1035       // Mark effective beginning of when frame pointer becomes valid.
1036       MCSymbol *FrameLabel = MMI.getContext().CreateTempSymbol();
1037       BuildMI(MBB, MBBI, DL, TII.get(X86::PROLOG_LABEL)).addSym(FrameLabel);
1038
1039       // Define the current CFA to use the EBP/RBP register.
1040       MachineLocation FPDst(FramePtr);
1041       MachineLocation FPSrc(MachineLocation::VirtualFP);
1042       Moves.push_back(MachineMove(FrameLabel, FPDst, FPSrc));
1043     }
1044
1045     // Mark the FramePtr as live-in in every block except the entry.
1046     for (MachineFunction::iterator I = llvm::next(MF.begin()), E = MF.end();
1047          I != E; ++I)
1048       I->addLiveIn(FramePtr);
1049
1050     // Realign stack
1051     if (needsStackRealignment(MF)) {
1052       MachineInstr *MI =
1053         BuildMI(MBB, MBBI, DL,
1054                 TII.get(Is64Bit ? X86::AND64ri32 : X86::AND32ri),
1055                 StackPtr).addReg(StackPtr).addImm(-MaxAlign);
1056
1057       // The EFLAGS implicit def is dead.
1058       MI->getOperand(3).setIsDead();
1059     }
1060   } else {
1061     NumBytes = StackSize - X86FI->getCalleeSavedFrameSize();
1062   }
1063
1064   // Skip the callee-saved push instructions.
1065   bool PushedRegs = false;
1066   int StackOffset = 2 * stackGrowth;
1067
1068   while (MBBI != MBB.end() &&
1069          (MBBI->getOpcode() == X86::PUSH32r ||
1070           MBBI->getOpcode() == X86::PUSH64r)) {
1071     PushedRegs = true;
1072     ++MBBI;
1073
1074     if (!HasFP && needsFrameMoves) {
1075       // Mark callee-saved push instruction.
1076       MCSymbol *Label = MMI.getContext().CreateTempSymbol();
1077       BuildMI(MBB, MBBI, DL, TII.get(X86::PROLOG_LABEL)).addSym(Label);
1078
1079       // Define the current CFA rule to use the provided offset.
1080       unsigned Ptr = StackSize ?
1081         MachineLocation::VirtualFP : StackPtr;
1082       MachineLocation SPDst(Ptr);
1083       MachineLocation SPSrc(Ptr, StackOffset);
1084       Moves.push_back(MachineMove(Label, SPDst, SPSrc));
1085       StackOffset += stackGrowth;
1086     }
1087   }
1088
1089   DL = MBB.findDebugLoc(MBBI);
1090
1091   // Adjust stack pointer: ESP -= numbytes.
1092   if (NumBytes >= 4096 && Subtarget->isTargetCygMing()) {
1093     // Check, whether EAX is livein for this function.
1094     bool isEAXAlive = false;
1095     for (MachineRegisterInfo::livein_iterator
1096            II = MF.getRegInfo().livein_begin(),
1097            EE = MF.getRegInfo().livein_end(); (II != EE) && !isEAXAlive; ++II) {
1098       unsigned Reg = II->first;
1099       isEAXAlive = (Reg == X86::EAX || Reg == X86::AX ||
1100                     Reg == X86::AH || Reg == X86::AL);
1101     }
1102
1103     // Function prologue calls _alloca to probe the stack when allocating more
1104     // than 4k bytes in one go. Touching the stack at 4K increments is necessary
1105     // to ensure that the guard pages used by the OS virtual memory manager are
1106     // allocated in correct sequence.
1107     if (!isEAXAlive) {
1108       BuildMI(MBB, MBBI, DL, TII.get(X86::MOV32ri), X86::EAX)
1109         .addImm(NumBytes);
1110       BuildMI(MBB, MBBI, DL, TII.get(X86::CALLpcrel32))
1111         .addExternalSymbol("_alloca")
1112         .addReg(StackPtr, RegState::Define | RegState::Implicit);
1113     } else {
1114       // Save EAX
1115       BuildMI(MBB, MBBI, DL, TII.get(X86::PUSH32r))
1116         .addReg(X86::EAX, RegState::Kill);
1117
1118       // Allocate NumBytes-4 bytes on stack. We'll also use 4 already
1119       // allocated bytes for EAX.
1120       BuildMI(MBB, MBBI, DL, TII.get(X86::MOV32ri), X86::EAX)
1121         .addImm(NumBytes - 4);
1122       BuildMI(MBB, MBBI, DL, TII.get(X86::CALLpcrel32))
1123         .addExternalSymbol("_alloca")
1124         .addReg(StackPtr, RegState::Define | RegState::Implicit);
1125
1126       // Restore EAX
1127       MachineInstr *MI = addRegOffset(BuildMI(MF, DL, TII.get(X86::MOV32rm),
1128                                               X86::EAX),
1129                                       StackPtr, false, NumBytes - 4);
1130       MBB.insert(MBBI, MI);
1131     }
1132   } else if (NumBytes) {
1133     // If there is an SUB32ri of ESP immediately before this instruction, merge
1134     // the two. This can be the case when tail call elimination is enabled and
1135     // the callee has more arguments then the caller.
1136     NumBytes -= mergeSPUpdates(MBB, MBBI, StackPtr, true);
1137
1138     // If there is an ADD32ri or SUB32ri of ESP immediately after this
1139     // instruction, merge the two instructions.
1140     mergeSPUpdatesDown(MBB, MBBI, StackPtr, &NumBytes);
1141
1142     if (NumBytes)
1143       emitSPUpdate(MBB, MBBI, StackPtr, -(int64_t)NumBytes, Is64Bit, TII);
1144   }
1145
1146   if ((NumBytes || PushedRegs) && needsFrameMoves) {
1147     // Mark end of stack pointer adjustment.
1148     MCSymbol *Label = MMI.getContext().CreateTempSymbol();
1149     BuildMI(MBB, MBBI, DL, TII.get(X86::PROLOG_LABEL)).addSym(Label);
1150
1151     if (!HasFP && NumBytes) {
1152       // Define the current CFA rule to use the provided offset.
1153       if (StackSize) {
1154         MachineLocation SPDst(MachineLocation::VirtualFP);
1155         MachineLocation SPSrc(MachineLocation::VirtualFP,
1156                               -StackSize + stackGrowth);
1157         Moves.push_back(MachineMove(Label, SPDst, SPSrc));
1158       } else {
1159         // FIXME: Verify & implement for FP
1160         MachineLocation SPDst(StackPtr);
1161         MachineLocation SPSrc(StackPtr, stackGrowth);
1162         Moves.push_back(MachineMove(Label, SPDst, SPSrc));
1163       }
1164     }
1165
1166     // Emit DWARF info specifying the offsets of the callee-saved registers.
1167     if (PushedRegs)
1168       emitCalleeSavedFrameMoves(MF, Label, HasFP ? FramePtr : StackPtr);
1169   }
1170 }
1171
1172 void X86RegisterInfo::emitEpilogue(MachineFunction &MF,
1173                                    MachineBasicBlock &MBB) const {
1174   const MachineFrameInfo *MFI = MF.getFrameInfo();
1175   X86MachineFunctionInfo *X86FI = MF.getInfo<X86MachineFunctionInfo>();
1176   MachineBasicBlock::iterator MBBI = prior(MBB.end());
1177   unsigned RetOpcode = MBBI->getOpcode();
1178   DebugLoc DL = MBBI->getDebugLoc();
1179
1180   switch (RetOpcode) {
1181   default:
1182     llvm_unreachable("Can only insert epilog into returning blocks");
1183   case X86::RET:
1184   case X86::RETI:
1185   case X86::TCRETURNdi:
1186   case X86::TCRETURNri:
1187   case X86::TCRETURNmi:
1188   case X86::TCRETURNdi64:
1189   case X86::TCRETURNri64:
1190   case X86::TCRETURNmi64:
1191   case X86::EH_RETURN:
1192   case X86::EH_RETURN64:
1193     break;  // These are ok
1194   }
1195
1196   // Get the number of bytes to allocate from the FrameInfo.
1197   uint64_t StackSize = MFI->getStackSize();
1198   uint64_t MaxAlign  = MFI->getMaxAlignment();
1199   unsigned CSSize = X86FI->getCalleeSavedFrameSize();
1200   uint64_t NumBytes = 0;
1201
1202   // If we're forcing a stack realignment we can't rely on just the frame
1203   // info, we need to know the ABI stack alignment as well in case we
1204   // have a call out.  Otherwise just make sure we have some alignment - we'll
1205   // go with the minimum.
1206   if (ForceStackAlign) {
1207     if (MFI->hasCalls())
1208       MaxAlign = (StackAlign > MaxAlign) ? StackAlign : MaxAlign;
1209     else
1210       MaxAlign = MaxAlign ? MaxAlign : 4;
1211   }
1212
1213   if (hasFP(MF)) {
1214     // Calculate required stack adjustment.
1215     uint64_t FrameSize = StackSize - SlotSize;
1216     if (needsStackRealignment(MF))
1217       FrameSize = (FrameSize + MaxAlign - 1)/MaxAlign*MaxAlign;
1218
1219     NumBytes = FrameSize - CSSize;
1220
1221     // Pop EBP.
1222     BuildMI(MBB, MBBI, DL,
1223             TII.get(Is64Bit ? X86::POP64r : X86::POP32r), FramePtr);
1224   } else {
1225     NumBytes = StackSize - CSSize;
1226   }
1227
1228   // Skip the callee-saved pop instructions.
1229   MachineBasicBlock::iterator LastCSPop = MBBI;
1230   while (MBBI != MBB.begin()) {
1231     MachineBasicBlock::iterator PI = prior(MBBI);
1232     unsigned Opc = PI->getOpcode();
1233
1234     if (Opc != X86::POP32r && Opc != X86::POP64r &&
1235         !PI->getDesc().isTerminator())
1236       break;
1237
1238     --MBBI;
1239   }
1240
1241   DL = MBBI->getDebugLoc();
1242
1243   // If there is an ADD32ri or SUB32ri of ESP immediately before this
1244   // instruction, merge the two instructions.
1245   if (NumBytes || MFI->hasVarSizedObjects())
1246     mergeSPUpdatesUp(MBB, MBBI, StackPtr, &NumBytes);
1247
1248   // If dynamic alloca is used, then reset esp to point to the last callee-saved
1249   // slot before popping them off! Same applies for the case, when stack was
1250   // realigned.
1251   if (needsStackRealignment(MF)) {
1252     // We cannot use LEA here, because stack pointer was realigned. We need to
1253     // deallocate local frame back.
1254     if (CSSize) {
1255       emitSPUpdate(MBB, MBBI, StackPtr, NumBytes, Is64Bit, TII);
1256       MBBI = prior(LastCSPop);
1257     }
1258
1259     BuildMI(MBB, MBBI, DL,
1260             TII.get(Is64Bit ? X86::MOV64rr : X86::MOV32rr),
1261             StackPtr).addReg(FramePtr);
1262   } else if (MFI->hasVarSizedObjects()) {
1263     if (CSSize) {
1264       unsigned Opc = Is64Bit ? X86::LEA64r : X86::LEA32r;
1265       MachineInstr *MI =
1266         addRegOffset(BuildMI(MF, DL, TII.get(Opc), StackPtr),
1267                      FramePtr, false, -CSSize);
1268       MBB.insert(MBBI, MI);
1269     } else {
1270       BuildMI(MBB, MBBI, DL,
1271               TII.get(Is64Bit ? X86::MOV64rr : X86::MOV32rr), StackPtr)
1272         .addReg(FramePtr);
1273     }
1274   } else if (NumBytes) {
1275     // Adjust stack pointer back: ESP += numbytes.
1276     emitSPUpdate(MBB, MBBI, StackPtr, NumBytes, Is64Bit, TII);
1277   }
1278
1279   // We're returning from function via eh_return.
1280   if (RetOpcode == X86::EH_RETURN || RetOpcode == X86::EH_RETURN64) {
1281     MBBI = prior(MBB.end());
1282     MachineOperand &DestAddr  = MBBI->getOperand(0);
1283     assert(DestAddr.isReg() && "Offset should be in register!");
1284     BuildMI(MBB, MBBI, DL,
1285             TII.get(Is64Bit ? X86::MOV64rr : X86::MOV32rr),
1286             StackPtr).addReg(DestAddr.getReg());
1287   } else if (RetOpcode == X86::TCRETURNri || RetOpcode == X86::TCRETURNdi ||
1288              RetOpcode == X86::TCRETURNmi ||
1289              RetOpcode == X86::TCRETURNri64 || RetOpcode == X86::TCRETURNdi64 ||
1290              RetOpcode == X86::TCRETURNmi64) {
1291     bool isMem = RetOpcode == X86::TCRETURNmi || RetOpcode == X86::TCRETURNmi64;
1292     // Tail call return: adjust the stack pointer and jump to callee.
1293     MBBI = prior(MBB.end());
1294     MachineOperand &JumpTarget = MBBI->getOperand(0);
1295     MachineOperand &StackAdjust = MBBI->getOperand(isMem ? 5 : 1);
1296     assert(StackAdjust.isImm() && "Expecting immediate value.");
1297
1298     // Adjust stack pointer.
1299     int StackAdj = StackAdjust.getImm();
1300     int MaxTCDelta = X86FI->getTCReturnAddrDelta();
1301     int Offset = 0;
1302     assert(MaxTCDelta <= 0 && "MaxTCDelta should never be positive");
1303
1304     // Incoporate the retaddr area.
1305     Offset = StackAdj-MaxTCDelta;
1306     assert(Offset >= 0 && "Offset should never be negative");
1307
1308     if (Offset) {
1309       // Check for possible merge with preceeding ADD instruction.
1310       Offset += mergeSPUpdates(MBB, MBBI, StackPtr, true);
1311       emitSPUpdate(MBB, MBBI, StackPtr, Offset, Is64Bit, TII);
1312     }
1313
1314     // Jump to label or value in register.
1315     if (RetOpcode == X86::TCRETURNdi || RetOpcode == X86::TCRETURNdi64) {
1316       BuildMI(MBB, MBBI, DL, TII.get((RetOpcode == X86::TCRETURNdi)
1317                                      ? X86::TAILJMPd : X86::TAILJMPd64)).
1318         addGlobalAddress(JumpTarget.getGlobal(), JumpTarget.getOffset(),
1319                          JumpTarget.getTargetFlags());
1320     } else if (RetOpcode == X86::TCRETURNmi || RetOpcode == X86::TCRETURNmi64) {
1321       MachineInstrBuilder MIB =
1322         BuildMI(MBB, MBBI, DL, TII.get((RetOpcode == X86::TCRETURNmi)
1323                                        ? X86::TAILJMPm : X86::TAILJMPm64));
1324       for (unsigned i = 0; i != 5; ++i)
1325         MIB.addOperand(MBBI->getOperand(i));
1326     } else if (RetOpcode == X86::TCRETURNri64) {
1327       BuildMI(MBB, MBBI, DL, TII.get(X86::TAILJMPr64)).
1328         addReg(JumpTarget.getReg(), RegState::Kill);
1329     } else {
1330       BuildMI(MBB, MBBI, DL, TII.get(X86::TAILJMPr)).
1331         addReg(JumpTarget.getReg(), RegState::Kill);
1332     }
1333
1334     MachineInstr *NewMI = prior(MBBI);
1335     for (unsigned i = 2, e = MBBI->getNumOperands(); i != e; ++i)
1336       NewMI->addOperand(MBBI->getOperand(i));
1337
1338     // Delete the pseudo instruction TCRETURN.
1339     MBB.erase(MBBI);
1340   } else if ((RetOpcode == X86::RET || RetOpcode == X86::RETI) &&
1341              (X86FI->getTCReturnAddrDelta() < 0)) {
1342     // Add the return addr area delta back since we are not tail calling.
1343     int delta = -1*X86FI->getTCReturnAddrDelta();
1344     MBBI = prior(MBB.end());
1345
1346     // Check for possible merge with preceeding ADD instruction.
1347     delta += mergeSPUpdates(MBB, MBBI, StackPtr, true);
1348     emitSPUpdate(MBB, MBBI, StackPtr, delta, Is64Bit, TII);
1349   }
1350 }
1351
1352 unsigned X86RegisterInfo::getRARegister() const {
1353   return Is64Bit ? X86::RIP     // Should have dwarf #16.
1354                  : X86::EIP;    // Should have dwarf #8.
1355 }
1356
1357 unsigned X86RegisterInfo::getFrameRegister(const MachineFunction &MF) const {
1358   return hasFP(MF) ? FramePtr : StackPtr;
1359 }
1360
1361 void
1362 X86RegisterInfo::getInitialFrameState(std::vector<MachineMove> &Moves) const {
1363   // Calculate amount of bytes used for return address storing
1364   int stackGrowth = (Is64Bit ? -8 : -4);
1365
1366   // Initial state of the frame pointer is esp+stackGrowth.
1367   MachineLocation Dst(MachineLocation::VirtualFP);
1368   MachineLocation Src(StackPtr, stackGrowth);
1369   Moves.push_back(MachineMove(0, Dst, Src));
1370
1371   // Add return address to move list
1372   MachineLocation CSDst(StackPtr, stackGrowth);
1373   MachineLocation CSSrc(getRARegister());
1374   Moves.push_back(MachineMove(0, CSDst, CSSrc));
1375 }
1376
1377 unsigned X86RegisterInfo::getEHExceptionRegister() const {
1378   llvm_unreachable("What is the exception register");
1379   return 0;
1380 }
1381
1382 unsigned X86RegisterInfo::getEHHandlerRegister() const {
1383   llvm_unreachable("What is the exception handler register");
1384   return 0;
1385 }
1386
1387 namespace llvm {
1388 unsigned getX86SubSuperRegister(unsigned Reg, EVT VT, bool High) {
1389   switch (VT.getSimpleVT().SimpleTy) {
1390   default: return Reg;
1391   case MVT::i8:
1392     if (High) {
1393       switch (Reg) {
1394       default: return 0;
1395       case X86::AH: case X86::AL: case X86::AX: case X86::EAX: case X86::RAX:
1396         return X86::AH;
1397       case X86::DH: case X86::DL: case X86::DX: case X86::EDX: case X86::RDX:
1398         return X86::DH;
1399       case X86::CH: case X86::CL: case X86::CX: case X86::ECX: case X86::RCX:
1400         return X86::CH;
1401       case X86::BH: case X86::BL: case X86::BX: case X86::EBX: case X86::RBX:
1402         return X86::BH;
1403       }
1404     } else {
1405       switch (Reg) {
1406       default: return 0;
1407       case X86::AH: case X86::AL: case X86::AX: case X86::EAX: case X86::RAX:
1408         return X86::AL;
1409       case X86::DH: case X86::DL: case X86::DX: case X86::EDX: case X86::RDX:
1410         return X86::DL;
1411       case X86::CH: case X86::CL: case X86::CX: case X86::ECX: case X86::RCX:
1412         return X86::CL;
1413       case X86::BH: case X86::BL: case X86::BX: case X86::EBX: case X86::RBX:
1414         return X86::BL;
1415       case X86::SIL: case X86::SI: case X86::ESI: case X86::RSI:
1416         return X86::SIL;
1417       case X86::DIL: case X86::DI: case X86::EDI: case X86::RDI:
1418         return X86::DIL;
1419       case X86::BPL: case X86::BP: case X86::EBP: case X86::RBP:
1420         return X86::BPL;
1421       case X86::SPL: case X86::SP: case X86::ESP: case X86::RSP:
1422         return X86::SPL;
1423       case X86::R8B: case X86::R8W: case X86::R8D: case X86::R8:
1424         return X86::R8B;
1425       case X86::R9B: case X86::R9W: case X86::R9D: case X86::R9:
1426         return X86::R9B;
1427       case X86::R10B: case X86::R10W: case X86::R10D: case X86::R10:
1428         return X86::R10B;
1429       case X86::R11B: case X86::R11W: case X86::R11D: case X86::R11:
1430         return X86::R11B;
1431       case X86::R12B: case X86::R12W: case X86::R12D: case X86::R12:
1432         return X86::R12B;
1433       case X86::R13B: case X86::R13W: case X86::R13D: case X86::R13:
1434         return X86::R13B;
1435       case X86::R14B: case X86::R14W: case X86::R14D: case X86::R14:
1436         return X86::R14B;
1437       case X86::R15B: case X86::R15W: case X86::R15D: case X86::R15:
1438         return X86::R15B;
1439       }
1440     }
1441   case MVT::i16:
1442     switch (Reg) {
1443     default: return Reg;
1444     case X86::AH: case X86::AL: case X86::AX: case X86::EAX: case X86::RAX:
1445       return X86::AX;
1446     case X86::DH: case X86::DL: case X86::DX: case X86::EDX: case X86::RDX:
1447       return X86::DX;
1448     case X86::CH: case X86::CL: case X86::CX: case X86::ECX: case X86::RCX:
1449       return X86::CX;
1450     case X86::BH: case X86::BL: case X86::BX: case X86::EBX: case X86::RBX:
1451       return X86::BX;
1452     case X86::SIL: case X86::SI: case X86::ESI: case X86::RSI:
1453       return X86::SI;
1454     case X86::DIL: case X86::DI: case X86::EDI: case X86::RDI:
1455       return X86::DI;
1456     case X86::BPL: case X86::BP: case X86::EBP: case X86::RBP:
1457       return X86::BP;
1458     case X86::SPL: case X86::SP: case X86::ESP: case X86::RSP:
1459       return X86::SP;
1460     case X86::R8B: case X86::R8W: case X86::R8D: case X86::R8:
1461       return X86::R8W;
1462     case X86::R9B: case X86::R9W: case X86::R9D: case X86::R9:
1463       return X86::R9W;
1464     case X86::R10B: case X86::R10W: case X86::R10D: case X86::R10:
1465       return X86::R10W;
1466     case X86::R11B: case X86::R11W: case X86::R11D: case X86::R11:
1467       return X86::R11W;
1468     case X86::R12B: case X86::R12W: case X86::R12D: case X86::R12:
1469       return X86::R12W;
1470     case X86::R13B: case X86::R13W: case X86::R13D: case X86::R13:
1471       return X86::R13W;
1472     case X86::R14B: case X86::R14W: case X86::R14D: case X86::R14:
1473       return X86::R14W;
1474     case X86::R15B: case X86::R15W: case X86::R15D: case X86::R15:
1475       return X86::R15W;
1476     }
1477   case MVT::i32:
1478     switch (Reg) {
1479     default: return Reg;
1480     case X86::AH: case X86::AL: case X86::AX: case X86::EAX: case X86::RAX:
1481       return X86::EAX;
1482     case X86::DH: case X86::DL: case X86::DX: case X86::EDX: case X86::RDX:
1483       return X86::EDX;
1484     case X86::CH: case X86::CL: case X86::CX: case X86::ECX: case X86::RCX:
1485       return X86::ECX;
1486     case X86::BH: case X86::BL: case X86::BX: case X86::EBX: case X86::RBX:
1487       return X86::EBX;
1488     case X86::SIL: case X86::SI: case X86::ESI: case X86::RSI:
1489       return X86::ESI;
1490     case X86::DIL: case X86::DI: case X86::EDI: case X86::RDI:
1491       return X86::EDI;
1492     case X86::BPL: case X86::BP: case X86::EBP: case X86::RBP:
1493       return X86::EBP;
1494     case X86::SPL: case X86::SP: case X86::ESP: case X86::RSP:
1495       return X86::ESP;
1496     case X86::R8B: case X86::R8W: case X86::R8D: case X86::R8:
1497       return X86::R8D;
1498     case X86::R9B: case X86::R9W: case X86::R9D: case X86::R9:
1499       return X86::R9D;
1500     case X86::R10B: case X86::R10W: case X86::R10D: case X86::R10:
1501       return X86::R10D;
1502     case X86::R11B: case X86::R11W: case X86::R11D: case X86::R11:
1503       return X86::R11D;
1504     case X86::R12B: case X86::R12W: case X86::R12D: case X86::R12:
1505       return X86::R12D;
1506     case X86::R13B: case X86::R13W: case X86::R13D: case X86::R13:
1507       return X86::R13D;
1508     case X86::R14B: case X86::R14W: case X86::R14D: case X86::R14:
1509       return X86::R14D;
1510     case X86::R15B: case X86::R15W: case X86::R15D: case X86::R15:
1511       return X86::R15D;
1512     }
1513   case MVT::i64:
1514     switch (Reg) {
1515     default: return Reg;
1516     case X86::AH: case X86::AL: case X86::AX: case X86::EAX: case X86::RAX:
1517       return X86::RAX;
1518     case X86::DH: case X86::DL: case X86::DX: case X86::EDX: case X86::RDX:
1519       return X86::RDX;
1520     case X86::CH: case X86::CL: case X86::CX: case X86::ECX: case X86::RCX:
1521       return X86::RCX;
1522     case X86::BH: case X86::BL: case X86::BX: case X86::EBX: case X86::RBX:
1523       return X86::RBX;
1524     case X86::SIL: case X86::SI: case X86::ESI: case X86::RSI:
1525       return X86::RSI;
1526     case X86::DIL: case X86::DI: case X86::EDI: case X86::RDI:
1527       return X86::RDI;
1528     case X86::BPL: case X86::BP: case X86::EBP: case X86::RBP:
1529       return X86::RBP;
1530     case X86::SPL: case X86::SP: case X86::ESP: case X86::RSP:
1531       return X86::RSP;
1532     case X86::R8B: case X86::R8W: case X86::R8D: case X86::R8:
1533       return X86::R8;
1534     case X86::R9B: case X86::R9W: case X86::R9D: case X86::R9:
1535       return X86::R9;
1536     case X86::R10B: case X86::R10W: case X86::R10D: case X86::R10:
1537       return X86::R10;
1538     case X86::R11B: case X86::R11W: case X86::R11D: case X86::R11:
1539       return X86::R11;
1540     case X86::R12B: case X86::R12W: case X86::R12D: case X86::R12:
1541       return X86::R12;
1542     case X86::R13B: case X86::R13W: case X86::R13D: case X86::R13:
1543       return X86::R13;
1544     case X86::R14B: case X86::R14W: case X86::R14D: case X86::R14:
1545       return X86::R14;
1546     case X86::R15B: case X86::R15W: case X86::R15D: case X86::R15:
1547       return X86::R15;
1548     }
1549   }
1550
1551   return Reg;
1552 }
1553 }
1554
1555 #include "X86GenRegisterInfo.inc"
1556
1557 namespace {
1558   struct MSAH : public MachineFunctionPass {
1559     static char ID;
1560     MSAH() : MachineFunctionPass(&ID) {}
1561
1562     virtual bool runOnMachineFunction(MachineFunction &MF) {
1563       const X86TargetMachine *TM =
1564         static_cast<const X86TargetMachine *>(&MF.getTarget());
1565       const X86RegisterInfo *X86RI = TM->getRegisterInfo();
1566       MachineRegisterInfo &RI = MF.getRegInfo();
1567       X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
1568       unsigned StackAlignment = X86RI->getStackAlignment();
1569
1570       // Be over-conservative: scan over all vreg defs and find whether vector
1571       // registers are used. If yes, there is a possibility that vector register
1572       // will be spilled and thus require dynamic stack realignment.
1573       for (unsigned RegNum = TargetRegisterInfo::FirstVirtualRegister;
1574            RegNum < RI.getLastVirtReg(); ++RegNum)
1575         if (RI.getRegClass(RegNum)->getAlignment() > StackAlignment) {
1576           FuncInfo->setReserveFP(true);
1577           return true;
1578         }
1579
1580       // Nothing to do
1581       return false;
1582     }
1583
1584     virtual const char *getPassName() const {
1585       return "X86 Maximal Stack Alignment Check";
1586     }
1587
1588     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
1589       AU.setPreservesCFG();
1590       MachineFunctionPass::getAnalysisUsage(AU);
1591     }
1592   };
1593
1594   char MSAH::ID = 0;
1595 }
1596
1597 FunctionPass*
1598 llvm::createX86MaxStackAlignmentHeuristicPass() { return new MSAH(); }