Driver: hoist the `wchar_t` handling to the driver

[compnerd]

Summary

Move the logic for determining the wchar_t type information into the
driver. Rather than passing the single bit of information of
-fshort-wchar indicate to the frontend the desired type of wchar_t
through a new -cc1 option of -fwchar-type and indicate the
signedness through -f{,no-}signed-wchar. This replicates the current
logic which was spread throughout Basic into the
RenderCharacterOptions.

Most of the changes to the tests are to ensure that the frontend uses
the correct type. Add a new test set under test/Driver/wchar_t.c to
ensure that we calculate the proper types for the various cases.

[rnk]

I do remember recommending this approach over IRC, but I thought we concluded that we should leave all the defaults in lib/Basic/Targets/ and make the -cc1 -fwchar-type= and -f[no-]signed-wchar overrides that affected all targets equally. That would avoid the need for these test updates, anyway.

[compnerd]

We could leave the defaults there as they stand, and only have the new flags alter the default. However, it seems that just paying the cost of adjusting the tests once isn't too bad. To me, it seems that having one instance of the horrible logic for determining the type of wchar_t is better than having two copies which can diverge slightly. My understanding was that we determined that it was better to just pay this test adjustment cost, since it would treat all the targets the same.

[rnk]

lib/CodeGen/CodeGenModule.cpp

477

@MatzeB ptal

lib/Driver/ToolChains/Clang.cpp

2659

This target detection logic is insanely complicated, and I'm not convinced it's simpler than the Basic/Targets/ delegation strategy.

I can go either way on putting this info in the Driver or Basic, but this code needs to be simpler. Surely a switch could help here?

[compnerd]

lib/Driver/ToolChains/Clang.cpp

2659

I like the idea of the switch, I'll try to convert this. In my defense, this was trying to be a translation of the original conditions in Basic. Doesn't mean that I like this or don't want this to converted into something saner.

If we put this into Basic, we get back the 3-bits of information ({char, short, int} * {signed, unsigned}) into 1-bit :-p. This was a pretty painful change, but I think that it does result in a simpler flow for the frontend.

[compnerd]

Try to clarify the logic for APCS ABI.

[MatzeB]

lib/CodeGen/CodeGenModule.cpp

477

Can you find a new place for this assert()? Please do not just remove it!

For the backstory: Unfortunately I had to duplicate the wchar decision logic inside llvm (TargetLibraryInfoImpl::getTargetWCharSize() for cases where we just have the target triple available but need to know the size of wchar_t using library function. This means the logic in LLVM needs to be updated when support for new platforms is added but for people adding platform support it will not be obvious that they have the change LLVM/TargetLibraryInfo as well unless an assert() point them to there being a mismatch.

[compnerd]

lib/CodeGen/CodeGenModule.cpp

477

Sure, I'll try to see if I can find a suitable place or adjustment of it. However, one thing to note is that the frontend does actually embed that into the IR metadata ("wchar_size").

[compnerd]

lib/CodeGen/CodeGenModule.cpp

477

I think that if we try to retain this assertion, we need to update all the tests to ensure that they pass the arguments for selecting the wchar_t type. The entire problem is that the backend view of this cannot correlate with what the user specified without passing it back to it. The "wchar_size" metadata does exactly that. Using that to perform the validation for the library function call.

[MatzeB]

lib/CodeGen/CodeGenModule.cpp

477

This has been resolved with r314187 that made the assertion obsolete.

[compnerd]

Moves the logic back into Basic. The flags are now optional, but controlled by the driver. The test adjustments are to map the old -fshort-wchar to -fwchar-type=short -fno-signed-wchar for the most part, there is one case where we were checking that we were passing -fshort-wchar through to the frontend, which we no longer do.

[rnk]

lib/Basic/TargetInfo.cpp

29

How is this better than what we had before? It's totally inconsistent with our existing strategy for figuring out type widths and sizes. Our current approach can be extended for new targets, this requires modifying shared TargetInfo code. This refactoring *should* be NFC anyway, so if we did want to do it, we'd want to split it out.

[compnerd]

lib/Basic/TargetInfo.cpp

29

The previous thing was split across and was fairly difficult to identify what was going on. I tend to think that this makes it easier to identify what is going on. However, if you have a strong opinion on this, Im willing to switch it back (though, possibly retain some of the adjustments to make it easier to follow).

[rnk]

lib/Basic/TargetInfo.cpp

29

I do, I want to see the minimal functional change. It'll make it easier to spot awkward places where we duplicate logic.

[compnerd]

Split the defaulting back to all the various targets.

[rnk]

Looks good with nits

lib/Basic/Targets/AArch64.cpp

47–51

I felt like this was clearer the way it was before, and we're already checking for the BSDs above.

160–161

This is correct because we compute macros after we apply the flag override, right?

[compnerd]

lib/Basic/Targets/AArch64.cpp

47–51

Okay, I'll swap it back.

160–161

Correct :-)

[compnerd]

SVN r315126

include/clang/Basic/DiagnosticFrontendKinds.td

def warn_fe_unable_to_open_stats_file : Warning<
     "unable to open statistics output file '%0': '%1'">,
     InGroup<DiagGroup<"unable-to-open-stats-file">>;
 def err_fe_no_pch_in_dir : Error<
     "no suitable precompiled header file found in directory '%0'">;
 def err_fe_action_not_available : Error<
     "action %0 not compiled in">;
 def err_fe_invalid_alignment : Error<
     "invalid value '%1' in '%0'; alignment must be a power of 2">;
+def err_fe_invalid_wchar_type
+    : Error<"invalid wchar_t type '%0'; must be one of 'char', 'short', 'int'">;
 
 def warn_fe_serialized_diag_merge_failure : Warning<
     "unable to merge a subprocess's serialized diagnostics">,
     InGroup<SerializedDiagnostics>;
 def warn_fe_serialized_diag_failure : Warning<
     "unable to open file %0 for serializing diagnostics (%1)">,
     InGroup<SerializedDiagnostics>;
 

include/clang/Basic/LangOptions.def

 COMPATIBLE_LANGOPT(FastMath          , 1, 0, "fast FP math optimizations, and __FAST_MATH__ predefined macro")
 COMPATIBLE_LANGOPT(FiniteMathOnly    , 1, 0, "__FINITE_MATH_ONLY__ predefined macro")
 COMPATIBLE_LANGOPT(UnsafeFPMath      , 1, 0, "Unsafe Floating Point Math")
 
 BENIGN_LANGOPT(ObjCGCBitmapPrint , 1, 0, "printing of GC's bitmap layout for __weak/__strong ivars")
 
 BENIGN_LANGOPT(AccessControl     , 1, 1, "C++ access control")
 LANGOPT(CharIsSigned      , 1, 1, "signed char")
-LANGOPT(ShortWChar        , 1, 0, "unsigned short wchar_t")
+LANGOPT(WCharSize         , 4, 0, "width of wchar_t")
+LANGOPT(WCharIsSigned        , 1, 0, "signed or unsigned wchar_t")
 ENUM_LANGOPT(MSPointerToMemberRepresentationMethod, PragmaMSPointersToMembersKind, 2, PPTMK_BestCase, "member-pointer representation method")
 ENUM_LANGOPT(DefaultCallingConv, DefaultCallingConvention, 3, DCC_None, "default calling convention")
 
 LANGOPT(ShortEnums        , 1, 0, "short enum types")
 
 LANGOPT(OpenCL            , 1, 0, "OpenCL")
 LANGOPT(OpenCLVersion     , 32, 0, "OpenCL version")
 LANGOPT(NativeHalfType    , 1, 0, "Native half type support")

include/clang/Driver/CC1Options.td

 def fallow_half_arguments_and_returns : Flag<["-"], "fallow-half-arguments-and-returns">,
   HelpText<"Allow function arguments and returns of type half">;
 def fdefault_calling_conv_EQ : Joined<["-"], "fdefault-calling-conv=">,
   HelpText<"Set default MS calling convention">, Values<"cdecl,fastcall,stdcall,vectorcall">;
 def finclude_default_header : Flag<["-"], "finclude-default-header">,
   HelpText<"Include the default header file for OpenCL">;
 def fpreserve_vec3_type : Flag<["-"], "fpreserve-vec3-type">,
   HelpText<"Preserve 3-component vector type">;
+def fwchar_type_EQ : Joined<["-"], "fwchar-type=">,
+  HelpText<"Select underlying type for wchar_t">, Values<"char,short,int">;
+def fsigned_wchar : Flag<["-"], "fsigned-wchar">,
+  HelpText<"Use a signed type for wchar_t">;
+def fno_signed_wchar : Flag<["-"], "fno-signed-wchar">,
+  HelpText<"Use an unsigned type for wchar_t">;
 
 // FIXME: Remove these entirely once functionality/tests have been excised.
 def fobjc_gc_only : Flag<["-"], "fobjc-gc-only">, Group<f_Group>,
   HelpText<"Use GC exclusively for Objective-C related memory management">;
 def fobjc_gc : Flag<["-"], "fobjc-gc">, Group<f_Group>,
   HelpText<"Enable Objective-C garbage collection">;
 
 //===----------------------------------------------------------------------===//

include/clang/Driver/Options.td

 def framework : Separate<["-"], "framework">, Flags<[LinkerInput]>;
 def frandom_seed_EQ : Joined<["-"], "frandom-seed=">, Group<clang_ignored_f_Group>;
 def freg_struct_return : Flag<["-"], "freg-struct-return">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Override the default ABI to return small structs in registers">;
 def frtti : Flag<["-"], "frtti">, Group<f_Group>;
 def : Flag<["-"], "fsched-interblock">, Group<clang_ignored_f_Group>;
 def fshort_enums : Flag<["-"], "fshort-enums">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Allocate to an enum type only as many bytes as it needs for the declared range of possible values">;
-def fshort_wchar : Flag<["-"], "fshort-wchar">, Group<f_Group>, Flags<[CC1Option]>,
+def fshort_wchar : Flag<["-"], "fshort-wchar">, Group<f_Group>,
   HelpText<"Force wchar_t to be a short unsigned int">;
-def fno_short_wchar : Flag<["-"], "fno-short-wchar">, Group<f_Group>, Flags<[CC1Option]>,
+def fno_short_wchar : Flag<["-"], "fno-short-wchar">, Group<f_Group>,
   HelpText<"Force wchar_t to be an unsigned int">;
 def fshow_overloads_EQ : Joined<["-"], "fshow-overloads=">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Which overload candidates to show when overload resolution fails: "
            "best|all; defaults to all">, Values<"best,all">;
 def fshow_column : Flag<["-"], "fshow-column">, Group<f_Group>, Flags<[CC1Option]>;
 def fshow_source_location : Flag<["-"], "fshow-source-location">, Group<f_Group>;
 def fspell_checking : Flag<["-"], "fspell-checking">, Group<f_Group>;
 def fspell_checking_limit_EQ : Joined<["-"], "fspell-checking-limit=">, Group<f_Group>;

lib/Basic/TargetInfo.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include <cstdlib>
 using namespace clang;
 
 static const LangAS::Map DefaultAddrSpaceMap = { 0 };
 
 // TargetInfo Constructor.
 TargetInfo::TargetInfo(const llvm::Triple &T) : TargetOpts(), Triple(T) {
   // Set defaults.  Defaults are set for a 32-bit RISC platform, like PPC or
   // SPARC.  These should be overridden by concrete targets as needed.
   BigEndian = !T.isLittleEndian();
   TLSSupported = true;
   NoAsmVariants = false;
   HasFloat128 = false;
   PointerWidth = PointerAlign = 32;
   BoolWidth = BoolAlign = 8;
   IntWidth = IntAlign = 32;

 
 /// adjust - Set forced language options.
 /// Apply changes to the target information with respect to certain
 /// language options which change the target configuration and adjust
 /// the language based on the target options where applicable.
 void TargetInfo::adjust(LangOptions &Opts) {
   if (Opts.NoBitFieldTypeAlign)
     UseBitFieldTypeAlignment = false;
-  if (Opts.ShortWChar)
-    WCharType = UnsignedShort;
+
+  switch (Opts.WCharSize) {
+  default: llvm_unreachable("invalid wchar_t width");
+  case 0: break;
+  case 1: WCharType = Opts.WCharIsSigned ? SignedChar : UnsignedChar; break;
+  case 2: WCharType = Opts.WCharIsSigned ? SignedShort : UnsignedShort; break;
+  case 4: WCharType = Opts.WCharIsSigned ? SignedInt : UnsignedInt; break;
+  }
+
   if (Opts.AlignDouble) {
     DoubleAlign = LongLongAlign = 64;
     LongDoubleAlign = 64;
   }
 
   if (Opts.OpenCL) {
     // OpenCL C requires specific widths for types, irrespective of
     // what these normally are for the target.

lib/Basic/Targets/AArch64.cpp

 // This file implements AArch64 TargetInfo objects.
 //
 //===----------------------------------------------------------------------===//
 
 #include "AArch64.h"
 #include "clang/Basic/TargetBuiltins.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringExtras.h"
 
 using namespace clang;
 using namespace clang::targets;
 
 const Builtin::Info AArch64TargetInfo::BuiltinInfo[] = {
 #define BUILTIN(ID, TYPE, ATTRS)                                               \
    {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr},
 #include "clang/Basic/BuiltinsNEON.def"
 
 #define BUILTIN(ID, TYPE, ATTRS)                                               \
    {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr},
 #include "clang/Basic/BuiltinsAArch64.def"
 };
 
 AArch64TargetInfo::AArch64TargetInfo(const llvm::Triple &Triple,
                                      const TargetOptions &Opts)
     : TargetInfo(Triple), ABI("aapcs") {
   if (getTriple().getOS() == llvm::Triple::NetBSD ||
       getTriple().getOS() == llvm::Triple::OpenBSD) {
-    WCharType = SignedInt;
-
     // NetBSD apparently prefers consistency across ARM targets to
     // consistency across 64-bit targets.
     Int64Type = SignedLongLong;
     IntMaxType = SignedLongLong;
   } else {
-    WCharType = UnsignedInt;
     Int64Type = SignedLong;
     IntMaxType = SignedLong;
   }
 
   LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
   MaxVectorAlign = 128;
   MaxAtomicInlineWidth = 128;
   MaxAtomicPromoteWidth = 128;
 
   LongDoubleWidth = LongDoubleAlign = SuitableAlign = 128;
   LongDoubleFormat = &llvm::APFloat::IEEEquad();
 
   // Make __builtin_ms_va_list available.
   HasBuiltinMSVaList = true;
 
   // {} in inline assembly are neon specifiers, not assembly variant
   // specifiers.
void AArch64TargetInfo::getTargetDefines(const LangOptions &Opts,
   // PCS specifies this for SysV variants, which is all we support. Other ABIs
   // may choose __ARM_FP16_FORMAT_ALTERNATIVE.
   Builder.defineMacro("__ARM_FP16_FORMAT_IEEE", "1");
   Builder.defineMacro("__ARM_FP16_ARGS", "1");
 
   if (Opts.UnsafeFPMath)
     Builder.defineMacro("__ARM_FP_FAST", "1");
 
-  Builder.defineMacro("__ARM_SIZEOF_WCHAR_T", Opts.ShortWChar ? "2" : "4");
+  Builder.defineMacro("__ARM_SIZEOF_WCHAR_T",
+                      llvm::utostr(Opts.WCharSize ? Opts.WCharSize : 4));
 
   Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM", Opts.ShortEnums ? "1" : "4");
 
   if (FPU & NeonMode) {
     Builder.defineMacro("__ARM_NEON", "1");
     // 64-bit NEON supports half, single and double precision operations.
     Builder.defineMacro("__ARM_NEON_FP", "0xE");
   }
 
   if (FPU & SveMode)
     Builder.defineMacro("__ARM_FEATURE_SVE", "1");
 
   if (CRC)

 }
 
 WindowsARM64TargetInfo::WindowsARM64TargetInfo(const llvm::Triple &Triple,
                                                const TargetOptions &Opts)
     : WindowsTargetInfo<AArch64leTargetInfo>(Triple, Opts), Triple(Triple) {
 
   // This is an LLP64 platform.
   // int:4, long:4, long long:8, long double:8.
-  WCharType = UnsignedShort;
   IntWidth = IntAlign = 32;
   LongWidth = LongAlign = 32;
   DoubleAlign = LongLongAlign = 64;
   LongDoubleWidth = LongDoubleAlign = 64;
   LongDoubleFormat = &llvm::APFloat::IEEEdouble();
   IntMaxType = SignedLongLong;
   Int64Type = SignedLongLong;
   SizeType = UnsignedLongLong;
void MinGWARM64TargetInfo::getTargetDefines(const LangOptions &Opts,
   addMinGWDefines(Opts, Builder);
 }
 
 
 DarwinAArch64TargetInfo::DarwinAArch64TargetInfo(const llvm::Triple &Triple,
                                                  const TargetOptions &Opts)
     : DarwinTargetInfo<AArch64leTargetInfo>(Triple, Opts) {
   Int64Type = SignedLongLong;
-  WCharType = SignedInt;
   UseSignedCharForObjCBool = false;
 
   LongDoubleWidth = LongDoubleAlign = SuitableAlign = 64;
   LongDoubleFormat = &llvm::APFloat::IEEEdouble();
 
   TheCXXABI.set(TargetCXXABI::iOS64);
 }
 

lib/Basic/Targets/ARM.cpp

void ARMTargetInfo::setABIAAPCS() {
   // size_t is unsigned long on MachO-derived environments, NetBSD, and
   // OpenBSD.
   if (T.isOSBinFormatMachO() || T.getOS() == llvm::Triple::NetBSD ||
       T.getOS() == llvm::Triple::OpenBSD)
     SizeType = UnsignedLong;
   else
     SizeType = UnsignedInt;
 
-  switch (T.getOS()) {
-  case llvm::Triple::NetBSD:
-  case llvm::Triple::OpenBSD:
-    WCharType = SignedInt;
-    break;
-  case llvm::Triple::Win32:
-    WCharType = UnsignedShort;
-    break;
-  case llvm::Triple::Linux:
-  default:
-    // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
-    WCharType = UnsignedInt;
-    break;
-  }
-
   UseBitFieldTypeAlignment = true;
 
   ZeroLengthBitfieldBoundary = 0;
 
   // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
   // so set preferred for small types to 32.
   if (T.isOSBinFormatMachO()) {
     resetDataLayout(BigEndian
else
     DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
 
   // size_t is unsigned int on FreeBSD.
   if (T.getOS() == llvm::Triple::FreeBSD)
     SizeType = UnsignedInt;
   else
     SizeType = UnsignedLong;
 
-  // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
-  WCharType = SignedInt;
-
   // Do not respect the alignment of bit-field types when laying out
   // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
   UseBitFieldTypeAlignment = false;
 
   /// gcc forces the alignment to 4 bytes, regardless of the type of the
   /// zero length bitfield.  This corresponds to EMPTY_FIELD_BOUNDARY in
   /// gcc.
   ZeroLengthBitfieldBoundary = 32;
if ((FPU & NeonFPU) && !SoftFloat && ArchVersion >= 7) {
     Builder.defineMacro("__ARM_NEON", "1");
     Builder.defineMacro("__ARM_NEON__");
     // current AArch32 NEON implementations do not support double-precision
     // floating-point even when it is present in VFP.
     Builder.defineMacro("__ARM_NEON_FP",
                         "0x" + llvm::utohexstr(HW_FP & ~HW_FP_DP));
   }
 
-  Builder.defineMacro("__ARM_SIZEOF_WCHAR_T", Opts.ShortWChar ? "2" : "4");
+  Builder.defineMacro("__ARM_SIZEOF_WCHAR_T",
+                      llvm::utostr(Opts.WCharSize ? Opts.WCharSize : 4));
 
   Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM", Opts.ShortEnums ? "1" : "4");
 
   if (ArchVersion >= 6 && CPUAttr != "6M" && CPUAttr != "8M_BASE") {
     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
void ARMbeTargetInfo::getTargetDefines(const LangOptions &Opts,
   Builder.defineMacro("__ARMEB__");
   Builder.defineMacro("__ARM_BIG_ENDIAN");
   ARMTargetInfo::getTargetDefines(Opts, Builder);
 }
 
 WindowsARMTargetInfo::WindowsARMTargetInfo(const llvm::Triple &Triple,
                                            const TargetOptions &Opts)
     : WindowsTargetInfo<ARMleTargetInfo>(Triple, Opts), Triple(Triple) {
-  WCharType = UnsignedShort;
   SizeType = UnsignedInt;
 }
 
 void WindowsARMTargetInfo::getVisualStudioDefines(const LangOptions &Opts,
                                                   MacroBuilder &Builder) const {
   WindowsTargetInfo<ARMleTargetInfo>::getVisualStudioDefines(Opts, Builder);
 
   // FIXME: this is invalid for WindowsCE
void MinGWARMTargetInfo::getTargetDefines(const LangOptions &Opts,
   Builder.defineMacro("_ARM_");
   addMinGWDefines(Opts, Builder);
 }
 
 CygwinARMTargetInfo::CygwinARMTargetInfo(const llvm::Triple &Triple,
                                          const TargetOptions &Opts)
     : ARMleTargetInfo(Triple, Opts) {
   TLSSupported = false;
-  WCharType = UnsignedShort;
   DoubleAlign = LongLongAlign = 64;
   resetDataLayout("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64");
 }
 
 void CygwinARMTargetInfo::getTargetDefines(const LangOptions &Opts,
                                            MacroBuilder &Builder) const {
   ARMleTargetInfo::getTargetDefines(Opts, Builder);
   Builder.defineMacro("_ARM_");

lib/Basic/Targets/AVR.h

AVRTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
     DoubleFormat = &llvm::APFloat::IEEEsingle();
     LongDoubleWidth = 32;
     LongDoubleAlign = 8;
     LongDoubleFormat = &llvm::APFloat::IEEEsingle();
     SizeType = UnsignedInt;
     PtrDiffType = SignedInt;
     IntPtrType = SignedInt;
     Char16Type = UnsignedInt;
-    WCharType = SignedInt;
     WIntType = SignedInt;
     Char32Type = UnsignedLong;
     SigAtomicType = SignedChar;
     resetDataLayout("e-p:16:16:16-i8:8:8-i16:16:16-i32:32:32-i64:64:64"
                     "-f32:32:32-f64:64:64-n8");
   }
 
   void getTargetDefines(const LangOptions &Opts,

lib/Basic/Targets/OSTargets.h

void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
     DefineStd(Builder, "unix", Opts);
     Builder.defineMacro("__ELF__");
     Builder.defineMacro("__ORBIS__");
   }
 
 public:
   PS4OSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : OSTargetInfo<Target>(Triple, Opts) {
-    this->WCharType = this->UnsignedShort;
-
     // On PS4, TLS variable cannot be aligned to more than 32 bytes (256 bits).
     this->MaxTLSAlign = 256;
 
     // On PS4, do not honor explicit bit field alignment,
     // as in "__attribute__((aligned(2))) int b : 1;".
     this->UseExplicitBitFieldAlignment = false;
 
     switch (Triple.getArch()) {
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
     Builder.defineMacro("_LARGEFILE64_SOURCE");
     Builder.defineMacro("__EXTENSIONS__");
     Builder.defineMacro("_REENTRANT");
   }
 
 public:
   SolarisTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : OSTargetInfo<Target>(Triple, Opts) {
-    this->WCharType = this->SignedInt;
     // FIXME: WIntType should be SignedLong
   }
 };
 
 // Windows target
 template <typename Target>
 class LLVM_LIBRARY_VISIBILITY WindowsTargetInfo : public OSTargetInfo<Target> {
 protected:

lib/Basic/Targets/X86.h

 };
 
 // x86-32 Windows target
 class LLVM_LIBRARY_VISIBILITY WindowsX86_32TargetInfo
     : public WindowsTargetInfo<X86_32TargetInfo> {
 public:
   WindowsX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : WindowsTargetInfo<X86_32TargetInfo>(Triple, Opts) {
-    WCharType = UnsignedShort;
     DoubleAlign = LongLongAlign = 64;
     bool IsWinCOFF =
         getTriple().isOSWindows() && getTriple().isOSBinFormatCOFF();
     resetDataLayout(IsWinCOFF
                         ? "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
                         : "e-m:e-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32");
   }
 
public:
   }
 };
 
 // x86-32 Cygwin target
 class LLVM_LIBRARY_VISIBILITY CygwinX86_32TargetInfo : public X86_32TargetInfo {
 public:
   CygwinX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : X86_32TargetInfo(Triple, Opts) {
-    WCharType = UnsignedShort;
     DoubleAlign = LongLongAlign = 64;
     resetDataLayout("e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32");
   }
 
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override {
     X86_32TargetInfo::getTargetDefines(Opts, Builder);
     Builder.defineMacro("_X86_");

 };
 
 // x86-64 Windows target
 class LLVM_LIBRARY_VISIBILITY WindowsX86_64TargetInfo
     : public WindowsTargetInfo<X86_64TargetInfo> {
 public:
   WindowsX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : WindowsTargetInfo<X86_64TargetInfo>(Triple, Opts) {
-    WCharType = UnsignedShort;
     LongWidth = LongAlign = 32;
     DoubleAlign = LongLongAlign = 64;
     IntMaxType = SignedLongLong;
     Int64Type = SignedLongLong;
     SizeType = UnsignedLongLong;
     PtrDiffType = SignedLongLong;
     IntPtrType = SignedLongLong;
   }

 };
 
 // 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) {
     TLSSupported = false;
-    WCharType = UnsignedShort;
   }
 
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override {
     X86_64TargetInfo::getTargetDefines(Opts, Builder);
     Builder.defineMacro("__x86_64__");
     Builder.defineMacro("__CYGWIN__");
     Builder.defineMacro("__CYGWIN64__");

lib/Basic/Targets/XCore.h

XCoreTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
       : TargetInfo(Triple) {
     NoAsmVariants = true;
     LongLongAlign = 32;
     SuitableAlign = 32;
     DoubleAlign = LongDoubleAlign = 32;
     SizeType = UnsignedInt;
     PtrDiffType = SignedInt;
     IntPtrType = SignedInt;
-    WCharType = UnsignedChar;
     WIntType = UnsignedInt;
     UseZeroLengthBitfieldAlignment = true;
     resetDataLayout("e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32"
                     "-f64:32-a:0:32-n32");
   }
 
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;

lib/CodeGen/CodeGenModule.cpp

if (DebugInfo)
     // parser will drop debug info with a different version number
     // (and warn about it, too).
     getModule().addModuleFlag(llvm::Module::Warning, "Debug Info Version",
                               llvm::DEBUG_METADATA_VERSION);
 
   // Width of wchar_t in bytes
   uint64_t WCharWidth =
       Context.getTypeSizeInChars(Context.getWideCharType()).getQuantity();
-  assert((LangOpts.ShortWChar ||
-          llvm::TargetLibraryInfoImpl::getTargetWCharSize(Target.getTriple()) ==
-              Target.getWCharWidth() / 8) &&
-         "LLVM wchar_t size out of sync");
 
   // We need to record the widths of enums and wchar_t, so that we can generate
   // the correct build attributes in the ARM backend. wchar_size is also used by
   // TargetLibraryInfo.
   getModule().addModuleFlag(llvm::Module::Error, "wchar_size", WCharWidth);
 
   llvm::Triple::ArchType Arch = Context.getTargetInfo().getTriple().getArch();
   if (   Arch == llvm::Triple::arm

lib/Driver/ToolChains/Clang.cpp

     Args.AddLastArg(CmdArgs,
                     options::OPT_fmodules_validate_once_per_build_session);
   }
 
   Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
   Args.AddLastArg(CmdArgs, options::OPT_fmodules_disable_diagnostic_validation);
 }
 
+static void RenderCharacterOptions(const ArgList &Args, const llvm::Triple &T,
+                                   ArgStringList &CmdArgs) {
+  // -fsigned-char is default.
+  if (const Arg *A = Args.getLastArg(options::OPT_fsigned_char,
+                                     options::OPT_fno_signed_char,
+                                     options::OPT_funsigned_char,
+                                     options::OPT_fno_unsigned_char)) {
+    if (A->getOption().matches(options::OPT_funsigned_char) ||
+        A->getOption().matches(options::OPT_fno_signed_char)) {
+      CmdArgs.push_back("-fno-signed-char");
+    }
+  } else if (!isSignedCharDefault(T)) {
+    CmdArgs.push_back("-fno-signed-char");
+  }
+
+  const llvm::Triple::ArchType Arch = T.getArch();
+  const llvm::Triple::OSType OS = T.getOS();
+
+  const bool IsARM = T.isARM() || T.isThumb();
+  const bool IsAArch64 =
+      Arch == llvm::Triple::aarch64 || Arch == llvm::Triple::aarch64_be;
+
+  const bool IsDarwin = T.isOSDarwin();
+  const bool IsWindows = T.isOSWindows();
+  const bool IsNetBSD = OS == llvm::Triple::NetBSD;
+  const bool IsOpenBSD = OS == llvm::Triple::OpenBSD;
+  const bool IsUnknownOS = OS == llvm::Triple::UnknownOS;
+
+  const bool IsEABIEnvironment = T.getEnvironment() == llvm::Triple::EABI;
+  const bool IsGNUEnvironment= T.getEnvironment() == llvm::Triple::GNU;
+
+  const bool IsMachO = T.isOSBinFormatMachO();
+
+  llvm::ARM::ProfileKind ARMProfile = llvm::ARM::ProfileKind::INVALID;
+  if (IsARM) {
+    auto ARMArch = llvm::ARM::parseArch(T.getArchName());
+    auto ARMSubArch = llvm::ARM::getSubArch(ARMArch);
+    ARMProfile = llvm::ARM::parseArchProfile(ARMSubArch);
+  }
+
+  const bool IsAPCSABI =
+      IsARM && (IsGNUEnvironment || IsNetBSD ||
+                (T.isWatchABI() ||
+                 (IsMachO && !(IsEABIEnvironment || IsUnknownOS ||
+                               ARMProfile == llvm::ARM::ProfileKind::M))));
+
+  if (Arch == llvm::Triple::xcore) {
+    CmdArgs.push_back("-fwchar-type=char");
+    CmdArgs.push_back("-fno-signed-wchar");
+  } else if (Args.hasFlag(options::OPT_fshort_wchar,
+                          options::OPT_fno_short_wchar,
+                          IsWindows || OS == llvm::Triple::PS4)) {
+    CmdArgs.push_back("-fwchar-type=short");
+    CmdArgs.push_back("-fno-signed-wchar");
+  } else {
+    CmdArgs.push_back("-fwchar-type=int");
+    // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
+    if ((IsARM && !IsNetBSD && !(IsWindows || IsOpenBSD || IsAPCSABI)) ||
+        (IsAArch64 && !IsDarwin && (IsNetBSD || IsOpenBSD)))
+      CmdArgs.push_back("-fno-signed-wchar");
+    else
+      CmdArgs.push_back("-fsigned-wchar");
+  }
+}
+
 static void RenderObjCOptions(const ToolChain &TC, const Driver &D,
                               const llvm::Triple &T, const ArgList &Args,
                               ObjCRuntime &Runtime, bool InferCovariantReturns,
                               const InputInfo &Input, ArgStringList &CmdArgs) {
   const llvm::Triple::ArchType Arch = TC.getArch();
 
   // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and legacy
   // is the default. Except for deployment target of 10.5, next runtime is

   // second input. All other jobs are expected to have exactly one
   // input.
   bool IsCuda = JA.isOffloading(Action::OFK_Cuda);
   bool IsOpenMPDevice = JA.isDeviceOffloading(Action::OFK_OpenMP);
   assert((IsCuda || (IsOpenMPDevice && Inputs.size() == 2) ||
           Inputs.size() == 1) &&
          "Unable to handle multiple inputs.");
 
+  const llvm::Triple *AuxTriple =
+      IsCuda ? getToolChain().getAuxTriple() : nullptr;
+
   bool IsWindowsGNU = RawTriple.isWindowsGNUEnvironment();
   bool IsWindowsCygnus = RawTriple.isWindowsCygwinEnvironment();
   bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment();
   bool IsIAMCU = RawTriple.isOSIAMCU();
 
   // Adjust IsWindowsXYZ for CUDA compilations.  Even when compiling in device
   // mode (i.e., getToolchain().getTriple() is NVPTX, not Windows), we need to
   // pass Windows-specific flags to cc1.
   if (IsCuda) {
-    const llvm::Triple *AuxTriple = getToolChain().getAuxTriple();
     IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment();
     IsWindowsGNU |= AuxTriple && AuxTriple->isWindowsGNUEnvironment();
     IsWindowsCygnus |= AuxTriple && AuxTriple->isWindowsCygwinEnvironment();
   }
 
   // C++ is not supported for IAMCU.
   if (IsIAMCU && types::isCXX(Input.getType()))
     D.Diag(diag::err_drv_clang_unsupported) << "C++ for IAMCU";

                         RTTIMode == ToolChain::RM_DisabledImplicitly)))
     CmdArgs.push_back("-fno-rtti");
 
   // -fshort-enums=0 is default for all architectures except Hexagon.
   if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
                    getToolChain().getArch() == llvm::Triple::hexagon))
     CmdArgs.push_back("-fshort-enums");
 
-  // -fsigned-char is default.
-  if (Arg *A = Args.getLastArg(
-          options::OPT_fsigned_char, options::OPT_fno_signed_char,
-          options::OPT_funsigned_char, options::OPT_fno_unsigned_char)) {
-    if (A->getOption().matches(options::OPT_funsigned_char) ||
-        A->getOption().matches(options::OPT_fno_signed_char)) {
-      CmdArgs.push_back("-fno-signed-char");
-    }
-  } else if (!isSignedCharDefault(RawTriple)) {
-    CmdArgs.push_back("-fno-signed-char");
-  }
+  RenderCharacterOptions(Args, AuxTriple ? *AuxTriple : RawTriple, CmdArgs);
 
   // -fuse-cxa-atexit is default.
   if (!Args.hasFlag(
           options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
           !RawTriple.isOSWindows() &&
               RawTriple.getOS() != llvm::Triple::Solaris &&
               getToolChain().getArch() != llvm::Triple::hexagon &&
               getToolChain().getArch() != llvm::Triple::xcore &&

   // -fconstant-cfstrings is default, and may be subject to argument translation
   // on Darwin.
   if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
                     options::OPT_fno_constant_cfstrings) ||
       !Args.hasFlag(options::OPT_mconstant_cfstrings,
                     options::OPT_mno_constant_cfstrings))
     CmdArgs.push_back("-fno-constant-cfstrings");
 
-  // -fshort-wchar default varies depending on platform; only
-  // pass if specified.
-  if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
-                               options::OPT_fno_short_wchar))
-    A->render(Args, CmdArgs);
-
   // -fno-pascal-strings is default, only pass non-default.
   if (Args.hasFlag(options::OPT_fpascal_strings,
                    options::OPT_fno_pascal_strings, false))
     CmdArgs.push_back("-fpascal-strings");
 
   // Honor -fpack-struct= and -fpack-struct, if given. Note that
   // -fno-pack-struct doesn't apply to -fpack-struct=.
   if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {

lib/Frontend/CompilerInstance.cpp

void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) {
   // Create the Preprocessor.
   HeaderSearch *HeaderInfo =
       new HeaderSearch(getHeaderSearchOptsPtr(), getSourceManager(),
                        getDiagnostics(), getLangOpts(), &getTarget());
   PP = std::make_shared<Preprocessor>(
       Invocation->getPreprocessorOptsPtr(), getDiagnostics(), getLangOpts(),
       getSourceManager(), getPCMCache(), *HeaderInfo, *this, PTHMgr,
       /*OwnsHeaderSearch=*/true, TUKind);
+  getTarget().adjust(getLangOpts());
   PP->Initialize(getTarget(), getAuxTarget());
 
   // Note that this is different then passing PTHMgr to Preprocessor's ctor.
   // That argument is used as the IdentifierInfoLookup argument to
   // IdentifierTable's ctor.
   if (PTHMgr) {
     PTHMgr->setPreprocessor(&*PP);
     PP->setPTHManager(PTHMgr);

lib/Frontend/CompilerInvocation.cpp

   Opts.ModulesDebugInfo = Args.hasArg(OPT_fmodules_debuginfo);
   Opts.ModulesSearchAll = Opts.Modules &&
     !Args.hasArg(OPT_fno_modules_search_all) &&
     Args.hasArg(OPT_fmodules_search_all);
   Opts.ModulesErrorRecovery = !Args.hasArg(OPT_fno_modules_error_recovery);
   Opts.ImplicitModules = !Args.hasArg(OPT_fno_implicit_modules);
   Opts.CharIsSigned = Opts.OpenCL || !Args.hasArg(OPT_fno_signed_char);
   Opts.WChar = Opts.CPlusPlus && !Args.hasArg(OPT_fno_wchar);
-  Opts.ShortWChar = Args.hasFlag(OPT_fshort_wchar, OPT_fno_short_wchar, false);
+  if (const Arg *A = Args.getLastArg(OPT_fwchar_type_EQ)) {
+    Opts.WCharSize = llvm::StringSwitch<unsigned>(A->getValue())
+                         .Case("char", 1)
+                         .Case("short", 2)
+                         .Case("int", 4)
+                         .Default(0);
+    if (Opts.WCharSize == 0)
+      Diags.Report(diag::err_fe_invalid_wchar_type) << A->getValue();
+  }
+  Opts.WCharIsSigned = Args.hasFlag(OPT_fsigned_wchar, OPT_fno_signed_wchar, true);
   Opts.ShortEnums = Args.hasArg(OPT_fshort_enums);
   Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
   Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
   if (!Opts.NoBuiltin)
     getAllNoBuiltinFuncValues(Args, Opts.NoBuiltinFuncs);
   Opts.NoMathBuiltin = Args.hasArg(OPT_fno_math_builtin);
   Opts.RelaxedTemplateTemplateArgs =
       Args.hasArg(OPT_frelaxed_template_template_args);

test/CXX/conv/conv.prom/p2.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++0x -triple x86_64-pc-linux-gnu -ffreestanding %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++0x -triple x86_64-pc-linux-gnu -ffreestanding -fshort-wchar %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++0x -triple x86_64-pc-linux-gnu -ffreestanding -fwchar-type=short -fno-signed-wchar %s
 // expected-no-diagnostics
 
 #include <stdint.h>
 
 // In theory, the promoted types vary by platform; however, in reality they
 // are quite consistent across all platforms where clang runs.
 
 extern int promoted_wchar;
 extern decltype(+L'a') promoted_wchar;
 
 extern int promoted_char16;
 extern decltype(+u'a') promoted_char16;
 
 extern unsigned promoted_char32;
 extern decltype(+U'a') promoted_char32;

test/CodeGen/aarch64-type-sizes.c

-// RUN: %clang_cc1 -triple aarch64_be-none-linux-gnu -emit-llvm -w -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple aarch64_be-none-linux-gnu -fwchar-type=int -fno-signed-wchar -emit-llvm -w -o - %s | FileCheck %s
 // char by definition has size 1
 
 // CHECK: target datalayout = "E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 
 int check_short() {
   return sizeof(short);
 // CHECK: ret i32 2
 }

test/CodeGen/arm-metadata.c

 // RUN: %clang_cc1 -triple armv7a-linux-gnueabi -emit-llvm -o - %s | FileCheck -check-prefix=DEFAULT %s
 // RUN: %clang_cc1 -triple armv7a-linux-gnueabi -emit-llvm -o - %s -fshort-enums | FileCheck -check-prefix=SHORT-ENUM %s
-// RUN: %clang_cc1 -triple armv7a-linux-gnueabi -emit-llvm -o - %s -fshort-wchar | FileCheck -check-prefix=SHORT-WCHAR %s
+// RUN: %clang_cc1 -triple armv7a-linux-gnueabi -emit-llvm -o - %s -fwchar-type=short -fno-signed-wchar | FileCheck -check-prefix=SHORT-WCHAR %s
 
 // DEFAULT:  !{{[0-9]+}} = !{i32 1, !"wchar_size", i32 4}
 // DEFAULT:   !{{[0-9]+}} = !{i32 1, !"min_enum_size", i32 4}
 
 // SHORT-WCHAR: !{{[0-9]+}} = !{i32 1, !"wchar_size", i32 2}
 // SHORT-WCHAR:   !{{[0-9]+}} = !{i32 1, !"min_enum_size", i32 4}
 
 // SHORT_ENUM:  !{{[0-9]+}} = !{i32 1, !"wchar_size", i32 4}
 // SHORT-ENUM:  !{{[0-9]+}} = !{i32 1, !"min_enum_size", i32 1}

test/CodeGen/coff-aarch64-type-sizes.c

-// RUN: %clang_cc1 -triple aarch64-windows -emit-llvm -w -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple aarch64-windows -emit-llvm -fwchar-type=short -fno-signed-wchar -w -o - %s | FileCheck %s
 
 // CHECK: target datalayout = "e-m:w-p:64:64-i32:32-i64:64-i128:128-n32:64-S128"
 // CHECK: target triple = "aarch64--windows-msvc"
 
 int check_short() {
   return sizeof(short);
 // CHECK: ret i32 2
 }

test/CodeGen/ms-annotation.c

-// RUN: %clang_cc1 -triple i686-windows %s -fms-extensions -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple i686-windows %s -fwchar-type=short -fno-signed-wchar -fms-extensions -emit-llvm -o - | FileCheck %s
 //
 // Test that LLVM optimizations leave these intrinsics alone, for the most part.
-// RUN: %clang_cc1 -O2 -triple i686-windows %s -fms-extensions -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -O2 -triple i686-windows %s -fwchar-type=short -fno-signed-wchar -fms-extensions -emit-llvm -o - | FileCheck %s
 
 void test1(void) {
   __annotation(L"a1");
   __annotation(L"a1", L"a2");
   __annotation(L"a1", L"a2", L"a3");
   __annotation(L"multi " L"part " L"string");
   __annotation(L"unicode: \u0ca0_\u0ca0");
 }

test/CodeGen/pascal-wchar-string.c

-// RUN: %clang_cc1 -emit-llvm -o -  %s -fpascal-strings -fshort-wchar  | FileCheck %s
+// RUN: %clang_cc1 -emit-llvm -o -  %s -fpascal-strings -fwchar-type=short -fno-signed-wchar | FileCheck %s
 // rdar://8020384
 
 #include <stddef.h>
 
 extern void abort (void);
 
 typedef unsigned short UInt16;
 

test/CodeGen/string-literal-short-wstring.c

-// RUN: %clang_cc1 -x c++ -triple %itanium_abi_triple -emit-llvm -fshort-wchar %s -o - | FileCheck %s --check-prefix=CHECK --check-prefix=ITANIUM
-// RUN: %clang_cc1 -x c++ -triple %ms_abi_triple -emit-llvm -fshort-wchar %s -o - | FileCheck %s --check-prefix=CHECK --check-prefix=MSABI
+// RUN: %clang_cc1 -x c++ -triple %itanium_abi_triple -emit-llvm -fwchar-type=short -fno-signed-wchar %s -o - | FileCheck %s --check-prefix=CHECK --check-prefix=ITANIUM
+// RUN: %clang_cc1 -x c++ -triple %ms_abi_triple -emit-llvm -fwchar-type=short -fno-signed-wchar %s -o - | FileCheck %s --check-prefix=CHECK --check-prefix=MSABI
 // Runs in c++ mode so that wchar_t is available.
 
 // XFAIL: hexagon
 // Hexagon aligns arrays of size 8+ bytes to a 64-bit boundary, which fails
 // the first check line with "align 1".
 
 int main() {
   // This should convert to utf8.

test/CodeGen/string-literal-unicode-conversion.c

 // RUN: %clang_cc1 -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck -check-prefix=CHECK-C %s
 // RUN: %clang_cc1 -x c++ -std=c++0x -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck -check-prefix=CHECK-CPP0X %s
-// RUN: %clang_cc1 -x c++ -std=c++0x -fshort-wchar -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck -check-prefix=CHECK-SHORTWCHAR %s
+// RUN: %clang_cc1 -x c++ -std=c++0x -fwchar-type=short -fno-signed-wchar -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck -check-prefix=CHECK-SHORTWCHAR %s
 
 // This file contains a mix of ISO-8859-1 and UTF-8 encoded data.
 // the literal assigned to 'aa' should be the ISO-8859-1 encoding for the code
 // points U+00C0 U+00E9 U+00EE U+00F5 U+00FC
 
 // The rest of the literals should contain the UTF-8 encoding for U+041A U+043E
 // U+0448 U+043A U+0430
 

test/CodeGen/wchar-const.c

-// RUN: %clang_cc1 -emit-llvm %s -o - -triple i386-pc-win32 | FileCheck %s --check-prefix=CHECK-WIN
+// RUN: %clang_cc1 -emit-llvm %s -o - -triple i386-pc-win32 -fwchar-type=short -fno-signed-wchar | FileCheck %s --check-prefix=CHECK-WIN
 // RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-apple-darwin | FileCheck %s --check-prefix=CHECK-DAR
 // This should pass for any endianness combination of host and target.
 
 // This bit is taken from Sema/wchar.c so we can avoid the wchar.h include.
 typedef __WCHAR_TYPE__ wchar_t;
 #if defined(_WIN32) || defined(_M_IX86) || defined(__CYGWIN__) \
   || defined(_M_X64) || defined(SHORT_WCHAR)
   #define WCHAR_T_TYPE unsigned short

test/CodeGen/wchar-size.c

 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s -check-prefix=LONG-WCHAR
-// RUN: %clang_cc1 -triple x86_64-unknown-windows-msvc -emit-llvm -o - %s | FileCheck %s -check-prefix=SHORT-WCHAR
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -o - -fshort-wchar %s | FileCheck %s -check-prefix=SHORT-WCHAR
+// RUN: %clang_cc1 -triple x86_64-unknown-windows-msvc -fwchar-type=short -fno-signed-wchar -emit-llvm -o - %s | FileCheck %s -check-prefix=SHORT-WCHAR
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -o - -fwchar-type=short -fno-signed-wchar %s | FileCheck %s -check-prefix=SHORT-WCHAR
 // Note: -fno-short-wchar implies the target default is used; so there is no
 // need to test this separately here.
 
 // LONG-WCHAR: !{{[0-9]+}} = !{i32 {{[0-9]+}}, !"wchar_size", i32 4}
 // SHORT-WCHAR: !{{[0-9]+}} = !{i32 {{[0-9]+}}, !"wchar_size", i32 2}

test/CodeGenCXX/mangle-ms-string-literals.cpp

-// RUN: %clang_cc1 -x c++ -std=c++11 -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s
-// RUN: %clang_cc1 -x c++ -std=c++11 -emit-llvm %s -o - -triple=x86_64-pc-win32 | FileCheck %s
+// RUN: %clang_cc1 -x c++ -std=c++11 -emit-llvm %s -o - -triple=i386-pc-win32 -fwchar-type=short -fno-signed-wchar | FileCheck %s
+// RUN: %clang_cc1 -x c++ -std=c++11 -emit-llvm %s -o - -triple=x86_64-pc-win32 -fwchar-type=short -fno-signed-wchar | FileCheck %s
 
 const char *l255 = "\xff";
 const char *l254 = "\xfe";
 const char *l253 = "\xfd";
 const char *l252 = "\xfc";
 const char *l251 = "\xfb";
 const char *l250 = "\xfa";
 const char *l249 = "\xf9";

test/CodeGenCXX/ms_wide_predefined_expr.cpp

-// RUN: %clang_cc1 %s -fms-extensions -triple i686-pc-win32 -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 %s -fms-extensions -fwchar-type=short -fno-signed-wchar -triple i686-pc-win32 -emit-llvm -o - | FileCheck %s
 
 // CHECK: @"\01??_C@_19DPFBEKIN@?$AAf?$AAu?$AAn?$AAc?$AA?$AA@" = linkonce_odr unnamed_addr constant [5 x i16] [i16 102, i16 117, i16 110, i16 99, i16 0], comdat, align 2
 
 void wprint(const wchar_t*);
 
 #define __STR2WSTR(str) L##str
 #define _STR2WSTR(str) __STR2WSTR(str)
 #define STR2WSTR(str) _STR2WSTR(str)

test/Driver/clang_f_opts.c

 // REQUIRES: clang-driver
 
 // RUN: %clang -### -S -fasm -fblocks -fbuiltin -fno-math-errno -fcommon -fpascal-strings -fno-blocks -fno-builtin -fmath-errno -fno-common -fno-pascal-strings -fblocks -fbuiltin -fmath-errno -fcommon -fpascal-strings -fsplit-stack %s 2>&1 | FileCheck -check-prefix=CHECK-OPTIONS1 %s
 // RUN: %clang -### -S -fasm -fblocks -fbuiltin -fno-math-errno -fcommon -fpascal-strings -fno-asm -fno-blocks -fno-builtin -fmath-errno -fno-common -fno-pascal-strings -fno-show-source-location -fshort-enums -fshort-wchar %s 2>&1 | FileCheck -check-prefix=CHECK-OPTIONS2 %s
 
 // CHECK-OPTIONS1: -split-stacks
 // CHECK-OPTIONS1: -fgnu-keywords
 // CHECK-OPTIONS1: -fblocks
 // CHECK-OPTIONS1: -fpascal-strings
 
 // CHECK-OPTIONS2: -fmath-errno
 // CHECK-OPTIONS2: -fno-gnu-keywords
 // CHECK-OPTIONS2: -fno-builtin
 // CHECK-OPTIONS2: -fshort-enums
-// CHECK-OPTIONS2: -fshort-wchar
+// CHECK-OPTIONS2: -fwchar-type=short
+// CHECK-OPTIONS2: -fno-signed-wchar
 // CHECK-OPTIONS2: -fno-common
 // CHECK-OPTIONS2: -fno-show-source-location
 
 // RUN: %clang -### -S -Wwrite-strings %s 2>&1 | FileCheck -check-prefix=WRITE-STRINGS1 %s
 // WRITE-STRINGS1: -fconst-strings
 // RUN: %clang -### -S -Wwrite-strings -Wno-write-strings %s 2>&1 | FileCheck -check-prefix=WRITE-STRINGS2 %s
 // WRITE-STRINGS2-NOT: -fconst-strings
 // RUN: %clang -### -S -Wwrite-strings -w %s 2>&1 | FileCheck -check-prefix=WRITE-STRINGS3 %s

 // RUN: %clang -### -S -fno-unsigned-char %s 2>&1 | FileCheck -check-prefix=CHAR-SIGN4 %s
 // CHAR-SIGN4-NOT: -fno-signed-char
 
 // RUN: %clang -### -fshort-wchar -fno-short-wchar %s 2>&1 | FileCheck -check-prefix=CHECK-WCHAR1 -check-prefix=DELIMITERS %s
 // RUN: %clang -### -fno-short-wchar -fshort-wchar %s 2>&1 | FileCheck -check-prefix=CHECK-WCHAR2 -check-prefix=DELIMITERS %s
 // 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: {{^ *"}}
-// CHECK-WCHAR1: -fno-short-wchar
-// CHECK-WCHAR1-NOT: -fshort-wchar
-// CHECK-WCHAR2: -fshort-wchar
-// CHECK-WCHAR2-NOT: -fno-short-wchar
+// CHECK-WCHAR1: -fwchar-type=int
+// CHECK-WCHAR1-NOT: -fwchar-type=short
+// CHECK-WCHAR2: -fwchar-type=short
+// CHECK-WCHAR2-NOT: -fwchar-type=int
 // DELIMITERS: {{^ *"}}
 
 // RUN: %clang -### -fno-experimental-new-pass-manager -fexperimental-new-pass-manager %s 2>&1 | FileCheck --check-prefix=CHECK-PM --check-prefix=CHECK-NEW-PM %s
 // RUN: %clang -### -fexperimental-new-pass-manager -fno-experimental-new-pass-manager %s 2>&1 | FileCheck --check-prefix=CHECK-PM --check-prefix=CHECK-NO-NEW-PM %s
 // CHECK-PM-NOT: argument unused
 // CHECK-NEW-PM: -fexperimental-new-pass-manager
 // CHECK-NEW-PM-NOT: -fno-experimental-new-pass-manager
 // CHECK-NO-NEW-PM: -fno-experimental-new-pass-manager

test/Driver/rewrite-legacy-objc.m

 // RUN: %clang -no-canonical-prefixes -target x86_64-apple-macosx10.7.0 -rewrite-legacy-objc %s -o - -### 2>&1 | \
 // RUN:   FileCheck -check-prefix=TEST0 %s
 // TEST0: clang{{.*}}" "-cc1"
 // TEST0: "-rewrite-objc"
 // FIXME: CHECK-NOT is broken somehow, it doesn't work here. Check adjacency instead.
-// TEST0: "-fmessage-length" "0" "-stack-protector" "1" "-fblocks" "-fencode-extended-block-signature" "-fobjc-runtime=macosx-fragile" "-fno-objc-infer-related-result-type" "-fobjc-exceptions" "-fexceptions" "-fmax-type-align=16" "-fdiagnostics-show-option"
+// TEST0: "-fmessage-length" "0" "-stack-protector" "1" "-fblocks" "-fencode-extended-block-signature" "-fwchar-type=int" "-fsigned-wchar" "-fobjc-runtime=macosx-fragile" "-fno-objc-infer-related-result-type" "-fobjc-exceptions" "-fexceptions" "-fmax-type-align=16" "-fdiagnostics-show-option"
 // TEST0: rewrite-legacy-objc.m"
 // RUN: %clang -no-canonical-prefixes -target i386-apple-macosx10.9.0 -rewrite-legacy-objc %s -o - -### 2>&1 | \
 // RUN:   FileCheck -check-prefix=TEST1 %s
 // RUN: %clang -no-canonical-prefixes -target i386-apple-macosx10.6.0 -rewrite-legacy-objc %s -o - -### 2>&1 | \
 // RUN:   FileCheck -check-prefix=TEST2 %s
-// TEST1: "-fmessage-length" "0" "-stack-protector" "1" "-fblocks" "-fencode-extended-block-signature" "-fobjc-runtime=macosx-fragile" "-fobjc-subscripting-legacy-runtime" "-fno-objc-infer-related-result-type" "-fobjc-exceptions" "-fmax-type-align=16" "-fdiagnostics-show-option"
-// TEST2: "-fmessage-length" "0" "-stack-protector" "1" "-fblocks" "-fencode-extended-block-signature" "-fobjc-runtime=macosx-fragile" "-fno-objc-infer-related-result-type" "-fobjc-exceptions" "-fmax-type-align=16" "-fdiagnostics-show-option"
+// TEST1: "-fmessage-length" "0" "-stack-protector" "1" "-fblocks" "-fencode-extended-block-signature" "-fwchar-type=int" "-fsigned-wchar" "-fobjc-runtime=macosx-fragile" "-fobjc-subscripting-legacy-runtime" "-fno-objc-infer-related-result-type" "-fobjc-exceptions" "-fmax-type-align=16" "-fdiagnostics-show-option"
+// TEST2: "-fmessage-length" "0" "-stack-protector" "1" "-fblocks" "-fencode-extended-block-signature" "-fwchar-type=int" "-fsigned-wchar" "-fobjc-runtime=macosx-fragile" "-fno-objc-infer-related-result-type" "-fobjc-exceptions" "-fmax-type-align=16" "-fdiagnostics-show-option"

test/Driver/rewrite-objc.m

 // RUN: %clang -no-canonical-prefixes -target x86_64-apple-macosx10.7.0 -rewrite-objc %s -o - -### 2>&1 | \
 // RUN:   FileCheck -check-prefix=TEST0 %s
 // TEST0: clang{{.*}}" "-cc1"
 // TEST0: "-rewrite-objc"
 // FIXME: CHECK-NOT is broken somehow, it doesn't work here. Check adjacency instead.
-// TEST0: "-fmessage-length" "0" "-stack-protector" "1" "-fblocks" "-fencode-extended-block-signature" "-fobjc-runtime=macosx" "-fno-objc-infer-related-result-type" "-fobjc-exceptions" "-fexceptions" "-fmax-type-align=16" "-fdiagnostics-show-option"
+// TEST0: "-fmessage-length" "0" "-stack-protector" "1" "-fblocks" "-fencode-extended-block-signature" "-fwchar-type=int" "-fsigned-wchar" "-fobjc-runtime=macosx" "-fno-objc-infer-related-result-type" "-fobjc-exceptions" "-fexceptions" "-fmax-type-align=16" "-fdiagnostics-show-option"

test/Driver/wchar_t.c

+// RUN: %clang -### -target i386-unknown-solarisiiiiiii %s 2>&1 | FileCheck %s -check-prefix CHECK-SOLARIS
+// CHECK-SOLARIS-DAG: "-fwchar-type=int"
+// CHECK-SOLARIS-DAG: "-fsigned-wchar"
+
+// RUN: %clang -### -target avr-unknown-none %s 2>&1 | FileCheck %s -check-prefix CHECK-AVR
+// CHECK-AVR-DAG: "-fwchar-type=int"
+// CHECK-AVR-DAG: "-fsigned-wchar"
+
+// RUN: %clang -### -target arm-unknown-none-eabi %s 2>&1 | FileCheck %s -check-prefix CHECK-ARM-AAPCS
+// CHECK-ARM-AAPCS-DAG: "-fwchar-type=int"
+// CHECK-ARM-AAPCS-DAG: "-fno-signed-wchar"
+
+// RUN: %clang -### -target arm-unknown-none-gnu %s 2>&1 | FileCheck %s -check-prefix CHECK-ARM-APCS
+// CHECK-ARM-APCS-DAG: "-fwchar-type=int"
+// CHECK-ARM-APCS-DAG: "-fsigned-wchar"
+
+// RUN: %clang -### -target arm-unknown-netbsd-gnu %s 2>&1 | FileCheck %s -check-prefix CHECK-ARM-NETBSD-AAPCS
+// CHECK-ARM-NETBSD-AAPCS-DAG: "-fwchar-type=int"
+// CHECK-ARM-NETBSD-AAPCS-DAG: "-fsigned-wchar"
+
+// RUN: %clang -### -target arm-unknown-openbsd %s 2>&1 | FileCheck %s -check-prefix CHECK-ARM-OPENBSD
+// CHECK-ARM-OPENBSD-DAG: "-fwchar-type=int"
+// CHECK-ARM-OPENBSD-DAG: "-fsigned-wchar"
+
+// RUN: %clang -### -target arm64-apple-ios %s 2>&1 | FileCheck %s -check-prefix CHECK-ARM64-DARWIN
+// CHECK-ARM64-DARWIN-DAG: "-fwchar-type=int"
+// CHECK-ARM64-DARWIN-DAG: "-fsigned-wchar"
+
+// RUN: %clang -### -target aarch64-unknown-netbsd %s 2>&1 | FileCheck %s -check-prefix CHECK-ARM64-NETBSD
+// CHECK-ARM64-NETBSD-DAG: "-fwchar-type=int"
+// CHECK-ARM64-NETBSD-DAG: "-fno-signed-wchar"
+
+// RUN: %clang -### -target aarch64-unknown-openbsd %s 2>&1 | FileCheck %s -check-prefix CHECK-ARM64-OPENBSD
+// CHECK-ARM64-OPENBSD-DAG: "-fwchar-type=int"
+// CHECK-ARM64-OPENBSD-DAG: "-fno-signed-wchar"
+
+// RUN: %clang -### -target aarch64-unknown-none %s 2>&1 | FileCheck %s -check-prefix CHECK-ARM64-AAPCS64
+// CHECK-ARM64-AAPCS64-DAG: "-fwchar-type=int"
+// CHECK-ARM64-AAPCS64-DAG: "-fsigned-wchar"
+
+// RUN: %clang -### -target xcore-unknown-none %s 2>&1 | FileCheck %s -check-prefix CHECK-XCORE
+// CHECK-XCORE-DAG: "-fwchar-type=char"
+// CHECK-XCORE-DAG: "-fno-signed-wchar"
+
+// RUN: %clang -### -target x86_64-unknown-windows-cygnus %s 2>&1 | FileCheck %s -check-prefix CHECK-CYGWIN-X64
+// CHECK-CYGWIN-X64-DAG: "-fwchar-type=short"
+// CHECK-CYGWIN-X64-DAG: "-fno-signed-wchar"
+
+// RUN: %clang -### -target x86_64-unknown-windows-msvc %s 2>&1 | FileCheck %s -check-prefix CHECK-MSVC-X64
+// CHECK-MSVC-X64-DAG: "-fwchar-type=short"
+// CHECK-MSVC-X64-DAG: "-fno-signed-wchar"
+
+// RUN: %clang -### -target i686-unknown-windows-cygnus %s 2>&1 | FileCheck %s -check-prefix CHECK-CYGWIN-X86
+// CHECK-CYGWIN-X86-DAG: "-fwchar-type=short"
+// CHECK-CYGWIN-X86-DAG: "-fno-signed-wchar"
+
+// RUN: %clang -### -target i686-unknown-windows-msvc %s 2>&1 | FileCheck %s -check-prefix CHECK-MSVC-X86
+// CHECK-MSVC-X86-DAG: "-fwchar-type=short"
+// CHECK-MSVC-X86-DAG: "-fno-signed-wchar"
+
+// RUN: %clang -### -target x86_64-scei-ps4 %s 2>&1 | FileCheck %s -check-prefix CHECK-PS4
+// CHECK-PS4-DAG: "-fwchar-type=short"
+// CHECK-PS4-DAG: "-fno-signed-wchar"
+
+// RUN: %clang -### -target thumbv7-unknown-windows-cygnus %s 2>&1 | FileCheck %s -check-prefix CHECK-CYGWIN-ARM
+// CHECK-CYGWIN-ARM-DAG: "-fwchar-type=short"
+// CHECK-CYGWIN-ARM-DAG: "-fno-signed-wchar"
+
+// RUN: %clang -### -target thumbv7-unknown-windows-msvc %s 2>&1 | FileCheck %s -check-prefix CHECK-MSVC-ARM
+// CHECK-MSVC-ARM-DAG: "-fwchar-type=short"
+// CHECK-MSVC-ARM-DAG: "-fno-signed-wchar"
+
+// RUN: %clang -### -target aarch64-unknown-windows-msvc %s 2>&1 | FileCheck %s -check-prefix CHECK-MSVC-ARM64
+// CHECK-MSVC-ARM64-DAG: "-fwchar-type=short"
+// CHECK-MSVC-ARM64-DAG: "-fno-signed-wchar"
+

test/Headers/wchar_limits.cpp

 // RUN: %clang_cc1 -ffreestanding -fsyntax-only -verify %s
-// RUN: %clang_cc1 -ffreestanding -fsyntax-only -verify -fshort-wchar %s
+// RUN: %clang_cc1 -ffreestanding -fsyntax-only -verify -fwchar-type=short -fno-signed-wchar %s
 // expected-no-diagnostics
 
 #include <stdint.h>
 
 const bool swchar = (wchar_t)-1 > (wchar_t)0;
 
 int max_test[WCHAR_MAX == (swchar ? -(WCHAR_MIN+1) : (wchar_t)-1)];
 int min_test[WCHAR_MIN == (swchar ? 0 : -WCHAR_MAX-1)];

test/Index/index-pch.cpp

-// RUN: c-index-test -write-pch %t.pch -fshort-wchar %s
+// RUN: c-index-test -write-pch %t.pch -fwchar-type=short -fno-signed-wchar %s
 // RUN: env LIBCLANG_NOTHREADS=1 c-index-test -index-tu %t.pch | FileCheck %s
 
 // CHECK: [indexDeclaration]: kind: variable | name: wideStr
 const wchar_t *wideStr = L"123";
 
 // CHECK: [indexDeclaration]: kind: struct | name: __is_void
 struct __is_void {};

test/Lexer/wchar-signedness.c

-// RUN: %clang_cc1 -fsyntax-only -dM -E %s -triple x86_64-none-linux-gnu | FileCheck %s --check-prefix=CHECK-X86
-// RUN: %clang_cc1 -fsyntax-only -dM -E %s -triple armv7-none-eabi | FileCheck %s --check-prefix=CHECK-ARM
-// RUN: %clang_cc1 -fsyntax-only -dM -E %s -triple thumbv7-none-eabi | FileCheck %s --check-prefix=CHECK-ARM
+// RUN: %clang_cc1 -fsyntax-only -fwchar-type=int -fsigned-wchar -dM -E %s -triple x86_64-none-linux-gnu | FileCheck %s --check-prefix=CHECK-X86
+// RUN: %clang_cc1 -fsyntax-only -fwchar-type=int -fno-signed-wchar -dM -E %s -triple armv7-none-eabi | FileCheck %s --check-prefix=CHECK-ARM
+// RUN: %clang_cc1 -fsyntax-only -fwchar-type=int -fno-signed-wchar -dM -E %s -triple thumbv7-none-eabi | FileCheck %s --check-prefix=CHECK-ARM
 
 // CHECK-X86-NOT: #define __WCHAR_UNSIGNED__
 // CHECK-X86: #define __WINT_UNSIGNED__ 1
 
 // CHECK-ARM: #define __WCHAR_UNSIGNED__ 1
 // CHECK-ARM-NOT: #define __WINT_UNSIGNED__ 1

test/Lexer/wchar.c

-// RUN: %clang_cc1 -fsyntax-only -fshort-wchar -verify %s
+// RUN: %clang_cc1 -fsyntax-only -fwchar-type=short -fno-signed-wchar -verify %s
 
 void f() {
   (void)L"\U00010000"; // unicode escape produces UTF-16 sequence, so no warning
 
   (void)L'\U00010000'; // expected-error {{character too large for enclosing character literal type}}
 
   (void)L'ab';  // expected-warning {{extraneous characters in character constant ignored}}
 
   (void)L'a\u1000';  // expected-warning {{extraneous characters in character constant ignored}}
 }
 

test/Preprocessor/init.c

 //
 // 
 // RUN: %clang_cc1 -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix SCHAR %s
 // 
 // SCHAR:#define __STDC__ 1
 // SCHAR-NOT:#define __UNSIGNED_CHAR__
 // SCHAR:#define __clang__ 1
 //
-// RUN: %clang_cc1 -E -dM -fshort-wchar < /dev/null | FileCheck -match-full-lines -check-prefix SHORTWCHAR %s
+// RUN: %clang_cc1 -E -dM -fwchar-type=short -fno-signed-wchar < /dev/null | FileCheck -match-full-lines -check-prefix SHORTWCHAR %s
 // wchar_t is u16 for targeting Win32.
 // FIXME: Implement and check x86_64-cygwin.
-// RUN: %clang_cc1 -E -dM -fno-short-wchar -triple=x86_64-w64-mingw32 < /dev/null | FileCheck -match-full-lines -check-prefix SHORTWCHAR %s
+// RUN: %clang_cc1 -E -dM -fwchar-type=short -fno-signed-wchar -triple=x86_64-w64-mingw32 < /dev/null | FileCheck -match-full-lines -check-prefix SHORTWCHAR %s
 //
 // SHORTWCHAR: #define __SIZEOF_WCHAR_T__ 2
 // SHORTWCHAR: #define __WCHAR_MAX__ 65535
 // SHORTWCHAR: #define __WCHAR_TYPE__ unsigned short
 // SHORTWCHAR: #define __WCHAR_WIDTH__ 16
 //
-// RUN: %clang_cc1 -E -dM -fno-short-wchar -triple=i686-unknown-unknown < /dev/null | FileCheck -match-full-lines -check-prefix SHORTWCHAR2 %s
-// RUN: %clang_cc1 -E -dM -fno-short-wchar -triple=x86_64-unknown-unknown < /dev/null | FileCheck -match-full-lines -check-prefix SHORTWCHAR2 %s
+// RUN: %clang_cc1 -E -dM -fwchar-type=int -fsigned-wchar -triple=i686-unknown-unknown < /dev/null | FileCheck -match-full-lines -check-prefix SHORTWCHAR2 %s
+// RUN: %clang_cc1 -E -dM  -fwchar-type=int -fsigned-wchar -triple=x86_64-unknown-unknown < /dev/null | FileCheck -match-full-lines -check-prefix SHORTWCHAR2 %s
 //
 // SHORTWCHAR2: #define __SIZEOF_WCHAR_T__ 4
 // SHORTWCHAR2: #define __WCHAR_WIDTH__ 32
 // Other definitions vary from platform to platform
 
-// RUN: %clang_cc1 -E -dM -ffreestanding -triple=aarch64-none-none < /dev/null | FileCheck -match-full-lines -check-prefix AARCH64 %s
-// RUN: %clang_cc1 -E -dM -ffreestanding -triple=arm64-none-none < /dev/null | FileCheck -match-full-lines -check-prefix AARCH64 %s
-// RUN: %clang_cc1 -x c++ -E -dM -ffreestanding -triple=arm64-none-none < /dev/null | FileCheck -match-full-lines -check-prefix AARCH64 -check-prefix AARCH64-CXX %s
+// RUN: %clang_cc1 -E -dM -ffreestanding -fwchar-type=int -fno-signed-wchar -triple=aarch64-none-none < /dev/null | FileCheck -match-full-lines -check-prefix AARCH64 %s
+// RUN: %clang_cc1 -E -dM -ffreestanding -fwchar-type=int -fno-signed-wchar -triple=arm64-none-none < /dev/null | FileCheck -match-full-lines -check-prefix AARCH64 %s
+// RUN: %clang_cc1 -x c++ -E -dM -ffreestanding -fwchar-type=int -fno-signed-wchar -triple=arm64-none-none < /dev/null | FileCheck -match-full-lines -check-prefix AARCH64 -check-prefix AARCH64-CXX %s
 //
 // AARCH64:#define _LP64 1
 // AARCH64-NOT:#define __AARCH64EB__ 1
 // AARCH64:#define __AARCH64EL__ 1
 // AARCH64-NOT:#define __AARCH_BIG_ENDIAN 1
 // AARCH64:#define __ARM_64BIT_STATE 1
 // AARCH64:#define __ARM_ARCH 8
 // AARCH64:#define __ARM_ARCH_ISA_A64 1

 // AARCH64:#define __WCHAR_MAX__ 4294967295U
 // AARCH64:#define __WCHAR_TYPE__ unsigned int
 // AARCH64:#define __WCHAR_UNSIGNED__ 1
 // AARCH64:#define __WCHAR_WIDTH__ 32
 // AARCH64:#define __WINT_TYPE__ int
 // AARCH64:#define __WINT_WIDTH__ 32
 // AARCH64:#define __aarch64__ 1
 //
-// RUN: %clang_cc1 -E -dM -ffreestanding -triple=aarch64_be-none-none < /dev/null | FileCheck -match-full-lines -check-prefix AARCH64-BE %s
+// RUN: %clang_cc1 -E -dM -ffreestanding -fwchar-type=int -fno-signed-wchar -triple=aarch64_be-none-none < /dev/null | FileCheck -match-full-lines -check-prefix AARCH64-BE %s
 //
 // AARCH64-BE:#define _LP64 1
 // AARCH64-BE:#define __AARCH64EB__ 1
 // AARCH64-BE-NOT:#define __AARCH64EL__ 1
 // AARCH64-BE:#define __AARCH_BIG_ENDIAN 1
 // AARCH64-BE:#define __ARM_64BIT_STATE 1
 // AARCH64-BE:#define __ARM_ARCH 8
 // AARCH64-BE:#define __ARM_ARCH_ISA_A64 1

 // AARCH64-OPENBSD:#define __USER_LABEL_PREFIX__
 // AARCH64-OPENBSD:#define __WCHAR_MAX__ 2147483647
 // AARCH64-OPENBSD:#define __WCHAR_TYPE__ int
 // AARCH64-OPENBSD:#define __WCHAR_WIDTH__ 32
 // AARCH64-OPENBSD:#define __WINT_TYPE__ int
 // AARCH64-OPENBSD:#define __WINT_WIDTH__ 32
 // AARCH64-OPENBSD:#define __aarch64__ 1
 //
-// RUN: %clang_cc1 -E -dM -ffreestanding -triple=aarch64-freebsd11 < /dev/null | FileCheck -match-full-lines -check-prefix AARCH64-FREEBSD %s
+// RUN: %clang_cc1 -E -dM -ffreestanding -fwchar-type=int -fno-signed-wchar -triple=aarch64-freebsd11 < /dev/null | FileCheck -match-full-lines -check-prefix AARCH64-FREEBSD %s
 //
 // AARCH64-FREEBSD:#define _LP64 1
 // AARCH64-FREEBSD-NOT:#define __AARCH64EB__ 1
 // AARCH64-FREEBSD:#define __AARCH64EL__ 1
 // AARCH64-FREEBSD-NOT:#define __AARCH_BIG_ENDIAN 1
 // AARCH64-FREEBSD:#define __ARM_64BIT_STATE 1
 // AARCH64-FREEBSD:#define __ARM_ARCH 8
 // AARCH64-FREEBSD:#define __ARM_ARCH_ISA_A64 1

 // AARCH64-DARWIN: #define __WCHAR_MAX__ 2147483647
 // AARCH64-DARWIN: #define __WCHAR_TYPE__ int
 // AARCH64-DARWIN-NOT: #define __WCHAR_UNSIGNED__
 // AARCH64-DARWIN: #define __WCHAR_WIDTH__ 32
 // AARCH64-DARWIN: #define __WINT_TYPE__ int
 // AARCH64-DARWIN: #define __WINT_WIDTH__ 32
 // AARCH64-DARWIN: #define __aarch64__ 1
 
-// RUN: %clang_cc1 -E -dM -ffreestanding -triple=aarch64-windows-msvc < /dev/null | FileCheck -match-full-lines -check-prefix AARCH64-MSVC %s
+// RUN: %clang_cc1 -E -dM -ffreestanding -fwchar-type=short -fno-signed-wchar -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
 // AARCH64-MSVC: #define __AARCH64EL__ 1
 // AARCH64-MSVC: #define __ARM_64BIT_STATE 1

 // AARCH64-MSVC: #define __ARM_FEATURE_LDREX 0xF
 // AARCH64-MSVC: #define __ARM_FEATURE_NUMERIC_MAXMIN 1
 // AARCH64-MSVC: #define __ARM_FEATURE_UNALIGNED 1
 // AARCH64-MSVC: #define __ARM_FP 0xE
 // AARCH64-MSVC: #define __ARM_FP16_ARGS 1
 // AARCH64-MSVC: #define __ARM_FP16_FORMAT_IEEE 1
 // AARCH64-MSVC: #define __ARM_PCS_AAPCS64 1
 // AARCH64-MSVC: #define __ARM_SIZEOF_MINIMAL_ENUM 4
-// AARCH64-MSVC: #define __ARM_SIZEOF_WCHAR_T 4
+// AARCH64-MSVC: #define __ARM_SIZEOF_WCHAR_T 2
 // AARCH64-MSVC: #define __BIGGEST_ALIGNMENT__ 16
 // AARCH64-MSVC: #define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
 // AARCH64-MSVC: #define __CHAR16_TYPE__ unsigned short
 // AARCH64-MSVC: #define __CHAR32_TYPE__ unsigned int
 // AARCH64-MSVC: #define __CHAR_BIT__ 8
 // AARCH64-MSVC: #define __CONSTANT_CFSTRINGS__ 1
 // AARCH64-MSVC: #define __DBL_DECIMAL_DIG__ 17
 // AARCH64-MSVC: #define __DBL_DENORM_MIN__ 4.9406564584124654e-324

 // AARCH64-MSVC: #define __WCHAR_MAX__ 65535
 // AARCH64-MSVC: #define __WCHAR_TYPE__ unsigned short
 // AARCH64-MSVC: #define __WCHAR_UNSIGNED__ 1
 // AARCH64-MSVC: #define __WCHAR_WIDTH__ 16
 // AARCH64-MSVC: #define __WINT_TYPE__ int
 // AARCH64-MSVC: #define __WINT_WIDTH__ 32
 // AARCH64-MSVC: #define __aarch64__ 1
 
-// RUN: %clang_cc1 -E -dM -ffreestanding -triple=arm-none-none < /dev/null | FileCheck -match-full-lines -check-prefix ARM %s
-// RUN: %clang_cc1 -x c++ -E -dM -ffreestanding -triple=arm-none-none < /dev/null | FileCheck -match-full-lines -check-prefix ARM -check-prefix ARM-CXX %s
+// RUN: %clang_cc1 -E -dM -ffreestanding -fwchar-type=int -fno-signed-wchar -triple=arm-none-none < /dev/null | FileCheck -match-full-lines -check-prefix ARM %s
+// RUN: %clang_cc1 -x c++ -E -dM -ffreestanding -fwchar-type=int -fno-signed-wchar -triple=arm-none-none < /dev/null | FileCheck -match-full-lines -check-prefix ARM -check-prefix ARM-CXX %s
 //
 // ARM-NOT:#define _LP64
 // ARM:#define __APCS_32__ 1
 // ARM-NOT:#define __ARMEB__ 1
 // ARM:#define __ARMEL__ 1
 // ARM:#define __ARM_ARCH_4T__ 1
 // ARM-NOT:#define __ARM_BIG_ENDIAN 1
 // ARM:#define __BIGGEST_ALIGNMENT__ 8

 // ARM:#define __WCHAR_MAX__ 4294967295U
 // ARM:#define __WCHAR_TYPE__ unsigned int
 // ARM:#define __WCHAR_WIDTH__ 32
 // ARM:#define __WINT_TYPE__ int
 // ARM:#define __WINT_WIDTH__ 32
 // ARM:#define __arm 1
 // ARM:#define __arm__ 1
 
-// RUN: %clang_cc1 -E -dM -ffreestanding -triple=armeb-none-none < /dev/null | FileCheck -match-full-lines -check-prefix ARM-BE %s
+// RUN: %clang_cc1 -E -dM -ffreestanding -fwchar-type=int -fno-signed-wchar -triple=armeb-none-none < /dev/null | FileCheck -match-full-lines -check-prefix ARM-BE %s
 //
 // ARM-BE-NOT:#define _LP64
 // ARM-BE:#define __APCS_32__ 1
 // ARM-BE:#define __ARMEB__ 1
 // ARM-BE-NOT:#define __ARMEL__ 1
 // ARM-BE:#define __ARM_ARCH_4T__ 1
 // ARM-BE:#define __ARM_BIG_ENDIAN 1
 // ARM-BE:#define __BIGGEST_ALIGNMENT__ 8

 // ARM-BE:#define __WCHAR_MAX__ 4294967295U
 // ARM-BE:#define __WCHAR_TYPE__ unsigned int
 // ARM-BE:#define __WCHAR_WIDTH__ 32
 // ARM-BE:#define __WINT_TYPE__ int
 // ARM-BE:#define __WINT_WIDTH__ 32
 // ARM-BE:#define __arm 1
 // ARM-BE:#define __arm__ 1
 
-// RUN: %clang_cc1 -E -dM -ffreestanding -triple=arm-none-linux-gnueabi -target-feature +soft-float -target-feature +soft-float-abi < /dev/null | FileCheck -match-full-lines -check-prefix ARMEABISOFTFP %s
+// RUN: %clang_cc1 -E -dM -ffreestanding -fwchar-type=int -fno-signed-wchar -triple=arm-none-linux-gnueabi -target-feature +soft-float -target-feature +soft-float-abi < /dev/null | FileCheck -match-full-lines -check-prefix ARMEABISOFTFP %s
 //
 // ARMEABISOFTFP-NOT:#define _LP64
 // ARMEABISOFTFP:#define __APCS_32__ 1
 // ARMEABISOFTFP-NOT:#define __ARMEB__ 1
 // ARMEABISOFTFP:#define __ARMEL__ 1
 // ARMEABISOFTFP:#define __ARM_ARCH 4
 // ARMEABISOFTFP:#define __ARM_ARCH_4T__ 1
 // ARMEABISOFTFP-NOT:#define __ARM_BIG_ENDIAN 1

 // ARMEABISOFTFP:#define __WCHAR_MAX__ 4294967295U
 // ARMEABISOFTFP:#define __WCHAR_TYPE__ unsigned int
 // ARMEABISOFTFP:#define __WCHAR_WIDTH__ 32
 // ARMEABISOFTFP:#define __WINT_TYPE__ unsigned int
 // ARMEABISOFTFP:#define __WINT_WIDTH__ 32
 // ARMEABISOFTFP:#define __arm 1
 // ARMEABISOFTFP:#define __arm__ 1
 
-// RUN: %clang_cc1 -E -dM -ffreestanding -triple=arm-none-linux-gnueabi < /dev/null | FileCheck -match-full-lines -check-prefix ARMEABIHARDFP %s
+// RUN: %clang_cc1 -E -dM -ffreestanding -fwchar-type=int -fno-signed-wchar -triple=arm-none-linux-gnueabi < /dev/null | FileCheck -match-full-lines -check-prefix ARMEABIHARDFP %s
 //
 // ARMEABIHARDFP-NOT:#define _LP64
 // ARMEABIHARDFP:#define __APCS_32__ 1
 // ARMEABIHARDFP-NOT:#define __ARMEB__ 1
 // ARMEABIHARDFP:#define __ARMEL__ 1
 // ARMEABIHARDFP:#define __ARM_ARCH 4
 // ARMEABIHARDFP:#define __ARM_ARCH_4T__ 1
 // ARMEABIHARDFP-NOT:#define __ARM_BIG_ENDIAN 1

 // X86_64-NETBSD:#define __WCHAR_WIDTH__ 32
 // X86_64-NETBSD:#define __WINT_TYPE__ int
 // X86_64-NETBSD:#define __WINT_WIDTH__ 32
 // X86_64-NETBSD:#define __amd64 1
 // X86_64-NETBSD:#define __amd64__ 1
 // X86_64-NETBSD:#define __x86_64 1
 // X86_64-NETBSD:#define __x86_64__ 1
 //
-// RUN: %clang_cc1 -E -dM -ffreestanding -triple=x86_64-scei-ps4 < /dev/null | FileCheck -match-full-lines -check-prefix PS4 %s
+// RUN: %clang_cc1 -E -dM -ffreestanding -fwchar-type=short -fno-signed-wchar -triple=x86_64-scei-ps4 < /dev/null | FileCheck -match-full-lines -check-prefix PS4 %s
 //
 // PS4:#define _LP64 1
 // PS4:#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
 // PS4:#define __CHAR16_TYPE__ unsigned short
 // PS4:#define __CHAR32_TYPE__ unsigned int
 // PS4:#define __CHAR_BIT__ 8
 // PS4:#define __DBL_DENORM_MIN__ 4.9406564584124654e-324
 // PS4:#define __DBL_DIG__ 15

test/Preprocessor/pr19649-unsigned-wchar_t.c

-// RUN: %clang_cc1 -triple i386-pc-cygwin -E -x c %s
-// RUN: %clang_cc1 -triple powerpc64-unknown-linux-gnu -E -fshort-wchar -x c %s
+// RUN: %clang_cc1 -triple i386-pc-cygwin -fwchar-type=short -fno-signed-wchar -E -x c %s
+// RUN: %clang_cc1 -triple powerpc64-unknown-linux-gnu -E -fwchar-type=short -fno-signed-wchar -x c %s
 
 #if (L'\0' - 1 < 0)
 # error "Unexpected expression evaluation result"
 #endif

test/Preprocessor/stdint.c

-// RUN: %clang_cc1 -E -ffreestanding -triple=arm-none-none %s | FileCheck -check-prefix ARM %s
+// RUN: %clang_cc1 -E -ffreestanding -fwchar-type=int -fno-signed-wchar -triple=arm-none-none %s | FileCheck -check-prefix ARM %s
 //
 // ARM:typedef long long int int64_t;
 // ARM:typedef long long unsigned int uint64_t;
 // ARM:typedef int64_t int_least64_t;
 // ARM:typedef uint64_t uint_least64_t;
 // ARM:typedef int64_t int_fast64_t;
 // ARM:typedef uint64_t uint_fast64_t;
 //

 //
 //
 // RUN: %clang_cc1 -E -ffreestanding -triple=x86_64-pc-linux-gnu %s | FileCheck -check-prefix X86_64_LINUX %s
 //
 // X86_64_LINUX:WINT_MIN_ 0U
 // X86_64_LINUX:WINT_MAX_ 4294967295U
 //
 //
-// RUN: %clang_cc1 -E -ffreestanding -triple=i386-mingw32 %s | FileCheck -check-prefix I386_MINGW32 %s
+// RUN: %clang_cc1 -E -ffreestanding -fwchar-type=short -fno-signed-wchar -triple=i386-mingw32 %s | FileCheck -check-prefix I386_MINGW32 %s
 //
 // I386_MINGW32:WCHAR_MAX_ 65535
 // I386_MINGW32:WCHAR_MIN_ 0
 //
 //
-// RUN: %clang_cc1 -E -ffreestanding -triple=xcore-none-none %s | FileCheck -check-prefix XCORE %s
+// RUN: %clang_cc1 -E -ffreestanding -fwchar-type=char -fno-signed-wchar -triple=xcore-none-none %s | FileCheck -check-prefix XCORE %s
 //
 // XCORE:typedef long long int int64_t;
 // XCORE:typedef long long unsigned int uint64_t;
 // XCORE:typedef int64_t int_least64_t;
 // XCORE:typedef uint64_t uint_least64_t;
 // XCORE:typedef int64_t int_fast64_t;
 // XCORE:typedef uint64_t uint_fast64_t;
 //

test/Preprocessor/wchar_t.c

+// RUN: %clang_cc1 -triple i386-pc-solaris -dM -E %s -o - | FileCheck %s -check-prefix CHECK-SOLARIS
+// CHECK-SOLARIS-DAG: #define __WCHAR_MAX__ 2147483647
+// CHECK-SOLARIS-DAG: #define __WCHAR_TYPE__ int
+// CHECK-SOLARIS-NOT: #define __WCHAR_UNSIGNED__ 0
+
+// RUN: %clang_cc1 -triple avr-unknown-unknown -fwchar-type=int -fsigned-wchar -dM -E %s -o - | FileCheck %s -check-prefix CHECK-AVR
+// CHECK-AVR-DAG: #define __WCHAR_MAX__ 32767
+// CHECK-AVR-DAG: #define __WCHAR_TYPE__ int
+// CHECK-AVR-NOT: #define __WCHAR_UNSIGNED__ 0
+
+// RUN: %clang_cc1 -triple arm-unknown-none-gnu -fsigned-wchar -dM -E %s -o - | FileCheck %s -check-prefix CHECK-ARM-APCS
+// CHECK-ARM-APCS-DAG: #define __WCHAR_MAX__ 2147483647
+// CHECK-ARM-APCS-DAG: #define __WCHAR_TYPE__ int
+// CHECK-ARM-APCS-NOT: #define __WCHAR_UNSIGNED__ 0
+
+// RUN: %clang_cc1 -triple arm-unknown-netbsd-gnu -fsigned-wchar -dM -E %s -o - | FileCheck %s -check-prefix CHECK-ARM-NETBSD-AAPCS
+// CHECK-ARM-NETBSD-AAPCS-DAG: #define __WCHAR_MAX__ 2147483647
+// CHECK-ARM-NETBSD-AAPCS-DAG: #define __WCHAR_TYPE__ int
+// CHECK-ARM-NETBSD-AAPCS-NOT: #define __WCHAR_UNSIGNED__ 0
+
+// RUN: %clang_cc1 -triple arm-unknown-openbsd -fsigned-wchar -dM -E %s -o - | FileCheck %s -check-prefix CHECK-ARM-OPENBSD
+// CHECK-ARM-OPENBSD-DAG: #define __WCHAR_MAX__ 2147483647
+// CHECK-ARM-OPENBSD-DAG: #define __WCHAR_TYPE__ int
+// CHECK-ARM-OPENBSD-NOT: #define __WCHAR_UNSIGNED__ 0
+
+// RUN: %clang_cc1 -triple arm64-apple-ios -fsigned-wchar -dM -E %s -o - | FileCheck %s -check-prefix CHECK-ARM64-DARWIN
+// CHECK-ARM64-DARWIN-DAG: #define __WCHAR_MAX__ 2147483647
+// CHECK-ARM64-DARWIN-DAG: #define __WCHAR_TYPE__ int
+// CHECK-ARM64-DARWIN-NOT: #define __WCHAR_UNSIGNED__ 0
+
+// RUN: %clang_cc1 -triple aarch64-unknown-netbsd -fsigned-wchar -dM -E %s -o - | FileCheck %s -check-prefix CHECK-ARM64-NETBSD
+// CHECK-ARM64-NETBSD-DAG: #define __WCHAR_MAX__ 2147483647
+// CHECK-ARM64-NETBSD-DAG: #define __WCHAR_TYPE__ int
+// CHECK-ARM64-NETBSD-NOT: #define __WCHAR_UNSIGNED__ 0
+
+// RUN: %clang_cc1 -triple aarch64-unknown-openbsd -fsigned-wchar -dM -E %s -o - | FileCheck %s -check-prefix CHECK-ARM64-OPENBSD
+// CHECK-ARM64-OPENBSD-DAG: #define __WCHAR_MAX__ 2147483647
+// CHECK-ARM64-OPENBSD-DAG: #define __WCHAR_TYPE__ int
+// CHECK-ARM64-OPENBSD-NOT: #define __WCHAR_UNSIGNED__ 0
+
+// RUN: %clang_cc1 -triple aarch64-unknown-none -fwchar-type=int -fno-signed-wchar -dM -E %s -o - | FileCheck %s -check-prefix CHECK-ARM64-AAPCS64
+// CHECK-ARM64-AAPCS64-DAG: #define __WCHAR_MAX__ 4294967295U
+// CHECK-ARM64-AAPCS64-DAG: #define __WCHAR_TYPE__ unsigned int
+// CHECK-ARM64-AAPCS64-DAG: #define __WCHAR_UNSIGNED__ 1
+
+// RUN: %clang_cc1 -triple xcore-unknown-unknown -fwchar-type=char -fno-signed-wchar -dM -E %s -o - | FileCheck %s -check-prefix CHECK-XCORE
+// CHECK-XCORE-DAG: #define __WCHAR_MAX__ 255
+// CHECK-XCORE-DAG: #define __WCHAR_TYPE__ unsigned char
+// CHECK-XCORE-DAG: #define __WCHAR_UNSIGNED__ 1
+
+// RUN: %clang_cc1 -triple x86_64-unknown-windows-cygnus -fwchar-type=short -fno-signed-wchar -dM -E %s -o - | FileCheck %s -check-prefix CHECK-CYGWIN-X64
+// CHECK-CYGWIN-X64-DAG: #define __WCHAR_MAX__ 65535
+// CHECK-CYGWIN-X64-DAG: #define __WCHAR_TYPE__ unsigned short
+// CHECK-CYGWIN-X64-DAG: #define __WCHAR_UNSIGNED__ 1
+
+// RUN: %clang_cc1 -triple x86_64-unknown-windows-msvc -fwchar-type=short -fno-signed-wchar -dM -E %s -o - | FileCheck %s -check-prefix CHECK-MSVC-X64
+// CHECK-MSVC-X64-DAG: #define __WCHAR_MAX__ 65535
+// CHECK-MSVC-X64-DAG: #define __WCHAR_TYPE__ unsigned short
+// CHECK-MSVC-X64-DAG: #define __WCHAR_UNSIGNED__ 1
+
+// RUN: %clang_cc1 -triple i686-unknown-windows-cygnus -fwchar-type=short -fno-signed-wchar -dM -E %s -o - | FileCheck %s -check-prefix CHECK-CYGWIN-X86
+// CHECK-CYGWIN-X86-DAG: #define __WCHAR_MAX__ 65535
+// CHECK-CYGWIN-X86-DAG: #define __WCHAR_TYPE__ unsigned short
+// CHECK-CYGWIN-X86-DAG: #define __WCHAR_UNSIGNED__ 1
+
+// RUN: %clang_cc1 -triple i686-unknown-windows-msvc -fwchar-type=short -fno-signed-wchar -dM -E %s -o - | FileCheck %s -check-prefix CHECK-MSVC-X86
+// CHECK-MSVC-X86-DAG: #define __WCHAR_MAX__ 65535
+// CHECK-MSVC-X86-DAG: #define __WCHAR_TYPE__ unsigned short
+// CHECK-MSVC-X86-DAG: #define __WCHAR_UNSIGNED__ 1
+
+// RUN: %clang_cc1 -triple x86_64-scei-ps4 -fwchar-type=short -fno-signed-wchar -dM -E %s -o - | FileCheck %s -check-prefix CHECK-PS4
+// CHECK-PS4-DAG: #define __WCHAR_MAX__ 65535
+// CHECK-PS4-DAG: #define __WCHAR_TYPE__ unsigned short
+// CHECK-PS4-DAG: #define __WCHAR_UNSIGNED__ 1
+
+// RUN: %clang_cc1 -triple thumbv7-unknown-windows-cygnus -fwchar-type=short -fno-signed-wchar -dM -E %s -o - | FileCheck %s -check-prefix CHECK-CYGWIN-ARM
+// CHECK-CYGWIN-ARM-DAG: #define __WCHAR_MAX__ 65535
+// CHECK-CYGWIN-ARM-DAG: #define __WCHAR_TYPE__ unsigned short
+// CHECK-CYGWIN-ARM-DAG: #define __WCHAR_UNSIGNED__ 1
+
+// RUN: %clang_cc1 -triple thumbv7-unknown-windows-msvc -fwchar-type=short -fno-signed-wchar -dM -E %s -o - | FileCheck %s -check-prefix CHECK-MSVC-ARM
+// CHECK-MSVC-ARM-DAG: #define __WCHAR_MAX__ 65535
+// CHECK-MSVC-ARM-DAG: #define __WCHAR_TYPE__ unsigned short
+// CHECK-MSVC-ARM-DAG: #define __WCHAR_UNSIGNED__ 1
+
+// RUN: %clang_cc1 -triple aarch64-unknown-windows-msvc -fwchar-type=short -fno-signed-wchar -dM -E %s -o - | FileCheck %s -check-prefix CHECK-MSVC-ARM64
+// CHECK-MSVC-ARM64-DAG: #define __WCHAR_MAX__ 65535
+// CHECK-MSVC-ARM64-DAG: #define __WCHAR_TYPE__ unsigned short
+// CHECK-MSVC-ARM64-DAG: #define __WCHAR_UNSIGNED__ 1
+

test/Preprocessor/woa-defaults.c

-// RUN: %clang_cc1 -dM -triple armv7-windows -E %s | FileCheck %s
+// RUN: %clang_cc1 -dM -fwchar-type=short -fsigned-wchar -triple armv7-windows -E %s | FileCheck %s
 // RUN: %clang_cc1 -dM -fno-signed-char -triple armv7-windows -E %s \
 // RUN:   | FileCheck %s -check-prefix CHECK-UNSIGNED-CHAR
 
 // CHECK: #define _INTEGRAL_MAX_BITS 64
 // CHECK: #define _M_ARM 7
 // CHECK: #define _M_ARMT _M_ARM
 // CHECK: #define _M_ARM_FP 31
 // CHECK: #define _M_ARM_NT 1

test/Preprocessor/woa-wchar_t.c

-// RUN: %clang_cc1 -dM -triple armv7-windows -E %s | FileCheck %s
-// RUN: %clang_cc1 -dM -fno-signed-char -triple armv7-windows -E %s | FileCheck %s
+// RUN: %clang_cc1 -dM -fwchar-type=short -fno-signed-wchar -triple armv7-windows -E %s | FileCheck %s
+// RUN: %clang_cc1 -dM -fwchar-type=short -fno-signed-wchar -fno-signed-char -triple armv7-windows -E %s | FileCheck %s
 
 // CHECK: #define __WCHAR_TYPE__ unsigned short
 

test/Sema/format-strings-ms.c

-// RUN: %clang_cc1 -fsyntax-only -verify -fms-compatibility -triple=i386-pc-win32 %s
-// RUN: %clang_cc1 -fsyntax-only -verify -fms-compatibility -triple=i386-pc-win32 -Wformat-non-iso -DNON_ISO_WARNING %s
+// RUN: %clang_cc1 -fsyntax-only -verify -fms-compatibility -fwchar-type=short -fno-signed-wchar -triple=i386-pc-win32 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -fms-compatibility -fwchar-type=short -fno-signed-wchar -triple=i386-pc-win32 -Wformat-non-iso -DNON_ISO_WARNING %s
 
 int printf(const char *format, ...) __attribute__((format(printf, 1, 2)));
 int scanf(const char * restrict, ...) ;
 typedef unsigned short wchar_t;
 
 #ifdef NON_ISO_WARNING
 
 // Split off this test to reduce the warning noise in the rest of the file.

test/Sema/wchar.c

 // RUN: %clang_cc1 %s -fsyntax-only -verify
-// RUN: %clang_cc1 %s -fsyntax-only -fshort-wchar -verify -DSHORT_WCHAR
+// RUN: %clang_cc1 %s -fsyntax-only -fwchar-type=short -fno-signed-wchar -verify -DSHORT_WCHAR
 
 typedef __WCHAR_TYPE__ wchar_t;
 
 #if defined(_WIN32) || defined(_M_IX86) || defined(__CYGWIN__) \
  || defined(_M_X64) || defined(__ORBIS__) || defined(SHORT_WCHAR)
   #define WCHAR_T_TYPE unsigned short
 #elif defined(__arm) || defined(__aarch64__)
   #define WCHAR_T_TYPE unsigned int

test/SemaCXX/no-wchar.cpp

-// RUN: %clang_cc1 -triple i386-pc-win32 -fsyntax-only -fno-wchar -verify %s
-// RUN: %clang_cc1 -triple i386-pc-win32 -fsyntax-only -fno-wchar -verify -std=c++98 %s
-// RUN: %clang_cc1 -triple i386-pc-win32 -fsyntax-only -fno-wchar -verify -std=c++11 %s
+// RUN: %clang_cc1 -triple i386-pc-win32 -fsyntax-only -fwchar-type=short -fno-signed-wchar -fno-wchar -verify %s
+// RUN: %clang_cc1 -triple i386-pc-win32 -fsyntax-only -fwchar-type=short -fno-signed-wchar -fno-wchar -verify -std=c++98 %s
+// RUN: %clang_cc1 -triple i386-pc-win32 -fsyntax-only -fwchar-type=short -fno-signed-wchar -fno-wchar -verify -std=c++11 %s
 wchar_t x; // expected-error {{unknown type name 'wchar_t'}}
 
 typedef unsigned short wchar_t;
 void foo(const wchar_t* x);
 
 void bar() {
   foo(L"wide string literal");
 }

test/SemaCXX/short-wchar-sign.cpp

 // RUN: %clang_cc1 -triple i386-mingw32 -fsyntax-only -pedantic -verify %s
-// RUN: %clang_cc1 -fshort-wchar -fsyntax-only -pedantic -verify %s
+// RUN: %clang_cc1 -fwchar-type=short -fno-signed-wchar -fsyntax-only -pedantic -verify %s
 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -pedantic -verify %s
 // expected-no-diagnostics
 
 // Check that short wchar_t is unsigned, and that regular wchar_t is not.
 int test[(wchar_t(-1)<wchar_t(0)) == (sizeof(wchar_t) == 4) ?1:-1];