Enable recognition of __declspec for PS4

[wristow]

Summary

This change includes the changes of reviews.llvm.org/D11164 (reserving a flag for Sony/PS extensions), and also uses that flag to enable recognition of __declspec. This supersedes D11164.

Can someone review, and if OK then commit this patch for me, please?

-Warren Ristow
SN Systems - Sony Computer Entertainment Group

[alexr]

LGTM

[wristow]

Can I get a brief description of what you're trying to accomplish and
why this is needed?

We intend to support declspec(dllimport)/declspec(dllexport) on PS4, and we will be uploading code reviews for that. So we're enabling recognition of __declspec on PS4 as a prerequisite for that.

-Warren

[rnk]

Seems reasonable.

include/clang/Basic/LangOptions.def

81

How do you guys feel about "sony" vs. "sce"? I know we abbreviated Microsoft to MS, but I think a lot of folks don't know that the full name of the particular company involved is "Sony Computer Entertainment". If -fsce-extensions is already used in build systems, I'm OK leaving the flag as is. I'm mostly concerned with SceExt.

[wristow]

include/clang/Basic/LangOptions.def

81

We do already have '-target x86_64-scei-ps4', and we have other pending changes that use 'sce' (rather than 'scei') that I expect will appear very soon. So we (Sony) are leaning toward continuing with 'sce'.

[silvas]

include/clang/Basic/LangOptions.def

81

"Sony" is way too broad. The company "Sony" does everything from image sensors to banking & insurance to lithium batteries to public transit turnstiles to laparoscopic surgery equipment. We don't represent the entire company "Sony", nor is there any reason to believe that anything we are doing applies to "Sony" as a whole.

[wristow]

Sony would like support for declspec without turning on all MS
extensions. We currently have the same idea in place to support
declspec for CUDA. It seems to me that there are cases where
unconditional support of declspec is desired. I am wondering if we
want an -fdeclspec-ext (or something) that enables just declspec
support, instead of trying to tie this extension to compiler vendors.
Obviously, we could turn this extension on for Sony's triple as well
in that case. I'm wondering if that's a design we'd want to consider
exploring or not.

Yes, and to be clear, it also is not _only_ '__declspec' that we (Sony) want to enable. Hence the idea of the '-fsce-extensions' approach.

But that said, the set of extensions we want to enable is not large, so the approach of '-fdeclspec-ext' is attractive. With that in mind, I'll re-implement this concept.

Thanks all.

-Warren

[• dberlin]

include/clang/Basic/LangOptions.def

81

Please don't use (R) here. It should be unnecessary (and we don't do it for others).

[rnk]

include/clang/Basic/LangOptions.def

81

Sounds like it's going to be SCE, then. Would it be accurate to put "Sony Computer Entertainment extensions" in the comment, since that's what's being abbreviated?

[ygao]

include/clang/Basic/LangOptions.def

81

Makese sense. Although if Aaron's -fdeclspec idea goes through, we may not need the separate fsce-ext flag.
Ref: http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20150713/133372.html

[compnerd]

I imagine that at some point MinGW will also want the __declspec keyword available, even though they try to use the GNU side of things. There are minor differences in __attribute__ vs __declspec, primarily involved in where they may be placed. I think that having the -fdeclspec-ext sounds much more favorable, unless we intend to have a number of additional extension environments, which seems a bit unnecessary.

[wristow]

This has been superseded by D13322.

include/clang/Basic/LangOptions.def

 LANGOPT(CPlusPlus1z       , 1, 0, "C++1z")
 LANGOPT(ObjC1             , 1, 0, "Objective-C 1")
 LANGOPT(ObjC2             , 1, 0, "Objective-C 2")
+LANGOPT(SceExt            , 1, 0, "Sony PlayStation(R) extensions")
 BENIGN_LANGOPT(ObjCDefaultSynthProperties , 1, 0,
                "Objective-C auto-synthesized properties")
 BENIGN_LANGOPT(EncodeExtendedBlockSig , 1, 0,

include/clang/Basic/TokenKinds.def

 //   KEYNOOPENCL  - This is a keyword that is not supported in OpenCL
 //   KEYALTIVEC - This is a keyword in AltiVec
 //   KEYBORLAND - This is a keyword if Borland extensions are enabled
+//   KEYSCE     - This is a keyword if Sony PlayStation extensions are enabled
 //   BOOLSUPPORT - This is a keyword if 'bool' is a built-in type
 //   HALFSUPPORT - This is a keyword if 'half' is a built-in type
 //   WCHARSUPPORT - This is a keyword if 'wchar_t' is a built-in type

 KEYWORD(__module_private__          , KEYALL)
 
 // Microsoft Extension.
-KEYWORD(__declspec                  , KEYMS|KEYBORLAND)
+KEYWORD(__declspec                  , KEYMS|KEYBORLAND|KEYSCE)
 KEYWORD(__cdecl                     , KEYALL)
 KEYWORD(__stdcall                   , KEYALL)
 KEYWORD(__fastcall                  , KEYALL)

include/clang/Driver/CC1Options.td

   HelpText<"Use the native half type for __fp16 instead of promoting to float">;
 def fallow_half_arguments_and_returns : Flag<["-"], "fallow-half-arguments-and-returns">,
   HelpText<"Allow function arguments and returns of type half">;
+def fsce_extensions : Flag<["-"], "fsce-extensions">,
+  HelpText<"">;
 
 //===----------------------------------------------------------------------===//
 // Header Search Options

include/clang/Parse/Parser.h

   void MaybeParseMicrosoftDeclSpecs(ParsedAttributes &Attrs,
                                     SourceLocation *End = nullptr) {
     const auto &LO = getLangOpts();
-    if ((LO.MicrosoftExt || LO.Borland || LO.CUDA) &&
+    if ((LO.MicrosoftExt || LO.Borland || LO.CUDA || LO.SceExt) &&
         Tok.is(tok::kw___declspec))
       ParseMicrosoftDeclSpecs(Attrs, End);
   }

lib/Basic/IdentifierTable.cpp

     HALFSUPPORT = 0x08000,
     KEYCONCEPTS = 0x10000,
     KEYOBJC2    = 0x20000,
-    KEYALL = (0x3ffff & ~KEYNOMS18 &
+    KEYSCE      = 0x40000,
+    KEYALL = (0x7ffff & ~KEYNOMS18 &
               ~KEYNOOPENCL) // KEYNOMS18 and KEYNOOPENCL are used to exclude.
   };
 

   if (LangOpts.GNUKeywords && (Flags & KEYGNU)) return KS_Extension;
   if (LangOpts.MicrosoftExt && (Flags & KEYMS)) return KS_Extension;
   if (LangOpts.Borland && (Flags & KEYBORLAND)) return KS_Extension;
+  if (LangOpts.SceExt && (Flags & KEYSCE)) return KS_Extension;
   if (LangOpts.Bool && (Flags & BOOLSUPPORT)) return KS_Enabled;
   if (LangOpts.Half && (Flags & HALFSUPPORT)) return KS_Enabled;
   if (LangOpts.WChar && (Flags & WCHARSUPPORT)) return KS_Enabled;

lib/Driver/Tools.cpp

                    IsWindowsMSVC))
     CmdArgs.push_back("-fms-extensions");
 
+  if (getToolChain().getTriple().isPS4())
+    CmdArgs.push_back("-fsce-extensions");
+
   // -fno-use-line-directives is default.
   if (Args.hasFlag(options::OPT_fuse_line_directives,
                    options::OPT_fno_use_line_directives, false))

lib/Frontend/CompilerInvocation.cpp

   
   CompilerInvocation::setLangDefaults(Opts, IK, LangStd);
 
+  if (Args.hasArg(OPT_fsce_extensions))
+    Opts.SceExt = 1;
+
   // We abuse '-f[no-]gnu-keywords' to force overriding all GNU-extension
   // keywords. This behavior is provided by GCC's poorly named '-fasm' flag,
   // while a subset (the non-C++ GNU keywords) is provided by GCC's

lib/Parse/ParseDecl.cpp

 void Parser::ParseMicrosoftDeclSpecs(ParsedAttributes &Attrs,
                                      SourceLocation *End) {
   assert((getLangOpts().MicrosoftExt || getLangOpts().Borland ||
-          getLangOpts().CUDA) &&
+          getLangOpts().CUDA || getLangOpts().SceExt) &&
          "Incorrect language options for parsing __declspec");
   assert(Tok.is(tok::kw___declspec) && "Not a declspec!");
 

test/Lexer/keywords_test.c

 
 // RUN: %clang_cc1 -std=c99 -fms-extensions -E %s -o - \
 // RUN:     | FileCheck --check-prefix=CHECK-MS-KEYWORDS %s
+// RUN: %clang_cc1 -std=c99 -fsce-extensions -E %s -o - \
+// RUN:     | FileCheck --check-prefix=CHECK-SCE-KEYWORDS %s
 
 void f() {
 // CHECK-NONE: int asm

 #else
 void has_ms_wchar();
 #endif
+
+// CHECK-NONE: no_declspec
+// CHECK-MS-KEYWORDS: has_declspec
+// CHECK-SCE-KEYWORDS: has_declspec
+#if __is_identifier(__declspec)
+void no_declspec();
+#else
+void has_declspec();
+#endif

test/Lexer/keywords_test.cpp

 // RUN: %clang_cc1 -std=c++03 -fsyntax-only %s
 // RUN: %clang_cc1 -std=c++11 -DCXX11 -fsyntax-only %s
 // RUN: %clang_cc1 -std=c++14 -fconcepts-ts -DCXX11 -DCONCEPTS -fsyntax-only %s
+// RUN: %clang_cc1 -std=c++03 -fsce-extensions -DSCE -fsyntax-only %s
 
 #define IS_KEYWORD(NAME) _Static_assert(!__is_identifier(NAME), #NAME)
 #define NOT_KEYWORD(NAME) _Static_assert(__is_identifier(NAME), #NAME)

 #define CONCEPTS_KEYWORD(NAME)  NOT_KEYWORD(NAME)
 #endif
 
+#ifdef SCE
+#define SCE_KEYWORD(NAME)  IS_KEYWORD(NAME)
+#else
+#define SCE_KEYWORD(NAME)  NOT_KEYWORD(NAME)
+#endif
+
 #ifdef CXX11
 #define CXX11_KEYWORD(NAME)  IS_KEYWORD(NAME)
 #define CXX11_TYPE(NAME)     IS_TYPE(NAME)

 CONCEPTS_KEYWORD(concept);
 CONCEPTS_KEYWORD(requires);
 
+// SCE extensions
+SCE_KEYWORD(__declspec);
+
 // Clang extension
 IS_KEYWORD(__char16_t);
 IS_TYPE(__char16_t);