Extended format string checking to wprintf/wscanf

[MarcusJohnson91]

Summary

Split from D103426

[MarcusJohnson91]

This comment was removed by MarcusJohnson91.

[MarcusJohnson91]

Clang-formatted the diff.

[efriedma]

clang/lib/AST/Expr.cpp

1081

getStringAsChar16?

clang/lib/AST/Type.cpp

1979

(The discussion of the typedefs on D103426 didn't really finish.)

clang/lib/Lex/LiteralSupport.cpp

1923

The math here probably needs to change for wide strings.

clang/lib/Sema/SemaChecking.cpp

9633

The math here looks suspicious... TypeSize is not in the same units as StrRef.size().

[MarcusJohnson91]

Rebased

[floam]

This comment was removed by floam.

clang-tools-extra/clang-tidy/boost/UseToStringCheck.cpp

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace boost {
 
 namespace {
 AST_MATCHER(Type, isStrictlyInteger) {
-  return Node.isIntegerType() && !Node.isAnyCharacterType() &&
+  return Node.isIntegerType() &&
+         !Node.isAnyCharacterType(Finder->getASTContext().getLangOpts()) &&
          !Node.isBooleanType();
 }
 } // namespace
 
 void UseToStringCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       callExpr(
           hasDeclaration(functionDecl(

clang-tools-extra/clang-tidy/misc/ThrowByValueCatchByReferenceCheck.cpp

if (caughtType.isNull())
     return;
   auto *varDecl = catchStmt->getExceptionDecl();
   if (const auto *PT = caughtType.getCanonicalType()->getAs<PointerType>()) {
     const char *diagMsgCatchReference = "catch handler catches a pointer value; "
                                         "should throw a non-pointer value and "
                                         "catch by reference instead";
     // We do not diagnose when catching pointer to strings since we also allow
     // throwing string literals.
-    if (!PT->getPointeeType()->isAnyCharacterType())
+    if (!PT->getPointeeType()->isAnyCharacterType(getLangOpts()))
       diag(varDecl->getBeginLoc(), diagMsgCatchReference);
   } else if (!caughtType->isReferenceType()) {
     const char *diagMsgCatchReference = "catch handler catches by value; "
                                         "should catch by reference instead";
     // If it's not a pointer and not a reference then it must be caught "by
     // value". In this case we should emit a diagnosis message unless the type
     // is trivial.
     if (!caughtType.isTrivialType(context)) {

clang/include/clang/AST/Expr.h

static StringLiteral *CreateEmpty(const ASTContext &Ctx,
                                     unsigned CharByteWidth);
 
   StringRef getString() const {
     assert(getCharByteWidth() == 1 &&
            "This function is used in places that assume strings use char");
     return StringRef(getStrDataAsChar(), getByteLength());
   }
 
+  std::string getStringAsChar() const;
+
+  std::u16string getStringAsChar16() const {
+    assert(getCharByteWidth() == 2 &&
+           "This function is used in places that assume strings use char16_t");
+    return std::u16string(
+        reinterpret_cast<const char16_t *>(getTrailingObjects<char>()),
+        reinterpret_cast<const char16_t *>(getTrailingObjects<char>() +
+                                           getByteLength()));
+  }
+
+  std::u32string getStringAsChar32() const {
+    assert(getCharByteWidth() == 4 &&
+           "This function is used in places that assume strings use char32_t");
+    return std::u32string(
+        reinterpret_cast<const char32_t *>(getTrailingObjects<char>()),
+        reinterpret_cast<const char32_t *>(getTrailingObjects<char>() +
+                                           getByteLength()));
+  }
+
+  std::wstring getStringAsWChar() const {
+    assert((getCharByteWidth() == 2 || getCharByteWidth() == 4) &&
+           "This function is used in places that assume strings use wchar_t");
+    return std::wstring(
+        reinterpret_cast<const wchar_t *>(getTrailingObjects<char>()),
+        reinterpret_cast<const wchar_t *>(getTrailingObjects<char>() +
+                                          getByteLength()));
+  }
+
   /// Allow access to clients that need the byte representation, such as
   /// ASTWriterStmt::VisitStringLiteral().
   StringRef getBytes() const {
     // FIXME: StringRef may not be the right type to use as a result for this.
     return StringRef(getStrDataAsChar(), getByteLength());
   }
 
   void outputString(raw_ostream &OS) const;

clang/include/clang/AST/FormatString.h

protected:
   bool IsPrintf;
   const char *Position;
   const char *EndScanList;
   Kind kind;
 };
 
 class ArgType {
 public:
-  enum Kind { UnknownTy, InvalidTy, SpecificTy, ObjCPointerTy, CPointerTy,
-              AnyCharTy, CStrTy, WCStrTy, WIntTy };
+  enum Kind {
+    UnknownTy,
+    InvalidTy,
+    SpecificTy,
+    ObjCPointerTy,
+    CPointerTy,
+    AnyCharTy,
+    CStrTy,
+    WCStrTy,
+    WIntTy,
+  };
 
   /// How well a given conversion specifier matches its argument.
   enum MatchKind {
     /// The conversion specifier and the argument types are incompatible. For
     /// instance, "%d" and float.
     NoMatch = 0,
     /// The conversion specifier and the argument type are compatible. For
     /// instance, "%d" and _Bool.

clang/include/clang/AST/Type.h

public:
   /// isComplexIntegerType() can be used to test for complex integers.
   bool isIntegerType() const;     // C99 6.2.5p17 (int, char, bool, enum)
   bool isEnumeralType() const;
 
   /// Determine whether this type is a scoped enumeration type.
   bool isScopedEnumeralType() const;
   bool isBooleanType() const;
   bool isCharType() const;
-  bool isWideCharType() const;
   bool isChar8Type() const;
-  bool isChar16Type() const;
-  bool isChar32Type() const;
-  bool isAnyCharacterType() const;
+  bool isWideCharType() const;
+  bool isChar16Type(const LangOptions &LangOpts) const;
+  bool isChar32Type(const LangOptions &LangOpts) const;
+  bool isAnyCharacterType(const LangOptions &LangOpts) const;
   bool isIntegralType(const ASTContext &Ctx) const;
 
   /// Determine whether this type is an integral or enumeration type.
   bool isIntegralOrEnumerationType() const;
 
   /// Determine whether this type is an integral or unscoped enumeration type.
   bool isIntegralOrUnscopedEnumerationType() const;
   bool isUnscopedEnumerationType() const;

clang/include/clang/ASTMatchers/ASTMatchers.h

 /// \code
 ///   void a(char);
 ///   void b(wchar_t);
 ///   void c(double);
 /// \endcode
 /// functionDecl(hasAnyParameter(hasType(isAnyCharacter())))
 /// matches "a(char)", "b(wchar_t)", but not "c(double)".
 AST_MATCHER(QualType, isAnyCharacter) {
-    return Node->isAnyCharacterType();
+  return Node->isAnyCharacterType(Finder->getASTContext().getLangOpts());
 }
 
 /// Matches QualType nodes that are of any pointer type; this includes
 /// the Objective-C object pointer type, which is different despite being
 /// syntactically similar.
 ///
 /// Given
 /// \code

clang/include/clang/Basic/Builtins.def

 BUILTIN(__builtin_wcschr, "w*wC*w", "nF")
 BUILTIN(__builtin_wcscmp, "iwC*wC*", "nF")
 BUILTIN(__builtin_wcslen, "zwC*", "nF")
 BUILTIN(__builtin_wcsncmp, "iwC*wC*z", "nF")
 BUILTIN(__builtin_wmemchr, "w*wC*wz", "nF")
 BUILTIN(__builtin_wmemcmp, "iwC*wC*z", "nF")
 BUILTIN(__builtin_wmemcpy, "w*w*wC*z", "nF")
 BUILTIN(__builtin_wmemmove, "w*w*wC*z", "nF")
-BUILTIN(__builtin_realloc, "v*v*z", "nF")
+BUILTIN(__builtin_wprintf, "iwC*R.", "Fp:0:")
+BUILTIN(__builtin_wscanf,  "iwC*R.", "Fs:0:")
+BUILTIN(__builtin_fwprintf, "iP*RCw*R", "fp:1:")
+BUILTIN(__builtin_fwscanf,  "iP*RCw*R", "fs:1:")
+BUILTIN(__builtin_swprintf, "iw*RzCw*R.", "fp:2:")
+BUILTIN(__builtin_swscanf,  "iCw*RCw*R.", "fs:1:")
+BUILTIN(__builtin_vfwprintf,"iP*RCw*Ra", "fp:1:")
+BUILTIN(__builtin_vfwscanf, "iP*RCw*Ra", "fs:1:")
+BUILTIN(__builtin_vswprintf,"iw*RzCw*Ra", "fp:2:")
+BUILTIN(__builtin_vswscanf, "iCw*RCw*Ra", "fs:1:")
+BUILTIN(__builtin_vwprintf, "iCw*Ra", "fp:0:")
+BUILTIN(__builtin_vwscanf,  "iCw*Ra", "fs:0:")
 BUILTIN(__builtin_return_address, "v*IUi", "n")
 BUILTIN(__builtin_extract_return_addr, "v*v*", "n")
 BUILTIN(__builtin_frame_address, "v*IUi", "n")
 BUILTIN(__builtin___clear_cache, "vc*c*", "n")
 BUILTIN(__builtin_setjmp, "iv**", "j")
 BUILTIN(__builtin_longjmp, "vv**i", "r")
 BUILTIN(__builtin_unwind_init, "v", "")
 BUILTIN(__builtin_eh_return_data_regno, "iIi", "nc")

 LIBBUILTIN(wcschr,  "w*wC*w",   "f", "wchar.h", ALL_LANGUAGES)
 LIBBUILTIN(wcscmp,  "iwC*wC*",  "f", "wchar.h", ALL_LANGUAGES)
 LIBBUILTIN(wcslen,  "zwC*",     "f", "wchar.h", ALL_LANGUAGES)
 LIBBUILTIN(wcsncmp, "iwC*wC*z", "f", "wchar.h", ALL_LANGUAGES)
 LIBBUILTIN(wmemchr, "w*wC*wz",  "f", "wchar.h", ALL_LANGUAGES)
 LIBBUILTIN(wmemcmp, "iwC*wC*z", "f", "wchar.h", ALL_LANGUAGES)
 LIBBUILTIN(wmemcpy, "w*w*wC*z", "f", "wchar.h", ALL_LANGUAGES)
 LIBBUILTIN(wmemmove,"w*w*wC*z", "f", "wchar.h", ALL_LANGUAGES)
+LIBBUILTIN(wprintf, "iwC*R.",     "fp:0:", "wchar.h", ALL_LANGUAGES)
+LIBBUILTIN(wscanf,  "iwC*R.",     "fs:0:", "wchar.h", ALL_LANGUAGES)
+LIBBUILTIN(fwprintf, "iP*RCw*R",   "fp:1:", "wchar.h", ALL_LANGUAGES)
+LIBBUILTIN(fwscanf,  "iP*RCw*R",   "fs:1:", "wchar.h", ALL_LANGUAGES)
+LIBBUILTIN(swprintf, "iw*RzCw*R.", "fp:2:", "wchar.h", ALL_LANGUAGES)
+LIBBUILTIN(swscanf,  "iCw*RCw*R.", "fs:1:", "wchar.h", ALL_LANGUAGES)
+LIBBUILTIN(vfwprintf,"iP*RCw*Ra",  "fp:1:", "wchar.h", ALL_LANGUAGES)
+LIBBUILTIN(vfwscanf, "iP*RCw*Ra",  "fs:1:", "wchar.h", ALL_LANGUAGES)
+LIBBUILTIN(vswprintf,"iw*RzCw*Ra", "fp:2:", "wchar.h", ALL_LANGUAGES)
+LIBBUILTIN(vswscanf, "iCw*RCw*Ra", "fs:1:", "wchar.h", ALL_LANGUAGES)
+LIBBUILTIN(vwprintf, "iCw*Ra",     "fp:0:", "wchar.h", ALL_LANGUAGES)
+LIBBUILTIN(vwscanf,  "iCw*Ra",     "fs:0:", "wchar.h", ALL_LANGUAGES)
 
 // C99
 // In some systems setjmp is a macro that expands to _setjmp. We undefine
 // it here to avoid having two identical LIBBUILTIN entries.
 #undef setjmp
 LIBBUILTIN(setjmp, "iJ",          "fjT",   "setjmp.h", ALL_LANGUAGES)
 LIBBUILTIN(longjmp, "vJi",        "frT",   "setjmp.h", ALL_LANGUAGES)
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_init_for_function_type : Error<
   "cannot create object of function type %0">;
 def warn_format_nonliteral_noargs : Warning<
   "format string is not a string literal (potentially insecure)">,
   InGroup<FormatSecurity>;
 def warn_format_nonliteral : Warning<
   "format string is not a string literal">,
   InGroup<FormatNonLiteral>, DefaultIgnore;
-
+def err_format_invalid_type : Error<
+  "format strings type is invalid">;
 def err_unexpected_interface : Error<
   "unexpected interface name %0: expected expression">;
 def err_ref_non_value : Error<"%0 does not refer to a value">;
 def err_ref_vm_type : Error<
   "cannot refer to declaration with a variably modified type inside block">;
 def err_ref_flexarray_type : Error<
   "cannot refer to declaration of structure variable with flexible array member "
   "inside block">;
def warn_ptr_arith_exceeds_max_addressable_bounds : Warning<
   "address space containing %2-bit (%3-byte) elements (max possible %4 element%s5)">,
   InGroup<ArrayBounds>;
 def warn_array_index_exceeds_max_addressable_bounds : Warning<
   "array index %0 refers past the last possible element for an array in %1-bit "
   "address space containing %2-bit (%3-byte) elements (max possible %4 element%s5)">,
   InGroup<ArrayBounds>;
 def note_array_declared_here : Note<
   "array %0 declared here">;
-
 def warn_printf_insufficient_data_args : Warning<
   "more '%%' conversions than data arguments">, InGroup<FormatInsufficientArgs>;
 def warn_printf_data_arg_not_used : Warning<
   "data argument not used by format string">, InGroup<FormatExtraArgs>;
 def warn_format_invalid_conversion : Warning<
   "invalid conversion specifier '%0'">, InGroup<FormatInvalidSpecifier>;
 def warn_printf_incomplete_specifier : Warning<
   "incomplete format specifier">, InGroup<Format>;

 def warn_static_array_too_small : Warning<
   "array argument is too small; %select{contains %0 elements|is of size %0}2,"
   " callee requires at least %1">,
   InGroup<ArrayBounds>;
 def note_callee_static_array : Note<
   "callee declares array parameter as static here">;
 def warn_empty_format_string : Warning<
   "format string is empty">, InGroup<FormatZeroLength>;
-def warn_format_string_is_wide_literal : Warning<
-  "format string should not be a wide string">, InGroup<Format>;
 def warn_printf_format_string_contains_null_char : Warning<
   "format string contains '\\0' within the string body">, InGroup<Format>;
 def warn_printf_format_string_not_null_terminated : Warning<
   "format string is not null-terminated">, InGroup<Format>;
 def warn_printf_asterisk_missing_arg : Warning<
   "'%select{*|.*}0' specified field %select{width|precision}0 is missing a matching 'int' argument">,
   InGroup<Format>;
 def warn_printf_asterisk_wrong_type : Warning<

clang/lib/AST/Expr.cpp

 #include "clang/AST/RecordLayout.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Lex/LiteralSupport.h"
+#include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstring>
 using namespace clang;
 
 const Expr *Expr::getBestDynamicClassTypeExpr() const {
unsigned StringLiteral::mapCharByteWidth(TargetInfo const &Target,
   }
   assert((CharByteWidth & 7) == 0 && "Assumes character size is byte multiple");
   CharByteWidth /= 8;
   assert((CharByteWidth == 1 || CharByteWidth == 2 || CharByteWidth == 4) &&
          "The only supported character byte widths are 1,2 and 4!");
   return CharByteWidth;
 }
 
+std::string StringLiteral::getStringAsChar() const {
+  std::string Output = "";
+
+  switch (getKind()) {
+  case StringKind::Ascii:
+    LLVM_FALLTHROUGH;
+  case StringKind::UTF8:
+    return getTrailingObjects<char>();
+    break;
+  case StringKind::UTF16: {
+    ArrayRef<char> AR(getTrailingObjects<char>(),
+                      getTrailingObjects<char>() + getByteLength());
+    if (llvm::convertUTF16ToUTF8String(AR, Output)) {
+      return Output;
+    }
+    break;
+  }
+  case StringKind::UTF32: {
+    ArrayRef<char> AR(getTrailingObjects<char>(),
+                      getTrailingObjects<char>() + getByteLength());
+    if (llvm::convertUTF32ToUTF8String(AR, Output)) {
+      return Output;
+    }
+    break;
+  }
+  case StringKind::Wide: {
+    if (llvm::convertWideToUTF8(getStringAsWChar(), Output)) {
+      return Output;
+    }
+    break;
+  }
+  }
+}
+
 StringLiteral::StringLiteral(const ASTContext &Ctx, StringRef Str,
                              StringKind Kind, bool Pascal, QualType Ty,
                              const SourceLocation *Loc,
                              unsigned NumConcatenated)
     : Expr(StringLiteralClass, Ty, VK_LValue, OK_Ordinary) {
   assert(Ctx.getAsConstantArrayType(Ty) &&
          "StringLiteral must be of constant array type!");
   unsigned CharByteWidth = mapCharByteWidth(Ctx.getTargetInfo(), Kind);

 /// O(n) if one wants to get the location of byte for all the tokens in a
 /// string.
 ///
 SourceLocation
 StringLiteral::getLocationOfByte(unsigned ByteNo, const SourceManager &SM,
                                  const LangOptions &Features,
                                  const TargetInfo &Target, unsigned *StartToken,
                                  unsigned *StartTokenByteOffset) const {
-  assert((getKind() == StringLiteral::Ascii ||
-          getKind() == StringLiteral::UTF8) &&
-         "Only narrow string literals are currently supported");
-
+  assert(
+      (getKind() == StringLiteral::Ascii || getKind() == StringLiteral::UTF8) &&
   // Loop over all of the tokens in this string until we find the one that
   // contains the byte we're looking for.
   unsigned TokNo = 0;
   unsigned StringOffset = 0;
   if (StartToken)
     TokNo = *StartToken;
   if (StartTokenByteOffset) {
     StringOffset = *StartTokenByteOffset;

clang/lib/AST/ExprCXX.cpp

UserDefinedLiteral::getLiteralOperatorKind() const {
   if (getNumArgs() == 2)
     return LOK_String;
 
   assert(getNumArgs() == 1 && "unexpected #args in literal operator call");
   QualType ParamTy =
     cast<FunctionDecl>(getCalleeDecl())->getParamDecl(0)->getType();
   if (ParamTy->isPointerType())
     return LOK_Raw;
-  if (ParamTy->isAnyCharacterType())
+  if (ParamTy->isAnyCharacterType(getCalleeDecl()->getLangOpts()))
     return LOK_Character;
   if (ParamTy->isIntegerType())
     return LOK_Integer;
   if (ParamTy->isFloatingType())
     return LOK_Floating;
 
   llvm_unreachable("unknown kind of literal operator");
 }

clang/lib/AST/OSLog.cpp

case Builtin::BI__builtin_os_log_format:
     VarArgs = Args.slice(2);
     break;
   default:
     llvm_unreachable("non-os_log builtin passed to computeOSLogBufferLayout");
   }
 
   const StringLiteral *Lit = cast<StringLiteral>(StringArg->IgnoreParenCasts());
   assert(Lit && (Lit->isAscii() || Lit->isUTF8()));
-  StringRef Data = Lit->getString();
+  std::string String = Lit->getStringAsChar();
+  StringRef Data(String);
+
   OSLogFormatStringHandler H(VarArgs);
   ParsePrintfString(H, Data.begin(), Data.end(), Ctx.getLangOpts(),
                     Ctx.getTargetInfo(), /*isFreeBSDKPrintf*/ false);
 
   H.computeLayout(Ctx, Layout);
   return true;
 }

clang/lib/AST/TemplateBase.cpp

static void printIntegral(const TemplateArgument &TemplArg, raw_ostream &Out,
   } else if (T->isCharType()) {
     if (IncludeType) {
       if (T->isSpecificBuiltinType(BuiltinType::SChar))
         Out << "(signed char)";
       else if (T->isSpecificBuiltinType(BuiltinType::UChar))
         Out << "(unsigned char)";
     }
     CharacterLiteral::print(Val.getZExtValue(), CharacterLiteral::Ascii, Out);
-  } else if (T->isAnyCharacterType() && !Policy.MSVCFormatting) {
+  } else if (T->isAnyCharacterType(
+                 T->getAs<TypedefType>()->getDecl()->getLangOpts()) &&
+             !Policy.MSVCFormatting) {
     CharacterLiteral::CharacterKind Kind;
     if (T->isWideCharType())
       Kind = CharacterLiteral::Wide;
     else if (T->isChar8Type())
       Kind = CharacterLiteral::UTF8;
-    else if (T->isChar16Type())
+    else if (T->isChar16Type(T->getAs<TypedefType>()->getDecl()->getLangOpts()))
       Kind = CharacterLiteral::UTF16;
-    else if (T->isChar32Type())
+    else if (T->isChar32Type(T->getAs<TypedefType>()->getDecl()->getLangOpts()))
       Kind = CharacterLiteral::UTF32;
     else
       Kind = CharacterLiteral::Ascii;
     CharacterLiteral::print(Val.getExtValue(), Kind, Out);
   } else if (IncludeType) {
     if (const auto *BT = T->getAs<BuiltinType>()) {
       switch (BT->getKind()) {
       case BuiltinType::ULongLong:

clang/lib/AST/Type.cpp

 }
 
 bool Type::isChar8Type() const {
   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() == BuiltinType::Char8;
   return false;
 }
 
-bool Type::isChar16Type() const {
+bool Type::isChar16Type(const LangOptions &LangOpts) const {
   if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
-    return BT->getKind() == BuiltinType::Char16;
+    if (BT->getKind() == BuiltinType::Char16)
+      return true;
+  if (!LangOpts.CPlusPlus) {
+    QualType Desugar = this->getLocallyUnqualifiedSingleStepDesugaredType();
+
+    while (!Desugar->isCanonicalUnqualified()) {
+      if (Desugar.getAsString() == "char16_t") {
+        return true;
+      }
+      Desugar = Desugar->getLocallyUnqualifiedSingleStepDesugaredType();
+    }
+  }
   return false;
 }
 
-bool Type::isChar32Type() const {
+bool Type::isChar32Type(const LangOptions &LangOpts) const {
   if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
-    return BT->getKind() == BuiltinType::Char32;
+    if (BT->getKind() == BuiltinType::Char32)
+      return true;
+  if (!LangOpts.CPlusPlus) {
+    QualType Desugar = this->getLocallyUnqualifiedSingleStepDesugaredType();
+
+    while (!Desugar->isCanonicalUnqualified()) {
+      if (Desugar.getAsString() == "char32_t") {
+        return true;
+      }
+      Desugar = Desugar->getLocallyUnqualifiedSingleStepDesugaredType();
+    }
+  }
   return false;
 }
 
-/// Determine whether this type is any of the built-in character
-/// types.
-bool Type::isAnyCharacterType() const {
-  const auto *BT = dyn_cast<BuiltinType>(CanonicalType);
-  if (!BT) return false;
+/// Determine whether this type is any of the character types.
+bool Type::isAnyCharacterType(const LangOptions &LangOpts) const {
+  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
     switch (BT->getKind()) {
-  default: return false;
-  case BuiltinType::Char_U:
-  case BuiltinType::UChar:
-  case BuiltinType::WChar_U:
     case BuiltinType::Char8:
     case BuiltinType::Char16:
     case BuiltinType::Char32:
     case BuiltinType::Char_S:
+    case BuiltinType::Char_U:
     case BuiltinType::SChar:
+    case BuiltinType::UChar:
     case BuiltinType::WChar_S:
+    case BuiltinType::WChar_U:
       return true;
     }
   }
+  if (!LangOpts.CPlusPlus) {
+    return isChar16Type(LangOpts) | isChar32Type(LangOpts);
+  }
+  return false;
+}
 
 /// isSignedIntegerType - Return true if this is an integer type that is
 /// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
 /// an enum decl which has a signed representation
 bool Type::isSignedIntegerType() const {
   if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
     return BT->getKind() >= BuiltinType::Char_S &&
            BT->getKind() <= BuiltinType::Int128;

clang/lib/Lex/LiteralSupport.cpp

unsigned StringLiteralParser::getOffsetOfStringByte(const Token &Tok,
 
   const char *SpellingStart = SpellingPtr;
   const char *SpellingEnd = SpellingPtr+TokLen;
 
   // Handle UTF-8 strings just like narrow strings.
   if (SpellingPtr[0] == 'u' && SpellingPtr[1] == '8')
     SpellingPtr += 2;
 
-  assert(SpellingPtr[0] != 'L' && SpellingPtr[0] != 'u' &&
-         SpellingPtr[0] != 'U' && "Doesn't handle wide or utf strings yet");
+  // Handle UTF-16 strings
+  if (SpellingPtr[0] == 'u' && SpellingPtr[1] != '8')
+    SpellingPtr += 1;
+
+  // Handle UTF-32 strings
+  if (SpellingPtr[0] == 'U')
+    SpellingPtr += 1;
+
+  // Handle wide strings
+  if (SpellingPtr[0] == 'L')
+    SpellingPtr += 1;
 
   // For raw string literals, this is easy.
   if (SpellingPtr[0] == 'R') {
     assert(SpellingPtr[1] == '"' && "Should be a raw string literal!");
     // Skip 'R"'.
     SpellingPtr += 2;
     while (*SpellingPtr != '(') {
       ++SpellingPtr;
unsigned StringLiteralParser::getOffsetOfStringByte(const Token &Tok,
   ++SpellingPtr;
 
   // Skip over bytes until we find the offset we're looking for.
   while (ByteNo) {
     assert(SpellingPtr < SpellingEnd && "Didn't find byte offset!");
 
     // Step over non-escapes simply.
     if (*SpellingPtr != '\\') {
       ++SpellingPtr;
       --ByteNo;
       continue;
     }
 
     // Otherwise, this is an escape character.  Advance over it.
     bool HadError = false;
     if (SpellingPtr[1] == 'u' || SpellingPtr[1] == 'U') {
       const char *EscapePtr = SpellingPtr;

clang/lib/Sema/SemaCast.cpp

if (IsDereference) {
     DestTy = DestType->getPointeeType();
   }
 
   // Cast is compatible if the types are the same.
   if (Context.hasSameUnqualifiedType(DestTy, SrcTy)) {
     return;
   }
   // or one of the types is a char or void type
-  if (DestTy->isAnyCharacterType() || DestTy->isVoidType() ||
-      SrcTy->isAnyCharacterType() || SrcTy->isVoidType()) {
+  if (DestTy->isAnyCharacterType(getLangOpts()) || DestTy->isVoidType() ||
+      SrcTy->isAnyCharacterType(getLangOpts()) || SrcTy->isVoidType()) {
     return;
   }
   // or one of the types is a tag type.
   if (SrcTy->getAs<TagType>() || DestTy->getAs<TagType>()) {
     return;
   }
 
   // FIXME: Scoped enums?

clang/lib/Sema/SemaChecking.cpp

void Sema::checkFortifiedBuiltinMemoryFunction(FunctionDecl *FD,
   }
 
   case Builtin::BIsprintf:
   case Builtin::BI__builtin___sprintf_chk: {
     size_t FormatIndex = BuiltinID == Builtin::BIsprintf ? 1 : 3;
     auto *FormatExpr = TheCall->getArg(FormatIndex)->IgnoreParenImpCasts();
 
     if (auto *Format = dyn_cast<StringLiteral>(FormatExpr)) {
+      str::string String = Format->getStringAsChar();
+      StringRef FormatStrRef(String);
 
-      if (!Format->isAscii() && !Format->isUTF8())
-        return;
-
-      StringRef FormatStrRef = Format->getString();
       EstimateSizeFormatHandler H(FormatStrRef);
       const char *FormatBytes = FormatStrRef.data();
       const ConstantArrayType *T =
           Context.getAsConstantArrayType(Format->getType());
       assert(T && "String literal not of constant array type!");
-      size_t TypeSize = T->getSize().getZExtValue();
+      size_t TypeSize = String.size();
 
       // In case there's a null byte somewhere.
       size_t StrLen =
           std::min(std::max(TypeSize, size_t(1)) - 1, FormatStrRef.find(0));
       if (!analyze_format_string::ParsePrintfString(
               H, FormatBytes, FormatBytes + StrLen, getLangOpts(),
               Context.getTargetInfo(), false)) {
         DiagID = diag::warn_fortify_source_format_overflow;

  public:
   FormatStringLiteral(const StringLiteral *fexpr, int64_t Offset = 0)
       : FExpr(fexpr), Offset(Offset) {}
 
   StringRef getString() const {
     return FExpr->getString().drop_front(Offset);
   }
 
+  std::string getStringAsChar() const { return FExpr->getStringAsChar(); }
+
+  std::u16string getStringAsChar16() const {
+    return FExpr->getStringAsChar16();
+  }
+
+  std::u32string getStringAsChar32() const {
+    return FExpr->getStringAsChar32();
+  }
+
+  std::wstring getStringAsWChar() const { return FExpr->getStringAsWChar(); }
+
   unsigned getByteLength() const {
     return FExpr->getByteLength() - getCharByteWidth() * Offset;
   }
 
   unsigned getLength() const { return FExpr->getLength() - Offset; }
   unsigned getCharByteWidth() const { return FExpr->getCharByteWidth(); }
 
   StringLiteral::StringKind getKind() const { return FExpr->getKind(); }
tryAgain:
 
   default:
     return SLCT_NotALiteral;
   }
 }
 
 Sema::FormatStringType Sema::GetFormatStringType(const FormatAttr *Format) {
   return llvm::StringSwitch<FormatStringType>(Format->getType()->getName())
-      .Case("scanf", FST_Scanf)
-      .Cases("printf", "printf0", FST_Printf)
+      .Cases("scanf", "wscanf", FST_Scanf)
+      .Cases("printf", "printf0", "wprintf", FST_Printf)
       .Cases("NSString", "CFString", FST_NSString)
       .Case("strftime", FST_Strftime)
       .Case("strfmon", FST_Strfmon)
       .Cases("kprintf", "cmn_err", "vcmn_err", "zcmn_err", FST_Kprintf)
       .Case("freebsd_kprintf", FST_FreeBSDKPrintf)
       .Case("os_trace", FST_OSLog)
       .Case("os_log", FST_OSLog)
       .Default(FST_Unknown);
static void CheckFormatString(Sema &S, const FormatStringLiteral *FExpr,
                               bool HasVAListArg, unsigned format_idx,
                               unsigned firstDataArg,
                               Sema::FormatStringType Type,
                               bool inFunctionCall,
                               Sema::VariadicCallType CallType,
                               llvm::SmallBitVector &CheckedVarArgs,
                               UncoveredArgHandler &UncoveredArg,
                               bool IgnoreStringsWithoutSpecifiers) {
-  // CHECK: is the format string a wide literal?
-  if (!FExpr->isAscii() && !FExpr->isUTF8()) {
+  // CHECK: is the format string's type valid?
+  if (!FExpr->isAscii() && !FExpr->isUTF8() && !FExpr->isUTF16() &&
+      !FExpr->isUTF32() && !FExpr->isWide()) {
     CheckFormatHandler::EmitFormatDiagnostic(
         S, inFunctionCall, Args[format_idx],
-        S.PDiag(diag::warn_format_string_is_wide_literal), FExpr->getBeginLoc(),
+        S.PDiag(diag::err_format_invalid_type), FExpr->getBeginLoc(),
         /*IsStringLocation*/ true, OrigFormatExpr->getSourceRange());
     return;
   }
+  std::string String = FExpr->getStringAsChar();
 
-  // Str - The format string.  NOTE: this is NOT null-terminated!
-  StringRef StrRef = FExpr->getString();
+  StringRef StrRef(String);
   const char *Str = StrRef.data();
+
   // Account for cases where the string literal is truncated in a declaration.
   const ConstantArrayType *T =
       S.Context.getAsConstantArrayType(FExpr->getType());
   assert(T && "String literal not of constant array type!");
   size_t TypeSize = T->getSize().getZExtValue();
+
   size_t StrLen = std::min(std::max(TypeSize, size_t(1)) - 1, StrRef.size());
   const unsigned numDataArgs = Args.size() - firstDataArg;
 
   if (IgnoreStringsWithoutSpecifiers &&
       !analyze_format_string::parseFormatStringHasFormattingSpecifiers(
           Str, Str + StrLen, S.getLangOpts(), S.Context.getTargetInfo()))
     return;
 
   // Emit a warning if the string literal is truncated and does not contain an
   // embedded null character.
-  if (TypeSize <= StrRef.size() &&
+  if (TypeSize < StrRef.size() &&
       StrRef.substr(0, TypeSize).find('\0') == StringRef::npos) {
     CheckFormatHandler::EmitFormatDiagnostic(
         S, inFunctionCall, Args[format_idx],
         S.PDiag(diag::warn_printf_format_string_not_null_terminated),
         FExpr->getBeginLoc(),
         /*IsStringLocation=*/true, OrigFormatExpr->getSourceRange());
     return;
   }
if (Type == Sema::FST_Printf || Type == Sema::FST_NSString ||
     if (!analyze_format_string::ParseScanfString(H, Str, Str + StrLen,
                                                  S.getLangOpts(),
                                                  S.Context.getTargetInfo()))
       H.DoneProcessing();
   } // TODO: handle other formats
 }
 
 bool Sema::FormatStringHasSArg(const StringLiteral *FExpr) {
-  // Str - The format string.  NOTE: this is NOT null-terminated!
-  StringRef StrRef = FExpr->getString();
-  const char *Str = StrRef.data();
   // Account for cases where the string literal is truncated in a declaration.
-  const ConstantArrayType *T = Context.getAsConstantArrayType(FExpr->getType());
+  const ConstantArrayType *T = Context.getAsConstantArrayType(
+      FExpr->getType()); // FExpr->getType() is a QualType, and it's no longer
+                         // relevent because we changed the format literal for
+                         // type checking?
   assert(T && "String literal not of constant array type!");
   size_t TypeSize = T->getSize().getZExtValue();
+
+  std::string String = FExpr->getStringAsChar();
+  StringRef StrRef(String);
+  const char *Str = StrRef.data();
+
   size_t StrLen = std::min(std::max(TypeSize, size_t(1)) - 1, StrRef.size());
   return analyze_format_string::ParseFormatStringHasSArg(Str, Str + StrLen,
                                                          getLangOpts(),
                                                          Context.getTargetInfo());
 }
 
 //===--- CHECK: Warn on use of wrong absolute value function. -------------===//
 
 // Returns the related absolute value function that is larger, of 0 if one

clang/lib/Sema/SemaDeclAttr.cpp

static void handleFormatArgAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   ParamIdx Idx;
   if (!checkFunctionOrMethodParameterIndex(S, D, AL, 1, IdxExpr, Idx))
     return;
 
   // Make sure the format string is really a string.
   QualType Ty = getFunctionOrMethodParamType(D, Idx.getASTIndex());
 
   bool NotNSStringTy = !isNSStringType(Ty, S.Context);
-  if (NotNSStringTy &&
-      !isCFStringType(Ty, S.Context) &&
+  if (NotNSStringTy && !isCFStringType(Ty, S.Context) &&
       (!Ty->isPointerType() ||
-       !Ty->castAs<PointerType>()->getPointeeType()->isCharType())) {
+       !Ty->castAs<PointerType>()->getPointeeType()->isAnyCharacterType(
+           S.getLangOpts()))) {
     S.Diag(AL.getLoc(), diag::err_format_attribute_not)
         << "a string type" << IdxExpr->getSourceRange()
         << getFunctionOrMethodParamRange(D, 0);
     return;
   }
   Ty = getFunctionOrMethodResultType(D);
   if (!isNSStringType(Ty, S.Context, /*AllowNSAttributedString=*/true) &&
       !isCFStringType(Ty, S.Context) &&
       (!Ty->isPointerType() ||
-       !Ty->castAs<PointerType>()->getPointeeType()->isCharType())) {
+       !Ty->castAs<PointerType>()->getPointeeType()->isAnyCharacterType(
+           S.getLangOpts()))) {
     S.Diag(AL.getLoc(), diag::err_format_attribute_result_not)
         << (NotNSStringTy ? "string type" : "NSString")
         << IdxExpr->getSourceRange() << getFunctionOrMethodParamRange(D, 0);
     return;
   }
 
   D->addAttr(::new (S.Context) FormatArgAttr(S.Context, AL, Idx));
 }
return llvm::StringSwitch<FormatAttrKind>(Format)
       // Check for formats that get handled specially.
       .Case("NSString", NSStringFormat)
       .Case("CFString", CFStringFormat)
       .Case("strftime", StrftimeFormat)
 
       // Otherwise, check for supported formats.
       .Cases("scanf", "printf", "printf0", "strfmon", SupportedFormat)
       .Cases("cmn_err", "vcmn_err", "zcmn_err", SupportedFormat)
+      .Cases("wscanf", "wprintf", SupportedFormat)
       .Case("kprintf", SupportedFormat)         // OpenBSD.
       .Case("freebsd_kprintf", SupportedFormat) // FreeBSD.
       .Case("os_trace", SupportedFormat)
       .Case("os_log", SupportedFormat)
 
       .Cases("gcc_diag", "gcc_cdiag", "gcc_cxxdiag", "gcc_tdiag", IgnoredFormat)
       .Default(InvalidFormat);
 }
if (F->getType() == Format &&
         F->setRange(CI.getRange());
       return nullptr;
     }
   }
 
   return ::new (Context) FormatAttr(Context, CI, Format, FormatIdx, FirstArg);
 }
 
-/// Handle __attribute__((format(type,idx,firstarg))) attributes based on
+/// Handle __attribute__((format(type,format_idx,firstarg))) attributes based on
 /// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
 static void handleFormatAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   if (!AL.isArgIdent(0)) {
     S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
         << AL << 1 << AANT_ArgumentIdentifier;
     return;
   }
 
   // In C++ the implicit 'this' function parameter also counts, and they are
   // counted from one.
   bool HasImplicitThisParam = isInstanceMethod(D);
   unsigned NumArgs = getFunctionOrMethodNumParams(D) + HasImplicitThisParam;
 
   IdentifierInfo *II = AL.getArgAsIdent(0)->Ident;
   StringRef Format = II->getName();
 
   if (normalizeName(Format)) {
     // If we've modified the string name, we need a new identifier for it.
     II = &S.Context.Idents.get(Format);
   }
 
-  // Check for supported formats.
+  // Check the type parameter
   FormatAttrKind Kind = getFormatAttrKind(Format);
 
   if (Kind == IgnoredFormat)
     return;
 
   if (Kind == InvalidFormat) {
     S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported)
         << AL << II->getName();
     return;
   }
 
-  // checks for the 2nd argument
+  // Check the format_idx parameter
   Expr *IdxExpr = AL.getArgAsExpr(1);
   uint32_t Idx;
   if (!checkUInt32Argument(S, AL, IdxExpr, Idx, 2))
     return;
 
   if (Idx < 1 || Idx > NumArgs) {
     S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
         << AL << 2 << IdxExpr->getSourceRange();
if (Kind == CFStringFormat) {
     // semantics?
     if (!isNSStringType(Ty, S.Context, /*AllowNSAttributedString=*/true)) {
       S.Diag(AL.getLoc(), diag::err_format_attribute_not)
         << "an NSString" << IdxExpr->getSourceRange()
         << getFunctionOrMethodParamRange(D, ArgIdx);
       return;
     }
   } else if (!Ty->isPointerType() ||
-             !Ty->castAs<PointerType>()->getPointeeType()->isCharType()) {
+             !Ty->castAs<PointerType>()->getPointeeType()->isAnyCharacterType(
+                 S.getLangOpts())) {
     S.Diag(AL.getLoc(), diag::err_format_attribute_not)
       << "a string type" << IdxExpr->getSourceRange()
       << getFunctionOrMethodParamRange(D, ArgIdx);
     return;
   }
 
-  // check the 3rd argument
+  // check the firstarg parameter
   Expr *FirstArgExpr = AL.getArgAsExpr(2);
   uint32_t FirstArg;
   if (!checkUInt32Argument(S, AL, FirstArgExpr, FirstArg, 3))
     return;
 
   // check if the function is variadic if the 3rd argument non-zero
   if (FirstArg != 0) {
     if (isFunctionOrMethodVariadic(D)) {

clang/lib/Sema/SemaExpr.cpp

static void diagnoseStringPlusChar(Sema &Self, SourceLocation OpLoc,
 
   const QualType StringType = StringRefExpr->getType();
 
   // Return if not a PointerType.
   if (!StringType->isAnyPointerType())
     return;
 
   // Return if not a CharacterType.
-  if (!StringType->getPointeeType()->isAnyCharacterType())
+  if (!StringType->getPointeeType()->isAnyCharacterType(Self.getLangOpts()))
     return;
 
   ASTContext &Ctx = Self.getASTContext();
   SourceRange DiagRange(LHSExpr->getBeginLoc(), RHSExpr->getEndLoc());
 
   const QualType CharType = CharExpr->getType();
-  if (!CharType->isAnyCharacterType() &&
+  if (!CharType->isAnyCharacterType(Self.getLangOpts()) &&
       CharType->isIntegerType() &&
       llvm::isUIntN(Ctx.getCharWidth(), CharExpr->getValue())) {
     Self.Diag(OpLoc, diag::warn_string_plus_char)
         << DiagRange << Ctx.CharTy;
   } else {
     Self.Diag(OpLoc, diag::warn_string_plus_char)
         << DiagRange << CharExpr->getType();
   }

clang/lib/Sema/SemaExprObjC.cpp

case CharacterLiteral::UTF8:
       NumberType = Context.CharTy;
       break;
 
     case CharacterLiteral::Wide:
       NumberType = Context.getWideCharType();
       break;
 
     case CharacterLiteral::UTF16:
-      NumberType = Context.Char16Ty;
+      NumberType = Context.getChar16Type();
       break;
 
     case CharacterLiteral::UTF32:
-      NumberType = Context.Char32Ty;
+      NumberType = Context.getChar32Type();
       break;
     }
   }
 
   // Look for the appropriate method within NSNumber.
   // Construct the literal.
   SourceRange NR(Number->getSourceRange());
   ObjCMethodDecl *Method = getNSNumberFactoryMethod(*this, AtLoc, NumberType,
if (const CharacterLiteral *Char =
         ValueType = Context.CharTy;
         break;
 
       case CharacterLiteral::Wide:
         ValueType = Context.getWideCharType();
         break;
 
       case CharacterLiteral::UTF16:
-        ValueType = Context.Char16Ty;
+        ValueType = Context.getChar16Type();
         break;
 
       case CharacterLiteral::UTF32:
-        ValueType = Context.Char32Ty;
+        ValueType = Context.getChar32Type();
         break;
       }
     }
     // FIXME:  Do I need to do anything special with BoolTy expressions?
 
     // Look for the appropriate method within NSNumber.
     BoxingMethod = getNSNumberFactoryMethod(*this, Loc, ValueType);
     BoxedType = NSNumberPointer;

clang/lib/Sema/SemaFixItUtils.cpp

if (S.LangOpts.CPlusPlus11)
       return "nullptr";
     if (isMacroDefined(S, Loc, "NULL"))
       return "NULL";
   }
   if (T.isCharType())
     return "'\\0'";
   if (T.isWideCharType())
     return "L'\\0'";
-  if (T.isChar16Type())
+  if (T.isChar16Type(S.getLangOpts()))
     return "u'\\0'";
-  if (T.isChar32Type())
+  if (T.isChar32Type(S.getLangOpts()))
     return "U'\\0'";
   return "0";
 }
 
 std::string
 Sema::getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const {
   if (T->isScalarType()) {
     std::string s = getScalarZeroExpressionForType(*T, Loc, *this);

clang/lib/Sema/SemaOverload.cpp

bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
   //   A prvalue of type char16_t, char32_t, or wchar_t (3.9.1) can be converted
   //   to an rvalue a prvalue of the first of the following types that can
   //   represent all the values of its underlying type: int, unsigned int,
   //   long int, unsigned long int, long long int, or unsigned long long int.
   //   If none of the types in that list can represent all the values of its
   //   underlying type, an rvalue a prvalue of type char16_t, char32_t,
   //   or wchar_t can be converted to an rvalue a prvalue of its underlying
   //   type.
-  if (FromType->isAnyCharacterType() && !FromType->isCharType() &&
+  if (FromType->isAnyCharacterType(getLangOpts()) && !FromType->isCharType() &&
       ToType->isIntegerType()) {
     // Determine whether the type we're converting from is signed or
     // unsigned.
     bool FromIsSigned = FromType->isSignedIntegerType();
     uint64_t FromSize = Context.getTypeSize(FromType);
 
     // The types we'll try to promote to, in the appropriate
     // order. Try each of these types.

clang/lib/Sema/SemaTemplate.cpp

Sema::BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg,
   // IntegerLiteral with enum type.  The integer type of an enum type can be of
   // any integral type with C++11 enum classes, make sure we create the right
   // type of literal for it.
   QualType T = OrigT;
   if (const EnumType *ET = OrigT->getAs<EnumType>())
     T = ET->getDecl()->getIntegerType();
 
   Expr *E;
-  if (T->isAnyCharacterType()) {
+  if (T->isAnyCharacterType(getLangOpts())) {
     CharacterLiteral::CharacterKind Kind;
     if (T->isWideCharType())
       Kind = CharacterLiteral::Wide;
     else if (T->isChar8Type() && getLangOpts().Char8)
       Kind = CharacterLiteral::UTF8;
-    else if (T->isChar16Type())
+    else if (T->isChar16Type(getLangOpts()))
       Kind = CharacterLiteral::UTF16;
-    else if (T->isChar32Type())
+    else if (T->isChar32Type(getLangOpts()))
       Kind = CharacterLiteral::UTF32;
     else
       Kind = CharacterLiteral::Ascii;
 
     E = new (Context) CharacterLiteral(Arg.getAsIntegral().getZExtValue(),
                                        Kind, T, Loc);
   } else if (T->isBooleanType()) {
     E = new (Context) CXXBoolLiteralExpr(Arg.getAsIntegral().getBoolValue(),

clang/lib/StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp

int ArgIndex =
           .Cases("swprintf", "snprintf", "vswprintf", "vsnprintf", "memcpy",
                  "memmove", "memset", "strncpy", "strncat", DEPR_ONLY)
           .Default(UNKNOWN_CALL);
 
   assert(ArgIndex != UNKNOWN_CALL && "Unsupported function");
   bool BoundsProvided = ArgIndex == DEPR_ONLY;
 
   if (!BoundsProvided) {
-    // Currently we only handle (not wide) string literals. It is possible to do
-    // better, either by looking at references to const variables, or by doing
+    // Currently we only handle string literals. It is possible to do better
+    // either by looking at references to const variables, or by doing
     // real flow analysis.
     auto FormatString =
         dyn_cast<StringLiteral>(CE->getArg(ArgIndex)->IgnoreParenImpCasts());
-    if (FormatString &&
-        FormatString->getString().find("%s") == StringRef::npos &&
-        FormatString->getString().find("%[") == StringRef::npos)
+
+    std::string String = FormatString->getStringAsChar();
+    StringRef StrRef = StringRef(String);
+
+    if (FormatString && StrRef.find("%s") == StringRef::npos &&
+        StrRef.find("%[") == StringRef::npos)
       BoundsProvided = true;
   }
 
   SmallString<128> Buf1;
   SmallString<512> Buf2;
   llvm::raw_svector_ostream Out1(Buf1);
   llvm::raw_svector_ostream Out2(Buf2);
 

clang/test/Sema/format-strings-c90.c

 /* RUN: %clang_cc1 -fsyntax-only -verify -triple i386-apple-darwin9 -Wformat-non-iso -std=c89 %s
  */
 
-int scanf(const char * restrict, ...);
 int printf(const char *restrict, ...);
+int scanf(const char *restrict, ...);
+int wprintf(const wchar_t *restrict, ...);
+int wscanf(const wchar_t *restrict, ...);
 
 void foo(char **sp, float *fp, int *ip) {
   scanf("%as", sp); /* expected-warning{{'a' length modifier is not supported by ISO C}} */
   scanf("%a[abc]", sp); /* expected-warning{{'a' length modifier is not supported by ISO C}} */
+  wscanf(L"%as", sp);   /* expected-warning{{'a' length modifier is not supported by ISO C}} */
+  wscanf(L"%a[abc]", sp); /* expected-warning{{'a' length modifier is not supported by ISO C}} */
 
   /* TODO: Warn that the 'a' conversion specifier is a C99 feature. */
   scanf("%a", fp);
   scanf("%afoobar", fp);
   printf("%a", 1.0);
   printf("%as", 1.0);
   printf("%aS", 1.0);
   printf("%a[", 1.0);
   printf("%afoo", 1.0);
 
+  wscanf(L"%a", fp);
+  wscanf(L"%afoobar", fp);
+  wprintf(L"%a", 1.0);
+  wprintf(L"%as", 1.0);
+  wprintf(L"%aS", 1.0);
+  wprintf(L"%a[", 1.0);
+  wprintf(L"%afoo", 1.0);
+
   scanf("%da", ip);
 
+  wscanf("%da", ip);
+
   /* Test argument type check for the 'a' length modifier. */
   scanf("%as", fp); /* expected-warning{{format specifies type 'char **' but the argument has type 'float *'}}
                        expected-warning{{'a' length modifier is not supported by ISO C}} */
   scanf("%aS", fp); /* expected-warning{{format specifies type 'wchar_t **' (aka 'int **') but the argument has type 'float *'}}
                        expected-warning{{'a' length modifier is not supported by ISO C}}
                        expected-warning{{'S' conversion specifier is not supported by ISO C}} */
   scanf("%a[abc]", fp); /* expected-warning{{format specifies type 'char **' but the argument has type 'float *'}}
                            expected-warning{{'a' length modifier is not supported by ISO C}} */
+
+  wscanf(L"%as", fp);     /* expected-warning{{format specifies type 'char **' but the argument has type 'float *'}}
+                           expected-warning{{'a' length modifier is not supported by ISO C}} */
+  wscanf(L"%aS", fp);     /* expected-warning{{format specifies type 'wchar_t **' (aka 'int **') but the argument has type 'float *'}}
+                           expected-warning{{'a' length modifier is not supported by ISO C}}
+                           expected-warning{{'S' conversion specifier is not supported by ISO C}} */
+  wscanf(L"%a[abc]", fp); /* expected-warning{{format specifies type 'char **' but the argument has type 'float *'}}
+                           expected-warning{{'a' length modifier is not supported by ISO C}} */
 }

clang/test/Sema/format-strings-darwin.c

 // RUN: %clang_cc1 -fsyntax-only -verify -triple i386-apple-darwin9 -Wformat-non-iso -DALLOWED %s
 // RUN: %clang_cc1 -fsyntax-only -verify -triple thumbv6-apple-ios4.0 -Wformat-non-iso -DALLOWED %s
 
 // RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-mingw32 -Wformat-non-iso %s
 // RUN: %clang_cc1 -fsyntax-only -verify -triple i686-pc-win32 -Wformat-non-iso %s
 
 // RUN: %clang_cc1 -fsyntax-only -verify -triple i686-linux-gnu -Wformat-non-iso %s
 // RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-unknown-freebsd -Wformat-non-iso %s
 
 int printf(const char *restrict, ...);
-int scanf(const char * restrict, ...) ;
+int scanf(const char *restrict, ...);
+int wprintf(const wchar_t *restrict, ...);
+int wscanf(const wchar_t *restrict, ...);
 
 void test() {
   int justRight = 1;
   long tooLong = 2;
 
   printf("%D", justRight);
   printf("%D", tooLong);
   printf("%U", justRight);
   printf("%U", tooLong);
   printf("%O", justRight);
   printf("%O", tooLong);
 
+  wprintf(L"%D", justRight);
+  wprintf(L"%D", tooLong);
+  wprintf(L"%U", justRight);
+  wprintf(L"%U", tooLong);
+  wprintf(L"%O", justRight);
+  wprintf(L"%O", tooLong);
+
 #ifdef ALLOWED
   // expected-warning@-8 {{'D' conversion specifier is not supported by ISO C}} expected-note@-8 {{did you mean to use 'd'?}}
   // expected-warning@-8 {{'D' conversion specifier is not supported by ISO C}} expected-note@-8 {{did you mean to use 'd'?}} expected-warning@-8 {{format specifies type 'int' but the argument has type 'long'}}
   // expected-warning@-8 {{'U' conversion specifier is not supported by ISO C}} expected-note@-8 {{did you mean to use 'u'?}}
   // expected-warning@-8 {{'U' conversion specifier is not supported by ISO C}} expected-note@-8 {{did you mean to use 'u'?}} expected-warning@-8 {{format specifies type 'unsigned int' but the argument has type 'long'}}
   // expected-warning@-8 {{'O' conversion specifier is not supported by ISO C}} expected-note@-8 {{did you mean to use 'o'?}}
   // expected-warning@-8 {{'O' conversion specifier is not supported by ISO C}} expected-note@-8 {{did you mean to use 'o'?}} expected-warning@-8 {{format specifies type 'unsigned int' but the argument has type 'long'}}
+  // expected-warning@-8 {{'D' conversion specifier is not supported by ISO C}} expected-note@-8 {{did you mean to use 'd'?}}
+  // expected-warning@-8 {{'D' conversion specifier is not supported by ISO C}} expected-note@-8 {{did you mean to use 'd'?}} expected-warning@-8 {{format specifies type 'int' but the argument has type 'long'}}
+  // expected-warning@-8 {{'U' conversion specifier is not supported by ISO C}} expected-note@-8 {{did you mean to use 'u'?}}
+  // expected-warning@-8 {{'U' conversion specifier is not supported by ISO C}} expected-note@-8 {{did you mean to use 'u'?}} expected-warning@-8 {{format specifies type 'unsigned int' but the argument has type 'long'}}
+  // expected-warning@-8 {{'O' conversion specifier is not supported by ISO C}} expected-note@-8 {{did you mean to use 'o'?}}
+  // expected-warning@-8 {{'O' conversion specifier is not supported by ISO C}} expected-note@-8 {{did you mean to use 'o'?}} expected-warning@-8 {{format specifies type 'unsigned int' but the argument has type 'long'}}
 #else
   // expected-warning@-15 {{invalid conversion specifier 'D'}}
   // expected-warning@-15 {{invalid conversion specifier 'D'}}
   // expected-warning@-15 {{invalid conversion specifier 'U'}}
   // expected-warning@-15 {{invalid conversion specifier 'U'}}
   // expected-warning@-15 {{invalid conversion specifier 'O'}}
   // expected-warning@-15 {{invalid conversion specifier 'O'}}
+  // expected-warning@-15 {{invalid conversion specifier 'D'}}
+  // expected-warning@-15 {{invalid conversion specifier 'D'}}
+  // expected-warning@-15 {{invalid conversion specifier 'U'}}
+  // expected-warning@-15 {{invalid conversion specifier 'U'}}
+  // expected-warning@-15 {{invalid conversion specifier 'O'}}
+  // expected-warning@-15 {{invalid conversion specifier 'O'}}
 #endif
 }
 
 #ifdef ALLOWED
 void testPrintf(short x, long y) {
   printf("%hD", x); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'd'?}}
   printf("%lD", y); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'd'?}}
   printf("%hU", x); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'u'?}}
   printf("%lU", y); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'u'?}}
   printf("%hO", x); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'o'?}}
   printf("%lO", y); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'o'?}}
 
   printf("%+'0.5lD", y); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'd'?}}
   printf("% '0.5lD", y); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'd'?}}
   printf("%#0.5lO", y); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'o'?}}
   printf("%'0.5lU", y); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'u'?}}
+
+  wprintf("%hD", x); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'd'?}}
+  wprintf("%lD", y); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'd'?}}
+  wprintf("%hU", x); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'u'?}}
+  wprintf("%lU", y); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'u'?}}
+  wprintf("%hO", x); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'o'?}}
+  wprintf("%lO", y); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'o'?}}
+
+  wprintf("%+'0.5lD", y); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'd'?}}
+  wprintf("% '0.5lD", y); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'd'?}}
+  wprintf("%#0.5lO", y);  // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'o'?}}
+  wprintf("%'0.5lU", y);  // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'u'?}}
 }
 
 void testScanf(short *x, long *y) {
   scanf("%hD", x); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'd'?}}
   scanf("%lD", y); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'd'?}}
   scanf("%hU", x); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'u'?}}
   scanf("%lU", y); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'u'?}}
   scanf("%hO", x); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'o'?}}
   scanf("%lO", y); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'o'?}}
+
+  wscanf("%hD", x); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'd'?}}
+  wscanf("%lD", y); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'd'?}}
+  wscanf("%hU", x); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'u'?}}
+  wscanf("%lU", y); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'u'?}}
+  wscanf("%hO", x); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'o'?}}
+  wscanf("%lO", y); // expected-warning{{conversion specifier is not supported by ISO C}} expected-note {{did you mean to use 'o'?}}
 }
 #endif

clang/test/Sema/format-strings-int-typedefs.c

 // RUN: %clang_cc1 -triple i386-apple-darwin9 -fsyntax-only -verify %s
 
 int printf(char const *, ...);
 int scanf(char const *, ...);
+int wprintf(wchar_t const *, ...);
+int wscanf(wchar_t const *, ...);
 
 void test(void) {
   printf("%jd", 42.0); // expected-warning {{format specifies type 'intmax_t' (aka 'long long')}}
   printf("%ju", 42.0); // expected-warning {{format specifies type 'uintmax_t' (aka 'unsigned long long')}}
   printf("%zu", 42.0); // expected-warning {{format specifies type 'size_t' (aka 'unsigned long')}}
   printf("%td", 42.0); // expected-warning {{format specifies type 'ptrdiff_t' (aka 'int')}}
   printf("%lc", 42.0); // expected-warning {{format specifies type 'wint_t' (aka 'int')}}
   printf("%ls", 42.0); // expected-warning {{format specifies type 'wchar_t *' (aka 'int *')}}
   printf("%S", 42.0);  // expected-warning {{format specifies type 'wchar_t *' (aka 'int *')}}
   printf("%C", 42.0);  // expected-warning {{format specifies type 'wchar_t' (aka 'int')}}
 
+  wprintf(L"%jd", 42.0); // expected-warning {{format specifies type 'intmax_t' (aka 'long long')}}
+  wprintf(L"%ju", 42.0); // expected-warning {{format specifies type 'uintmax_t' (aka 'unsigned long long')}}
+  wprintf(L"%zu", 42.0); // expected-warning {{format specifies type 'size_t' (aka 'unsigned long')}}
+  wprintf(L"%td", 42.0); // expected-warning {{format specifies type 'ptrdiff_t' (aka 'int')}}
+  wprintf(L"%lc", 42.0); // expected-warning {{format specifies type 'wint_t' (aka 'int')}}
+  wprintf(L"%ls", 42.0); // expected-warning {{format specifies type 'wchar_t *' (aka 'int *')}}
+  wprintf(L"%S", 42.0);  // expected-warning {{format specifies type 'wchar_t *' (aka 'int *')}}
+  wprintf(L"%C", 42.0);  // expected-warning {{format specifies type 'wchar_t' (aka 'int')}}
+
   scanf("%jd", 0); // expected-warning {{format specifies type 'intmax_t *' (aka 'long long *')}}
   scanf("%ju", 0); // expected-warning {{format specifies type 'uintmax_t *' (aka 'unsigned long long *')}}
   scanf("%zu", 0); // expected-warning {{format specifies type 'size_t *' (aka 'unsigned long *')}}
   scanf("%td", 0); // expected-warning {{format specifies type 'ptrdiff_t *' (aka 'int *')}}
   scanf("%lc", 0); // expected-warning {{format specifies type 'wchar_t *' (aka 'int *')}}
   scanf("%ls", 0); // expected-warning {{format specifies type 'wchar_t *' (aka 'int *')}}
   scanf("%S",  0);  // expected-warning {{format specifies type 'wchar_t *' (aka 'int *')}}
   scanf("%C",  0);  // expected-warning {{format specifies type 'wchar_t *' (aka 'int *')}}
 
+  wscanf("%jd", 0); // expected-warning {{format specifies type 'intmax_t *' (aka 'long long *')}}
+  wscanf("%ju", 0); // expected-warning {{format specifies type 'uintmax_t *' (aka 'unsigned long long *')}}
+  wscanf("%zu", 0); // expected-warning {{format specifies type 'size_t *' (aka 'unsigned long *')}}
+  wscanf("%td", 0); // expected-warning {{format specifies type 'ptrdiff_t *' (aka 'int *')}}
+  wscanf("%lc", 0); // expected-warning {{format specifies type 'wchar_t *' (aka 'int *')}}
+  wscanf("%ls", 0); // expected-warning {{format specifies type 'wchar_t *' (aka 'int *')}}
+  wscanf("%S", 0);  // expected-warning {{format specifies type 'wchar_t *' (aka 'int *')}}
+  wscanf("%C", 0);  // expected-warning {{format specifies type 'wchar_t *' (aka 'int *')}}
 
   // typedef size_t et al. to something crazy.
   typedef void *size_t;
   typedef void *intmax_t;
   typedef void *uintmax_t;
   typedef void *ptrdiff_t;
 
   // The warning still fires, because it checks the underlying type.
   printf("%jd", (intmax_t)42); // expected-warning {{format specifies type 'intmax_t' (aka 'long long') but the argument has type 'intmax_t' (aka 'void *')}}
   printf("%ju", (uintmax_t)42); // expected-warning {{format specifies type 'uintmax_t' (aka 'unsigned long long') but the argument has type 'uintmax_t' (aka 'void *')}}
   printf("%zu", (size_t)42); // expected-warning {{format specifies type 'size_t' (aka 'unsigned long') but the argument has type 'size_t' (aka 'void *')}}
   printf("%td", (ptrdiff_t)42); // expected-warning {{format specifies type 'ptrdiff_t' (aka 'int') but the argument has type 'ptrdiff_t' (aka 'void *')}}
 }

clang/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
 
 int printf(const char *format, ...) __attribute__((format(printf, 1, 2)));
-int scanf(const char * restrict, ...) ;
-typedef unsigned short wchar_t;
+int scanf(const char *restrict, ...);
+int wprintf(const wchar_t *format, ...) __attribute__((format(printf, 1, 2)));
+int wscanf(const wchar_t *restrict, ...);
 
 #ifdef NON_ISO_WARNING
 
 // Split off this test to reduce the warning noise in the rest of the file.
 void non_iso_warning_test(__int32 i32, __int64 i64, wchar_t c, void *p) {
   printf("%Id", i32); // expected-warning{{'I' length modifier is not supported by ISO C}}
   printf("%I32d", i32); // expected-warning{{'I32' length modifier is not supported by ISO C}}
   printf("%I64d", i64); // expected-warning{{'I64' length modifier is not supported by ISO C}}
   printf("%wc", c); // expected-warning{{'w' length modifier is not supported by ISO C}}
   printf("%Z", p); // expected-warning{{'Z' conversion specifier is not supported by ISO C}}
+
+  wprintf(L"%Id", i32);   // expected-warning{{'I' length modifier is not supported by ISO C}}
+  wprintf(L"%I32d", i32); // expected-warning{{'I32' length modifier is not supported by ISO C}}
+  wprintf(L"%I64d", i64); // expected-warning{{'I64' length modifier is not supported by ISO C}}
+  wprintf(L"%wc", c);     // expected-warning{{'w' length modifier is not supported by ISO C}}
+  wprintf(L"%Z", p);      // expected-warning{{'Z' conversion specifier is not supported by ISO C}}
 }
 
 #else
 
 void signed_test() {
   short val = 30;
-  printf("val = %I64d\n", val); // expected-warning{{format specifies type '__int64' (aka 'long long') but the argument has type 'short'}}
   long long bigval = 30;
+  printf("val = %I64d\n", val);    // expected-warning{{format specifies type '__int64' (aka 'long long') but the argument has type 'short'}}
   printf("val = %I32d\n", bigval); // expected-warning{{format specifies type '__int32' (aka 'int') but the argument has type 'long long'}}
   printf("val = %Id\n", bigval); // expected-warning{{format specifies type '__int32' (aka 'int') but the argument has type 'long long'}}
+
+  wprintf(L"val = %I64d\n", val);    // expected-warning{{format specifies type '__int64' (aka 'long long') but the argument has type 'short'}}
+  wprintf(L"val = %I32d\n", bigval); // expected-warning{{format specifies type '__int32' (aka 'int') but the argument has type 'long long'}}
+  wprintf(L"val = %Id\n", bigval);   // expected-warning{{format specifies type '__int32' (aka 'int') but the argument has type 'long long'}}
 }
 
 void unsigned_test() {
   unsigned short val = 30;
-  printf("val = %I64u\n", val); // expected-warning{{format specifies type 'unsigned __int64' (aka 'unsigned long long') but the argument has type 'unsigned short'}}
   unsigned long long bigval = 30;
+  printf("val = %I64u\n", val);    // expected-warning{{format specifies type 'unsigned __int64' (aka 'unsigned long long') but the argument has type 'unsigned short'}}
   printf("val = %I32u\n", bigval); // expected-warning{{format specifies type 'unsigned __int32' (aka 'unsigned int') but the argument has type 'unsigned long long'}}
   printf("val = %Iu\n", bigval); // expected-warning{{format specifies type 'unsigned __int32' (aka 'unsigned int') but the argument has type 'unsigned long long'}}
+
+  wprintf(L"val = %I64u\n", val);    // expected-warning{{format specifies type 'unsigned __int64' (aka 'unsigned long long') but the argument has type 'unsigned short'}}
+  wprintf(L"val = %I32u\n", bigval); // expected-warning{{format specifies type 'unsigned __int32' (aka 'unsigned int') but the argument has type 'unsigned long long'}}
+  wprintf(L"val = %Iu\n", bigval);   // expected-warning{{format specifies type 'unsigned __int32' (aka 'unsigned int') but the argument has type 'unsigned long long'}}
 }
 
 void w_test(wchar_t c, wchar_t *s) {
   printf("%wc", c);
   printf("%wC", c);
   printf("%C", c);
   printf("%ws", s);
   printf("%wS", s);
   printf("%S", s);
   scanf("%wc", &c);
   scanf("%wC", &c);
   scanf("%C", &c);
   scanf("%ws", s);
   scanf("%wS", s);
   scanf("%S", s);
 
+  wprintf(L"%wc", c);
+  wprintf(L"%wC", c);
+  wprintf(L"%C", c);
+  wprintf(L"%ws", s);
+  wprintf(L"%wS", s);
+  wprintf(L"%S", s);
+
+  wscanf(L"%wc", &c);
+  wscanf(L"%wC", &c);
+  wscanf(L"%C", &c);
+  wscanf(L"%ws", s);
+  wscanf(L"%wS", s);
+  wscanf(L"%S", s);
+
   double bad;
   printf("%wc", bad); // expected-warning{{format specifies type 'wint_t' (aka 'unsigned short') but the argument has type 'double'}}
   printf("%wC", bad); // expected-warning{{format specifies type 'wchar_t' (aka 'unsigned short') but the argument has type 'double'}}
   printf("%C", bad); // expected-warning{{format specifies type 'wchar_t' (aka 'unsigned short') but the argument has type 'double'}}
   printf("%ws", bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double'}}
   printf("%wS", bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double'}}
   printf("%S", bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double'}}
   scanf("%wc", &bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double *'}}
   scanf("%wC", &bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double *'}}
   scanf("%C", &bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double *'}}
   scanf("%ws", &bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double *'}}
   scanf("%wS", &bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double *'}}
   scanf("%S", &bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double *'}}
 
+  wprintf(L"%wc", bad); // expected-warning{{format specifies type 'wint_t' (aka 'unsigned short') but the argument has type 'double'}}
+  wprintf(L"%wC", bad); // expected-warning{{format specifies type 'wchar_t' (aka 'unsigned short') but the argument has type 'double'}}
+  wprintf(L"%C", bad);  // expected-warning{{format specifies type 'wchar_t' (aka 'unsigned short') but the argument has type 'double'}}
+  wprintf(L"%ws", bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double'}}
+  wprintf(L"%wS", bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double'}}
+  wprintf(L"%S", bad);  // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double'}}
+  wscanf(L"%wc", &bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double *'}}
+  wscanf(L"%wC", &bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double *'}}
+  wscanf(L"%C", &bad);  // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double *'}}
+  wscanf(L"%ws", &bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double *'}}
+  wscanf(L"%wS", &bad); // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double *'}}
+  wscanf(L"%S", &bad);  // expected-warning{{format specifies type 'wchar_t *' (aka 'unsigned short *') but the argument has type 'double *'}}
 }
 
 void h_test(char c, char* s) {
   double bad;
   printf("%hc", bad); // expected-warning{{format specifies type 'int' but the argument has type 'double'}}
   printf("%hC", bad); // expected-warning{{format specifies type 'int' but the argument has type 'double'}}
   printf("%hs", bad); // expected-warning{{format specifies type 'char *' but the argument has type 'double'}}
   printf("%hS", bad); // expected-warning{{format specifies type 'char *' but the argument has type 'double'}}
   scanf("%hc", &bad); // expected-warning{{format specifies type 'char *' but the argument has type 'double *'}}
   scanf("%hC", &bad); // expected-warning{{format specifies type 'char *' but the argument has type 'double *'}}
   scanf("%hs", &bad); // expected-warning{{format specifies type 'char *' but the argument has type 'double *'}}
   scanf("%hS", &bad); // expected-warning{{format specifies type 'char *' but the argument has type 'double *'}}
+
+  wprintf(L"%hc", bad); // expected-warning{{format specifies type 'int' but the argument has type 'double'}}
+  wprintf(L"%hC", bad); // expected-warning{{format specifies type 'int' but the argument has type 'double'}}
+  wprintf(L"%hs", bad); // expected-warning{{format specifies type 'char *' but the argument has type 'double'}}
+  wprintf(L"%hS", bad); // expected-warning{{format specifies type 'char *' but the argument has type 'double'}}
+  wscanf(L"%hc", &bad); // expected-warning{{format specifies type 'char *' but the argument has type 'double *'}}
+  wscanf(L"%hC", &bad); // expected-warning{{format specifies type 'char *' but the argument has type 'double *'}}
+  wscanf(L"%hs", &bad); // expected-warning{{format specifies type 'char *' but the argument has type 'double *'}}
+  wscanf(L"%hS", &bad); // expected-warning{{format specifies type 'char *' but the argument has type 'double *'}}
 }
 
 void z_test(void *p) {
   printf("%Z", p);
   printf("%hZ", p);
   printf("%lZ", p);
   printf("%wZ", p);
   printf("%hhZ", p); // expected-warning{{length modifier 'hh' results in undefined behavior or no effect with 'Z' conversion specifier}}
   scanf("%Z", p); // expected-warning{{invalid conversion specifier 'Z'}}
+
+  wprintf("%Z", p);
+  wprintf("%hZ", p);
+  wprintf("%lZ", p);
+  wprintf("%wZ", p);
+  wprintf("%hhZ", p); // expected-warning{{length modifier 'hh' results in undefined behavior or no effect with 'Z' conversion specifier}}
+  wscanf("%Z", p);    // expected-warning{{invalid conversion specifier 'Z'}}
 }
 
 #endif

clang/test/Sema/format-strings-non-iso.c

 // RUN: %clang_cc1 -triple i686-linux-gnu -fsyntax-only -verify -std=c99 -Wformat-non-iso %s
 
 int printf(const char *restrict, ...);
-int scanf(const char * restrict, ...);
+int scanf(const char *restrict, ...);
 
+int wprintf(const wchar_t *restrict, ...);
+int wscanf(const wchar_t *restrict, ...);
+
 void f(void) {
   char *cp;
 
   // The 'q' length modifier.
   printf("%qd", (long long)42); // expected-warning{{'q' length modifier is not supported by ISO C}} expected-note{{did you mean to use 'll'?}}
   scanf("%qd", (long long *)0); // expected-warning{{'q' length modifier is not supported by ISO C}} expected-note{{did you mean to use 'll'?}}
 
+  // The 'q' length modifier.
+  wprintf(L"%qd", (long long)42); // expected-warning{{'q' length modifier is not supported by ISO C}} expected-note{{did you mean to use 'll'?}}
+  wscanf(L"%qd", (long long *)0); // expected-warning{{'q' length modifier is not supported by ISO C}} expected-note{{did you mean to use 'll'?}}
+
   // The 'm' length modifier.
   scanf("%ms", &cp); // expected-warning{{'m' length modifier is not supported by ISO C}}
+  wscanf(L"%ms", &cp); // expected-warning{{'m' length modifier is not supported by ISO C}}
 
   // The 'S' and 'C' conversion specifiers.
   printf("%S", L"foo"); // expected-warning{{'S' conversion specifier is not supported by ISO C}}
   printf("%C", L'x'); // expected-warning{{'C' conversion specifier is not supported by ISO C}}
+  wprintf(L"%S", L"foo"); // expected-warning{{'S' conversion specifier is not supported by ISO C}}
+  wprintf(L"%C", L'x');   // expected-warning{{'C' conversion specifier is not supported by ISO C}}
 
   // Combining 'L' with an integer conversion specifier.
   printf("%Li", (long long)42); // expected-warning{{using length modifier 'L' with conversion specifier 'i' is not supported by ISO C}} expected-note{{did you mean to use 'll'?}}
   printf("%Lo", (long long)42); // expected-warning{{using length modifier 'L' with conversion specifier 'o' is not supported by ISO C}} expected-note{{did you mean to use 'll'?}}
   printf("%Lu", (long long)42); // expected-warning{{using length modifier 'L' with conversion specifier 'u' is not supported by ISO C}} expected-note{{did you mean to use 'll'?}}
   printf("%Lx", (long long)42); // expected-warning{{using length modifier 'L' with conversion specifier 'x' is not supported by ISO C}} expected-note{{did you mean to use 'll'?}}
   printf("%LX", (long long)42); // expected-warning{{using length modifier 'L' with conversion specifier 'X' is not supported by ISO C}} expected-note{{did you mean to use 'll'?}}
 
+  wprintf(L"%Li", (long long)42); // expected-warning{{using length modifier 'L' with conversion specifier 'i' is not supported by ISO C}} expected-note{{did you mean to use 'll'?}}
+  wprintf(L"%Lo", (long long)42); // expected-warning{{using length modifier 'L' with conversion specifier 'o' is not supported by ISO C}} expected-note{{did you mean to use 'll'?}}
+  wprintf(L"%Lu", (long long)42); // expected-warning{{using length modifier 'L' with conversion specifier 'u' is not supported by ISO C}} expected-note{{did you mean to use 'll'?}}
+  wprintf(L"%Lx", (long long)42); // expected-warning{{using length modifier 'L' with conversion specifier 'x' is not supported by ISO C}} expected-note{{did you mean to use 'll'?}}
+  wprintf(L"%LX", (long long)42); // expected-warning{{using length modifier 'L' with conversion specifier 'X' is not supported by ISO C}} expected-note{{did you mean to use 'll'?}}
+
   // Positional arguments.
   printf("%1$d", 42); // expected-warning{{positional arguments are not supported by ISO C}}
+  wprintf(L"%1$d", 42); // expected-warning{{positional arguments are not supported by ISO C}}
 }

clang/test/Sema/format-strings-pedantic.c

 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-format -Wformat-pedantic %s
 // RUN: %clang_cc1 -xobjective-c -fblocks -fsyntax-only -verify -Wno-format -Wformat-pedantic %s
 // RUN: %clang_cc1 -xc++ -fsyntax-only -verify -Wno-format -Wformat-pedantic %s
 
 __attribute__((format(printf, 1, 2)))
 int printf(const char *restrict, ...);
 
+__attribute__((format(wprintf, 1, 2))) int wprintf(const wchar_t *restrict, ...);
+
 int main() {
   printf("%p", (int *)0); // expected-warning {{format specifies type 'void *' but the argument has type 'int *'}}
   printf("%p", (void *)0);
 
+  wprintf(L"%p", (int *)0); // expected-warning {{format specifies type 'void *' but the argument has type 'int *'}}
+  wprintf(L"%p", (void *)0);
+
 #ifdef __OBJC__
   printf("%p", ^{}); // expected-warning {{format specifies type 'void *' but the argument has type 'void (^)(void)'}}
   printf("%p", (id)0); // expected-warning {{format specifies type 'void *' but the argument has type 'id'}}
 #endif
 
 #ifdef __cplusplus
   printf("%p", nullptr); // expected-warning {{format specifies type 'void *' but the argument has type 'nullptr_t'}}
 #endif
 }

clang/test/Sema/format-strings-scanf.c

__typeof__(_Generic((__PTRDIFF_TYPE__)0,                                     \
                       short : (unsigned short)0,                               \
                       signed char : (unsigned char)0))
 
 typedef struct _FILE FILE;
 typedef __WCHAR_TYPE__ wchar_t;
 
 int fscanf(FILE * restrict, const char * restrict, ...) ;
 int scanf(const char * restrict, ...) ;
+int wscanf(const wchar_t *restrict, ...);
 int sscanf(const char * restrict, const char * restrict, ...) ;
 int my_scanf(const char * restrict, ...) __attribute__((__format__(__scanf__, 1, 2)));
 
 int vscanf(const char * restrict, va_list);
 int vfscanf(FILE * restrict, const char * restrict, va_list);
 int vsscanf(const char * restrict, const char * restrict, va_list);
 
 void test(const char *s, int *i) {
   scanf(s, i); // expected-warning{{format string is not a string literal}}
   scanf("%0d", i); // expected-warning{{zero field width in scanf format string is unused}}
   scanf("%00d", i); // expected-warning{{zero field width in scanf format string is unused}}
   scanf("%d%[asdfasdfd", i, s); // expected-warning{{no closing ']' for '%[' in scanf format string}}
 
+  wscanf(s, i);                   // expected-warning{{format string is not a string literal}}
+  wscanf(L"%0d", i);              // expected-warning{{zero field width in scanf format string is unused}}
+  wscanf(L"%00d", i);             // expected-warning{{zero field width in scanf format string is unused}}
+  wscanf(L"%d%[asdfasdfd", i, s); // expected-warning{{no closing ']' for '%[' in scanf format string}}
+
   unsigned short s_x;
   scanf ("%" "hu" "\n", &s_x); // no-warning
   scanf("%y", i); // expected-warning{{invalid conversion specifier 'y'}}
   scanf("%%"); // no-warning
   scanf("%%%1$d", i); // no-warning
   scanf("%1$d%%", i); // no-warning
   scanf("%d", i, i); // expected-warning{{data argument not used by format string}}
   scanf("%*d", i); // // expected-warning{{data argument not used by format string}}
   scanf("%*d", i); // // expected-warning{{data argument not used by format string}}
   scanf("%*d%1$d", i); // no-warning
 
+  unsigned short s_x;
+  wscanf(L"%"
+         L"hu"
+         L"\n",
+         &s_x);          // no-warning
+  wscanf(L"%y", i);      // expected-warning{{invalid conversion specifier 'y'}}
+  wscanf(L"%%");         // no-warning
+  wscanf(L"%%%1$d", i);  // no-warning
+  wscanf(L"%1$d%%", i);  // no-warning
+  wscanf(L"%d", i, i);   // expected-warning{{data argument not used by format string}}
+  wscanf(L"%*d", i);     // expected-warning{{data argument not used by format string}}
+  wscanf(L"%*d", i);     // expected-warning{{data argument not used by format string}}
+  wscanf(L"%*d%1$d", i); // no-warning
+
   scanf("%s", (char*)0); // no-warning
   scanf("%s", (volatile char*)0); // no-warning
   scanf("%s", (signed char*)0); // no-warning
   scanf("%s", (unsigned char*)0); // no-warning
   scanf("%hhu", (signed char*)0); // no-warning
+
+  wscanf(L"%s", (wchar_t *)0);          // no-warning
+  wscanf(L"%s", (volatile wchar_t *)0); // no-warning
+  wscanf(L"%s", (signed wchar_t *)0);   // no-warning
+  wscanf(L"%s", (unsigned wchar_t *)0); // no-warning
+  wscanf(L"%hhu", (signed wchar_t *)0); // no-warning
 }
 
 void bad_length_modifiers(char *s, void *p, wchar_t *ws, long double *ld) {
   scanf("%hhs", "foo"); // expected-warning{{length modifier 'hh' results in undefined behavior or no effect with 's' conversion specifier}}
   scanf("%1$zp", &p); // expected-warning{{length modifier 'z' results in undefined behavior or no effect with 'p' conversion specifier}}
   scanf("%ls", ws); // no-warning
   scanf("%#.2Lf", ld); // expected-warning{{invalid conversion specifier '#'}}
+
+  wscanf(L"%hhs", "foo"); // expected-warning{{length modifier 'hh' results in undefined behavior or no effect with 's' conversion specifier}}
+  wscanf(L"%1$zp", &p);   // expected-warning{{length modifier 'z' results in undefined behavior or no effect with 'p' conversion specifier}}
+  wscanf(L"%ls", ws);     // no-warning
+  wscanf(L"%#.2Lf", ld);  // expected-warning{{invalid conversion specifier '#'}}
 }
 
 // Test that the scanf call site is where the warning is attached.  If the
 // format string is somewhere else, point to it in a note.
 void pr9751() {
   int *i;
   char str[100];
   const char kFormat1[] = "%00d"; // expected-note{{format string is defined here}}}

clang/test/Sema/string-plus-char.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 struct AB{const char *a; const char*b;};
 
+struct CD {
+  const wchar_t *a;
+  const wchar_t *b;
+};
+
 const char *foo(const struct AB *ab) {
   return ab->a + 'b'; // expected-warning {{adding 'char' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
 }
 
+const wchar_t *foo(const struct CD *cd) {
+  return cd->a + 'b'; // expected-warning {{adding 'wchar_t' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
+}
+
 void f(const char *s) {
   char *str = 0;
   char *str2 = str + 'c'; // expected-warning {{adding 'char' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
 
   const char *constStr = s + 'c'; // expected-warning {{adding 'char' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
 
   str = 'c' + str;// expected-warning {{adding 'char' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
 
   char strArr[] = "foo";
   str = strArr + 'c'; // expected-warning {{adding 'char' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
   char *strArr2[] = {"ac","dc"};
   str = strArr2[0] + 'c'; // expected-warning {{adding 'char' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
 
 
   struct AB ab;
   constStr = foo(&ab) + 'c'; // expected-warning {{adding 'char' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
 
   // no-warning
   char c = 'c';
   str = str + c;
   str = c + str;
 }
+
+void g(const wchar_t *s) {
+  wchar_t *str = 0;
+  wchar_t *str2 = str + 'c'; // expected-warning {{adding 'wchar_t' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
+
+  const wchar_t *constStr = s + 'c'; // expected-warning {{adding 'wchar_t' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
+
+  str = 'c' + str; // expected-warning {{adding 'wchar_t' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
+
+  wchar_t strArr[] = L"foo";
+  str = strArr + L'c'; // expected-warning {{adding 'wchar_t' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
+  wchar_t *strArr2[] = {L"ac", L"dc"};
+  str = strArr2[0] + L'c'; // expected-warning {{adding 'wchar_t' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
+
+  struct CD cd;
+  constStr = foo(&cd) + L'c'; // expected-warning {{adding 'wchar_t' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
+
+  // no-warning
+  wchar_t c = 'c';
+  str = str + c;
+  str = c + str;
+}

clang/test/SemaCXX/format-strings-0x.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic -std=c++11 %s
 
 extern "C" {
 extern int scanf(const char *restrict, ...);
 extern int printf(const char *restrict, ...);
+extern int wscanf(const wchar_t *restrict, ...);
+extern int wprintf(const wchar_t *restrict, ...);
 }
 
 void f(char **sp, float *fp) {
   scanf("%as", sp); // expected-warning{{format specifies type 'float *' but the argument has type 'char **'}}
+  wscanf("%as", sp); // expected-warning{{format specifies type 'float *' but the argument has type 'char **'}}
 
   printf("%p", sp); // expected-warning{{format specifies type 'void *' but the argument has type 'char **'}}
+  wprintf("%p", sp); // expected-warning{{format specifies type 'void *' but the argument has type 'char **'}}
   scanf("%p", sp);  // expected-warning{{format specifies type 'void **' but the argument has type 'char **'}}
+  wscanf("%p", sp); // expected-warning{{format specifies type 'void **' but the argument has type 'char **'}}
 
   printf("%a", 1.0);
   scanf("%afoobar", fp);
+  wprintf(L"%a", 1.0);
+  wscanf(L"%afoobar", fp);
   printf(nullptr);
   printf(*sp); // expected-warning {{not a string literal}}
   // expected-note@-1{{treat the string as an argument to avoid this}}
+  wprintf(*sp); // expected-warning {{not a string literal}}
+  // expected-note@-1{{treat the string as an argument to avoid this}}
 
   // PR13099
   printf(
     R"foobar(%)foobar"
     R"bazquux(d)bazquux" // expected-warning {{more '%' conversions than data arguments}}
     R"xyzzy()xyzzy");
+  wprintf(
+      LR"foobar(%)foobar"
+      LR"bazquux(d)bazquux" // expected-warning {{more '%' conversions than data arguments}}
+      LR"xyzzy()xyzzy");
 
   printf(u8"this is %d test", 0); // ok
+  wprintf(L"this is %d test", 0); // ok
   printf(u8R"foo(
       \u1234\U0010fffe
       %d)foo" // expected-warning {{more '%' conversions than data arguments}}
   );
+  wprintf(LR"foo(
+      \u1234\U0010fffe
+      %d)foo" // expected-warning {{more '%' conversions than data arguments}}
+  );
 
   printf("init list: %d", { 0 }); // expected-error {{cannot pass initializer list to variadic function; expected type from format string was 'int'}}
+  wprintf("init list: %d", {0});  // expected-error {{cannot pass initializer list to variadic function; expected type from format string was 'int'}}
   printf("void: %d", f(sp, fp)); // expected-error {{cannot pass expression of type 'void' to variadic function; expected type from format string was 'int'}}
+  wprintf("void: %d", f(sp, fp)); // expected-error {{cannot pass expression of type 'void' to variadic function; expected type from format string was 'int'}}
   printf(0, { 0 }); // expected-error {{cannot pass initializer list to variadic function}}
+  wprintf(0, {0});  // expected-error {{cannot pass initializer list to variadic function}}
 }

clang/test/SemaCXX/format-strings.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -Wformat-nonliteral -Wformat-non-iso -fblocks %s
 // RUN: %clang_cc1 -fsyntax-only -verify -Wformat-nonliteral -Wformat-non-iso -fblocks -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -Wformat-nonliteral -Wformat-non-iso -fblocks -std=c++11 %s
 
 #include <stdarg.h>
 
 extern "C" {
 extern int scanf(const char *restrict, ...);
 extern int printf(const char *restrict, ...);
 extern int vprintf(const char *restrict, va_list);
+extern int wscanf(const wchar_t *restrict, ...);
+extern int wprintf(const wchar_t *restrict, ...);
+extern int vwprintf(const wchar_t *restrict, va_list);
 }
 
 void f(char **sp, float *fp) {
   scanf("%as", sp);
 #if __cplusplus <= 199711L
   // expected-warning@-2 {{'a' length modifier is not supported by ISO C}}
 #else
   // expected-warning@-4 {{format specifies type 'float *' but the argument has type 'char **'}}
 #endif
 
+  scanf("%as", sp);
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{'a' length modifier is not supported by ISO C}}
+#else
+  // expected-warning@-4 {{format specifies type 'float *' but the argument has type 'wchar_t **'}}
+#endif
+
   printf("%a", 1.0);
   scanf("%afoobar", fp);
+
+  wprintf("%a", 1.0);
+  wscanf("%afoobar", fp);
 }
 
 void g() {
   printf("%ls", "foo"); // expected-warning{{format specifies type 'wchar_t *' but the argument has type 'const char *'}}
+  wprintf("%ls", "foo"); // expected-warning{{format specifies type 'wchar_t *' but the argument has type 'const char *'}}
 }
 
 // Test that we properly handle format_idx on C++ members.
 class Foo {
 public:
   const char *gettext(const char *fmt) __attribute__((format_arg(2)));
 
   int scanf(const char *, ...) __attribute__((format(scanf, 2, 3)));