[PATCH] Stop resetting NoFramePointerElim in TargetMachine::resetTargetOptions

[ahatanak]

Summary

This is part of the work to remove TargetMachine::resetTargetOptions.

In this patch, instead of updating global variable TargetOptions::NoFramePointerElim in resetTargetOptions, its use in DisableFramePointerElim is replaced with calls to TargetOptions::noFramePointerElim and TargetFrameLowering::noFramePointerElim. These functions determine on a per-function basis if frame pointer elimination should be disabled.

There is no change in functionality except that cl:opt option "disable-fp-elim" can now override function attribute "no-frame-pointer-elim". I removed the option from test case 2014-08-29-CompactUnwind.ll to prevent it from changing the output (it had no effect previously, but with this patch, it overrides the function attribute).

[echristo]

Lot of extra work just to maintain the command line flag, but it looks fine. Go ahead and commit the X86 testcase fix separately if it is NFC.

-eric

[ahatanak]

Thanks, I'll commit this patch today unless there are further comments.

We can remove NoFramePointerElimOverride if we don't need the cl::opt option. We can also remove NoFramePointerElim if we can assume front-ends or JITs today emit function attribute "no-frame-pointer-elim" to disable frame pointer elimination rather than setting NoFramePointerElim, but I don't think that is the case.

[echristo]

We can probably make the assumption that front ends do that these days
since, of course, there aren't a lot of public front ends and clang has
been doing this for a while.

-eric

[ahatanak]

Does that include JITs too? r180229 made changes in ExecutionEngineBindings.cpp and added an API to enable setting NoFramePointerElim. I wasn't sure if I can make the assumption that users of the API have made changes to use function attributes.

[ahatanak]

I created a new patch which changes the backend to only look at function attribute "no-frame-pointer-elim" and disregard TargetOptions::NoFramePointerElim.

In the new patch, overrideFunctionAttributes is rewritten and renamed. The new function is called from LLVMCreateMCJITCompilerForModule and the tools (llc and opt) and it behaves differently based on where it is called:

• If it is called from the tools, it overwrites function attribute "no-frame-pointer-elim" only if the corresponding command line option "disable-fp-elim" was specified.

• If it is called from LLVMCreateMCJITCompilerForModule, it always writes the function attribute. This is necessary to preserve the behavior of this C API after changes are made in the backend. Note that I'm assuming function attribute "no-frame-pointer-elim" never appears in the module passed to this function as there are no C APIs that allow recording string function attributes as far as I can tell (see include/llvm-c/Core.h).

I also changed it to create and reset the function attribute set once per visited function rather than doing it many times.

I think this patch is better than my previous patch as it simplifies the backend. What do you think?

[echristo]

I like this much more, thank you.

A few inline comments, but don't bother with resubmitting after fixing them or responding, anything else can be follow up.

Thanks a lot!

-eric

include/llvm/CodeGen/CommandFlags.h

233

Should be possible to get rid of this now and just check the command line option?

lib/ExecutionEngine/ExecutionEngineBindings.cpp

185

Comment the true argument, (and probably why we're not setting the first two arguments as well).

test/CodeGen/X86/2014-08-29-CompactUnwind.ll

1

Should probably make this commit separately?

tools/llc/llc.cpp

308

Comment the false argument.

tools/opt/opt.cpp

400

Comment the false argument.

[ahatanak]

include/llvm/CodeGen/CommandFlags.h

233

If we get rid of this, we can't distinguish between the case where "-disable-fp-elim" was not provided at all on the command line and the case where "-disable-fp-elim=false" was provided. For both cases, NoFramePointerElim would evaluate to false.

Or perhaps I'm missing some obvious way to do this?

lib/ExecutionEngine/ExecutionEngineBindings.cpp

185

OK, will fix.

test/CodeGen/X86/2014-08-29-CompactUnwind.ll

1

Yes, this should be separate. Probably the changes I made to overrideFunctionAttribute can be a separate commit too.

tools/llc/llc.cpp

308

Will fix.

[ahatanak]

I think I should just define a separate function that unconditionally sets "no-frame-pointer-elim" and is called only from ExecutionEngineBindings.cpp. I can then rewrite setFunctionAttributes and remove both NoFramePointerElim and NoFramePointerElimOverride from TargetOptions.

I'll probably have a patch ready next week.

[ahatanak]

As a follow-up to r238080, this patch removes NoFramePointerElim and NoFramePointerElimOverride from TargetOptions and removes ExecutionEngine's dependence on CodeGen. I also intend to delete the code in EmitAssemblyHelper::CreateTargetMachine of clang which uses NoFramePointerElim.

[echristo]

This works for me, thanks.

-eric

include/llvm/CodeGen/CommandFlags.h

JTableType("jump-table-type",
               clEnumValEnd));
 
 // Common utility function tightly tied to the options listed here. Initializes
 // a TargetOptions object with CodeGen flags and returns it.
 static inline TargetOptions InitTargetOptionsFromCodeGenFlags() {
   TargetOptions Options;
   Options.LessPreciseFPMADOption = EnableFPMAD;
   Options.NoFramePointerElim = DisableFPElim;
+  Options.NoFramePointerElimOverride = DisableFPElim.getNumOccurrences() > 0;
   Options.AllowFPOpFusion = FuseFPOps;
   Options.UnsafeFPMath = EnableUnsafeFPMath;
   Options.NoInfsFPMath = EnableNoInfsFPMath;
   Options.NoNaNsFPMath = EnableNoNaNsFPMath;
   Options.HonorSignDependentRoundingFPMathOption =
       EnableHonorSignDependentRoundingFPMath;
   if (FloatABIForCalls != FloatABI::Default)
     Options.FloatABIType = FloatABIForCalls;
static inline std::string getFeaturesStr() {
   }
 
   for (unsigned i = 0; i != MAttrs.size(); ++i)
     Features.AddFeature(MAttrs[i]);
 
   return Features.getString();
 }
 
-static inline void overrideFunctionAttributes(StringRef CPU, StringRef Features,
-                                              Module &M) {
-  for (auto &F : M) {
-    if (!CPU.empty())
-      llvm::overrideFunctionAttribute("target-cpu", CPU, F);
-
-    if (!Features.empty())
-      llvm::overrideFunctionAttribute("target-features", Features, F);
-  }
-}
-
 #endif

include/llvm/IR/Function.h

ilist_traits<BasicBlock>::getSymTab(Function *F) {
   return F ? &F->getValueSymbolTable() : nullptr;
 }
 
 inline ValueSymbolTable *
 ilist_traits<Argument>::getSymTab(Function *F) {
   return F ? &F->getValueSymbolTable() : nullptr;
 }
 
-/// \brief Overwrite attribute Kind in function F.
-void overrideFunctionAttribute(StringRef Kind, StringRef Value, Function &F);
-
 } // End llvm namespace
 
 #endif

include/llvm/Target/TargetFrameLowering.h

public:
   /// Returns false otherwise.
   virtual bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
                                            MachineBasicBlock::iterator MI,
                                         const std::vector<CalleeSavedInfo> &CSI,
                                         const TargetRegisterInfo *TRI) const {
     return false;
   }
 
+  /// Return true if the target needs to disable frame pointer elimination.
+  virtual bool noFramePointerElim(const MachineFunction &MF) const;
+
   /// 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;
 
   /// 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

include/llvm/Target/TargetOptions.h

 #ifndef LLVM_TARGET_TARGETOPTIONS_H
 #define LLVM_TARGET_TARGETOPTIONS_H
 
 #include "llvm/MC/MCTargetOptions.h"
 #include <string>
 
 namespace llvm {
   class MachineFunction;
+  class Module;
   class StringRef;
 
   namespace FloatABI {
     enum ABIType {
       Default, // Target-specific (either soft or hard depending on triple, etc).
       Soft,    // Soft float.
       Hard     // Hard float.
     };
enum Model {
       Single  // Single Threaded Environment
     };
   }
 
   class TargetOptions {
   public:
     TargetOptions()
         : PrintMachineCode(false), NoFramePointerElim(false),
+          NoFramePointerElimOverride(false),
           LessPreciseFPMADOption(false), UnsafeFPMath(false),
           NoInfsFPMath(false), NoNaNsFPMath(false),
           HonorSignDependentRoundingFPMathOption(false),
           NoZerosInBSS(false),
           GuaranteedTailCallOpt(false),
           DisableTailCalls(false), StackAlignmentOverride(0),
           EnableFastISel(false), PositionIndependentExecutable(false),
           UseInitArray(false), DisableIntegratedAS(false),
           CompressDebugSections(false), FunctionSections(false),
           DataSections(false), UniqueSectionNames(true), TrapUnreachable(false),
           TrapFuncName(), FloatABIType(FloatABI::Default),
           AllowFPOpFusion(FPOpFusion::Standard), JTType(JumpTable::Single),
           ThreadModel(ThreadModel::POSIX) {}
 
     /// PrintMachineCode - This flag is enabled when the -print-machineinstrs
     /// option is specified on the command line, and should enable debugging
     /// output from the code generator.
     unsigned PrintMachineCode : 1;
 
     /// NoFramePointerElim - This flag is enabled when the -disable-fp-elim is
     /// specified on the command line.  If the target supports the frame pointer
     /// elimination optimization, this option should disable it.
     unsigned NoFramePointerElim : 1;
 
+    /// This flag is true when "disable-fp-elim" appeared on the command line.
+    unsigned NoFramePointerElimOverride : 1;
+
     /// DisableFramePointerElim - This returns true if frame pointer elimination
     /// optimization should be disabled for the given machine function.
     bool DisableFramePointerElim(const MachineFunction &MF) const;
 
     /// LessPreciseFPMAD - This flag is enabled when the
     /// -enable-fp-mad is specified on the command line.  When this flag is off
     /// (the default), the code generator is not allowed to generate mad
     /// (multiply add) if the result is "less precise" than doing those
public:
     /// ThreadModel - This flag specifies the type of threading model to assume
     /// for things like atomics
     ThreadModel::Model ThreadModel;
 
     /// Machine level options.
     MCTargetOptions MCOptions;
   };
 
+/// \brief Set function attributes of functions in Module M based on CPU,
+/// Features, and Options.
+/// If AlwaysRecordAttrs is true, it will always record the function attributes
+/// in Options regardless of whether those attributes were specified on the
+/// tool's command line.
+void setFunctionAttributes(StringRef CPU, StringRef Features,
+                           const TargetOptions &Options, Module &M,
+                           bool AlwaysRecordAttrs);
+
 // Comparison operators:
 
 
 inline bool operator==(const TargetOptions &LHS,
                        const TargetOptions &RHS) {
 #define ARE_EQUAL(X) LHS.X == RHS.X
   return
     ARE_EQUAL(UnsafeFPMath) &&

lib/CodeGen/TargetFrameLoweringImpl.cpp

 //===----- TargetFrameLoweringImpl.cpp - Implement target frame interface --==//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Implements the layout of a stack frame on the target machine.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Target/TargetFrameLowering.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/IR/Function.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
 #include <cstdlib>
 using namespace llvm;
 
 TargetFrameLowering::~TargetFrameLowering() {
 }
 
+/// The default implementation just looks at attribute "no-frame-pointer-elim".
+bool TargetFrameLowering::noFramePointerElim(const MachineFunction &MF) const {
+  auto Attr = MF.getFunction()->getFnAttribute("no-frame-pointer-elim");
+  return Attr.getValueAsString() == "true";
+}
+
 /// getFrameIndexOffset - Returns the displacement from the frame register to
 /// the stack frame of the specified index. This is the default implementation
 /// which is overridden for some targets.
 int TargetFrameLowering::getFrameIndexOffset(const MachineFunction &MF,
                                              int FI) const {
   const MachineFrameInfo *MFI = MF.getFrameInfo();
   return MFI->getObjectOffset(FI) + MFI->getStackSize() -
     getOffsetOfLocalArea() + MFI->getOffsetAdjustment();

lib/CodeGen/TargetOptionsImpl.cpp

 //===-- TargetOptionsImpl.cpp - Options that apply to all targets ----------==//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the methods in the TargetOptions.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/Function.h"
+#include "llvm/IR/Module.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/Target/TargetFrameLowering.h"
 #include "llvm/Target/TargetOptions.h"
+#include "llvm/Target/TargetSubtargetInfo.h"
 using namespace llvm;
 
 /// DisableFramePointerElim - This returns true if frame pointer elimination
 /// optimization should be disabled for the given machine function.
 bool TargetOptions::DisableFramePointerElim(const MachineFunction &MF) const {
-  // Check to see if we should eliminate non-leaf frame pointers and then
-  // check to see if we should eliminate all frame pointers.
-  if (MF.getFunction()->hasFnAttribute("no-frame-pointer-elim-non-leaf") &&
-      !NoFramePointerElim) {
-    const MachineFrameInfo *MFI = MF.getFrameInfo();
-    return MFI->hasCalls();
-  }
+  // Check to see if we should eliminate all frame pointers.
+  if (MF.getSubtarget().getFrameLowering()->noFramePointerElim(MF))
+    return true;
+
+  // Check to see if we should eliminate non-leaf frame pointers.
+  if (MF.getFunction()->hasFnAttribute("no-frame-pointer-elim-non-leaf"))
+    return MF.getFrameInfo()->hasCalls();
 
-  return NoFramePointerElim;
+  return false;
 }
 
 /// LessPreciseFPMAD - This flag return true when -enable-fp-mad option
 /// is specified on the command line.  When this flag is off(default), the
 /// code generator is not allowed to generate mad (multiply add) if the
 /// result is "less precise" than doing those operations individually.
 bool TargetOptions::LessPreciseFPMAD() const {
   return UnsafeFPMath || LessPreciseFPMADOption;
 }
 
 /// HonorSignDependentRoundingFPMath - Return true if the codegen must assume
 /// that the rounding mode of the FPU can change from its default.
 bool TargetOptions::HonorSignDependentRoundingFPMath() const {
   return !UnsafeFPMath && HonorSignDependentRoundingFPMathOption;
 }
 
 /// getTrapFunctionName - If this returns a non-empty string, this means isel
 /// should lower Intrinsic::trap to a call to the specified function name
 /// instead of an ISD::TRAP node.
 StringRef TargetOptions::getTrapFunctionName() const {
   return TrapFuncName;
 }
+
+
+void llvm::setFunctionAttributes(StringRef CPU, StringRef Features,
+                                 const TargetOptions &Options, Module &M,
+                                 bool AlwaysRecordAttrs) {
+  for (auto &F : M) {
+    auto &Ctx = F.getContext();
+    AttributeSet Attrs = F.getAttributes(), NewAttrs;
+
+    if (!CPU.empty())
+      NewAttrs = NewAttrs.addAttribute(Ctx, AttributeSet::FunctionIndex,
+                                       "target-cpu", CPU);
+
+    if (!Features.empty())
+      NewAttrs = NewAttrs.addAttribute(Ctx, AttributeSet::FunctionIndex,
+                                       "target-features", Features);
+
+    if (Options.NoFramePointerElimOverride || AlwaysRecordAttrs)
+      NewAttrs = NewAttrs.addAttribute(
+          Ctx, AttributeSet::FunctionIndex, "no-frame-pointer-elim",
+          Options.NoFramePointerElim ? "true" : "false");
+
+    // Let NewAttrs override Attrs.
+    NewAttrs = Attrs.addAttributes(Ctx, AttributeSet::FunctionIndex, NewAttrs);
+    F.setAttributes(NewAttrs);
+  }
+}

lib/ExecutionEngine/ExecutionEngineBindings.cpp

LLVMBool LLVMCreateMCJITCompilerForModule(
   // set to the bitwise equivalent of zero, and assume that this means "do the
   // default" as if that option hadn't been available.
   LLVMInitializeMCJITCompilerOptions(&options, sizeof(options));
   memcpy(&options, PassedOptions, SizeOfPassedOptions);
   
   TargetOptions targetOptions;
   targetOptions.NoFramePointerElim = options.NoFramePointerElim;
   targetOptions.EnableFastISel = options.EnableFastISel;
+  std::unique_ptr<Module> Mod(unwrap(M));
+
+  if (Mod)
+    setFunctionAttributes("", "", targetOptions, *Mod, true);
 
   std::string Error;
-  EngineBuilder builder(std::unique_ptr<Module>(unwrap(M)));
+  EngineBuilder builder(std::move(Mod));
   builder.setEngineKind(EngineKind::JIT)
          .setErrorStr(&Error)
          .setOptLevel((CodeGenOpt::Level)options.OptLevel)
          .setCodeModel(unwrap(options.CodeModel))
          .setTargetOptions(targetOptions);
   if (options.MCJMM)
     builder.setMCJITMemoryManager(
       std::unique_ptr<RTDyldMemoryManager>(unwrap(options.MCJMM)));

lib/IR/Function.cpp

void Function::setPrologueData(Constant *PrologueData) {
   } else {
     delete PDHolder;
     PDMap.erase(this);
     PDData &= ~(1<<2);
   }
   setValueSubclassData(PDData);
 }
 
-void llvm::overrideFunctionAttribute(StringRef Kind, StringRef Value,
-                                     Function &F) {
-  auto &Ctx = F.getContext();
-  AttributeSet Attrs = F.getAttributes(), AttrsToRemove;
-
-  AttrsToRemove =
-      AttrsToRemove.addAttribute(Ctx, AttributeSet::FunctionIndex, Kind);
-  Attrs = Attrs.removeAttributes(Ctx, AttributeSet::FunctionIndex,
-                                 AttrsToRemove);
-  Attrs = Attrs.addAttribute(Ctx, AttributeSet::FunctionIndex, Kind, Value);
-  F.setAttributes(Attrs);
-}
-
 void Function::setEntryCount(uint64_t Count) {
   MDBuilder MDB(getContext());
   setMetadata(LLVMContext::MD_prof, MDB.createFunctionEntryCount(Count));
 }
 
 Optional<uint64_t> Function::getEntryCount() const {
   MDNode *MD = getMetadata(LLVMContext::MD_prof);
   if (MD && MD->getOperand(0))
     if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0)))
       if (MDS->getString().equals("function_entry_count")) {
         ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
         return CI->getValue().getZExtValue();
       }
   return None;
 }

lib/Target/ARM/ARMFastISel.cpp

bool ARMFastISel::fastLowerArguments() {
   }
 
   return true;
 }
 
 namespace llvm {
   FastISel *ARM::createFastISel(FunctionLoweringInfo &funcInfo,
                                 const TargetLibraryInfo *libInfo) {
-    const TargetMachine &TM = funcInfo.MF->getTarget();
-    const ARMSubtarget &STI =
-        static_cast<const ARMSubtarget &>(funcInfo.MF->getSubtarget());
-    // Thumb2 support on iOS; ARM support on iOS, Linux and NaCl.
-    bool UseFastISel = false;
-    UseFastISel |= STI.isTargetMachO() && !STI.isThumb1Only();
-    UseFastISel |= STI.isTargetLinux() && !STI.isThumb();
-    UseFastISel |= STI.isTargetNaCl() && !STI.isThumb();
-
-    if (UseFastISel) {
-      // iOS always has a FP for backtracking, force other targets
-      // to keep their FP when doing FastISel. The emitted code is
-      // currently superior, and in cases like test-suite's lencod
-      // FastISel isn't quite correct when FP is eliminated.
-      TM.Options.NoFramePointerElim = true;
+    if (funcInfo.MF->getSubtarget<ARMSubtarget>().useFastISel())
       return new ARMFastISel(funcInfo, libInfo);
-    }
+
     return nullptr;
   }
 }

lib/Target/ARM/ARMFrameLowering.h

bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
                                  const std::vector<CalleeSavedInfo> &CSI,
                                  const TargetRegisterInfo *TRI) const override;
 
   bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
                                   MachineBasicBlock::iterator MI,
                                   const std::vector<CalleeSavedInfo> &CSI,
                                   const TargetRegisterInfo *TRI) const override;
 
+  bool noFramePointerElim(const MachineFunction &MF) const override;
+
   bool hasFP(const MachineFunction &MF) const override;
   bool hasReservedCallFrame(const MachineFunction &MF) const override;
   bool canSimplifyCallFramePseudos(const MachineFunction &MF) const override;
   int getFrameIndexReference(const MachineFunction &MF, int FI,
                              unsigned &FrameReg) const override;
   int ResolveFrameIndexReference(const MachineFunction &MF, int FI,
                                  unsigned &FrameReg, int SPAdj) const;
   int getFrameIndexOffset(const MachineFunction &MF, int FI) const override;

lib/Target/ARM/ARMFrameLowering.cpp

 static MachineBasicBlock::iterator
 skipAlignedDPRCS2Spills(MachineBasicBlock::iterator MI,
                         unsigned NumAlignedDPRCS2Regs);
 
 ARMFrameLowering::ARMFrameLowering(const ARMSubtarget &sti)
     : TargetFrameLowering(StackGrowsDown, sti.getStackAlignment(), 0, 4),
       STI(sti) {}
 
+bool ARMFrameLowering::noFramePointerElim(const MachineFunction &MF) const {
+  // iOS always has a FP for backtracking, force other targets to keep their FP
+  // when doing FastISel. The emitted code is currently superior, and in cases
+  // like test-suite's lencod FastISel isn't quite correct when FP is eliminated.
+  return TargetFrameLowering::noFramePointerElim(MF) ||
+         MF.getSubtarget<ARMSubtarget>().useFastISel();
+}
+
 /// hasFP - Return true if the specified function should have a dedicated frame
 /// pointer register.  This is true if the function has variable sized allocas
 /// or if frame pointer elimination is disabled.
 bool ARMFrameLowering::hasFP(const MachineFunction &MF) const {
   const TargetRegisterInfo *RegInfo = MF.getSubtarget().getRegisterInfo();
 
   // iOS requires FP not to be clobbered for backtracing purpose.
   if (STI.isTargetIOS())

lib/Target/ARM/ARMSubtarget.h

public:
   /// stack frame on entry to the function and which must be maintained by every
   /// function for this subtarget.
   unsigned getStackAlignment() const { return stackAlignment; }
 
   /// GVIsIndirectSymbol - true if the GV will be accessed via an indirect
   /// symbol.
   bool GVIsIndirectSymbol(const GlobalValue *GV, Reloc::Model RelocM) const;
 
+  /// True if fast-isel is used.
+  bool useFastISel() const;
 };
 } // End llvm namespace
 
 #endif  // ARMSUBTARGET_H

lib/Target/ARM/ARMSubtarget.cpp

 
 bool ARMSubtarget::useMovt(const MachineFunction &MF) const {
   // NOTE Windows on ARM needs to use mov.w/mov.t pairs to materialise 32-bit
   // immediates as it is inherently position independent, and may be out of
   // range otherwise.
   return UseMovt && (isTargetWindows() ||
                      !MF.getFunction()->hasFnAttribute(Attribute::MinSize));
 }
+
+bool ARMSubtarget::useFastISel() const {
+  // Thumb2 support on iOS; ARM support on iOS, Linux and NaCl.
+  return TM.Options.EnableFastISel &&
+         ((isTargetMachO() && !isThumb1Only()) ||
+          (isTargetLinux() && !isThumb()) || (isTargetNaCl() && !isThumb()));
+}

lib/Target/TargetMachine.cpp

 //    and not on the TargetMachine (via TargetOptions) at all.
 void TargetMachine::resetTargetOptions(const Function &F) const {
 #define RESET_OPTION(X, Y)                                                     \
   do {                                                                         \
     if (F.hasFnAttribute(Y))                                                   \
       Options.X = (F.getFnAttribute(Y).getValueAsString() == "true");          \
   } while (0)
 
-  RESET_OPTION(NoFramePointerElim, "no-frame-pointer-elim");
   RESET_OPTION(LessPreciseFPMADOption, "less-precise-fpmad");
   RESET_OPTION(UnsafeFPMath, "unsafe-fp-math");
   RESET_OPTION(NoInfsFPMath, "no-infs-fp-math");
   RESET_OPTION(NoNaNsFPMath, "no-nans-fp-math");
   RESET_OPTION(DisableTailCalls, "disable-tail-calls");
 }
 
 /// getRelocationModel - Returns the code generation relocation model. The

test/CodeGen/ARM/disable-fp-elim.ll

+; RUN: llc < %s -mtriple armv7-none-linux-gnueabi -O1 | FileCheck %s --check-prefix=DISABLE-FP-ELIM
+; RUN: llc < %s -mtriple armv7-none-linux-gnueabi -disable-fp-elim -O1 | FileCheck %s --check-prefix=DISABLE-FP-ELIM
+; RUN: llc < %s -mtriple armv7-none-linux-gnueabi -disable-fp-elim=false -O1 | FileCheck %s --check-prefix=ENABLE-FP-ELIM
+; RUN: llc < %s -mtriple armv7-none-linux-gnueabi -disable-fp-elim=false -O0 | FileCheck %s --check-prefix=DISABLE-FP-ELIM
+
+; Check that command line option "-disable-fp-elim" overrides function attribute
+; "no-frame-pointer-elim". Also, check frame pointer elimination is disabled
+; when fast-isel is used.
+
+; ENABLE-FP-ELIM-NOT: .setfp
+; DISABLE-FP-ELIM: .setfp r11, sp
+
+define i32 @foo1(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) #0 {
+entry:
+  %call = tail call i32 @foo2(i32 %a)
+  %add = add i32 %c, %b
+  %add1 = add i32 %add, %d
+  %add2 = add i32 %add1, %e
+  %add3 = add i32 %add2, %call
+  ret i32 %add3
+}
+
+declare i32 @foo2(i32)
+
+attributes #0 = { nounwind "no-frame-pointer-elim"="true" }

test/CodeGen/X86/2014-08-29-CompactUnwind.ll

-; RUN: llc < %s -disable-fp-elim -mtriple x86_64-apple-darwin11 -mcpu corei7 -filetype=obj -o - | llvm-objdump -d -unwind-info -s - | FileCheck %s
+; RUN: llc < %s -mtriple x86_64-apple-darwin11 -mcpu corei7 -filetype=obj -o - | llvm-objdump -d -unwind-info -s - | FileCheck %s
 ; Regression test for http://llvm.org/bugs/show_bug.cgi?id=20800.
 
 ; ModuleID = 'asan_report.ii'
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.9.0"
 
 @.str = private unnamed_addr constant [3 x i8] c"=>\00", align 1
 @.str1 = private unnamed_addr constant [3 x i8] c"  \00", align 1

tools/llc/llc.cpp

if (DisableSimplifyLibCalls)
     TLII.disableAllFunctions();
   PM.add(new TargetLibraryInfoWrapperPass(TLII));
 
   // Add the target data from the target machine, if it exists, or the module.
   if (const DataLayout *DL = Target->getDataLayout())
     M->setDataLayout(*DL);
 
   // Override function attributes.
-  overrideFunctionAttributes(CPUStr, FeaturesStr, *M);
+  setFunctionAttributes(CPUStr, FeaturesStr, Options, *M, false);
 
   if (RelaxAll.getNumOccurrences() > 0 &&
       FileType != TargetMachine::CGFT_ObjectFile)
     errs() << argv[0]
              << ": warning: ignoring -mc-relax-all because filetype != obj";
 
   {
     raw_pwrite_stream *OS = &Out->os();

tools/opt/opt.cpp

if (OptLevelO2)
     return CodeGenOpt::Default;
   if (OptLevelO3)
     return CodeGenOpt::Aggressive;
   return CodeGenOpt::None;
 }
 
 // Returns the TargetMachine instance or zero if no triple is provided.
 static TargetMachine* GetTargetMachine(Triple TheTriple, StringRef CPUStr,
-                                       StringRef FeaturesStr) {
+                                       StringRef FeaturesStr,
+                                       const TargetOptions &Options) {
   std::string Error;
   const Target *TheTarget = TargetRegistry::lookupTarget(MArch, TheTriple,
                                                          Error);
   // Some modules don't specify a triple, and this is okay.
   if (!TheTarget) {
     return nullptr;
   }
 
   return TheTarget->createTargetMachine(TheTriple.getTriple(),
-                                        CPUStr, FeaturesStr,
-                                        InitTargetOptionsFromCodeGenFlags(),
+                                        CPUStr, FeaturesStr, Options,
                                         RelocModel, CMModel,
                                         GetCodeGenOptLevel());
 }
 
 #ifdef LINK_POLLY_INTO_TOOLS
 namespace polly {
 void initializePollyPasses(llvm::PassRegistry &Registry);
 }
if (EC) {
       errs() << EC.message() << '\n';
       return 1;
     }
   }
 
   Triple ModuleTriple(M->getTargetTriple());
   std::string CPUStr, FeaturesStr;
   TargetMachine *Machine = nullptr;
+  const TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
+
   if (ModuleTriple.getArch()) {
     CPUStr = getCPUStr();
     FeaturesStr = getFeaturesStr();
-    Machine = GetTargetMachine(ModuleTriple, CPUStr, FeaturesStr);
+    Machine = GetTargetMachine(ModuleTriple, CPUStr, FeaturesStr, Options);
   }
 
   std::unique_ptr<TargetMachine> TM(Machine);
 
   // Override function attributes.
-  overrideFunctionAttributes(CPUStr, FeaturesStr, *M);
+  setFunctionAttributes(CPUStr, FeaturesStr, Options, *M, false);
 
   // If the output is set to be emitted to standard out, and standard out is a
   // console, print out a warning message and refuse to do it.  We don't
   // impress anyone by spewing tons of binary goo to a terminal.
   if (!Force && !NoOutput && !AnalyzeOnly && !OutputAssembly)
     if (CheckBitcodeOutputToConsole(Out->os(), !Quiet))
       NoOutput = true;