[codegen] Prototype Frame Pointer Shrinkwrapping

[paulkirth]

Summary

The idea here is to make use of the frame pointer as a GPR when it isn't
absolutely required. The observation is that the FP is only needed at
callsites, but at any other point in the function, it can be used as a
GPR. This complicates some things, but is another valid way to use the
FP, but regain some of the performance lost by reserving a register.

Largely, we want to allow the RA to work normally as if FP was not
reserved, and use it freely. We add constraints by restoring FP at any
call site. In limited testing this seems to work as intended.

This prototype only focuses on X86, since its a bit more register starved
than other architectures, like ARM or RISCV. This type of optimization
may also not be worth it over just -momit-leaf.

This is entirely experimental at this point. Internal testing showed
that this does have an improvement over FP, but not as significant as we
would hope. Further analysis shows that using FP is often in the noise
over omitting the FP altogether. Benchmarking seems to exhibit a lot of
variance, so its is hard to estimate the impact. Linux perf is also
influenced by the use of FP, so getting good results is challenging.

clang/include/clang/Basic/CodeGenOptions.h

public:
   // support. "none" means that all ELF features can be used, regardless of
   // binutils support.
   std::string BinutilsVersion;
 
   enum class FramePointerKind {
     None,        // Omit all frame pointers.
     NonLeaf,     // Keep non-leaf frame pointers.
     All,         // Keep all frame pointers.
+    ShrinkWrap,  // Shrink wrap frame pointers.
   };
 
   static StringRef getFramePointerKindName(FramePointerKind Kind) {
     switch (Kind) {
     case FramePointerKind::None:
       return "none";
     case FramePointerKind::NonLeaf:
       return "non-leaf";

clang/include/clang/Driver/Options.td

def fno_module_file_deps : Flag <["-"], "fno-module-file-deps">, Group<f_Group>,
   Flags<[NoXarchOption]>;
 def fno_ms_extensions : Flag<["-"], "fno-ms-extensions">, Group<f_Group>,
   Flags<[CoreOption]>;
 def fno_ms_compatibility : Flag<["-"], "fno-ms-compatibility">, Group<f_Group>,
   Flags<[CoreOption]>;
 def fno_objc_legacy_dispatch : Flag<["-"], "fno-objc-legacy-dispatch">, Group<f_Group>;
 def fno_objc_weak : Flag<["-"], "fno-objc-weak">, Group<f_Group>, Flags<[CC1Option]>;
 def fno_omit_frame_pointer : Flag<["-"], "fno-omit-frame-pointer">, Group<f_Group>;
+def fno_frame_pointer_shrink_wrap : Flag<["-"], "fno-frame-pointer-shrink-wrap">, Group<f_Group>;
 defm operator_names : BoolFOption<"operator-names",
   LangOpts<"CXXOperatorNames">, Default<cplusplus.KeyPath>,
   NegFlag<SetFalse, [CC1Option], "Do not treat C++ operator name keywords as synonyms for operators">,
   PosFlag<SetTrue>>;
 def fdiagnostics_absolute_paths : Flag<["-"], "fdiagnostics-absolute-paths">, Group<f_Group>,
   Flags<[CC1Option, CoreOption]>, HelpText<"Print absolute paths in diagnostics">,
   MarshallingInfoFlag<DiagnosticOpts<"AbsolutePath">>;
 def fno_stack_protector : Flag<["-"], "fno-stack-protector">, Group<f_Group>,
def fobjc_disable_direct_methods_for_testing :
   MarshallingInfoFlag<LangOpts<"ObjCDisableDirectMethodsForTesting">>;
 defm objc_avoid_heapify_local_blocks : BoolFOption<"objc-avoid-heapify-local-blocks",
   CodeGenOpts<"ObjCAvoidHeapifyLocalBlocks">, DefaultFalse,
   PosFlag<SetTrue, [], "Try">,
   NegFlag<SetFalse, [], "Don't try">,
   BothFlags<[CC1Option, NoDriverOption], " to avoid heapifying local blocks">>;
 
 def fomit_frame_pointer : Flag<["-"], "fomit-frame-pointer">, Group<f_Group>;
+def fframe_pointer_shrink_wrap : Flag<["-"], "fframe-pointer-shrink-wrap">, Group<f_Group>;
 def fopenmp : Flag<["-"], "fopenmp">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused, FlangOption, FC1Option]>,
   HelpText<"Parse OpenMP pragmas and generate parallel code.">;
 def fno_openmp : Flag<["-"], "fno-openmp">, Group<f_Group>, Flags<[NoArgumentUnused]>;
 def fopenmp_version_EQ : Joined<["-"], "fopenmp-version=">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>,
   HelpText<"Set OpenMP version (e.g. 45 for OpenMP 4.5, 50 for OpenMP 5.0). Default value is 50.">;
 defm openmp_extensions: BoolFOption<"openmp-extensions",
   LangOpts<"OpenMPExtensions">, DefaultTrue,
   PosFlag<SetTrue, [CC1Option, NoArgumentUnused],
def no_struct_path_tbaa : Flag<["-"], "no-struct-path-tbaa">,
   HelpText<"Turn off struct-path aware Type Based Alias Analysis">,
   MarshallingInfoNegativeFlag<CodeGenOpts<"StructPathTBAA">>;
 def new_struct_path_tbaa : Flag<["-"], "new-struct-path-tbaa">,
   HelpText<"Enable enhanced struct-path aware Type Based Alias Analysis">;
 def mdebug_pass : Separate<["-"], "mdebug-pass">,
   HelpText<"Enable additional debug output">,
   MarshallingInfoString<CodeGenOpts<"DebugPass">>;
 def mframe_pointer_EQ : Joined<["-"], "mframe-pointer=">,
-  HelpText<"Specify which frame pointers to retain.">, Values<"all,non-leaf,none">,
-  NormalizedValuesScope<"CodeGenOptions::FramePointerKind">, NormalizedValues<["All", "NonLeaf", "None"]>,
+  HelpText<"Specify which frame pointers to retain.">, Values<"all,non-leaf,none,shrink-wrap">,
+  NormalizedValuesScope<"CodeGenOptions::FramePointerKind">, NormalizedValues<["All", "NonLeaf", "None", "ShrinkWrap"]>,
   MarshallingInfoEnum<CodeGenOpts<"FramePointer">, "None">;
 def mabi_EQ_ieeelongdouble : Flag<["-"], "mabi=ieeelongdouble">,
   HelpText<"Use IEEE 754 quadruple-precision for long double">,
   MarshallingInfoFlag<LangOpts<"PPCIEEELongDouble">>;
 def mfloat_abi : Separate<["-"], "mfloat-abi">,
   HelpText<"The float ABI to use">,
   MarshallingInfoString<CodeGenOpts<"FloatABI">>;
 def mtp : Separate<["-"], "mtp">,

clang/lib/CodeGen/CGCall.cpp

if (AttrOnCallSite) {
     if (!CodeGenOpts.TrapFuncName.empty())
       FuncAttrs.addAttribute("trap-func-name", CodeGenOpts.TrapFuncName);
   } else {
     switch (CodeGenOpts.getFramePointer()) {
     case CodeGenOptions::FramePointerKind::None:
       // This is the default behavior.
       break;
     case CodeGenOptions::FramePointerKind::NonLeaf:
+      FpKind = "non-leaf";
+      break;
+    case CodeGenOptions::FramePointerKind::ShrinkWrap:
+      FpKind = "shrink-wrap";
+      break;
     case CodeGenOptions::FramePointerKind::All:
       FuncAttrs.addAttribute("frame-pointer",
                              CodeGenOptions::getFramePointerKindName(
                                  CodeGenOpts.getFramePointer()));
     }
 
     if (CodeGenOpts.LessPreciseFPMAD)
       FuncAttrs.addAttribute("less-precise-fpmad", "true");

clang/lib/CodeGen/CodeGenModule.cpp

void CodeGenModule::Release() {
 
   switch (CodeGenOpts.getFramePointer()) {
   case CodeGenOptions::FramePointerKind::None:
     // 0 ("none") is the default.
     break;
   case CodeGenOptions::FramePointerKind::NonLeaf:
     getModule().setFramePointer(llvm::FramePointerKind::NonLeaf);
     break;
+  case CodeGenOptions::FramePointerKind::ShrinkWrap:
+    getModule().setFramePointer(llvm::FramePointerKind::ShrinkWrap);
+    break;
   case CodeGenOptions::FramePointerKind::All:
     getModule().setFramePointer(llvm::FramePointerKind::All);
     break;
   }
 
   SimplifyPersonality();
 
   if (getCodeGenOpts().EmitDeclMetadata)

clang/lib/Driver/ToolChains/Clang.cpp

Arg *A = Args.getLastArg(options::OPT_fomit_frame_pointer,
                            options::OPT_fno_omit_frame_pointer);
   bool OmitFP = A && A->getOption().matches(options::OPT_fomit_frame_pointer);
   bool NoOmitFP =
       A && A->getOption().matches(options::OPT_fno_omit_frame_pointer);
   bool OmitLeafFP =
       Args.hasFlag(options::OPT_momit_leaf_frame_pointer,
                    options::OPT_mno_omit_leaf_frame_pointer,
                    Triple.isAArch64() || Triple.isPS() || Triple.isVE());
+  bool ShrinkWrap =
+      Args.hasFlag(options::OPT_fframe_pointer_shrink_wrap,
+                   options::OPT_fno_frame_pointer_shrink_wrap, false);
   if (NoOmitFP || mustUseNonLeafFramePointerForTarget(Triple) ||
       (!OmitFP && useFramePointerForTargetByDefault(Args, Triple))) {
     if (OmitLeafFP)
       return CodeGenOptions::FramePointerKind::NonLeaf;
     return CodeGenOptions::FramePointerKind::All;
   }
+  // TODO: Revistit this ordering.
+  if (ShrinkWrap)
+    return CodeGenOptions::FramePointerKind::ShrinkWrap;
   return CodeGenOptions::FramePointerKind::None;
 }
 
 /// Add a CC1 option to specify the debug compilation directory.
 static const char *addDebugCompDirArg(const ArgList &Args,
                                       ArgStringList &CmdArgs,
                                       const llvm::vfs::FileSystem &VFS) {
   if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
#endif
   const char *FPKeepKindStr = nullptr;
   switch (FPKeepKind) {
   case CodeGenOptions::FramePointerKind::None:
     FPKeepKindStr = "-mframe-pointer=none";
     break;
   case CodeGenOptions::FramePointerKind::NonLeaf:
     FPKeepKindStr = "-mframe-pointer=non-leaf";
     break;
+  case CodeGenOptions::FramePointerKind::ShrinkWrap:
+    FPKeepKindStr = "-mframe-pointer=shrink-wrap";
+    break;
   case CodeGenOptions::FramePointerKind::All:
     FPKeepKindStr = "-mframe-pointer=all";
     break;
+
   }
   assert(FPKeepKindStr && "unknown FramePointerKind");
   CmdArgs.push_back(FPKeepKindStr);
 
   Args.addOptOutFlag(CmdArgs, options::OPT_fzero_initialized_in_bss,
                      options::OPT_fno_zero_initialized_in_bss);
 
   bool OFastEnabled = isOptimizationLevelFast(Args);

llvm/include/llvm/CodeGen/Passes.h

namespace llvm {
   MachineFunctionPass *
   createMachineFunctionPrinterPass(raw_ostream &OS,
                                    const std::string &Banner ="");
 
   /// StackFramePrinter pass - This pass prints out the machine function's
   /// stack frame to the given stream as a debugging tool.
   MachineFunctionPass *createStackFrameLayoutAnalysisPass();
 
+  MachineFunctionPass* createFramePointerShrinkWrapPass();
+
   /// MIRPrinting pass - this pass prints out the LLVM IR into the given stream
   /// using the MIR serialization format.
   MachineFunctionPass *createPrintMIRPass(raw_ostream &OS);
 
   /// This pass resets a MachineFunction when it has the FailedISel property
   /// as if it was just created.
   /// If EmitFallbackDiag is true, the pass will emit a
   /// DiagnosticInfoISelFallback for every MachineFunction it resets.
namespace llvm {
 
   /// BranchRelaxation - This pass replaces branches that need to jump further
   /// than is supported by a branch instruction.
   extern char &BranchRelaxationPassID;
 
   /// MachineFunctionPrinterPass - This pass prints out MachineInstr's.
   extern char &MachineFunctionPrinterPassID;
 
+  extern char &FramePointerShrinkWrapPassID;
+
   /// MIRPrintingPass - this pass prints out the LLVM IR using the MIR
   /// serialization format.
   extern char &MIRPrintingPassID;
 
   /// TailDuplicate - Duplicate blocks with unconditional branches
   /// into tails of their predecessors.
   extern char &TailDuplicateID;
 

llvm/include/llvm/CodeGen/TargetFrameLowering.h

virtual bool keepFramePointer(const MachineFunction &MF) const {
     return false;
   }
 
   /// hasFP - Return true if the specified function should have a dedicated
   /// frame pointer register. For most targets this is true only if the function
   /// has variable sized allocas or if frame pointer elimination is disabled.
   virtual bool hasFP(const MachineFunction &MF) const = 0;
 
+  /// hasFPShrinkWrap - Return true if the specified function should shrink wrap
+  /// the frame pointer register. This is true only if the function has frame
+  /// pointers and the FP shrink wrap option is set.
+  virtual bool hasFPShrinkWrap(const MachineFunction &MF) const {return false;}
+
+
   /// hasReservedCallFrame - Under normal circumstances, when a frame pointer is
   /// not required, we reserve argument space for call sites in the function
   /// immediately on entry to the current function. This eliminates the need for
   /// add/sub sp brackets around call sites. Returns true if the call frame is
   /// included as part of the stack frame.
   virtual bool hasReservedCallFrame(const MachineFunction &MF) const {
     return !hasFP(MF);
   }

llvm/include/llvm/CodeGen/TargetRegisterInfo.h

public:
 
   //===--------------------------------------------------------------------===//
   /// Debug information queries.
 
   /// getFrameRegister - This method should return the register used as a base
   /// for values allocated in the current stack frame.
   virtual Register getFrameRegister(const MachineFunction &MF) const = 0;
 
+  virtual Register getFPReg(const MachineFunction &MF) const{return getFrameRegister(MF);}
+
   /// Mark a register and all its aliases as reserved in the given set.
   void markSuperRegs(BitVector &RegisterSet, MCRegister Reg) const;
 
   /// Returns true if for every register in the set all super registers are part
   /// of the set as well.
   bool checkAllSuperRegsMarked(const BitVector &RegisterSet,
       ArrayRef<MCPhysReg> Exceptions = ArrayRef<MCPhysReg>()) const;
 

llvm/include/llvm/InitializePasses.h

 void initializeExternalAAWrapperPassPass(PassRegistry&);
 void initializeFEntryInserterPass(PassRegistry&);
 void initializeFinalizeISelPass(PassRegistry&);
 void initializeFinalizeMachineBundlesPass(PassRegistry&);
 void initializeFixIrreduciblePass(PassRegistry &);
 void initializeFixupStatepointCallerSavedPass(PassRegistry&);
 void initializeFlattenCFGLegacyPassPass(PassRegistry &);
 void initializeForceFunctionAttrsLegacyPassPass(PassRegistry&);
+void initializeForwardControlFlowIntegrityPass(PassRegistry&);
+void initializeFramePointerShrinkWrapPassPass(PassRegistry &);
 void initializeFuncletLayoutPass(PassRegistry&);
 void initializeGCMachineCodeAnalysisPass(PassRegistry&);
 void initializeGCModuleInfoPass(PassRegistry&);
 void initializeGVNLegacyPassPass(PassRegistry&);
 void initializeGlobalDCELegacyPassPass(PassRegistry&);
 void initializeGlobalMergePass(PassRegistry&);
 void initializeGlobalOptLegacyPassPass(PassRegistry&);
 void initializeGlobalSplitPass(PassRegistry&);

llvm/include/llvm/Support/CodeGen.h

namespace llvm {
   /// file could actually be made.
   enum CodeGenFileType {
     CGFT_AssemblyFile,
     CGFT_ObjectFile,
     CGFT_Null         // Do not emit any output.
   };
 
   // Specify what functions should keep the frame pointer.
-  enum class FramePointerKind { None, NonLeaf, All };
+  enum class FramePointerKind { None, NonLeaf, All, ShrinkWrap };
 
   // Specify what type of zeroing callee-used registers.
   namespace ZeroCallUsedRegs {
   const unsigned ONLY_USED = 1U << 1;
   const unsigned ONLY_GPR = 1U << 2;
   const unsigned ONLY_ARG = 1U << 3;
 
   enum class ZeroCallUsedRegsKind : unsigned int {

llvm/lib/CodeGen/CMakeLists.txt

add_llvm_component_library(LLVMCodeGen
   ExpandMemCmp.cpp
   ExpandPostRAPseudos.cpp
   ExpandReductions.cpp
   ExpandVectorPredication.cpp
   FaultMaps.cpp
   FEntryInserter.cpp
   FinalizeISel.cpp
   FixupStatepointCallerSaved.cpp
+  FramePointerShrinkWrap.cpp
   FuncletLayout.cpp
   GCMetadata.cpp
   GCMetadataPrinter.cpp
   GCRootLowering.cpp
   GlobalMerge.cpp
   HardwareLoops.cpp
   IfConversion.cpp
   ImplicitNullChecks.cpp

llvm/lib/CodeGen/CommandFlags.cpp

static cl::opt<FramePointerKind> FramePointerUsage(
       cl::desc("Specify frame pointer elimination optimization"),
       cl::init(FramePointerKind::None),
       cl::values(
           clEnumValN(FramePointerKind::All, "all",
                      "Disable frame pointer elimination"),
           clEnumValN(FramePointerKind::NonLeaf, "non-leaf",
                      "Disable frame pointer elimination for non-leaf frame"),
           clEnumValN(FramePointerKind::None, "none",
-                     "Enable frame pointer elimination")));
+                     "Enable frame pointer elimination"),
+          clEnumValN(FramePointerKind::ShrinkWrap, "shrink-wrap",
+                     "Enable frame pointer shrink-wrap")));
   CGBINDOPT(FramePointerUsage);
 
   static cl::opt<bool> EnableUnsafeFPMath(
       "enable-unsafe-fp-math",
       cl::desc("Enable optimizations that may decrease FP precision"),
       cl::init(false));
   CGBINDOPT(EnableUnsafeFPMath);
 
if (!Features.empty()) {
     }
   }
   if (FramePointerUsageView->getNumOccurrences() > 0 &&
       !F.hasFnAttribute("frame-pointer")) {
     if (getFramePointerUsage() == FramePointerKind::All)
       NewAttrs.addAttribute("frame-pointer", "all");
     else if (getFramePointerUsage() == FramePointerKind::NonLeaf)
       NewAttrs.addAttribute("frame-pointer", "non-leaf");
+    else if (getFramePointerUsage() == FramePointerKind::ShrinkWrap)
+      NewAttrs.addAttribute("frame-pointer", "shrink-wrap");
     else if (getFramePointerUsage() == FramePointerKind::None)
       NewAttrs.addAttribute("frame-pointer", "none");
   }
   if (DisableTailCallsView->getNumOccurrences() > 0)
     NewAttrs.addAttribute("disable-tail-calls",
                           toStringRef(getDisableTailCalls()));
   if (getStackRealign())
     NewAttrs.addAttribute("stackrealign");

llvm/lib/CodeGen/FramePointerShrinkWrap.cpp

+//===-- MachineFunctionPrinterPass.cpp ------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// MachineFunctionPrinterPass implementation.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
+#include "llvm/CodeGen/MachineFrameInfo.h"
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/CodeGen/MachineInstrBuilder.h"
+#include "llvm/CodeGen/Passes.h"
+#include "llvm/CodeGen/SlotIndexes.h"
+#include "llvm/CodeGen/TargetInstrInfo.h"
+#include "llvm/CodeGen/TargetLowering.h"
+#include "llvm/CodeGen/TargetOpcodes.h"
+#include "llvm/CodeGen/TargetRegisterInfo.h"
+#include "llvm/CodeGen/TargetSubtargetInfo.h"
+#include "llvm/IR/PrintPasses.h"
+#include "llvm/InitializePasses.h"
+#include "llvm/MC/MCAsmInfo.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Target/TargetMachine.h"
+
+using namespace llvm;
+
+namespace {
+/// FramePointerShrinkWrapPass - Pass marks the frame pointer as a live register
+///
+struct FramePointerShrinkWrapPass : public MachineFunctionPass {
+  static char ID;
+
+  FramePointerShrinkWrapPass() : MachineFunctionPass(ID) {}
+
+  StringRef getPassName() const override {
+    return "Frame Pointer Shrink Wrappng Pass";
+  }
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesAll();
+    AU.addUsedIfAvailable<SlotIndexes>();
+    MachineFunctionPass::getAnalysisUsage(AU);
+  }
+
+  // TODO: don't copy these functions from target/x86
+
+  bool hasFP(const MachineFunction &MF) const {
+    const MachineFrameInfo &MFI = MF.getFrameInfo();
+    auto &STI = MF.getSubtarget();
+    auto *TRI = STI.getRegisterInfo();
+    return (MF.getTarget().Options.DisableFramePointerElim(MF) ||
+            TRI->hasStackRealignment(MF) || MFI.hasVarSizedObjects() ||
+            MFI.isFrameAddressTaken() || MFI.hasOpaqueSPAdjustment() ||
+            MF.callsUnwindInit() || MF.hasEHFunclets() || MF.callsEHReturn() ||
+            MFI.hasStackMap() || MFI.hasPatchPoint() ||
+            (MF.getTarget().getMCAsmInfo()->usesWindowsCFI() &&
+             MFI.hasCopyImplyingStackAdjustment()));
+  }
+
+  bool hasFPShrinkWrap(const MachineFunction &MF) const {
+    if (hasFP(MF))
+      return false;
+    const Function &F = MF.getFunction();
+    if (!F.hasFnAttribute("frame-pointer"))
+      return false;
+    StringRef FP = F.getFnAttribute("frame-pointer").getValueAsString();
+    return FP == "shrink-wrap";
+  }
+
+  bool runOnMachineFunction(MachineFunction &MF) override {
+    // only modify functions when shrink warp is enabled
+    if (!hasFPShrinkWrap(MF))
+      return false;
+
+    auto &STI = MF.getSubtarget();
+    auto *TII = STI.getInstrInfo();
+    auto *TRI = STI.getRegisterInfo();
+    MachineRegisterInfo &MRI = MF.getRegInfo();
+    Register FramePtr = TRI->getFPReg(MF);
+
+    // TODO: Rematerialize FP instead.
+
+    // add virtual reg in entry block, this is going to hold FP
+    const TargetRegisterClass *RegClass = TRI->getPointerRegClass(MF);
+    auto VReg = MRI.createVirtualRegister(RegClass);
+    auto &Entry = MF.front();
+    auto I = Entry.begin();
+
+    Entry.addLiveIn(FramePtr);
+
+    auto DL = I->getDebugLoc();
+    BuildMI(Entry, Entry.begin(), DL, TII->get(TargetOpcode::COPY), VReg)
+        .addReg(FramePtr);
+
+    // iterate over blocks
+    for (auto &MBB : MF) {
+      // iterate over instructions
+      for (MachineBasicBlock::iterator MBBI = MBB.begin(); MBBI != MBB.end();
+           ++MBBI) {
+        if (MBBI->isCall()) {
+          DL = MBBI->getDebugLoc();
+          MBBI = BuildMI(MBB, *MBBI, DL, TII->get(TargetOpcode::COPY), FramePtr)
+                     .addReg(VReg);
+          MBBI++;
+        }
+      }
+    }
+
+    return true;
+  }
+};
+
+char FramePointerShrinkWrapPass::ID = 0;
+} // namespace
+
+char &llvm::FramePointerShrinkWrapPassID = FramePointerShrinkWrapPass::ID;
+INITIALIZE_PASS(FramePointerShrinkWrapPass, "frame-pointer-shrink-wrap",
+                "Frame Pointer Shrink Wrap", false, false)
+
+namespace llvm {
+/// Returns a newly-created MachineFunction Printer pass. The
+/// default banner is empty.
+///
+MachineFunctionPass *createFramePointerShrinkWrapPass() {
+  return new FramePointerShrinkWrapPass();
+}
+
+} // namespace llvm

llvm/lib/CodeGen/TargetOptionsImpl.cpp

bool TargetOptions::DisableFramePointerElim(const MachineFunction &MF) const {
 
   const Function &F = MF.getFunction();
 
   if (!F.hasFnAttribute("frame-pointer"))
     return false;
   StringRef FP = F.getFnAttribute("frame-pointer").getValueAsString();
   if (FP == "all")
     return true;
+  if (FP == "shrink-wrap")
+    return false;
   if (FP == "non-leaf")
     return MF.getFrameInfo().hasCalls();
   if (FP == "none")
     return false;
   llvm_unreachable("unknown frame pointer flag");
 }
 
 /// HonorSignDependentRoundingFPMath - Return true if the codegen must assume

llvm/lib/CodeGen/TargetPassConfig.cpp

if (getOptLevel() != CodeGenOpt::None) {
     // If the target requests it, assign local variables to stack slots relative
     // to one another and simplify frame index references where possible.
     addPass(&LocalStackSlotAllocationID);
   }
 
   if (TM->Options.EnableIPRA)
     addPass(createRegUsageInfoPropPass());
 
+  addPass(createFramePointerShrinkWrapPass());
+
   // Run pre-ra passes.
   addPreRegAlloc();
 
   // Debugifying the register allocator passes seems to provoke some
   // non-determinism that affects CodeGen and there doesn't seem to be a point
   // where it becomes safe again so stop debugifying here.
   DebugifyIsSafe = false;
 

llvm/lib/IR/Function.cpp

if (UWTable != UWTableKind::None)
     B.addUWTableAttr(UWTable);
   switch (M->getFramePointer()) {
   case FramePointerKind::None:
     // 0 ("none") is the default.
     break;
   case FramePointerKind::NonLeaf:
     B.addAttribute("frame-pointer", "non-leaf");
     break;
+  case FramePointerKind::ShrinkWrap:
+    B.addAttribute("frame-pointer", "shrink-wrap");
+    break;
   case FramePointerKind::All:
     B.addAttribute("frame-pointer", "all");
     break;
   }
   if (M->getModuleFlag("function_return_thunk_extern"))
     B.addAttribute(Attribute::FnRetThunkExtern);
   F->addFnAttrs(B);
   return F;

llvm/lib/IR/Verifier.cpp

if (Attrs.hasFnAttr(Attribute::VScaleRange)) {
 
     std::optional<unsigned> VScaleMax = Attrs.getFnAttrs().getVScaleRangeMax();
     if (VScaleMax && VScaleMin > VScaleMax)
       CheckFailed("'vscale_range' minimum cannot be greater than maximum", V);
   }
 
   if (Attrs.hasFnAttr("frame-pointer")) {
     StringRef FP = Attrs.getFnAttr("frame-pointer").getValueAsString();
-    if (FP != "all" && FP != "non-leaf" && FP != "none")
+    if (FP != "all" && FP != "non-leaf" && FP != "shrink-wrap" && FP != "none")
       CheckFailed("invalid value for 'frame-pointer' attribute: " + FP, V);
   }
 
   checkUnsignedBaseTenFuncAttr(Attrs, "patchable-function-prefix", V);
   checkUnsignedBaseTenFuncAttr(Attrs, "patchable-function-entry", V);
   checkUnsignedBaseTenFuncAttr(Attrs, "warn-stack-size", V);
 }
 

llvm/lib/Target/X86/X86FrameLowering.h

public:
 
   bool
   restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
                               MachineBasicBlock::iterator MI,
                               MutableArrayRef<CalleeSavedInfo> CSI,
                               const TargetRegisterInfo *TRI) const override;
 
   bool hasFP(const MachineFunction &MF) const override;
+  bool hasFPShrinkWrap(const MachineFunction &MF) const override;
   bool hasReservedCallFrame(const MachineFunction &MF) const override;
   bool canSimplifyCallFramePseudos(const MachineFunction &MF) const override;
   bool needsFrameIndexResolution(const MachineFunction &MF) const override;
 
   StackOffset getFrameIndexReference(const MachineFunction &MF, int FI,
                                      Register &FrameReg) const override;
 
   int getWin64EHFrameIndexRef(const MachineFunction &MF, int FI,

llvm/lib/Target/X86/X86FrameLowering.cpp

return (MF.getTarget().Options.DisableFramePointerElim(MF) ||
           MFI.isFrameAddressTaken() || MFI.hasOpaqueSPAdjustment() ||
           MF.getInfo<X86MachineFunctionInfo>()->getForceFramePointer() ||
           MF.getInfo<X86MachineFunctionInfo>()->hasPreallocatedCall() ||
           MF.callsUnwindInit() || MF.hasEHFunclets() || MF.callsEHReturn() ||
           MFI.hasStackMap() || MFI.hasPatchPoint() ||
           (isWin64Prologue(MF) && MFI.hasCopyImplyingStackAdjustment()));
 }
 
+bool X86FrameLowering::hasFPShrinkWrap(const MachineFunction &MF) const {
+  if (hasFP(MF))
+    return false;
+  const Function &F = MF.getFunction();
+  if (!F.hasFnAttribute("frame-pointer"))
+    return false;
+  StringRef FP = F.getFnAttribute("frame-pointer").getValueAsString();
+  return FP == "shrink-wrap";
+}
+
 static unsigned getSUBriOpcode(bool IsLP64, int64_t Imm) {
   if (IsLP64) {
     if (isInt<8>(Imm))
       return X86::SUB64ri8;
     return X86::SUB64ri32;
   } else {
     if (isInt<8>(Imm))
       return X86::SUB32ri8;
void X86FrameLowering::emitPrologue(MachineFunction &MF,
   bool IsFunclet = MBB.isEHFuncletEntry();
   EHPersonality Personality = EHPersonality::Unknown;
   if (Fn.hasPersonalityFn())
     Personality = classifyEHPersonality(Fn.getPersonalityFn());
   bool FnHasClrFunclet =
       MF.hasEHFunclets() && Personality == EHPersonality::CoreCLR;
   bool IsClrFunclet = IsFunclet && FnHasClrFunclet;
   bool HasFP = hasFP(MF);
+  bool HasFPShrinkWrap = hasFPShrinkWrap(MF);
   bool IsWin64Prologue = isWin64Prologue(MF);
   bool NeedsWin64CFI = IsWin64Prologue && Fn.needsUnwindTableEntry();
   // FIXME: Emit FPO data for EH funclets.
   bool NeedsWinFPO =
       !IsFunclet && STI.isTargetWin32() && MMI.getModule()->getCodeViewFlag();
   bool NeedsWinCFI = NeedsWin64CFI || NeedsWinFPO;
   bool NeedsDwarfCFI = needsDwarfCFI(MF);
   Register FramePtr = TRI->getFrameRegister(MF);
void X86FrameLowering::emitPrologue(MachineFunction &MF,
   if (has128ByteRedZone(MF) && !TRI->hasStackRealignment(MF) &&
       !MFI.hasVarSizedObjects() &&             // No dynamic alloca.
       !MFI.adjustsStack() &&                   // No calls.
       !EmitStackProbeCall &&                   // No stack probes.
       !MFI.hasCopyImplyingStackAdjustment() && // Don't push and pop.
       !MF.shouldSplitStack()) {                // Regular stack
     uint64_t MinSize =
         X86FI->getCalleeSavedFrameSize() - X86FI->getTCReturnAddrDelta();
-    if (HasFP) MinSize += SlotSize;
+    if (HasFP || HasFPShrinkWrap) MinSize += SlotSize;
     X86FI->setUsesRedZone(MinSize > 0 || StackSize > 0);
     StackSize = std::max(MinSize, StackSize > 128 ? StackSize - 128 : 0);
     MFI.setStackSize(StackSize);
   }
 
   // Insert stack pointer adjustment for later moving of return addr.  Only
   // applies to tail call optimized functions where the callee argument stack
   // size is bigger than the callers.
if (!IsFunclet) {
               .setMIFlag(MachineInstr::FrameSetup);
         }
       }
     }
   } else {
     assert(!IsFunclet && "funclets without FPs not yet implemented");
     NumBytes = StackSize -
                (X86FI->getCalleeSavedFrameSize() + TailCallArgReserveSize);
+
+    if (HasFPShrinkWrap) {
+      NumBytes -= SlotSize;
+      // Callee-saved registers are pushed on stack before the stack is
+      // realigned.
+      if (TRI->hasStackRealignment(MF) && !IsWin64Prologue)
+        NumBytes = alignTo(NumBytes, MaxAlign);
+
+      // Save EBP/RBP into the appropriate stack slot.
+      Register FP = Is64Bit ? X86::RBP : X86::EBP;
+      BuildMI(MBB, MBBI, DL, TII.get(Is64Bit ? X86::PUSH64r : X86::PUSH32r))
+          .addReg(FP, RegState::Kill)
+          .setMIFlag(MachineInstr::FrameSetup);
+
+      if (NeedsDwarfCFI) {
+        // Mark the place where EBP/RBP was saved.
+        // Define the current CFA rule to use the provided offset.
+        assert(StackSize);
+        BuildCFI(MBB, MBBI, DL,
+                 MCCFIInstruction::cfiDefCfaOffset(nullptr, -2 * stackGrowth),
+                 MachineInstr::FrameSetup);
+
+        // Change the rule for the FramePtr to be an "offset" rule.
+        unsigned DwarfFramePtr = TRI->getDwarfRegNum(FP, true);
+        BuildCFI(MBB, MBBI, DL,
+                 MCCFIInstruction::createOffset(nullptr, DwarfFramePtr,
+                                                2 * stackGrowth),
+                 MachineInstr::FrameSetup);
+      }
+    }
   }
 
   // Update the offset adjustment, which is mainly used by codeview to translate
   // from ESP to VFRAME relative local variable offsets.
   if (!IsFunclet) {
     if (HasFP && TRI->hasStackRealignment(MF))
       MFI.setOffsetAdjustment(-NumBytes);
     else
void X86FrameLowering::emitPrologue(MachineFunction &MF,
   while (MBBI != MBB.end() &&
          MBBI->getFlag(MachineInstr::FrameSetup) &&
          (MBBI->getOpcode() == X86::PUSH32r ||
           MBBI->getOpcode() == X86::PUSH64r)) {
     PushedRegs = true;
     Register Reg = MBBI->getOperand(0).getReg();
     ++MBBI;
 
-    if (!HasFP && NeedsDwarfCFI) {
+    if (( !HasFP && !HasFPShrinkWrap  )&& NeedsDwarfCFI) {
       // Mark callee-saved push instruction.
       // Define the current CFA rule to use the provided offset.
       assert(StackSize);
       BuildCFI(MBB, MBBI, DL,
                MCCFIInstruction::cfiDefCfaOffset(nullptr, -StackOffset),
                MachineInstr::FrameSetup);
       StackOffset += stackGrowth;
     }
if (!HasFP && NumBytes) {
           MCCFIInstruction::cfiDefCfaOffset(nullptr, StackSize - stackGrowth),
           MachineInstr::FrameSetup);
     }
 
     // Emit DWARF info specifying the offsets of the callee-saved registers.
     emitCalleeSavedFrameMoves(MBB, MBBI, DL, true);
   }
 
+  if (HasFPShrinkWrap) {
+    Register FP = Is64Bit ? X86::RBP : X86::EBP;
+    MBBI = BuildMI(MBB, MBBI, DL, TII.get(IsLP64 ? X86::LEA64r : X86::LEA64_32r),
+        FP)
+      .addReg(X86::RSP)
+      .addImm(1)
+      .addReg(0)
+      .addImm(-StackSize)
+      .addReg(0);
+    MBBI++;
+  }
+
   // X86 Interrupt handling function cannot assume anything about the direction
   // flag (DF in EFLAGS register). Clear this flag by creating "cld" instruction
   // in each prologue of interrupt handler function.
   //
   // FIXME: Create "cld" instruction only in these cases:
   // 1. The interrupt handling function uses any of the "rep" instructions.
   // 2. Interrupt handling function calls another function.
   //
void X86FrameLowering::emitEpilogue(MachineFunction &MF,
   bool IsFunclet = MBBI == MBB.end() ? false : isFuncletReturnInstr(*MBBI);
 
   // Get the number of bytes to allocate from the FrameInfo.
   uint64_t StackSize = MFI.getStackSize();
   uint64_t MaxAlign = calculateMaxStackAlign(MF);
   unsigned CSSize = X86FI->getCalleeSavedFrameSize();
   unsigned TailCallArgReserveSize = -X86FI->getTCReturnAddrDelta();
   bool HasFP = hasFP(MF);
+  bool HasFPShrinkWrap = hasFPShrinkWrap(MF);
   uint64_t NumBytes = 0;
 
   bool NeedsDwarfCFI = (!MF.getTarget().getTargetTriple().isOSDarwin() &&
                         !MF.getTarget().getTargetTriple().isOSWindows()) &&
                        MF.needsFrameMoves();
 
   if (IsFunclet) {
     assert(HasFP && "EH funclets without FP not yet implemented");
     NumBytes = getWinEHFuncletFrameSize(MF);
-  } else if (HasFP) {
+  } else if (HasFP || HasFPShrinkWrap) {
     // Calculate required stack adjustment.
     uint64_t FrameSize = StackSize - SlotSize;
     NumBytes = FrameSize - CSSize - TailCallArgReserveSize;
 
     // Callee-saved registers were pushed on stack before the stack was
     // realigned.
     if (TRI->hasStackRealignment(MF) && !IsWin64Prologue)
       NumBytes = alignTo(FrameSize, MaxAlign);
if (NeedsDwarfCFI) {
                  MachineInstr::FrameDestroy);
         --MBBI;
         --AfterPop;
       }
       --MBBI;
     }
   }
 
+  if(HasFPShrinkWrap){
+      Register FP = Is64Bit ? X86::RBP : X86::EBP;
+  // Pop EBP.
+    BuildMI(MBB, MBBI, DL, TII.get(Is64Bit ? X86::POP64r : X86::POP32r),
+            FP)
+        .setMIFlag(MachineInstr::FrameDestroy);
+
+    if (NeedsDwarfCFI) {
+      unsigned DwarfStackPtr =
+          TRI->getDwarfRegNum(Is64Bit ? X86::RSP : X86::ESP, true);
+      BuildCFI(MBB, MBBI, DL,
+               MCCFIInstruction::cfiDefCfa(nullptr, DwarfStackPtr, SlotSize),
+               MachineInstr::FrameDestroy);
+      if (!MBB.succ_empty() && !MBB.isReturnBlock()) {
+        unsigned DwarfFramePtr = TRI->getDwarfRegNum(FP, true);
+        BuildCFI(MBB, AfterPop, DL,
+                 MCCFIInstruction::createRestore(nullptr, DwarfFramePtr),
+                 MachineInstr::FrameDestroy);
+        --MBBI;
+        --AfterPop;
+      }
+      --MBBI;
+    }
+  }
+
   MachineBasicBlock::iterator FirstCSPop = MBBI;
   // Skip the callee-saved pop instructions.
   while (MBBI != MBB.begin()) {
     MachineBasicBlock::iterator PI = std::prev(MBBI);
     unsigned Opc = PI->getOpcode();
 
     if (Opc != X86::DBG_VALUE && !PI->isTerminator()) {
       if ((Opc != X86::POP32r || !PI->getFlag(MachineInstr::FrameDestroy)) &&
if (this->TRI->hasBasePointer(MF)) {
     // Allocate a spill slot for EBP if we have a base pointer and EH funclets.
     if (MF.hasEHFunclets()) {
       int FI = MFI.CreateSpillStackObject(SlotSize, Align(SlotSize));
       X86FI->setHasSEHFramePtrSave(true);
       X86FI->setSEHFramePtrSaveIndex(FI);
     }
   }
 
-  if (hasFP(MF)) {
+  if (hasFP(MF) || hasFPShrinkWrap(MF)) {
     // emitPrologue always spills frame register the first thing.
     SpillSlotOffset -= SlotSize;
     MFI.CreateFixedSpillStackObject(SlotSize, SpillSlotOffset);
 
     // The async context lives directly before the frame pointer, and we
     // allocate a second slot to preserve stack alignment.
     if (X86FI->hasSwiftAsyncContext()) {
       SpillSlotOffset -= SlotSize;
       MFI.CreateFixedSpillStackObject(SlotSize, SpillSlotOffset);
       SpillSlotOffset -= SlotSize;
     }
 
     // Since emitPrologue and emitEpilogue will handle spilling and restoring of
     // the frame register, we can delete it from CSI list and not have to worry
     // about avoiding it later.
-    Register FPReg = TRI->getFrameRegister(MF);
+    Register FPReg = hasFPShrinkWrap(MF) ? (Is64Bit ? X86::RBP :X86::EBP) : TRI->getFrameRegister(MF);
     for (unsigned i = 0; i < CSI.size(); ++i) {
       if (TRI->regsOverlap(CSI[i].getReg(),FPReg)) {
         CSI.erase(CSI.begin() + i);
         break;
       }
     }
   }
 

llvm/lib/Target/X86/X86RegisterInfo.h

public:
   /// findDeadCallerSavedReg - Return a caller-saved register that isn't live
   /// when it reaches the "return" instruction. We can then pop a stack object
   /// to this register without worry about clobbering it.
   unsigned findDeadCallerSavedReg(MachineBasicBlock &MBB,
                                   MachineBasicBlock::iterator &MBBI) const;
 
   // Debug information queries.
   Register getFrameRegister(const MachineFunction &MF) const override;
+  Register getFPReg(const MachineFunction &MF) const override;
   unsigned getPtrSizedFrameRegister(const MachineFunction &MF) const;
   unsigned getPtrSizedStackRegister(const MachineFunction &MF) const;
   Register getStackRegister() const { return StackPtr; }
   Register getBaseRegister() const { return BasePtr; }
   /// Returns physical register used as frame pointer.
   /// This will always returns the frame pointer register, contrary to
   /// getFrameRegister() which returns the "base pointer" in situations
   /// involving a stack, frame and base pointer.

llvm/lib/Target/X86/X86RegisterInfo.cpp

unsigned X86RegisterInfo::findDeadCallerSavedReg(
   return 0;
 }
 
 Register X86RegisterInfo::getFrameRegister(const MachineFunction &MF) const {
   const X86FrameLowering *TFI = getFrameLowering(MF);
   return TFI->hasFP(MF) ? FramePtr : StackPtr;
 }
 
+Register X86RegisterInfo::getFPReg(const MachineFunction &MF) const {
+  return getFramePtr();
+}
+
 unsigned
 X86RegisterInfo::getPtrSizedFrameRegister(const MachineFunction &MF) const {
   const X86Subtarget &Subtarget = MF.getSubtarget<X86Subtarget>();
   Register FrameReg = getFrameRegister(MF);
   if (Subtarget.isTarget64BitILP32())
     FrameReg = getX86SubSuperRegister(FrameReg, 32);
   return FrameReg;
 }