[CUDA] [AST] Allow isInlineDefinitionExternallyVisible to be called on functions without bodies.

[jlebar]

Summary

In CUDA compilation, we call isInlineDefinitionExternallyVisible (via
getGVALinkageForFunction) on functions while parsing their definitions.

At the point in time when we call getGVALinkageForFunction, the function
may not have a body, so we trip this assert. But as far as I can tell,
this is harmless.

It is not clear to me whether it's possible to replace this assert with
something slightly weaker.

[jlebar]

Friendly ping. This assert breaks basically all cuda compilation on certain libstdc++ versions. If this change is wrong, I sort of urgently need to figure out the right thing.

[tra]

I'm OK with the change, but the comments suggest that things may be more complicated.
How about disabling assert for CUDA only?

[jlebar]

In D25640#579238, @tra wrote:

I'm OK with the change, but the comments suggest that things may be more complicated.
How about disabling assert for CUDA only?

I don't think that is the right approach. This function has nothing to do with CUDA, so either the assertion is valid and we shouldn't be calling it this way, or it's not valid and we should remove the assertion.

Richard, would appreciate some help with this one.

[rsmith]

I'm not OK with losing this checking entirely. It seems like the problem case is when we're currently processing the definition of the function in question (so it /does/ have a body, it just doesn't have a /complete/ body yet)? I suppose we could track that directly somehow.

[jlebar]

Add WillHaveBody flag.

[jlebar]

OK, I can add new flags with the best of 'em.

I got rid of a super ugly hack I found that was working around the same problem I was trying to work around here. (And I verified that if I don't call setWillHaveBody, a testcase fails.) I can split this out into two patches if you prefer.

[rsmith]

Looks great, thanks.

clang/lib/Sema/SemaDecl.cpp

5762–5768 ↗

(On Diff #76118)

Wow.

clang/lib/AST/Decl.cpp

 /// inline definition becomes externally visible (C99 6.7.4p6).
 ///
 /// In GNU89 mode, or if the gnu_inline attribute is attached to the function
 /// definition, we use the GNU semantics for inline, which are nearly the 
 /// opposite of C99 semantics. In particular, "inline" by itself will create 
 /// an externally visible symbol, but "extern inline" will not create an 
 /// externally visible symbol.
 bool FunctionDecl::isInlineDefinitionExternallyVisible() const {
-  assert(doesThisDeclarationHaveABody() && "Must have the function definition");
   assert(isInlined() && "Function must be inline");
   ASTContext &Context = getASTContext();
   
   if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
     // Note: If you change the logic here, please change
     // doesDeclarationForceExternallyVisibleDefinition as well.
     //
     // If it's not the case that both 'inline' and 'extern' are

clang/test/SemaCUDA/gnu-inline.cu

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+#include "Inputs/cuda.h"
+
+// expected-no-diagnostics
+
+// Check that we can handle gnu_inline functions when compiling in CUDA mode.
+
+void foo();
+inline __attribute__((gnu_inline)) void bar() { foo(); }