Add new language mode flags for C17.

This adds -std=c17, -std=gnu17, and -std=iso9899:2017 as language mode flags for C17 and updates the value of __STDC_VERSION__ to the value based on the C17 FDIS. Given that this ballot cannot succeed until 2018, it is expected that we (and GCC) will add c18 flags as aliases once the ballot passes.

llvm-svn: 320089

1 files changed, 201 insertions, 200 deletions

diff --git a/clang/lib/Frontend/CompilerInvocation.cpp b/clang/lib/Frontend/CompilerInvocation.cpp
index d2800b52e22..22cc9c25dd0 100644
--- a/clang/lib/Frontend/CompilerInvocation.cpp
+++ b/clang/lib/Frontend/CompilerInvocation.cpp
@@ -1645,206 +1645,207 @@ static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args,
       Opts.AddPath(Prefix.str() + A->getValue(), frontend::Angled, false, true);
   }
 
-  for (const Arg *A : Args.filtered(OPT_idirafter))
-    Opts.AddPath(A->getValue(), frontend::After, false, true);
-  for (const Arg *A : Args.filtered(OPT_iquote))
-    Opts.AddPath(A->getValue(), frontend::Quoted, false, true);
-  for (const Arg *A : Args.filtered(OPT_isystem, OPT_iwithsysroot))
-    Opts.AddPath(A->getValue(), frontend::System, false,
-                 !A->getOption().matches(OPT_iwithsysroot));
-  for (const Arg *A : Args.filtered(OPT_iframework))
-    Opts.AddPath(A->getValue(), frontend::System, true, true);
-  for (const Arg *A : Args.filtered(OPT_iframeworkwithsysroot))
-    Opts.AddPath(A->getValue(), frontend::System, /*IsFramework=*/true,
-                 /*IgnoreSysRoot=*/false);
-
-  // Add the paths for the various language specific isystem flags.
-  for (const Arg *A : Args.filtered(OPT_c_isystem))
-    Opts.AddPath(A->getValue(), frontend::CSystem, false, true);
-  for (const Arg *A : Args.filtered(OPT_cxx_isystem))
-    Opts.AddPath(A->getValue(), frontend::CXXSystem, false, true);
-  for (const Arg *A : Args.filtered(OPT_objc_isystem))
-    Opts.AddPath(A->getValue(), frontend::ObjCSystem, false,true);
-  for (const Arg *A : Args.filtered(OPT_objcxx_isystem))
-    Opts.AddPath(A->getValue(), frontend::ObjCXXSystem, false, true);
-
-  // Add the internal paths from a driver that detects standard include paths.
-  for (const Arg *A :
-       Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {
-    frontend::IncludeDirGroup Group = frontend::System;
-    if (A->getOption().matches(OPT_internal_externc_isystem))
-      Group = frontend::ExternCSystem;
-    Opts.AddPath(A->getValue(), Group, false, true);
-  }
-
-  // Add the path prefixes which are implicitly treated as being system headers.
-  for (const Arg *A :
-       Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))
-    Opts.AddSystemHeaderPrefix(
-        A->getValue(), A->getOption().matches(OPT_system_header_prefix));
-
-  for (const Arg *A : Args.filtered(OPT_ivfsoverlay))
-    Opts.AddVFSOverlayFile(A->getValue());
-}
-
-void CompilerInvocation::setLangDefaults(LangOptions &Opts, InputKind IK,
-                                         const llvm::Triple &T,
-                                         PreprocessorOptions &PPOpts,
-                                         LangStandard::Kind LangStd) {
-  // Set some properties which depend solely on the input kind; it would be nice
-  // to move these to the language standard, and have the driver resolve the
-  // input kind + language standard.
-  //
-  // FIXME: Perhaps a better model would be for a single source file to have
-  // multiple language standards (C / C++ std, ObjC std, OpenCL std, OpenMP std)
-  // simultaneously active?
-  if (IK.getLanguage() == InputKind::Asm) {
-    Opts.AsmPreprocessor = 1;
-  } else if (IK.isObjectiveC()) {
-    Opts.ObjC1 = Opts.ObjC2 = 1;
-  }
-
-  if (LangStd == LangStandard::lang_unspecified) {
-    // Based on the base language, pick one.
-    switch (IK.getLanguage()) {
-    case InputKind::Unknown:
-    case InputKind::LLVM_IR:
-      llvm_unreachable("Invalid input kind!");
-    case InputKind::OpenCL:
-      LangStd = LangStandard::lang_opencl10;
-      break;
-    case InputKind::CUDA:
-      LangStd = LangStandard::lang_cuda;
-      break;
-    case InputKind::Asm:
-    case InputKind::C:
-      // The PS4 uses C99 as the default C standard.
-      if (T.isPS4())
-        LangStd = LangStandard::lang_gnu99;
-      else
-        LangStd = LangStandard::lang_gnu11;
-      break;
-    case InputKind::ObjC:
-      LangStd = LangStandard::lang_gnu11;
-      break;
-    case InputKind::CXX:
-    case InputKind::ObjCXX:
-      // The PS4 uses C++11 as the default C++ standard.
-      if (T.isPS4())
-        LangStd = LangStandard::lang_gnucxx11;
-      else
-        LangStd = LangStandard::lang_gnucxx98;
-      break;
-    case InputKind::RenderScript:
-      LangStd = LangStandard::lang_c99;
-      break;
-    }
-  }
-
-  const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
-  Opts.LineComment = Std.hasLineComments();
-  Opts.C99 = Std.isC99();
-  Opts.C11 = Std.isC11();
-  Opts.CPlusPlus = Std.isCPlusPlus();
-  Opts.CPlusPlus11 = Std.isCPlusPlus11();
-  Opts.CPlusPlus14 = Std.isCPlusPlus14();
-  Opts.CPlusPlus17 = Std.isCPlusPlus17();
-  Opts.CPlusPlus2a = Std.isCPlusPlus2a();
-  Opts.Digraphs = Std.hasDigraphs();
-  Opts.GNUMode = Std.isGNUMode();
-  Opts.GNUInline = !Opts.C99 && !Opts.CPlusPlus;
-  Opts.HexFloats = Std.hasHexFloats();
-  Opts.ImplicitInt = Std.hasImplicitInt();
-
-  // Set OpenCL Version.
-  Opts.OpenCL = Std.isOpenCL();
-  if (LangStd == LangStandard::lang_opencl10)
-    Opts.OpenCLVersion = 100;
-  else if (LangStd == LangStandard::lang_opencl11)
-    Opts.OpenCLVersion = 110;
-  else if (LangStd == LangStandard::lang_opencl12)
-    Opts.OpenCLVersion = 120;
-  else if (LangStd == LangStandard::lang_opencl20)
-    Opts.OpenCLVersion = 200;
-
-  // OpenCL has some additional defaults.
-  if (Opts.OpenCL) {
-    Opts.AltiVec = 0;
-    Opts.ZVector = 0;
-    Opts.LaxVectorConversions = 0;
-    Opts.setDefaultFPContractMode(LangOptions::FPC_On);
-    Opts.NativeHalfType = 1;
-    Opts.NativeHalfArgsAndReturns = 1;
-    // Include default header file for OpenCL.
-    if (Opts.IncludeDefaultHeader) {
-      PPOpts.Includes.push_back("opencl-c.h");
-    }
-  }
-
-  Opts.CUDA = IK.getLanguage() == InputKind::CUDA;
-  if (Opts.CUDA)
-    // Set default FP_CONTRACT to FAST.
-    Opts.setDefaultFPContractMode(LangOptions::FPC_Fast);
-
-  Opts.RenderScript = IK.getLanguage() == InputKind::RenderScript;
-  if (Opts.RenderScript) {
-    Opts.NativeHalfType = 1;
-    Opts.NativeHalfArgsAndReturns = 1;
-  }
-
-  // OpenCL and C++ both have bool, true, false keywords.
-  Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
-
-  // OpenCL has half keyword
-  Opts.Half = Opts.OpenCL;
-
-  // C++ has wchar_t keyword.
-  Opts.WChar = Opts.CPlusPlus;
-
-  Opts.GNUKeywords = Opts.GNUMode;
-  Opts.CXXOperatorNames = Opts.CPlusPlus;
-
-  Opts.AlignedAllocation = Opts.CPlusPlus17;
-
-  Opts.DollarIdents = !Opts.AsmPreprocessor;
-}
-
-/// Attempt to parse a visibility value out of the given argument.
-static Visibility parseVisibility(Arg *arg, ArgList &args,
-                                  DiagnosticsEngine &diags) {
-  StringRef value = arg->getValue();
-  if (value == "default") {
-    return DefaultVisibility;
-  } else if (value == "hidden" || value == "internal") {
-    return HiddenVisibility;
-  } else if (value == "protected") {
-    // FIXME: diagnose if target does not support protected visibility
-    return ProtectedVisibility;
-  }
-
-  diags.Report(diag::err_drv_invalid_value)
-    << arg->getAsString(args) << value;
-  return DefaultVisibility;
-}
-
-/// Check if input file kind and language standard are compatible.
-static bool IsInputCompatibleWithStandard(InputKind IK,
-                                          const LangStandard &S) {
-  switch (IK.getLanguage()) {
-  case InputKind::Unknown:
-  case InputKind::LLVM_IR:
-    llvm_unreachable("should not parse language flags for this input");
-
-  case InputKind::C:
-  case InputKind::ObjC:
-  case InputKind::RenderScript:
-    return S.getLanguage() == InputKind::C;
-
-  case InputKind::OpenCL:
-    return S.getLanguage() == InputKind::OpenCL;
-
-  case InputKind::CXX:
-  case InputKind::ObjCXX:
+  for (const Arg *A : Args.filtered(OPT_idirafter))

+    Opts.AddPath(A->getValue(), frontend::After, false, true);

+  for (const Arg *A : Args.filtered(OPT_iquote))

+    Opts.AddPath(A->getValue(), frontend::Quoted, false, true);

+  for (const Arg *A : Args.filtered(OPT_isystem, OPT_iwithsysroot))

+    Opts.AddPath(A->getValue(), frontend::System, false,

+                 !A->getOption().matches(OPT_iwithsysroot));

+  for (const Arg *A : Args.filtered(OPT_iframework))

+    Opts.AddPath(A->getValue(), frontend::System, true, true);

+  for (const Arg *A : Args.filtered(OPT_iframeworkwithsysroot))

+    Opts.AddPath(A->getValue(), frontend::System, /*IsFramework=*/true,

+                 /*IgnoreSysRoot=*/false);

+

+  // Add the paths for the various language specific isystem flags.

+  for (const Arg *A : Args.filtered(OPT_c_isystem))

+    Opts.AddPath(A->getValue(), frontend::CSystem, false, true);

+  for (const Arg *A : Args.filtered(OPT_cxx_isystem))

+    Opts.AddPath(A->getValue(), frontend::CXXSystem, false, true);

+  for (const Arg *A : Args.filtered(OPT_objc_isystem))

+    Opts.AddPath(A->getValue(), frontend::ObjCSystem, false,true);

+  for (const Arg *A : Args.filtered(OPT_objcxx_isystem))

+    Opts.AddPath(A->getValue(), frontend::ObjCXXSystem, false, true);

+

+  // Add the internal paths from a driver that detects standard include paths.

+  for (const Arg *A :

+       Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {

+    frontend::IncludeDirGroup Group = frontend::System;

+    if (A->getOption().matches(OPT_internal_externc_isystem))

+      Group = frontend::ExternCSystem;

+    Opts.AddPath(A->getValue(), Group, false, true);

+  }

+

+  // Add the path prefixes which are implicitly treated as being system headers.

+  for (const Arg *A :

+       Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))

+    Opts.AddSystemHeaderPrefix(

+        A->getValue(), A->getOption().matches(OPT_system_header_prefix));

+

+  for (const Arg *A : Args.filtered(OPT_ivfsoverlay))

+    Opts.AddVFSOverlayFile(A->getValue());

+}

+

+void CompilerInvocation::setLangDefaults(LangOptions &Opts, InputKind IK,

+                                         const llvm::Triple &T,

+                                         PreprocessorOptions &PPOpts,

+                                         LangStandard::Kind LangStd) {

+  // Set some properties which depend solely on the input kind; it would be nice

+  // to move these to the language standard, and have the driver resolve the

+  // input kind + language standard.

+  //

+  // FIXME: Perhaps a better model would be for a single source file to have

+  // multiple language standards (C / C++ std, ObjC std, OpenCL std, OpenMP std)

+  // simultaneously active?

+  if (IK.getLanguage() == InputKind::Asm) {

+    Opts.AsmPreprocessor = 1;

+  } else if (IK.isObjectiveC()) {

+    Opts.ObjC1 = Opts.ObjC2 = 1;

+  }

+

+  if (LangStd == LangStandard::lang_unspecified) {

+    // Based on the base language, pick one.

+    switch (IK.getLanguage()) {

+    case InputKind::Unknown:

+    case InputKind::LLVM_IR:

+      llvm_unreachable("Invalid input kind!");

+    case InputKind::OpenCL:

+      LangStd = LangStandard::lang_opencl10;

+      break;

+    case InputKind::CUDA:

+      LangStd = LangStandard::lang_cuda;

+      break;

+    case InputKind::Asm:

+    case InputKind::C:

+      // The PS4 uses C99 as the default C standard.

+      if (T.isPS4())

+        LangStd = LangStandard::lang_gnu99;

+      else

+        LangStd = LangStandard::lang_gnu11;

+      break;

+    case InputKind::ObjC:

+      LangStd = LangStandard::lang_gnu11;

+      break;

+    case InputKind::CXX:

+    case InputKind::ObjCXX:

+      // The PS4 uses C++11 as the default C++ standard.

+      if (T.isPS4())

+        LangStd = LangStandard::lang_gnucxx11;

+      else

+        LangStd = LangStandard::lang_gnucxx98;

+      break;

+    case InputKind::RenderScript:

+      LangStd = LangStandard::lang_c99;

+      break;

+    }

+  }

+

+  const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);

+  Opts.LineComment = Std.hasLineComments();

+  Opts.C99 = Std.isC99();

+  Opts.C11 = Std.isC11();

+  Opts.C17 = Std.isC17();

+  Opts.CPlusPlus = Std.isCPlusPlus();

+  Opts.CPlusPlus11 = Std.isCPlusPlus11();

+  Opts.CPlusPlus14 = Std.isCPlusPlus14();

+  Opts.CPlusPlus17 = Std.isCPlusPlus17();

+  Opts.CPlusPlus2a = Std.isCPlusPlus2a();

+  Opts.Digraphs = Std.hasDigraphs();

+  Opts.GNUMode = Std.isGNUMode();

+  Opts.GNUInline = !Opts.C99 && !Opts.CPlusPlus;

+  Opts.HexFloats = Std.hasHexFloats();

+  Opts.ImplicitInt = Std.hasImplicitInt();

+

+  // Set OpenCL Version.

+  Opts.OpenCL = Std.isOpenCL();

+  if (LangStd == LangStandard::lang_opencl10)

+    Opts.OpenCLVersion = 100;

+  else if (LangStd == LangStandard::lang_opencl11)

+    Opts.OpenCLVersion = 110;

+  else if (LangStd == LangStandard::lang_opencl12)

+    Opts.OpenCLVersion = 120;

+  else if (LangStd == LangStandard::lang_opencl20)

+    Opts.OpenCLVersion = 200;

+

+  // OpenCL has some additional defaults.

+  if (Opts.OpenCL) {

+    Opts.AltiVec = 0;

+    Opts.ZVector = 0;

+    Opts.LaxVectorConversions = 0;

+    Opts.setDefaultFPContractMode(LangOptions::FPC_On);

+    Opts.NativeHalfType = 1;

+    Opts.NativeHalfArgsAndReturns = 1;

+    // Include default header file for OpenCL.

+    if (Opts.IncludeDefaultHeader) {

+      PPOpts.Includes.push_back("opencl-c.h");

+    }

+  }

+

+  Opts.CUDA = IK.getLanguage() == InputKind::CUDA;

+  if (Opts.CUDA)

+    // Set default FP_CONTRACT to FAST.

+    Opts.setDefaultFPContractMode(LangOptions::FPC_Fast);

+

+  Opts.RenderScript = IK.getLanguage() == InputKind::RenderScript;

+  if (Opts.RenderScript) {

+    Opts.NativeHalfType = 1;

+    Opts.NativeHalfArgsAndReturns = 1;

+  }

+

+  // OpenCL and C++ both have bool, true, false keywords.

+  Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;

+

+  // OpenCL has half keyword

+  Opts.Half = Opts.OpenCL;

+

+  // C++ has wchar_t keyword.

+  Opts.WChar = Opts.CPlusPlus;

+

+  Opts.GNUKeywords = Opts.GNUMode;

+  Opts.CXXOperatorNames = Opts.CPlusPlus;

+

+  Opts.AlignedAllocation = Opts.CPlusPlus17;

+

+  Opts.DollarIdents = !Opts.AsmPreprocessor;

+}

+

+/// Attempt to parse a visibility value out of the given argument.

+static Visibility parseVisibility(Arg *arg, ArgList &args,

+                                  DiagnosticsEngine &diags) {

+  StringRef value = arg->getValue();

+  if (value == "default") {

+    return DefaultVisibility;

+  } else if (value == "hidden" || value == "internal") {

+    return HiddenVisibility;

+  } else if (value == "protected") {

+    // FIXME: diagnose if target does not support protected visibility

+    return ProtectedVisibility;

+  }

+

+  diags.Report(diag::err_drv_invalid_value)

+    << arg->getAsString(args) << value;

+  return DefaultVisibility;

+}

+

+/// Check if input file kind and language standard are compatible.

+static bool IsInputCompatibleWithStandard(InputKind IK,

+                                          const LangStandard &S) {

+  switch (IK.getLanguage()) {

+  case InputKind::Unknown:

+  case InputKind::LLVM_IR:

+    llvm_unreachable("should not parse language flags for this input");

+

+  case InputKind::C:

+  case InputKind::ObjC:

+  case InputKind::RenderScript:

+    return S.getLanguage() == InputKind::C;

+

+  case InputKind::OpenCL:

+    return S.getLanguage() == InputKind::OpenCL;

+

+  case InputKind::CXX:

+  case InputKind::ObjCXX:

     return S.getLanguage() == InputKind::CXX;
 
   case InputKind::CUDA: