Add support for function attribute "notail"

[ahatanak]

Summary

This patch adds support for a new IR function attribute "notail". The attribute is used to disable tail call optimization on calls to functions marked with the attribute.

This attribute is different from the existing attribute "disable-tail-calls", which disables tail call optimizations on all call sites within the marked function.

The patch to add support for the corresponding source-level function attribute is here:
http://reviews.llvm.org/D12922

[sanjoy]

Does this mean LLVM will not longer be able to generate indirect tail calls (tail calls when the target function is not known statically); because the target function /could/ have been marked notail?

For instance, clang 3.7.0 optimizes

typedef int (g)(void *, int);

int f(g* ptr, int x) {
  return ptr(ptr, x);
}

into

	.section	__TEXT,__text,regular,pure_instructions
	.macosx_version_min 10, 10
	.globl	_f
	.align	4, 0x90
_f:                                     ## @f
	.cfi_startproc
## BB#0:
	pushq	%rbp
Ltmp0:
	.cfi_def_cfa_offset 16
Ltmp1:
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
Ltmp2:
	.cfi_def_cfa_register %rbp
	popq	%rbp
	jmpq	*%rdi                   ## TAILCALL
	.cfi_endproc


.subsections_via_symbols

[Edit] And this is now illegal since ptr can be a function in another translation unit marked notail.

[vsk]

Could you add a small test to Bitcode/compatibility.ll in the function attributes section? E.g

; CHECK: define void @f.notail() #35
define void @f.notail() notail {
  ret void
}
; CHECK: attributes #35 = { notail }

[ahatanak]

No, tail call optimization doesn't have to be disabled on indirect calls.

[sanjoy]

In D12923#247639, @ahatanak wrote:

No, tail call optimization doesn't have to be disabled on indirect calls.

What if the indirect callee is marked with notail? Isn't the whole point of notail that functions marked notail won't have tail calls to them?

Perhaps I'm missing something here, so it helps to be concrete -- in the C example I gave, what's the expected behavior of the program if the function pointer passed to f via ptr is a notail function?

I think the notail should be on the call instruction, not on the callee; as some sort of "inverse" of musttail. Then we can teach the optimizer to never codegen a notail call as a tail call.

[ahatanak]

• Added a small test to Bitcode/compatibility.ll.
• Changed attr-notail.ll to demonstrate attribute "notail" overrides the "tail" marker but doesn't override the "musttail" marker.

[sanjoy]

In D12923#247639, @ahatanak wrote:

No, tail call optimization doesn't have to be disabled on indirect calls.

An IR example of the issue I'm trying to point out is this:

define i32 @caller(i32 %a) {
entry:
  %p = alloca i32(i32)*
  store i32(i32)* @callee, i32(i32)** %p

  %ptr = load i32(i32)*, i32(i32)** %p
  %call = call i32 %ptr(i32 %a)
  ret i32 %call
}

declare i32 @callee(i32) #0

attributes #0 = { notail }

If you pass the above through opt -tailcallelim -mem2reg (opt built with this patch) you'll get

define i32 @caller(i32 %a) {
entry:
  %call = tail call i32 @callee(i32 %a)
  ret i32 %call
}

; Function Attrs: notail
declare i32 @callee(i32) #0

attributes #0 = { notail }

which is what you're trying to avoid with notail, if I understand this change correctly.

[ahatanak]

In D12923#247641, @sanjoy wrote:

In D12923#247639, @ahatanak wrote:

No, tail call optimization doesn't have to be disabled on indirect calls.

What if the indirect callee is marked with notail? Isn't the whole point of notail that functions marked notail won't have tail calls to them?

Yes, that's correct. We want to avoid doing tail call optimization on a call site if the compiler knows it is a call to a notail function. If the call is an indirect call, it's not always possible to know that.

Perhaps I'm missing something here, so it helps to be concrete -- in the C example I gave, what's the expected behavior of the program if the function pointer passed to f via ptr is a notail function?

It should have no effect. If the compiler cannot determine a call site is a call to a nontail function, it doesn't block tail call optimization.

I think the notail should be on the call instruction, not on the callee; as some sort of "inverse" of musttail. Then we can teach the optimizer to never codegen a notail call as a tail call.

I think attaching notail to the call instruction is more limiting than attaching it to the callee function in some cases. Suppose we are compiling a code like this with -O3:

int f(g* ptr, int x) {

return ptr(ptr, x);

}

int __attribute((notail)) foo2(void*, int);

int foo1(int a) {

return f(foo2, a);

}

After all the optimization passes (including the inliner) are run, the IR will look like this:

define i32 @foo1(i32 %a) #0 {
entry:

%call.i = call i32 @foo2(i8* bitcast (i32 (i8*, i32)* @foo2 to i8*), i32 %a) #2
ret i32 %call.i

}

If the notail attribute was on the call instruction, there would be no way to tell tail call optimization shouldn't be done on the call to foo2.

[ahatanak]

So, in your example, you wouldn't be able to block tail call optimization if the attribute was on the call site. Is that correct?

To elaborate on my previous comment, the notail attributes should block tail call optimization on as many call sites as possible, but it's okay if it can't block some of the indirect call sites if the compiler cannot determine which function is being called.

[sanjoy]

In D12923#247647, @ahatanak wrote:

It should have no effect. If the compiler cannot determine a call site is a call to a nontail function, it doesn't block tail call optimization.

So this (and what you said below) is fine as long as not obeying notail won't result in an
incorrect program; and notail on a function only prevents tail calls
to that function on a best effort basis. Is that the direction of
this patch? If so, then please clarify that on the langref.

Otherwise (i.e. if you *require* notail to prevent tail calls for
correctness) I don't see how you can get avoid making all indirect
calls non-tail calls.

I think the notail should be on the call instruction, not on the callee; as some sort of "inverse" of musttail. Then we can teach the optimizer to never codegen a notail call as a tail call.

I think attaching notail to the call instruction is more limiting than attaching it to the callee function in some cases. Suppose we are compiling a code like this with -O3:

int f(g* ptr, int x) {

return ptr(ptr, x);

}

int __attribute((notail)) foo2(void*, int);

int foo1(int a) {

return f(foo2, a);

}

After all the optimization passes (including the inliner) are run, the IR will look like this:

define i32 @foo1(i32 %a) #0 {
entry:

%call.i = call i32 @foo2(i8* bitcast (i32 (i8*, i32)* @foo2 to i8*), i32 %a) #2
ret i32 %call.i

}

If the notail attribute was on the call instruction, there would be no way to tell tail call optimization shouldn't be done on the call to foo2.

[ahatanak]

That's correct. Preventing tail call on a best effort basis is good enough for the use cases we care about. I'll update the langref to clarify that.

[ahatanak]

This patch makes changes to add the "notail" marker to call instructions instead of using a function attribute.

[rnk]

Seems reasonable. Where is the LangRef change for this?

[ahatanak]

Added description in LangRef.

Let me know if you think there are changes I can make to improve it.

[rnk]

lgtm

[spatel]

lib/Bitcode/Writer/BitcodeWriter.cpp

2044–2046

Hi Akira -

Can you give these bitfields proper names in a struct or enum in LLVMBitCodes.h? It took me a while to understand why we have this encoding (no code comments...).

The other reason I ask is because I was about to swipe bit 16 myself. :)

I think that's the only backwards-compatible way to add fast-math-flags to a call ( PR21290 ). We can't use the usual method of tacking an optional field to the end of the record because the record length is unknown for a call with varargs.

[ahatanak]

lib/Bitcode/Writer/BitcodeWriter.cpp

2044–2046

Hi Sanjay.

I've made the changes you suggested in my local branch, but I think they should be in a follow-up patch to separate the changes related to notail from the changes related to the bitfield names.

These are the enums I defined in LLVMBitCodes.h:

enum CallMarkersFlags {

CALL_TAIL = 0,
CALL_CCONV = 1,
CALL_MUSTTAIL = 14,
CALL_EXPLICIT_TYPE = 15,
CALL_NOTAIL = 16

};

[spatel]

lib/Bitcode/Writer/BitcodeWriter.cpp

2044–2046

Yes, a follow-up NFC patch sounds right. Thanks!

docs/LangRef.rst

``nonlazybind``
     startup time if the function is not called during program startup.
 ``noredzone``
     This attribute indicates that the code generator should not use a
     red zone, even if the target-specific ABI normally permits it.
 ``noreturn``
     This function attribute indicates that the function never returns
     normally. This produces undefined behavior at runtime if the
     function ever does dynamically return.
+``notail``
+    This attribute indicates that tail call optimization cannot be done on calls
+    to the function.
 ``nounwind``
     This function attribute indicates that the function never raises an
     exception. If the function does raise an exception, its runtime
     behavior is undefined. However, functions marked nounwind may still
     trap or generate asynchronous exceptions. Exception handling schemes
     that are recognized by LLVM to handle asynchronous exceptions, such
     as SEH, will still provide their implementation defined semantics.
 ``optnone``

include/llvm/Bitcode/LLVMBitCodes.h

enum AttributeKindCodes {
     ATTR_KIND_NON_NULL = 39,
     ATTR_KIND_JUMP_TABLE = 40,
     ATTR_KIND_DEREFERENCEABLE = 41,
     ATTR_KIND_DEREFERENCEABLE_OR_NULL = 42,
     ATTR_KIND_CONVERGENT = 43,
     ATTR_KIND_SAFESTACK = 44,
     ATTR_KIND_ARGMEMONLY = 45,
     ATTR_KIND_SWIFT_SELF = 46,
-    ATTR_KIND_SWIFT_ERROR = 47
+    ATTR_KIND_SWIFT_ERROR = 47,
+    ATTR_KIND_NO_TAIL = 48
   };
 
   enum ComdatSelectionKindCodes {
     COMDAT_SELECTION_KIND_ANY = 1,
     COMDAT_SELECTION_KIND_EXACT_MATCH = 2,
     COMDAT_SELECTION_KIND_LARGEST = 3,
     COMDAT_SELECTION_KIND_NO_DUPLICATES = 4,
     COMDAT_SELECTION_KIND_SAME_SIZE = 5,
   };
 
 } // End bitc namespace
 } // End llvm namespace
 
 #endif

include/llvm/IR/Attributes.h

enum AttrKind {
     NoInline,              ///< inline=never
     NonLazyBind,           ///< Function is called early and/or
                            ///< often, so lazy binding isn't worthwhile
     NonNull,               ///< Pointer is known to be not null
     Dereferenceable,       ///< Pointer is known to be dereferenceable
     DereferenceableOrNull, ///< Pointer is either null or dereferenceable
     NoRedZone,             ///< Disable redzone
     NoReturn,              ///< Mark the function as not returning
+    NoTail,                ///< No tail call optimization to this function
     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
     ArgMemOnly,            ///< Funciton can access memory only using pointers
                            ///< based on its arguments.
     Returned,              ///< Return value is always equal to this argument

include/llvm/IR/Instructions.h

public:
   }
 
   /// \brief Return true if the call should not be inlined.
   bool isNoInline() const { return hasFnAttr(Attribute::NoInline); }
   void setIsNoInline() {
     addAttribute(AttributeSet::FunctionIndex, Attribute::NoInline);
   }
 
+  bool isNoTail() const { return hasFnAttr(Attribute::NoTail); }
+
   /// \brief Return true if the call can return twice
   bool canReturnTwice() const {
     return hasFnAttr(Attribute::ReturnsTwice);
   }
   void setCanReturnTwice() {
     addAttribute(AttributeSet::FunctionIndex, Attribute::ReturnsTwice);
   }
 

lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
   KEYWORD(nocapture);
   KEYWORD(noduplicate);
   KEYWORD(noimplicitfloat);
   KEYWORD(noinline);
   KEYWORD(nonlazybind);
   KEYWORD(nonnull);
   KEYWORD(noredzone);
   KEYWORD(noreturn);
+  KEYWORD(notail);
   KEYWORD(nounwind);
   KEYWORD(optnone);
   KEYWORD(optsize);
   KEYWORD(readnone);
   KEYWORD(readonly);
   KEYWORD(returned);
   KEYWORD(returns_twice);
   KEYWORD(signext);

lib/AsmParser/LLParser.cpp

while (true) {
     case lltok::kw_nobuiltin: B.addAttribute(Attribute::NoBuiltin); break;
     case lltok::kw_noduplicate: B.addAttribute(Attribute::NoDuplicate); break;
     case lltok::kw_noimplicitfloat:
       B.addAttribute(Attribute::NoImplicitFloat); break;
     case lltok::kw_noinline: B.addAttribute(Attribute::NoInline); break;
     case lltok::kw_nonlazybind: B.addAttribute(Attribute::NonLazyBind); break;
     case lltok::kw_noredzone: B.addAttribute(Attribute::NoRedZone); break;
     case lltok::kw_noreturn: B.addAttribute(Attribute::NoReturn); break;
+    case lltok::kw_notail: B.addAttribute(Attribute::NoTail); 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_returns_twice:
       B.addAttribute(Attribute::ReturnsTwice); break;
     case lltok::kw_ssp: B.addAttribute(Attribute::StackProtect); break;
while (1) {
     case lltok::kw_naked:
     case lltok::kw_nobuiltin:
     case lltok::kw_noduplicate:
     case lltok::kw_noimplicitfloat:
     case lltok::kw_noinline:
     case lltok::kw_nonlazybind:
     case lltok::kw_noredzone:
     case lltok::kw_noreturn:
+    case lltok::kw_notail:
     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_sanitize_memory:
     case lltok::kw_sanitize_thread:
     case lltok::kw_ssp:
while (1) {
     case lltok::kw_inlinehint:
     case lltok::kw_jumptable:
     case lltok::kw_minsize:
     case lltok::kw_naked:
     case lltok::kw_nobuiltin:
     case lltok::kw_noduplicate:
     case lltok::kw_noimplicitfloat:
     case lltok::kw_noinline:
+    case lltok::kw_notail:
     case lltok::kw_nonlazybind:
     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

enum Kind {
     kw_nocapture,
     kw_noduplicate,
     kw_noimplicitfloat,
     kw_noinline,
     kw_nonlazybind,
     kw_nonnull,
     kw_noredzone,
     kw_noreturn,
+    kw_notail,
     kw_nounwind,
     kw_optnone,
     kw_optsize,
     kw_readnone,
     kw_readonly,
     kw_returned,
     kw_returns_twice,
     kw_signext,

lib/Bitcode/Reader/BitcodeReader.cpp

static Attribute::AttrKind getAttrFromCode(uint64_t Code) {
   case bitc::ATTR_KIND_DEREFERENCEABLE:
     return Attribute::Dereferenceable;
   case bitc::ATTR_KIND_DEREFERENCEABLE_OR_NULL:
     return Attribute::DereferenceableOrNull;
   case bitc::ATTR_KIND_NO_RED_ZONE:
     return Attribute::NoRedZone;
   case bitc::ATTR_KIND_NO_RETURN:
     return Attribute::NoReturn;
+  case bitc::ATTR_KIND_NO_TAIL:
+    return Attribute::NoTail;
   case bitc::ATTR_KIND_NO_UNWIND:
     return Attribute::NoUnwind;
   case bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE:
     return Attribute::OptimizeForSize;
   case bitc::ATTR_KIND_OPTIMIZE_NONE:
     return Attribute::OptimizeNone;
   case bitc::ATTR_KIND_READ_NONE:
     return Attribute::ReadNone;

lib/Bitcode/Writer/BitcodeWriter.cpp

static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
   case Attribute::Dereferenceable:
     return bitc::ATTR_KIND_DEREFERENCEABLE;
   case Attribute::DereferenceableOrNull:
     return bitc::ATTR_KIND_DEREFERENCEABLE_OR_NULL;
   case Attribute::NoRedZone:
     return bitc::ATTR_KIND_NO_RED_ZONE;
   case Attribute::NoReturn:
     return bitc::ATTR_KIND_NO_RETURN;
+  case Attribute::NoTail:
+    return bitc::ATTR_KIND_NO_TAIL;
   case Attribute::NoUnwind:
     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 Instruction::Fence:
     break;
   case Instruction::Call: {
     const CallInst &CI = cast<CallInst>(I);
     FunctionType *FTy = CI.getFunctionType();
 
     Code = bitc::FUNC_CODE_INST_CALL;
 
     Vals.push_back(VE.getAttributeID(CI.getAttributes()));
     Vals.push_back((CI.getCallingConv() << 1) | unsigned(CI.isTailCall()) |
                    unsigned(CI.isMustTailCall()) << 14 | 1 << 15);
     Vals.push_back(VE.getTypeID(FTy));
     PushValueAndType(CI.getCalledValue(), InstID, Vals, VE);  // Callee
 
     // Emit value #'s for the fixed parameters.
     for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
       // Check for labels (can happen with asm labels).
       if (FTy->getParamType(i)->isLabelTy())
         Vals.push_back(VE.getValueID(CI.getArgOperand(i)));
       else

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

if (!RenameFn)
     Callee = getValue(I.getCalledValue());
   else
     Callee = DAG.getExternalSymbol(
         RenameFn,
         DAG.getTargetLoweringInfo().getPointerTy(DAG.getDataLayout()));
 
   // Check if we can potentially perform a tail call. More detailed checking is
   // be done within LowerCallTo, after more information about the call is known.
-  LowerCallTo(&I, Callee, I.isTailCall());
+  LowerCallTo(&I, Callee, I.isTailCall() && !I.isNoTail());
 }
 
 namespace {
 
 /// AsmOperandInfo - This contains information for each constraint that we are
 /// lowering.
 class SDISelAsmOperandInfo : public TargetLowering::AsmOperandInfo {
 public:

lib/IR/Attributes.cpp

std::string Attribute::getAsString(bool InAttrGrp) const {
   if (hasAttribute(Attribute::NonLazyBind))
     return "nonlazybind";
   if (hasAttribute(Attribute::NonNull))
     return "nonnull";
   if (hasAttribute(Attribute::NoRedZone))
     return "noredzone";
   if (hasAttribute(Attribute::NoReturn))
     return "noreturn";
+  if (hasAttribute(Attribute::NoTail))
+    return "notail";
   if (hasAttribute(Attribute::NoUnwind))
     return "nounwind";
   if (hasAttribute(Attribute::OptimizeNone))
     return "optnone";
   if (hasAttribute(Attribute::OptimizeForSize))
     return "optsize";
   if (hasAttribute(Attribute::ReadNone))
     return "readnone";
uint64_t AttributeImpl::getAttrMask(Attribute::AttrKind Val) {
   case Attribute::Cold:            return 1ULL << 40;
   case Attribute::Builtin:         return 1ULL << 41;
   case Attribute::OptimizeNone:    return 1ULL << 42;
   case Attribute::InAlloca:        return 1ULL << 43;
   case Attribute::NonNull:         return 1ULL << 44;
   case Attribute::JumpTable:       return 1ULL << 45;
   case Attribute::Convergent:      return 1ULL << 46;
   case Attribute::SafeStack:       return 1ULL << 47;
+  case Attribute::NoTail:          return 1ULL << 48;
   case Attribute::Dereferenceable:
     llvm_unreachable("dereferenceable attribute not supported in raw format");
     break;
   case Attribute::DereferenceableOrNull:
     llvm_unreachable("dereferenceable_or_null attribute not supported in raw "
                      "format");
     break;
   case Attribute::ArgMemOnly:

lib/IR/Verifier.cpp

if (I->getKindAsEnum() == Attribute::NoReturn ||
         I->getKindAsEnum() == Attribute::MinSize ||
         I->getKindAsEnum() == Attribute::NoDuplicate ||
         I->getKindAsEnum() == Attribute::Builtin ||
         I->getKindAsEnum() == Attribute::NoBuiltin ||
         I->getKindAsEnum() == Attribute::Cold ||
         I->getKindAsEnum() == Attribute::OptimizeNone ||
         I->getKindAsEnum() == Attribute::JumpTable ||
         I->getKindAsEnum() == Attribute::Convergent ||
-        I->getKindAsEnum() == Attribute::ArgMemOnly) {
+        I->getKindAsEnum() == Attribute::ArgMemOnly ||
+        I->getKindAsEnum() == Attribute::NoTail) {
       if (!isFunction) {
         CheckFailed("Attribute '" + I->getAsString() +
                     "' only applies to functions!", V);
         return;
       }
     } else if (I->getKindAsEnum() == Attribute::ReadOnly ||
                I->getKindAsEnum() == Attribute::ReadNone) {
       if (Idx == 0) {

lib/Transforms/Scalar/TailRecursionElimination.cpp

do {
     for (auto &I : *BB) {
       if (Tracker.EscapePoints.count(&I))
         Escaped = ESCAPED;
 
       CallInst *CI = dyn_cast<CallInst>(&I);
       if (!CI || CI->isTailCall())
         continue;
 
-      if (CI->doesNotAccessMemory()) {
+      bool IsNoTail = CI->isNoTail();
+
+      if (!IsNoTail && CI->doesNotAccessMemory()) {
         // A call to a readnone function whose arguments are all things computed
         // outside this function can be marked tail. Even if you stored the
         // alloca address into a global, a readnone function can't load the
         // global anyhow.
         //
         // Note that this runs whether we know an alloca has escaped or not. If
         // it has, then we can't trust Tracker.AllocaUsers to be accurate.
         bool SafeToTail = true;
for (auto &I : *BB) {
               F.getContext(), "tailcallelim", F, CI->getDebugLoc(),
               "marked this readnone call a tail call candidate");
           CI->setTailCall();
           Modified = true;
           continue;
         }
       }
 
-      if (Escaped == UNESCAPED && !Tracker.AllocaUsers.count(CI)) {
+      if (!IsNoTail && Escaped == UNESCAPED && !Tracker.AllocaUsers.count(CI)) {
         DeferredTails.push_back(CI);
       } else {
         AllCallsAreTailCalls = false;
       }
     }
 
     for (auto *SuccBB : make_range(succ_begin(BB), succ_end(BB))) {
       auto &State = Visited[SuccBB];

test/Bindings/llvm-c/invalid-bitcode.test

 ; RUN: not llvm-c-test --module-dump < %S/Inputs/invalid.ll.bc 2>&1 | FileCheck %s
 
-CHECK: Error parsing bitcode: Unknown attribute kind (48)
+CHECK: Error parsing bitcode: Unknown attribute kind (63)

test/Bitcode/attributes.ll

 }
 
 declare void @nobuiltin()
 
 define void @f34()
 ; CHECK: define void @f34()
 {
         call void @nobuiltin() nobuiltin
-; CHECK: call void @nobuiltin() #27
+; CHECK: call void @nobuiltin() #28
         ret void;
 }
 
 define void @f35() optnone noinline
 ; CHECK: define void @f35() #23
 {
         ret void;
 }
define "string_attribute" void @f45(i32 "string_attribute") {
   ret void
 }
 
 ; CHECK: define "string_attribute_with_value"="value" void @f46(i32 "string_attribute_with_value"="value")
 define "string_attribute_with_value"="value" void @f46(i32 "string_attribute_with_value"="value") {
   ret void
 }
 
+; CHECK: define void @f47() #27
+define void @f47() notail {
+  ret void
+}
+
 ; CHECK: attributes #0 = { noreturn }
 ; CHECK: attributes #1 = { nounwind }
 ; CHECK: attributes #2 = { readnone }
 ; CHECK: attributes #3 = { readonly }
 ; CHECK: attributes #4 = { noinline }
 ; CHECK: attributes #5 = { alwaysinline }
 ; CHECK: attributes #6 = { optsize }
 ; CHECK: attributes #7 = { ssp }

 ; CHECK: attributes #19 = { sanitize_memory }
 ; CHECK: attributes #20 = { "cpu"="cortex-a8" }
 ; CHECK: attributes #21 = { sspstrong }
 ; CHECK: attributes #22 = { minsize }
 ; CHECK: attributes #23 = { noinline optnone }
 ; CHECK: attributes #24 = { jumptable }
 ; CHECK: attributes #25 = { convergent }
 ; CHECK: attributes #26 = { argmemonly }
-; CHECK: attributes #27 = { nobuiltin }
+; CHECK: attributes #27 = { notail }
+; CHECK: attributes #28 = { nobuiltin }

test/Bitcode/invalid.ll

 ; RUN:  not llvm-dis < %s.bc 2>&1 | FileCheck %s
 
-; CHECK: llvm-dis{{(\.EXE|\.exe)?}}: error: Unknown attribute kind (48)
+; CHECK: llvm-dis{{(\.EXE|\.exe)?}}: error: Unknown attribute kind (63)
 
 ; invalid.ll.bc has an invalid attribute number.
 ; The test checks that LLVM reports the error and doesn't access freed memory
 ; in doing so.

test/CodeGen/X86/attr-notail.ll

+; RUN: llc < %s -march=x86-64 | FileCheck %s
+
+; CHECK-LABEL: {{\_?}}caller0:
+; CHECK: callq {{\_?}}callee0
+; CHECK: jmp {{\_?}}callee2
+; CHECK: callq {{\_?}}callee1
+
+define i32 @callee0(i32 %a) #0 {
+entry:
+  %add = add nsw i32 %a, 1
+  ret i32 %add
+}
+
+define i32 @caller0(i32 %a) {
+entry:
+  %cmp = icmp sgt i32 %a, 0
+  br i1 %cmp, label %if.then, label %if.end
+
+if.then:                                          ; preds = %entry
+  %call = call i32 @callee0(i32 %a)
+  br label %return
+
+if.end:                                           ; preds = %entry
+  %cmp1 = icmp slt i32 %a, 0
+  br i1 %cmp1, label %if.then.2, label %if.end.4
+
+if.then.2:                                        ; preds = %if.end
+  %call3 = call i32 @callee1(i32 %a)
+  br label %return
+
+if.end.4:                                         ; preds = %if.end
+  %call5 = tail call i32 @callee2(i32 %a)
+  br label %return
+
+return:                                           ; preds = %if.end.4, %if.then.2, %if.then
+  %retval.0 = phi i32 [ %call, %if.then ], [ %call3, %if.then.2 ], [ %call5, %if.end.4 ]
+  ret i32 %retval.0
+}
+
+declare i32 @callee1(i32) #0
+
+declare i32 @callee2(i32)
+
+attributes #0 = { notail }

test/Transforms/TailCallElim/notail.ll

+; RUN: opt < %s -tailcallelim -S | FileCheck %s
+
+; Check that callee isn't marked as "tail".
+
+; CHECK: %{{[a-z]+}} = call i32 @callee(i32 %{{[a-z]+}})
+
+define i32 @caller(i32 %a) {
+entry:
+  %call = call i32 @callee(i32 %a)
+  ret i32 %call
+}
+
+declare i32 @callee(i32) #0
+
+attributes #0 = { notail }