[IR] Create new method in the Function class (NFC)

[evandro]

Summary

Create method optForNaught() testing for -O0 and refactor appropriately.

[evandro]

Ping! 🔔

[spatel]

llvm/include/llvm/IR/Function.h

594

I understand that we're trying to mimic the existing 'optForSize' naming, but "optForNaught" is not obvious.
How about "isOptNone()"?

[evandro]

llvm/include/llvm/IR/Function.h

594

optForNone()? Though I don't feel strongly about it.

[spatel]

llvm/include/llvm/IR/Function.h

594

I'm still not reading that as obvious. When I see this in IR, I'm used to seeing the string "optnone", so it makes more sense to me that the query includes that string exactly. If others disagree, I won't block it though.

[evandro]

llvm/include/llvm/IR/Function.h

594

In an OCD way, I'm trying to preserve the existing pattern for such methods. 😌

[spatel]

Ok, LGTM...it's just a convenience wrapper, so if anyone feels like the name can be improved, feel free. My vote would still be "isOptNone" or "hasOptNone". If that doesn't match the existing API, then I'd say fix that too: "hasOptSize".

[evandro]

That's a good idea to follow up on, following the pattern of hasOptNone().

clang/lib/CodeGen/CGCall.cpp

 
 void CodeGenModule::AddDefaultFnAttrs(llvm::Function &F) {
   llvm::AttrBuilder FuncAttrs;
-  ConstructDefaultFnAttrList(F.getName(),
-                             F.hasFnAttribute(llvm::Attribute::OptimizeNone),
+  ConstructDefaultFnAttrList(F.getName(), F.optForNaught(),
                              /* AttrOnCallsite = */ false, FuncAttrs);
   F.addAttributes(llvm::AttributeList::FunctionIndex, FuncAttrs);
 }

llvm/include/llvm/IR/Function.h

     addAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
   }
 
+  /// Do not optimize this function (-O0).
+  bool optForNaught() const { return hasFnAttribute(Attribute::OptimizeNone); }
+
   /// Optimize this function for minimum size (-Oz).
   bool optForMinSize() const { return hasFnAttribute(Attribute::MinSize); }
 

llvm/lib/Analysis/GlobalsModRef.cpp

         break;
       }
 
-      if (F->isDeclaration() || F->hasFnAttribute(Attribute::OptimizeNone)) {
+      if (F->isDeclaration() || F->optForNaught()) {
         // Try to get mod/ref behaviour from function attributes.
         if (F->doesNotAccessMemory()) {
           // Can't do better than that!

       // Don't prove any properties based on the implementation of an optnone
       // function. Function attributes were already used as a best approximation
       // above.
-      if (Node->getFunction()->hasFnAttribute(Attribute::OptimizeNone))
+      if (Node->getFunction()->optForNaught())
         continue;
 
       for (Instruction &I : instructions(Node->getFunction())) {

llvm/lib/Analysis/InlineCost.cpp

     return llvm::InlineCost::getNever("conflicting attributes");
 
   // Don't inline this call if the caller has the optnone attribute.
-  if (Caller->hasFnAttribute(Attribute::OptimizeNone))
+  if (Caller->optForNaught())
     return llvm::InlineCost::getNever("optnone attribute");
 
   // Don't inline a function that treats null pointer as valid into a caller

llvm/lib/Analysis/LoopPass.cpp

   if (Gate.isEnabled() && !Gate.shouldRunPass(this, getDescription(*L)))
     return true;
   // Check for the OptimizeNone attribute.
-  if (F->hasFnAttribute(Attribute::OptimizeNone)) {
+  if (F->optForNaught()) {
     // FIXME: Report this to dbgs() only once per function.
     LLVM_DEBUG(dbgs() << "Skipping pass '" << getPassName() << "' in function "
                       << F->getName() << "\n");

llvm/lib/Analysis/RegionPass.cpp

   if (Gate.isEnabled() && !Gate.shouldRunPass(this, getDescription(R)))
     return true;
 
-  if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+  if (F.optForNaught()) {
     // Report this only once per function.
     if (R.getEntry() == &F.getEntryBlock())
       LLVM_DEBUG(dbgs() << "Skipping pass '" << getPassName()

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

     FPO |= FrameProcedureOptions::SecurityChecks;
   FPO |= FrameProcedureOptions(uint32_t(CurFn->EncodedLocalFramePtrReg) << 14U);
   FPO |= FrameProcedureOptions(uint32_t(CurFn->EncodedParamFramePtrReg) << 16U);
-  if (Asm->TM.getOptLevel() != CodeGenOpt::None && !GV.optForSize() &&
-      !GV.hasFnAttribute(Attribute::OptimizeNone))
+  if (Asm->TM.getOptLevel() != CodeGenOpt::None &&
+      !GV.optForSize() && !GV.optForNaught())
     FPO |= FrameProcedureOptions::OptimizedForSpeed;
   // FIXME: Set GuardCfg when it is implemented.
   CurFn->FrameProcOpts = FPO;

llvm/lib/CodeGen/GlobalISel/RegBankSelect.cpp

   LLVM_DEBUG(dbgs() << "Assign register banks for: " << MF.getName() << '\n');
   const Function &F = MF.getFunction();
   Mode SaveOptMode = OptMode;
-  if (F.hasFnAttribute(Attribute::OptimizeNone))
+  if (F.optForNaught())
     OptMode = Mode::Fast;
   init(MF);
 

llvm/lib/CodeGen/SafeStack.cpp

   if (!isa<CallInst>(UnsafeStackPtr))
     return;
 
-  if(F.hasFnAttribute(Attribute::OptimizeNone))
+  if(F.optForNaught())
     return;
 
   CallSite CS(UnsafeStackPtr);

llvm/lib/IR/Pass.cpp

   if (Gate.isEnabled() && !Gate.shouldRunPass(this, getDescription(F)))
     return true;
 
-  if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+  if (F.optForNaught()) {
     LLVM_DEBUG(dbgs() << "Skipping pass '" << getPassName() << "' on function "
                       << F.getName() << "\n");
     return true;

   OptPassGate &Gate = F->getContext().getOptPassGate();
   if (Gate.isEnabled() && !Gate.shouldRunPass(this, getDescription(BB)))
     return true;
-  if (F->hasFnAttribute(Attribute::OptimizeNone)) {
+  if (F->optForNaught()) {
     // Report this only once per function.
     if (&BB == &F->getEntryBlock())
       LLVM_DEBUG(dbgs() << "Skipping pass '" << getPassName()

llvm/lib/Target/ARM/ARMAsmPrinter.cpp

 
   // Calculate this function's optimization goal.
   unsigned OptimizationGoal;
-  if (F.hasFnAttribute(Attribute::OptimizeNone))
+  if (F.optForNaught())
     // For best debugging illusion, speed and small size sacrificed
     OptimizationGoal = 6;
   else if (F.optForMinSize())

llvm/lib/Target/Hexagon/HexagonFrameLowering.cpp

 }
 
 static inline bool isOptNone(const MachineFunction &MF) {
-    return MF.getFunction().hasFnAttribute(Attribute::OptimizeNone) ||
+    return MF.getFunction().optForNaught() ||
            MF.getTarget().getOptLevel() == CodeGenOpt::None;
 }
 

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

   bool HasUnknownCall = false;
   for (LazyCallGraph::Node &N : C) {
     Function &F = N.getFunction();
-    if (F.hasFnAttribute(Attribute::OptimizeNone) ||
-        F.hasFnAttribute(Attribute::Naked)) {
+    if (F.optForNaught() || F.hasFnAttribute(Attribute::Naked)) {
       // Treat any function we're trying not to optimize as if it were an
       // indirect call and omit it from the node set used below.
       HasUnknownCall = true;

   bool ExternalNode = false;
   for (CallGraphNode *I : SCC) {
     Function *F = I->getFunction();
-    if (!F || F->hasFnAttribute(Attribute::OptimizeNone) ||
-        F->hasFnAttribute(Attribute::Naked)) {
+    if (!F || F->optForNaught() || F->hasFnAttribute(Attribute::Naked)) {
       // External node or function we're trying not to optimize - we both avoid
       // transform them and avoid leveraging information they provide.
       ExternalNode = true;

llvm/lib/Transforms/IPO/HotColdSplitting.cpp

 /// module has profile data), set entry count to 0 to ensure treated as cold.
 /// Return true if the function is changed.
 static bool markFunctionCold(Function &F, bool UpdateEntryCount = false) {
-  assert(!F.hasFnAttribute(Attribute::OptimizeNone) && "Can't mark this cold");
+  assert(!F.optForNaught() && "Can't mark this cold");
   bool Changed = false;
   if (!F.hasFnAttribute(Attribute::Cold)) {
     F.addFnAttr(Attribute::Cold);

       continue;
 
     // Do not modify `optnone` functions.
-    if (F.hasFnAttribute(Attribute::OptimizeNone))
+    if (F.optForNaught())
       continue;
 
     // Detect inherently cold functions and mark them as such.

llvm/lib/Transforms/IPO/InferFunctionAttrs.cpp

   for (Function &F : M.functions())
     // We only infer things using the prototype and the name; we don't need
     // definitions.
-    if (F.isDeclaration() && !F.hasFnAttribute((Attribute::OptimizeNone)))
+    if (F.isDeclaration() && !F.optForNaught())
       Changed |= inferLibFuncAttributes(F, TLI);
 
   return Changed;

llvm/lib/Transforms/IPO/Inliner.cpp

     LazyCallGraph::Node &N = *CG.lookup(F);
     if (CG.lookupSCC(N) != C)
       continue;
-    if (F.hasFnAttribute(Attribute::OptimizeNone)) {
+    if (F.optForNaught()) {
       setInlineRemark(Calls[i].first, "optnone attribute");
       continue;
     }

llvm/lib/Transforms/Instrumentation/IndirectCallPromotion.cpp

   }
   bool Changed = false;
   for (auto &F : M) {
-    if (F.isDeclaration())
-      continue;
-    if (F.hasFnAttribute(Attribute::OptimizeNone))
+    if (F.isDeclaration() || F.optForNaught())
       continue;
 
     std::unique_ptr<OptimizationRemarkEmitter> OwnedORE;

llvm/lib/Transforms/Scalar/WarnMissedTransforms.cpp

 WarnMissedTransformationsPass::run(Function &F, FunctionAnalysisManager &AM) {
   // Do not warn about not applied transformations if optimizations are
   // disabled.
-  if (F.hasFnAttribute(Attribute::OptimizeNone))
+  if (F.optForNaught())
     return PreservedAnalyses::all();
 
   auto &ORE = AM.getResult<OptimizationRemarkEmitterAnalysis>(F);