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 ↗

(On Diff #121832)

"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 ↗

(On Diff #121832)

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

684 ↗

(On Diff #123486)

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

684 ↗

(On Diff #123486)

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

684 ↗

(On Diff #123486)

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

686 ↗

(On Diff #123758)

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

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

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.

cfe/trunk/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>
 

cfe/trunk/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, "SEH .xdata 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")

cfe/trunk/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>;

cfe/trunk/include/clang/Driver/ToolChain.h

public:
   // i.e. a value of 'true' does not imply that debugging is wanted.
   virtual bool GetDefaultStandaloneDebug() const { return false; }
 
   // Return the default debugger "tuning."
   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;
-  }
+  /// GetExceptionModel - Return the tool chain exception model.
+  virtual llvm::ExceptionHandling
+  GetExceptionModel(const llvm::opt::ArgList &Args) const;
 
   /// 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"; }

cfe/trunk/lib/Basic/Targets/ARM.cpp

MinGWARMTargetInfo::MinGWARMTargetInfo(const llvm::Triple &Triple,
     : WindowsARMTargetInfo(Triple, Opts) {
   TheCXXABI.set(TargetCXXABI::GenericARM);
 }
 
 void MinGWARMTargetInfo::getTargetDefines(const LangOptions &Opts,
                                           MacroBuilder &Builder) const {
   WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
   Builder.defineMacro("_ARM_");
-  Builder.defineMacro("__ARM_DWARF_EH__");
 }
 
 CygwinARMTargetInfo::CygwinARMTargetInfo(const llvm::Triple &Triple,
                                          const TargetOptions &Opts)
     : ARMleTargetInfo(Triple, Opts) {
   this->WCharType = TargetInfo::UnsignedShort;
   TLSSupported = false;
   DoubleAlign = LongLongAlign = 64;

cfe/trunk/lib/Basic/Targets/OSTargets.h

protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     // NetBSD defines; list based off of gcc output
     Builder.defineMacro("__NetBSD__");
     Builder.defineMacro("__unix__");
     Builder.defineMacro("__ELF__");
     if (Opts.POSIXThreads)
       Builder.defineMacro("_REENTRANT");
-
-    switch (Triple.getArch()) {
-    default:
-      break;
-    case llvm::Triple::arm:
-    case llvm::Triple::armeb:
-    case llvm::Triple::thumb:
-    case llvm::Triple::thumbeb:
-      Builder.defineMacro("__ARM_DWARF_EH__");
-      break;
-    }
   }
 
 public:
   NetBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : OSTargetInfo<Target>(Triple, Opts) {
     this->MCountName = "_mcount";
   }
 };

cfe/trunk/lib/Basic/Targets/OSTargets.cpp

if (Triple.isiOS()) {
     }
     Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
   }
 
   // Tell users about the kernel if there is one.
   if (Triple.isOSDarwin())
     Builder.defineMacro("__MACH__");
 
-  // The Watch ABI uses Dwarf EH.
-  if (Triple.isWatchABI())
-    Builder.defineMacro("__ARM_DWARF_EH__");
-
   PlatformMinVersion = VersionTuple(Maj, Min, Rev);
 }
 } // namespace targets
 } // namespace clang

cfe/trunk/lib/Basic/Targets/X86.h

public:
   MinGWX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : WindowsX86_64TargetInfo(Triple, Opts) {
     // Mingw64 rounds long double size and alignment up to 16 bytes, but sticks
     // with x86 FP ops. Weird.
     LongDoubleWidth = LongDoubleAlign = 128;
     LongDoubleFormat = &llvm::APFloat::x87DoubleExtended();
     HasFloat128 = true;
   }
-
-  void getTargetDefines(const LangOptions &Opts,
-                        MacroBuilder &Builder) const override {
-    WindowsX86_64TargetInfo::getTargetDefines(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) {

cfe/trunk/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;

cfe/trunk/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);

cfe/trunk/lib/Driver/ToolChain.cpp

 #include "clang/Driver/XRayArgs.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
+#include "llvm/MC/MCAsmInfo.h"
+#include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/Support/TargetParser.h"
 #include "llvm/Support/TargetRegistry.h"
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm;
 using namespace llvm::opt;
bool ToolChain::isCrossCompiling() const {
   }
 }
 
 ObjCRuntime ToolChain::getDefaultObjCRuntime(bool isNonFragile) const {
   return ObjCRuntime(isNonFragile ? ObjCRuntime::GNUstep : ObjCRuntime::GCC,
                      VersionTuple());
 }
 
+llvm::ExceptionHandling
+ToolChain::GetExceptionModel(const llvm::opt::ArgList &Args) const {
+  if (Triple.isOSWindows())
+    return llvm::ExceptionHandling::WinEH;
+  return llvm::ExceptionHandling::None;
+}
+
 bool ToolChain::isThreadModelSupported(const StringRef Model) const {
   if (Model == "single") {
     // FIXME: 'single' is only supported on ARM and WebAssembly so far.
     return Triple.getArch() == llvm::Triple::arm ||
            Triple.getArch() == llvm::Triple::armeb ||
            Triple.getArch() == llvm::Triple::thumb ||
            Triple.getArch() == llvm::Triple::thumbeb ||
            Triple.getArch() == llvm::Triple::wasm32 ||

cfe/trunk/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 {
+    switch(getToolChain().GetExceptionModel(Args)) {
+      default:
+        break;
+      case llvm::ExceptionHandling::DwarfCFI:
+        CmdArgs.push_back("-fdwarf-exceptions");
+        break;
+      case llvm::ExceptionHandling::SjLj:
         CmdArgs.push_back("-fsjlj-exceptions");
+        break;
+      case llvm::ExceptionHandling::WinEH:
+        CmdArgs.push_back("-fseh-exceptions");
+        break;
+    }
+  }
 
   // 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

cfe/trunk/lib/Driver/ToolChains/Darwin.h

public:
   bool isPICDefault() const override;
   bool isPIEDefault() const override;
   bool isPICDefaultForced() const override;
 
   bool SupportsProfiling() const override;
 
   bool UseDwarfDebugFlags() const override;
 
-  bool UseSjLjExceptions(const llvm::opt::ArgList &Args) const override {
-    return false;
+  llvm::ExceptionHandling
+  GetExceptionModel(const llvm::opt::ArgList &Args) const override {
+    return llvm::ExceptionHandling::None;
   }
 
   /// }
 };
 
 /// Darwin - The base Darwin tool chain.
 class LLVM_LIBRARY_VISIBILITY Darwin : public MachO {
 public:
unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const override {
     else if (isTargetMacOS() && !isMacosxVersionLT(10, 5) && !KernelOrKext)
       return 1;
 
     return 0;
   }
 
   void CheckObjCARC() const override;
 
-  bool UseSjLjExceptions(const llvm::opt::ArgList &Args) const override;
+  llvm::ExceptionHandling GetExceptionModel(
+      const llvm::opt::ArgList &Args) const override;
 
   bool SupportsEmbeddedBitcode() const override;
 
   SanitizerMask getSupportedSanitizers() const override;
 
   void printVerboseInfo(raw_ostream &OS) const override;
 };
 

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

Darwin::TranslateArgs(const DerivedArgList &Args, StringRef BoundArch,
 
   return DAL;
 }
 
 bool MachO::IsUnwindTablesDefault(const ArgList &Args) const {
   // Unwind tables are not emitted if -fno-exceptions is supplied (except when
   // targeting x86_64).
   return getArch() == llvm::Triple::x86_64 ||
-         (!UseSjLjExceptions(Args) &&
+         (GetExceptionModel(Args) != llvm::ExceptionHandling::SjLj &&
           Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
                        true));
 }
 
 bool MachO::UseDwarfDebugFlags() const {
   if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
     return S[0] != '\0';
   return false;
 }
 
-bool Darwin::UseSjLjExceptions(const ArgList &Args) const {
+llvm::ExceptionHandling Darwin::GetExceptionModel(const ArgList &Args) const {
   // Darwin uses SjLj exceptions on ARM.
   if (getTriple().getArch() != llvm::Triple::arm &&
       getTriple().getArch() != llvm::Triple::thumb)
-    return false;
+    return llvm::ExceptionHandling::None;
 
   // Only watchOS uses the new DWARF/Compact unwinding method.
   llvm::Triple Triple(ComputeLLVMTriple(Args));
-  return !Triple.isWatchABI();
+  if(Triple.isWatchABI())
+    return llvm::ExceptionHandling::DwarfCFI;
+
+  return llvm::ExceptionHandling::SjLj;
 }
 
 bool Darwin::SupportsEmbeddedBitcode() const {
   assert(TargetInitialized && "Target not initialized!");
   if (isTargetIPhoneOS() && isIPhoneOSVersionLT(6, 0))
     return false;
   return true;
 }

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

public:
 
   CXXStdlibType GetDefaultCXXStdlibType() const override;
   void addLibStdCxxIncludePaths(
       const llvm::opt::ArgList &DriverArgs,
       llvm::opt::ArgStringList &CC1Args) const override;
   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
                            llvm::opt::ArgStringList &CmdArgs) const override;
 
-  bool UseSjLjExceptions(const llvm::opt::ArgList &Args) const override;
+  llvm::ExceptionHandling GetExceptionModel(
+      const llvm::opt::ArgList &Args) const override;
   bool isPIEDefault() const override;
   SanitizerMask getSupportedSanitizers() const override;
   unsigned GetDefaultDwarfVersion() const override { return 2; }
   // Until dtrace (via CTF) and LLDB can deal with distributed debug info,
   // FreeBSD defaults to standalone/full debug info.
   bool GetDefaultStandaloneDebug() const override { return true; }
 
 protected:

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

 }
 
 Tool *FreeBSD::buildAssembler() const {
   return new tools::freebsd::Assembler(*this);
 }
 
 Tool *FreeBSD::buildLinker() const { return new tools::freebsd::Linker(*this); }
 
-bool FreeBSD::UseSjLjExceptions(const ArgList &Args) const {
+llvm::ExceptionHandling FreeBSD::GetExceptionModel(const ArgList &Args) const {
   // FreeBSD uses SjLj exceptions on ARM oabi.
   switch (getTriple().getEnvironment()) {
+  default:
+    if (getTriple().getArch() == llvm::Triple::arm ||
+        getTriple().getArch() == llvm::Triple::thumb)
+      return llvm::ExceptionHandling::SjLj;
   case llvm::Triple::GNUEABIHF:
   case llvm::Triple::GNUEABI:
   case llvm::Triple::EABI:
-    return false;
-
-  default:
-    return (getTriple().getArch() == llvm::Triple::arm ||
-            getTriple().getArch() == llvm::Triple::thumb);
+    return llvm::ExceptionHandling::None;
   }
 }
 
 bool FreeBSD::HasNativeLLVMSupport() const { return true; }
 
 bool FreeBSD::isPIEDefault() const { return getSanitizerArgs().requiresPIE(); }
 
 SanitizerMask FreeBSD::getSupportedSanitizers() const {

cfe/trunk/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;
+
+  llvm::ExceptionHandling GetExceptionModel(
+      const llvm::opt::ArgList &Args) const override;
 
   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;
 

cfe/trunk/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;
+llvm::ExceptionHandling
+toolchains::MinGW::GetExceptionModel(const ArgList &Args) const {
+  if (getArch() == llvm::Triple::x86_64)
+    return llvm::ExceptionHandling::WinEH;
+  return llvm::ExceptionHandling::DwarfCFI;
 }
 
 void toolchains::MinGW::AddCudaIncludeArgs(const ArgList &DriverArgs,
                                            ArgStringList &CC1Args) const {
   CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);
 }
 
 void toolchains::MinGW::printVerboseInfo(raw_ostream &OS) const {

cfe/trunk/lib/Driver/ToolChains/NetBSD.h

public:
   void addLibStdCxxIncludePaths(
       const llvm::opt::ArgList &DriverArgs,
       llvm::opt::ArgStringList &CC1Args) const override;
 
   bool IsUnwindTablesDefault(const llvm::opt::ArgList &Args) const override {
     return true;
   }
 
+  llvm::ExceptionHandling GetExceptionModel(
+      const llvm::opt::ArgList &Args) const override;
+
   SanitizerMask getSupportedSanitizers() const override;
 
 protected:
   Tool *buildAssembler() const override;
   Tool *buildLinker() const override;
 };
 
 } // end namespace toolchains
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_NETBSD_H

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

 }
 
 void NetBSD::addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
                                       llvm::opt::ArgStringList &CC1Args) const {
   addLibStdCXXIncludePaths(getDriver().SysRoot, "/usr/include/g++", "", "", "",
                            "", DriverArgs, CC1Args);
 }
 
+llvm::ExceptionHandling NetBSD::GetExceptionModel(const ArgList &Args) const {
+  // NetBSD uses Dwarf exceptions on ARM.
+  if (getTriple().getArch() == llvm::Triple::arm ||
+      getTriple().getArch() == llvm::Triple::thumb)
+    return llvm::ExceptionHandling::DwarfCFI;
+  return llvm::ExceptionHandling::None;
+}
+
 SanitizerMask NetBSD::getSupportedSanitizers() const {
   const bool IsX86 = getTriple().getArch() == llvm::Triple::x86;
   const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
   SanitizerMask Res = ToolChain::getSupportedSanitizers();
   if (IsX86 || IsX86_64) {
     Res |= SanitizerKind::Address;
     Res |= SanitizerKind::Function;
     Res |= SanitizerKind::Leak;

cfe/trunk/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);

cfe/trunk/lib/Frontend/InitPreprocessor.cpp

if (LangOpts.Blocks) {
     Builder.defineMacro("__block", "__attribute__((__blocks__(byref)))");
     Builder.defineMacro("__BLOCKS__");
   }
 
   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__");
+  else if (LangOpts.SEHExceptions)
+    Builder.defineMacro("__SEH__");
+  else if (LangOpts.DWARFExceptions &&
+          (TI.getTriple().isThumb() || TI.getTriple().isARM()))
+    Builder.defineMacro("__ARM_DWARF_EH__");
 
   if (LangOpts.Deprecated)
     Builder.defineMacro("__DEPRECATED");
 
   if (!LangOpts.MSVCCompat && LangOpts.CPlusPlus) {
     Builder.defineMacro("__GNUG__", "4");
     Builder.defineMacro("__GXX_WEAK__");
     Builder.defineMacro("__private_extern__", "extern");

cfe/trunk/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"

cfe/trunk/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 -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
 // RUN: %clang_cc1 %s -fexceptions -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();

cfe/trunk/test/Preprocessor/arm-target-features.c

 
 // Test whether predefines are as expected when targeting cortex-a5.
 // RUN: %clang -target armv7 -mcpu=cortex-a5 -x c -E -dM %s -o - | FileCheck -match-full-lines --check-prefix=A5 %s
 // RUN: %clang -target armv7 -mthumb -mcpu=cortex-a5 -x c -E -dM %s -o - | FileCheck -match-full-lines --check-prefix=A5 %s
 // A5:#define __ARM_ARCH 7
 // A5:#define __ARM_ARCH_7A__ 1
 // A5-NOT:#define __ARM_ARCH_EXT_IDIV__
 // A5:#define __ARM_ARCH_PROFILE 'A'
+// A5-NOT:#define __ARM_DWARF_EH__ 1
 // A5-NOT: #define __ARM_FEATURE_DIRECTED_ROUNDING
 // A5:#define __ARM_FEATURE_DSP 1
 // A5-NOT: #define __ARM_FEATURE_NUMERIC_MAXMIN
 // A5:#define __ARM_FP 0xE
 
 // Test whether predefines are as expected when targeting cortex-a7.
 // RUN: %clang -target armv7k -mcpu=cortex-a7 -x c -E -dM %s -o - | FileCheck -match-full-lines --check-prefix=A7 %s
 // RUN: %clang -target armv7k -mthumb -mcpu=cortex-a7 -x c -E -dM %s -o - | FileCheck -match-full-lines --check-prefix=A7 %s
 // A7:#define __ARM_ARCH 7
 // A7:#define __ARM_ARCH_EXT_IDIV__ 1
 // A7:#define __ARM_ARCH_PROFILE 'A'
+// A7-NOT:#define __ARM_DWARF_EH__ 1
 // A7:#define __ARM_FEATURE_DSP 1
 // A7:#define __ARM_FP 0xE
 
 // Test whether predefines are as expected when targeting cortex-a7.
 // RUN: %clang -target x86_64-apple-darwin -arch armv7k -x c -E -dM %s -o - | FileCheck -match-full-lines --check-prefix=ARMV7K %s
 // ARMV7K:#define __ARM_ARCH 7
 // ARMV7K:#define __ARM_ARCH_EXT_IDIV__ 1
 // ARMV7K:#define __ARM_ARCH_PROFILE 'A'

cfe/trunk/test/Preprocessor/init.c

 // AARCH64-DARWIN: #define __WINT_TYPE__ int
 // AARCH64-DARWIN: #define __WINT_WIDTH__ 32
 // AARCH64-DARWIN: #define __aarch64__ 1
 
 // RUN: %clang_cc1 -E -dM -ffreestanding -triple=thumbv7-windows-msvc < /dev/null | FileCheck -match-full-lines -check-prefix ARM-MSVC %s
 //
 // ARM-MSVC: #define _M_ARM_NT 1
 // ARM-MSVC: #define _WIN32 1
+// ARM-MSVC-NOT:#define __ARM_DWARF_EH__ 1
 
 // RUN: %clang_cc1 -E -dM -ffreestanding -triple=aarch64-windows-msvc < /dev/null | FileCheck -match-full-lines -check-prefix AARCH64-MSVC %s
 //
 // AARCH64-MSVC: #define _INTEGRAL_MAX_BITS 64
 // AARCH64-MSVC-NOT: #define _LP64 1
 // AARCH64-MSVC: #define _M_ARM64 1
 // AARCH64-MSVC: #define _WIN32 1
 // AARCH64-MSVC: #define _WIN64 1