[CGAtomic] Mark atomic libcall functions `nounwind`

[guiand]

Summary

These functions won't ever unwind. This is useful for MemorySanitizer
as it simplifies handling __atomic_load in particular.

[eugenis]

While we are here, how about setting a few more attributes?
argmemonly, readonly/writeonly, willreturn come to mind.

[eugenis]

nocapture on the pointer argument

[guiand]

I don't think we can necessarily guarantee argmemonly/readonly/writeonly, particularly since these library calls can take a lock somewhere inside. I'll definitely add nocapture and willreturn though.

[guiand]

Added willreturn. I think nocapture is probably best left to a future change since it's more invasive -- it would require keeping tabs of which arguments to each function is a pointer arg.

[eugenis]

LGTM

clang/lib/CodeGen/CGAtomic.cpp

 
 static RValue emitAtomicLibcall(CodeGenFunction &CGF,
                                 StringRef fnName,
                                 QualType resultType,
                                 CallArgList &args) {
   const CGFunctionInfo &fnInfo =
     CGF.CGM.getTypes().arrangeBuiltinFunctionCall(resultType, args);
   llvm::FunctionType *fnTy = CGF.CGM.getTypes().GetFunctionType(fnInfo);
-  llvm::FunctionCallee fn = CGF.CGM.CreateRuntimeFunction(fnTy, fnName);
+  llvm::AttrBuilder fnAttrB;
+  fnAttrB.addAttribute(llvm::Attribute::NoUnwind);
+  fnAttrB.addAttribute(llvm::Attribute::WillReturn);
+  llvm::AttributeList fnAttrs = llvm::AttributeList::get(
+      CGF.getLLVMContext(), llvm::AttributeList::FunctionIndex, fnAttrB);
+
+  llvm::FunctionCallee fn =
+      CGF.CGM.CreateRuntimeFunction(fnTy, fnName, fnAttrs);
   auto callee = CGCallee::forDirect(fn);
   return CGF.EmitCall(fnInfo, callee, ReturnValueSlot(), args);
 }
 
 /// Does a store of the given IR type modify the full expected width?
 static bool isFullSizeType(CodeGenModule &CGM, llvm::Type *type,
                            uint64_t expectedSize) {
   return (CGM.getDataLayout().getTypeStoreSize(type) * 8 == expectedSize);

clang/test/CodeGen/atomic_ops.c

void foo(int x)
   j /= x;
   // NATIVE: sdiv i32
   // NATIVE: cmpxchg i16*
   // LIBCALL: sdiv i32
   // LIBCALL: i1 @__atomic_compare_exchange(i32 2,
 
 }
 
+// LIBCALL: declare void @__atomic_load(i32, i8*, i8*, i32) [[LC_ATTRS:#[0-9]+]]
+// LIBCALL: declare i1 @__atomic_compare_exchange(i32, i8*, i8*, i8*, i32, i32) [[LC_ATTRS:#[0-9]+]]
+
 extern _Atomic _Bool b;
 
 _Bool bar() {
 // NATIVE-LABEL: @bar
 // NATIVE: %[[load:.*]] = load atomic i8, i8* @b seq_cst
 // NATIVE: %[[tobool:.*]] = trunc i8 %[[load]] to i1
 // NATIVE: ret i1 %[[tobool]]
 // LIBCALL-LABEL: @bar

 // NATIVE-LABEL: @baz
 // NATIVE: store atomic
 // LIBCALL-LABEL: @baz
 // LIBCALL: call void @__atomic_store
 
   x += y;
 }
 
+// LIBCALL: declare void @__atomic_store(i32, i8*, i8*, i32) [[LC_ATTRS:#[0-9]+]]
+
 _Atomic(int) compound_add(_Atomic(int) in) {
 // CHECK-LABEL: @compound_add
 // CHECK: [[OLD:%.*]] = atomicrmw add i32* {{.*}}, i32 5 seq_cst
 // CHECK: [[NEW:%.*]] = add i32 [[OLD]], 5
 // CHECK: ret i32 [[NEW]]
 
   return (in += 5);
 }

 // NATIVE-LABEL: @compound_mul
 // NATIVE: cmpxchg i32* {{%.*}}, i32 {{%.*}}, i32 [[NEW:%.*]] seq_cst seq_cst
 // NATIVE: ret i32 [[NEW]]
 // LIBCALL-LABEL: @compound_mul
 // LIBCALL: i1 @__atomic_compare_exchange(i32 4,
 
   return (in *= 5);
 }
+
+// LIBCALL: [[LC_ATTRS]] = { nounwind willreturn }