LLVM API Documentation
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(); }