Add support for -fpermissive.

[rsmith]

Summary

The intent is to provide similar functionality to GCC's -fpermissive.
For Clang's approach to diagnostics, this means that we remap all
extension diagnostics to no higher than a warning. As with GCC, the
warnings can then be suppressed with -w.

[jyknight]

Hm -- in GCC, -fpermissive has nothing at all to do with -pedantic/-pedantic-errors, but I suppose it should be fine to do this way.

[aaron.ballman]

I'm not super keen on supporting -fpermissive -- what is the impetus for supporting this? Is it just for GCC compatibility?

[rsmith]

In D58154#1417363, @aaron.ballman wrote:

I'm not super keen on supporting -fpermissive -- what is the impetus for supporting this? Is it just for GCC compatibility?

Yes, exactly that -- this is to improve our drop-in compatibility with GCC. See http://llvm.org/PR40670 for an example user request for this.

In much the same way that -w can be used to mean "I just want this (crufty old, but presumed correct) code to compile; don't bother me with warnings about it", -fpermissive (and in particular -fpermissive -w) can be used to mean "I just want this (crufty, old, and relying on compiler extensions, but presumably correct) code to compile; don't bother me with complaints that it's technically ill-formed".

In D58154#1417358, @jyknight wrote:

Hm -- in GCC, -fpermissive has nothing at all to do with -pedantic/-pedantic-errors, but I suppose it should be fine to do this way.

Yeah, I don't think it's likely that the restriction on combining those two flags will cause problems in practice.

[I don't think the behavior of -fpermissive -pedantic-errors (converting all error-by-default extensions to warnings and converting all non-error-by-default extensions to errors) was a carefully-considered design choice on GCC's part; rather, I think it's just the emergent behavior of the way they happen to deal with extension diagnostics. As a general design point for Clang, downgrading a diagnostic from error-by-default to warning-by-default shouldn't be a breaking change, but could be if we followed GCC here and someone actually used that flag combination. If someone actually hits the diagnostic for combining these two flags and can provide some kind of justification for wanting that behavior, we could reconsider.]

[aaron.ballman]

In D58154#1417474, @rsmith wrote:

In D58154#1417363, @aaron.ballman wrote:

I'm not super keen on supporting -fpermissive -- what is the impetus for supporting this? Is it just for GCC compatibility?

Yes, exactly that -- this is to improve our drop-in compatibility with GCC. See http://llvm.org/PR40670 for an example user request for this.

I don't think we should support -fpermissive. I'm sure that we *can*, but I don't think that we *should*. My strong preference is to close that report as WONTFIX.

In much the same way that -w can be used to mean "I just want this (crufty old, but presumed correct) code to compile; don't bother me with warnings about it", -fpermissive (and in particular -fpermissive -w) can be used to mean "I just want this (crufty, old, and relying on compiler extensions, but presumably correct) code to compile; don't bother me with complaints that it's technically ill-formed".

I think -fpermssive is actively harmful to support because its use cannot be limited to old code bases to allow them to continue to limp along in a broken state. Naive users will turn it on simply because it gets their code to compile. Also, there is a big difference between -w and -fpermissive; the former is reasonable because of false positive diagnostics, but the latter simply hides utterly broken code that may or may not happen to "work". This flag is so toxic that our static analyzer won't attempt to analyze code relying on -fpermissive to compile, so there is out-of-tree cost to Clang supporting this.

As much as I usually love improving compiler compatibility, I don't think compatibility is sufficiently compelling for this feature. Personally, I think supporting -fpermissive is about as compelling as trying to be bug-for-bug compatible with another compiler (though, it is marginally better because this is at least a documented compiler flag).

[jyknight]

The errors disabled by this feature are default-error warnings -- you can already get the same effect by using -Wno-<lots-of-things>. Why is it bad to additionally allow -fpermissive to disable them? (If we have any diagnostics which are currently default-on-warnings which should not _ever_ be disable-able, then maybe we should just fix those?)

[rsmith]

In D58154#1418594, @jyknight wrote:

The errors disabled by this feature are default-error warnings -- you can already get the same effect by using -Wno-<lots-of-things>.

Right; the -fpermissive mode added by this patch turns off strictly less than -Wno-everything. (-fpermissive still produces warnings on uses of extensions at least -- it's very similar to what -Wno-error=everything would mean if we supported it.)

[aaron.ballman]

In D58154#1418594, @jyknight wrote:

The errors disabled by this feature are default-error warnings -- you can already get the same effect by using -Wno-<lots-of-things>. Why is it bad to additionally allow -fpermissive to disable them? (If we have any diagnostics which are currently default-on-warnings which should not _ever_ be disable-able, then maybe we should just fix those?)

I believe -fpermissive controls more than just default-error warnings in GCC, and that's the kind of stuff I really don't want to support. For instance, there's no warning flag for this nonsense, but GCC accepts it under -fpermissive: https://godbolt.org/z/Q-Fl0i (If you think "but who does that?", this blog post shows up on the first page of a popular search engine when I search for fpermissive: http://blog.binchen.org/posts/always-turn-on-fpermissive-for-gcc-4-6.html). Another example of -fpermissive that I've seen in the wild is: https://godbolt.org/z/-44pK5 (which is warned on in C, but not controllable via a warning flag in C++). If we're going to claim support for -fpermissive as a GCC compatibility feature, then we'll get requests to support dialects like the above examples at some point as well and that's where my concern comes in -- I don't think we should ever support that kind of broken code.

I'd be fine with what's proposed here under a different flag name though.

[jyknight]

Ah -- I now understand your concern, and managing user expectations appropriately does seem like a potential concern.

I did not look too closely before into what exactly GCC categorized as "permerror" (errors that can be disabled with -fpermissive) vs what Clang categorized as "ExtWarn,DefaultError" diagnostics. Looking into it a little more now, I think there may not actually be substantial overlap between the two right now.

Many errors we have warning flags for are unconditional in GCC, and many that gcc allows disabling with -fpermissive are unconditional errors in clang.

You gave examples of the latter already, and e.g. here's a bunch of bogus code which you can currently build with -Wno-everything in clang, but most of which cannot be disabled in gcc (and I believe most if not all of these flags are ExtWarn, so would be disabled by this proposed -fpermissive):
https://godbolt.org/z/81NkJQ

Given that, yeah, it may not actually make sense to call this behavior -fpermissive.

I also can't really tell what the intent is behind classifying some diagnostics in Clang as ExtWarn,DefaultError and others Warning,DefaultError -- or if there even is any useful purpose there at all. I note with special-puzzlement the existence of both ext_return_missing_expr and warn_return_missing_expr.

I guess my feeling now is that perhaps we should just eliminate that categorization as meaningless, and just make -Wno-error=everything work properly (for anyone who wants to not abort the compile on broken code, but for whatever reason also loves to see build-spam so doesn't want -Wno-everything).

[rsmith]

In D58154#1419956, @jyknight wrote:

I also can't really tell what the intent is behind classifying some diagnostics in Clang as ExtWarn,DefaultError and others Warning,DefaultError -- or if there even is any useful purpose there at all. I note with special-puzzlement the existence of both ext_return_missing_expr and warn_return_missing_expr.

ExtWarn,DefaultError is for extensions that we disable by default. It should only ever fire on non-conforming code. Such extensions are implicitly enabled in system headers and can be explicitly enabled with a -Wno- flag.

Warning,DefaultError is for conforming code that we can accept, but that's doing something so egregious that we choose to reject it by default. Such cases should be incredibly rare. As above, such cases are permitted in system headers and the error can be downgraded via a -W flag.

ext_return_missing_expr is used in languages where a return statement with no expression is ill-formed (everything later than C90), and warn_return_missing_expr is used in the case where it's valid but is very likely to result in undefined behavior (C90). (This patch certainly has surprising behavior for these diagnostics -- demoting the former case to a warning but leaving the latter as an error -- which I think strongly suggests that this is the wrong approach for -fpermissive.)

I guess my feeling now is that perhaps we should just eliminate that categorization as meaningless, and just make -Wno-error=everything work properly (for anyone who wants to not abort the compile on broken code, but for whatever reason also loves to see build-spam so doesn't want -Wno-everything).

The existing categories seem meaningful to me. I agree that making -Wno-error=everything work would probably be a good idea.

I don't have particularly strong feelings one way or the other about accepting -fpermissive at all. For GCC compatibility, it seems like a moderately useful thing to support, but I don't think we have any interest in accepting everything that GCC accepts under -fpermissive. Perhaps the better choice is to not provide the flag at all, rather than to provide something that has the same interface but doesn't accept the same code. If not that, making -fpermissive an alias for -Wno-error=everything is probably a better approach than that of this patch.

[aaron.ballman]

In D58154#1420344, @rsmith wrote:

I don't have particularly strong feelings one way or the other about accepting -fpermissive at all. For GCC compatibility, it seems like a moderately useful thing to support, but I don't think we have any interest in accepting everything that GCC accepts under -fpermissive.

Agreed that we shouldn't accept everything GCC accepts under -fpermissive.

Perhaps the better choice is to not provide the flag at all, rather than to provide something that has the same interface but doesn't accept the same code. If not that, making -fpermissive an alias for -Wno-error=everything is probably a better approach than that of this patch.

Past experience has shown that when we add a flag for compatibility purposes, users expect compatibility and when I saw the title "Add support for -fpermissive", I got very scared that we meant *all* of -fpermissive (especially when the rationale was for GCC compatibility). I think we should avoid spelling this -fpermissive.

If we go with a different name for the flag, then the user has to update their build scripts to get code to compile with Clang, which means it shouldn't be too onerous for them to spell out the specific diagnostics they need disabled (and it sort of forces them into somewhat better code hygiene by not disabling all diagnostics). I'm kind of leaning towards not providing a flag at all.

[rsmith]

In D58154#1420565, @aaron.ballman wrote:

If we go with a different name for the flag, then the user has to update their build scripts to get code to compile with Clang, which means it shouldn't be too onerous for them to spell out the specific diagnostics they need disabled (and it sort of forces them into somewhat better code hygiene by not disabling all diagnostics). I'm kind of leaning towards not providing a flag at all.

I would certainly prefer that people explicitly list the -Wno-whatever flags they're relying on when porting to Clang. There might still be some benefit in -Wno-error=everything, but it seems questionable (as James points out, users who don't enjoy build spam would likely reach for -Wno-everything instead).

In any case, I think we have consensus that this patch is the wrong direction. Abandoning.

docs/UsersManual.rst

 .. option:: -pedantic
 
   Warn on language extensions.
 
 .. option:: -pedantic-errors
 
   Error on language extensions.
 
+.. option:: -fpermissive
+
+  Do not error on language extensions. Diagnostics for invalid code using known
+  language extensions in the current language mode are downgraded to at most a
+  warning. It is strongly recommended that ``-Wno-foo`` or ``-Wno-error=foo``
+  are used to silence or downgrade individual errors instead of using this
+  flag.
+
+  Note that this does not generally enable extensions controlled by other
+  ``-f`` flags, such as ``-fms-extensions``.
+
 .. option:: -Wsystem-headers
 
   Enable warnings from system headers.
 
 .. option:: -ferror-limit=123
 
   Stop emitting diagnostics after 123 errors have been produced. The default is
-  20, and the error limit can be disabled with `-ferror-limit=0`.
+  20, and the error limit can be disabled with ``-ferror-limit=0``.
 
 .. option:: -ftemplate-backtrace-limit=123
 
   Only emit up to 123 template instantiation notes within the template
   instantiation backtrace for a single warning or error. The default is 10, and
-  the limit can be disabled with `-ftemplate-backtrace-limit=0`.
+  the limit can be disabled with ``-ftemplate-backtrace-limit=0``.
 
 .. _cl_diag_formatting:
 
 Formatting of Diagnostics
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Clang aims to produce beautiful diagnostics by default, particularly for
 new users that first come to Clang. However, different people have

include/clang/Basic/Diagnostic.h

public:
 
     // Treat errors like fatal errors.
     unsigned ErrorsAsFatal : 1;
 
     // Suppress warnings in system headers.
     unsigned SuppressSystemWarnings : 1;
 
     // Map extensions to warnings or errors?
-    diag::Severity ExtBehavior = diag::Severity::Ignored;
+    ExtensionDiagMode ExtBehavior : 2;
 
     DiagState()
         : IgnoreAllWarnings(false), EnableAllWarnings(false),
           WarningsAsErrors(false), ErrorsAsFatal(false),
-          SuppressSystemWarnings(false) {}
+          SuppressSystemWarnings(false),
+          ExtBehavior(ExtensionDiagMode::Default) {}
 
     using iterator = llvm::DenseMap<unsigned, DiagnosticMapping>::iterator;
     using const_iterator =
         llvm::DenseMap<unsigned, DiagnosticMapping>::const_iterator;
 
     void setMapping(diag::kind Diag, DiagnosticMapping Info) {
       DiagMap[Diag] = Info;
     }
public:
   /// diagnostic will be suppressed.
   bool isLastDiagnosticIgnored() const {
     return LastDiagLevel == DiagnosticIDs::Ignored;
   }
 
   /// Controls whether otherwise-unmapped extension diagnostics are
   /// mapped onto ignore/warning/error.
   ///
-  /// This corresponds to the GCC -pedantic and -pedantic-errors option.
-  void setExtensionHandlingBehavior(diag::Severity H) {
-    GetCurDiagState()->ExtBehavior = H;
+  /// This corresponds to the GCC -fpermissive/-pedantic/-pedantic-errors
+  /// options.
+  void setExtensionHandlingBehavior(ExtensionDiagMode E) {
+    GetCurDiagState()->ExtBehavior = E;
   }
-  diag::Severity getExtensionHandlingBehavior() const {
+  ExtensionDiagMode getExtensionHandlingBehavior() const {
     return GetCurDiagState()->ExtBehavior;
   }
 
   /// Counter bumped when an __extension__  block is/ encountered.
   ///
   /// When non-zero, all extension diagnostics are entirely silenced, no
   /// matter how they are mapped.
   void IncrementAllExtensionsSilenced() { ++AllExtensionsSilenced; }

include/clang/Basic/DiagnosticOptions.h

inline DiagnosticLevelMask operator&(DiagnosticLevelMask LHS,
                                      DiagnosticLevelMask RHS) {
   using UT = std::underlying_type<DiagnosticLevelMask>::type;
   return static_cast<DiagnosticLevelMask>(
     static_cast<UT>(LHS) & static_cast<UT>(RHS));
 }
 
 raw_ostream& operator<<(raw_ostream& Out, DiagnosticLevelMask M);
 
+/// An enumeration describing how extension diagnostics should be treated
+/// by default.
+enum class ExtensionDiagMode : unsigned {
+  /// Map all extension diagnostics to at most a warning.
+  Permissive,
+  /// Map all extension diagnostics as specified in the diagnostic.
+  Default,
+  /// Map all extension diagnostics to at least a warning.
+  Pedantic,
+  /// Map all extension diagnostics to at least an error.
+  PedanticErrors,
+};
+
+raw_ostream& operator<<(raw_ostream& Out, ExtensionDiagMode M);
+
 /// Options for controlling the compiler diagnostics engine.
 class DiagnosticOptions : public RefCountedBase<DiagnosticOptions>{
 public:
   enum TextDiagnosticFormat { Clang, MSVC, Vi };
 
   // Default values.
   enum {
     DefaultTabStop = 8,

include/clang/Basic/DiagnosticOptions.def

 
 #ifndef SEMANTIC_ENUM_DIAGOPT
 #  define SEMANTIC_ENUM_DIAGOPT(Name, Type, Bits, Default) \
      ENUM_DIAGOPT(Name, Type, Bits, Default)
 #endif
 
 SEMANTIC_DIAGOPT(IgnoreWarnings, 1, 0)   /// -w
 DIAGOPT(NoRewriteMacros, 1, 0)  /// -Wno-rewrite-macros
-DIAGOPT(Pedantic, 1, 0)         /// -pedantic
-DIAGOPT(PedanticErrors, 1, 0)   /// -pedantic-errors
+ENUM_DIAGOPT(ExtensionsMode, ExtensionDiagMode, 2, ExtensionDiagMode::Default)
+                                /// -pedantic, -pedantic-errors, -fpermissive
 DIAGOPT(ShowColumn, 1, 1)       /// Show column number on diagnostics.
 DIAGOPT(ShowLocation, 1, 1)     /// Show source location information.
 DIAGOPT(AbsolutePath, 1, 0)     /// Use absolute paths.
 DIAGOPT(ShowCarets, 1, 1)       /// Show carets in diagnostics.
 DIAGOPT(ShowFixits, 1, 1)       /// Show fixit information.
 DIAGOPT(ShowSourceRanges, 1, 0) /// Show source ranges in numeric form.
 DIAGOPT(ShowParseableFixits, 1, 0) /// Show machine parseable fix-its.
 DIAGOPT(ShowPresumedLoc, 1, 0)  /// Show presumed location for diagnostics.

include/clang/Driver/Options.td

 def fembed_bitcode_marker : Flag<["-"], "fembed-bitcode-marker">,
   Alias<fembed_bitcode_EQ>, AliasArgs<["marker"]>,
   HelpText<"Embed placeholder LLVM IR data as a marker">;
 def fgnu_inline_asm : Flag<["-"], "fgnu-inline-asm">, Group<f_Group>, Flags<[DriverOption]>;
 def fno_gnu_inline_asm : Flag<["-"], "fno-gnu-inline-asm">, Group<f_Group>,
   Flags<[DriverOption, CC1Option]>,
   HelpText<"Disable GNU style inline asm">;
 
+def fpermissive : Flag<["-"], "fpermissive">, Group<f_Group>, Flags<[CC1Option]>,
+    HelpText<"Downgrade diagnostics for conforming extensions from errors to warnings">;
+def fno_permissive : Flag<["-"], "fno-permissive">, Group<f_Group>;
 def fprofile_sample_use : Flag<["-"], "fprofile-sample-use">, Group<f_Group>,
     Flags<[CoreOption]>;
 def fno_profile_sample_use : Flag<["-"], "fno-profile-sample-use">, Group<f_Group>,
     Flags<[CoreOption]>;
 def fprofile_sample_use_EQ : Joined<["-"], "fprofile-sample-use=">,
     Group<f_Group>, Flags<[DriverOption, CC1Option]>,
     HelpText<"Enable sample-based profile guided optimizations">;
 def fprofile_sample_accurate : Flag<["-"], "fprofile-sample-accurate">,

 defm finline_limit : BooleanFFlag<"inline-limit">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm inline_small_functions : BooleanFFlag<"inline-small-functions">,
     Group<clang_ignored_gcc_optimization_f_Group>;
 defm ipa_cp : BooleanFFlag<"ipa-cp">,
     Group<clang_ignored_gcc_optimization_f_Group>;
 defm ivopts : BooleanFFlag<"ivopts">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm non_call_exceptions : BooleanFFlag<"non-call-exceptions">, Group<clang_ignored_f_Group>;
 defm peel_loops : BooleanFFlag<"peel-loops">, Group<clang_ignored_gcc_optimization_f_Group>;
-defm permissive : BooleanFFlag<"permissive">, Group<clang_ignored_f_Group>;
 defm prefetch_loop_arrays : BooleanFFlag<"prefetch-loop-arrays">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm printf : BooleanFFlag<"printf">, Group<clang_ignored_f_Group>;
 defm profile : BooleanFFlag<"profile">, Group<clang_ignored_f_Group>;
 defm profile_correction : BooleanFFlag<"profile-correction">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm profile_generate_sampling : BooleanFFlag<"profile-generate-sampling">, Group<clang_ignored_f_Group>;
 defm profile_reusedist : BooleanFFlag<"profile-reusedist">, Group<clang_ignored_f_Group>;
 defm profile_values : BooleanFFlag<"profile-values">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm regs_graph : BooleanFFlag<"regs-graph">, Group<clang_ignored_f_Group>;

lib/ARCMigrate/ARCMT.cpp

if (!PPOpts.ImplicitPCHInclude.empty()) {
     PPOpts.ImplicitPCHInclude.clear();
   }
   std::string define = getARCMTMacroName();
   define += '=';
   CInvok->getPreprocessorOpts().addMacroDef(define);
   CInvok->getLangOpts()->ObjCAutoRefCount = true;
   CInvok->getLangOpts()->setGC(LangOptions::NonGC);
   CInvok->getDiagnosticOpts().ErrorLimit = 0;
-  CInvok->getDiagnosticOpts().PedanticErrors = 0;
+  if (CInvok->getDiagnosticOpts().getExtensionsMode() ==
+        ExtensionDiagMode::PedanticErrors)
+    CInvok->getDiagnosticOpts().setExtensionsMode(ExtensionDiagMode::Pedantic);
 
   // Ignore -Werror flags when migrating.
   std::vector<std::string> WarnOpts;
   for (std::vector<std::string>::iterator
          I = CInvok->getDiagnosticOpts().Warnings.begin(),
          E = CInvok->getDiagnosticOpts().Warnings.end(); I != E; ++I) {
     if (!StringRef(*I).startswith("error"))
       WarnOpts.push_back(*I);

lib/Basic/DiagnosticIDs.cpp

DiagnosticIDs::getDiagnosticSeverity(unsigned DiagID, SourceLocation Loc,
   // (The diagnostics controlled by -pedantic are the extension diagnostics
   // that are not enabled by default.)
   bool EnabledByDefault = false;
   bool IsExtensionDiag = isBuiltinExtensionDiag(DiagID, EnabledByDefault);
   if (Diag.AllExtensionsSilenced && IsExtensionDiag && !EnabledByDefault)
     return diag::Severity::Ignored;
 
   // For extension diagnostics that haven't been explicitly mapped, check if we
-  // should upgrade the diagnostic.
-  if (IsExtensionDiag && !Mapping.isUser())
-    Result = std::max(Result, State->ExtBehavior);
+  // should upgrade or downgrade the diagnostic.
+  if (IsExtensionDiag && !Mapping.isUser()) {
+    switch (State->ExtBehavior) {
+    case ExtensionDiagMode::PedanticErrors:
+      Result = std::max(Result, diag::Severity::Error);
+      break;
+    case ExtensionDiagMode::Pedantic:
+      Result = std::max(Result, diag::Severity::Warning);
+      break;
+    case ExtensionDiagMode::Default:
+      break;
+    case ExtensionDiagMode::Permissive:
+      Result = std::min(Result, diag::Severity::Warning);
+      break;
+    }
+  }
 
   // At this point, ignored errors can no longer be upgraded.
   if (Result == diag::Severity::Ignored)
     return Result;
 
   // Honor -w: this disables all messages which which are not Error/Fatal by
   // default (disregarding attempts to upgrade severity from Warning to Error),
   // as well as disabling all messages which are currently mapped to Warning
   // (whether by default or downgraded from Error via e.g. -Wno-error or #pragma
-  // diagnostic.)
+  // diagnostic or -fpermissive.)
   if (State->IgnoreAllWarnings) {
     if (Result == diag::Severity::Warning ||
         (Result >= diag::Severity::Error &&
          !isDefaultMappingAsError((diag::kind)DiagID)))
       return diag::Severity::Ignored;
   }
 
   // If -Werror is enabled, map warnings to errors unless explicitly disabled.

lib/Basic/DiagnosticOptions.cpp

 
 namespace clang {
 
 raw_ostream &operator<<(raw_ostream &Out, DiagnosticLevelMask M) {
   using UT = std::underlying_type<DiagnosticLevelMask>::type;
   return Out << static_cast<UT>(M);
 }
 
+raw_ostream &operator<<(raw_ostream &Out, ExtensionDiagMode E) {
+  switch (E) {
+  case ExtensionDiagMode::PedanticErrors: return Out << "pedantic-errors";
+  case ExtensionDiagMode::Pedantic: return Out << "pedantic";
+  case ExtensionDiagMode::Default: return Out << "default";
+  case ExtensionDiagMode::Permissive: return Out << "permissive";
+  }
+  llvm_unreachable("unknown extension diagnostic mode");
+}
+
 } // namespace clang

lib/Basic/Warnings.cpp

void clang::ProcessWarningOptions(DiagnosticsEngine &Diags,
   if (Opts.TemplateBacktraceLimit)
     Diags.setTemplateBacktraceLimit(Opts.TemplateBacktraceLimit);
   if (Opts.ConstexprBacktraceLimit)
     Diags.setConstexprBacktraceLimit(Opts.ConstexprBacktraceLimit);
 
   // If -pedantic or -pedantic-errors was specified, then we want to map all
   // extension diagnostics onto WARNING or ERROR unless the user has futz'd
   // around with them explicitly.
-  if (Opts.PedanticErrors)
-    Diags.setExtensionHandlingBehavior(diag::Severity::Error);
-  else if (Opts.Pedantic)
-    Diags.setExtensionHandlingBehavior(diag::Severity::Warning);
-  else
-    Diags.setExtensionHandlingBehavior(diag::Severity::Ignored);
+  Diags.setExtensionHandlingBehavior(Opts.getExtensionsMode());
 
   SmallVector<diag::kind, 10> _Diags;
   const IntrusiveRefCntPtr< DiagnosticIDs > DiagIDs =
     Diags.getDiagnosticIDs();
   // We parse the warning options twice.  The first pass sets diagnostic state,
   // while the second pass reports warnings/errors.  This has the effect that
   // we follow the more canonical "last option wins" paradigm when there are
   // conflicting options.

lib/Driver/ToolChains/Clang.cpp

for (const Arg *A :
     A->claim();
   }
 
   claimNoWarnArgs(Args);
 
   Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
 
   Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
-  if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
-    CmdArgs.push_back("-pedantic");
-  Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
   Args.AddLastArg(CmdArgs, options::OPT_w);
 
+  // Extensions handling: last of -pedantic / -pedantic-errors / -no-pedantic
+  // takes precedence, except that -pedantic after -pedantic-errors has no
+  // effect.
+  const Arg *PedanticArg = nullptr;
+  if (const Arg *A =
+          Args.getLastArg(options::OPT_pedantic_errors, options::OPT_pedantic,
+                          options::OPT_no_pedantic)) {
+    if (!A->getOption().matches(options::OPT_no_pedantic)) {
+      const Arg *PedErrors = Args.getLastArg(options::OPT_pedantic_errors,
+                                             options::OPT_no_pedantic);
+      if (PedErrors &&
+          PedErrors->getOption().matches(options::OPT_pedantic_errors)) {
+        CmdArgs.push_back("-pedantic-errors");
+        PedanticArg = PedErrors;
+      } else {
+        CmdArgs.push_back("-pedantic");
+        PedanticArg = A;
+      }
+    }
+  }
+  if (Args.hasFlag(options::OPT_fpermissive, options::OPT_fno_permissive,
+                   false)) {
+    // Unlike GCC, we apply -pedantic and -fpermissive to all extension
+    // diagnostics, and reject any combination of both flags.
+    //
+    // GCC allows (eg) -pedantic-errors -fpermissive, and responds by
+    // erroring on all extensions it would not error on by default, and
+    // only warning on all extensions it would error on by default. That
+    // does not seem like useful behavior, so we do not follow suit.
+    if (PedanticArg)
+      D.Diag(diag::err_drv_argument_not_allowed_with)
+          << PedanticArg->getAsString(Args) << "-fpermissive";
+    CmdArgs.push_back("-fpermissive");
+  }
+
   // Fixed point flags
   if (Args.hasFlag(options::OPT_ffixed_point, options::OPT_fno_fixed_point,
                    /*Default=*/false))
     Args.AddLastArg(CmdArgs, options::OPT_ffixed_point);
 
   // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
   // (-ansi is equivalent to -std=c89 or -std=c++98).
   //

lib/Frontend/CompilerInvocation.cpp

bool clang::ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
   bool Success = true;
 
   Opts.DiagnosticLogFile = Args.getLastArgValue(OPT_diagnostic_log_file);
   if (Arg *A =
           Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
     Opts.DiagnosticSerializationFile = A->getValue();
   Opts.IgnoreWarnings = Args.hasArg(OPT_w);
   Opts.NoRewriteMacros = Args.hasArg(OPT_Wno_rewrite_macros);
-  Opts.Pedantic = Args.hasArg(OPT_pedantic);
-  Opts.PedanticErrors = Args.hasArg(OPT_pedantic_errors);
+
+  if (Args.hasArg(OPT_pedantic_errors))
+    Opts.setExtensionsMode(ExtensionDiagMode::PedanticErrors);
+  else if (Args.hasArg(OPT_pedantic))
+    Opts.setExtensionsMode(ExtensionDiagMode::Pedantic);
+  else if (Args.hasArg(OPT_fpermissive))
+    Opts.setExtensionsMode(ExtensionDiagMode::Permissive);
+
   Opts.ShowCarets = !Args.hasArg(OPT_fno_caret_diagnostics);
   Opts.ShowColors = parseShowColorsArgs(Args, DefaultDiagColor);
   Opts.ShowColumn = Args.hasFlag(OPT_fshow_column,
                                  OPT_fno_show_column,
                                  /*Default=*/true);
   Opts.ShowFixits = !Args.hasArg(OPT_fno_diagnostics_fixit_info);
   Opts.ShowLocation = !Args.hasArg(OPT_fno_show_source_location);
   Opts.AbsolutePath = Args.hasArg(OPT_fdiagnostics_absolute_paths);

lib/Lex/PPMacroExpansion.cpp

 /// specified by the identifier, either as an extension or a standard language
 /// feature.
 static bool HasExtension(const Preprocessor &PP, StringRef Extension) {
   if (HasFeature(PP, Extension))
     return true;
 
   // If the use of an extension results in an error diagnostic, extensions are
   // effectively unavailable, so just return false here.
-  if (PP.getDiagnostics().getExtensionHandlingBehavior() >=
-      diag::Severity::Error)
+  switch (PP.getDiagnostics().getExtensionHandlingBehavior()) {
+    case ExtensionDiagMode::PedanticErrors:
       return false;
+    case ExtensionDiagMode::Pedantic:
+    case ExtensionDiagMode::Default:
+    case ExtensionDiagMode::Permissive:
+      break;
+  }
 
   const LangOptions &LangOpts = PP.getLangOpts();
 
   // Normalize the extension name, __foo__ becomes foo.
   if (Extension.startswith("__") && Extension.endswith("__") &&
       Extension.size() >= 4)
     Extension = Extension.substr(2, Extension.size() - 4);
 

lib/Serialization/ASTReader.cpp

for (auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
       }
     }
   }
 
   return false;
 }
 
 static bool isExtHandlingFromDiagsError(DiagnosticsEngine &Diags) {
-  diag::Severity Ext = Diags.getExtensionHandlingBehavior();
-  if (Ext == diag::Severity::Warning && Diags.getWarningsAsErrors())
+  switch (Diags.getExtensionHandlingBehavior()) {
+  case ExtensionDiagMode::PedanticErrors:
     return true;
-  return Ext >= diag::Severity::Error;
+  case ExtensionDiagMode::Pedantic:
+    return Diags.getWarningsAsErrors();
+  case ExtensionDiagMode::Default:
+  case ExtensionDiagMode::Permissive:
+    return false;
+  }
+  llvm_unreachable("unknown extension diagnostic mode");
 }
 
 static bool checkDiagnosticMappings(DiagnosticsEngine &StoredDiags,
                                     DiagnosticsEngine &Diags,
                                     bool IsSystem, bool Complain) {
   // Top-level options
   if (IsSystem) {
     if (Diags.getSuppressSystemWarnings())
if (F.Kind == MK_ImplicitModule) {
       // -Wblah flags.
       unsigned Flags = Record[Idx++];
       DiagState Initial;
       Initial.SuppressSystemWarnings = Flags & 1; Flags >>= 1;
       Initial.ErrorsAsFatal = Flags & 1; Flags >>= 1;
       Initial.WarningsAsErrors = Flags & 1; Flags >>= 1;
       Initial.EnableAllWarnings = Flags & 1; Flags >>= 1;
       Initial.IgnoreAllWarnings = Flags & 1; Flags >>= 1;
-      Initial.ExtBehavior = (diag::Severity)Flags;
+      Initial.ExtBehavior = (ExtensionDiagMode)Flags;
       FirstState = ReadDiagState(Initial, SourceLocation(), true);
 
       assert(F.OriginalSourceFileID.isValid());
 
       // Set up the root buffer of the module to start with the initial
       // diagnostic state of the module itself, to cover files that contain no
       // explicit transitions (for which we did not serialize anything).
       Diag.DiagStatesByLoc.Files[F.OriginalSourceFileID]

test/Driver/warning-options_pedantic.cpp

 // Make sure we don't match the -NOT lines with the linker invocation.
 // Delimiters match the start of the cc1 and the start of the linker lines
 // DELIMITERS: {{^ *"}}
 
+// RUN: %clang -### -pedantic %s 2>&1 | FileCheck -check-prefix=PEDANTIC -check-prefix=DELIMITERS %s
+// RUN: %clang -### -pedantic-errors %s 2>&1 | FileCheck -check-prefix=PEDANTIC_ERRORS -check-prefix=DELIMITERS %s
+// RUN: %clang -### -Wpedantic %s 2>&1 | FileCheck -check-prefix=NO_PEDANTIC -check-prefix=DELIMITERS %s
 // RUN: %clang -### -pedantic -no-pedantic %s 2>&1 | FileCheck -check-prefix=NO_PEDANTIC -check-prefix=DELIMITERS %s
 // RUN: %clang -### -pedantic -Wno-pedantic %s 2>&1 | FileCheck -check-prefix=PEDANTIC -check-prefix=DELIMITERS %s
+// RUN: %clang -### -pedantic -no-pedantic -pedantic %s 2>&1 | FileCheck -check-prefix=PEDANTIC -check-prefix=DELIMITERS %s
+// RUN: %clang -### -pedantic -no-pedantic -pedantic-errors %s 2>&1 | FileCheck -check-prefix=PEDANTIC_ERRORS -check-prefix=DELIMITERS %s
+// RUN: %clang -### -pedantic-errors -no-pedantic -pedantic %s 2>&1 | FileCheck -check-prefix=PEDANTIC -check-prefix=DELIMITERS %s
+// RUN: %clang -### -pedantic -no-pedantic -pedantic-errors -pedantic %s 2>&1 | FileCheck -check-prefix=PEDANTIC_ERRORS -check-prefix=DELIMITERS %s
+// RUN: %clang -### -pedantic -no-pedantic -Wpedantic %s 2>&1 | FileCheck -check-prefix=NO_PEDANTIC -check-prefix=DELIMITERS %s
+// RUN: %clang -### -pedantic-errors -no-pedantic -Wpedantic %s 2>&1 | FileCheck -check-prefix=NO_PEDANTIC -check-prefix=DELIMITERS %s
+
+// RUN: %clang -### -fpermissive %s 2>&1 | FileCheck -check-prefix=PERMISSIVE -check-prefix=DELIMITERS %s
+// RUN: %clang -### -fpermissive -fno-permissive -pedantic %s 2>&1 | FileCheck -check-prefix=PEDANTIC -check-prefix=DELIMITERS %s
+// RUN: %clang -### -fpermissive -fno-permissive -pedantic-errors %s 2>&1 | FileCheck -check-prefix=PEDANTIC_ERRORS -check-prefix=DELIMITERS %s
+// RUN: %clang -### -pedantic -fpermissive -fno-permissive %s 2>&1 | FileCheck -check-prefix=PEDANTIC -check-prefix=DELIMITERS %s
+// RUN: %clang -### -pedantic-errors -fpermissive -fno-permissive %s 2>&1 | FileCheck -check-prefix=PEDANTIC_ERRORS -check-prefix=DELIMITERS %s
+// RUN: %clang -### -pedantic -no-pedantic -fpermissive %s 2>&1 | FileCheck -check-prefix=PERMISSIVE -check-prefix=DELIMITERS %s
+// RUN: %clang -### -pedantic-errors -no-pedantic -fpermissive %s 2>&1 | FileCheck -check-prefix=PERMISSIVE -check-prefix=DELIMITERS %s
+
+// RUN: %clang -### -pedantic -fpermissive %s 2>&1 | FileCheck -check-prefix=PEDANTIC_PERMISSIVE %s
+// RUN: %clang -### -pedantic-errors -fpermissive %s 2>&1 | FileCheck -check-prefix=PEDANTIC_ERRORS_PERMISSIVE %s
+// RUN: %clang -### -pedantic-errors -pedantic -fpermissive %s 2>&1 | FileCheck -check-prefix=PEDANTIC_ERRORS_PERMISSIVE %s
+
 // NO_PEDANTIC-NOT: -pedantic
-// RUN: %clang -### -pedantic -pedantic -no-pedantic -pedantic %s 2>&1 | FileCheck -check-prefix=PEDANTIC -check-prefix=DELIMITERS %s
-// RUN: %clang -### -pedantic -pedantic -no-pedantic -Wpedantic %s 2>&1 | FileCheck -check-prefix=NO_PEDANTIC -check-prefix=DELIMITERS %s
-// PEDANTIC: -pedantic
+// PEDANTIC: "-pedantic"
+// PEDANTIC_ERRORS: "-pedantic-errors"
+// PERMISSIVE: "-fpermissive"
 // REQUIRES: clang-driver
 
 // DELIMITERS: {{^ *"}}
+
+// PEDANTIC_PERMISSIVE: error: invalid argument '-pedantic' not allowed with '-fpermissive'
+// PEDANTIC_ERRORS_PERMISSIVE: error: invalid argument '-pedantic-errors' not allowed with '-fpermissive'

test/Frontend/warning-mapping-2.c

+// Check that -pedantic-errors promotes extensions to errors
+// RUN: %clang_cc1 -verify -pedantic-errors %s -DMODE=0
+
 // Check that -w takes precedence over -pedantic-errors.
-// RUN: %clang_cc1 -verify -pedantic-errors -w %s
+// RUN: %clang_cc1 -verify -pedantic-errors -w %s -DMODE=1
 
-// Expect *not* to see a diagnostic for "implicit declaration of function"
-// expected-no-diagnostics
+// Check that -fpermissive demotes errors to warnings.
+// RUN: %clang_cc1 -verify -fpermissive %s -DMODE=2
+
+// Check that -w suppresses diagnostics demoted by -fpermissive.
+// RUN: %clang_cc1 -verify -fpermissive -w %s -DMODE=3
 
 void f0() { f1(); }
+#if MODE == 0
+  // expected-error@-2 {{implicit declaration of function}}
+#elif MODE == 1
+  // no diagnostic
+#elif MODE == 2
+  // expected-warning@-6 {{implicit declaration of function}}
+#else
+  // expected-no-diagnostics
+#endif
+
+void f2() {
+  return 123;
+#if MODE <= 1
+  // expected-error@-2 {{should not return a value}}
+#elif MODE == 2
+  // expected-warning@-4 {{should not return a value}}
+#endif
+}