[FunctionAttrs] allow weak functions to propagate noreturn

[nickdesaulniers]

Summary

I noticed that FunctionAttrs would propagate noreturn for various
functions, but stopped unexpectedly for a very simple weak definition.

While functions with weak linkage may be redefined, that should not
prevent us from propagating noreturn for this particular definition.

Link: https://github.com/ClangBuiltLinux/linux/issues/1815

[jdoerfert]

I don't think this is sound. Refinement again:

static I = 0;
__attribute__((weak)) void weak() {
  unspecified_order(++I, UB_if_I_is_non_zero());
}

Order 1:

static I = 0;
__attribute__((weak)) void weak() {
  auto _T1 = ++I;
  auto _T2 = UB_if_I_is_non_zero();
  unspecified_order(_T1, _T2);
  // weak is now noreturn because we hit UB computing _T2.
}

Order 2:

static I = 0;
__attribute__((weak)) void weak() {
  auto _T1 = UB_if_I_is_non_zero();
  auto _T2 = ++I;
  unspecified_order(_T2, _T1);
  // weak is not noreturn and optimizing call sites with it will cause problems if we pick this version.
}

[nickdesaulniers]

Right, the callers is what we have to worry about.

If the weak function was declared as being noreturn, even the strong definitions should be noreturn, and optimizations should hold the code to that contract.

But if the weak function wasn't declared as noreturn, inferring it for one definition says nothing about the strong definition, so such optimizations might be surprising!

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

static bool canReturn(Function &F) {
 
   return false;
 }
 
 // Set the noreturn function attribute if possible.
 static void addNoReturnAttrs(const SCCNodeSet &SCCNodes,
                              SmallSet<Function *, 8> &Changed) {
   for (Function *F : SCCNodes) {
-    if (!F || !F->hasExactDefinition() || F->hasFnAttribute(Attribute::Naked) ||
-        F->doesNotReturn())
+    if (!F || F->hasFnAttribute(Attribute::Naked) || F->doesNotReturn())
       continue;
 
     if (!canReturn(*F)) {
       F->setDoesNotReturn();
       Changed.insert(F);
     }
   }
 }

llvm/test/Transforms/FunctionAttrs/noreturn.ll

 define void @coro() presplitcoroutine {
   call token @llvm.coro.id.retcon.once(i32 0, i32 0, ptr null, ptr @coro, ptr null, ptr null)
   call i1 @llvm.coro.end(ptr null, i1 false)
   unreachable
 }
 
 declare token @llvm.coro.id.retcon.once(i32 %size, i32 %align, ptr %buffer, ptr %prototype, ptr %alloc, ptr %free)
 declare i1 @llvm.coro.end(ptr, i1)
+
+; CHECK: Function Attrs: {{.*}}noreturn
+; CHECK-NEXT: @weak
+define weak void @weak() {
+  tail call void @noreturn()
+  unreachable
+}