lib/Sema/SemaChecking.cpp

   1 //===--- SemaChecking.cpp - Extra Semantic Checking -----------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file implements extra semantic analysis beyond what is enforced
  11 //  by the C type system.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/Sema/Sema.h"
  16 #include "clang/Sema/SemaInternal.h"
  17 #include "clang/Sema/ScopeInfo.h"
  18 #include "clang/Analysis/Analyses/FormatString.h"
  19 #include "clang/AST/ASTContext.h"
  20 #include "clang/AST/CharUnits.h"
  21 #include "clang/AST/DeclCXX.h"
  22 #include "clang/AST/DeclObjC.h"
  23 #include "clang/AST/ExprCXX.h"
  24 #include "clang/AST/ExprObjC.h"
  25 #include "clang/AST/DeclObjC.h"
  26 #include "clang/AST/StmtCXX.h"
  27 #include "clang/AST/StmtObjC.h"
  28 #include "clang/Lex/LiteralSupport.h"
  29 #include "clang/Lex/Preprocessor.h"
  30 #include "llvm/ADT/BitVector.h"
  31 #include "llvm/ADT/STLExtras.h"
  32 #include "llvm/Support/raw_ostream.h"
  33 #include "clang/Basic/TargetBuiltins.h"
  34 #include "clang/Basic/TargetInfo.h"
  35 #include <limits>
  36 using namespace clang;
  37 using namespace sema;
  38
  39 /// getLocationOfStringLiteralByte - Return a source location that points to the
  40 /// specified byte of the specified string literal.
  41 ///
  42 /// Strings are amazingly complex.  They can be formed from multiple tokens and
  43 /// can have escape sequences in them in addition to the usual trigraph and
  44 /// escaped newline business.  This routine handles this complexity.
  45 ///
  46 SourceLocation Sema::getLocationOfStringLiteralByte(const StringLiteral *SL,
  47                                                     unsigned ByteNo) const {
  48   assert(!SL->isWide() && "This doesn't work for wide strings yet");
  49
  50   // Loop over all of the tokens in this string until we find the one that
  51   // contains the byte we're looking for.
  52   unsigned TokNo = 0;
  53   while (1) {
  54     assert(TokNo < SL->getNumConcatenated() && "Invalid byte number!");
  55     SourceLocation StrTokLoc = SL->getStrTokenLoc(TokNo);
  56
  57     // Get the spelling of the string so that we can get the data that makes up
  58     // the string literal, not the identifier for the macro it is potentially
  59     // expanded through.
  60     SourceLocation StrTokSpellingLoc = SourceMgr.getSpellingLoc(StrTokLoc);
  61
  62     // Re-lex the token to get its length and original spelling.
  63     std::pair<FileID, unsigned> LocInfo =
  64       SourceMgr.getDecomposedLoc(StrTokSpellingLoc);
  65     bool Invalid = false;
  66     llvm::StringRef Buffer = SourceMgr.getBufferData(LocInfo.first, &Invalid);
  67     if (Invalid)
  68       return StrTokSpellingLoc;
  69
  70     const char *StrData = Buffer.data()+LocInfo.second;
  71
  72     // Create a langops struct and enable trigraphs.  This is sufficient for
  73     // relexing tokens.
  74     LangOptions LangOpts;
  75     LangOpts.Trigraphs = true;
  76
  77     // Create a lexer starting at the beginning of this token.
  78     Lexer TheLexer(StrTokSpellingLoc, LangOpts, Buffer.begin(), StrData,
  79                    Buffer.end());
  80     Token TheTok;
  81     TheLexer.LexFromRawLexer(TheTok);
  82
  83     // Use the StringLiteralParser to compute the length of the string in bytes.
  84     StringLiteralParser SLP(&TheTok, 1, PP, /*Complain=*/false);
  85     unsigned TokNumBytes = SLP.GetStringLength();
  86
  87     // If the byte is in this token, return the location of the byte.
  88     if (ByteNo < TokNumBytes ||
  89         (ByteNo == TokNumBytes && TokNo == SL->getNumConcatenated())) {
  90       unsigned Offset =
  91         StringLiteralParser::getOffsetOfStringByte(TheTok, ByteNo, PP,
  92                                                    /*Complain=*/false);
  93
  94       // Now that we know the offset of the token in the spelling, use the
  95       // preprocessor to get the offset in the original source.
  96       return PP.AdvanceToTokenCharacter(StrTokLoc, Offset);
  97     }
  98
  99     // Move to the next string token.
 100     ++TokNo;
 101     ByteNo -= TokNumBytes;
 102   }
 103 }
 104
 105 /// CheckablePrintfAttr - does a function call have a "printf" attribute
 106 /// and arguments that merit checking?
 107 bool Sema::CheckablePrintfAttr(const FormatAttr *Format, CallExpr *TheCall) {
 108   if (Format->getType() == "printf") return true;
 109   if (Format->getType() == "printf0") {
 110     // printf0 allows null "format" string; if so don't check format/args
 111     unsigned format_idx = Format->getFormatIdx() - 1;
 112     // Does the index refer to the implicit object argument?
 113     if (isa<CXXMemberCallExpr>(TheCall)) {
 114       if (format_idx == 0)
 115         return false;
 116       --format_idx;
 117     }
 118     if (format_idx < TheCall->getNumArgs()) {
 119       Expr *Format = TheCall->getArg(format_idx)->IgnoreParenCasts();
 120       if (!Format->isNullPointerConstant(Context,
 121                                          Expr::NPC_ValueDependentIsNull))
 122         return true;
 123     }
 124   }
 125   return false;
 126 }
 127
 128 ExprResult
 129 Sema::CheckBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
 130   ExprResult TheCallResult(Owned(TheCall));
 131
 132   switch (BuiltinID) {
 133   case Builtin::BI__builtin___CFStringMakeConstantString:
 134     assert(TheCall->getNumArgs() == 1 &&
 135            "Wrong # arguments to builtin CFStringMakeConstantString");
 136     if (CheckObjCString(TheCall->getArg(0)))
 137       return ExprError();
 138     break;
 139   case Builtin::BI__builtin_stdarg_start:
 140   case Builtin::BI__builtin_va_start:
 141     if (SemaBuiltinVAStart(TheCall))
 142       return ExprError();
 143     break;
 144   case Builtin::BI__builtin_isgreater:
 145   case Builtin::BI__builtin_isgreaterequal:
 146   case Builtin::BI__builtin_isless:
 147   case Builtin::BI__builtin_islessequal:
 148   case Builtin::BI__builtin_islessgreater:
 149   case Builtin::BI__builtin_isunordered:
 150     if (SemaBuiltinUnorderedCompare(TheCall))
 151       return ExprError();
 152     break;
 153   case Builtin::BI__builtin_fpclassify:
 154     if (SemaBuiltinFPClassification(TheCall, 6))
 155       return ExprError();
 156     break;
 157   case Builtin::BI__builtin_isfinite:
 158   case Builtin::BI__builtin_isinf:
 159   case Builtin::BI__builtin_isinf_sign:
 160   case Builtin::BI__builtin_isnan:
 161   case Builtin::BI__builtin_isnormal:
 162     if (SemaBuiltinFPClassification(TheCall, 1))
 163       return ExprError();
 164     break;
 165   case Builtin::BI__builtin_return_address:
 166   case Builtin::BI__builtin_frame_address: {
 167     llvm::APSInt Result;
 168     if (SemaBuiltinConstantArg(TheCall, 0, Result))
 169       return ExprError();
 170     break;
 171   }
 172   case Builtin::BI__builtin_eh_return_data_regno: {
 173     llvm::APSInt Result;
 174     if (SemaBuiltinConstantArg(TheCall, 0, Result))
 175       return ExprError();
 176     break;
 177   }
 178   case Builtin::BI__builtin_shufflevector:
 179     return SemaBuiltinShuffleVector(TheCall);
 180     // TheCall will be freed by the smart pointer here, but that's fine, since
 181     // SemaBuiltinShuffleVector guts it, but then doesn't release it.
 182   case Builtin::BI__builtin_prefetch:
 183     if (SemaBuiltinPrefetch(TheCall))
 184       return ExprError();
 185     break;
 186   case Builtin::BI__builtin_object_size:
 187     if (SemaBuiltinObjectSize(TheCall))
 188       return ExprError();
 189     break;
 190   case Builtin::BI__builtin_longjmp:
 191     if (SemaBuiltinLongjmp(TheCall))
 192       return ExprError();
 193     break;
 194   case Builtin::BI__sync_fetch_and_add:
 195   case Builtin::BI__sync_fetch_and_sub:
 196   case Builtin::BI__sync_fetch_and_or:
 197   case Builtin::BI__sync_fetch_and_and:
 198   case Builtin::BI__sync_fetch_and_xor:
 199   case Builtin::BI__sync_add_and_fetch:
 200   case Builtin::BI__sync_sub_and_fetch:
 201   case Builtin::BI__sync_and_and_fetch:
 202   case Builtin::BI__sync_or_and_fetch:
 203   case Builtin::BI__sync_xor_and_fetch:
 204   case Builtin::BI__sync_val_compare_and_swap:
 205   case Builtin::BI__sync_bool_compare_and_swap:
 206   case Builtin::BI__sync_lock_test_and_set:
 207   case Builtin::BI__sync_lock_release:
 208     return SemaBuiltinAtomicOverloaded(move(TheCallResult));
 209   }
 210
 211   // Since the target specific builtins for each arch overlap, only check those
 212   // of the arch we are compiling for.
 213   if (BuiltinID >= Builtin::FirstTSBuiltin) {
 214     switch (Context.Target.getTriple().getArch()) {
 215       case llvm::Triple::arm:
 216       case llvm::Triple::thumb:
 217         if (CheckARMBuiltinFunctionCall(BuiltinID, TheCall))
 218           return ExprError();
 219         break;
 220       case llvm::Triple::x86:
 221       case llvm::Triple::x86_64:
 222         if (CheckX86BuiltinFunctionCall(BuiltinID, TheCall))
 223           return ExprError();
 224         break;
 225       default:
 226         break;
 227     }
 228   }
 229
 230   return move(TheCallResult);
 231 }
 232
 233 bool Sema::CheckX86BuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
 234   switch (BuiltinID) {
 235   case X86::BI__builtin_ia32_palignr128:
 236   case X86::BI__builtin_ia32_palignr: {
 237     llvm::APSInt Result;
 238     if (SemaBuiltinConstantArg(TheCall, 2, Result))
 239       return true;
 240     break;
 241   }
 242   }
 243   return false;
 244 }
 245
 246 // Get the valid immediate range for the specified NEON type code.
 247 static unsigned RFT(unsigned t, bool shift = false) {
 248   bool quad = t & 0x10;
 249
 250   switch (t & 0x7) {
 251     case 0: // i8
 252       return shift ? 7 : (8 << (int)quad) - 1;
 253     case 1: // i16
 254       return shift ? 15 : (4 << (int)quad) - 1;
 255     case 2: // i32
 256       return shift ? 31 : (2 << (int)quad) - 1;
 257     case 3: // i64
 258       return shift ? 63 : (1 << (int)quad) - 1;
 259     case 4: // f32
 260       assert(!shift && "cannot shift float types!");
 261       return (2 << (int)quad) - 1;
 262     case 5: // poly8
 263       assert(!shift && "cannot shift polynomial types!");
 264       return (8 << (int)quad) - 1;
 265     case 6: // poly16
 266       assert(!shift && "cannot shift polynomial types!");
 267       return (4 << (int)quad) - 1;
 268     case 7: // float16
 269       assert(!shift && "cannot shift float types!");
 270       return (4 << (int)quad) - 1;
 271   }
 272   return 0;
 273 }
 274
 275 bool Sema::CheckARMBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
 276   llvm::APSInt Result;
 277
 278   unsigned mask = 0;
 279   unsigned TV = 0;
 280   switch (BuiltinID) {
 281 #define GET_NEON_OVERLOAD_CHECK
 282 #include "clang/Basic/arm_neon.inc"
 283 #undef GET_NEON_OVERLOAD_CHECK
 284   }
 285
 286   // For NEON intrinsics which are overloaded on vector element type, validate
 287   // the immediate which specifies which variant to emit.
 288   if (mask) {
 289     unsigned ArgNo = TheCall->getNumArgs()-1;
 290     if (SemaBuiltinConstantArg(TheCall, ArgNo, Result))
 291       return true;
 292
 293     TV = Result.getLimitedValue(32);
 294     if ((TV > 31) || (mask & (1 << TV)) == 0)
 295       return Diag(TheCall->getLocStart(), diag::err_invalid_neon_type_code)
 296         << TheCall->getArg(ArgNo)->getSourceRange();
 297   }
 298
 299   // For NEON intrinsics which take an immediate value as part of the
 300   // instruction, range check them here.
 301   unsigned i = 0, l = 0, u = 0;
 302   switch (BuiltinID) {
 303   default: return false;
 304   case ARM::BI__builtin_arm_ssat: i = 1; l = 1; u = 31; break;
 305   case ARM::BI__builtin_arm_usat: i = 1; u = 31; break;
 306   case ARM::BI__builtin_arm_vcvtr_f:
 307   case ARM::BI__builtin_arm_vcvtr_d: i = 1; u = 1; break;
 308 #define GET_NEON_IMMEDIATE_CHECK
 309 #include "clang/Basic/arm_neon.inc"
 310 #undef GET_NEON_IMMEDIATE_CHECK
 311   };
 312
 313   // Check that the immediate argument is actually a constant.
 314   if (SemaBuiltinConstantArg(TheCall, i, Result))
 315     return true;
 316
 317   // Range check against the upper/lower values for this isntruction.
 318   unsigned Val = Result.getZExtValue();
 319   if (Val < l || Val > (u + l))
 320     return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range)
 321       << l << u+l << TheCall->getArg(i)->getSourceRange();
 322
 323   // FIXME: VFP Intrinsics should error if VFP not present.
 324   return false;
 325 }
 326
 327 /// CheckFunctionCall - Check a direct function call for various correctness
 328 /// and safety properties not strictly enforced by the C type system.
 329 bool Sema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall) {
 330   // Get the IdentifierInfo* for the called function.
 331   IdentifierInfo *FnInfo = FDecl->getIdentifier();
 332
 333   // None of the checks below are needed for functions that don't have
 334   // simple names (e.g., C++ conversion functions).
 335   if (!FnInfo)
 336     return false;
 337
 338   // FIXME: This mechanism should be abstracted to be less fragile and
 339   // more efficient. For example, just map function ids to custom
 340   // handlers.
 341
 342   // Printf checking.
 343   if (const FormatAttr *Format = FDecl->getAttr<FormatAttr>()) {
 344     const bool b = Format->getType() == "scanf";
 345     if (b || CheckablePrintfAttr(Format, TheCall)) {
 346       bool HasVAListArg = Format->getFirstArg() == 0;
 347       CheckPrintfScanfArguments(TheCall, HasVAListArg,
 348                                 Format->getFormatIdx() - 1,
 349                                 HasVAListArg ? 0 : Format->getFirstArg() - 1,
 350                                 !b);
 351     }
 352   }
 353
 354   specific_attr_iterator<NonNullAttr>
 355     i = FDecl->specific_attr_begin<NonNullAttr>(),
 356     e = FDecl->specific_attr_end<NonNullAttr>();
 357
 358   for (; i != e; ++i)
 359     CheckNonNullArguments(*i, TheCall);
 360
 361   return false;
 362 }
 363
 364 bool Sema::CheckBlockCall(NamedDecl *NDecl, CallExpr *TheCall) {
 365   // Printf checking.
 366   const FormatAttr *Format = NDecl->getAttr<FormatAttr>();
 367   if (!Format)
 368     return false;
 369
 370   const VarDecl *V = dyn_cast<VarDecl>(NDecl);
 371   if (!V)
 372     return false;
 373
 374   QualType Ty = V->getType();
 375   if (!Ty->isBlockPointerType())
 376     return false;
 377
 378   const bool b = Format->getType() == "scanf";
 379   if (!b && !CheckablePrintfAttr(Format, TheCall))
 380     return false;
 381
 382   bool HasVAListArg = Format->getFirstArg() == 0;
 383   CheckPrintfScanfArguments(TheCall, HasVAListArg, Format->getFormatIdx() - 1,
 384                             HasVAListArg ? 0 : Format->getFirstArg() - 1, !b);
 385
 386   return false;
 387 }
 388
 389 /// SemaBuiltinAtomicOverloaded - We have a call to a function like
 390 /// __sync_fetch_and_add, which is an overloaded function based on the pointer
 391 /// type of its first argument.  The main ActOnCallExpr routines have already
 392 /// promoted the types of arguments because all of these calls are prototyped as
 393 /// void(...).
 394 ///
 395 /// This function goes through and does final semantic checking for these
 396 /// builtins,
 397 ExprResult
 398 Sema::SemaBuiltinAtomicOverloaded(ExprResult TheCallResult) {
 399   CallExpr *TheCall = (CallExpr *)TheCallResult.get();
 400   DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
 401   FunctionDecl *FDecl = cast<FunctionDecl>(DRE->getDecl());
 402
 403   // Ensure that we have at least one argument to do type inference from.
 404   if (TheCall->getNumArgs() < 1) {
 405     Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args_at_least)
 406       << 0 << 1 << TheCall->getNumArgs()
 407       << TheCall->getCallee()->getSourceRange();
 408     return ExprError();
 409   }
 410
 411   // Inspect the first argument of the atomic builtin.  This should always be
 412   // a pointer type, whose element is an integral scalar or pointer type.
 413   // Because it is a pointer type, we don't have to worry about any implicit
 414   // casts here.
 415   // FIXME: We don't allow floating point scalars as input.
 416   Expr *FirstArg = TheCall->getArg(0);
 417   if (!FirstArg->getType()->isPointerType()) {
 418     Diag(DRE->getLocStart(), diag::err_atomic_builtin_must_be_pointer)
 419       << FirstArg->getType() << FirstArg->getSourceRange();
 420     return ExprError();
 421   }
 422
 423   QualType ValType =
 424     FirstArg->getType()->getAs<PointerType>()->getPointeeType();
 425   if (!ValType->isIntegerType() && !ValType->isPointerType() &&
 426       !ValType->isBlockPointerType()) {
 427     Diag(DRE->getLocStart(), diag::err_atomic_builtin_must_be_pointer_intptr)
 428       << FirstArg->getType() << FirstArg->getSourceRange();
 429     return ExprError();
 430   }
 431
 432   // The majority of builtins return a value, but a few have special return
 433   // types, so allow them to override appropriately below.
 434   QualType ResultType = ValType;
 435
 436   // We need to figure out which concrete builtin this maps onto.  For example,
 437   // __sync_fetch_and_add with a 2 byte object turns into
 438   // __sync_fetch_and_add_2.
 439 #define BUILTIN_ROW(x) \
 440   { Builtin::BI##x##_1, Builtin::BI##x##_2, Builtin::BI##x##_4, \
 441     Builtin::BI##x##_8, Builtin::BI##x##_16 }
 442
 443   static const unsigned BuiltinIndices[][5] = {
 444     BUILTIN_ROW(__sync_fetch_and_add),
 445     BUILTIN_ROW(__sync_fetch_and_sub),
 446     BUILTIN_ROW(__sync_fetch_and_or),
 447     BUILTIN_ROW(__sync_fetch_and_and),
 448     BUILTIN_ROW(__sync_fetch_and_xor),
 449
 450     BUILTIN_ROW(__sync_add_and_fetch),
 451     BUILTIN_ROW(__sync_sub_and_fetch),
 452     BUILTIN_ROW(__sync_and_and_fetch),
 453     BUILTIN_ROW(__sync_or_and_fetch),
 454     BUILTIN_ROW(__sync_xor_and_fetch),
 455
 456     BUILTIN_ROW(__sync_val_compare_and_swap),
 457     BUILTIN_ROW(__sync_bool_compare_and_swap),
 458     BUILTIN_ROW(__sync_lock_test_and_set),
 459     BUILTIN_ROW(__sync_lock_release)
 460   };
 461 #undef BUILTIN_ROW
 462
 463   // Determine the index of the size.
 464   unsigned SizeIndex;
 465   switch (Context.getTypeSizeInChars(ValType).getQuantity()) {
 466   case 1: SizeIndex = 0; break;
 467   case 2: SizeIndex = 1; break;
 468   case 4: SizeIndex = 2; break;
 469   case 8: SizeIndex = 3; break;
 470   case 16: SizeIndex = 4; break;
 471   default:
 472     Diag(DRE->getLocStart(), diag::err_atomic_builtin_pointer_size)
 473       << FirstArg->getType() << FirstArg->getSourceRange();
 474     return ExprError();
 475   }
 476
 477   // Each of these builtins has one pointer argument, followed by some number of
 478   // values (0, 1 or 2) followed by a potentially empty varags list of stuff
 479   // that we ignore.  Find out which row of BuiltinIndices to read from as well
 480   // as the number of fixed args.
 481   unsigned BuiltinID = FDecl->getBuiltinID();
 482   unsigned BuiltinIndex, NumFixed = 1;
 483   switch (BuiltinID) {
 484   default: assert(0 && "Unknown overloaded atomic builtin!");
 485   case Builtin::BI__sync_fetch_and_add: BuiltinIndex = 0; break;
 486   case Builtin::BI__sync_fetch_and_sub: BuiltinIndex = 1; break;
 487   case Builtin::BI__sync_fetch_and_or:  BuiltinIndex = 2; break;
 488   case Builtin::BI__sync_fetch_and_and: BuiltinIndex = 3; break;
 489   case Builtin::BI__sync_fetch_and_xor: BuiltinIndex = 4; break;
 490
 491   case Builtin::BI__sync_add_and_fetch: BuiltinIndex = 5; break;
 492   case Builtin::BI__sync_sub_and_fetch: BuiltinIndex = 6; break;
 493   case Builtin::BI__sync_and_and_fetch: BuiltinIndex = 7; break;
 494   case Builtin::BI__sync_or_and_fetch:  BuiltinIndex = 8; break;
 495   case Builtin::BI__sync_xor_and_fetch: BuiltinIndex = 9; break;
 496
 497   case Builtin::BI__sync_val_compare_and_swap:
 498     BuiltinIndex = 10;
 499     NumFixed = 2;
 500     break;
 501   case Builtin::BI__sync_bool_compare_and_swap:
 502     BuiltinIndex = 11;
 503     NumFixed = 2;
 504     ResultType = Context.BoolTy;
 505     break;
 506   case Builtin::BI__sync_lock_test_and_set: BuiltinIndex = 12; break;
 507   case Builtin::BI__sync_lock_release:
 508     BuiltinIndex = 13;
 509     NumFixed = 0;
 510     ResultType = Context.VoidTy;
 511     break;
 512   }
 513
 514   // Now that we know how many fixed arguments we expect, first check that we
 515   // have at least that many.
 516   if (TheCall->getNumArgs() < 1+NumFixed) {
 517     Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args_at_least)
 518       << 0 << 1+NumFixed << TheCall->getNumArgs()
 519       << TheCall->getCallee()->getSourceRange();
 520     return ExprError();
 521   }
 522
 523   // Get the decl for the concrete builtin from this, we can tell what the
 524   // concrete integer type we should convert to is.
 525   unsigned NewBuiltinID = BuiltinIndices[BuiltinIndex][SizeIndex];
 526   const char *NewBuiltinName = Context.BuiltinInfo.GetName(NewBuiltinID);
 527   IdentifierInfo *NewBuiltinII = PP.getIdentifierInfo(NewBuiltinName);
 528   FunctionDecl *NewBuiltinDecl =
 529     cast<FunctionDecl>(LazilyCreateBuiltin(NewBuiltinII, NewBuiltinID,
 530                                            TUScope, false, DRE->getLocStart()));
 531
 532   // The first argument --- the pointer --- has a fixed type; we
 533   // deduce the types of the rest of the arguments accordingly.  Walk
 534   // the remaining arguments, converting them to the deduced value type.
 535   for (unsigned i = 0; i != NumFixed; ++i) {
 536     Expr *Arg = TheCall->getArg(i+1);
 537
 538     // If the argument is an implicit cast, then there was a promotion due to
 539     // "...", just remove it now.
 540     if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
 541       Arg = ICE->getSubExpr();
 542       ICE->setSubExpr(0);
 543       TheCall->setArg(i+1, Arg);
 544     }
 545
 546     // GCC does an implicit conversion to the pointer or integer ValType.  This
 547     // can fail in some cases (1i -> int**), check for this error case now.
 548     CastKind Kind = CK_Unknown;
 549     CXXCastPath BasePath;
 550     if (CheckCastTypes(Arg->getSourceRange(), ValType, Arg, Kind, BasePath))
 551       return ExprError();
 552
 553     // Okay, we have something that *can* be converted to the right type.  Check
 554     // to see if there is a potentially weird extension going on here.  This can
 555     // happen when you do an atomic operation on something like an char* and
 556     // pass in 42.  The 42 gets converted to char.  This is even more strange
 557     // for things like 45.123 -> char, etc.
 558     // FIXME: Do this check.
 559     ImpCastExprToType(Arg, ValType, Kind, VK_RValue, &BasePath);
 560     TheCall->setArg(i+1, Arg);
 561   }
 562
 563   // Switch the DeclRefExpr to refer to the new decl.
 564   DRE->setDecl(NewBuiltinDecl);
 565   DRE->setType(NewBuiltinDecl->getType());
 566
 567   // Set the callee in the CallExpr.
 568   // FIXME: This leaks the original parens and implicit casts.
 569   Expr *PromotedCall = DRE;
 570   UsualUnaryConversions(PromotedCall);
 571   TheCall->setCallee(PromotedCall);
 572
 573   // Change the result type of the call to match the original value type. This
 574   // is arbitrary, but the codegen for these builtins ins design to handle it
 575   // gracefully.
 576   TheCall->setType(ResultType);
 577
 578   return move(TheCallResult);
 579 }
 580
 581
 582 /// CheckObjCString - Checks that the argument to the builtin
 583 /// CFString constructor is correct
 584 /// FIXME: GCC currently emits the following warning:
 585 /// "warning: input conversion stopped due to an input byte that does not
 586 ///           belong to the input codeset UTF-8"
 587 /// Note: It might also make sense to do the UTF-16 conversion here (would
 588 /// simplify the backend).
 589 bool Sema::CheckObjCString(Expr *Arg) {
 590   Arg = Arg->IgnoreParenCasts();
 591   StringLiteral *Literal = dyn_cast<StringLiteral>(Arg);
 592
 593   if (!Literal || Literal->isWide()) {
 594     Diag(Arg->getLocStart(), diag::err_cfstring_literal_not_string_constant)
 595       << Arg->getSourceRange();
 596     return true;
 597   }
 598
 599   size_t NulPos = Literal->getString().find('\0');
 600   if (NulPos != llvm::StringRef::npos) {
 601     Diag(getLocationOfStringLiteralByte(Literal, NulPos),
 602          diag::warn_cfstring_literal_contains_nul_character)
 603       << Arg->getSourceRange();
 604   }
 605
 606   return false;
 607 }
 608
 609 /// SemaBuiltinVAStart - Check the arguments to __builtin_va_start for validity.
 610 /// Emit an error and return true on failure, return false on success.
 611 bool Sema::SemaBuiltinVAStart(CallExpr *TheCall) {
 612   Expr *Fn = TheCall->getCallee();
 613   if (TheCall->getNumArgs() > 2) {
 614     Diag(TheCall->getArg(2)->getLocStart(),
 615          diag::err_typecheck_call_too_many_args)
 616       << 0 /*function call*/ << 2 << TheCall->getNumArgs()
 617       << Fn->getSourceRange()
 618       << SourceRange(TheCall->getArg(2)->getLocStart(),
 619                      (*(TheCall->arg_end()-1))->getLocEnd());
 620     return true;
 621   }
 622
 623   if (TheCall->getNumArgs() < 2) {
 624     return Diag(TheCall->getLocEnd(),
 625       diag::err_typecheck_call_too_few_args_at_least)
 626       << 0 /*function call*/ << 2 << TheCall->getNumArgs();
 627   }
 628
 629   // Determine whether the current function is variadic or not.
 630   BlockScopeInfo *CurBlock = getCurBlock();
 631   bool isVariadic;
 632   if (CurBlock)
 633     isVariadic = CurBlock->TheDecl->isVariadic();
 634   else if (FunctionDecl *FD = getCurFunctionDecl())
 635     isVariadic = FD->isVariadic();
 636   else
 637     isVariadic = getCurMethodDecl()->isVariadic();
 638
 639   if (!isVariadic) {
 640     Diag(Fn->getLocStart(), diag::err_va_start_used_in_non_variadic_function);
 641     return true;
 642   }
 643
 644   // Verify that the second argument to the builtin is the last argument of the
 645   // current function or method.
 646   bool SecondArgIsLastNamedArgument = false;
 647   const Expr *Arg = TheCall->getArg(1)->IgnoreParenCasts();
 648
 649   if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Arg)) {
 650     if (const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(DR->getDecl())) {
 651       // FIXME: This isn't correct for methods (results in bogus warning).
 652       // Get the last formal in the current function.
 653       const ParmVarDecl *LastArg;
 654       if (CurBlock)
 655         LastArg = *(CurBlock->TheDecl->param_end()-1);
 656       else if (FunctionDecl *FD = getCurFunctionDecl())
 657         LastArg = *(FD->param_end()-1);
 658       else
 659         LastArg = *(getCurMethodDecl()->param_end()-1);
 660       SecondArgIsLastNamedArgument = PV == LastArg;
 661     }
 662   }
 663
 664   if (!SecondArgIsLastNamedArgument)
 665     Diag(TheCall->getArg(1)->getLocStart(),
 666          diag::warn_second_parameter_of_va_start_not_last_named_argument);
 667   return false;
 668 }
 669
 670 /// SemaBuiltinUnorderedCompare - Handle functions like __builtin_isgreater and
 671 /// friends.  This is declared to take (...), so we have to check everything.
 672 bool Sema::SemaBuiltinUnorderedCompare(CallExpr *TheCall) {
 673   if (TheCall->getNumArgs() < 2)
 674     return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args)
 675       << 0 << 2 << TheCall->getNumArgs()/*function call*/;
 676   if (TheCall->getNumArgs() > 2)
 677     return Diag(TheCall->getArg(2)->getLocStart(),
 678                 diag::err_typecheck_call_too_many_args)
 679       << 0 /*function call*/ << 2 << TheCall->getNumArgs()
 680       << SourceRange(TheCall->getArg(2)->getLocStart(),
 681                      (*(TheCall->arg_end()-1))->getLocEnd());
 682
 683   Expr *OrigArg0 = TheCall->getArg(0);
 684   Expr *OrigArg1 = TheCall->getArg(1);
 685
 686   // Do standard promotions between the two arguments, returning their common
 687   // type.
 688   QualType Res = UsualArithmeticConversions(OrigArg0, OrigArg1, false);
 689
 690   // Make sure any conversions are pushed back into the call; this is
 691   // type safe since unordered compare builtins are declared as "_Bool
 692   // foo(...)".
 693   TheCall->setArg(0, OrigArg0);
 694   TheCall->setArg(1, OrigArg1);
 695
 696   if (OrigArg0->isTypeDependent() || OrigArg1->isTypeDependent())
 697     return false;
 698
 699   // If the common type isn't a real floating type, then the arguments were
 700   // invalid for this operation.
 701   if (!Res->isRealFloatingType())
 702     return Diag(OrigArg0->getLocStart(),
 703                 diag::err_typecheck_call_invalid_ordered_compare)
 704       << OrigArg0->getType() << OrigArg1->getType()
 705       << SourceRange(OrigArg0->getLocStart(), OrigArg1->getLocEnd());
 706
 707   return false;
 708 }
 709
 710 /// SemaBuiltinSemaBuiltinFPClassification - Handle functions like
 711 /// __builtin_isnan and friends.  This is declared to take (...), so we have
 712 /// to check everything. We expect the last argument to be a floating point
 713 /// value.
 714 bool Sema::SemaBuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs) {
 715   if (TheCall->getNumArgs() < NumArgs)
 716     return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args)
 717       << 0 << NumArgs << TheCall->getNumArgs()/*function call*/;
 718   if (TheCall->getNumArgs() > NumArgs)
 719     return Diag(TheCall->getArg(NumArgs)->getLocStart(),
 720                 diag::err_typecheck_call_too_many_args)
 721       << 0 /*function call*/ << NumArgs << TheCall->getNumArgs()
 722       << SourceRange(TheCall->getArg(NumArgs)->getLocStart(),
 723                      (*(TheCall->arg_end()-1))->getLocEnd());
 724
 725   Expr *OrigArg = TheCall->getArg(NumArgs-1);
 726
 727   if (OrigArg->isTypeDependent())
 728     return false;
 729
 730   // This operation requires a non-_Complex floating-point number.
 731   if (!OrigArg->getType()->isRealFloatingType())
 732     return Diag(OrigArg->getLocStart(),
 733                 diag::err_typecheck_call_invalid_unary_fp)
 734       << OrigArg->getType() << OrigArg->getSourceRange();
 735
 736   // If this is an implicit conversion from float -> double, remove it.
 737   if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(OrigArg)) {
 738     Expr *CastArg = Cast->getSubExpr();
 739     if (CastArg->getType()->isSpecificBuiltinType(BuiltinType::Float)) {
 740       assert(Cast->getType()->isSpecificBuiltinType(BuiltinType::Double) &&
 741              "promotion from float to double is the only expected cast here");
 742       Cast->setSubExpr(0);
 743       TheCall->setArg(NumArgs-1, CastArg);
 744       OrigArg = CastArg;
 745     }
 746   }
 747
 748   return false;
 749 }
 750
 751 /// SemaBuiltinShuffleVector - Handle __builtin_shufflevector.
 752 // This is declared to take (...), so we have to check everything.
 753 ExprResult Sema::SemaBuiltinShuffleVector(CallExpr *TheCall) {
 754   if (TheCall->getNumArgs() < 2)
 755     return ExprError(Diag(TheCall->getLocEnd(),
 756                           diag::err_typecheck_call_too_few_args_at_least)
 757       << 0 /*function call*/ << 2 << TheCall->getNumArgs()
 758       << TheCall->getSourceRange());
 759
 760   // Determine which of the following types of shufflevector we're checking:
 761   // 1) unary, vector mask: (lhs, mask)
 762   // 2) binary, vector mask: (lhs, rhs, mask)
 763   // 3) binary, scalar mask: (lhs, rhs, index, ..., index)
 764   QualType resType = TheCall->getArg(0)->getType();
 765   unsigned numElements = 0;
 766
 767   if (!TheCall->getArg(0)->isTypeDependent() &&
 768       !TheCall->getArg(1)->isTypeDependent()) {
 769     QualType LHSType = TheCall->getArg(0)->getType();
 770     QualType RHSType = TheCall->getArg(1)->getType();
 771
 772     if (!LHSType->isVectorType() || !RHSType->isVectorType()) {
 773       Diag(TheCall->getLocStart(), diag::err_shufflevector_non_vector)
 774         << SourceRange(TheCall->getArg(0)->getLocStart(),
 775                        TheCall->getArg(1)->getLocEnd());
 776       return ExprError();
 777     }
 778
 779     numElements = LHSType->getAs<VectorType>()->getNumElements();
 780     unsigned numResElements = TheCall->getNumArgs() - 2;
 781
 782     // Check to see if we have a call with 2 vector arguments, the unary shuffle
 783     // with mask.  If so, verify that RHS is an integer vector type with the
 784     // same number of elts as lhs.
 785     if (TheCall->getNumArgs() == 2) {
 786       if (!RHSType->hasIntegerRepresentation() ||
 787           RHSType->getAs<VectorType>()->getNumElements() != numElements)
 788         Diag(TheCall->getLocStart(), diag::err_shufflevector_incompatible_vector)
 789           << SourceRange(TheCall->getArg(1)->getLocStart(),
 790                          TheCall->getArg(1)->getLocEnd());
 791       numResElements = numElements;
 792     }
 793     else if (!Context.hasSameUnqualifiedType(LHSType, RHSType)) {
 794       Diag(TheCall->getLocStart(), diag::err_shufflevector_incompatible_vector)
 795         << SourceRange(TheCall->getArg(0)->getLocStart(),
 796                        TheCall->getArg(1)->getLocEnd());
 797       return ExprError();
 798     } else if (numElements != numResElements) {
 799       QualType eltType = LHSType->getAs<VectorType>()->getElementType();
 800       resType = Context.getVectorType(eltType, numResElements,
 801                                       VectorType::NotAltiVec);
 802     }
 803   }
 804
 805   for (unsigned i = 2; i < TheCall->getNumArgs(); i++) {
 806     if (TheCall->getArg(i)->isTypeDependent() ||
 807         TheCall->getArg(i)->isValueDependent())
 808       continue;
 809
 810     llvm::APSInt Result(32);
 811     if (!TheCall->getArg(i)->isIntegerConstantExpr(Result, Context))
 812       return ExprError(Diag(TheCall->getLocStart(),
 813                   diag::err_shufflevector_nonconstant_argument)
 814                 << TheCall->getArg(i)->getSourceRange());
 815
 816     if (Result.getActiveBits() > 64 || Result.getZExtValue() >= numElements*2)
 817       return ExprError(Diag(TheCall->getLocStart(),
 818                   diag::err_shufflevector_argument_too_large)
 819                << TheCall->getArg(i)->getSourceRange());
 820   }
 821
 822   llvm::SmallVector<Expr*, 32> exprs;
 823
 824   for (unsigned i = 0, e = TheCall->getNumArgs(); i != e; i++) {
 825     exprs.push_back(TheCall->getArg(i));
 826     TheCall->setArg(i, 0);
 827   }
 828
 829   return Owned(new (Context) ShuffleVectorExpr(Context, exprs.begin(),
 830                                             exprs.size(), resType,
 831                                             TheCall->getCallee()->getLocStart(),
 832                                             TheCall->getRParenLoc()));
 833 }
 834
 835 /// SemaBuiltinPrefetch - Handle __builtin_prefetch.
 836 // This is declared to take (const void*, ...) and can take two
 837 // optional constant int args.
 838 bool Sema::SemaBuiltinPrefetch(CallExpr *TheCall) {
 839   unsigned NumArgs = TheCall->getNumArgs();
 840
 841   if (NumArgs > 3)
 842     return Diag(TheCall->getLocEnd(),
 843              diag::err_typecheck_call_too_many_args_at_most)
 844              << 0 /*function call*/ << 3 << NumArgs
 845              << TheCall->getSourceRange();
 846
 847   // Argument 0 is checked for us and the remaining arguments must be
 848   // constant integers.
 849   for (unsigned i = 1; i != NumArgs; ++i) {
 850     Expr *Arg = TheCall->getArg(i);
 851
 852     llvm::APSInt Result;
 853     if (SemaBuiltinConstantArg(TheCall, i, Result))
 854       return true;
 855
 856     // FIXME: gcc issues a warning and rewrites these to 0. These
 857     // seems especially odd for the third argument since the default
 858     // is 3.
 859     if (i == 1) {
 860       if (Result.getLimitedValue() > 1)
 861         return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range)
 862              << "0" << "1" << Arg->getSourceRange();
 863     } else {
 864       if (Result.getLimitedValue() > 3)
 865         return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range)
 866             << "0" << "3" << Arg->getSourceRange();
 867     }
 868   }
 869
 870   return false;
 871 }
 872
 873 /// SemaBuiltinConstantArg - Handle a check if argument ArgNum of CallExpr
 874 /// TheCall is a constant expression.
 875 bool Sema::SemaBuiltinConstantArg(CallExpr *TheCall, int ArgNum,
 876                                   llvm::APSInt &Result) {
 877   Expr *Arg = TheCall->getArg(ArgNum);
 878   DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
 879   FunctionDecl *FDecl = cast<FunctionDecl>(DRE->getDecl());
 880
 881   if (Arg->isTypeDependent() || Arg->isValueDependent()) return false;
 882
 883   if (!Arg->isIntegerConstantExpr(Result, Context))
 884     return Diag(TheCall->getLocStart(), diag::err_constant_integer_arg_type)
 885                 << FDecl->getDeclName() <<  Arg->getSourceRange();
 886
 887   return false;
 888 }
 889
 890 /// SemaBuiltinObjectSize - Handle __builtin_object_size(void *ptr,
 891 /// int type). This simply type checks that type is one of the defined
 892 /// constants (0-3).
 893 // For compatability check 0-3, llvm only handles 0 and 2.
 894 bool Sema::SemaBuiltinObjectSize(CallExpr *TheCall) {
 895   llvm::APSInt Result;
 896
 897   // Check constant-ness first.
 898   if (SemaBuiltinConstantArg(TheCall, 1, Result))
 899     return true;
 900
 901   Expr *Arg = TheCall->getArg(1);
 902   if (Result.getSExtValue() < 0 || Result.getSExtValue() > 3) {
 903     return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range)
 904              << "0" << "3" << SourceRange(Arg->getLocStart(), Arg->getLocEnd());
 905   }
 906
 907   return false;
 908 }
 909
 910 /// SemaBuiltinLongjmp - Handle __builtin_longjmp(void *env[5], int val).
 911 /// This checks that val is a constant 1.
 912 bool Sema::SemaBuiltinLongjmp(CallExpr *TheCall) {
 913   Expr *Arg = TheCall->getArg(1);
 914   llvm::APSInt Result;
 915
 916   // TODO: This is less than ideal. Overload this to take a value.
 917   if (SemaBuiltinConstantArg(TheCall, 1, Result))
 918     return true;
 919
 920   if (Result != 1)
 921     return Diag(TheCall->getLocStart(), diag::err_builtin_longjmp_invalid_val)
 922              << SourceRange(Arg->getLocStart(), Arg->getLocEnd());
 923
 924   return false;
 925 }
 926
 927 // Handle i > 1 ? "x" : "y", recursivelly
 928 bool Sema::SemaCheckStringLiteral(const Expr *E, const CallExpr *TheCall,
 929                                   bool HasVAListArg,
 930                                   unsigned format_idx, unsigned firstDataArg,
 931                                   bool isPrintf) {
 932
 933   if (E->isTypeDependent() || E->isValueDependent())
 934     return false;
 935
 936   switch (E->getStmtClass()) {
 937   case Stmt::ConditionalOperatorClass: {
 938     const ConditionalOperator *C = cast<ConditionalOperator>(E);
 939     return SemaCheckStringLiteral(C->getTrueExpr(), TheCall, HasVAListArg,
 940                                   format_idx, firstDataArg, isPrintf)
 941         && SemaCheckStringLiteral(C->getRHS(), TheCall, HasVAListArg,
 942                                   format_idx, firstDataArg, isPrintf);
 943   }
 944
 945   case Stmt::ImplicitCastExprClass: {
 946     const ImplicitCastExpr *Expr = cast<ImplicitCastExpr>(E);
 947     return SemaCheckStringLiteral(Expr->getSubExpr(), TheCall, HasVAListArg,
 948                                   format_idx, firstDataArg, isPrintf);
 949   }
 950
 951   case Stmt::ParenExprClass: {
 952     const ParenExpr *Expr = cast<ParenExpr>(E);
 953     return SemaCheckStringLiteral(Expr->getSubExpr(), TheCall, HasVAListArg,
 954                                   format_idx, firstDataArg, isPrintf);
 955   }
 956
 957   case Stmt::DeclRefExprClass: {
 958     const DeclRefExpr *DR = cast<DeclRefExpr>(E);
 959
 960     // As an exception, do not flag errors for variables binding to
 961     // const string literals.
 962     if (const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl())) {
 963       bool isConstant = false;
 964       QualType T = DR->getType();
 965
 966       if (const ArrayType *AT = Context.getAsArrayType(T)) {
 967         isConstant = AT->getElementType().isConstant(Context);
 968       } else if (const PointerType *PT = T->getAs<PointerType>()) {
 969         isConstant = T.isConstant(Context) &&
 970                      PT->getPointeeType().isConstant(Context);
 971       }
 972
 973       if (isConstant) {
 974         if (const Expr *Init = VD->getAnyInitializer())
 975           return SemaCheckStringLiteral(Init, TheCall,
 976                                         HasVAListArg, format_idx, firstDataArg,
 977                                         isPrintf);
 978       }
 979
 980       // For vprintf* functions (i.e., HasVAListArg==true), we add a
 981       // special check to see if the format string is a function parameter
 982       // of the function calling the printf function.  If the function
 983       // has an attribute indicating it is a printf-like function, then we
 984       // should suppress warnings concerning non-literals being used in a call
 985       // to a vprintf function.  For example:
 986       //
 987       // void
 988       // logmessage(char const *fmt __attribute__ (format (printf, 1, 2)), ...){
 989       //      va_list ap;
 990       //      va_start(ap, fmt);
 991       //      vprintf(fmt, ap);  // Do NOT emit a warning about "fmt".
 992       //      ...
 993       //
 994       //
 995       //  FIXME: We don't have full attribute support yet, so just check to see
 996       //    if the argument is a DeclRefExpr that references a parameter.  We'll
 997       //    add proper support for checking the attribute later.
 998       if (HasVAListArg)
 999         if (isa<ParmVarDecl>(VD))
1000           return true;
1001     }
1002
1003     return false;
1004   }
1005
1006   case Stmt::CallExprClass: {
1007     const CallExpr *CE = cast<CallExpr>(E);
1008     if (const ImplicitCastExpr *ICE
1009           = dyn_cast<ImplicitCastExpr>(CE->getCallee())) {
1010       if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) {
1011         if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
1012           if (const FormatArgAttr *FA = FD->getAttr<FormatArgAttr>()) {
1013             unsigned ArgIndex = FA->getFormatIdx();
1014             const Expr *Arg = CE->getArg(ArgIndex - 1);
1015
1016             return SemaCheckStringLiteral(Arg, TheCall, HasVAListArg,
1017                                           format_idx, firstDataArg, isPrintf);
1018           }
1019         }
1020       }
1021     }
1022
1023     return false;
1024   }
1025   case Stmt::ObjCStringLiteralClass:
1026   case Stmt::StringLiteralClass: {
1027     const StringLiteral *StrE = NULL;
1028
1029     if (const ObjCStringLiteral *ObjCFExpr = dyn_cast<ObjCStringLiteral>(E))
1030       StrE = ObjCFExpr->getString();
1031     else
1032       StrE = cast<StringLiteral>(E);
1033
1034     if (StrE) {
1035       CheckFormatString(StrE, E, TheCall, HasVAListArg, format_idx,
1036                         firstDataArg, isPrintf);
1037       return true;
1038     }
1039
1040     return false;
1041   }
1042
1043   default:
1044     return false;
1045   }
1046 }
1047
1048 void
1049 Sema::CheckNonNullArguments(const NonNullAttr *NonNull,
1050                             const CallExpr *TheCall) {
1051   for (NonNullAttr::args_iterator i = NonNull->args_begin(),
1052                                   e = NonNull->args_end();
1053        i != e; ++i) {
1054     const Expr *ArgExpr = TheCall->getArg(*i);
1055     if (ArgExpr->isNullPointerConstant(Context,
1056                                        Expr::NPC_ValueDependentIsNotNull))
1057       Diag(TheCall->getCallee()->getLocStart(), diag::warn_null_arg)
1058         << ArgExpr->getSourceRange();
1059   }
1060 }
1061
1062 /// CheckPrintfScanfArguments - Check calls to printf and scanf (and similar
1063 /// functions) for correct use of format strings.
1064 void
1065 Sema::CheckPrintfScanfArguments(const CallExpr *TheCall, bool HasVAListArg,
1066                                 unsigned format_idx, unsigned firstDataArg,
1067                                 bool isPrintf) {
1068
1069   const Expr *Fn = TheCall->getCallee();
1070
1071   // The way the format attribute works in GCC, the implicit this argument
1072   // of member functions is counted. However, it doesn't appear in our own
1073   // lists, so decrement format_idx in that case.
1074   if (isa<CXXMemberCallExpr>(TheCall)) {
1075     // Catch a format attribute mistakenly referring to the object argument.
1076     if (format_idx == 0)
1077       return;
1078     --format_idx;
1079     if(firstDataArg != 0)
1080       --firstDataArg;
1081   }
1082
1083   // CHECK: printf/scanf-like function is called with no format string.
1084   if (format_idx >= TheCall->getNumArgs()) {
1085     Diag(TheCall->getRParenLoc(), diag::warn_missing_format_string)
1086       << Fn->getSourceRange();
1087     return;
1088   }
1089
1090   const Expr *OrigFormatExpr = TheCall->getArg(format_idx)->IgnoreParenCasts();
1091
1092   // CHECK: format string is not a string literal.
1093   //
1094   // Dynamically generated format strings are difficult to
1095   // automatically vet at compile time.  Requiring that format strings
1096   // are string literals: (1) permits the checking of format strings by
1097   // the compiler and thereby (2) can practically remove the source of
1098   // many format string exploits.
1099
1100   // Format string can be either ObjC string (e.g. @"%d") or
1101   // C string (e.g. "%d")
1102   // ObjC string uses the same format specifiers as C string, so we can use
1103   // the same format string checking logic for both ObjC and C strings.
1104   if (SemaCheckStringLiteral(OrigFormatExpr, TheCall, HasVAListArg, format_idx,
1105                              firstDataArg, isPrintf))
1106     return;  // Literal format string found, check done!
1107
1108   // If there are no arguments specified, warn with -Wformat-security, otherwise
1109   // warn only with -Wformat-nonliteral.
1110   if (TheCall->getNumArgs() == format_idx+1)
1111     Diag(TheCall->getArg(format_idx)->getLocStart(),
1112          diag::warn_format_nonliteral_noargs)
1113       << OrigFormatExpr->getSourceRange();
1114   else
1115     Diag(TheCall->getArg(format_idx)->getLocStart(),
1116          diag::warn_format_nonliteral)
1117            << OrigFormatExpr->getSourceRange();
1118 }
1119
1120 namespace {
1121 class CheckFormatHandler : public analyze_format_string::FormatStringHandler {
1122 protected:
1123   Sema &S;
1124   const StringLiteral *FExpr;
1125   const Expr *OrigFormatExpr;
1126   const unsigned FirstDataArg;
1127   const unsigned NumDataArgs;
1128   const bool IsObjCLiteral;
1129   const char *Beg; // Start of format string.
1130   const bool HasVAListArg;
1131   const CallExpr *TheCall;
1132   unsigned FormatIdx;
1133   llvm::BitVector CoveredArgs;
1134   bool usesPositionalArgs;
1135   bool atFirstArg;
1136 public:
1137   CheckFormatHandler(Sema &s, const StringLiteral *fexpr,
1138                      const Expr *origFormatExpr, unsigned firstDataArg,
1139                      unsigned numDataArgs, bool isObjCLiteral,
1140                      const char *beg, bool hasVAListArg,
1141                      const CallExpr *theCall, unsigned formatIdx)
1142     : S(s), FExpr(fexpr), OrigFormatExpr(origFormatExpr),
1143       FirstDataArg(firstDataArg),
1144       NumDataArgs(numDataArgs),
1145       IsObjCLiteral(isObjCLiteral), Beg(beg),
1146       HasVAListArg(hasVAListArg),
1147       TheCall(theCall), FormatIdx(formatIdx),
1148       usesPositionalArgs(false), atFirstArg(true) {
1149         CoveredArgs.resize(numDataArgs);
1150         CoveredArgs.reset();
1151       }
1152
1153   void DoneProcessing();
1154
1155   void HandleIncompleteSpecifier(const char *startSpecifier,
1156                                  unsigned specifierLen);
1157
1158   virtual void HandleInvalidPosition(const char *startSpecifier,
1159                                      unsigned specifierLen,
1160                                      analyze_format_string::PositionContext p);
1161
1162   virtual void HandleZeroPosition(const char *startPos, unsigned posLen);
1163
1164   void HandleNullChar(const char *nullCharacter);
1165
1166 protected:
1167   bool HandleInvalidConversionSpecifier(unsigned argIndex, SourceLocation Loc,
1168                                         const char *startSpec,
1169                                         unsigned specifierLen,
1170                                         const char *csStart, unsigned csLen);
1171
1172   SourceRange getFormatStringRange();
1173   CharSourceRange getSpecifierRange(const char *startSpecifier,
1174                                     unsigned specifierLen);
1175   SourceLocation getLocationOfByte(const char *x);
1176
1177   const Expr *getDataArg(unsigned i) const;
1178
1179   bool CheckNumArgs(const analyze_format_string::FormatSpecifier &FS,
1180                     const analyze_format_string::ConversionSpecifier &CS,
1181                     const char *startSpecifier, unsigned specifierLen,
1182                     unsigned argIndex);
1183 };
1184 }
1185
1186 SourceRange CheckFormatHandler::getFormatStringRange() {
1187   return OrigFormatExpr->getSourceRange();
1188 }
1189
1190 CharSourceRange CheckFormatHandler::
1191 getSpecifierRange(const char *startSpecifier, unsigned specifierLen) {
1192   SourceLocation Start = getLocationOfByte(startSpecifier);
1193   SourceLocation End   = getLocationOfByte(startSpecifier + specifierLen - 1);
1194
1195   // Advance the end SourceLocation by one due to half-open ranges.
1196   End = End.getFileLocWithOffset(1);
1197
1198   return CharSourceRange::getCharRange(Start, End);
1199 }
1200
1201 SourceLocation CheckFormatHandler::getLocationOfByte(const char *x) {
1202   return S.getLocationOfStringLiteralByte(FExpr, x - Beg);
1203 }
1204
1205 void CheckFormatHandler::HandleIncompleteSpecifier(const char *startSpecifier,
1206                                                    unsigned specifierLen){
1207   SourceLocation Loc = getLocationOfByte(startSpecifier);
1208   S.Diag(Loc, diag::warn_printf_incomplete_specifier)
1209     << getSpecifierRange(startSpecifier, specifierLen);
1210 }
1211
1212 void
1213 CheckFormatHandler::HandleInvalidPosition(const char *startPos, unsigned posLen,
1214                                      analyze_format_string::PositionContext p) {
1215   SourceLocation Loc = getLocationOfByte(startPos);
1216   S.Diag(Loc, diag::warn_format_invalid_positional_specifier)
1217     << (unsigned) p << getSpecifierRange(startPos, posLen);
1218 }
1219
1220 void CheckFormatHandler::HandleZeroPosition(const char *startPos,
1221                                             unsigned posLen) {
1222   SourceLocation Loc = getLocationOfByte(startPos);
1223   S.Diag(Loc, diag::warn_format_zero_positional_specifier)
1224     << getSpecifierRange(startPos, posLen);
1225 }
1226
1227 void CheckFormatHandler::HandleNullChar(const char *nullCharacter) {
1228   // The presence of a null character is likely an error.
1229   S.Diag(getLocationOfByte(nullCharacter),
1230          diag::warn_printf_format_string_contains_null_char)
1231     << getFormatStringRange();
1232 }
1233
1234 const Expr *CheckFormatHandler::getDataArg(unsigned i) const {
1235   return TheCall->getArg(FirstDataArg + i);
1236 }
1237
1238 void CheckFormatHandler::DoneProcessing() {
1239     // Does the number of data arguments exceed the number of
1240     // format conversions in the format string?
1241   if (!HasVAListArg) {
1242       // Find any arguments that weren't covered.
1243     CoveredArgs.flip();
1244     signed notCoveredArg = CoveredArgs.find_first();
1245     if (notCoveredArg >= 0) {
1246       assert((unsigned)notCoveredArg < NumDataArgs);
1247       S.Diag(getDataArg((unsigned) notCoveredArg)->getLocStart(),
1248              diag::warn_printf_data_arg_not_used)
1249       << getFormatStringRange();
1250     }
1251   }
1252 }
1253
1254 bool
1255 CheckFormatHandler::HandleInvalidConversionSpecifier(unsigned argIndex,
1256                                                      SourceLocation Loc,
1257                                                      const char *startSpec,
1258                                                      unsigned specifierLen,
1259                                                      const char *csStart,
1260                                                      unsigned csLen) {
1261
1262   bool keepGoing = true;
1263   if (argIndex < NumDataArgs) {
1264     // Consider the argument coverered, even though the specifier doesn't
1265     // make sense.
1266     CoveredArgs.set(argIndex);
1267   }
1268   else {
1269     // If argIndex exceeds the number of data arguments we
1270     // don't issue a warning because that is just a cascade of warnings (and
1271     // they may have intended '%%' anyway). We don't want to continue processing
1272     // the format string after this point, however, as we will like just get
1273     // gibberish when trying to match arguments.
1274     keepGoing = false;
1275   }
1276
1277   S.Diag(Loc, diag::warn_format_invalid_conversion)
1278     << llvm::StringRef(csStart, csLen)
1279     << getSpecifierRange(startSpec, specifierLen);
1280
1281   return keepGoing;
1282 }
1283
1284 bool
1285 CheckFormatHandler::CheckNumArgs(
1286   const analyze_format_string::FormatSpecifier &FS,
1287   const analyze_format_string::ConversionSpecifier &CS,
1288   const char *startSpecifier, unsigned specifierLen, unsigned argIndex) {
1289
1290   if (argIndex >= NumDataArgs) {
1291     if (FS.usesPositionalArg())  {
1292       S.Diag(getLocationOfByte(CS.getStart()),
1293              diag::warn_printf_positional_arg_exceeds_data_args)
1294       << (argIndex+1) << NumDataArgs
1295       << getSpecifierRange(startSpecifier, specifierLen);
1296     }
1297     else {
1298       S.Diag(getLocationOfByte(CS.getStart()),
1299              diag::warn_printf_insufficient_data_args)
1300       << getSpecifierRange(startSpecifier, specifierLen);
1301     }
1302
1303     return false;
1304   }
1305   return true;
1306 }
1307
1308 //===--- CHECK: Printf format string checking ------------------------------===//
1309
1310 namespace {
1311 class CheckPrintfHandler : public CheckFormatHandler {
1312 public:
1313   CheckPrintfHandler(Sema &s, const StringLiteral *fexpr,
1314                      const Expr *origFormatExpr, unsigned firstDataArg,
1315                      unsigned numDataArgs, bool isObjCLiteral,
1316                      const char *beg, bool hasVAListArg,
1317                      const CallExpr *theCall, unsigned formatIdx)
1318   : CheckFormatHandler(s, fexpr, origFormatExpr, firstDataArg,
1319                        numDataArgs, isObjCLiteral, beg, hasVAListArg,
1320                        theCall, formatIdx) {}
1321
1322
1323   bool HandleInvalidPrintfConversionSpecifier(
1324                                       const analyze_printf::PrintfSpecifier &FS,
1325                                       const char *startSpecifier,
1326                                       unsigned specifierLen);
1327
1328   bool HandlePrintfSpecifier(const analyze_printf::PrintfSpecifier &FS,
1329                              const char *startSpecifier,
1330                              unsigned specifierLen);
1331
1332   bool HandleAmount(const analyze_format_string::OptionalAmount &Amt, unsigned k,
1333                     const char *startSpecifier, unsigned specifierLen);
1334   void HandleInvalidAmount(const analyze_printf::PrintfSpecifier &FS,
1335                            const analyze_printf::OptionalAmount &Amt,
1336                            unsigned type,
1337                            const char *startSpecifier, unsigned specifierLen);
1338   void HandleFlag(const analyze_printf::PrintfSpecifier &FS,
1339                   const analyze_printf::OptionalFlag &flag,
1340                   const char *startSpecifier, unsigned specifierLen);
1341   void HandleIgnoredFlag(const analyze_printf::PrintfSpecifier &FS,
1342                          const analyze_printf::OptionalFlag &ignoredFlag,
1343                          const analyze_printf::OptionalFlag &flag,
1344                          const char *startSpecifier, unsigned specifierLen);
1345 };
1346 }
1347
1348 bool CheckPrintfHandler::HandleInvalidPrintfConversionSpecifier(
1349                                       const analyze_printf::PrintfSpecifier &FS,
1350                                       const char *startSpecifier,
1351                                       unsigned specifierLen) {
1352   const analyze_printf::PrintfConversionSpecifier &CS =
1353     FS.getConversionSpecifier();
1354
1355   return HandleInvalidConversionSpecifier(FS.getArgIndex(),
1356                                           getLocationOfByte(CS.getStart()),
1357                                           startSpecifier, specifierLen,
1358                                           CS.getStart(), CS.getLength());
1359 }
1360
1361 bool CheckPrintfHandler::HandleAmount(
1362                                const analyze_format_string::OptionalAmount &Amt,
1363                                unsigned k, const char *startSpecifier,
1364                                unsigned specifierLen) {
1365
1366   if (Amt.hasDataArgument()) {
1367     if (!HasVAListArg) {
1368       unsigned argIndex = Amt.getArgIndex();
1369       if (argIndex >= NumDataArgs) {
1370         S.Diag(getLocationOfByte(Amt.getStart()),
1371                diag::warn_printf_asterisk_missing_arg)
1372           << k << getSpecifierRange(startSpecifier, specifierLen);
1373         // Don't do any more checking.  We will just emit
1374         // spurious errors.
1375         return false;
1376       }
1377
1378       // Type check the data argument.  It should be an 'int'.
1379       // Although not in conformance with C99, we also allow the argument to be
1380       // an 'unsigned int' as that is a reasonably safe case.  GCC also
1381       // doesn't emit a warning for that case.
1382       CoveredArgs.set(argIndex);
1383       const Expr *Arg = getDataArg(argIndex);
1384       QualType T = Arg->getType();
1385
1386       const analyze_printf::ArgTypeResult &ATR = Amt.getArgType(S.Context);
1387       assert(ATR.isValid());
1388
1389       if (!ATR.matchesType(S.Context, T)) {
1390         S.Diag(getLocationOfByte(Amt.getStart()),
1391                diag::warn_printf_asterisk_wrong_type)
1392           << k
1393           << ATR.getRepresentativeType(S.Context) << T
1394           << getSpecifierRange(startSpecifier, specifierLen)
1395           << Arg->getSourceRange();
1396         // Don't do any more checking.  We will just emit
1397         // spurious errors.
1398         return false;
1399       }
1400     }
1401   }
1402   return true;
1403 }
1404
1405 void CheckPrintfHandler::HandleInvalidAmount(
1406                                       const analyze_printf::PrintfSpecifier &FS,
1407                                       const analyze_printf::OptionalAmount &Amt,
1408                                       unsigned type,
1409                                       const char *startSpecifier,
1410                                       unsigned specifierLen) {
1411   const analyze_printf::PrintfConversionSpecifier &CS =
1412     FS.getConversionSpecifier();
1413   switch (Amt.getHowSpecified()) {
1414   case analyze_printf::OptionalAmount::Constant:
1415     S.Diag(getLocationOfByte(Amt.getStart()),
1416         diag::warn_printf_nonsensical_optional_amount)
1417       << type
1418       << CS.toString()
1419       << getSpecifierRange(startSpecifier, specifierLen)
1420       << FixItHint::CreateRemoval(getSpecifierRange(Amt.getStart(),
1421           Amt.getConstantLength()));
1422     break;
1423
1424   default:
1425     S.Diag(getLocationOfByte(Amt.getStart()),
1426         diag::warn_printf_nonsensical_optional_amount)
1427       << type
1428       << CS.toString()
1429       << getSpecifierRange(startSpecifier, specifierLen);
1430     break;
1431   }
1432 }
1433
1434 void CheckPrintfHandler::HandleFlag(const analyze_printf::PrintfSpecifier &FS,
1435                                     const analyze_printf::OptionalFlag &flag,
1436                                     const char *startSpecifier,
1437                                     unsigned specifierLen) {
1438   // Warn about pointless flag with a fixit removal.
1439   const analyze_printf::PrintfConversionSpecifier &CS =
1440     FS.getConversionSpecifier();
1441   S.Diag(getLocationOfByte(flag.getPosition()),
1442       diag::warn_printf_nonsensical_flag)
1443     << flag.toString() << CS.toString()
1444     << getSpecifierRange(startSpecifier, specifierLen)
1445     << FixItHint::CreateRemoval(getSpecifierRange(flag.getPosition(), 1));
1446 }
1447
1448 void CheckPrintfHandler::HandleIgnoredFlag(
1449                                 const analyze_printf::PrintfSpecifier &FS,
1450                                 const analyze_printf::OptionalFlag &ignoredFlag,
1451                                 const analyze_printf::OptionalFlag &flag,
1452                                 const char *startSpecifier,
1453                                 unsigned specifierLen) {
1454   // Warn about ignored flag with a fixit removal.
1455   S.Diag(getLocationOfByte(ignoredFlag.getPosition()),
1456       diag::warn_printf_ignored_flag)
1457     << ignoredFlag.toString() << flag.toString()
1458     << getSpecifierRange(startSpecifier, specifierLen)
1459     << FixItHint::CreateRemoval(getSpecifierRange(
1460         ignoredFlag.getPosition(), 1));
1461 }
1462
1463 bool
1464 CheckPrintfHandler::HandlePrintfSpecifier(const analyze_printf::PrintfSpecifier
1465                                             &FS,
1466                                           const char *startSpecifier,
1467                                           unsigned specifierLen) {
1468
1469   using namespace analyze_format_string;
1470   using namespace analyze_printf;
1471   const PrintfConversionSpecifier &CS = FS.getConversionSpecifier();
1472
1473   if (FS.consumesDataArgument()) {
1474     if (atFirstArg) {
1475         atFirstArg = false;
1476         usesPositionalArgs = FS.usesPositionalArg();
1477     }
1478     else if (usesPositionalArgs != FS.usesPositionalArg()) {
1479       // Cannot mix-and-match positional and non-positional arguments.
1480       S.Diag(getLocationOfByte(CS.getStart()),
1481              diag::warn_format_mix_positional_nonpositional_args)
1482         << getSpecifierRange(startSpecifier, specifierLen);
1483       return false;
1484     }
1485   }
1486
1487   // First check if the field width, precision, and conversion specifier
1488   // have matching data arguments.
1489   if (!HandleAmount(FS.getFieldWidth(), /* field width */ 0,
1490                     startSpecifier, specifierLen)) {
1491     return false;
1492   }
1493
1494   if (!HandleAmount(FS.getPrecision(), /* precision */ 1,
1495                     startSpecifier, specifierLen)) {
1496     return false;
1497   }
1498
1499   if (!CS.consumesDataArgument()) {
1500     // FIXME: Technically specifying a precision or field width here
1501     // makes no sense.  Worth issuing a warning at some point.
1502     return true;
1503   }
1504
1505   // Consume the argument.
1506   unsigned argIndex = FS.getArgIndex();
1507   if (argIndex < NumDataArgs) {
1508     // The check to see if the argIndex is valid will come later.
1509     // We set the bit here because we may exit early from this
1510     // function if we encounter some other error.
1511     CoveredArgs.set(argIndex);
1512   }
1513
1514   // Check for using an Objective-C specific conversion specifier
1515   // in a non-ObjC literal.
1516   if (!IsObjCLiteral && CS.isObjCArg()) {
1517     return HandleInvalidPrintfConversionSpecifier(FS, startSpecifier,
1518                                                   specifierLen);
1519   }
1520
1521   // Check for invalid use of field width
1522   if (!FS.hasValidFieldWidth()) {
1523     HandleInvalidAmount(FS, FS.getFieldWidth(), /* field width */ 0,
1524         startSpecifier, specifierLen);
1525   }
1526
1527   // Check for invalid use of precision
1528   if (!FS.hasValidPrecision()) {
1529     HandleInvalidAmount(FS, FS.getPrecision(), /* precision */ 1,
1530         startSpecifier, specifierLen);
1531   }
1532
1533   // Check each flag does not conflict with any other component.
1534   if (!FS.hasValidLeadingZeros())
1535     HandleFlag(FS, FS.hasLeadingZeros(), startSpecifier, specifierLen);
1536   if (!FS.hasValidPlusPrefix())
1537     HandleFlag(FS, FS.hasPlusPrefix(), startSpecifier, specifierLen);
1538   if (!FS.hasValidSpacePrefix())
1539     HandleFlag(FS, FS.hasSpacePrefix(), startSpecifier, specifierLen);
1540   if (!FS.hasValidAlternativeForm())
1541     HandleFlag(FS, FS.hasAlternativeForm(), startSpecifier, specifierLen);
1542   if (!FS.hasValidLeftJustified())
1543     HandleFlag(FS, FS.isLeftJustified(), startSpecifier, specifierLen);
1544
1545   // Check that flags are not ignored by another flag
1546   if (FS.hasSpacePrefix() && FS.hasPlusPrefix()) // ' ' ignored by '+'
1547     HandleIgnoredFlag(FS, FS.hasSpacePrefix(), FS.hasPlusPrefix(),
1548         startSpecifier, specifierLen);
1549   if (FS.hasLeadingZeros() && FS.isLeftJustified()) // '0' ignored by '-'
1550     HandleIgnoredFlag(FS, FS.hasLeadingZeros(), FS.isLeftJustified(),
1551             startSpecifier, specifierLen);
1552
1553   // Check the length modifier is valid with the given conversion specifier.
1554   const LengthModifier &LM = FS.getLengthModifier();
1555   if (!FS.hasValidLengthModifier())
1556     S.Diag(getLocationOfByte(LM.getStart()),
1557         diag::warn_format_nonsensical_length)
1558       << LM.toString() << CS.toString()
1559       << getSpecifierRange(startSpecifier, specifierLen)
1560       << FixItHint::CreateRemoval(getSpecifierRange(LM.getStart(),
1561           LM.getLength()));
1562
1563   // Are we using '%n'?
1564   if (CS.getKind() == ConversionSpecifier::nArg) {
1565     // Issue a warning about this being a possible security issue.
1566     S.Diag(getLocationOfByte(CS.getStart()), diag::warn_printf_write_back)
1567       << getSpecifierRange(startSpecifier, specifierLen);
1568     // Continue checking the other format specifiers.
1569     return true;
1570   }
1571
1572   // The remaining checks depend on the data arguments.
1573   if (HasVAListArg)
1574     return true;
1575
1576   if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex))
1577     return false;
1578
1579   // Now type check the data expression that matches the
1580   // format specifier.
1581   const Expr *Ex = getDataArg(argIndex);
1582   const analyze_printf::ArgTypeResult &ATR = FS.getArgType(S.Context);
1583   if (ATR.isValid() && !ATR.matchesType(S.Context, Ex->getType())) {
1584     // Check if we didn't match because of an implicit cast from a 'char'
1585     // or 'short' to an 'int'.  This is done because printf is a varargs
1586     // function.
1587     if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Ex))
1588       if (ICE->getType() == S.Context.IntTy)
1589         if (ATR.matchesType(S.Context, ICE->getSubExpr()->getType()))
1590           return true;
1591
1592     // We may be able to offer a FixItHint if it is a supported type.
1593     PrintfSpecifier fixedFS = FS;
1594     bool success = fixedFS.fixType(Ex->getType());
1595
1596     if (success) {
1597       // Get the fix string from the fixed format specifier
1598       llvm::SmallString<128> buf;
1599       llvm::raw_svector_ostream os(buf);
1600       fixedFS.toString(os);
1601
1602       // FIXME: getRepresentativeType() perhaps should return a string
1603       // instead of a QualType to better handle when the representative
1604       // type is 'wint_t' (which is defined in the system headers).
1605       S.Diag(getLocationOfByte(CS.getStart()),
1606           diag::warn_printf_conversion_argument_type_mismatch)
1607         << ATR.getRepresentativeType(S.Context) << Ex->getType()
1608         << getSpecifierRange(startSpecifier, specifierLen)
1609         << Ex->getSourceRange()
1610         << FixItHint::CreateReplacement(
1611             getSpecifierRange(startSpecifier, specifierLen),
1612             os.str());
1613     }
1614     else {
1615       S.Diag(getLocationOfByte(CS.getStart()),
1616              diag::warn_printf_conversion_argument_type_mismatch)
1617         << ATR.getRepresentativeType(S.Context) << Ex->getType()
1618         << getSpecifierRange(startSpecifier, specifierLen)
1619         << Ex->getSourceRange();
1620     }
1621   }
1622
1623   return true;
1624 }
1625
1626 //===--- CHECK: Scanf format string checking ------------------------------===//
1627
1628 namespace {
1629 class CheckScanfHandler : public CheckFormatHandler {
1630 public:
1631   CheckScanfHandler(Sema &s, const StringLiteral *fexpr,
1632                     const Expr *origFormatExpr, unsigned firstDataArg,
1633                     unsigned numDataArgs, bool isObjCLiteral,
1634                     const char *beg, bool hasVAListArg,
1635                     const CallExpr *theCall, unsigned formatIdx)
1636   : CheckFormatHandler(s, fexpr, origFormatExpr, firstDataArg,
1637                        numDataArgs, isObjCLiteral, beg, hasVAListArg,
1638                        theCall, formatIdx) {}
1639
1640   bool HandleScanfSpecifier(const analyze_scanf::ScanfSpecifier &FS,
1641                             const char *startSpecifier,
1642                             unsigned specifierLen);
1643
1644   bool HandleInvalidScanfConversionSpecifier(
1645           const analyze_scanf::ScanfSpecifier &FS,
1646           const char *startSpecifier,
1647           unsigned specifierLen);
1648
1649   void HandleIncompleteScanList(const char *start, const char *end);
1650 };
1651 }
1652
1653 void CheckScanfHandler::HandleIncompleteScanList(const char *start,
1654                                                  const char *end) {
1655   S.Diag(getLocationOfByte(end), diag::warn_scanf_scanlist_incomplete)
1656     << getSpecifierRange(start, end - start);
1657 }
1658
1659 bool CheckScanfHandler::HandleInvalidScanfConversionSpecifier(
1660                                         const analyze_scanf::ScanfSpecifier &FS,
1661                                         const char *startSpecifier,
1662                                         unsigned specifierLen) {
1663
1664   const analyze_scanf::ScanfConversionSpecifier &CS =
1665     FS.getConversionSpecifier();
1666
1667   return HandleInvalidConversionSpecifier(FS.getArgIndex(),
1668                                           getLocationOfByte(CS.getStart()),
1669                                           startSpecifier, specifierLen,
1670                                           CS.getStart(), CS.getLength());
1671 }
1672
1673 bool CheckScanfHandler::HandleScanfSpecifier(
1674                                        const analyze_scanf::ScanfSpecifier &FS,
1675                                        const char *startSpecifier,
1676                                        unsigned specifierLen) {
1677
1678   using namespace analyze_scanf;
1679   using namespace analyze_format_string;
1680
1681   const ScanfConversionSpecifier &CS = FS.getConversionSpecifier();
1682
1683   // Handle case where '%' and '*' don't consume an argument.  These shouldn't
1684   // be used to decide if we are using positional arguments consistently.
1685   if (FS.consumesDataArgument()) {
1686     if (atFirstArg) {
1687       atFirstArg = false;
1688       usesPositionalArgs = FS.usesPositionalArg();
1689     }
1690     else if (usesPositionalArgs != FS.usesPositionalArg()) {
1691       // Cannot mix-and-match positional and non-positional arguments.
1692       S.Diag(getLocationOfByte(CS.getStart()),
1693              diag::warn_format_mix_positional_nonpositional_args)
1694         << getSpecifierRange(startSpecifier, specifierLen);
1695       return false;
1696     }
1697   }
1698
1699   // Check if the field with is non-zero.
1700   const OptionalAmount &Amt = FS.getFieldWidth();
1701   if (Amt.getHowSpecified() == OptionalAmount::Constant) {
1702     if (Amt.getConstantAmount() == 0) {
1703       const CharSourceRange &R = getSpecifierRange(Amt.getStart(),
1704                                                    Amt.getConstantLength());
1705       S.Diag(getLocationOfByte(Amt.getStart()),
1706              diag::warn_scanf_nonzero_width)
1707         << R << FixItHint::CreateRemoval(R);
1708     }
1709   }
1710
1711   if (!FS.consumesDataArgument()) {
1712     // FIXME: Technically specifying a precision or field width here
1713     // makes no sense.  Worth issuing a warning at some point.
1714     return true;
1715   }
1716
1717   // Consume the argument.
1718   unsigned argIndex = FS.getArgIndex();
1719   if (argIndex < NumDataArgs) {
1720       // The check to see if the argIndex is valid will come later.
1721       // We set the bit here because we may exit early from this
1722       // function if we encounter some other error.
1723     CoveredArgs.set(argIndex);
1724   }
1725
1726   // Check the length modifier is valid with the given conversion specifier.
1727   const LengthModifier &LM = FS.getLengthModifier();
1728   if (!FS.hasValidLengthModifier()) {
1729     S.Diag(getLocationOfByte(LM.getStart()),
1730            diag::warn_format_nonsensical_length)
1731       << LM.toString() << CS.toString()
1732       << getSpecifierRange(startSpecifier, specifierLen)
1733       << FixItHint::CreateRemoval(getSpecifierRange(LM.getStart(),
1734                                                     LM.getLength()));
1735   }
1736
1737   // The remaining checks depend on the data arguments.
1738   if (HasVAListArg)
1739     return true;
1740
1741   if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex))
1742     return false;
1743
1744   // FIXME: Check that the argument type matches the format specifier.
1745
1746   return true;
1747 }
1748
1749 void Sema::CheckFormatString(const StringLiteral *FExpr,
1750                              const Expr *OrigFormatExpr,
1751                              const CallExpr *TheCall, bool HasVAListArg,
1752                              unsigned format_idx, unsigned firstDataArg,
1753                              bool isPrintf) {
1754
1755   // CHECK: is the format string a wide literal?
1756   if (FExpr->isWide()) {
1757     Diag(FExpr->getLocStart(),
1758          diag::warn_format_string_is_wide_literal)
1759     << OrigFormatExpr->getSourceRange();
1760     return;
1761   }
1762
1763   // Str - The format string.  NOTE: this is NOT null-terminated!
1764   llvm::StringRef StrRef = FExpr->getString();
1765   const char *Str = StrRef.data();
1766   unsigned StrLen = StrRef.size();
1767
1768   // CHECK: empty format string?
1769   if (StrLen == 0) {
1770     Diag(FExpr->getLocStart(), diag::warn_empty_format_string)
1771     << OrigFormatExpr->getSourceRange();
1772     return;
1773   }
1774
1775   if (isPrintf) {
1776     CheckPrintfHandler H(*this, FExpr, OrigFormatExpr, firstDataArg,
1777                          TheCall->getNumArgs() - firstDataArg,
1778                          isa<ObjCStringLiteral>(OrigFormatExpr), Str,
1779                          HasVAListArg, TheCall, format_idx);
1780
1781     if (!analyze_format_string::ParsePrintfString(H, Str, Str + StrLen))
1782       H.DoneProcessing();
1783   }
1784   else {
1785     CheckScanfHandler H(*this, FExpr, OrigFormatExpr, firstDataArg,
1786                         TheCall->getNumArgs() - firstDataArg,
1787                         isa<ObjCStringLiteral>(OrigFormatExpr), Str,
1788                         HasVAListArg, TheCall, format_idx);
1789
1790     if (!analyze_format_string::ParseScanfString(H, Str, Str + StrLen))
1791       H.DoneProcessing();
1792   }
1793 }
1794
1795 //===--- CHECK: Return Address of Stack Variable --------------------------===//
1796
1797 static DeclRefExpr* EvalVal(Expr *E);
1798 static DeclRefExpr* EvalAddr(Expr* E);
1799
1800 /// CheckReturnStackAddr - Check if a return statement returns the address
1801 ///   of a stack variable.
1802 void
1803 Sema::CheckReturnStackAddr(Expr *RetValExp, QualType lhsType,
1804                            SourceLocation ReturnLoc) {
1805
1806   // Perform checking for returned stack addresses.
1807   if (lhsType->isPointerType() || lhsType->isBlockPointerType()) {
1808     if (DeclRefExpr *DR = EvalAddr(RetValExp))
1809       Diag(DR->getLocStart(), diag::warn_ret_stack_addr)
1810        << DR->getDecl()->getDeclName() << RetValExp->getSourceRange();
1811
1812     // Skip over implicit cast expressions when checking for block expressions.
1813     RetValExp = RetValExp->IgnoreParenCasts();
1814
1815     if (BlockExpr *C = dyn_cast<BlockExpr>(RetValExp))
1816       if (C->hasBlockDeclRefExprs())
1817         Diag(C->getLocStart(), diag::err_ret_local_block)
1818           << C->getSourceRange();
1819
1820     if (AddrLabelExpr *ALE = dyn_cast<AddrLabelExpr>(RetValExp))
1821       Diag(ALE->getLocStart(), diag::warn_ret_addr_label)
1822         << ALE->getSourceRange();
1823
1824   } else if (lhsType->isReferenceType()) {
1825     // Perform checking for stack values returned by reference.
1826     // Check for a reference to the stack
1827     if (DeclRefExpr *DR = EvalVal(RetValExp))
1828       Diag(DR->getLocStart(), diag::warn_ret_stack_ref)
1829         << DR->getDecl()->getDeclName() << RetValExp->getSourceRange();
1830   }
1831 }
1832
1833 /// EvalAddr - EvalAddr and EvalVal are mutually recursive functions that
1834 ///  check if the expression in a return statement evaluates to an address
1835 ///  to a location on the stack.  The recursion is used to traverse the
1836 ///  AST of the return expression, with recursion backtracking when we
1837 ///  encounter a subexpression that (1) clearly does not lead to the address
1838 ///  of a stack variable or (2) is something we cannot determine leads to
1839 ///  the address of a stack variable based on such local checking.
1840 ///
1841 ///  EvalAddr processes expressions that are pointers that are used as
1842 ///  references (and not L-values).  EvalVal handles all other values.
1843 ///  At the base case of the recursion is a check for a DeclRefExpr* in
1844 ///  the refers to a stack variable.
1845 ///
1846 ///  This implementation handles:
1847 ///
1848 ///   * pointer-to-pointer casts
1849 ///   * implicit conversions from array references to pointers
1850 ///   * taking the address of fields
1851 ///   * arbitrary interplay between "&" and "*" operators
1852 ///   * pointer arithmetic from an address of a stack variable
1853 ///   * taking the address of an array element where the array is on the stack
1854 static DeclRefExpr* EvalAddr(Expr *E) {
1855   // We should only be called for evaluating pointer expressions.
1856   assert((E->getType()->isAnyPointerType() ||
1857           E->getType()->isBlockPointerType() ||
1858           E->getType()->isObjCQualifiedIdType()) &&
1859          "EvalAddr only works on pointers");
1860
1861   // Our "symbolic interpreter" is just a dispatch off the currently
1862   // viewed AST node.  We then recursively traverse the AST by calling
1863   // EvalAddr and EvalVal appropriately.
1864   switch (E->getStmtClass()) {
1865   case Stmt::ParenExprClass:
1866     // Ignore parentheses.
1867     return EvalAddr(cast<ParenExpr>(E)->getSubExpr());
1868
1869   case Stmt::UnaryOperatorClass: {
1870     // The only unary operator that make sense to handle here
1871     // is AddrOf.  All others don't make sense as pointers.
1872     UnaryOperator *U = cast<UnaryOperator>(E);
1873
1874     if (U->getOpcode() == UO_AddrOf)
1875       return EvalVal(U->getSubExpr());
1876     else
1877       return NULL;
1878   }
1879
1880   case Stmt::BinaryOperatorClass: {
1881     // Handle pointer arithmetic.  All other binary operators are not valid
1882     // in this context.
1883     BinaryOperator *B = cast<BinaryOperator>(E);
1884     BinaryOperatorKind op = B->getOpcode();
1885
1886     if (op != BO_Add && op != BO_Sub)
1887       return NULL;
1888
1889     Expr *Base = B->getLHS();
1890
1891     // Determine which argument is the real pointer base.  It could be
1892     // the RHS argument instead of the LHS.
1893     if (!Base->getType()->isPointerType()) Base = B->getRHS();
1894
1895     assert (Base->getType()->isPointerType());
1896     return EvalAddr(Base);
1897   }
1898
1899   // For conditional operators we need to see if either the LHS or RHS are
1900   // valid DeclRefExpr*s.  If one of them is valid, we return it.
1901   case Stmt::ConditionalOperatorClass: {
1902     ConditionalOperator *C = cast<ConditionalOperator>(E);
1903
1904     // Handle the GNU extension for missing LHS.
1905     if (Expr *lhsExpr = C->getLHS())
1906       if (DeclRefExpr* LHS = EvalAddr(lhsExpr))
1907         return LHS;
1908
1909      return EvalAddr(C->getRHS());
1910   }
1911
1912   // For casts, we need to handle conversions from arrays to
1913   // pointer values, and pointer-to-pointer conversions.
1914   case Stmt::ImplicitCastExprClass:
1915   case Stmt::CStyleCastExprClass:
1916   case Stmt::CXXFunctionalCastExprClass: {
1917     Expr* SubExpr = cast<CastExpr>(E)->getSubExpr();
1918     QualType T = SubExpr->getType();
1919
1920     if (SubExpr->getType()->isPointerType() ||
1921         SubExpr->getType()->isBlockPointerType() ||
1922         SubExpr->getType()->isObjCQualifiedIdType())
1923       return EvalAddr(SubExpr);
1924     else if (T->isArrayType())
1925       return EvalVal(SubExpr);
1926     else
1927       return 0;
1928   }
1929
1930   // C++ casts.  For dynamic casts, static casts, and const casts, we
1931   // are always converting from a pointer-to-pointer, so we just blow
1932   // through the cast.  In the case the dynamic cast doesn't fail (and
1933   // return NULL), we take the conservative route and report cases
1934   // where we return the address of a stack variable.  For Reinterpre
1935   // FIXME: The comment about is wrong; we're not always converting
1936   // from pointer to pointer. I'm guessing that this code should also
1937   // handle references to objects.
1938   case Stmt::CXXStaticCastExprClass:
1939   case Stmt::CXXDynamicCastExprClass:
1940   case Stmt::CXXConstCastExprClass:
1941   case Stmt::CXXReinterpretCastExprClass: {
1942       Expr *S = cast<CXXNamedCastExpr>(E)->getSubExpr();
1943       if (S->getType()->isPointerType() || S->getType()->isBlockPointerType())
1944         return EvalAddr(S);
1945       else
1946         return NULL;
1947   }
1948
1949   // Everything else: we simply don't reason about them.
1950   default:
1951     return NULL;
1952   }
1953 }
1954
1955
1956 ///  EvalVal - This function is complements EvalAddr in the mutual recursion.
1957 ///   See the comments for EvalAddr for more details.
1958 static DeclRefExpr* EvalVal(Expr *E) {
1959 do {
1960   // We should only be called for evaluating non-pointer expressions, or
1961   // expressions with a pointer type that are not used as references but instead
1962   // are l-values (e.g., DeclRefExpr with a pointer type).
1963
1964   // Our "symbolic interpreter" is just a dispatch off the currently
1965   // viewed AST node.  We then recursively traverse the AST by calling
1966   // EvalAddr and EvalVal appropriately.
1967   switch (E->getStmtClass()) {
1968   case Stmt::ImplicitCastExprClass: {
1969     ImplicitCastExpr *IE = cast<ImplicitCastExpr>(E);
1970     if (IE->getValueKind() == VK_LValue) {
1971       E = IE->getSubExpr();
1972       continue;
1973     }
1974     return NULL;
1975   }
1976
1977   case Stmt::DeclRefExprClass: {
1978     // DeclRefExpr: the base case.  When we hit a DeclRefExpr we are looking
1979     //  at code that refers to a variable's name.  We check if it has local
1980     //  storage within the function, and if so, return the expression.
1981     DeclRefExpr *DR = cast<DeclRefExpr>(E);
1982
1983     if (VarDecl *V = dyn_cast<VarDecl>(DR->getDecl()))
1984       if (V->hasLocalStorage() && !V->getType()->isReferenceType()) return DR;
1985
1986     return NULL;
1987   }
1988
1989   case Stmt::ParenExprClass: {
1990     // Ignore parentheses.
1991     E = cast<ParenExpr>(E)->getSubExpr();
1992     continue;
1993   }
1994
1995   case Stmt::UnaryOperatorClass: {
1996     // The only unary operator that make sense to handle here
1997     // is Deref.  All others don't resolve to a "name."  This includes
1998     // handling all sorts of rvalues passed to a unary operator.
1999     UnaryOperator *U = cast<UnaryOperator>(E);
2000
2001     if (U->getOpcode() == UO_Deref)
2002       return EvalAddr(U->getSubExpr());
2003
2004     return NULL;
2005   }
2006
2007   case Stmt::ArraySubscriptExprClass: {
2008     // Array subscripts are potential references to data on the stack.  We
2009     // retrieve the DeclRefExpr* for the array variable if it indeed
2010     // has local storage.
2011     return EvalAddr(cast<ArraySubscriptExpr>(E)->getBase());
2012   }
2013
2014   case Stmt::ConditionalOperatorClass: {
2015     // For conditional operators we need to see if either the LHS or RHS are
2016     // non-NULL DeclRefExpr's.  If one is non-NULL, we return it.
2017     ConditionalOperator *C = cast<ConditionalOperator>(E);
2018
2019     // Handle the GNU extension for missing LHS.
2020     if (Expr *lhsExpr = C->getLHS())
2021       if (DeclRefExpr *LHS = EvalVal(lhsExpr))
2022         return LHS;
2023
2024     return EvalVal(C->getRHS());
2025   }
2026
2027   // Accesses to members are potential references to data on the stack.
2028   case Stmt::MemberExprClass: {
2029     MemberExpr *M = cast<MemberExpr>(E);
2030
2031     // Check for indirect access.  We only want direct field accesses.
2032     if (M->isArrow())
2033       return NULL;
2034
2035     // Check whether the member type is itself a reference, in which case
2036     // we're not going to refer to the member, but to what the member refers to.
2037     if (M->getMemberDecl()->getType()->isReferenceType())
2038       return NULL;
2039
2040     return EvalVal(M->getBase());
2041   }
2042
2043   // Everything else: we simply don't reason about them.
2044   default:
2045     return NULL;
2046   }
2047 } while (true);
2048 }
2049
2050 //===--- CHECK: Floating-Point comparisons (-Wfloat-equal) ---------------===//
2051
2052 /// Check for comparisons of floating point operands using != and ==.
2053 /// Issue a warning if these are no self-comparisons, as they are not likely
2054 /// to do what the programmer intended.
2055 void Sema::CheckFloatComparison(SourceLocation loc, Expr* lex, Expr *rex) {
2056   bool EmitWarning = true;
2057
2058   Expr* LeftExprSansParen = lex->IgnoreParens();
2059   Expr* RightExprSansParen = rex->IgnoreParens();
2060
2061   // Special case: check for x == x (which is OK).
2062   // Do not emit warnings for such cases.
2063   if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(LeftExprSansParen))
2064     if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(RightExprSansParen))
2065       if (DRL->getDecl() == DRR->getDecl())
2066         EmitWarning = false;
2067
2068
2069   // Special case: check for comparisons against literals that can be exactly
2070   //  represented by APFloat.  In such cases, do not emit a warning.  This
2071   //  is a heuristic: often comparison against such literals are used to
2072   //  detect if a value in a variable has not changed.  This clearly can
2073   //  lead to false negatives.
2074   if (EmitWarning) {
2075     if (FloatingLiteral* FLL = dyn_cast<FloatingLiteral>(LeftExprSansParen)) {
2076       if (FLL->isExact())
2077         EmitWarning = false;
2078     } else
2079       if (FloatingLiteral* FLR = dyn_cast<FloatingLiteral>(RightExprSansParen)){
2080         if (FLR->isExact())
2081           EmitWarning = false;
2082     }
2083   }
2084
2085   // Check for comparisons with builtin types.
2086   if (EmitWarning)
2087     if (CallExpr* CL = dyn_cast<CallExpr>(LeftExprSansParen))
2088       if (CL->isBuiltinCall(Context))
2089         EmitWarning = false;
2090
2091   if (EmitWarning)
2092     if (CallExpr* CR = dyn_cast<CallExpr>(RightExprSansParen))
2093       if (CR->isBuiltinCall(Context))
2094         EmitWarning = false;
2095
2096   // Emit the diagnostic.
2097   if (EmitWarning)
2098     Diag(loc, diag::warn_floatingpoint_eq)
2099       << lex->getSourceRange() << rex->getSourceRange();
2100 }
2101
2102 //===--- CHECK: Integer mixed-sign comparisons (-Wsign-compare) --------===//
2103 //===--- CHECK: Lossy implicit conversions (-Wconversion) --------------===//
2104
2105 namespace {
2106
2107 /// Structure recording the 'active' range of an integer-valued
2108 /// expression.
2109 struct IntRange {
2110   /// The number of bits active in the int.
2111   unsigned Width;
2112
2113   /// True if the int is known not to have negative values.
2114   bool NonNegative;
2115
2116   IntRange(unsigned Width, bool NonNegative)
2117     : Width(Width), NonNegative(NonNegative)
2118   {}
2119
2120   // Returns the range of the bool type.
2121   static IntRange forBoolType() {
2122     return IntRange(1, true);
2123   }
2124
2125   // Returns the range of an integral type.
2126   static IntRange forType(ASTContext &C, QualType T) {
2127     return forCanonicalType(C, T->getCanonicalTypeInternal().getTypePtr());
2128   }
2129
2130   // Returns the range of an integeral type based on its canonical
2131   // representation.
2132   static IntRange forCanonicalType(ASTContext &C, const Type *T) {
2133     assert(T->isCanonicalUnqualified());
2134
2135     if (const VectorType *VT = dyn_cast<VectorType>(T))
2136       T = VT->getElementType().getTypePtr();
2137     if (const ComplexType *CT = dyn_cast<ComplexType>(T))
2138       T = CT->getElementType().getTypePtr();
2139
2140     if (const EnumType *ET = dyn_cast<EnumType>(T)) {
2141       EnumDecl *Enum = ET->getDecl();
2142       unsigned NumPositive = Enum->getNumPositiveBits();
2143       unsigned NumNegative = Enum->getNumNegativeBits();
2144
2145       return IntRange(std::max(NumPositive, NumNegative), NumNegative == 0);
2146     }
2147
2148     const BuiltinType *BT = cast<BuiltinType>(T);
2149     assert(BT->isInteger());
2150
2151     return IntRange(C.getIntWidth(QualType(T, 0)), BT->isUnsignedInteger());
2152   }
2153
2154   // Returns the supremum of two ranges: i.e. their conservative merge.
2155   static IntRange join(IntRange L, IntRange R) {
2156     return IntRange(std::max(L.Width, R.Width),
2157                     L.NonNegative && R.NonNegative);
2158   }
2159
2160   // Returns the infinum of two ranges: i.e. their aggressive merge.
2161   static IntRange meet(IntRange L, IntRange R) {
2162     return IntRange(std::min(L.Width, R.Width),
2163                     L.NonNegative || R.NonNegative);
2164   }
2165 };
2166
2167 IntRange GetValueRange(ASTContext &C, llvm::APSInt &value, unsigned MaxWidth) {
2168   if (value.isSigned() && value.isNegative())
2169     return IntRange(value.getMinSignedBits(), false);
2170
2171   if (value.getBitWidth() > MaxWidth)
2172     value.trunc(MaxWidth);
2173
2174   // isNonNegative() just checks the sign bit without considering
2175   // signedness.
2176   return IntRange(value.getActiveBits(), true);
2177 }
2178
2179 IntRange GetValueRange(ASTContext &C, APValue &result, QualType Ty,
2180                        unsigned MaxWidth) {
2181   if (result.isInt())
2182     return GetValueRange(C, result.getInt(), MaxWidth);
2183
2184   if (result.isVector()) {
2185     IntRange R = GetValueRange(C, result.getVectorElt(0), Ty, MaxWidth);
2186     for (unsigned i = 1, e = result.getVectorLength(); i != e; ++i) {
2187       IntRange El = GetValueRange(C, result.getVectorElt(i), Ty, MaxWidth);
2188       R = IntRange::join(R, El);
2189     }
2190     return R;
2191   }
2192
2193   if (result.isComplexInt()) {
2194     IntRange R = GetValueRange(C, result.getComplexIntReal(), MaxWidth);
2195     IntRange I = GetValueRange(C, result.getComplexIntImag(), MaxWidth);
2196     return IntRange::join(R, I);
2197   }
2198
2199   // This can happen with lossless casts to intptr_t of "based" lvalues.
2200   // Assume it might use arbitrary bits.
2201   // FIXME: The only reason we need to pass the type in here is to get
2202   // the sign right on this one case.  It would be nice if APValue
2203   // preserved this.
2204   assert(result.isLValue());
2205   return IntRange(MaxWidth, Ty->isUnsignedIntegerType());
2206 }
2207
2208 /// Pseudo-evaluate the given integer expression, estimating the
2209 /// range of values it might take.
2210 ///
2211 /// \param MaxWidth - the width to which the value will be truncated
2212 IntRange GetExprRange(ASTContext &C, Expr *E, unsigned MaxWidth) {
2213   E = E->IgnoreParens();
2214
2215   // Try a full evaluation first.
2216   Expr::EvalResult result;
2217   if (E->Evaluate(result, C))
2218     return GetValueRange(C, result.Val, E->getType(), MaxWidth);
2219
2220   // I think we only want to look through implicit casts here; if the
2221   // user has an explicit widening cast, we should treat the value as
2222   // being of the new, wider type.
2223   if (ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E)) {
2224     if (CE->getCastKind() == CK_NoOp)
2225       return GetExprRange(C, CE->getSubExpr(), MaxWidth);
2226
2227     IntRange OutputTypeRange = IntRange::forType(C, CE->getType());
2228
2229     bool isIntegerCast = (CE->getCastKind() == CK_IntegralCast);
2230     if (!isIntegerCast && CE->getCastKind() == CK_Unknown)
2231       isIntegerCast = CE->getSubExpr()->getType()->isIntegerType();
2232
2233     // Assume that non-integer casts can span the full range of the type.
2234     if (!isIntegerCast)
2235       return OutputTypeRange;
2236
2237     IntRange SubRange
2238       = GetExprRange(C, CE->getSubExpr(),
2239                      std::min(MaxWidth, OutputTypeRange.Width));
2240
2241     // Bail out if the subexpr's range is as wide as the cast type.
2242     if (SubRange.Width >= OutputTypeRange.Width)
2243       return OutputTypeRange;
2244
2245     // Otherwise, we take the smaller width, and we're non-negative if
2246     // either the output type or the subexpr is.
2247     return IntRange(SubRange.Width,
2248                     SubRange.NonNegative || OutputTypeRange.NonNegative);
2249   }
2250
2251   if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
2252     // If we can fold the condition, just take that operand.
2253     bool CondResult;
2254     if (CO->getCond()->EvaluateAsBooleanCondition(CondResult, C))
2255       return GetExprRange(C, CondResult ? CO->getTrueExpr()
2256                                         : CO->getFalseExpr(),
2257                           MaxWidth);
2258
2259     // Otherwise, conservatively merge.
2260     IntRange L = GetExprRange(C, CO->getTrueExpr(), MaxWidth);
2261     IntRange R = GetExprRange(C, CO->getFalseExpr(), MaxWidth);
2262     return IntRange::join(L, R);
2263   }
2264
2265   if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
2266     switch (BO->getOpcode()) {
2267
2268     // Boolean-valued operations are single-bit and positive.
2269     case BO_LAnd:
2270     case BO_LOr:
2271     case BO_LT:
2272     case BO_GT:
2273     case BO_LE:
2274     case BO_GE:
2275     case BO_EQ:
2276     case BO_NE:
2277       return IntRange::forBoolType();
2278
2279     // The type of these compound assignments is the type of the LHS,
2280     // so the RHS is not necessarily an integer.
2281     case BO_MulAssign:
2282     case BO_DivAssign:
2283     case BO_RemAssign:
2284     case BO_AddAssign:
2285     case BO_SubAssign:
2286       return IntRange::forType(C, E->getType());
2287
2288     // Operations with opaque sources are black-listed.
2289     case BO_PtrMemD:
2290     case BO_PtrMemI:
2291       return IntRange::forType(C, E->getType());
2292
2293     // Bitwise-and uses the *infinum* of the two source ranges.
2294     case BO_And:
2295     case BO_AndAssign:
2296       return IntRange::meet(GetExprRange(C, BO->getLHS(), MaxWidth),
2297                             GetExprRange(C, BO->getRHS(), MaxWidth));
2298
2299     // Left shift gets black-listed based on a judgement call.
2300     case BO_Shl:
2301       // ...except that we want to treat '1 << (blah)' as logically
2302       // positive.  It's an important idiom.
2303       if (IntegerLiteral *I
2304             = dyn_cast<IntegerLiteral>(BO->getLHS()->IgnoreParenCasts())) {
2305         if (I->getValue() == 1) {
2306           IntRange R = IntRange::forType(C, E->getType());
2307           return IntRange(R.Width, /*NonNegative*/ true);
2308         }
2309       }
2310       // fallthrough
2311
2312     case BO_ShlAssign:
2313       return IntRange::forType(C, E->getType());
2314
2315     // Right shift by a constant can narrow its left argument.
2316     case BO_Shr:
2317     case BO_ShrAssign: {
2318       IntRange L = GetExprRange(C, BO->getLHS(), MaxWidth);
2319
2320       // If the shift amount is a positive constant, drop the width by
2321       // that much.
2322       llvm::APSInt shift;
2323       if (BO->getRHS()->isIntegerConstantExpr(shift, C) &&
2324           shift.isNonNegative()) {
2325         unsigned zext = shift.getZExtValue();
2326         if (zext >= L.Width)
2327           L.Width = (L.NonNegative ? 0 : 1);
2328         else
2329           L.Width -= zext;
2330       }
2331
2332       return L;
2333     }
2334
2335     // Comma acts as its right operand.
2336     case BO_Comma:
2337       return GetExprRange(C, BO->getRHS(), MaxWidth);
2338
2339     // Black-list pointer subtractions.
2340     case BO_Sub:
2341       if (BO->getLHS()->getType()->isPointerType())
2342         return IntRange::forType(C, E->getType());
2343       // fallthrough
2344
2345     default:
2346       break;
2347     }
2348
2349     // Treat every other operator as if it were closed on the
2350     // narrowest type that encompasses both operands.
2351     IntRange L = GetExprRange(C, BO->getLHS(), MaxWidth);
2352     IntRange R = GetExprRange(C, BO->getRHS(), MaxWidth);
2353     return IntRange::join(L, R);
2354   }
2355
2356   if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
2357     switch (UO->getOpcode()) {
2358     // Boolean-valued operations are white-listed.
2359     case UO_LNot:
2360       return IntRange::forBoolType();
2361
2362     // Operations with opaque sources are black-listed.
2363     case UO_Deref:
2364     case UO_AddrOf: // should be impossible
2365       return IntRange::forType(C, E->getType());
2366
2367     default:
2368       return GetExprRange(C, UO->getSubExpr(), MaxWidth);
2369     }
2370   }
2371
2372   if (dyn_cast<OffsetOfExpr>(E)) {
2373     IntRange::forType(C, E->getType());
2374   }
2375
2376   FieldDecl *BitField = E->getBitField();
2377   if (BitField) {
2378     llvm::APSInt BitWidthAP = BitField->getBitWidth()->EvaluateAsInt(C);
2379     unsigned BitWidth = BitWidthAP.getZExtValue();
2380
2381     return IntRange(BitWidth, BitField->getType()->isUnsignedIntegerType());
2382   }
2383
2384   return IntRange::forType(C, E->getType());
2385 }
2386
2387 IntRange GetExprRange(ASTContext &C, Expr *E) {
2388   return GetExprRange(C, E, C.getIntWidth(E->getType()));
2389 }
2390
2391 /// Checks whether the given value, which currently has the given
2392 /// source semantics, has the same value when coerced through the
2393 /// target semantics.
2394 bool IsSameFloatAfterCast(const llvm::APFloat &value,
2395                           const llvm::fltSemantics &Src,
2396                           const llvm::fltSemantics &Tgt) {
2397   llvm::APFloat truncated = value;
2398
2399   bool ignored;
2400   truncated.convert(Src, llvm::APFloat::rmNearestTiesToEven, &ignored);
2401   truncated.convert(Tgt, llvm::APFloat::rmNearestTiesToEven, &ignored);
2402
2403   return truncated.bitwiseIsEqual(value);
2404 }
2405
2406 /// Checks whether the given value, which currently has the given
2407 /// source semantics, has the same value when coerced through the
2408 /// target semantics.
2409 ///
2410 /// The value might be a vector of floats (or a complex number).
2411 bool IsSameFloatAfterCast(const APValue &value,
2412                           const llvm::fltSemantics &Src,
2413                           const llvm::fltSemantics &Tgt) {
2414   if (value.isFloat())
2415     return IsSameFloatAfterCast(value.getFloat(), Src, Tgt);
2416
2417   if (value.isVector()) {
2418     for (unsigned i = 0, e = value.getVectorLength(); i != e; ++i)
2419       if (!IsSameFloatAfterCast(value.getVectorElt(i), Src, Tgt))
2420         return false;
2421     return true;
2422   }
2423
2424   assert(value.isComplexFloat());
2425   return (IsSameFloatAfterCast(value.getComplexFloatReal(), Src, Tgt) &&
2426           IsSameFloatAfterCast(value.getComplexFloatImag(), Src, Tgt));
2427 }
2428
2429 void AnalyzeImplicitConversions(Sema &S, Expr *E);
2430
2431 bool IsZero(Sema &S, Expr *E) {
2432   llvm::APSInt Value;
2433   return E->isIntegerConstantExpr(Value, S.Context) && Value == 0;
2434 }
2435
2436 void CheckTrivialUnsignedComparison(Sema &S, BinaryOperator *E) {
2437   BinaryOperatorKind op = E->getOpcode();
2438   if (op == BO_LT && IsZero(S, E->getRHS())) {
2439     S.Diag(E->getOperatorLoc(), diag::warn_lunsigned_always_true_comparison)
2440       << "< 0" << "false"
2441       << E->getLHS()->getSourceRange() << E->getRHS()->getSourceRange();
2442   } else if (op == BO_GE && IsZero(S, E->getRHS())) {
2443     S.Diag(E->getOperatorLoc(), diag::warn_lunsigned_always_true_comparison)
2444       << ">= 0" << "true"
2445       << E->getLHS()->getSourceRange() << E->getRHS()->getSourceRange();
2446   } else if (op == BO_GT && IsZero(S, E->getLHS())) {
2447     S.Diag(E->getOperatorLoc(), diag::warn_runsigned_always_true_comparison)
2448       << "0 >" << "false"
2449       << E->getLHS()->getSourceRange() << E->getRHS()->getSourceRange();
2450   } else if (op == BO_LE && IsZero(S, E->getLHS())) {
2451     S.Diag(E->getOperatorLoc(), diag::warn_runsigned_always_true_comparison)
2452       << "0 <=" << "true"
2453       << E->getLHS()->getSourceRange() << E->getRHS()->getSourceRange();
2454   }
2455 }
2456
2457 /// Analyze the operands of the given comparison.  Implements the
2458 /// fallback case from AnalyzeComparison.
2459 void AnalyzeImpConvsInComparison(Sema &S, BinaryOperator *E) {
2460   AnalyzeImplicitConversions(S, E->getLHS());
2461   AnalyzeImplicitConversions(S, E->getRHS());
2462 }
2463
2464 /// \brief Implements -Wsign-compare.
2465 ///
2466 /// \param lex the left-hand expression
2467 /// \param rex the right-hand expression
2468 /// \param OpLoc the location of the joining operator
2469 /// \param BinOpc binary opcode or 0
2470 void AnalyzeComparison(Sema &S, BinaryOperator *E) {
2471   // The type the comparison is being performed in.
2472   QualType T = E->getLHS()->getType();
2473   assert(S.Context.hasSameUnqualifiedType(T, E->getRHS()->getType())
2474          && "comparison with mismatched types");
2475
2476   // We don't do anything special if this isn't an unsigned integral
2477   // comparison:  we're only interested in integral comparisons, and
2478   // signed comparisons only happen in cases we don't care to warn about.
2479   if (!T->hasUnsignedIntegerRepresentation())
2480     return AnalyzeImpConvsInComparison(S, E);
2481
2482   Expr *lex = E->getLHS()->IgnoreParenImpCasts();
2483   Expr *rex = E->getRHS()->IgnoreParenImpCasts();
2484
2485   // Check to see if one of the (unmodified) operands is of different
2486   // signedness.
2487   Expr *signedOperand, *unsignedOperand;
2488   if (lex->getType()->hasSignedIntegerRepresentation()) {
2489     assert(!rex->getType()->hasSignedIntegerRepresentation() &&
2490            "unsigned comparison between two signed integer expressions?");
2491     signedOperand = lex;
2492     unsignedOperand = rex;
2493   } else if (rex->getType()->hasSignedIntegerRepresentation()) {
2494     signedOperand = rex;
2495     unsignedOperand = lex;
2496   } else {
2497     CheckTrivialUnsignedComparison(S, E);
2498     return AnalyzeImpConvsInComparison(S, E);
2499   }
2500
2501   // Otherwise, calculate the effective range of the signed operand.
2502   IntRange signedRange = GetExprRange(S.Context, signedOperand);
2503
2504   // Go ahead and analyze implicit conversions in the operands.  Note
2505   // that we skip the implicit conversions on both sides.
2506   AnalyzeImplicitConversions(S, lex);
2507   AnalyzeImplicitConversions(S, rex);
2508
2509   // If the signed range is non-negative, -Wsign-compare won't fire,
2510   // but we should still check for comparisons which are always true
2511   // or false.
2512   if (signedRange.NonNegative)
2513     return CheckTrivialUnsignedComparison(S, E);
2514
2515   // For (in)equality comparisons, if the unsigned operand is a
2516   // constant which cannot collide with a overflowed signed operand,
2517   // then reinterpreting the signed operand as unsigned will not
2518   // change the result of the comparison.
2519   if (E->isEqualityOp()) {
2520     unsigned comparisonWidth = S.Context.getIntWidth(T);
2521     IntRange unsignedRange = GetExprRange(S.Context, unsignedOperand);
2522
2523     // We should never be unable to prove that the unsigned operand is
2524     // non-negative.
2525     assert(unsignedRange.NonNegative && "unsigned range includes negative?");
2526
2527     if (unsignedRange.Width < comparisonWidth)
2528       return;
2529   }
2530
2531   S.Diag(E->getOperatorLoc(), diag::warn_mixed_sign_comparison)
2532     << lex->getType() << rex->getType()
2533     << lex->getSourceRange() << rex->getSourceRange();
2534 }
2535
2536 /// Diagnose an implicit cast;  purely a helper for CheckImplicitConversion.
2537 void DiagnoseImpCast(Sema &S, Expr *E, QualType T, unsigned diag) {
2538   S.Diag(E->getExprLoc(), diag) << E->getType() << T << E->getSourceRange();
2539 }
2540
2541 void CheckImplicitConversion(Sema &S, Expr *E, QualType T,
2542                              bool *ICContext = 0) {
2543   if (E->isTypeDependent() || E->isValueDependent()) return;
2544
2545   const Type *Source = S.Context.getCanonicalType(E->getType()).getTypePtr();
2546   const Type *Target = S.Context.getCanonicalType(T).getTypePtr();
2547   if (Source == Target) return;
2548   if (Target->isDependentType()) return;
2549
2550   // Never diagnose implicit casts to bool.
2551   if (Target->isSpecificBuiltinType(BuiltinType::Bool))
2552     return;
2553
2554   // Strip vector types.
2555   if (isa<VectorType>(Source)) {
2556     if (!isa<VectorType>(Target))
2557       return DiagnoseImpCast(S, E, T, diag::warn_impcast_vector_scalar);
2558
2559     Source = cast<VectorType>(Source)->getElementType().getTypePtr();
2560     Target = cast<VectorType>(Target)->getElementType().getTypePtr();
2561   }
2562
2563   // Strip complex types.
2564   if (isa<ComplexType>(Source)) {
2565     if (!isa<ComplexType>(Target))
2566       return DiagnoseImpCast(S, E, T, diag::warn_impcast_complex_scalar);
2567
2568     Source = cast<ComplexType>(Source)->getElementType().getTypePtr();
2569     Target = cast<ComplexType>(Target)->getElementType().getTypePtr();
2570   }
2571
2572   const BuiltinType *SourceBT = dyn_cast<BuiltinType>(Source);
2573   const BuiltinType *TargetBT = dyn_cast<BuiltinType>(Target);
2574
2575   // If the source is floating point...
2576   if (SourceBT && SourceBT->isFloatingPoint()) {
2577     // ...and the target is floating point...
2578     if (TargetBT && TargetBT->isFloatingPoint()) {
2579       // ...then warn if we're dropping FP rank.
2580
2581       // Builtin FP kinds are ordered by increasing FP rank.
2582       if (SourceBT->getKind() > TargetBT->getKind()) {
2583         // Don't warn about float constants that are precisely
2584         // representable in the target type.
2585         Expr::EvalResult result;
2586         if (E->Evaluate(result, S.Context)) {
2587           // Value might be a float, a float vector, or a float complex.
2588           if (IsSameFloatAfterCast(result.Val,
2589                    S.Context.getFloatTypeSemantics(QualType(TargetBT, 0)),
2590                    S.Context.getFloatTypeSemantics(QualType(SourceBT, 0))))
2591             return;
2592         }
2593
2594         DiagnoseImpCast(S, E, T, diag::warn_impcast_float_precision);
2595       }
2596       return;
2597     }
2598
2599     // If the target is integral, always warn.
2600     if ((TargetBT && TargetBT->isInteger()))
2601       // TODO: don't warn for integer values?
2602       DiagnoseImpCast(S, E, T, diag::warn_impcast_float_integer);
2603
2604     return;
2605   }
2606
2607   if (!Source->isIntegerType() || !Target->isIntegerType())
2608     return;
2609
2610   IntRange SourceRange = GetExprRange(S.Context, E);
2611   IntRange TargetRange = IntRange::forCanonicalType(S.Context, Target);
2612
2613   if (SourceRange.Width > TargetRange.Width) {
2614     // People want to build with -Wshorten-64-to-32 and not -Wconversion
2615     // and by god we'll let them.
2616     if (SourceRange.Width == 64 && TargetRange.Width == 32)
2617       return DiagnoseImpCast(S, E, T, diag::warn_impcast_integer_64_32);
2618     return DiagnoseImpCast(S, E, T, diag::warn_impcast_integer_precision);
2619   }
2620
2621   if ((TargetRange.NonNegative && !SourceRange.NonNegative) ||
2622       (!TargetRange.NonNegative && SourceRange.NonNegative &&
2623        SourceRange.Width == TargetRange.Width)) {
2624     unsigned DiagID = diag::warn_impcast_integer_sign;
2625
2626     // Traditionally, gcc has warned about this under -Wsign-compare.
2627     // We also want to warn about it in -Wconversion.
2628     // So if -Wconversion is off, use a completely identical diagnostic
2629     // in the sign-compare group.
2630     // The conditional-checking code will
2631     if (ICContext) {
2632       DiagID = diag::warn_impcast_integer_sign_conditional;
2633       *ICContext = true;
2634     }
2635
2636     return DiagnoseImpCast(S, E, T, DiagID);
2637   }
2638
2639   return;
2640 }
2641
2642 void CheckConditionalOperator(Sema &S, ConditionalOperator *E, QualType T);
2643
2644 void CheckConditionalOperand(Sema &S, Expr *E, QualType T,
2645                              bool &ICContext) {
2646   E = E->IgnoreParenImpCasts();
2647
2648   if (isa<ConditionalOperator>(E))
2649     return CheckConditionalOperator(S, cast<ConditionalOperator>(E), T);
2650
2651   AnalyzeImplicitConversions(S, E);
2652   if (E->getType() != T)
2653     return CheckImplicitConversion(S, E, T, &ICContext);
2654   return;
2655 }
2656
2657 void CheckConditionalOperator(Sema &S, ConditionalOperator *E, QualType T) {
2658   AnalyzeImplicitConversions(S, E->getCond());
2659
2660   bool Suspicious = false;
2661   CheckConditionalOperand(S, E->getTrueExpr(), T, Suspicious);
2662   CheckConditionalOperand(S, E->getFalseExpr(), T, Suspicious);
2663
2664   // If -Wconversion would have warned about either of the candidates
2665   // for a signedness conversion to the context type...
2666   if (!Suspicious) return;
2667
2668   // ...but it's currently ignored...
2669   if (S.Diags.getDiagnosticLevel(diag::warn_impcast_integer_sign_conditional))
2670     return;
2671
2672   // ...and -Wsign-compare isn't...
2673   if (!S.Diags.getDiagnosticLevel(diag::warn_mixed_sign_conditional))
2674     return;
2675
2676   // ...then check whether it would have warned about either of the
2677   // candidates for a signedness conversion to the condition type.
2678   if (E->getType() != T) {
2679     Suspicious = false;
2680     CheckImplicitConversion(S, E->getTrueExpr()->IgnoreParenImpCasts(),
2681                             E->getType(), &Suspicious);
2682     if (!Suspicious)
2683       CheckImplicitConversion(S, E->getFalseExpr()->IgnoreParenImpCasts(),
2684                               E->getType(), &Suspicious);
2685     if (!Suspicious)
2686       return;
2687   }
2688
2689   // If so, emit a diagnostic under -Wsign-compare.
2690   Expr *lex = E->getTrueExpr()->IgnoreParenImpCasts();
2691   Expr *rex = E->getFalseExpr()->IgnoreParenImpCasts();
2692   S.Diag(E->getQuestionLoc(), diag::warn_mixed_sign_conditional)
2693     << lex->getType() << rex->getType()
2694     << lex->getSourceRange() << rex->getSourceRange();
2695 }
2696
2697 /// AnalyzeImplicitConversions - Find and report any interesting
2698 /// implicit conversions in the given expression.  There are a couple
2699 /// of competing diagnostics here, -Wconversion and -Wsign-compare.
2700 void AnalyzeImplicitConversions(Sema &S, Expr *OrigE) {
2701   QualType T = OrigE->getType();
2702   Expr *E = OrigE->IgnoreParenImpCasts();
2703
2704   // For conditional operators, we analyze the arguments as if they
2705   // were being fed directly into the output.
2706   if (isa<ConditionalOperator>(E)) {
2707     ConditionalOperator *CO = cast<ConditionalOperator>(E);
2708     CheckConditionalOperator(S, CO, T);
2709     return;
2710   }
2711
2712   // Go ahead and check any implicit conversions we might have skipped.
2713   // The non-canonical typecheck is just an optimization;
2714   // CheckImplicitConversion will filter out dead implicit conversions.
2715   if (E->getType() != T)
2716     CheckImplicitConversion(S, E, T);
2717
2718   // Now continue drilling into this expression.
2719
2720   // Skip past explicit casts.
2721   if (isa<ExplicitCastExpr>(E)) {
2722     E = cast<ExplicitCastExpr>(E)->getSubExpr()->IgnoreParenImpCasts();
2723     return AnalyzeImplicitConversions(S, E);
2724   }
2725
2726   // Do a somewhat different check with comparison operators.
2727   if (isa<BinaryOperator>(E) && cast<BinaryOperator>(E)->isComparisonOp())
2728     return AnalyzeComparison(S, cast<BinaryOperator>(E));
2729
2730   // These break the otherwise-useful invariant below.  Fortunately,
2731   // we don't really need to recurse into them, because any internal
2732   // expressions should have been analyzed already when they were
2733   // built into statements.
2734   if (isa<StmtExpr>(E)) return;
2735
2736   // Don't descend into unevaluated contexts.
2737   if (isa<SizeOfAlignOfExpr>(E)) return;
2738
2739   // Now just recurse over the expression's children.
2740   for (Stmt::child_iterator I = E->child_begin(), IE = E->child_end();
2741          I != IE; ++I)
2742     AnalyzeImplicitConversions(S, cast<Expr>(*I));
2743 }
2744
2745 } // end anonymous namespace
2746
2747 /// Diagnoses "dangerous" implicit conversions within the given
2748 /// expression (which is a full expression).  Implements -Wconversion
2749 /// and -Wsign-compare.
2750 void Sema::CheckImplicitConversions(Expr *E) {
2751   // Don't diagnose in unevaluated contexts.
2752   if (ExprEvalContexts.back().Context == Sema::Unevaluated)
2753     return;
2754
2755   // Don't diagnose for value- or type-dependent expressions.
2756   if (E->isTypeDependent() || E->isValueDependent())
2757     return;
2758
2759   AnalyzeImplicitConversions(*this, E);
2760 }
2761
2762 /// CheckParmsForFunctionDef - Check that the parameters of the given
2763 /// function are appropriate for the definition of a function. This
2764 /// takes care of any checks that cannot be performed on the
2765 /// declaration itself, e.g., that the types of each of the function
2766 /// parameters are complete.
2767 bool Sema::CheckParmsForFunctionDef(FunctionDecl *FD) {
2768   bool HasInvalidParm = false;
2769   for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) {
2770     ParmVarDecl *Param = FD->getParamDecl(p);
2771
2772     // C99 6.7.5.3p4: the parameters in a parameter type list in a
2773     // function declarator that is part of a function definition of
2774     // that function shall not have incomplete type.
2775     //
2776     // This is also C++ [dcl.fct]p6.
2777     if (!Param->isInvalidDecl() &&
2778         RequireCompleteType(Param->getLocation(), Param->getType(),
2779                                diag::err_typecheck_decl_incomplete_type)) {
2780       Param->setInvalidDecl();
2781       HasInvalidParm = true;
2782     }
2783
2784     // C99 6.9.1p5: If the declarator includes a parameter type list, the
2785     // declaration of each parameter shall include an identifier.
2786     if (Param->getIdentifier() == 0 &&
2787         !Param->isImplicit() &&
2788         !getLangOptions().CPlusPlus)
2789       Diag(Param->getLocation(), diag::err_parameter_name_omitted);
2790
2791     // C99 6.7.5.3p12:
2792     //   If the function declarator is not part of a definition of that
2793     //   function, parameters may have incomplete type and may use the [*]
2794     //   notation in their sequences of declarator specifiers to specify
2795     //   variable length array types.
2796     QualType PType = Param->getOriginalType();
2797     if (const ArrayType *AT = Context.getAsArrayType(PType)) {
2798       if (AT->getSizeModifier() == ArrayType::Star) {
2799         // FIXME: This diagnosic should point the the '[*]' if source-location
2800         // information is added for it.
2801         Diag(Param->getLocation(), diag::err_array_star_in_function_definition);
2802       }
2803     }
2804   }
2805
2806   return HasInvalidParm;
2807 }
2808
2809 /// CheckCastAlign - Implements -Wcast-align, which warns when a
2810 /// pointer cast increases the alignment requirements.
2811 void Sema::CheckCastAlign(Expr *Op, QualType T, SourceRange TRange) {
2812   // This is actually a lot of work to potentially be doing on every
2813   // cast; don't do it if we're ignoring -Wcast_align (as is the default).
2814   if (getDiagnostics().getDiagnosticLevel(diag::warn_cast_align)
2815         == Diagnostic::Ignored)
2816     return;
2817
2818   // Ignore dependent types.
2819   if (T->isDependentType() || Op->getType()->isDependentType())
2820     return;
2821
2822   // Require that the destination be a pointer type.
2823   const PointerType *DestPtr = T->getAs<PointerType>();
2824   if (!DestPtr) return;
2825
2826   // If the destination has alignment 1, we're done.
2827   QualType DestPointee = DestPtr->getPointeeType();
2828   if (DestPointee->isIncompleteType()) return;
2829   CharUnits DestAlign = Context.getTypeAlignInChars(DestPointee);
2830   if (DestAlign.isOne()) return;
2831
2832   // Require that the source be a pointer type.
2833   const PointerType *SrcPtr = Op->getType()->getAs<PointerType>();
2834   if (!SrcPtr) return;
2835   QualType SrcPointee = SrcPtr->getPointeeType();
2836
2837   // Whitelist casts from cv void*.  We already implicitly
2838   // whitelisted casts to cv void*, since they have alignment 1.
2839   // Also whitelist casts involving incomplete types, which implicitly
2840   // includes 'void'.
2841   if (SrcPointee->isIncompleteType()) return;
2842
2843   CharUnits SrcAlign = Context.getTypeAlignInChars(SrcPointee);
2844   if (SrcAlign >= DestAlign) return;
2845
2846   Diag(TRange.getBegin(), diag::warn_cast_align)
2847     << Op->getType() << T
2848     << static_cast<unsigned>(SrcAlign.getQuantity())
2849     << static_cast<unsigned>(DestAlign.getQuantity())
2850     << TRange << Op->getSourceRange();
2851 }
2852