Toolchain: Normalize dwarf, sjlj and seh eh

[martell]

Summary

adds -fseh-exceptions and -fdwarf-exceptions flags

clang will check if the user has specified an exception model flag,
in the absense of specifying the exception model clang will then check
the driver default and append the model flag for that target to cc1

clang cc1 assumes dwarf is the default if none is passed
and -fno-exceptions has a higher priority then specifying the model

move SEH macro definitions out of Targets into InitPreprocessor
behind the -fseh-exceptions flag

move ARM_DWARF_EH macrodefinitions out of verious targets and into
InitPreprocessor behind the -fdwarf-exceptions flag and arm|thumb check

remove unused USESEHExceptions from the MinGW Driver
fold USESjLjExceptions into a new GetExceptionModel function that
gives the toolchain classes more flexibility with eh models.

if a toolchain does not specify the exception model make a best guess based
what llvm does for that triple with the assembler much like cc1as.

[martell]

Add command line documentation references

[martell]

@mstorsjo I think this should help with issues like having to set the default for ARM to DWARF.
If you can set it at run time then it should be a lot easier to just set that in the clang wrapper scripts.

Long term I would like the MinGW Driver to load a different libunwind depending on the exception model but that discussion might still be a little off.
Any thoughts?

[mstorsjo]

In D39673#917506, @martell wrote:

@mstorsjo I think this should help with issues like having to set the default for ARM to DWARF.
If you can set it at run time then it should be a lot easier to just set that in the clang wrapper scripts.

Yes, I think this probably can be useful.

As for the ARM patch (D39532), parts of it are necessary in any case since the ARM/COFF backend doesn't support outputting dwarf yet. Since there's no other option there yet, setting it to dwarf until something else is implemented probably should be fine though.

The main place where this patch really can provide value though, is for the libcxxabi/libunwind based x86_64 builds. Since libcxxabi doesn't support SEH yet (although I'm planning on at least having a look at how much work it'd be to implement it, but I'm afraid it can be a pretty big task), but clang for x86_64 mingw in general does support SEH (and that's what is used for the normal mingw setups) we shouldn't change the default there.

I haven't tried this patch in that setup yet but will do soon.

Long term I would like the MinGW Driver to load a different libunwind depending on the exception model but that discussion might still be a little off.

I don't really see what would be necessary there; a matching unwinding library should be provided in whatever C++ and compiler runtime library you use, so that's mostly an issue for whoever sets up the environment to build libraries in the right configurations matching it as a whole.

[mstorsjo]

In D39673#917506, @martell wrote:

@mstorsjo I think this should help with issues like having to set the default for ARM to DWARF.

Btw, in addition to making setting __SEH__ conditional, it should also instead set __ARM_DWARF_EH__ on ARM if dwarf is chosen there (see D39533).

[martell]

In D39673, @martell wrote:

Long term I would like the MinGW Driver to load a different libunwind depending on the exception model but that discussion might still be a little off.

In D39673#917510, @mstorsjo wrote:

I don't really see what would be necessary there; a matching unwinding library should be provided in whatever C++ and compiler runtime library you use, so that's mostly an issue for whoever sets up the environment to build libraries in the right configurations matching it as a whole.

I mostly expect this to be useful where environment has builds all 3 versions of the libunwind. where the library is named differently based on the eh model.
e.g. libunwind-sjlj.a libunwind-seh.a and libunwind-dwarf.a
With the above exception flags the version of libunwind with the matching model should be automatically linked, I imagine it to be stored in a similar locations as the compiler-rt libs.

[mstorsjo]

In D39673#917524, @martell wrote:

I mostly expect this to be useful where environment has builds all 3 versions of the libunwind. where the library is named differently based on the eh model.
e.g. libunwind-sjlj.a libunwind-seh.a and libunwind-dwarf.a
With the above exception flags the version of libunwind with the matching model should be automatically linked, I imagine it to be stored in a similar locations as the compiler-rt libs.

Ah, I see. I'm a little hesitant about such an environment, because code built with each exception handling model is essentially a different ABI, and having them all in the same setup feels pretty prone to errors. Like, you need to have built your libcxx and libcxxabi with matching exception handling models as well, so then you need three copies of them as well.

[martell]

@rnk ping :)

[martell]

Ping :)

[rnk]

Looks good, sorry for the delay!

include/clang/Basic/LangOptions.def

129

"Structured exception handling" is very ambiguous. I would say something like "SEH .xdata exception handling" or something to clarify.

[mstorsjo]

lib/Frontend/InitPreprocessor.cpp

683

Please define __ARM_DWARF_EH__ if dwarf is enabled on arm, see D39533, as I commented earlier. (Sorry, I forgot about it and thought it was fixed already.)

[mstorsjo]

D39533 was committed now, so before committing, make sure that the __ARM_DWARF_EH__ (that was added in that commit) only gets set while dwarf is enabled (which now is the default for mingw/arm but not msvc/arm).

[martell]

updated to handle dwarf exceptions on arm.

[martell]

Thanks for the review @rnk . I addressed the comment nit you had.
@mstorsjo I updated this to also handle thumb on arm.

When doing that I noticed there is something really strange about the existing macro defines. I assume they should only be defined when exceptions is enabled.
This is by default in c++ mode of with -fexceptions in c mode.
I moved the defines within a check of exceptions being enabled to address that.

Apple seem to do their own thing for watchOS by just force enabling it for that target only.
Some input there would help a lot.

Also if you think we should define the macros even when exceptions are disabled could you explain why?

[mstorsjo]

lib/Frontend/InitPreprocessor.cpp

685

Won't this start setting this define also on platforms where ARM EHABI is the default? (I.e. all ELF platforms except netbsd)?

[martell]

lib/Frontend/InitPreprocessor.cpp

685

It will set it on any arm / thumb platform where exceptions are enabled and the current model is dwarf.
This includes netbsd. The issue we have is that apple set this unconditionally for their watch platform.

I'm wondering if we should put this behind a !apple guard or just add an if windows or netbsd guard.

Or is it okay to just generally have this macro on all platforms where dwarf is exception model and the target is arm?

[mstorsjo]

In D39673#929536, @martell wrote:

When doing that I noticed there is something really strange about the existing macro defines. I assume they should only be defined when exceptions is enabled.
This is by default in c++ mode of with -fexceptions in c mode.
I moved the defines within a check of exceptions being enabled to address that.

I'm not sure if this is the right thing to do. Since the exception handling model more or less also defines what ABI the code conforms to, I can see it being useful to know what exception handling mode is intended to be used, even if compiling plain C code without exceptions enabled. E.g. when building libunwind, some of the C sources there have ifdefs that check for __USING_SJLJ_EXCEPTIONS__ and/or __ARM_DWARF_EH__. With this change, one has to manually start specifying it when building libunwind, to match whatever the default and/or manually chosen exception handling model is.

[mstorsjo]

lib/Frontend/InitPreprocessor.cpp

685

No, it will set it on any arm/thumb platform where one hasn't indicated preference for any other model. And there are more models than just dwarf/seh/sjlj - there's also the ARM EHABI model. (According to MC/MCTargetOptions.h in llvm, there aren't any more than this currently though.)

Prior to this patch, clang -x c++ -target armv7-linux-gnueabihf -E -dM - < /dev/null will not include __ARM_DWARF_EH__ - while it will after this patch. This will certainly break libunwind for linux on arm. (And prior to this patch, clang -x c -target armv7-netbsd -E -dM - < /dev/null did include it, but now it's only included when exceptions are enabled - I think the old behaviour is preferrable wrt that as well.)

So, similarly how we on x86_64 have a default that enables SEH unless something else has been specified, we need to prefer ARM EHABI on everything on ELF except netbsd. I guess you could fold in the apple defaults into that as well?

[martell]

updated to HEAD.
added a NOT msvc test

[martell]

In D39673#929986, @mstorsjo wrote:

I'm not sure if this is the right thing to do. Since the exception handling model more or less also defines what ABI the code conforms to, I can see it being useful to know what exception handling mode is intended to be used, even if compiling plain C code without exceptions enabled. E.g. when building libunwind, some of the C sources there have ifdefs that check for __USING_SJLJ_EXCEPTIONS__ and/or __ARM_DWARF_EH__. With this change, one has to manually start specifying it when building libunwind, to match whatever the default and/or manually chosen exception handling model is.

It seems reasonable to me that one would specify -fexceptions when building c sources to get the macro for the exceptions, libunwind included, but yes right now there are c sources in libunwind that this would break and probably other libraries that have c sources that check unconditionally. This is not an issue for c++ as -fexceptions is enabled by default.

This is a little beyond the scope of what I am trying to achieve in this patch though and should be in a different differential after libunwind adds -fexceptions when building it's c sources, if we go that route.
For now I have update this patch to HEAD and reverted back to using the model macros defines independent of -fexceptions as you suggested.

[martell]

Just as a note there is still a lot to be desired here. I do not particularly like the UseSEHExceptions function default and the actual macro definition guards should be based on the current ExceptionModel because we set that in lib/CodeGen/BackendUtil.cpp. This way we do not need to have some silly default of x64 && windows for UseSEHExceptions and can rely on the llvm backend defaults but override within the driver we want like the apple targets do for sjlj. This does for now keep the current functionality while giving us a flag to override which is the goal of this patch.

[rnk]

In D39673#931487, @martell wrote:

Just as a note there is still a lot to be desired here. I do not particularly like the UseSEHExceptions function default and the actual macro definition guards should be based on the current ExceptionModel because we set that in lib/CodeGen/BackendUtil.cpp. This way we do not need to have some silly default of x64 && windows for UseSEHExceptions and can rely on the llvm backend defaults but override within the driver we want like the apple targets do for sjlj. This does for now keep the current functionality while giving us a flag to override which is the goal of this patch.

We have to know the EH model before pre-processing, and that shouldn't rely on LLVM TargetOptions. We can probably reuse the llvm::ExceptionHandling enum instead of these various overlapping booleans, if that's the direction you want to go. However, I don't see how we can get away from the clang toolchain knowing the default EH model for each target.

[mstorsjo]

No objection from me about committing this now, although I have some minor comments (that possibly can be taken care of without reposting and re-reviewing). Still ok with @rnk?

lib/Frontend/InitPreprocessor.cpp

685

I guess you could add an || LangOpts.DWARFExceptions here as well? That would allow you to manually enable dwarf on arm on linux as well. (I did that manually while testing some bits in libunwind.)

Ideally I'd prefer to have a UseDWARFExceptions just like there already is UseSEHExceptions and UseSjLjExceptions in the driver, so that it'd explcitly pass -fdwarf-exceptions here in the cases where it's known to be the default. But at least this form shouldn't break anything right now.

[rnk]

Yep, looks good

[martell]

fold USESjLjExceptions into GetExceptionModel.
do a best effort to check the llvm default exception model for the triple if the toolchain does not specify.
(mostly based on the cc1_as code)

[martell]

In D39673#931861, @rnk wrote:

We have to know the EH model before pre-processing, and that shouldn't rely on LLVM TargetOptions. We can probably reuse the llvm::ExceptionHandling enum instead of these various overlapping booleans, if that's the direction you want to go. However, I don't see how we can get away from the clang toolchain knowing the default EH model for each target.

I ended up folding USESjLjExceptions into a GetExceptionModel function that returns the llvm::ExceptionHandling.
Reid you are right that clang needed to know some targets beforehand, this is especially obvious for the various apple devices. watch and co.

relying on LLVM TargetOptions is much better for platforms like windows
rather then checking T.isOSWindows() && T.getArch() == llvm::Triple::x86_64 to decide on enabling SEH I opted to do a best effort attempt to check what the default is much like how cc1as does.
the difference being if it fails we just specify the default as none giving us the following pattern.

1. set eh based no user flags passed into clang
2. if no flags passed check the toolchain defaults,
3. if no toolchain default then check llvm,
4. if we can not determine if it is a supported triple default to None.

I also addressed Martin's concern in the folding by adding | LangOpts.DWARFExceptions and no longer have to specifically check for mingw or netbsd.

Sorry for the noise on this, I just want to make sure we get the best functionality on this while ensuring it is future proof for other model.

If you still have strong objections on 3. after seeing this it is pretty trivial to just return None from GetExceptionModel by default and then always rely on the Toolchains to know the models. (though I will have to do some windows specific checks in the ToolChain::GetExceptionModel to ensure seh is the default)

[mstorsjo]

Looks really good to me now! @rnk?

[rnk]

lib/Driver/ToolChain.cpp

450–458 ↗

(On Diff #123883)

I think this is problematic because Clang is supposed to be able to generate LLVM IR for targets that are not registered. With this change, we have silent behavior difference between clang with LLVM backend and clang without LLVM backends.

Building clang without a single backend is pretty silly, but our test suite frequently generates IR for targets that are not compiled in. Some of the tests you've written will probably fail on buildbots configured this way.

[martell]

address reid's comment
update to HEAD

[mstorsjo]

lib/Driver/ToolChain.cpp

458 ↗

(On Diff #124692)

I'd suggest braces around the outer if statement.

But is there any point to this default fallback here at all? Dwarf isn't right for x86 for MSVC, and we set the right defaults for all the MinGW cases in that driver in any case. So isn't it enough to just return None always here, or possibly WinEH for all windows cases?

[martell]

lib/Driver/ToolChain.cpp

458 ↗

(On Diff #124692)

Won't need braces with the change I am about to make.

The previous check was getArch() == llvm::Triple::x86_64 then use seh.
This didn't take into account arm or aarch64 so I flipped this.

I read the wrong llvm class for llvm::Triple::x86 X86MCAsmInfoGNUCOFF
It should have been X86MCAsmInfoMicrosoft I looked at.

if (Triple.getArch() == Triple::x86_64) {
  PrivateGlobalPrefix = ".L";
  PrivateLabelPrefix = ".L";
  CodePointerSize = 8;
  WinEHEncodingType = WinEH::EncodingType::Itanium;
} else {
  // 32-bit X86 doesn't use CFI, so this isn't a real encoding type. It's just
  // a place holder that the Windows EHStreamer looks for to suppress CFI
  // output. In particular, usesWindowsCFI() returns false.
  WinEHEncodingType = WinEH::EncodingType::X86;
}

ExceptionsType = ExceptionHandling::WinEH;

I think None in the case of x86 is the behavior that was present previously so I am going to revert from dwarf to none.

https://www.google.com/patents/US5628016
That borland patent has long since expired now and seh is the default in llvm for x86 so we can do seh on x86 for clang but I will leave that to a different patch.

[martell]

• disregard my last comment, lets go with seh on all windows targets.

[martell]

landing this as it was previous approved by reid in this state and again re checked by martin.

[mstorsjo]

cfe/trunk/lib/Driver/ToolChain.cpp

457 ↗

(On Diff #124696)

It looks like this broke some buildbot after all - see e.g. http://lab.llvm.org:8011/builders/sanitizer-windows/builds/20371.

Perhaps it's best to just have the default here be None even for Windows, and just let it be overridden for MinGW? I don't think we did define __SEH__ at all when targeting MSVC before either, so it should be fine to just leave it unset and not override anything from the backend defaults here.

[mstorsjo]

cfe/trunk/lib/Driver/ToolChains/FreeBSD.cpp

368 ↗

(On Diff #124696)

This seems to need a fallthrough comment to build without warnings in some configurations, see e.g. http://lab.llvm.org:8011/builders/ubuntu-gcc7.1-werror/builds/3329/steps/build-unified-tree/logs/stdio

[martell]

@mstorsjo yup, I added a comment on the commit about the failure here rL319294
I have already fixed both issues.
Will re apply shortly.

[martell]

I also want to note a small addition armeb and thumbeb for NetBSD.
They were missed in the previous version.
Just waiting for tests to pass now.

docs/ClangCommandLineReference.rst

 .. option:: -fsigned-char, -fno-signed-char, --signed-char
 
 .. option:: -fsigned-zeros, -fno-signed-zeros
 
 .. option:: -fsized-deallocation, -fno-sized-deallocation
 
 Enable C++14 sized global deallocation functions
 
+.. option:: -fdwarf-exceptions
+
+Use DWARF style exceptions
+
 .. option:: -fsjlj-exceptions
 
 Use SjLj style exceptions
 
+.. option:: -fseh-exceptions
+
+Use SEH style exceptions
+
 .. option:: -fslp-vectorize, -fno-slp-vectorize, -ftree-slp-vectorize
 
 Enable the superword-level parallelism vectorization passes
 
 .. option:: -fspell-checking, -fno-spell-checking
 
 .. option:: -fspell-checking-limit=<arg>
 

include/clang/Basic/LangOptions.def

 LANGOPT(WritableStrings   , 1, 0, "writable string support")
 LANGOPT(ConstStrings      , 1, 0, "const-qualified string support")
 LANGOPT(LaxVectorConversions , 1, 1, "lax vector conversions")
 LANGOPT(AltiVec           , 1, 0, "AltiVec-style vector initializers")
 LANGOPT(ZVector           , 1, 0, "System z vector extensions")
 LANGOPT(Exceptions        , 1, 0, "exception handling")
 LANGOPT(ObjCExceptions    , 1, 0, "Objective-C exceptions")
 LANGOPT(CXXExceptions     , 1, 0, "C++ exceptions")
+LANGOPT(DWARFExceptions   , 1, 0, "dwarf exception handling")
 LANGOPT(SjLjExceptions    , 1, 0, "setjmp-longjump exception handling")
+LANGOPT(SEHExceptions     , 1, 0, "structured exception handling")
 LANGOPT(ExternCNoUnwind   , 1, 0, "Assume extern C functions don't unwind")
 LANGOPT(TraditionalCPP    , 1, 0, "traditional CPP emulation")
 LANGOPT(RTTI              , 1, 1, "run-time type information")
 LANGOPT(RTTIData          , 1, 1, "emit run-time type information data")
 LANGOPT(MSBitfields       , 1, 0, "Microsoft-compatible structure layout")
 LANGOPT(Freestanding, 1, 0, "freestanding implementation")
 LANGOPT(NoBuiltin         , 1, 0, "disable builtin functions")
 LANGOPT(NoMathBuiltin     , 1, 0, "disable math builtin functions")

include/clang/Driver/Options.td

def femit_all_decls : Flag<["-"], "femit-all-decls">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Emit all declarations, even if unused">;
 def femulated_tls : Flag<["-"], "femulated-tls">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Use emutls functions to access thread_local variables">;
 def fno_emulated_tls : Flag<["-"], "fno-emulated-tls">, Group<f_Group>;
 def fencoding_EQ : Joined<["-"], "fencoding=">, Group<f_Group>;
 def ferror_limit_EQ : Joined<["-"], "ferror-limit=">, Group<f_Group>, Flags<[CoreOption]>;
 def fexceptions : Flag<["-"], "fexceptions">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable support for exception handling">;
+def fdwarf_exceptions : Flag<["-"], "fdwarf-exceptions">, Group<f_Group>,
+  Flags<[CC1Option]>, HelpText<"Use DWARF style exceptions">;
 def fsjlj_exceptions : Flag<["-"], "fsjlj-exceptions">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Use SjLj style exceptions">;
+def fseh_exceptions : Flag<["-"], "fseh-exceptions">, Group<f_Group>,
+  Flags<[CC1Option]>, HelpText<"Use SEH style exceptions">;
 def fexcess_precision_EQ : Joined<["-"], "fexcess-precision=">,
     Group<clang_ignored_gcc_optimization_f_Group>;
 def : Flag<["-"], "fexpensive-optimizations">, Group<clang_ignored_gcc_optimization_f_Group>;
 def : Flag<["-"], "fno-expensive-optimizations">, Group<clang_ignored_gcc_optimization_f_Group>;
 def fextdirs_EQ : Joined<["-"], "fextdirs=">, Group<f_Group>;
 def : Flag<["-"], "fdefer-pop">, Group<clang_ignored_gcc_optimization_f_Group>;
 def : Flag<["-"], "fno-defer-pop">, Group<clang_ignored_gcc_optimization_f_Group>;
 def : Flag<["-"], "fextended-identifiers">, Group<clang_ignored_f_Group>;

include/clang/Driver/ToolChain.h

virtual llvm::DebuggerKind getDefaultDebuggerTuning() const {
     return llvm::DebuggerKind::GDB;
   }
 
   /// UseSjLjExceptions - Does this tool chain use SjLj exceptions.
   virtual bool UseSjLjExceptions(const llvm::opt::ArgList &Args) const {
     return false;
   }
 
+  /// UseSEHExceptions - Does this tool chain use SEH exceptions.
+  virtual bool UseSEHExceptions(const llvm::opt::ArgList &Args) const {
+    return getTriple().isOSWindows() && getArch() == llvm::Triple::x86_64;
+  }
+
   /// SupportsEmbeddedBitcode - Does this tool chain support embedded bitcode.
   virtual bool SupportsEmbeddedBitcode() const {
     return false;
   }
 
   /// getThreadModel() - Which thread model does this target use?
   virtual std::string getThreadModel() const { return "posix"; }
 

lib/Basic/Targets/X86.h

public:
   }
 
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override {
     WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
     DefineStd(Builder, "WIN64", Opts);
     Builder.defineMacro("__MINGW64__");
     addMinGWDefines(Opts, Builder);
-
-    // GCC defines this macro when it is using __gxx_personality_seh0.
-    if (!Opts.SjLjExceptions)
-      Builder.defineMacro("__SEH__");
   }
 };
 
 // x86-64 Cygwin target
 class LLVM_LIBRARY_VISIBILITY CygwinX86_64TargetInfo : public X86_64TargetInfo {
 public:
   CygwinX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : X86_64TargetInfo(Triple, Opts) {
     this->WCharType = TargetInfo::UnsignedShort;
     TLSSupported = false;
   }
 
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override {
     X86_64TargetInfo::getTargetDefines(Opts, Builder);
     Builder.defineMacro("__x86_64__");
     Builder.defineMacro("__CYGWIN__");
     Builder.defineMacro("__CYGWIN64__");
     addCygMingDefines(Opts, Builder);
     DefineStd(Builder, "unix", Opts);
     if (Opts.CPlusPlus)
       Builder.defineMacro("_GNU_SOURCE");
-
-    // GCC defines this macro when it is using __gxx_personality_seh0.
-    if (!Opts.SjLjExceptions)
-      Builder.defineMacro("__SEH__");
   }
 };
 
 class LLVM_LIBRARY_VISIBILITY DarwinX86_64TargetInfo
     : public DarwinTargetInfo<X86_64TargetInfo> {
 public:
   DarwinX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : DarwinTargetInfo<X86_64TargetInfo>(Triple, Opts) {

lib/CodeGen/BackendUtil.cpp

static void initTargetOptions(llvm::TargetOptions &Options,
   Options.CompressDebugSections = CodeGenOpts.getCompressDebugSections();
   Options.RelaxELFRelocations = CodeGenOpts.RelaxELFRelocations;
 
   // Set EABI version.
   Options.EABIVersion = TargetOpts.EABIVersion;
 
   if (LangOpts.SjLjExceptions)
     Options.ExceptionModel = llvm::ExceptionHandling::SjLj;
+  if (LangOpts.SEHExceptions)
+    Options.ExceptionModel = llvm::ExceptionHandling::WinEH;
+  if (LangOpts.DWARFExceptions)
+    Options.ExceptionModel = llvm::ExceptionHandling::DwarfCFI;
 
   Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath;
   Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath;
   Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
   Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath;
   Options.StackAlignmentOverride = CodeGenOpts.StackAlignment;
   Options.FunctionSections = CodeGenOpts.FunctionSections;
   Options.DataSections = CodeGenOpts.DataSections;

lib/CodeGen/CGException.cpp

 EHPersonality::GNUstep_ObjC = { "__gnustep_objc_personality_v0", nullptr };
 const EHPersonality
 EHPersonality::MSVC_except_handler = { "_except_handler3", nullptr };
 const EHPersonality
 EHPersonality::MSVC_C_specific_handler = { "__C_specific_handler", nullptr };
 const EHPersonality
 EHPersonality::MSVC_CxxFrameHandler3 = { "__CxxFrameHandler3", nullptr };
 
-/// On Win64, use libgcc's SEH personality function. We fall back to dwarf on
-/// other platforms, unless the user asked for SjLj exceptions.
-static bool useLibGCCSEHPersonality(const llvm::Triple &T) {
-  return T.isOSWindows() && T.getArch() == llvm::Triple::x86_64;
-}
-
 static const EHPersonality &getCPersonality(const llvm::Triple &T,
                                             const LangOptions &L) {
   if (L.SjLjExceptions)
     return EHPersonality::GNU_C_SJLJ;
-  else if (useLibGCCSEHPersonality(T))
+  if (L.SEHExceptions)
     return EHPersonality::GNU_C_SEH;
   return EHPersonality::GNU_C;
 }
 
 static const EHPersonality &getObjCPersonality(const llvm::Triple &T,
                                                const LangOptions &L) {
   switch (L.ObjCRuntime.getKind()) {
   case ObjCRuntime::FragileMacOSX:
     return getCPersonality(T, L);
   case ObjCRuntime::MacOSX:
   case ObjCRuntime::iOS:
   case ObjCRuntime::WatchOS:
     return EHPersonality::NeXT_ObjC;
   case ObjCRuntime::GNUstep:
     if (L.ObjCRuntime.getVersion() >= VersionTuple(1, 7))
       return EHPersonality::GNUstep_ObjC;
     // fallthrough
   case ObjCRuntime::GCC:
   case ObjCRuntime::ObjFW:
     if (L.SjLjExceptions)
       return EHPersonality::GNU_ObjC_SJLJ;
-    else if (useLibGCCSEHPersonality(T))
+    if (L.SEHExceptions)
       return EHPersonality::GNU_ObjC_SEH;
     return EHPersonality::GNU_ObjC;
   }
   llvm_unreachable("bad runtime kind");
 }
 
 static const EHPersonality &getCXXPersonality(const llvm::Triple &T,
                                               const LangOptions &L) {
   if (L.SjLjExceptions)
     return EHPersonality::GNU_CPlusPlus_SJLJ;
-  else if (useLibGCCSEHPersonality(T))
+  if (L.SEHExceptions)
     return EHPersonality::GNU_CPlusPlus_SEH;
   return EHPersonality::GNU_CPlusPlus;
 }
 
 /// Determines the personality function to use when both C++
 /// and Objective-C exceptions are being caught.
 static const EHPersonality &getObjCXXPersonality(const llvm::Triple &T,
                                                  const LangOptions &L) {
if (FD && FD->usesSEHTry())
     return getSEHPersonalityMSVC(T);
 
   // Try to pick a personality function that is compatible with MSVC if we're
   // not compiling Obj-C. Obj-C users better have an Obj-C runtime that supports
   // the GCC-style personality function.
   if (T.isWindowsMSVCEnvironment() && !L.ObjC1) {
     if (L.SjLjExceptions)
       return EHPersonality::GNU_CPlusPlus_SJLJ;
+    if (L.SEHExceptions)
+      return EHPersonality::GNU_CPlusPlus_SEH;
+    if (L.DWARFExceptions)
+      return EHPersonality::GNU_CPlusPlus;
     else
       return EHPersonality::MSVC_CxxFrameHandler3;
   }
 
   if (L.CPlusPlus && L.ObjC1)
     return getObjCXXPersonality(T, L);
   else if (L.CPlusPlus)
     return getCXXPersonality(T, L);
void CodeGenModule::SimplifyPersonality() {
 
   assert(std::strcmp(ObjCXX.PersonalityFn, CXX.PersonalityFn) != 0 &&
          "Different EHPersonalities using the same personality function.");
 
   llvm::Function *Fn = getModule().getFunction(ObjCXX.PersonalityFn);
 
   // Nothing to do if it's unused.
   if (!Fn || Fn->use_empty()) return;
-  
   // Can't do the optimization if it has non-C++ uses.
   if (!PersonalityHasOnlyCXXUses(Fn)) return;
 
   // Create the C++ personality function and kill off the old
   // function.
   llvm::Constant *CXXFn = getPersonalityFn(*this, CXX);
 
   // This can happen if the user is screwing with us.
void CodeGenFunction::EmitCXXThrowExpr(const CXXThrowExpr *E,
   // to leave ourselves at a valid insertion point.
   if (KeepInsertionPoint)
     EmitBlock(createBasicBlock("throw.cont"));
 }
 
 void CodeGenFunction::EmitStartEHSpec(const Decl *D) {
   if (!CGM.getLangOpts().CXXExceptions)
     return;
-  
   const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D);
   if (!FD) {
     // Check if CapturedDecl is nothrow and create terminate scope for it.
     if (const CapturedDecl* CD = dyn_cast_or_null<CapturedDecl>(D)) {
       if (CD->isNothrow())
         EHStack.pushTerminate();
     }
     return;

lib/Driver/ToolChains/Clang.cpp

if (Args.hasFlag(options::OPT_fapplication_extension,
                    options::OPT_fno_application_extension, false))
     CmdArgs.push_back("-fapplication-extension");
 
   // Handle GCC-style exception args.
   if (!C.getDriver().IsCLMode())
     addExceptionArgs(Args, InputType, getToolChain(), KernelOrKext, Runtime,
                      CmdArgs);
 
-  if (Args.hasArg(options::OPT_fsjlj_exceptions) ||
-      getToolChain().UseSjLjExceptions(Args))
+  // Handle exception personalities
+  Arg *A = Args.getLastArg(options::OPT_fsjlj_exceptions,
+                           options::OPT_fseh_exceptions,
+                           options::OPT_fdwarf_exceptions);
+  if (A) {
+    const Option &Opt = A->getOption();
+    if (Opt.matches(options::OPT_fsjlj_exceptions))
+      CmdArgs.push_back("-fsjlj-exceptions");
+    if (Opt.matches(options::OPT_fseh_exceptions))
+      CmdArgs.push_back("-fseh-exceptions");
+    if (Opt.matches(options::OPT_fdwarf_exceptions))
+      CmdArgs.push_back("-fdwarf-exceptions");
+  } else if (getToolChain().UseSjLjExceptions(Args))
       CmdArgs.push_back("-fsjlj-exceptions");
+    else if (getToolChain().UseSEHExceptions(Args))
+      CmdArgs.push_back("-fseh-exceptions");
 
   // C++ "sane" operator new.
   if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
                     options::OPT_fno_assume_sane_operator_new))
     CmdArgs.push_back("-fno-assume-sane-operator-new");
 
   // -frelaxed-template-template-args is off by default, as it is a severe
   // breaking change until a corresponding change to template partial ordering

lib/Driver/ToolChains/MinGW.h

public:
   MinGW(const Driver &D, const llvm::Triple &Triple,
         const llvm::opt::ArgList &Args);
 
   bool IsIntegratedAssemblerDefault() const override;
   bool IsUnwindTablesDefault(const llvm::opt::ArgList &Args) const override;
   bool isPICDefault() const override;
   bool isPIEDefault() const override;
   bool isPICDefaultForced() const override;
-  bool UseSEHExceptions() const;
 
   void
   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                             llvm::opt::ArgStringList &CC1Args) const override;
   void AddClangCXXStdlibIncludeArgs(
       const llvm::opt::ArgList &DriverArgs,
       llvm::opt::ArgStringList &CC1Args) const override;
 

lib/Driver/ToolChains/MinGW.cpp

 }
 
 bool toolchains::MinGW::isPIEDefault() const { return false; }
 
 bool toolchains::MinGW::isPICDefaultForced() const {
   return getArch() == llvm::Triple::x86_64;
 }
 
-bool toolchains::MinGW::UseSEHExceptions() const {
-  return getArch() == llvm::Triple::x86_64;
-}
-
 void toolchains::MinGW::AddCudaIncludeArgs(const ArgList &DriverArgs,
                                            ArgStringList &CC1Args) const {
   CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);
 }
 
 void toolchains::MinGW::printVerboseInfo(raw_ostream &OS) const {
   CudaInstallation.print(OS);
 }

lib/Frontend/CompilerInvocation.cpp

Opts.ConstStrings = Args.hasFlag(OPT_fconst_strings, OPT_fno_const_strings,
                                    Opts.ConstStrings);
   if (Args.hasArg(OPT_fno_lax_vector_conversions))
     Opts.LaxVectorConversions = 0;
   if (Args.hasArg(OPT_fno_threadsafe_statics))
     Opts.ThreadsafeStatics = 0;
   Opts.Exceptions = Args.hasArg(OPT_fexceptions);
   Opts.ObjCExceptions = Args.hasArg(OPT_fobjc_exceptions);
   Opts.CXXExceptions = Args.hasArg(OPT_fcxx_exceptions);
-  Opts.SjLjExceptions = Args.hasArg(OPT_fsjlj_exceptions);
+
+  // Handle exception personalities
+  Arg *A = Args.getLastArg(options::OPT_fsjlj_exceptions,
+                           options::OPT_fseh_exceptions,
+                           options::OPT_fdwarf_exceptions);
+  if (A) {
+    const Option &Opt = A->getOption();
+    Opts.SjLjExceptions = Opt.matches(options::OPT_fsjlj_exceptions);
+    Opts.SEHExceptions = Opt.matches(options::OPT_fseh_exceptions);
+    Opts.DWARFExceptions = Opt.matches(options::OPT_fdwarf_exceptions);
+  }
+
   Opts.ExternCNoUnwind = Args.hasArg(OPT_fexternc_nounwind);
   Opts.TraditionalCPP = Args.hasArg(OPT_traditional_cpp);
 
   Opts.RTTI = Opts.CPlusPlus && !Args.hasArg(OPT_fno_rtti);
   Opts.RTTIData = Opts.RTTI && !Args.hasArg(OPT_fno_rtti_data);
   Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
     && Opts.OpenCLVersion >= 200);
   Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional);

lib/Frontend/InitPreprocessor.cpp

#undef TOSTR2
   }
 
   if (!LangOpts.MSVCCompat && LangOpts.Exceptions)
     Builder.defineMacro("__EXCEPTIONS");
   if (!LangOpts.MSVCCompat && LangOpts.RTTI)
     Builder.defineMacro("__GXX_RTTI");
   if (LangOpts.SjLjExceptions)
     Builder.defineMacro("__USING_SJLJ_EXCEPTIONS__");
+  if (LangOpts.SEHExceptions)
+    Builder.defineMacro("__SEH__");
 
   if (LangOpts.Deprecated)
     Builder.defineMacro("__DEPRECATED");
 
   if (!LangOpts.MSVCCompat && LangOpts.CPlusPlus) {
     Builder.defineMacro("__GNUG__", "4");
     Builder.defineMacro("__GXX_WEAK__");
     Builder.defineMacro("__private_extern__", "extern");
   }
 

test/CodeGenCXX/mingw-w64-exceptions.c

+// RUN: %clang -target x86_64-windows-gnu -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SEH
+// RUN: %clang -target i686-windows-gnu -c %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DWARF
+
+// RUN: %clang -target x86_64-windows-gnu -fsjlj-exceptions -c %s -### 2>&1 | \
+// RUN: FileCheck %s --check-prefix=CHECK-SJLJ
+
+// RUN: %clang -target x86_64-windows-gnu -fdwarf-exceptions -c %s -### 2>&1 | \
+// RUN: FileCheck %s --check-prefix=CHECK-DWARF
+
+// RUN: %clang -target x86_64-windows-gnu -fsjlj-exceptions -fseh-exceptions -c %s -### 2>&1 | \
+// RUN: FileCheck %s --check-prefix=CHECK-SEH
+
+// RUN: %clang -target x86_64-windows-gnu -fseh-exceptions -fsjlj-exceptions -c %s -### 2>&1 | \
+// RUN: FileCheck %s --check-prefix=CHECK-SJLJ
+
+// RUN: %clang -target x86_64-windows-gnu -fseh-exceptions -fdwarf-exceptions -c %s -### 2>&1 | \
+// RUN: FileCheck %s --check-prefix=CHECK-DWARF
+
+// CHECK-SEH: "-fseh-exceptions"
+// CHECK-SJLJ: "-fsjlj-exceptions"
+// CHECK-DWARF-NOT: "-fsjlj-exceptions"
+// CHECK-DWARF-NOT: "-fseh-exceptions"

test/CodeGenCXX/mingw-w64-seh-exceptions.cpp

-// RUN: %clang_cc1 %s -fexceptions -emit-llvm -triple x86_64-w64-windows-gnu -o - | FileCheck %s --check-prefix=X64
-// RUN: %clang_cc1 %s -fexceptions -emit-llvm -triple i686-w64-windows-gnu -o - | FileCheck %s --check-prefix=X86
+// RUN: %clang_cc1 %s -fexceptions -fseh-exceptions -emit-llvm -triple x86_64-w64-windows-gnu -o - | FileCheck %s --check-prefix=X64
+// RUN: %clang_cc1 %s -fexceptions -fdwarf-exceptions -emit-llvm -triple i686-w64-windows-gnu -o - | FileCheck %s --check-prefix=X86
 
 extern "C" void foo();
 extern "C" void bar();
 
 struct Cleanup {
   ~Cleanup() {
     bar();
   }