Add function attribute 'optnone'

[andreadb]

Summary

Hi all,

here is the first of a sequence of patches that implements a new function attributed called 'optnone'.
Attribute optnone has been discussed here: http://llvm.1065342.n5.nabble.com/RFC-add-Function-Attribute-to-disable-optimization-td58549.html

Function attribute 'optnone' indicates that the function is not optimized by optimization or code generation passes with the exception of interprocedural optimization passes. This attribute cannot be used together with the 'alwaysinline' attribute; also it is incompatible with both 'minsize' and 'optsize'.
The inliner is not allowed to inline functions marked as 'optnone' in any situation. 'alwaysinline' functions are the only valid candidates for inlining inside the body of 'optnone' functions.

This patch defines the optnone function attribute.
I added rules to check that optnone is never used along with 'alwaysinline' or 'optsize' or 'minsize'.
I added a test under Features to verify that we correctly assemble/disassemble 'optnone'; this also required a small change in the bitcode reader/writer.
This patch also updates LangRef.rst with a short description of the new attribute.

A patch will follow that implements the required changes to the optimizer.
The last patch of the sequence will add support for the attribute to clang.

Please let me know what you think. Any feedback would be appreciated.

Thanks,
Andrea Di Biagio
SN Systems - Sony Computer Entertainment Group

[andreadb]

Ping.
Any feedback on this?

[void]

Hi Andrea,

What was the status of the proposal to add this new attribute? Was it accepted that it should be added?

-bw

[andreadb]

Hi Bill,

The proposal didn't receive strong objections but nor did it receive a clear accept. The lack of proper feedback made it difficult to understand what to do next. A couple of colleagues discussed this at one of the last Bay-area socials; the consensus there was that sending a first patch for review would be a reasonable next-step since nobody really expressed strong objections on it.

Thanks,
Andrea Di Biagio

[void]

Okay. The patch looks good to me. I skimmed over the thread you linked here. It sounds like people are generally in favor of this option. I say go ahead and commit it. If there are strong objections afterwards, we can revert this before the next release.

-bw

[andreadb]

Bill, Thanks for the review.
I committed this patch at r189101.
I agree that if there will be strong objections, then this patch can be reverted.

Thanks,
Andrea Di Biagio

docs/LangRef.rst

     This function attribute indicates that the function never returns
     with an unwind or exceptional control flow. If the function does
     unwind, its runtime behavior is undefined.
+``optnone``
+    This function attribute indicates that the function is not optimized
+    by any optimization or code generator passes with the 
+    exception of interprocedural optimization passes.
+    This attribute cannot be used together with the ``alwaysinline``
+    attribute; this attribute is also incompatible
+    with the ``minsize`` attribute and the ``optsize`` attribute.
+    
+    The inliner should never inline this function in any situation.
+    Only functions with the ``alwaysinline`` attribute are valid
+    candidates for inlining inside the body of this function.
 ``optsize``
     This attribute suggests that optimization passes and code generator
     passes make choices that keep the code size of this function low,

include/llvm-c/Core.h

        a temporary measure until the API/ABI impact to the C API is understood
        and the path forward agreed upon.
     LLVMAddressSafety = 1ULL << 32,
-    LLVMStackProtectStrongAttribute = 1ULL<<33
-    LLVMCold = 1ULL << 34
+    LLVMStackProtectStrongAttribute = 1ULL<<33,
+    LLVMCold = 1ULL << 34,
+    LLVMOptimizeNone = 1ULL << 35
     */
 } LLVMAttribute;
 

include/llvm/Bitcode/LLVMBitCodes.h

     ATTR_KIND_UW_TABLE = 33,
     ATTR_KIND_Z_EXT = 34,
     ATTR_KIND_BUILTIN = 35,
-    ATTR_KIND_COLD = 36
+    ATTR_KIND_COLD = 36,
+    ATTR_KIND_OPTIMIZE_NONE = 37
   };
 
 } // End bitc namespace

include/llvm/IR/Attributes.h

     NoReturn,              ///< Mark the function as not returning
     NoUnwind,              ///< Function doesn't unwind stack
     OptimizeForSize,       ///< opt_size
+    OptimizeNone,          ///< Function must not be optimized.
     ReadNone,              ///< Function does not access memory
     ReadOnly,              ///< Function only reads from memory
     Returned,              ///< Return value is always equal to this argument

lib/AsmParser/LLLexer.cpp

   KEYWORD(noredzone);
   KEYWORD(noreturn);
   KEYWORD(nounwind);
+  KEYWORD(optnone);
   KEYWORD(optsize);
   KEYWORD(readnone);
   KEYWORD(readonly);

lib/AsmParser/LLParser.cpp

     case lltok::kw_noredzone:         B.addAttribute(Attribute::NoRedZone); break;
     case lltok::kw_noreturn:          B.addAttribute(Attribute::NoReturn); break;
     case lltok::kw_nounwind:          B.addAttribute(Attribute::NoUnwind); break;
+    case lltok::kw_optnone:           B.addAttribute(Attribute::OptimizeNone); break;
     case lltok::kw_optsize:           B.addAttribute(Attribute::OptimizeForSize); break;
     case lltok::kw_readnone:          B.addAttribute(Attribute::ReadNone); break;
     case lltok::kw_readonly:          B.addAttribute(Attribute::ReadOnly); break;

     case lltok::kw_noredzone:
     case lltok::kw_noreturn:
     case lltok::kw_nounwind:
+    case lltok::kw_optnone:
     case lltok::kw_optsize:
     case lltok::kw_returns_twice:
     case lltok::kw_sanitize_address:

     case lltok::kw_noredzone:
     case lltok::kw_noreturn:
     case lltok::kw_nounwind:
+    case lltok::kw_optnone:
     case lltok::kw_optsize:
     case lltok::kw_returns_twice:
     case lltok::kw_sanitize_address:

lib/AsmParser/LLToken.h

     kw_noredzone,
     kw_noreturn,
     kw_nounwind,
+    kw_optnone,
     kw_optsize,
     kw_readnone,
     kw_readonly,

lib/Bitcode/Reader/BitcodeReader.cpp

   case bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE:
     *Kind = Attribute::OptimizeForSize;
     return false;
+  case bitc::ATTR_KIND_OPTIMIZE_NONE:
+    *Kind = Attribute::OptimizeNone;
+    return false;
   case bitc::ATTR_KIND_READ_NONE:
     *Kind = Attribute::ReadNone;
     return false;

lib/Bitcode/Writer/BitcodeWriter.cpp

     return bitc::ATTR_KIND_NO_UNWIND;
   case Attribute::OptimizeForSize:
     return bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE;
+  case Attribute::OptimizeNone:
+    return bitc::ATTR_KIND_OPTIMIZE_NONE;
   case Attribute::ReadNone:
     return bitc::ATTR_KIND_READ_NONE;
   case Attribute::ReadOnly:

lib/IR/Attributes.cpp

     return "noreturn";
   if (hasAttribute(Attribute::NoUnwind))
     return "nounwind";
+  if (hasAttribute(Attribute::OptimizeNone))
+    return "optnone";
   if (hasAttribute(Attribute::OptimizeForSize))
     return "optsize";
   if (hasAttribute(Attribute::ReadNone))

   case Attribute::Returned:        return 1ULL << 39;
   case Attribute::Cold:            return 1ULL << 40;
   case Attribute::Builtin:         return 1ULL << 41;
+  case Attribute::OptimizeNone:    return 1ULL << 42;
   }
   llvm_unreachable("Unsupported attribute type");
 }

lib/IR/Verifier.cpp

         I->getKindAsEnum() == Attribute::NoDuplicate ||
         I->getKindAsEnum() == Attribute::Builtin ||
         I->getKindAsEnum() == Attribute::NoBuiltin ||
-        I->getKindAsEnum() == Attribute::Cold) {
+        I->getKindAsEnum() == Attribute::Cold ||
+        I->getKindAsEnum() == Attribute::OptimizeNone) {
       if (!isFunction) {
         CheckFailed("Attribute '" + I->getAsString() +
                     "' only applies to functions!", V);

             Attrs.hasAttribute(AttributeSet::FunctionIndex,
                                Attribute::AlwaysInline)),
           "Attributes 'noinline and alwaysinline' are incompatible!", V);
+
+  if (Attrs.hasAttribute(AttributeSet::FunctionIndex, 
+                         Attribute::OptimizeNone)) {
+    Assert1(!Attrs.hasAttribute(AttributeSet::FunctionIndex,
+                                Attribute::AlwaysInline),
+            "Attributes 'alwaysinline and optnone' are incompatible!", V);
+
+    Assert1(!Attrs.hasAttribute(AttributeSet::FunctionIndex,
+                                Attribute::OptimizeForSize),
+            "Attributes 'optsize and optnone' are incompatible!", V);
+
+    Assert1(!Attrs.hasAttribute(AttributeSet::FunctionIndex,
+                                Attribute::MinSize),
+            "Attributes 'minsize and optnone' are incompatible!", V);
+  }
 }
 
 void Verifier::VerifyBitcastType(const Value *V, Type *DestTy, Type *SrcTy) {

lib/Target/CppBackend/CPPBackend.cpp

       HANDLE_ATTR(ReadOnly);
       HANDLE_ATTR(NoInline);
       HANDLE_ATTR(AlwaysInline);
+      HANDLE_ATTR(OptimizeNone);
       HANDLE_ATTR(OptimizeForSize);
       HANDLE_ATTR(StackProtect);
       HANDLE_ATTR(StackProtectReq);

test/Bitcode/attributes.ll

 ; CHECK: define void @f34()
 {
         call void @nobuiltin() nobuiltin
-; CHECK: call void @nobuiltin() #23
+; CHECK: call void @nobuiltin() #24
         ret void;
 }
 
+define void @f35() optnone
+; CHECK: define void @f35() #23
+{
+        ret void;
+}
+
 ; CHECK: attributes #0 = { noreturn }
 ; CHECK: attributes #1 = { nounwind }
 ; CHECK: attributes #2 = { readnone }

 ; CHECK: attributes #20 = { "cpu"="cortex-a8" }
 ; CHECK: attributes #21 = { sspstrong }
 ; CHECK: attributes #22 = { minsize }
-; CHECK: attributes #23 = { nobuiltin }
+; CHECK: attributes #23 = { optnone }
+; CHECK: attributes #24 = { nobuiltin }
+

test/Feature/optnone.ll

+; RUN: llvm-as < %s | llvm-dis | FileCheck %s
+
+; Check for the presence of attribute noopt in the disassembly.
+
+; CHECK: @foo() #0
+define void @foo() #0 {
+  ret void
+}
+
+; CHECK: attributes #0 = { optnone }
+attributes #0 = { optnone }
+

utils/kate/llvm.xml

       <item> noredzone </item>
       <item> noreturn </item>
       <item> nounwind </item>
+      <item> optnone </item>
       <item> optsize </item>
       <item> readnone </item>
       <item> readonly </item>

utils/vim/llvm.vim

 syn keyword llvmKeyword localdynamic localexec minsize module monotonic
 syn keyword llvmKeyword msp430_intrcc naked nest noalias nocapture
 syn keyword llvmKeyword noimplicitfloat noinline nonlazybind noredzone noreturn
-syn keyword llvmKeyword nounwind optsize personality private protected
+syn keyword llvmKeyword nounwind optnone optsize personality private protected
 syn keyword llvmKeyword ptx_device ptx_kernel readnone readonly release
 syn keyword llvmKeyword returns_twice sanitize_thread sanitize_memory
 syn keyword llvmKeyword section seq_cst sideeffect signext singlethread