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 "Sema.h"
  16 #include "clang/AST/ASTContext.h"
  17 #include "clang/AST/DeclObjC.h"
  18 #include "clang/AST/ExprCXX.h"
  19 #include "clang/AST/ExprObjC.h"
  20 #include "clang/Lex/LiteralSupport.h"
  21 #include "clang/Lex/Preprocessor.h"
  22 #include <limits>
  23 using namespace clang;
  24
  25 /// getLocationOfStringLiteralByte - Return a source location that points to the
  26 /// specified byte of the specified string literal.
  27 ///
  28 /// Strings are amazingly complex.  They can be formed from multiple tokens and
  29 /// can have escape sequences in them in addition to the usual trigraph and
  30 /// escaped newline business.  This routine handles this complexity.
  31 ///
  32 SourceLocation Sema::getLocationOfStringLiteralByte(const StringLiteral *SL,
  33                                                     unsigned ByteNo) const {
  34   assert(!SL->isWide() && "This doesn't work for wide strings yet");
  35
  36   // Loop over all of the tokens in this string until we find the one that
  37   // contains the byte we're looking for.
  38   unsigned TokNo = 0;
  39   while (1) {
  40     assert(TokNo < SL->getNumConcatenated() && "Invalid byte number!");
  41     SourceLocation StrTokLoc = SL->getStrTokenLoc(TokNo);
  42
  43     // Get the spelling of the string so that we can get the data that makes up
  44     // the string literal, not the identifier for the macro it is potentially
  45     // expanded through.
  46     SourceLocation StrTokSpellingLoc = SourceMgr.getSpellingLoc(StrTokLoc);
  47
  48     // Re-lex the token to get its length and original spelling.
  49     std::pair<FileID, unsigned> LocInfo =
  50       SourceMgr.getDecomposedLoc(StrTokSpellingLoc);
  51     std::pair<const char *,const char *> Buffer =
  52       SourceMgr.getBufferData(LocInfo.first);
  53     const char *StrData = Buffer.first+LocInfo.second;
  54
  55     // Create a langops struct and enable trigraphs.  This is sufficient for
  56     // relexing tokens.
  57     LangOptions LangOpts;
  58     LangOpts.Trigraphs = true;
  59
  60     // Create a lexer starting at the beginning of this token.
  61     Lexer TheLexer(StrTokSpellingLoc, LangOpts, Buffer.first, StrData,
  62                    Buffer.second);
  63     Token TheTok;
  64     TheLexer.LexFromRawLexer(TheTok);
  65
  66     // Use the StringLiteralParser to compute the length of the string in bytes.
  67     StringLiteralParser SLP(&TheTok, 1, PP);
  68     unsigned TokNumBytes = SLP.GetStringLength();
  69
  70     // If the byte is in this token, return the location of the byte.
  71     if (ByteNo < TokNumBytes ||
  72         (ByteNo == TokNumBytes && TokNo == SL->getNumConcatenated())) {
  73       unsigned Offset =
  74         StringLiteralParser::getOffsetOfStringByte(TheTok, ByteNo, PP);
  75
  76       // Now that we know the offset of the token in the spelling, use the
  77       // preprocessor to get the offset in the original source.
  78       return PP.AdvanceToTokenCharacter(StrTokLoc, Offset);
  79     }
  80
  81     // Move to the next string token.
  82     ++TokNo;
  83     ByteNo -= TokNumBytes;
  84   }
  85 }
  86
  87 /// CheckablePrintfAttr - does a function call have a "printf" attribute
  88 /// and arguments that merit checking?
  89 bool Sema::CheckablePrintfAttr(const FormatAttr *Format, CallExpr *TheCall) {
  90   if (Format->getType() == "printf") return true;
  91   if (Format->getType() == "printf0") {
  92     // printf0 allows null "format" string; if so don't check format/args
  93     unsigned format_idx = Format->getFormatIdx() - 1;
  94     // Does the index refer to the implicit object argument?
  95     if (isa<CXXMemberCallExpr>(TheCall)) {
  96       if (format_idx == 0)
  97         return false;
  98       --format_idx;
  99     }
 100     if (format_idx < TheCall->getNumArgs()) {
 101       Expr *Format = TheCall->getArg(format_idx)->IgnoreParenCasts();
 102       if (!Format->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull))
 103         return true;
 104     }
 105   }
 106   return false;
 107 }
 108
 109 Action::OwningExprResult
 110 Sema::CheckBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
 111   OwningExprResult TheCallResult(Owned(TheCall));
 112
 113   switch (BuiltinID) {
 114   case Builtin::BI__builtin___CFStringMakeConstantString:
 115     assert(TheCall->getNumArgs() == 1 &&
 116            "Wrong # arguments to builtin CFStringMakeConstantString");
 117     if (CheckObjCString(TheCall->getArg(0)))
 118       return ExprError();
 119     break;
 120   case Builtin::BI__builtin_stdarg_start:
 121   case Builtin::BI__builtin_va_start:
 122     if (SemaBuiltinVAStart(TheCall))
 123       return ExprError();
 124     break;
 125   case Builtin::BI__builtin_isgreater:
 126   case Builtin::BI__builtin_isgreaterequal:
 127   case Builtin::BI__builtin_isless:
 128   case Builtin::BI__builtin_islessequal:
 129   case Builtin::BI__builtin_islessgreater:
 130   case Builtin::BI__builtin_isunordered:
 131     if (SemaBuiltinUnorderedCompare(TheCall))
 132       return ExprError();
 133     break;
 134   case Builtin::BI__builtin_isfinite:
 135   case Builtin::BI__builtin_isinf:
 136   case Builtin::BI__builtin_isinf_sign:
 137   case Builtin::BI__builtin_isnan:
 138   case Builtin::BI__builtin_isnormal:
 139     if (SemaBuiltinUnaryFP(TheCall))
 140       return ExprError();
 141     break;
 142   case Builtin::BI__builtin_return_address:
 143   case Builtin::BI__builtin_frame_address:
 144     if (SemaBuiltinStackAddress(TheCall))
 145       return ExprError();
 146     break;
 147   case Builtin::BI__builtin_eh_return_data_regno:
 148     if (SemaBuiltinEHReturnDataRegNo(TheCall))
 149       return ExprError();
 150     break;
 151   case Builtin::BI__builtin_shufflevector:
 152     return SemaBuiltinShuffleVector(TheCall);
 153     // TheCall will be freed by the smart pointer here, but that's fine, since
 154     // SemaBuiltinShuffleVector guts it, but then doesn't release it.
 155   case Builtin::BI__builtin_prefetch:
 156     if (SemaBuiltinPrefetch(TheCall))
 157       return ExprError();
 158     break;
 159   case Builtin::BI__builtin_object_size:
 160     if (SemaBuiltinObjectSize(TheCall))
 161       return ExprError();
 162     break;
 163   case Builtin::BI__builtin_longjmp:
 164     if (SemaBuiltinLongjmp(TheCall))
 165       return ExprError();
 166     break;
 167   case Builtin::BI__sync_fetch_and_add:
 168   case Builtin::BI__sync_fetch_and_sub:
 169   case Builtin::BI__sync_fetch_and_or:
 170   case Builtin::BI__sync_fetch_and_and:
 171   case Builtin::BI__sync_fetch_and_xor:
 172   case Builtin::BI__sync_fetch_and_nand:
 173   case Builtin::BI__sync_add_and_fetch:
 174   case Builtin::BI__sync_sub_and_fetch:
 175   case Builtin::BI__sync_and_and_fetch:
 176   case Builtin::BI__sync_or_and_fetch:
 177   case Builtin::BI__sync_xor_and_fetch:
 178   case Builtin::BI__sync_nand_and_fetch:
 179   case Builtin::BI__sync_val_compare_and_swap:
 180   case Builtin::BI__sync_bool_compare_and_swap:
 181   case Builtin::BI__sync_lock_test_and_set:
 182   case Builtin::BI__sync_lock_release:
 183     if (SemaBuiltinAtomicOverloaded(TheCall))
 184       return ExprError();
 185     break;
 186   }
 187
 188   return move(TheCallResult);
 189 }
 190
 191 /// CheckFunctionCall - Check a direct function call for various correctness
 192 /// and safety properties not strictly enforced by the C type system.
 193 bool Sema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall) {
 194   // Get the IdentifierInfo* for the called function.
 195   IdentifierInfo *FnInfo = FDecl->getIdentifier();
 196
 197   // None of the checks below are needed for functions that don't have
 198   // simple names (e.g., C++ conversion functions).
 199   if (!FnInfo)
 200     return false;
 201
 202   // FIXME: This mechanism should be abstracted to be less fragile and
 203   // more efficient. For example, just map function ids to custom
 204   // handlers.
 205
 206   // Printf checking.
 207   if (const FormatAttr *Format = FDecl->getAttr<FormatAttr>()) {
 208     if (CheckablePrintfAttr(Format, TheCall)) {
 209       bool HasVAListArg = Format->getFirstArg() == 0;
 210       if (!HasVAListArg) {
 211         if (const FunctionProtoType *Proto
 212             = FDecl->getType()->getAs<FunctionProtoType>())
 213           HasVAListArg = !Proto->isVariadic();
 214       }
 215       CheckPrintfArguments(TheCall, HasVAListArg, Format->getFormatIdx() - 1,
 216                            HasVAListArg ? 0 : Format->getFirstArg() - 1);
 217     }
 218   }
 219
 220   for (const NonNullAttr *NonNull = FDecl->getAttr<NonNullAttr>(); NonNull;
 221        NonNull = NonNull->getNext<NonNullAttr>())
 222     CheckNonNullArguments(NonNull, TheCall);
 223
 224   return false;
 225 }
 226
 227 bool Sema::CheckBlockCall(NamedDecl *NDecl, CallExpr *TheCall) {
 228   // Printf checking.
 229   const FormatAttr *Format = NDecl->getAttr<FormatAttr>();
 230   if (!Format)
 231     return false;
 232
 233   const VarDecl *V = dyn_cast<VarDecl>(NDecl);
 234   if (!V)
 235     return false;
 236
 237   QualType Ty = V->getType();
 238   if (!Ty->isBlockPointerType())
 239     return false;
 240
 241   if (!CheckablePrintfAttr(Format, TheCall))
 242     return false;
 243
 244   bool HasVAListArg = Format->getFirstArg() == 0;
 245   if (!HasVAListArg) {
 246     const FunctionType *FT =
 247       Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>();
 248     if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FT))
 249       HasVAListArg = !Proto->isVariadic();
 250   }
 251   CheckPrintfArguments(TheCall, HasVAListArg, Format->getFormatIdx() - 1,
 252                        HasVAListArg ? 0 : Format->getFirstArg() - 1);
 253
 254   return false;
 255 }
 256
 257 /// SemaBuiltinAtomicOverloaded - We have a call to a function like
 258 /// __sync_fetch_and_add, which is an overloaded function based on the pointer
 259 /// type of its first argument.  The main ActOnCallExpr routines have already
 260 /// promoted the types of arguments because all of these calls are prototyped as
 261 /// void(...).
 262 ///
 263 /// This function goes through and does final semantic checking for these
 264 /// builtins,
 265 bool Sema::SemaBuiltinAtomicOverloaded(CallExpr *TheCall) {
 266   DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
 267   FunctionDecl *FDecl = cast<FunctionDecl>(DRE->getDecl());
 268
 269   // Ensure that we have at least one argument to do type inference from.
 270   if (TheCall->getNumArgs() < 1)
 271     return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args)
 272               << 0 << TheCall->getCallee()->getSourceRange();
 273
 274   // Inspect the first argument of the atomic builtin.  This should always be
 275   // a pointer type, whose element is an integral scalar or pointer type.
 276   // Because it is a pointer type, we don't have to worry about any implicit
 277   // casts here.
 278   Expr *FirstArg = TheCall->getArg(0);
 279   if (!FirstArg->getType()->isPointerType())
 280     return Diag(DRE->getLocStart(), diag::err_atomic_builtin_must_be_pointer)
 281              << FirstArg->getType() << FirstArg->getSourceRange();
 282
 283   QualType ValType = FirstArg->getType()->getAs<PointerType>()->getPointeeType();
 284   if (!ValType->isIntegerType() && !ValType->isPointerType() &&
 285       !ValType->isBlockPointerType())
 286     return Diag(DRE->getLocStart(),
 287                 diag::err_atomic_builtin_must_be_pointer_intptr)
 288              << FirstArg->getType() << FirstArg->getSourceRange();
 289
 290   // We need to figure out which concrete builtin this maps onto.  For example,
 291   // __sync_fetch_and_add with a 2 byte object turns into
 292   // __sync_fetch_and_add_2.
 293 #define BUILTIN_ROW(x) \
 294   { Builtin::BI##x##_1, Builtin::BI##x##_2, Builtin::BI##x##_4, \
 295     Builtin::BI##x##_8, Builtin::BI##x##_16 }
 296
 297   static const unsigned BuiltinIndices[][5] = {
 298     BUILTIN_ROW(__sync_fetch_and_add),
 299     BUILTIN_ROW(__sync_fetch_and_sub),
 300     BUILTIN_ROW(__sync_fetch_and_or),
 301     BUILTIN_ROW(__sync_fetch_and_and),
 302     BUILTIN_ROW(__sync_fetch_and_xor),
 303     BUILTIN_ROW(__sync_fetch_and_nand),
 304
 305     BUILTIN_ROW(__sync_add_and_fetch),
 306     BUILTIN_ROW(__sync_sub_and_fetch),
 307     BUILTIN_ROW(__sync_and_and_fetch),
 308     BUILTIN_ROW(__sync_or_and_fetch),
 309     BUILTIN_ROW(__sync_xor_and_fetch),
 310     BUILTIN_ROW(__sync_nand_and_fetch),
 311
 312     BUILTIN_ROW(__sync_val_compare_and_swap),
 313     BUILTIN_ROW(__sync_bool_compare_and_swap),
 314     BUILTIN_ROW(__sync_lock_test_and_set),
 315     BUILTIN_ROW(__sync_lock_release)
 316   };
 317 #undef BUILTIN_ROW
 318
 319   // Determine the index of the size.
 320   unsigned SizeIndex;
 321   switch (Context.getTypeSize(ValType)/8) {
 322   case 1: SizeIndex = 0; break;
 323   case 2: SizeIndex = 1; break;
 324   case 4: SizeIndex = 2; break;
 325   case 8: SizeIndex = 3; break;
 326   case 16: SizeIndex = 4; break;
 327   default:
 328     return Diag(DRE->getLocStart(), diag::err_atomic_builtin_pointer_size)
 329              << FirstArg->getType() << FirstArg->getSourceRange();
 330   }
 331
 332   // Each of these builtins has one pointer argument, followed by some number of
 333   // values (0, 1 or 2) followed by a potentially empty varags list of stuff
 334   // that we ignore.  Find out which row of BuiltinIndices to read from as well
 335   // as the number of fixed args.
 336   unsigned BuiltinID = FDecl->getBuiltinID();
 337   unsigned BuiltinIndex, NumFixed = 1;
 338   switch (BuiltinID) {
 339   default: assert(0 && "Unknown overloaded atomic builtin!");
 340   case Builtin::BI__sync_fetch_and_add: BuiltinIndex = 0; break;
 341   case Builtin::BI__sync_fetch_and_sub: BuiltinIndex = 1; break;
 342   case Builtin::BI__sync_fetch_and_or:  BuiltinIndex = 2; break;
 343   case Builtin::BI__sync_fetch_and_and: BuiltinIndex = 3; break;
 344   case Builtin::BI__sync_fetch_and_xor: BuiltinIndex = 4; break;
 345   case Builtin::BI__sync_fetch_and_nand:BuiltinIndex = 5; break;
 346
 347   case Builtin::BI__sync_add_and_fetch: BuiltinIndex = 6; break;
 348   case Builtin::BI__sync_sub_and_fetch: BuiltinIndex = 7; break;
 349   case Builtin::BI__sync_and_and_fetch: BuiltinIndex = 8; break;
 350   case Builtin::BI__sync_or_and_fetch:  BuiltinIndex = 9; break;
 351   case Builtin::BI__sync_xor_and_fetch: BuiltinIndex =10; break;
 352   case Builtin::BI__sync_nand_and_fetch:BuiltinIndex =11; break;
 353
 354   case Builtin::BI__sync_val_compare_and_swap:
 355     BuiltinIndex = 12;
 356     NumFixed = 2;
 357     break;
 358   case Builtin::BI__sync_bool_compare_and_swap:
 359     BuiltinIndex = 13;
 360     NumFixed = 2;
 361     break;
 362   case Builtin::BI__sync_lock_test_and_set: BuiltinIndex = 14; break;
 363   case Builtin::BI__sync_lock_release:
 364     BuiltinIndex = 15;
 365     NumFixed = 0;
 366     break;
 367   }
 368
 369   // Now that we know how many fixed arguments we expect, first check that we
 370   // have at least that many.
 371   if (TheCall->getNumArgs() < 1+NumFixed)
 372     return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args)
 373             << 0 << TheCall->getCallee()->getSourceRange();
 374
 375
 376   // Get the decl for the concrete builtin from this, we can tell what the
 377   // concrete integer type we should convert to is.
 378   unsigned NewBuiltinID = BuiltinIndices[BuiltinIndex][SizeIndex];
 379   const char *NewBuiltinName = Context.BuiltinInfo.GetName(NewBuiltinID);
 380   IdentifierInfo *NewBuiltinII = PP.getIdentifierInfo(NewBuiltinName);
 381   FunctionDecl *NewBuiltinDecl =
 382     cast<FunctionDecl>(LazilyCreateBuiltin(NewBuiltinII, NewBuiltinID,
 383                                            TUScope, false, DRE->getLocStart()));
 384   const FunctionProtoType *BuiltinFT =
 385     NewBuiltinDecl->getType()->getAs<FunctionProtoType>();
 386   ValType = BuiltinFT->getArgType(0)->getAs<PointerType>()->getPointeeType();
 387
 388   // If the first type needs to be converted (e.g. void** -> int*), do it now.
 389   if (BuiltinFT->getArgType(0) != FirstArg->getType()) {
 390     ImpCastExprToType(FirstArg, BuiltinFT->getArgType(0), CastExpr::CK_BitCast);
 391     TheCall->setArg(0, FirstArg);
 392   }
 393
 394   // Next, walk the valid ones promoting to the right type.
 395   for (unsigned i = 0; i != NumFixed; ++i) {
 396     Expr *Arg = TheCall->getArg(i+1);
 397
 398     // If the argument is an implicit cast, then there was a promotion due to
 399     // "...", just remove it now.
 400     if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
 401       Arg = ICE->getSubExpr();
 402       ICE->setSubExpr(0);
 403       ICE->Destroy(Context);
 404       TheCall->setArg(i+1, Arg);
 405     }
 406
 407     // GCC does an implicit conversion to the pointer or integer ValType.  This
 408     // can fail in some cases (1i -> int**), check for this error case now.
 409     CastExpr::CastKind Kind = CastExpr::CK_Unknown;
 410     CXXMethodDecl *ConversionDecl = 0;
 411     if (CheckCastTypes(Arg->getSourceRange(), ValType, Arg, Kind,
 412                        ConversionDecl))
 413       return true;
 414
 415     // Okay, we have something that *can* be converted to the right type.  Check
 416     // to see if there is a potentially weird extension going on here.  This can
 417     // happen when you do an atomic operation on something like an char* and
 418     // pass in 42.  The 42 gets converted to char.  This is even more strange
 419     // for things like 45.123 -> char, etc.
 420     // FIXME: Do this check.
 421     ImpCastExprToType(Arg, ValType, Kind, /*isLvalue=*/false);
 422     TheCall->setArg(i+1, Arg);
 423   }
 424
 425   // Switch the DeclRefExpr to refer to the new decl.
 426   DRE->setDecl(NewBuiltinDecl);
 427   DRE->setType(NewBuiltinDecl->getType());
 428
 429   // Set the callee in the CallExpr.
 430   // FIXME: This leaks the original parens and implicit casts.
 431   Expr *PromotedCall = DRE;
 432   UsualUnaryConversions(PromotedCall);
 433   TheCall->setCallee(PromotedCall);
 434
 435
 436   // Change the result type of the call to match the result type of the decl.
 437   TheCall->setType(NewBuiltinDecl->getResultType());
 438   return false;
 439 }
 440
 441
 442 /// CheckObjCString - Checks that the argument to the builtin
 443 /// CFString constructor is correct
 444 /// FIXME: GCC currently emits the following warning:
 445 /// "warning: input conversion stopped due to an input byte that does not
 446 ///           belong to the input codeset UTF-8"
 447 /// Note: It might also make sense to do the UTF-16 conversion here (would
 448 /// simplify the backend).
 449 bool Sema::CheckObjCString(Expr *Arg) {
 450   Arg = Arg->IgnoreParenCasts();
 451   StringLiteral *Literal = dyn_cast<StringLiteral>(Arg);
 452
 453   if (!Literal || Literal->isWide()) {
 454     Diag(Arg->getLocStart(), diag::err_cfstring_literal_not_string_constant)
 455       << Arg->getSourceRange();
 456     return true;
 457   }
 458
 459   const char *Data = Literal->getStrData();
 460   unsigned Length = Literal->getByteLength();
 461
 462   for (unsigned i = 0; i < Length; ++i) {
 463     if (!Data[i]) {
 464       Diag(getLocationOfStringLiteralByte(Literal, i),
 465            diag::warn_cfstring_literal_contains_nul_character)
 466         << Arg->getSourceRange();
 467       break;
 468     }
 469   }
 470
 471   return false;
 472 }
 473
 474 /// SemaBuiltinVAStart - Check the arguments to __builtin_va_start for validity.
 475 /// Emit an error and return true on failure, return false on success.
 476 bool Sema::SemaBuiltinVAStart(CallExpr *TheCall) {
 477   Expr *Fn = TheCall->getCallee();
 478   if (TheCall->getNumArgs() > 2) {
 479     Diag(TheCall->getArg(2)->getLocStart(),
 480          diag::err_typecheck_call_too_many_args)
 481       << 0 /*function call*/ << Fn->getSourceRange()
 482       << SourceRange(TheCall->getArg(2)->getLocStart(),
 483                      (*(TheCall->arg_end()-1))->getLocEnd());
 484     return true;
 485   }
 486
 487   if (TheCall->getNumArgs() < 2) {
 488     return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args)
 489       << 0 /*function call*/;
 490   }
 491
 492   // Determine whether the current function is variadic or not.
 493   bool isVariadic;
 494   if (CurBlock)
 495     isVariadic = CurBlock->isVariadic;
 496   else if (getCurFunctionDecl()) {
 497     if (FunctionProtoType* FTP =
 498             dyn_cast<FunctionProtoType>(getCurFunctionDecl()->getType()))
 499       isVariadic = FTP->isVariadic();
 500     else
 501       isVariadic = false;
 502   } else {
 503     isVariadic = getCurMethodDecl()->isVariadic();
 504   }
 505
 506   if (!isVariadic) {
 507     Diag(Fn->getLocStart(), diag::err_va_start_used_in_non_variadic_function);
 508     return true;
 509   }
 510
 511   // Verify that the second argument to the builtin is the last argument of the
 512   // current function or method.
 513   bool SecondArgIsLastNamedArgument = false;
 514   const Expr *Arg = TheCall->getArg(1)->IgnoreParenCasts();
 515
 516   if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Arg)) {
 517     if (const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(DR->getDecl())) {
 518       // FIXME: This isn't correct for methods (results in bogus warning).
 519       // Get the last formal in the current function.
 520       const ParmVarDecl *LastArg;
 521       if (CurBlock)
 522         LastArg = *(CurBlock->TheDecl->param_end()-1);
 523       else if (FunctionDecl *FD = getCurFunctionDecl())
 524         LastArg = *(FD->param_end()-1);
 525       else
 526         LastArg = *(getCurMethodDecl()->param_end()-1);
 527       SecondArgIsLastNamedArgument = PV == LastArg;
 528     }
 529   }
 530
 531   if (!SecondArgIsLastNamedArgument)
 532     Diag(TheCall->getArg(1)->getLocStart(),
 533          diag::warn_second_parameter_of_va_start_not_last_named_argument);
 534   return false;
 535 }
 536
 537 /// SemaBuiltinUnorderedCompare - Handle functions like __builtin_isgreater and
 538 /// friends.  This is declared to take (...), so we have to check everything.
 539 bool Sema::SemaBuiltinUnorderedCompare(CallExpr *TheCall) {
 540   if (TheCall->getNumArgs() < 2)
 541     return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args)
 542       << 0 /*function call*/;
 543   if (TheCall->getNumArgs() > 2)
 544     return Diag(TheCall->getArg(2)->getLocStart(),
 545                 diag::err_typecheck_call_too_many_args)
 546       << 0 /*function call*/
 547       << SourceRange(TheCall->getArg(2)->getLocStart(),
 548                      (*(TheCall->arg_end()-1))->getLocEnd());
 549
 550   Expr *OrigArg0 = TheCall->getArg(0);
 551   Expr *OrigArg1 = TheCall->getArg(1);
 552
 553   // Do standard promotions between the two arguments, returning their common
 554   // type.
 555   QualType Res = UsualArithmeticConversions(OrigArg0, OrigArg1, false);
 556
 557   // Make sure any conversions are pushed back into the call; this is
 558   // type safe since unordered compare builtins are declared as "_Bool
 559   // foo(...)".
 560   TheCall->setArg(0, OrigArg0);
 561   TheCall->setArg(1, OrigArg1);
 562
 563   if (OrigArg0->isTypeDependent() || OrigArg1->isTypeDependent())
 564     return false;
 565
 566   // If the common type isn't a real floating type, then the arguments were
 567   // invalid for this operation.
 568   if (!Res->isRealFloatingType())
 569     return Diag(OrigArg0->getLocStart(),
 570                 diag::err_typecheck_call_invalid_ordered_compare)
 571       << OrigArg0->getType() << OrigArg1->getType()
 572       << SourceRange(OrigArg0->getLocStart(), OrigArg1->getLocEnd());
 573
 574   return false;
 575 }
 576
 577 /// SemaBuiltinUnorderedCompare - Handle functions like __builtin_isnan and
 578 /// friends.  This is declared to take (...), so we have to check everything.
 579 bool Sema::SemaBuiltinUnaryFP(CallExpr *TheCall) {
 580   if (TheCall->getNumArgs() < 1)
 581     return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args)
 582       << 0 /*function call*/;
 583   if (TheCall->getNumArgs() > 1)
 584     return Diag(TheCall->getArg(1)->getLocStart(),
 585                 diag::err_typecheck_call_too_many_args)
 586       << 0 /*function call*/
 587       << SourceRange(TheCall->getArg(1)->getLocStart(),
 588                      (*(TheCall->arg_end()-1))->getLocEnd());
 589
 590   Expr *OrigArg = TheCall->getArg(0);
 591
 592   if (OrigArg->isTypeDependent())
 593     return false;
 594
 595   // This operation requires a floating-point number
 596   if (!OrigArg->getType()->isRealFloatingType())
 597     return Diag(OrigArg->getLocStart(),
 598                 diag::err_typecheck_call_invalid_unary_fp)
 599       << OrigArg->getType() << OrigArg->getSourceRange();
 600
 601   return false;
 602 }
 603
 604 bool Sema::SemaBuiltinStackAddress(CallExpr *TheCall) {
 605   // The signature for these builtins is exact; the only thing we need
 606   // to check is that the argument is a constant.
 607   SourceLocation Loc;
 608   if (!TheCall->getArg(0)->isTypeDependent() &&
 609       !TheCall->getArg(0)->isValueDependent() &&
 610       !TheCall->getArg(0)->isIntegerConstantExpr(Context, &Loc))
 611     return Diag(Loc, diag::err_stack_const_level) << TheCall->getSourceRange();
 612
 613   return false;
 614 }
 615
 616 /// SemaBuiltinShuffleVector - Handle __builtin_shufflevector.
 617 // This is declared to take (...), so we have to check everything.
 618 Action::OwningExprResult Sema::SemaBuiltinShuffleVector(CallExpr *TheCall) {
 619   if (TheCall->getNumArgs() < 3)
 620     return ExprError(Diag(TheCall->getLocEnd(),
 621                           diag::err_typecheck_call_too_few_args)
 622       << 0 /*function call*/ << TheCall->getSourceRange());
 623
 624   unsigned numElements = std::numeric_limits<unsigned>::max();
 625   if (!TheCall->getArg(0)->isTypeDependent() &&
 626       !TheCall->getArg(1)->isTypeDependent()) {
 627     QualType FAType = TheCall->getArg(0)->getType();
 628     QualType SAType = TheCall->getArg(1)->getType();
 629
 630     if (!FAType->isVectorType() || !SAType->isVectorType()) {
 631       Diag(TheCall->getLocStart(), diag::err_shufflevector_non_vector)
 632         << SourceRange(TheCall->getArg(0)->getLocStart(),
 633                        TheCall->getArg(1)->getLocEnd());
 634       return ExprError();
 635     }
 636
 637     if (!Context.hasSameUnqualifiedType(FAType, SAType)) {
 638       Diag(TheCall->getLocStart(), diag::err_shufflevector_incompatible_vector)
 639         << SourceRange(TheCall->getArg(0)->getLocStart(),
 640                        TheCall->getArg(1)->getLocEnd());
 641       return ExprError();
 642     }
 643
 644     numElements = FAType->getAs<VectorType>()->getNumElements();
 645     if (TheCall->getNumArgs() != numElements+2) {
 646       if (TheCall->getNumArgs() < numElements+2)
 647         return ExprError(Diag(TheCall->getLocEnd(),
 648                               diag::err_typecheck_call_too_few_args)
 649                  << 0 /*function call*/ << TheCall->getSourceRange());
 650       return ExprError(Diag(TheCall->getLocEnd(),
 651                             diag::err_typecheck_call_too_many_args)
 652                  << 0 /*function call*/ << TheCall->getSourceRange());
 653     }
 654   }
 655
 656   for (unsigned i = 2; i < TheCall->getNumArgs(); i++) {
 657     if (TheCall->getArg(i)->isTypeDependent() ||
 658         TheCall->getArg(i)->isValueDependent())
 659       continue;
 660
 661     llvm::APSInt Result(32);
 662     if (!TheCall->getArg(i)->isIntegerConstantExpr(Result, Context))
 663       return ExprError(Diag(TheCall->getLocStart(),
 664                   diag::err_shufflevector_nonconstant_argument)
 665                 << TheCall->getArg(i)->getSourceRange());
 666
 667     if (Result.getActiveBits() > 64 || Result.getZExtValue() >= numElements*2)
 668       return ExprError(Diag(TheCall->getLocStart(),
 669                   diag::err_shufflevector_argument_too_large)
 670                << TheCall->getArg(i)->getSourceRange());
 671   }
 672
 673   llvm::SmallVector<Expr*, 32> exprs;
 674
 675   for (unsigned i = 0, e = TheCall->getNumArgs(); i != e; i++) {
 676     exprs.push_back(TheCall->getArg(i));
 677     TheCall->setArg(i, 0);
 678   }
 679
 680   return Owned(new (Context) ShuffleVectorExpr(Context, exprs.begin(),
 681                                             exprs.size(), exprs[0]->getType(),
 682                                             TheCall->getCallee()->getLocStart(),
 683                                             TheCall->getRParenLoc()));
 684 }
 685
 686 /// SemaBuiltinPrefetch - Handle __builtin_prefetch.
 687 // This is declared to take (const void*, ...) and can take two
 688 // optional constant int args.
 689 bool Sema::SemaBuiltinPrefetch(CallExpr *TheCall) {
 690   unsigned NumArgs = TheCall->getNumArgs();
 691
 692   if (NumArgs > 3)
 693     return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_many_args)
 694              << 0 /*function call*/ << TheCall->getSourceRange();
 695
 696   // Argument 0 is checked for us and the remaining arguments must be
 697   // constant integers.
 698   for (unsigned i = 1; i != NumArgs; ++i) {
 699     Expr *Arg = TheCall->getArg(i);
 700     if (Arg->isTypeDependent())
 701       continue;
 702
 703     if (!Arg->getType()->isIntegralType())
 704       return Diag(TheCall->getLocStart(), diag::err_prefetch_invalid_arg_type)
 705               << Arg->getSourceRange();
 706
 707     ImpCastExprToType(Arg, Context.IntTy, CastExpr::CK_IntegralCast);
 708     TheCall->setArg(i, Arg);
 709
 710     if (Arg->isValueDependent())
 711       continue;
 712
 713     llvm::APSInt Result;
 714     if (!Arg->isIntegerConstantExpr(Result, Context))
 715       return Diag(TheCall->getLocStart(), diag::err_prefetch_invalid_arg_ice)
 716         << SourceRange(Arg->getLocStart(), Arg->getLocEnd());
 717
 718     // FIXME: gcc issues a warning and rewrites these to 0. These
 719     // seems especially odd for the third argument since the default
 720     // is 3.
 721     if (i == 1) {
 722       if (Result.getLimitedValue() > 1)
 723         return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range)
 724              << "0" << "1" << Arg->getSourceRange();
 725     } else {
 726       if (Result.getLimitedValue() > 3)
 727         return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range)
 728             << "0" << "3" << Arg->getSourceRange();
 729     }
 730   }
 731
 732   return false;
 733 }
 734
 735 /// SemaBuiltinEHReturnDataRegNo - Handle __builtin_eh_return_data_regno, the
 736 /// operand must be an integer constant.
 737 bool Sema::SemaBuiltinEHReturnDataRegNo(CallExpr *TheCall) {
 738   llvm::APSInt Result;
 739   if (!TheCall->getArg(0)->isIntegerConstantExpr(Result, Context))
 740     return Diag(TheCall->getLocStart(), diag::err_expr_not_ice)
 741       << TheCall->getArg(0)->getSourceRange();
 742
 743   return false;
 744 }
 745
 746
 747 /// SemaBuiltinObjectSize - Handle __builtin_object_size(void *ptr,
 748 /// int type). This simply type checks that type is one of the defined
 749 /// constants (0-3).
 750 // For compatability check 0-3, llvm only handles 0 and 2.
 751 bool Sema::SemaBuiltinObjectSize(CallExpr *TheCall) {
 752   Expr *Arg = TheCall->getArg(1);
 753   if (Arg->isTypeDependent())
 754     return false;
 755
 756   QualType ArgType = Arg->getType();
 757   const BuiltinType *BT = ArgType->getAs<BuiltinType>();
 758   llvm::APSInt Result(32);
 759   if (!BT || BT->getKind() != BuiltinType::Int)
 760     return Diag(TheCall->getLocStart(), diag::err_object_size_invalid_argument)
 761              << SourceRange(Arg->getLocStart(), Arg->getLocEnd());
 762
 763   if (Arg->isValueDependent())
 764     return false;
 765
 766   if (!Arg->isIntegerConstantExpr(Result, Context)) {
 767     return Diag(TheCall->getLocStart(), diag::err_object_size_invalid_argument)
 768              << SourceRange(Arg->getLocStart(), Arg->getLocEnd());
 769   }
 770
 771   if (Result.getSExtValue() < 0 || Result.getSExtValue() > 3) {
 772     return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range)
 773              << "0" << "3" << SourceRange(Arg->getLocStart(), Arg->getLocEnd());
 774   }
 775
 776   return false;
 777 }
 778
 779 /// SemaBuiltinLongjmp - Handle __builtin_longjmp(void *env[5], int val).
 780 /// This checks that val is a constant 1.
 781 bool Sema::SemaBuiltinLongjmp(CallExpr *TheCall) {
 782   Expr *Arg = TheCall->getArg(1);
 783   if (Arg->isTypeDependent() || Arg->isValueDependent())
 784     return false;
 785
 786   llvm::APSInt Result(32);
 787   if (!Arg->isIntegerConstantExpr(Result, Context) || Result != 1)
 788     return Diag(TheCall->getLocStart(), diag::err_builtin_longjmp_invalid_val)
 789              << SourceRange(Arg->getLocStart(), Arg->getLocEnd());
 790
 791   return false;
 792 }
 793
 794 // Handle i > 1 ? "x" : "y", recursivelly
 795 bool Sema::SemaCheckStringLiteral(const Expr *E, const CallExpr *TheCall,
 796                                   bool HasVAListArg,
 797                                   unsigned format_idx, unsigned firstDataArg) {
 798   if (E->isTypeDependent() || E->isValueDependent())
 799     return false;
 800
 801   switch (E->getStmtClass()) {
 802   case Stmt::ConditionalOperatorClass: {
 803     const ConditionalOperator *C = cast<ConditionalOperator>(E);
 804     return SemaCheckStringLiteral(C->getTrueExpr(), TheCall,
 805                                   HasVAListArg, format_idx, firstDataArg)
 806         && SemaCheckStringLiteral(C->getRHS(), TheCall,
 807                                   HasVAListArg, format_idx, firstDataArg);
 808   }
 809
 810   case Stmt::ImplicitCastExprClass: {
 811     const ImplicitCastExpr *Expr = cast<ImplicitCastExpr>(E);
 812     return SemaCheckStringLiteral(Expr->getSubExpr(), TheCall, HasVAListArg,
 813                                   format_idx, firstDataArg);
 814   }
 815
 816   case Stmt::ParenExprClass: {
 817     const ParenExpr *Expr = cast<ParenExpr>(E);
 818     return SemaCheckStringLiteral(Expr->getSubExpr(), TheCall, HasVAListArg,
 819                                   format_idx, firstDataArg);
 820   }
 821
 822   case Stmt::DeclRefExprClass: {
 823     const DeclRefExpr *DR = cast<DeclRefExpr>(E);
 824
 825     // As an exception, do not flag errors for variables binding to
 826     // const string literals.
 827     if (const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl())) {
 828       bool isConstant = false;
 829       QualType T = DR->getType();
 830
 831       if (const ArrayType *AT = Context.getAsArrayType(T)) {
 832         isConstant = AT->getElementType().isConstant(Context);
 833       } else if (const PointerType *PT = T->getAs<PointerType>()) {
 834         isConstant = T.isConstant(Context) &&
 835                      PT->getPointeeType().isConstant(Context);
 836       }
 837
 838       if (isConstant) {
 839         const VarDecl *Def = 0;
 840         if (const Expr *Init = VD->getDefinition(Def))
 841           return SemaCheckStringLiteral(Init, TheCall,
 842                                         HasVAListArg, format_idx, firstDataArg);
 843       }
 844
 845       // For vprintf* functions (i.e., HasVAListArg==true), we add a
 846       // special check to see if the format string is a function parameter
 847       // of the function calling the printf function.  If the function
 848       // has an attribute indicating it is a printf-like function, then we
 849       // should suppress warnings concerning non-literals being used in a call
 850       // to a vprintf function.  For example:
 851       //
 852       // void
 853       // logmessage(char const *fmt __attribute__ (format (printf, 1, 2)), ...){
 854       //      va_list ap;
 855       //      va_start(ap, fmt);
 856       //      vprintf(fmt, ap);  // Do NOT emit a warning about "fmt".
 857       //      ...
 858       //
 859       //
 860       //  FIXME: We don't have full attribute support yet, so just check to see
 861       //    if the argument is a DeclRefExpr that references a parameter.  We'll
 862       //    add proper support for checking the attribute later.
 863       if (HasVAListArg)
 864         if (isa<ParmVarDecl>(VD))
 865           return true;
 866     }
 867
 868     return false;
 869   }
 870
 871   case Stmt::CallExprClass: {
 872     const CallExpr *CE = cast<CallExpr>(E);
 873     if (const ImplicitCastExpr *ICE
 874           = dyn_cast<ImplicitCastExpr>(CE->getCallee())) {
 875       if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) {
 876         if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
 877           if (const FormatArgAttr *FA = FD->getAttr<FormatArgAttr>()) {
 878             unsigned ArgIndex = FA->getFormatIdx();
 879             const Expr *Arg = CE->getArg(ArgIndex - 1);
 880
 881             return SemaCheckStringLiteral(Arg, TheCall, HasVAListArg,
 882                                           format_idx, firstDataArg);
 883           }
 884         }
 885       }
 886     }
 887
 888     return false;
 889   }
 890   case Stmt::ObjCStringLiteralClass:
 891   case Stmt::StringLiteralClass: {
 892     const StringLiteral *StrE = NULL;
 893
 894     if (const ObjCStringLiteral *ObjCFExpr = dyn_cast<ObjCStringLiteral>(E))
 895       StrE = ObjCFExpr->getString();
 896     else
 897       StrE = cast<StringLiteral>(E);
 898
 899     if (StrE) {
 900       CheckPrintfString(StrE, E, TheCall, HasVAListArg, format_idx,
 901                         firstDataArg);
 902       return true;
 903     }
 904
 905     return false;
 906   }
 907
 908   default:
 909     return false;
 910   }
 911 }
 912
 913 void
 914 Sema::CheckNonNullArguments(const NonNullAttr *NonNull,
 915                             const CallExpr *TheCall) {
 916   for (NonNullAttr::iterator i = NonNull->begin(), e = NonNull->end();
 917        i != e; ++i) {
 918     const Expr *ArgExpr = TheCall->getArg(*i);
 919     if (ArgExpr->isNullPointerConstant(Context,
 920                                        Expr::NPC_ValueDependentIsNotNull))
 921       Diag(TheCall->getCallee()->getLocStart(), diag::warn_null_arg)
 922         << ArgExpr->getSourceRange();
 923   }
 924 }
 925
 926 /// CheckPrintfArguments - Check calls to printf (and similar functions) for
 927 /// correct use of format strings.
 928 ///
 929 ///  HasVAListArg - A predicate indicating whether the printf-like
 930 ///    function is passed an explicit va_arg argument (e.g., vprintf)
 931 ///
 932 ///  format_idx - The index into Args for the format string.
 933 ///
 934 /// Improper format strings to functions in the printf family can be
 935 /// the source of bizarre bugs and very serious security holes.  A
 936 /// good source of information is available in the following paper
 937 /// (which includes additional references):
 938 ///
 939 ///  FormatGuard: Automatic Protection From printf Format String
 940 ///  Vulnerabilities, Proceedings of the 10th USENIX Security Symposium, 2001.
 941 ///
 942 /// Functionality implemented:
 943 ///
 944 ///  We can statically check the following properties for string
 945 ///  literal format strings for non v.*printf functions (where the
 946 ///  arguments are passed directly):
 947 //
 948 ///  (1) Are the number of format conversions equal to the number of
 949 ///      data arguments?
 950 ///
 951 ///  (2) Does each format conversion correctly match the type of the
 952 ///      corresponding data argument?  (TODO)
 953 ///
 954 /// Moreover, for all printf functions we can:
 955 ///
 956 ///  (3) Check for a missing format string (when not caught by type checking).
 957 ///
 958 ///  (4) Check for no-operation flags; e.g. using "#" with format
 959 ///      conversion 'c'  (TODO)
 960 ///
 961 ///  (5) Check the use of '%n', a major source of security holes.
 962 ///
 963 ///  (6) Check for malformed format conversions that don't specify anything.
 964 ///
 965 ///  (7) Check for empty format strings.  e.g: printf("");
 966 ///
 967 ///  (8) Check that the format string is a wide literal.
 968 ///
 969 ///  (9) Also check the arguments of functions with the __format__ attribute.
 970 ///      (TODO).
 971 ///
 972 /// All of these checks can be done by parsing the format string.
 973 ///
 974 /// For now, we ONLY do (1), (3), (5), (6), (7), and (8).
 975 void
 976 Sema::CheckPrintfArguments(const CallExpr *TheCall, bool HasVAListArg,
 977                            unsigned format_idx, unsigned firstDataArg) {
 978   const Expr *Fn = TheCall->getCallee();
 979
 980   // The way the format attribute works in GCC, the implicit this argument
 981   // of member functions is counted. However, it doesn't appear in our own
 982   // lists, so decrement format_idx in that case.
 983   if (isa<CXXMemberCallExpr>(TheCall)) {
 984     // Catch a format attribute mistakenly referring to the object argument.
 985     if (format_idx == 0)
 986       return;
 987     --format_idx;
 988     if(firstDataArg != 0)
 989       --firstDataArg;
 990   }
 991
 992   // CHECK: printf-like function is called with no format string.
 993   if (format_idx >= TheCall->getNumArgs()) {
 994     Diag(TheCall->getRParenLoc(), diag::warn_printf_missing_format_string)
 995       << Fn->getSourceRange();
 996     return;
 997   }
 998
 999   const Expr *OrigFormatExpr = TheCall->getArg(format_idx)->IgnoreParenCasts();
1000
1001   // CHECK: format string is not a string literal.
1002   //
1003   // Dynamically generated format strings are difficult to
1004   // automatically vet at compile time.  Requiring that format strings
1005   // are string literals: (1) permits the checking of format strings by
1006   // the compiler and thereby (2) can practically remove the source of
1007   // many format string exploits.
1008
1009   // Format string can be either ObjC string (e.g. @"%d") or
1010   // C string (e.g. "%d")
1011   // ObjC string uses the same format specifiers as C string, so we can use
1012   // the same format string checking logic for both ObjC and C strings.
1013   if (SemaCheckStringLiteral(OrigFormatExpr, TheCall, HasVAListArg, format_idx,
1014                              firstDataArg))
1015     return;  // Literal format string found, check done!
1016
1017   // If there are no arguments specified, warn with -Wformat-security, otherwise
1018   // warn only with -Wformat-nonliteral.
1019   if (TheCall->getNumArgs() == format_idx+1)
1020     Diag(TheCall->getArg(format_idx)->getLocStart(),
1021          diag::warn_printf_nonliteral_noargs)
1022       << OrigFormatExpr->getSourceRange();
1023   else
1024     Diag(TheCall->getArg(format_idx)->getLocStart(),
1025          diag::warn_printf_nonliteral)
1026            << OrigFormatExpr->getSourceRange();
1027 }
1028
1029 void Sema::CheckPrintfString(const StringLiteral *FExpr,
1030                              const Expr *OrigFormatExpr,
1031                              const CallExpr *TheCall, bool HasVAListArg,
1032                              unsigned format_idx, unsigned firstDataArg) {
1033
1034   const ObjCStringLiteral *ObjCFExpr =
1035     dyn_cast<ObjCStringLiteral>(OrigFormatExpr);
1036
1037   // CHECK: is the format string a wide literal?
1038   if (FExpr->isWide()) {
1039     Diag(FExpr->getLocStart(),
1040          diag::warn_printf_format_string_is_wide_literal)
1041       << OrigFormatExpr->getSourceRange();
1042     return;
1043   }
1044
1045   // Str - The format string.  NOTE: this is NOT null-terminated!
1046   const char *Str = FExpr->getStrData();
1047
1048   // CHECK: empty format string?
1049   unsigned StrLen = FExpr->getByteLength();
1050
1051   if (StrLen == 0) {
1052     Diag(FExpr->getLocStart(), diag::warn_printf_empty_format_string)
1053       << OrigFormatExpr->getSourceRange();
1054     return;
1055   }
1056
1057   // We process the format string using a binary state machine.  The
1058   // current state is stored in CurrentState.
1059   enum {
1060     state_OrdChr,
1061     state_Conversion
1062   } CurrentState = state_OrdChr;
1063
1064   // numConversions - The number of conversions seen so far.  This is
1065   //  incremented as we traverse the format string.
1066   unsigned numConversions = 0;
1067
1068   // numDataArgs - The number of data arguments after the format
1069   //  string.  This can only be determined for non vprintf-like
1070   //  functions.  For those functions, this value is 1 (the sole
1071   //  va_arg argument).
1072   unsigned numDataArgs = TheCall->getNumArgs()-firstDataArg;
1073
1074   // Inspect the format string.
1075   unsigned StrIdx = 0;
1076
1077   // LastConversionIdx - Index within the format string where we last saw
1078   //  a '%' character that starts a new format conversion.
1079   unsigned LastConversionIdx = 0;
1080
1081   for (; StrIdx < StrLen; ++StrIdx) {
1082
1083     // Is the number of detected conversion conversions greater than
1084     // the number of matching data arguments?  If so, stop.
1085     if (!HasVAListArg && numConversions > numDataArgs) break;
1086
1087     // Handle "\0"
1088     if (Str[StrIdx] == '\0') {
1089       // The string returned by getStrData() is not null-terminated,
1090       // so the presence of a null character is likely an error.
1091       Diag(getLocationOfStringLiteralByte(FExpr, StrIdx),
1092            diag::warn_printf_format_string_contains_null_char)
1093         <<  OrigFormatExpr->getSourceRange();
1094       return;
1095     }
1096
1097     // Ordinary characters (not processing a format conversion).
1098     if (CurrentState == state_OrdChr) {
1099       if (Str[StrIdx] == '%') {
1100         CurrentState = state_Conversion;
1101         LastConversionIdx = StrIdx;
1102       }
1103       continue;
1104     }
1105
1106     // Seen '%'.  Now processing a format conversion.
1107     switch (Str[StrIdx]) {
1108     // Handle dynamic precision or width specifier.
1109     case '*': {
1110       ++numConversions;
1111
1112       if (!HasVAListArg) {
1113         if (numConversions > numDataArgs) {
1114           SourceLocation Loc = getLocationOfStringLiteralByte(FExpr, StrIdx);
1115
1116           if (Str[StrIdx-1] == '.')
1117             Diag(Loc, diag::warn_printf_asterisk_precision_missing_arg)
1118               << OrigFormatExpr->getSourceRange();
1119           else
1120             Diag(Loc, diag::warn_printf_asterisk_width_missing_arg)
1121               << OrigFormatExpr->getSourceRange();
1122
1123           // Don't do any more checking.  We'll just emit spurious errors.
1124           return;
1125         }
1126
1127         // Perform type checking on width/precision specifier.
1128         const Expr *E = TheCall->getArg(format_idx+numConversions);
1129         if (const BuiltinType *BT = E->getType()->getAs<BuiltinType>())
1130           if (BT->getKind() == BuiltinType::Int)
1131             break;
1132
1133         SourceLocation Loc = getLocationOfStringLiteralByte(FExpr, StrIdx);
1134
1135         if (Str[StrIdx-1] == '.')
1136           Diag(Loc, diag::warn_printf_asterisk_precision_wrong_type)
1137           << E->getType() << E->getSourceRange();
1138         else
1139           Diag(Loc, diag::warn_printf_asterisk_width_wrong_type)
1140           << E->getType() << E->getSourceRange();
1141
1142         break;
1143       }
1144     }
1145
1146     // Characters which can terminate a format conversion
1147     // (e.g. "%d").  Characters that specify length modifiers or
1148     // other flags are handled by the default case below.
1149     //
1150     // FIXME: additional checks will go into the following cases.
1151     case 'i':
1152     case 'd':
1153     case 'o':
1154     case 'u':
1155     case 'x':
1156     case 'X':
1157     case 'D':
1158     case 'O':
1159     case 'U':
1160     case 'e':
1161     case 'E':
1162     case 'f':
1163     case 'F':
1164     case 'g':
1165     case 'G':
1166     case 'a':
1167     case 'A':
1168     case 'c':
1169     case 'C':
1170     case 'S':
1171     case 's':
1172     case 'p':
1173       ++numConversions;
1174       CurrentState = state_OrdChr;
1175       break;
1176
1177     case 'm':
1178       // FIXME: Warn in situations where this isn't supported!
1179       CurrentState = state_OrdChr;
1180       break;
1181
1182     // CHECK: Are we using "%n"?  Issue a warning.
1183     case 'n': {
1184       ++numConversions;
1185       CurrentState = state_OrdChr;
1186       SourceLocation Loc = getLocationOfStringLiteralByte(FExpr,
1187                                                           LastConversionIdx);
1188
1189       Diag(Loc, diag::warn_printf_write_back)<<OrigFormatExpr->getSourceRange();
1190       break;
1191     }
1192
1193     // Handle "%@"
1194     case '@':
1195       // %@ is allowed in ObjC format strings only.
1196       if (ObjCFExpr != NULL)
1197         CurrentState = state_OrdChr;
1198       else {
1199         // Issue a warning: invalid format conversion.
1200         SourceLocation Loc =
1201           getLocationOfStringLiteralByte(FExpr, LastConversionIdx);
1202
1203         Diag(Loc, diag::warn_printf_invalid_conversion)
1204           <<  std::string(Str+LastConversionIdx,
1205                           Str+std::min(LastConversionIdx+2, StrLen))
1206           << OrigFormatExpr->getSourceRange();
1207       }
1208       ++numConversions;
1209       break;
1210
1211     // Handle "%%"
1212     case '%':
1213       // Sanity check: Was the first "%" character the previous one?
1214       // If not, we will assume that we have a malformed format
1215       // conversion, and that the current "%" character is the start
1216       // of a new conversion.
1217       if (StrIdx - LastConversionIdx == 1)
1218         CurrentState = state_OrdChr;
1219       else {
1220         // Issue a warning: invalid format conversion.
1221         SourceLocation Loc =
1222           getLocationOfStringLiteralByte(FExpr, LastConversionIdx);
1223
1224         Diag(Loc, diag::warn_printf_invalid_conversion)
1225           << std::string(Str+LastConversionIdx, Str+StrIdx)
1226           << OrigFormatExpr->getSourceRange();
1227
1228         // This conversion is broken.  Advance to the next format
1229         // conversion.
1230         LastConversionIdx = StrIdx;
1231         ++numConversions;
1232       }
1233       break;
1234
1235     default:
1236       // This case catches all other characters: flags, widths, etc.
1237       // We should eventually process those as well.
1238       break;
1239     }
1240   }
1241
1242   if (CurrentState == state_Conversion) {
1243     // Issue a warning: invalid format conversion.
1244     SourceLocation Loc =
1245       getLocationOfStringLiteralByte(FExpr, LastConversionIdx);
1246
1247     Diag(Loc, diag::warn_printf_invalid_conversion)
1248       << std::string(Str+LastConversionIdx,
1249                      Str+std::min(LastConversionIdx+2, StrLen))
1250       << OrigFormatExpr->getSourceRange();
1251     return;
1252   }
1253
1254   if (!HasVAListArg) {
1255     // CHECK: Does the number of format conversions exceed the number
1256     //        of data arguments?
1257     if (numConversions > numDataArgs) {
1258       SourceLocation Loc =
1259         getLocationOfStringLiteralByte(FExpr, LastConversionIdx);
1260
1261       Diag(Loc, diag::warn_printf_insufficient_data_args)
1262         << OrigFormatExpr->getSourceRange();
1263     }
1264     // CHECK: Does the number of data arguments exceed the number of
1265     //        format conversions in the format string?
1266     else if (numConversions < numDataArgs)
1267       Diag(TheCall->getArg(format_idx+numConversions+1)->getLocStart(),
1268            diag::warn_printf_too_many_data_args)
1269         << OrigFormatExpr->getSourceRange();
1270   }
1271 }
1272
1273 //===--- CHECK: Return Address of Stack Variable --------------------------===//
1274
1275 static DeclRefExpr* EvalVal(Expr *E);
1276 static DeclRefExpr* EvalAddr(Expr* E);
1277
1278 /// CheckReturnStackAddr - Check if a return statement returns the address
1279 ///   of a stack variable.
1280 void
1281 Sema::CheckReturnStackAddr(Expr *RetValExp, QualType lhsType,
1282                            SourceLocation ReturnLoc) {
1283
1284   // Perform checking for returned stack addresses.
1285   if (lhsType->isPointerType() || lhsType->isBlockPointerType()) {
1286     if (DeclRefExpr *DR = EvalAddr(RetValExp))
1287       Diag(DR->getLocStart(), diag::warn_ret_stack_addr)
1288        << DR->getDecl()->getDeclName() << RetValExp->getSourceRange();
1289
1290     // Skip over implicit cast expressions when checking for block expressions.
1291     RetValExp = RetValExp->IgnoreParenCasts();
1292
1293     if (BlockExpr *C = dyn_cast<BlockExpr>(RetValExp))
1294       if (C->hasBlockDeclRefExprs())
1295         Diag(C->getLocStart(), diag::err_ret_local_block)
1296           << C->getSourceRange();
1297
1298     if (AddrLabelExpr *ALE = dyn_cast<AddrLabelExpr>(RetValExp))
1299       Diag(ALE->getLocStart(), diag::warn_ret_addr_label)
1300         << ALE->getSourceRange();
1301
1302   } else if (lhsType->isReferenceType()) {
1303     // Perform checking for stack values returned by reference.
1304     // Check for a reference to the stack
1305     if (DeclRefExpr *DR = EvalVal(RetValExp))
1306       Diag(DR->getLocStart(), diag::warn_ret_stack_ref)
1307         << DR->getDecl()->getDeclName() << RetValExp->getSourceRange();
1308   }
1309 }
1310
1311 /// EvalAddr - EvalAddr and EvalVal are mutually recursive functions that
1312 ///  check if the expression in a return statement evaluates to an address
1313 ///  to a location on the stack.  The recursion is used to traverse the
1314 ///  AST of the return expression, with recursion backtracking when we
1315 ///  encounter a subexpression that (1) clearly does not lead to the address
1316 ///  of a stack variable or (2) is something we cannot determine leads to
1317 ///  the address of a stack variable based on such local checking.
1318 ///
1319 ///  EvalAddr processes expressions that are pointers that are used as
1320 ///  references (and not L-values).  EvalVal handles all other values.
1321 ///  At the base case of the recursion is a check for a DeclRefExpr* in
1322 ///  the refers to a stack variable.
1323 ///
1324 ///  This implementation handles:
1325 ///
1326 ///   * pointer-to-pointer casts
1327 ///   * implicit conversions from array references to pointers
1328 ///   * taking the address of fields
1329 ///   * arbitrary interplay between "&" and "*" operators
1330 ///   * pointer arithmetic from an address of a stack variable
1331 ///   * taking the address of an array element where the array is on the stack
1332 static DeclRefExpr* EvalAddr(Expr *E) {
1333   // We should only be called for evaluating pointer expressions.
1334   assert((E->getType()->isAnyPointerType() ||
1335           E->getType()->isBlockPointerType() ||
1336           E->getType()->isObjCQualifiedIdType()) &&
1337          "EvalAddr only works on pointers");
1338
1339   // Our "symbolic interpreter" is just a dispatch off the currently
1340   // viewed AST node.  We then recursively traverse the AST by calling
1341   // EvalAddr and EvalVal appropriately.
1342   switch (E->getStmtClass()) {
1343   case Stmt::ParenExprClass:
1344     // Ignore parentheses.
1345     return EvalAddr(cast<ParenExpr>(E)->getSubExpr());
1346
1347   case Stmt::UnaryOperatorClass: {
1348     // The only unary operator that make sense to handle here
1349     // is AddrOf.  All others don't make sense as pointers.
1350     UnaryOperator *U = cast<UnaryOperator>(E);
1351
1352     if (U->getOpcode() == UnaryOperator::AddrOf)
1353       return EvalVal(U->getSubExpr());
1354     else
1355       return NULL;
1356   }
1357
1358   case Stmt::BinaryOperatorClass: {
1359     // Handle pointer arithmetic.  All other binary operators are not valid
1360     // in this context.
1361     BinaryOperator *B = cast<BinaryOperator>(E);
1362     BinaryOperator::Opcode op = B->getOpcode();
1363
1364     if (op != BinaryOperator::Add && op != BinaryOperator::Sub)
1365       return NULL;
1366
1367     Expr *Base = B->getLHS();
1368
1369     // Determine which argument is the real pointer base.  It could be
1370     // the RHS argument instead of the LHS.
1371     if (!Base->getType()->isPointerType()) Base = B->getRHS();
1372
1373     assert (Base->getType()->isPointerType());
1374     return EvalAddr(Base);
1375   }
1376
1377   // For conditional operators we need to see if either the LHS or RHS are
1378   // valid DeclRefExpr*s.  If one of them is valid, we return it.
1379   case Stmt::ConditionalOperatorClass: {
1380     ConditionalOperator *C = cast<ConditionalOperator>(E);
1381
1382     // Handle the GNU extension for missing LHS.
1383     if (Expr *lhsExpr = C->getLHS())
1384       if (DeclRefExpr* LHS = EvalAddr(lhsExpr))
1385         return LHS;
1386
1387      return EvalAddr(C->getRHS());
1388   }
1389
1390   // For casts, we need to handle conversions from arrays to
1391   // pointer values, and pointer-to-pointer conversions.
1392   case Stmt::ImplicitCastExprClass:
1393   case Stmt::CStyleCastExprClass:
1394   case Stmt::CXXFunctionalCastExprClass: {
1395     Expr* SubExpr = cast<CastExpr>(E)->getSubExpr();
1396     QualType T = SubExpr->getType();
1397
1398     if (SubExpr->getType()->isPointerType() ||
1399         SubExpr->getType()->isBlockPointerType() ||
1400         SubExpr->getType()->isObjCQualifiedIdType())
1401       return EvalAddr(SubExpr);
1402     else if (T->isArrayType())
1403       return EvalVal(SubExpr);
1404     else
1405       return 0;
1406   }
1407
1408   // C++ casts.  For dynamic casts, static casts, and const casts, we
1409   // are always converting from a pointer-to-pointer, so we just blow
1410   // through the cast.  In the case the dynamic cast doesn't fail (and
1411   // return NULL), we take the conservative route and report cases
1412   // where we return the address of a stack variable.  For Reinterpre
1413   // FIXME: The comment about is wrong; we're not always converting
1414   // from pointer to pointer. I'm guessing that this code should also
1415   // handle references to objects.
1416   case Stmt::CXXStaticCastExprClass:
1417   case Stmt::CXXDynamicCastExprClass:
1418   case Stmt::CXXConstCastExprClass:
1419   case Stmt::CXXReinterpretCastExprClass: {
1420       Expr *S = cast<CXXNamedCastExpr>(E)->getSubExpr();
1421       if (S->getType()->isPointerType() || S->getType()->isBlockPointerType())
1422         return EvalAddr(S);
1423       else
1424         return NULL;
1425   }
1426
1427   // Everything else: we simply don't reason about them.
1428   default:
1429     return NULL;
1430   }
1431 }
1432
1433
1434 ///  EvalVal - This function is complements EvalAddr in the mutual recursion.
1435 ///   See the comments for EvalAddr for more details.
1436 static DeclRefExpr* EvalVal(Expr *E) {
1437
1438   // We should only be called for evaluating non-pointer expressions, or
1439   // expressions with a pointer type that are not used as references but instead
1440   // are l-values (e.g., DeclRefExpr with a pointer type).
1441
1442   // Our "symbolic interpreter" is just a dispatch off the currently
1443   // viewed AST node.  We then recursively traverse the AST by calling
1444   // EvalAddr and EvalVal appropriately.
1445   switch (E->getStmtClass()) {
1446   case Stmt::DeclRefExprClass: {
1447     // DeclRefExpr: the base case.  When we hit a DeclRefExpr we are looking
1448     //  at code that refers to a variable's name.  We check if it has local
1449     //  storage within the function, and if so, return the expression.
1450     DeclRefExpr *DR = cast<DeclRefExpr>(E);
1451
1452     if (VarDecl *V = dyn_cast<VarDecl>(DR->getDecl()))
1453       if (V->hasLocalStorage() && !V->getType()->isReferenceType()) return DR;
1454
1455     return NULL;
1456   }
1457
1458   case Stmt::ParenExprClass:
1459     // Ignore parentheses.
1460     return EvalVal(cast<ParenExpr>(E)->getSubExpr());
1461
1462   case Stmt::UnaryOperatorClass: {
1463     // The only unary operator that make sense to handle here
1464     // is Deref.  All others don't resolve to a "name."  This includes
1465     // handling all sorts of rvalues passed to a unary operator.
1466     UnaryOperator *U = cast<UnaryOperator>(E);
1467
1468     if (U->getOpcode() == UnaryOperator::Deref)
1469       return EvalAddr(U->getSubExpr());
1470
1471     return NULL;
1472   }
1473
1474   case Stmt::ArraySubscriptExprClass: {
1475     // Array subscripts are potential references to data on the stack.  We
1476     // retrieve the DeclRefExpr* for the array variable if it indeed
1477     // has local storage.
1478     return EvalAddr(cast<ArraySubscriptExpr>(E)->getBase());
1479   }
1480
1481   case Stmt::ConditionalOperatorClass: {
1482     // For conditional operators we need to see if either the LHS or RHS are
1483     // non-NULL DeclRefExpr's.  If one is non-NULL, we return it.
1484     ConditionalOperator *C = cast<ConditionalOperator>(E);
1485
1486     // Handle the GNU extension for missing LHS.
1487     if (Expr *lhsExpr = C->getLHS())
1488       if (DeclRefExpr *LHS = EvalVal(lhsExpr))
1489         return LHS;
1490
1491     return EvalVal(C->getRHS());
1492   }
1493
1494   // Accesses to members are potential references to data on the stack.
1495   case Stmt::MemberExprClass: {
1496     MemberExpr *M = cast<MemberExpr>(E);
1497
1498     // Check for indirect access.  We only want direct field accesses.
1499     if (!M->isArrow())
1500       return EvalVal(M->getBase());
1501     else
1502       return NULL;
1503   }
1504
1505   // Everything else: we simply don't reason about them.
1506   default:
1507     return NULL;
1508   }
1509 }
1510
1511 //===--- CHECK: Floating-Point comparisons (-Wfloat-equal) ---------------===//
1512
1513 /// Check for comparisons of floating point operands using != and ==.
1514 /// Issue a warning if these are no self-comparisons, as they are not likely
1515 /// to do what the programmer intended.
1516 void Sema::CheckFloatComparison(SourceLocation loc, Expr* lex, Expr *rex) {
1517   bool EmitWarning = true;
1518
1519   Expr* LeftExprSansParen = lex->IgnoreParens();
1520   Expr* RightExprSansParen = rex->IgnoreParens();
1521
1522   // Special case: check for x == x (which is OK).
1523   // Do not emit warnings for such cases.
1524   if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(LeftExprSansParen))
1525     if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(RightExprSansParen))
1526       if (DRL->getDecl() == DRR->getDecl())
1527         EmitWarning = false;
1528
1529
1530   // Special case: check for comparisons against literals that can be exactly
1531   //  represented by APFloat.  In such cases, do not emit a warning.  This
1532   //  is a heuristic: often comparison against such literals are used to
1533   //  detect if a value in a variable has not changed.  This clearly can
1534   //  lead to false negatives.
1535   if (EmitWarning) {
1536     if (FloatingLiteral* FLL = dyn_cast<FloatingLiteral>(LeftExprSansParen)) {
1537       if (FLL->isExact())
1538         EmitWarning = false;
1539     } else
1540       if (FloatingLiteral* FLR = dyn_cast<FloatingLiteral>(RightExprSansParen)){
1541         if (FLR->isExact())
1542           EmitWarning = false;
1543     }
1544   }
1545
1546   // Check for comparisons with builtin types.
1547   if (EmitWarning)
1548     if (CallExpr* CL = dyn_cast<CallExpr>(LeftExprSansParen))
1549       if (CL->isBuiltinCall(Context))
1550         EmitWarning = false;
1551
1552   if (EmitWarning)
1553     if (CallExpr* CR = dyn_cast<CallExpr>(RightExprSansParen))
1554       if (CR->isBuiltinCall(Context))
1555         EmitWarning = false;
1556
1557   // Emit the diagnostic.
1558   if (EmitWarning)
1559     Diag(loc, diag::warn_floatingpoint_eq)
1560       << lex->getSourceRange() << rex->getSourceRange();
1561 }