[Sema] Prohibit function-scope compound literals with address spaces.

[ebevhan]

Summary

In C, compound literals in function scope are lvalues with
automatic storage duration. This means that generally, they
cannot be address space-qualified since you cannot have
address space-qualified objects with automatic storage duration.

The Embedded-C specification also adds a clause to the section
on compound literals that prohibits this.

We might want to check the 'alloca address space' here, but
neither ASTContext nor TargetInfo seem to have this.

[rjmccall]

LGTM, with one minor suggestion.

lib/Sema/SemaExpr.cpp

5745

Usually when we mention a standard section like this, it's a prelude to a quote. If you're just paraphrasing, I think we can trust people to find the right standard section.

[ebevhan]

lib/Sema/SemaExpr.cpp

5745

Hm, alright. I figured it was better to both provide the exact section and also include a summary here so you don't have to look it up.

Should I change it or is it good anyway?

[rjmccall]

lib/Sema/SemaExpr.cpp

5745

It's fine to include a reference to the standard. The way you've done it here makes it look like a quote at first glance, which it isn't. You should just say "See C99 6.5.2.5p6" if you think that's an important citation to make.

In this case, though, I don't think it's a particularly valuable citation. Remember that this code is in the middle of a function dedicated to the rules of section 6.5.2.5, so unless you're actually quoting the text because there's some important subtlety, I think you can assume general familiarity (and/or that the reader has the standard open). There *is* a better citation, though: the Embedded C spec explicitly says:

If the compound literal occurs inside the body of a function, the type name shall not be qualified by an address-space qualifier.

I'd cite it with a title like "Embedded C modifications to C99 6.5.2.5".

By the way, LLVM code style leaves a space between if and the opening parenthesis of the condition.

[ebevhan]

Added Embedded-C clause quote.
Fixed formatting.

[rjmccall]

LGTM.

[ebevhan]

Thanks!

I don't have commit access, so it would be appreciated if someone could commit it.

[rjmccall]

Committed as r341491.

include/clang/Basic/DiagnosticSemaKinds.td

 def err_attribute_address_function_type : Error<
   "function type may not be qualified with an address space">;
 def err_as_qualified_auto_decl : Error<
   "automatic variable qualified with an%select{| invalid}0 address space">;
 def err_arg_with_address_space : Error<
   "parameter may not be qualified with an address space">;
 def err_field_with_address_space : Error<
   "field may not be qualified with an address space">;
+def err_compound_literal_with_address_space : Error<
+  "compound literal in function scope may not be qualified with an address space">;
 def err_attr_objc_ownership_redundant : Error<
   "the type %0 is already explicitly ownership-qualified">;
 def err_invalid_nsnumber_type : Error<
   "%0 is not a valid literal type for NSNumber">;
 def err_objc_illegal_boxed_expression_type : Error<
   "illegal type %0 used in a boxed expression">;
 def err_objc_non_trivially_copyable_boxed_expression_type : Error<
   "non-trivially copyable type %0 cannot be used in a boxed expression">;

lib/Sema/SemaExpr.cpp

Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo,
   InitializationSequence InitSeq(*this, Entity, Kind, LiteralExpr);
   ExprResult Result = InitSeq.Perform(*this, Entity, Kind, LiteralExpr,
                                       &literalType);
   if (Result.isInvalid())
     return ExprError();
   LiteralExpr = Result.get();
 
   bool isFileScope = !CurContext->isFunctionOrMethod();
-  if (isFileScope &&
-      !LiteralExpr->isTypeDependent() &&
+  if (isFileScope) {
+    if (!LiteralExpr->isTypeDependent() &&
         !LiteralExpr->isValueDependent() &&
-      !literalType->isDependentType()) { // 6.5.2.5p3
+        !literalType->isDependentType()) // C99 6.5.2.5p3
       if (CheckForConstantInitializer(LiteralExpr, literalType))
         return ExprError();
+  } else if (literalType.getAddressSpace() != LangAS::opencl_private &&
+             literalType.getAddressSpace() != LangAS::Default) {
+    // Embedded-C extensions to C99 6.5.2.5:
+    //   "If the compound literal occurs inside the body of a function, the
+    //   type name shall not be qualified by an address-space qualifier."
+    Diag(LParenLoc, diag::err_compound_literal_with_address_space)
+      << SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd());
+    return ExprError();
   }
 
   // In C, compound literals are l-values for some reason.
   // For GCC compatibility, in C++, file-scope array compound literals with
   // constant initializers are also l-values, and compound literals are
   // otherwise prvalues.
   //
   // (GCC also treats C++ list-initialized file-scope array prvalues with

test/Sema/address_spaces.c

 
 typedef int PR4997 __attribute__((address_space(Foobar))); // expected-error {{use of undeclared identifier 'Foobar'}}
 __attribute__((address_space("12"))) int *i; // expected-error {{'address_space' attribute requires an integer constant}}
 
 // Clang extension doesn't forbid operations on pointers to different address spaces.
 char* cmp(_AS1 char *x,  _AS2 char *y) {
   return x < y ? x : y; // expected-error{{conditional operator with the second and third operands of type  ('__attribute__((address_space(1))) char *' and '__attribute__((address_space(2))) char *') which are pointers to non-overlapping address spaces}}
 }
+
+struct SomeStruct {
+  int a;
+  long b;
+  int c;
+};
+
+// Compound literals in function scope are lvalues with automatic storage duration,
+// so they cannot realistically be qualified with an address space.
+void as_compound_literal() {
+  (_AS1 struct SomeStruct){1, 2, 3}; // expected-error {{compound literal in function scope may not be qualified with an address space}}
+  (_AS1 char[]){"test"}; // expected-error {{compound literal in function scope may not be qualified with an address space}}
+  (_AS1 char[]){'a', 'b', 'c'}; // expected-error {{compound literal in function scope may not be qualified with an address space}}
+}