Correct line endings that got mixed up in r320089; NFC.

llvm-svn: 320113

1 files changed, 202 insertions, 202 deletions

diff --git a/clang/lib/Frontend/CompilerInvocation.cpp b/clang/lib/Frontend/CompilerInvocation.cpp
index 22cc9c25dd0..59e5b62c5e8 100644
--- a/clang/lib/Frontend/CompilerInvocation.cpp
+++ b/clang/lib/Frontend/CompilerInvocation.cpp
@@ -1645,207 +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.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:

+  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:
@@ -2165,7 +2165,7 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
     && Opts.OpenCLVersion >= 200);
   Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional);
   Opts.CoroutinesTS = Args.hasArg(OPT_fcoroutines_ts);
-  
+
   // Enable [[]] attributes in C++11 by default.
   Opts.DoubleSquareBracketAttributes =
       Args.hasFlag(OPT_fdouble_square_bracket_attributes,