SemaChecking.cpp revision 60fad45739b764886f707bd204eae9ecce6db1f2
159907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner//===--- SemaChecking.cpp - Extra Semantic Checking -----------------------===// 259907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner// 359907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner// The LLVM Compiler Infrastructure 459907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 759907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner// 859907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner//===----------------------------------------------------------------------===// 959907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner// 101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump// This file implements extra semantic analysis beyond what is enforced 1159907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner// by the C type system. 1259907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner// 1359907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner//===----------------------------------------------------------------------===// 1459907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner 1559907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner#include "Sema.h" 1659907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner#include "clang/AST/ASTContext.h" 17c4a1dea2dc56bd1357ec91b829a0b9e68229a13eDaniel Dunbar#include "clang/AST/DeclObjC.h" 182324512285caac0332bbbc6e4cab6245d2a370a1Ted Kremenek#include "clang/AST/ExprCXX.h" 197ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek#include "clang/AST/ExprObjC.h" 20719e61573f27c11057ecfe0dd8f141621602c571Chris Lattner#include "clang/Lex/LiteralSupport.h" 2159907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner#include "clang/Lex/Preprocessor.h" 22a1f3dba77b7418575c1ff539ffa74ebaa068280cZhongxing Xu#include <limits> 2359907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattnerusing namespace clang; 2459907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner 2560800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// getLocationOfStringLiteralByte - Return a source location that points to the 2660800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// specified byte of the specified string literal. 2760800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// 2860800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// Strings are amazingly complex. They can be formed from multiple tokens and 2960800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// can have escape sequences in them in addition to the usual trigraph and 3060800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// escaped newline business. This routine handles this complexity. 3160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// 3260800081361b0ffc114877b8abbc81cb57b4edf6Chris LattnerSourceLocation Sema::getLocationOfStringLiteralByte(const StringLiteral *SL, 3360800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner unsigned ByteNo) const { 3460800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner assert(!SL->isWide() && "This doesn't work for wide strings yet"); 351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3660800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // Loop over all of the tokens in this string until we find the one that 3760800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // contains the byte we're looking for. 3860800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner unsigned TokNo = 0; 3960800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner while (1) { 4060800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner assert(TokNo < SL->getNumConcatenated() && "Invalid byte number!"); 4160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceLocation StrTokLoc = SL->getStrTokenLoc(TokNo); 421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4360800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // Get the spelling of the string so that we can get the data that makes up 4460800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // the string literal, not the identifier for the macro it is potentially 4560800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // expanded through. 4660800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceLocation StrTokSpellingLoc = SourceMgr.getSpellingLoc(StrTokLoc); 4760800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner 4860800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // Re-lex the token to get its length and original spelling. 4960800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner std::pair<FileID, unsigned> LocInfo = 5060800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceMgr.getDecomposedLoc(StrTokSpellingLoc); 5160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner std::pair<const char *,const char *> Buffer = 5260800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceMgr.getBufferData(LocInfo.first); 5360800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner const char *StrData = Buffer.first+LocInfo.second; 541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5560800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // Create a langops struct and enable trigraphs. This is sufficient for 5660800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // relexing tokens. 5760800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner LangOptions LangOpts; 5860800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner LangOpts.Trigraphs = true; 591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6060800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // Create a lexer starting at the beginning of this token. 6160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner Lexer TheLexer(StrTokSpellingLoc, LangOpts, Buffer.first, StrData, 6260800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner Buffer.second); 6360800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner Token TheTok; 6460800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner TheLexer.LexFromRawLexer(TheTok); 651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 66443e53c7845f01c8ed693ccd137abb0bd76564f6Chris Lattner // Use the StringLiteralParser to compute the length of the string in bytes. 67443e53c7845f01c8ed693ccd137abb0bd76564f6Chris Lattner StringLiteralParser SLP(&TheTok, 1, PP); 68443e53c7845f01c8ed693ccd137abb0bd76564f6Chris Lattner unsigned TokNumBytes = SLP.GetStringLength(); 691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 702197c963543397777919cec22b65feb31a9ddf79Chris Lattner // If the byte is in this token, return the location of the byte. 7160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner if (ByteNo < TokNumBytes || 7260800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner (ByteNo == TokNumBytes && TokNo == SL->getNumConcatenated())) { 731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump unsigned Offset = 74719e61573f27c11057ecfe0dd8f141621602c571Chris Lattner StringLiteralParser::getOffsetOfStringByte(TheTok, ByteNo, PP); 751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 76719e61573f27c11057ecfe0dd8f141621602c571Chris Lattner // Now that we know the offset of the token in the spelling, use the 77719e61573f27c11057ecfe0dd8f141621602c571Chris Lattner // preprocessor to get the offset in the original source. 78719e61573f27c11057ecfe0dd8f141621602c571Chris Lattner return PP.AdvanceToTokenCharacter(StrTokLoc, Offset); 7960800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner } 801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 8160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // Move to the next string token. 8260800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner ++TokNo; 8360800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner ByteNo -= TokNumBytes; 8460800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner } 8560800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner} 8660800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner 874403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn/// CheckablePrintfAttr - does a function call have a "printf" attribute 884403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn/// and arguments that merit checking? 894403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynnbool Sema::CheckablePrintfAttr(const FormatAttr *Format, CallExpr *TheCall) { 904403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn if (Format->getType() == "printf") return true; 914403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn if (Format->getType() == "printf0") { 924403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn // printf0 allows null "format" string; if so don't check format/args 934403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn unsigned format_idx = Format->getFormatIdx() - 1; 944a2614e94672c47395abcde60518776fbebec589Sebastian Redl // Does the index refer to the implicit object argument? 954a2614e94672c47395abcde60518776fbebec589Sebastian Redl if (isa<CXXMemberCallExpr>(TheCall)) { 964a2614e94672c47395abcde60518776fbebec589Sebastian Redl if (format_idx == 0) 974a2614e94672c47395abcde60518776fbebec589Sebastian Redl return false; 984a2614e94672c47395abcde60518776fbebec589Sebastian Redl --format_idx; 994a2614e94672c47395abcde60518776fbebec589Sebastian Redl } 1004403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn if (format_idx < TheCall->getNumArgs()) { 1014403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn Expr *Format = TheCall->getArg(format_idx)->IgnoreParenCasts(); 102ce94049b69f75b44c18584fe79cd238978b6b0d5Douglas Gregor if (!Format->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) 1034403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn return true; 1044403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn } 1054403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn } 1064403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn return false; 1074403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn} 10860800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner 1090eb23307222bda7ad95d968eac4e1ab30864b213Sebastian RedlAction::OwningExprResult 110d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders CarlssonSema::CheckBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { 1110eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl OwningExprResult TheCallResult(Owned(TheCall)); 1122def48394f6d48bde0dec2b514193c2b533265b5Douglas Gregor 113d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson switch (BuiltinID) { 11430ce344307f8a8b00054021307015571f83c7364Chris Lattner case Builtin::BI__builtin___CFStringMakeConstantString: 115925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner assert(TheCall->getNumArgs() == 1 && 1161b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner "Wrong # arguments to builtin CFStringMakeConstantString"); 117690398188ea5b428f06aa13c7d4ce6eb741ad4f9Chris Lattner if (CheckObjCString(TheCall->getArg(0))) 1180eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 119d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 12049ff7a1c8c67d56e62d3b4627463b705c0d5008cTed Kremenek case Builtin::BI__builtin_stdarg_start: 12130ce344307f8a8b00054021307015571f83c7364Chris Lattner case Builtin::BI__builtin_va_start: 1220eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (SemaBuiltinVAStart(TheCall)) 1230eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 124d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 1251b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_isgreater: 1261b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_isgreaterequal: 1271b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_isless: 1281b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_islessequal: 1291b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_islessgreater: 1301b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_isunordered: 1310eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (SemaBuiltinUnorderedCompare(TheCall)) 1320eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 133d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 1349ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman case Builtin::BI__builtin_isfinite: 1359ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman case Builtin::BI__builtin_isinf: 1369ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman case Builtin::BI__builtin_isinf_sign: 1379ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman case Builtin::BI__builtin_isnan: 1389ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman case Builtin::BI__builtin_isnormal: 1399ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman if (SemaBuiltinUnaryFP(TheCall)) 1409ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman return ExprError(); 1419ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman break; 1426cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman case Builtin::BI__builtin_return_address: 1436cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman case Builtin::BI__builtin_frame_address: 1440eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (SemaBuiltinStackAddress(TheCall)) 1450eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 146d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 14721fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner case Builtin::BI__builtin_eh_return_data_regno: 14821fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner if (SemaBuiltinEHReturnDataRegNo(TheCall)) 14921fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner return ExprError(); 15021fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner break; 151d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman case Builtin::BI__builtin_shufflevector: 1520eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return SemaBuiltinShuffleVector(TheCall); 1530eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl // TheCall will be freed by the smart pointer here, but that's fine, since 1540eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl // SemaBuiltinShuffleVector guts it, but then doesn't release it. 1554493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar case Builtin::BI__builtin_prefetch: 1560eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (SemaBuiltinPrefetch(TheCall)) 1570eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 158d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 159d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar case Builtin::BI__builtin_object_size: 1600eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (SemaBuiltinObjectSize(TheCall)) 1610eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 162d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 163d875fed28578835de89cd407e9db4be788596d7cEli Friedman case Builtin::BI__builtin_longjmp: 164d875fed28578835de89cd407e9db4be788596d7cEli Friedman if (SemaBuiltinLongjmp(TheCall)) 165d875fed28578835de89cd407e9db4be788596d7cEli Friedman return ExprError(); 166d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 1675caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_add: 1685caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_sub: 1695caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_or: 1705caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_and: 1715caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_xor: 172eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_fetch_and_nand: 1735caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_add_and_fetch: 1745caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_sub_and_fetch: 1755caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_and_and_fetch: 1765caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_or_and_fetch: 1775caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_xor_and_fetch: 178eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_nand_and_fetch: 1795caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_val_compare_and_swap: 1805caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_bool_compare_and_swap: 1815caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_lock_test_and_set: 1825caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_lock_release: 1835caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner if (SemaBuiltinAtomicOverloaded(TheCall)) 1845caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return ExprError(); 185d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 18671993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson } 1871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 188d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return move(TheCallResult); 189d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson} 190d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson 191d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson/// CheckFunctionCall - Check a direct function call for various correctness 192d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson/// and safety properties not strictly enforced by the C type system. 193d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlssonbool Sema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall) { 194d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson // Get the IdentifierInfo* for the called function. 195d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson IdentifierInfo *FnInfo = FDecl->getIdentifier(); 196de45428f923b38d80407dbb9ede0df504256f9f6Daniel Dunbar 197d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson // None of the checks below are needed for functions that don't have 198d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson // simple names (e.g., C++ conversion functions). 199d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson if (!FnInfo) 200d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 2011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 202de45428f923b38d80407dbb9ede0df504256f9f6Daniel Dunbar // FIXME: This mechanism should be abstracted to be less fragile and 203de45428f923b38d80407dbb9ede0df504256f9f6Daniel Dunbar // more efficient. For example, just map function ids to custom 204de45428f923b38d80407dbb9ede0df504256f9f6Daniel Dunbar // handlers. 205de45428f923b38d80407dbb9ede0df504256f9f6Daniel Dunbar 20659907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner // Printf checking. 20740b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis if (const FormatAttr *Format = FDecl->getAttr<FormatAttr>()) { 2084403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn if (CheckablePrintfAttr(Format, TheCall)) { 2093d692df4b9c58895f9843b03543ec57447c93679Ted Kremenek bool HasVAListArg = Format->getFirstArg() == 0; 2103d692df4b9c58895f9843b03543ec57447c93679Ted Kremenek if (!HasVAListArg) { 2111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const FunctionProtoType *Proto 212183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall = FDecl->getType()->getAs<FunctionProtoType>()) 2134a2614e94672c47395abcde60518776fbebec589Sebastian Redl HasVAListArg = !Proto->isVariadic(); 2143d692df4b9c58895f9843b03543ec57447c93679Ted Kremenek } 2153c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor CheckPrintfArguments(TheCall, HasVAListArg, Format->getFormatIdx() - 1, 2163d692df4b9c58895f9843b03543ec57447c93679Ted Kremenek HasVAListArg ? 0 : Format->getFirstArg() - 1); 2173c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor } 21859907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner } 2191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (const NonNullAttr *NonNull = FDecl->getAttr<NonNullAttr>(); NonNull; 221d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson NonNull = NonNull->getNext<NonNullAttr>()) 222d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson CheckNonNullArguments(NonNull, TheCall); 2230eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl 224d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 22571993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson} 22671993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson 227d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlssonbool Sema::CheckBlockCall(NamedDecl *NDecl, CallExpr *TheCall) { 228725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian // Printf checking. 22940b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis const FormatAttr *Format = NDecl->getAttr<FormatAttr>(); 230725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian if (!Format) 231d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 2321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 233725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian const VarDecl *V = dyn_cast<VarDecl>(NDecl); 234725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian if (!V) 235d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 2361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 237725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian QualType Ty = V->getType(); 238725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian if (!Ty->isBlockPointerType()) 239d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 2401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 241d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson if (!CheckablePrintfAttr(Format, TheCall)) 242d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 2431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 244d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson bool HasVAListArg = Format->getFirstArg() == 0; 245d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson if (!HasVAListArg) { 2461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const FunctionType *FT = 247183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>(); 248d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FT)) 249d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson HasVAListArg = !Proto->isVariadic(); 250725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian } 251d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson CheckPrintfArguments(TheCall, HasVAListArg, Format->getFormatIdx() - 1, 252d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson HasVAListArg ? 0 : Format->getFirstArg() - 1); 253d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson 254d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 255725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian} 256725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian 2575caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// SemaBuiltinAtomicOverloaded - We have a call to a function like 2585caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// __sync_fetch_and_add, which is an overloaded function based on the pointer 2595caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// type of its first argument. The main ActOnCallExpr routines have already 2605caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// promoted the types of arguments because all of these calls are prototyped as 2615caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// void(...). 2625caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// 2635caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// This function goes through and does final semantic checking for these 2645caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// builtins, 2655caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattnerbool Sema::SemaBuiltinAtomicOverloaded(CallExpr *TheCall) { 2665caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts()); 2675caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner FunctionDecl *FDecl = cast<FunctionDecl>(DRE->getDecl()); 2685caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 2695caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Ensure that we have at least one argument to do type inference from. 2705caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner if (TheCall->getNumArgs() < 1) 2715caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args) 2725caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner << 0 << TheCall->getCallee()->getSourceRange(); 2731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2745caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Inspect the first argument of the atomic builtin. This should always be 2755caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // a pointer type, whose element is an integral scalar or pointer type. 2765caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Because it is a pointer type, we don't have to worry about any implicit 2775caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // casts here. 2785caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner Expr *FirstArg = TheCall->getArg(0); 2795caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner if (!FirstArg->getType()->isPointerType()) 2805caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return Diag(DRE->getLocStart(), diag::err_atomic_builtin_must_be_pointer) 2815caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner << FirstArg->getType() << FirstArg->getSourceRange(); 2821eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2836217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType ValType = FirstArg->getType()->getAs<PointerType>()->getPointeeType(); 2841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (!ValType->isIntegerType() && !ValType->isPointerType() && 2855caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner !ValType->isBlockPointerType()) 2865caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return Diag(DRE->getLocStart(), 2875caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner diag::err_atomic_builtin_must_be_pointer_intptr) 2885caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner << FirstArg->getType() << FirstArg->getSourceRange(); 2895caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 2905caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // We need to figure out which concrete builtin this maps onto. For example, 2915caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // __sync_fetch_and_add with a 2 byte object turns into 2925caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // __sync_fetch_and_add_2. 2935caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner#define BUILTIN_ROW(x) \ 2945caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner { Builtin::BI##x##_1, Builtin::BI##x##_2, Builtin::BI##x##_4, \ 2955caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner Builtin::BI##x##_8, Builtin::BI##x##_16 } 2961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2975caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner static const unsigned BuiltinIndices[][5] = { 2985caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_fetch_and_add), 2995caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_fetch_and_sub), 3005caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_fetch_and_or), 3015caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_fetch_and_and), 3025caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_fetch_and_xor), 303eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner BUILTIN_ROW(__sync_fetch_and_nand), 3041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3055caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_add_and_fetch), 3065caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_sub_and_fetch), 3075caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_and_and_fetch), 3085caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_or_and_fetch), 3095caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_xor_and_fetch), 310eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner BUILTIN_ROW(__sync_nand_and_fetch), 3111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3125caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_val_compare_and_swap), 3135caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_bool_compare_and_swap), 3145caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_lock_test_and_set), 3155caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_lock_release) 3165caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner }; 3171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump#undef BUILTIN_ROW 3181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3195caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Determine the index of the size. 3205caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner unsigned SizeIndex; 3215caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner switch (Context.getTypeSize(ValType)/8) { 3225caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case 1: SizeIndex = 0; break; 3235caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case 2: SizeIndex = 1; break; 3245caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case 4: SizeIndex = 2; break; 3255caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case 8: SizeIndex = 3; break; 3265caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case 16: SizeIndex = 4; break; 3275caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner default: 3285caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return Diag(DRE->getLocStart(), diag::err_atomic_builtin_pointer_size) 3295caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner << FirstArg->getType() << FirstArg->getSourceRange(); 3305caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner } 3311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3325caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Each of these builtins has one pointer argument, followed by some number of 3335caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // values (0, 1 or 2) followed by a potentially empty varags list of stuff 3345caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // that we ignore. Find out which row of BuiltinIndices to read from as well 3355caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // as the number of fixed args. 3367814e6d6645d587891293d59ecf6576defcfac92Douglas Gregor unsigned BuiltinID = FDecl->getBuiltinID(); 3375caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner unsigned BuiltinIndex, NumFixed = 1; 3385caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner switch (BuiltinID) { 3395caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner default: assert(0 && "Unknown overloaded atomic builtin!"); 3405caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_add: BuiltinIndex = 0; break; 3415caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_sub: BuiltinIndex = 1; break; 3425caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_or: BuiltinIndex = 2; break; 3435caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_and: BuiltinIndex = 3; break; 3445caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_xor: BuiltinIndex = 4; break; 345eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_fetch_and_nand:BuiltinIndex = 5; break; 3461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 347eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_add_and_fetch: BuiltinIndex = 6; break; 348eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_sub_and_fetch: BuiltinIndex = 7; break; 349eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_and_and_fetch: BuiltinIndex = 8; break; 350eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_or_and_fetch: BuiltinIndex = 9; break; 351eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_xor_and_fetch: BuiltinIndex =10; break; 352eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_nand_and_fetch:BuiltinIndex =11; break; 3531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3545caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_val_compare_and_swap: 355eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner BuiltinIndex = 12; 3565caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner NumFixed = 2; 3575caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner break; 3585caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_bool_compare_and_swap: 359eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner BuiltinIndex = 13; 3605caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner NumFixed = 2; 3615caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner break; 362eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_lock_test_and_set: BuiltinIndex = 14; break; 3635caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_lock_release: 364eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner BuiltinIndex = 15; 3655caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner NumFixed = 0; 3665caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner break; 3675caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner } 3681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3695caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Now that we know how many fixed arguments we expect, first check that we 3705caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // have at least that many. 3715caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner if (TheCall->getNumArgs() < 1+NumFixed) 3725caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args) 3735caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner << 0 << TheCall->getCallee()->getSourceRange(); 3741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 376e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner // Get the decl for the concrete builtin from this, we can tell what the 377e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner // concrete integer type we should convert to is. 378e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner unsigned NewBuiltinID = BuiltinIndices[BuiltinIndex][SizeIndex]; 379e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner const char *NewBuiltinName = Context.BuiltinInfo.GetName(NewBuiltinID); 380e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner IdentifierInfo *NewBuiltinII = PP.getIdentifierInfo(NewBuiltinName); 3811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump FunctionDecl *NewBuiltinDecl = 382e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner cast<FunctionDecl>(LazilyCreateBuiltin(NewBuiltinII, NewBuiltinID, 383e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner TUScope, false, DRE->getLocStart())); 384e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner const FunctionProtoType *BuiltinFT = 385183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall NewBuiltinDecl->getType()->getAs<FunctionProtoType>(); 3866217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek ValType = BuiltinFT->getArgType(0)->getAs<PointerType>()->getPointeeType(); 3871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 388e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner // If the first type needs to be converted (e.g. void** -> int*), do it now. 389e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner if (BuiltinFT->getArgType(0) != FirstArg->getType()) { 39073c39abdbb79927605d740c93dd9629e3e4f9bfeEli Friedman ImpCastExprToType(FirstArg, BuiltinFT->getArgType(0), CastExpr::CK_BitCast); 391e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner TheCall->setArg(0, FirstArg); 392e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner } 3931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3945caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Next, walk the valid ones promoting to the right type. 3955caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner for (unsigned i = 0; i != NumFixed; ++i) { 3965caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner Expr *Arg = TheCall->getArg(i+1); 3971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3985caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // If the argument is an implicit cast, then there was a promotion due to 3995caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // "...", just remove it now. 4005caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) { 4015caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner Arg = ICE->getSubExpr(); 4025caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner ICE->setSubExpr(0); 4035caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner ICE->Destroy(Context); 4045caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner TheCall->setArg(i+1, Arg); 4055caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner } 4061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4075caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // GCC does an implicit conversion to the pointer or integer ValType. This 4085caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // can fail in some cases (1i -> int**), check for this error case now. 409cdb61979755c1c0699c1ee25eede9a50bf94d29bAnders Carlsson CastExpr::CastKind Kind = CastExpr::CK_Unknown; 410e9f42087aabfdb6b2afc35c7e38ac65da063b409Fariborz Jahanian CXXMethodDecl *ConversionDecl = 0; 411e9f42087aabfdb6b2afc35c7e38ac65da063b409Fariborz Jahanian if (CheckCastTypes(Arg->getSourceRange(), ValType, Arg, Kind, 412e9f42087aabfdb6b2afc35c7e38ac65da063b409Fariborz Jahanian ConversionDecl)) 4135caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return true; 4141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4155caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Okay, we have something that *can* be converted to the right type. Check 4165caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // to see if there is a potentially weird extension going on here. This can 4175caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // happen when you do an atomic operation on something like an char* and 4185caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // pass in 42. The 42 gets converted to char. This is even more strange 4195caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // for things like 45.123 -> char, etc. 4201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // FIXME: Do this check. 421cdb61979755c1c0699c1ee25eede9a50bf94d29bAnders Carlsson ImpCastExprToType(Arg, ValType, Kind, /*isLvalue=*/false); 4225caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner TheCall->setArg(i+1, Arg); 4235caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner } 4241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4255caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Switch the DeclRefExpr to refer to the new decl. 4265caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner DRE->setDecl(NewBuiltinDecl); 4275caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner DRE->setType(NewBuiltinDecl->getType()); 4281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4295caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Set the callee in the CallExpr. 4305caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // FIXME: This leaks the original parens and implicit casts. 4315caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner Expr *PromotedCall = DRE; 4325caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner UsualUnaryConversions(PromotedCall); 4335caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner TheCall->setCallee(PromotedCall); 4341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4355caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 4365caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Change the result type of the call to match the result type of the decl. 4375caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner TheCall->setType(NewBuiltinDecl->getResultType()); 4385caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return false; 4395caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner} 4405caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 4415caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 442690398188ea5b428f06aa13c7d4ce6eb741ad4f9Chris Lattner/// CheckObjCString - Checks that the argument to the builtin 44371993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson/// CFString constructor is correct 444fd942628abfe30e30427875db953222ae99b4325Steve Naroff/// FIXME: GCC currently emits the following warning: 4451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// "warning: input conversion stopped due to an input byte that does not 446fd942628abfe30e30427875db953222ae99b4325Steve Naroff/// belong to the input codeset UTF-8" 447fd942628abfe30e30427875db953222ae99b4325Steve Naroff/// Note: It might also make sense to do the UTF-16 conversion here (would 448fd942628abfe30e30427875db953222ae99b4325Steve Naroff/// simplify the backend). 449690398188ea5b428f06aa13c7d4ce6eb741ad4f9Chris Lattnerbool Sema::CheckObjCString(Expr *Arg) { 45056f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner Arg = Arg->IgnoreParenCasts(); 45171993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson StringLiteral *Literal = dyn_cast<StringLiteral>(Arg); 45271993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson 45371993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson if (!Literal || Literal->isWide()) { 454fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner Diag(Arg->getLocStart(), diag::err_cfstring_literal_not_string_constant) 455fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << Arg->getSourceRange(); 4569cdc4d3834f203dcde3ff274b8928e4620a914d5Anders Carlsson return true; 45771993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson } 4581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 459f015b034159d40e7033309e50036804eb1971787Daniel Dunbar const char *Data = Literal->getStrData(); 460f015b034159d40e7033309e50036804eb1971787Daniel Dunbar unsigned Length = Literal->getByteLength(); 461f015b034159d40e7033309e50036804eb1971787Daniel Dunbar 462f015b034159d40e7033309e50036804eb1971787Daniel Dunbar for (unsigned i = 0; i < Length; ++i) { 463f015b034159d40e7033309e50036804eb1971787Daniel Dunbar if (!Data[i]) { 464f015b034159d40e7033309e50036804eb1971787Daniel Dunbar Diag(getLocationOfStringLiteralByte(Literal, i), 465f015b034159d40e7033309e50036804eb1971787Daniel Dunbar diag::warn_cfstring_literal_contains_nul_character) 466f015b034159d40e7033309e50036804eb1971787Daniel Dunbar << Arg->getSourceRange(); 467f015b034159d40e7033309e50036804eb1971787Daniel Dunbar break; 468f015b034159d40e7033309e50036804eb1971787Daniel Dunbar } 469f015b034159d40e7033309e50036804eb1971787Daniel Dunbar } 4701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4719cdc4d3834f203dcde3ff274b8928e4620a914d5Anders Carlsson return false; 47259907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner} 47359907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner 474c27c665c88b49dfb212aedc7bab8b9bf67658b9eChris Lattner/// SemaBuiltinVAStart - Check the arguments to __builtin_va_start for validity. 475c27c665c88b49dfb212aedc7bab8b9bf67658b9eChris Lattner/// Emit an error and return true on failure, return false on success. 476925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattnerbool Sema::SemaBuiltinVAStart(CallExpr *TheCall) { 477925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner Expr *Fn = TheCall->getCallee(); 478925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner if (TheCall->getNumArgs() > 2) { 4792c21a073525cdfa68e4439b7af551385dc2796abChris Lattner Diag(TheCall->getArg(2)->getLocStart(), 480fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner diag::err_typecheck_call_too_many_args) 4812c21a073525cdfa68e4439b7af551385dc2796abChris Lattner << 0 /*function call*/ << Fn->getSourceRange() 4821eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump << SourceRange(TheCall->getArg(2)->getLocStart(), 483fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner (*(TheCall->arg_end()-1))->getLocEnd()); 48430ce344307f8a8b00054021307015571f83c7364Chris Lattner return true; 48530ce344307f8a8b00054021307015571f83c7364Chris Lattner } 48656f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman 48756f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman if (TheCall->getNumArgs() < 2) { 48856f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args) 48956f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman << 0 /*function call*/; 49056f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman } 49156f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman 492c27c665c88b49dfb212aedc7bab8b9bf67658b9eChris Lattner // Determine whether the current function is variadic or not. 493c27c665c88b49dfb212aedc7bab8b9bf67658b9eChris Lattner bool isVariadic; 494cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff if (CurBlock) 495cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff isVariadic = CurBlock->isVariadic; 496cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff else if (getCurFunctionDecl()) { 49772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor if (FunctionProtoType* FTP = 49872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor dyn_cast<FunctionProtoType>(getCurFunctionDecl()->getType())) 49956f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman isVariadic = FTP->isVariadic(); 50056f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman else 50156f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman isVariadic = false; 50256f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman } else { 50353d0ea5f5bfa647ec23418bf3a3b7c183b51e4bdArgyrios Kyrtzidis isVariadic = getCurMethodDecl()->isVariadic(); 50456f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman } 5051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 506c27c665c88b49dfb212aedc7bab8b9bf67658b9eChris Lattner if (!isVariadic) { 50730ce344307f8a8b00054021307015571f83c7364Chris Lattner Diag(Fn->getLocStart(), diag::err_va_start_used_in_non_variadic_function); 50830ce344307f8a8b00054021307015571f83c7364Chris Lattner return true; 50930ce344307f8a8b00054021307015571f83c7364Chris Lattner } 5101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 51130ce344307f8a8b00054021307015571f83c7364Chris Lattner // Verify that the second argument to the builtin is the last argument of the 51230ce344307f8a8b00054021307015571f83c7364Chris Lattner // current function or method. 51330ce344307f8a8b00054021307015571f83c7364Chris Lattner bool SecondArgIsLastNamedArgument = false; 514e2c14103dec39cbd24dac9d7b3e91277b109c14fAnders Carlsson const Expr *Arg = TheCall->getArg(1)->IgnoreParenCasts(); 5151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 51688cf226caee50956ef47edd4d44cf7b80703a26cAnders Carlsson if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Arg)) { 51788cf226caee50956ef47edd4d44cf7b80703a26cAnders Carlsson if (const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(DR->getDecl())) { 51830ce344307f8a8b00054021307015571f83c7364Chris Lattner // FIXME: This isn't correct for methods (results in bogus warning). 51930ce344307f8a8b00054021307015571f83c7364Chris Lattner // Get the last formal in the current function. 52088cf226caee50956ef47edd4d44cf7b80703a26cAnders Carlsson const ParmVarDecl *LastArg; 521cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff if (CurBlock) 522cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff LastArg = *(CurBlock->TheDecl->param_end()-1); 523cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff else if (FunctionDecl *FD = getCurFunctionDecl()) 524371f258e61e1365b951b17931a3c5ac1530fd1a0Chris Lattner LastArg = *(FD->param_end()-1); 52530ce344307f8a8b00054021307015571f83c7364Chris Lattner else 52653d0ea5f5bfa647ec23418bf3a3b7c183b51e4bdArgyrios Kyrtzidis LastArg = *(getCurMethodDecl()->param_end()-1); 52730ce344307f8a8b00054021307015571f83c7364Chris Lattner SecondArgIsLastNamedArgument = PV == LastArg; 52830ce344307f8a8b00054021307015571f83c7364Chris Lattner } 52930ce344307f8a8b00054021307015571f83c7364Chris Lattner } 5301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 53130ce344307f8a8b00054021307015571f83c7364Chris Lattner if (!SecondArgIsLastNamedArgument) 5321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Diag(TheCall->getArg(1)->getLocStart(), 53330ce344307f8a8b00054021307015571f83c7364Chris Lattner diag::warn_second_parameter_of_va_start_not_last_named_argument); 53430ce344307f8a8b00054021307015571f83c7364Chris Lattner return false; 5356cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman} 53630ce344307f8a8b00054021307015571f83c7364Chris Lattner 5371b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner/// SemaBuiltinUnorderedCompare - Handle functions like __builtin_isgreater and 5381b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner/// friends. This is declared to take (...), so we have to check everything. 539925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattnerbool Sema::SemaBuiltinUnorderedCompare(CallExpr *TheCall) { 540925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner if (TheCall->getNumArgs() < 2) 5412c21a073525cdfa68e4439b7af551385dc2796abChris Lattner return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args) 5422c21a073525cdfa68e4439b7af551385dc2796abChris Lattner << 0 /*function call*/; 543925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner if (TheCall->getNumArgs() > 2) 5441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Diag(TheCall->getArg(2)->getLocStart(), 545fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner diag::err_typecheck_call_too_many_args) 5462c21a073525cdfa68e4439b7af551385dc2796abChris Lattner << 0 /*function call*/ 547fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << SourceRange(TheCall->getArg(2)->getLocStart(), 548fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner (*(TheCall->arg_end()-1))->getLocEnd()); 5491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 550925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner Expr *OrigArg0 = TheCall->getArg(0); 551925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner Expr *OrigArg1 = TheCall->getArg(1); 552cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 5531b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner // Do standard promotions between the two arguments, returning their common 5541b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner // type. 555925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner QualType Res = UsualArithmeticConversions(OrigArg0, OrigArg1, false); 556403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar 557403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar // Make sure any conversions are pushed back into the call; this is 558403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar // type safe since unordered compare builtins are declared as "_Bool 559403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar // foo(...)". 560403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar TheCall->setArg(0, OrigArg0); 561403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar TheCall->setArg(1, OrigArg1); 5621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 563cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (OrigArg0->isTypeDependent() || OrigArg1->isTypeDependent()) 564cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return false; 565cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 5661b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner // If the common type isn't a real floating type, then the arguments were 5671b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner // invalid for this operation. 5681b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner if (!Res->isRealFloatingType()) 5691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Diag(OrigArg0->getLocStart(), 570fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner diag::err_typecheck_call_invalid_ordered_compare) 571d162584991885ab004a02573a73ce06422b921fcChris Lattner << OrigArg0->getType() << OrigArg1->getType() 572fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << SourceRange(OrigArg0->getLocStart(), OrigArg1->getLocEnd()); 5731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5741b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner return false; 5751b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner} 5761b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner 5779ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman/// SemaBuiltinUnorderedCompare - Handle functions like __builtin_isnan and 5789ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman/// friends. This is declared to take (...), so we have to check everything. 5799ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedmanbool Sema::SemaBuiltinUnaryFP(CallExpr *TheCall) { 5809ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman if (TheCall->getNumArgs() < 1) 5819ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args) 5829ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman << 0 /*function call*/; 5839ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman if (TheCall->getNumArgs() > 1) 5841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Diag(TheCall->getArg(1)->getLocStart(), 5859ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman diag::err_typecheck_call_too_many_args) 5869ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman << 0 /*function call*/ 5879ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman << SourceRange(TheCall->getArg(1)->getLocStart(), 5889ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman (*(TheCall->arg_end()-1))->getLocEnd()); 5899ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman 5909ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman Expr *OrigArg = TheCall->getArg(0); 5911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5929ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman if (OrigArg->isTypeDependent()) 5939ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman return false; 5949ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman 5959ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman // This operation requires a floating-point number 5969ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman if (!OrigArg->getType()->isRealFloatingType()) 5971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Diag(OrigArg->getLocStart(), 5989ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman diag::err_typecheck_call_invalid_unary_fp) 5999ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman << OrigArg->getType() << OrigArg->getSourceRange(); 6001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6019ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman return false; 6029ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman} 6039ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman 6046cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedmanbool Sema::SemaBuiltinStackAddress(CallExpr *TheCall) { 6056cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman // The signature for these builtins is exact; the only thing we need 6066cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman // to check is that the argument is a constant. 6076cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman SourceLocation Loc; 608cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (!TheCall->getArg(0)->isTypeDependent() && 609cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor !TheCall->getArg(0)->isValueDependent() && 610cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor !TheCall->getArg(0)->isIntegerConstantExpr(Context, &Loc)) 611fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(Loc, diag::err_stack_const_level) << TheCall->getSourceRange(); 6121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6136cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman return false; 6146cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman} 6156cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman 616d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman/// SemaBuiltinShuffleVector - Handle __builtin_shufflevector. 617d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman// This is declared to take (...), so we have to check everything. 6180eb23307222bda7ad95d968eac4e1ab30864b213Sebastian RedlAction::OwningExprResult Sema::SemaBuiltinShuffleVector(CallExpr *TheCall) { 619d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman if (TheCall->getNumArgs() < 3) 6200eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(Diag(TheCall->getLocEnd(), 6210eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl diag::err_typecheck_call_too_few_args) 6220eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl << 0 /*function call*/ << TheCall->getSourceRange()); 623d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 624cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor unsigned numElements = std::numeric_limits<unsigned>::max(); 625cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (!TheCall->getArg(0)->isTypeDependent() && 626cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor !TheCall->getArg(1)->isTypeDependent()) { 627cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor QualType FAType = TheCall->getArg(0)->getType(); 628cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor QualType SAType = TheCall->getArg(1)->getType(); 6291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 630cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (!FAType->isVectorType() || !SAType->isVectorType()) { 631cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor Diag(TheCall->getLocStart(), diag::err_shufflevector_non_vector) 6321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump << SourceRange(TheCall->getArg(0)->getLocStart(), 633cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor TheCall->getArg(1)->getLocEnd()); 634cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return ExprError(); 635cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor } 6361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 637a4923eb7c4b04d360cb2747641a5e92818edf804Douglas Gregor if (!Context.hasSameUnqualifiedType(FAType, SAType)) { 638cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor Diag(TheCall->getLocStart(), diag::err_shufflevector_incompatible_vector) 6391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump << SourceRange(TheCall->getArg(0)->getLocStart(), 640cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor TheCall->getArg(1)->getLocEnd()); 641cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return ExprError(); 642cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor } 643d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 644183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall numElements = FAType->getAs<VectorType>()->getNumElements(); 645cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (TheCall->getNumArgs() != numElements+2) { 646cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (TheCall->getNumArgs() < numElements+2) 647cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return ExprError(Diag(TheCall->getLocEnd(), 648cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor diag::err_typecheck_call_too_few_args) 649cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor << 0 /*function call*/ << TheCall->getSourceRange()); 6500eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(Diag(TheCall->getLocEnd(), 651cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor diag::err_typecheck_call_too_many_args) 652cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor << 0 /*function call*/ << TheCall->getSourceRange()); 653cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor } 654d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 655d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 656d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman for (unsigned i = 2; i < TheCall->getNumArgs(); i++) { 657cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (TheCall->getArg(i)->isTypeDependent() || 658cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor TheCall->getArg(i)->isValueDependent()) 659cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor continue; 660cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 661d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman llvm::APSInt Result(32); 662d1a0b6d3dfb208f638d3d750b588d9c0daa49289Chris Lattner if (!TheCall->getArg(i)->isIntegerConstantExpr(Result, Context)) 6630eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(Diag(TheCall->getLocStart(), 664fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner diag::err_shufflevector_nonconstant_argument) 6650eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl << TheCall->getArg(i)->getSourceRange()); 6660eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl 667d1a0b6d3dfb208f638d3d750b588d9c0daa49289Chris Lattner if (Result.getActiveBits() > 64 || Result.getZExtValue() >= numElements*2) 6680eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(Diag(TheCall->getLocStart(), 669fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner diag::err_shufflevector_argument_too_large) 6700eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl << TheCall->getArg(i)->getSourceRange()); 671d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 672d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 673d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman llvm::SmallVector<Expr*, 32> exprs; 674d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 675d1a0b6d3dfb208f638d3d750b588d9c0daa49289Chris Lattner for (unsigned i = 0, e = TheCall->getNumArgs(); i != e; i++) { 676d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman exprs.push_back(TheCall->getArg(i)); 677d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman TheCall->setArg(i, 0); 678d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 679d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 680a88dc3079bedf70a5cfc39791727e43a10383006Nate Begeman return Owned(new (Context) ShuffleVectorExpr(Context, exprs.begin(), 681a88dc3079bedf70a5cfc39791727e43a10383006Nate Begeman exprs.size(), exprs[0]->getType(), 6828189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek TheCall->getCallee()->getLocStart(), 6838189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek TheCall->getRParenLoc())); 684d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 68530ce344307f8a8b00054021307015571f83c7364Chris Lattner 6864493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar/// SemaBuiltinPrefetch - Handle __builtin_prefetch. 6874493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar// This is declared to take (const void*, ...) and can take two 6884493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar// optional constant int args. 6894493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbarbool Sema::SemaBuiltinPrefetch(CallExpr *TheCall) { 690fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner unsigned NumArgs = TheCall->getNumArgs(); 6914493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar 692fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner if (NumArgs > 3) 693fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_many_args) 6942c21a073525cdfa68e4439b7af551385dc2796abChris Lattner << 0 /*function call*/ << TheCall->getSourceRange(); 6954493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar 6964493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar // Argument 0 is checked for us and the remaining arguments must be 6974493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar // constant integers. 698fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner for (unsigned i = 1; i != NumArgs; ++i) { 6994493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar Expr *Arg = TheCall->getArg(i); 700cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (Arg->isTypeDependent()) 701cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor continue; 702cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 7039aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman if (!Arg->getType()->isIntegralType()) 7049aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman return Diag(TheCall->getLocStart(), diag::err_prefetch_invalid_arg_type) 70521fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner << Arg->getSourceRange(); 706cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 7079aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman ImpCastExprToType(Arg, Context.IntTy, CastExpr::CK_IntegralCast); 7089aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman TheCall->setArg(i, Arg); 7099aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman 710cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (Arg->isValueDependent()) 711cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor continue; 712cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 7139aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman llvm::APSInt Result; 714cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (!Arg->isIntegerConstantExpr(Result, Context)) 7159aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman return Diag(TheCall->getLocStart(), diag::err_prefetch_invalid_arg_ice) 716cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor << SourceRange(Arg->getLocStart(), Arg->getLocEnd()); 7171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7184493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar // FIXME: gcc issues a warning and rewrites these to 0. These 7194493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar // seems especially odd for the third argument since the default 7204493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar // is 3. 721fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner if (i == 1) { 7229aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman if (Result.getLimitedValue() > 1) 723fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range) 72421fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner << "0" << "1" << Arg->getSourceRange(); 7254493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar } else { 7269aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman if (Result.getLimitedValue() > 3) 727fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range) 72821fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner << "0" << "3" << Arg->getSourceRange(); 7294493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar } 7304493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar } 7314493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar 732fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return false; 7334493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar} 7344493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar 73521fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner/// SemaBuiltinEHReturnDataRegNo - Handle __builtin_eh_return_data_regno, the 73621fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner/// operand must be an integer constant. 73721fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattnerbool Sema::SemaBuiltinEHReturnDataRegNo(CallExpr *TheCall) { 73821fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner llvm::APSInt Result; 73921fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner if (!TheCall->getArg(0)->isIntegerConstantExpr(Result, Context)) 74021fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner return Diag(TheCall->getLocStart(), diag::err_expr_not_ice) 74121fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner << TheCall->getArg(0)->getSourceRange(); 74221fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner 74321fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner return false; 74421fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner} 74521fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner 74621fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner 747d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar/// SemaBuiltinObjectSize - Handle __builtin_object_size(void *ptr, 748d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar/// int type). This simply type checks that type is one of the defined 749d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar/// constants (0-3). 750fee667f35e64751baa7fefe70b4e7bab06c8cd86Eric Christopher// For compatability check 0-3, llvm only handles 0 and 2. 751d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbarbool Sema::SemaBuiltinObjectSize(CallExpr *TheCall) { 752d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar Expr *Arg = TheCall->getArg(1); 753cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (Arg->isTypeDependent()) 754cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return false; 755cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 7561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump QualType ArgType = Arg->getType(); 757183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const BuiltinType *BT = ArgType->getAs<BuiltinType>(); 758d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar llvm::APSInt Result(32); 759cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (!BT || BT->getKind() != BuiltinType::Int) 760cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return Diag(TheCall->getLocStart(), diag::err_object_size_invalid_argument) 761cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor << SourceRange(Arg->getLocStart(), Arg->getLocEnd()); 762cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 763cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (Arg->isValueDependent()) 764cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return false; 765cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 766cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (!Arg->isIntegerConstantExpr(Result, Context)) { 767fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(TheCall->getLocStart(), diag::err_object_size_invalid_argument) 768fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << SourceRange(Arg->getLocStart(), Arg->getLocEnd()); 769d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar } 770d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar 771d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar if (Result.getSExtValue() < 0 || Result.getSExtValue() > 3) { 772fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range) 773fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << "0" << "3" << SourceRange(Arg->getLocStart(), Arg->getLocEnd()); 774d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar } 775d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar 776d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar return false; 777d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar} 778d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar 779586d6a81428da2d1ce70bcb98df29d749361cbf3Eli Friedman/// SemaBuiltinLongjmp - Handle __builtin_longjmp(void *env[5], int val). 780d875fed28578835de89cd407e9db4be788596d7cEli Friedman/// This checks that val is a constant 1. 781d875fed28578835de89cd407e9db4be788596d7cEli Friedmanbool Sema::SemaBuiltinLongjmp(CallExpr *TheCall) { 782d875fed28578835de89cd407e9db4be788596d7cEli Friedman Expr *Arg = TheCall->getArg(1); 783cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (Arg->isTypeDependent() || Arg->isValueDependent()) 784cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return false; 785cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 786d875fed28578835de89cd407e9db4be788596d7cEli Friedman llvm::APSInt Result(32); 787d875fed28578835de89cd407e9db4be788596d7cEli Friedman if (!Arg->isIntegerConstantExpr(Result, Context) || Result != 1) 788d875fed28578835de89cd407e9db4be788596d7cEli Friedman return Diag(TheCall->getLocStart(), diag::err_builtin_longjmp_invalid_val) 789d875fed28578835de89cd407e9db4be788596d7cEli Friedman << SourceRange(Arg->getLocStart(), Arg->getLocEnd()); 790d875fed28578835de89cd407e9db4be788596d7cEli Friedman 791d875fed28578835de89cd407e9db4be788596d7cEli Friedman return false; 792d875fed28578835de89cd407e9db4be788596d7cEli Friedman} 793d875fed28578835de89cd407e9db4be788596d7cEli Friedman 794d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek// Handle i > 1 ? "x" : "y", recursivelly 795082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenekbool Sema::SemaCheckStringLiteral(const Expr *E, const CallExpr *TheCall, 796082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek bool HasVAListArg, 7973c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor unsigned format_idx, unsigned firstDataArg) { 798cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (E->isTypeDependent() || E->isValueDependent()) 799cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return false; 800d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 801d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek switch (E->getStmtClass()) { 802d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek case Stmt::ConditionalOperatorClass: { 803082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const ConditionalOperator *C = cast<ConditionalOperator>(E); 804813b70d6db54dbf149cfaa14ec7502142121d86fChris Lattner return SemaCheckStringLiteral(C->getTrueExpr(), TheCall, 8053c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor HasVAListArg, format_idx, firstDataArg) 806d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek && SemaCheckStringLiteral(C->getRHS(), TheCall, 8073c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor HasVAListArg, format_idx, firstDataArg); 808d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 809d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 810d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek case Stmt::ImplicitCastExprClass: { 811082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const ImplicitCastExpr *Expr = cast<ImplicitCastExpr>(E); 812d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek return SemaCheckStringLiteral(Expr->getSubExpr(), TheCall, HasVAListArg, 8133c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor format_idx, firstDataArg); 814d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 815d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 816d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek case Stmt::ParenExprClass: { 817082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const ParenExpr *Expr = cast<ParenExpr>(E); 818d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek return SemaCheckStringLiteral(Expr->getSubExpr(), TheCall, HasVAListArg, 8193c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor format_idx, firstDataArg); 820d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 8211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 822082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek case Stmt::DeclRefExprClass: { 823082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const DeclRefExpr *DR = cast<DeclRefExpr>(E); 8241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 825082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek // As an exception, do not flag errors for variables binding to 826082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek // const string literals. 827082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek if (const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl())) { 828082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek bool isConstant = false; 829082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek QualType T = DR->getType(); 830082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek 831082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek if (const ArrayType *AT = Context.getAsArrayType(T)) { 832082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek isConstant = AT->getElementType().isConstant(Context); 833ac5fc7c6bcb494b60fee7ce615ac931c5db6135eMike Stump } else if (const PointerType *PT = T->getAs<PointerType>()) { 8341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump isConstant = T.isConstant(Context) && 835082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek PT->getPointeeType().isConstant(Context); 836082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek } 8371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 838082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek if (isConstant) { 839082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const VarDecl *Def = 0; 840082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek if (const Expr *Init = VD->getDefinition(Def)) 841082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek return SemaCheckStringLiteral(Init, TheCall, 842082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek HasVAListArg, format_idx, firstDataArg); 843082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek } 8441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 845d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // For vprintf* functions (i.e., HasVAListArg==true), we add a 846d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // special check to see if the format string is a function parameter 847d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // of the function calling the printf function. If the function 848d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // has an attribute indicating it is a printf-like function, then we 849d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // should suppress warnings concerning non-literals being used in a call 850d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // to a vprintf function. For example: 851d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // 852d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // void 853d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // logmessage(char const *fmt __attribute__ (format (printf, 1, 2)), ...){ 854d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // va_list ap; 855d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // va_start(ap, fmt); 856d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // vprintf(fmt, ap); // Do NOT emit a warning about "fmt". 857d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // ... 858d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // 859d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // 860d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // FIXME: We don't have full attribute support yet, so just check to see 861d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // if the argument is a DeclRefExpr that references a parameter. We'll 862d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // add proper support for checking the attribute later. 863d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson if (HasVAListArg) 864d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson if (isa<ParmVarDecl>(VD)) 865d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson return true; 866082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek } 8671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 868082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek return false; 869082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek } 870d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 8718f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson case Stmt::CallExprClass: { 8728f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson const CallExpr *CE = cast<CallExpr>(E); 8731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const ImplicitCastExpr *ICE 8748f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson = dyn_cast<ImplicitCastExpr>(CE->getCallee())) { 8758f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) { 8768f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) { 87740b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis if (const FormatArgAttr *FA = FD->getAttr<FormatArgAttr>()) { 8788f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson unsigned ArgIndex = FA->getFormatIdx(); 8798f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson const Expr *Arg = CE->getArg(ArgIndex - 1); 8801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 8811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return SemaCheckStringLiteral(Arg, TheCall, HasVAListArg, 8828f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson format_idx, firstDataArg); 8838f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson } 8848f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson } 8858f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson } 8868f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson } 8871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 8888f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson return false; 8898f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson } 890082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek case Stmt::ObjCStringLiteralClass: 891082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek case Stmt::StringLiteralClass: { 892082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const StringLiteral *StrE = NULL; 8931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 894082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek if (const ObjCStringLiteral *ObjCFExpr = dyn_cast<ObjCStringLiteral>(E)) 895d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek StrE = ObjCFExpr->getString(); 896d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek else 897082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek StrE = cast<StringLiteral>(E); 8981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 899d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek if (StrE) { 9001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump CheckPrintfString(StrE, E, TheCall, HasVAListArg, format_idx, 9013c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor firstDataArg); 902d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek return true; 903d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 9041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 905d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek return false; 906d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 9071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 908082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek default: 909082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek return false; 910d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 911d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek} 912d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 913e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanianvoid 9141eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpSema::CheckNonNullArguments(const NonNullAttr *NonNull, 9151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const CallExpr *TheCall) { 916e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanian for (NonNullAttr::iterator i = NonNull->begin(), e = NonNull->end(); 917e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanian i != e; ++i) { 91812b97ff9ce1412e388444f03049bfa6ad1bb5eb9Chris Lattner const Expr *ArgExpr = TheCall->getArg(*i); 919ce94049b69f75b44c18584fe79cd238978b6b0d5Douglas Gregor if (ArgExpr->isNullPointerConstant(Context, 920ce94049b69f75b44c18584fe79cd238978b6b0d5Douglas Gregor Expr::NPC_ValueDependentIsNotNull)) 92112b97ff9ce1412e388444f03049bfa6ad1bb5eb9Chris Lattner Diag(TheCall->getCallee()->getLocStart(), diag::warn_null_arg) 92212b97ff9ce1412e388444f03049bfa6ad1bb5eb9Chris Lattner << ArgExpr->getSourceRange(); 923e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanian } 924e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanian} 925d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 92659907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner/// CheckPrintfArguments - Check calls to printf (and similar functions) for 9271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// correct use of format strings. 92871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 92971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// HasVAListArg - A predicate indicating whether the printf-like 93071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// function is passed an explicit va_arg argument (e.g., vprintf) 93171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 93271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// format_idx - The index into Args for the format string. 93371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 93471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// Improper format strings to functions in the printf family can be 93571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// the source of bizarre bugs and very serious security holes. A 93671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// good source of information is available in the following paper 93771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (which includes additional references): 93859907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner/// 93959907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner/// FormatGuard: Automatic Protection From printf Format String 94059907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner/// Vulnerabilities, Proceedings of the 10th USENIX Security Symposium, 2001. 94171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 94271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// Functionality implemented: 94371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 94471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// We can statically check the following properties for string 94571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// literal format strings for non v.*printf functions (where the 94671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// arguments are passed directly): 94771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek// 94871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (1) Are the number of format conversions equal to the number of 94971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// data arguments? 95071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 95171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (2) Does each format conversion correctly match the type of the 95271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// corresponding data argument? (TODO) 95371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 95471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// Moreover, for all printf functions we can: 95571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 95671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (3) Check for a missing format string (when not caught by type checking). 95771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 95871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (4) Check for no-operation flags; e.g. using "#" with format 95971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// conversion 'c' (TODO) 96071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 96171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (5) Check the use of '%n', a major source of security holes. 96271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 96371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (6) Check for malformed format conversions that don't specify anything. 96471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 96571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (7) Check for empty format strings. e.g: printf(""); 96671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 96771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (8) Check that the format string is a wide literal. 96871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 96971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// All of these checks can be done by parsing the format string. 97071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 97171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// For now, we ONLY do (1), (3), (5), (6), (7), and (8). 97259907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattnervoid 9731eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpSema::CheckPrintfArguments(const CallExpr *TheCall, bool HasVAListArg, 9743c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor unsigned format_idx, unsigned firstDataArg) { 975082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const Expr *Fn = TheCall->getCallee(); 976925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner 9774a2614e94672c47395abcde60518776fbebec589Sebastian Redl // The way the format attribute works in GCC, the implicit this argument 9784a2614e94672c47395abcde60518776fbebec589Sebastian Redl // of member functions is counted. However, it doesn't appear in our own 9794a2614e94672c47395abcde60518776fbebec589Sebastian Redl // lists, so decrement format_idx in that case. 9804a2614e94672c47395abcde60518776fbebec589Sebastian Redl if (isa<CXXMemberCallExpr>(TheCall)) { 9814a2614e94672c47395abcde60518776fbebec589Sebastian Redl // Catch a format attribute mistakenly referring to the object argument. 9824a2614e94672c47395abcde60518776fbebec589Sebastian Redl if (format_idx == 0) 9834a2614e94672c47395abcde60518776fbebec589Sebastian Redl return; 9844a2614e94672c47395abcde60518776fbebec589Sebastian Redl --format_idx; 9854a2614e94672c47395abcde60518776fbebec589Sebastian Redl if(firstDataArg != 0) 9864a2614e94672c47395abcde60518776fbebec589Sebastian Redl --firstDataArg; 9874a2614e94672c47395abcde60518776fbebec589Sebastian Redl } 9884a2614e94672c47395abcde60518776fbebec589Sebastian Redl 9891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // CHECK: printf-like function is called with no format string. 990925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner if (format_idx >= TheCall->getNumArgs()) { 991dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner Diag(TheCall->getRParenLoc(), diag::warn_printf_missing_format_string) 992dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner << Fn->getSourceRange(); 99371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek return; 99471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 9951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 996082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const Expr *OrigFormatExpr = TheCall->getArg(format_idx)->IgnoreParenCasts(); 9971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 99859907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner // CHECK: format string is not a string literal. 9991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // 100071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // Dynamically generated format strings are difficult to 100171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // automatically vet at compile time. Requiring that format strings 100271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // are string literals: (1) permits the checking of format strings by 100371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // the compiler and thereby (2) can practically remove the source of 100471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // many format string exploits. 10057ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek 10061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Format string can be either ObjC string (e.g. @"%d") or 10077ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek // C string (e.g. "%d") 10081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // ObjC string uses the same format specifiers as C string, so we can use 10097ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek // the same format string checking logic for both ObjC and C strings. 10101cd3e1f72c3a1c256fb6a5c3d4512bca1f1b751dChris Lattner if (SemaCheckStringLiteral(OrigFormatExpr, TheCall, HasVAListArg, format_idx, 10111cd3e1f72c3a1c256fb6a5c3d4512bca1f1b751dChris Lattner firstDataArg)) 10121cd3e1f72c3a1c256fb6a5c3d4512bca1f1b751dChris Lattner return; // Literal format string found, check done! 10131cd3e1f72c3a1c256fb6a5c3d4512bca1f1b751dChris Lattner 1014655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner // If there are no arguments specified, warn with -Wformat-security, otherwise 1015655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner // warn only with -Wformat-nonliteral. 1016655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner if (TheCall->getNumArgs() == format_idx+1) 10171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Diag(TheCall->getArg(format_idx)->getLocStart(), 1018655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner diag::warn_printf_nonliteral_noargs) 1019655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner << OrigFormatExpr->getSourceRange(); 1020655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner else 10211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Diag(TheCall->getArg(format_idx)->getLocStart(), 1022655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner diag::warn_printf_nonliteral) 1023655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner << OrigFormatExpr->getSourceRange(); 1024d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek} 1025d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 1026082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenekvoid Sema::CheckPrintfString(const StringLiteral *FExpr, 1027082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const Expr *OrigFormatExpr, 1028082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const CallExpr *TheCall, bool HasVAListArg, 1029082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek unsigned format_idx, unsigned firstDataArg) { 1030082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek 1031082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const ObjCStringLiteral *ObjCFExpr = 1032082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek dyn_cast<ObjCStringLiteral>(OrigFormatExpr); 103371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 103471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // CHECK: is the format string a wide literal? 103571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek if (FExpr->isWide()) { 1036925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner Diag(FExpr->getLocStart(), 1037dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner diag::warn_printf_format_string_is_wide_literal) 1038dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner << OrigFormatExpr->getSourceRange(); 103971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek return; 104071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 104171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 104271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // Str - The format string. NOTE: this is NOT null-terminated! 1043b9fc856696defc78750fdb4977c4dce34307a7f1Chris Lattner const char *Str = FExpr->getStrData(); 104471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 104571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // CHECK: empty format string? 1046b9fc856696defc78750fdb4977c4dce34307a7f1Chris Lattner unsigned StrLen = FExpr->getByteLength(); 10471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 104871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek if (StrLen == 0) { 1049dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner Diag(FExpr->getLocStart(), diag::warn_printf_empty_format_string) 1050dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner << OrigFormatExpr->getSourceRange(); 105171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek return; 105271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 105371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 105471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // We process the format string using a binary state machine. The 105571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // current state is stored in CurrentState. 105671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek enum { 105771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek state_OrdChr, 105871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek state_Conversion 105971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } CurrentState = state_OrdChr; 10601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 106171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // numConversions - The number of conversions seen so far. This is 106271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // incremented as we traverse the format string. 106371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek unsigned numConversions = 0; 106471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 106571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // numDataArgs - The number of data arguments after the format 106671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // string. This can only be determined for non vprintf-like 106771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // functions. For those functions, this value is 1 (the sole 106871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // va_arg argument). 10693c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor unsigned numDataArgs = TheCall->getNumArgs()-firstDataArg; 107071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 107171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // Inspect the format string. 107271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek unsigned StrIdx = 0; 10731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 107471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // LastConversionIdx - Index within the format string where we last saw 107571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // a '%' character that starts a new format conversion. 107671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek unsigned LastConversionIdx = 0; 10771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1078925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner for (; StrIdx < StrLen; ++StrIdx) { 10791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 108071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // Is the number of detected conversion conversions greater than 108171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // the number of matching data arguments? If so, stop. 108271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek if (!HasVAListArg && numConversions > numDataArgs) break; 10831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 108471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // Handle "\0" 1085925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner if (Str[StrIdx] == '\0') { 108671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // The string returned by getStrData() is not null-terminated, 108771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // so the presence of a null character is likely an error. 108860800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner Diag(getLocationOfStringLiteralByte(FExpr, StrIdx), 1089dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner diag::warn_printf_format_string_contains_null_char) 1090dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner << OrigFormatExpr->getSourceRange(); 109171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek return; 109271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 10931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 109471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // Ordinary characters (not processing a format conversion). 109571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek if (CurrentState == state_OrdChr) { 109671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek if (Str[StrIdx] == '%') { 109771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek CurrentState = state_Conversion; 109871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek LastConversionIdx = StrIdx; 109971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 110071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek continue; 110171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 110271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 110371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // Seen '%'. Now processing a format conversion. 110471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek switch (Str[StrIdx]) { 11051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Handle dynamic precision or width specifier. 1106fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case '*': { 1107fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner ++numConversions; 11081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 110942ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek if (!HasVAListArg) { 111042ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek if (numConversions > numDataArgs) { 111142ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek SourceLocation Loc = getLocationOfStringLiteralByte(FExpr, StrIdx); 111242ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek 111342ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek if (Str[StrIdx-1] == '.') 111442ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek Diag(Loc, diag::warn_printf_asterisk_precision_missing_arg) 111542ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek << OrigFormatExpr->getSourceRange(); 111642ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek else 111742ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek Diag(Loc, diag::warn_printf_asterisk_width_missing_arg) 111842ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek << OrigFormatExpr->getSourceRange(); 11191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 112042ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek // Don't do any more checking. We'll just emit spurious errors. 112142ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek return; 112242ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek } 11231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 112442ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek // Perform type checking on width/precision specifier. 112542ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek const Expr *E = TheCall->getArg(format_idx+numConversions); 1126183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall if (const BuiltinType *BT = E->getType()->getAs<BuiltinType>()) 112742ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek if (BT->getKind() == BuiltinType::Int) 112842ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek break; 11291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 113060800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceLocation Loc = getLocationOfStringLiteralByte(FExpr, StrIdx); 11311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1132580b664e9c2acd3bffddfea79b1ce2863cfd9dd0Ted Kremenek if (Str[StrIdx-1] == '.') 113342ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek Diag(Loc, diag::warn_printf_asterisk_precision_wrong_type) 113442ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek << E->getType() << E->getSourceRange(); 1135580b664e9c2acd3bffddfea79b1ce2863cfd9dd0Ted Kremenek else 113642ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek Diag(Loc, diag::warn_printf_asterisk_width_wrong_type) 113742ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek << E->getType() << E->getSourceRange(); 11381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump break; 1140580b664e9c2acd3bffddfea79b1ce2863cfd9dd0Ted Kremenek } 1141fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 11421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1143fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Characters which can terminate a format conversion 1144fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // (e.g. "%d"). Characters that specify length modifiers or 1145fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // other flags are handled by the default case below. 1146fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // 11471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // FIXME: additional checks will go into the following cases. 1148fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'i': 1149fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'd': 11501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case 'o': 11511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case 'u': 1152fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'x': 1153fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'X': 1154fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'D': 1155fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'O': 1156fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'U': 1157fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'e': 1158fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'E': 1159fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'f': 1160fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'F': 1161fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'g': 1162fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'G': 1163fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'a': 1164fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'A': 1165fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'c': 1166fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'C': 1167fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'S': 1168fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 's': 11691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case 'p': 1170fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner ++numConversions; 1171fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner CurrentState = state_OrdChr; 1172fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner break; 117371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 1174b92abb460be254fe577ccb95355ff7debf6a7719Eli Friedman case 'm': 1175b92abb460be254fe577ccb95355ff7debf6a7719Eli Friedman // FIXME: Warn in situations where this isn't supported! 1176b92abb460be254fe577ccb95355ff7debf6a7719Eli Friedman CurrentState = state_OrdChr; 1177b92abb460be254fe577ccb95355ff7debf6a7719Eli Friedman break; 1178b92abb460be254fe577ccb95355ff7debf6a7719Eli Friedman 1179fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // CHECK: Are we using "%n"? Issue a warning. 1180fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'n': { 1181fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner ++numConversions; 1182fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner CurrentState = state_OrdChr; 118360800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceLocation Loc = getLocationOfStringLiteralByte(FExpr, 118460800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner LastConversionIdx); 11851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1186dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner Diag(Loc, diag::warn_printf_write_back)<<OrigFormatExpr->getSourceRange(); 1187fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner break; 1188fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 11891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11907ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek // Handle "%@" 11917ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek case '@': 11927ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek // %@ is allowed in ObjC format strings only. 11931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (ObjCFExpr != NULL) 11941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump CurrentState = state_OrdChr; 11957ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek else { 11967ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek // Issue a warning: invalid format conversion. 11971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SourceLocation Loc = 119860800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner getLocationOfStringLiteralByte(FExpr, LastConversionIdx); 11991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1200d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner Diag(Loc, diag::warn_printf_invalid_conversion) 1201d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner << std::string(Str+LastConversionIdx, 1202d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner Str+std::min(LastConversionIdx+2, StrLen)) 1203d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner << OrigFormatExpr->getSourceRange(); 12047ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek } 12057ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek ++numConversions; 12067ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek break; 12071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1208fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Handle "%%" 1209fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case '%': 1210fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Sanity check: Was the first "%" character the previous one? 1211fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // If not, we will assume that we have a malformed format 1212fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // conversion, and that the current "%" character is the start 1213fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // of a new conversion. 1214fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner if (StrIdx - LastConversionIdx == 1) 12151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump CurrentState = state_OrdChr; 1216fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner else { 1217fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Issue a warning: invalid format conversion. 121860800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceLocation Loc = 121960800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner getLocationOfStringLiteralByte(FExpr, LastConversionIdx); 12201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1221d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner Diag(Loc, diag::warn_printf_invalid_conversion) 1222d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner << std::string(Str+LastConversionIdx, Str+StrIdx) 1223d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner << OrigFormatExpr->getSourceRange(); 12241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1225fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // This conversion is broken. Advance to the next format 1226fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // conversion. 1227fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner LastConversionIdx = StrIdx; 1228fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner ++numConversions; 122971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 1230fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner break; 12311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1232fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner default: 1233fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // This case catches all other characters: flags, widths, etc. 1234fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // We should eventually process those as well. 1235fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner break; 123671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 123771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 123871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 123971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek if (CurrentState == state_Conversion) { 124071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // Issue a warning: invalid format conversion. 124160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceLocation Loc = 124260800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner getLocationOfStringLiteralByte(FExpr, LastConversionIdx); 12431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1244d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner Diag(Loc, diag::warn_printf_invalid_conversion) 1245d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner << std::string(Str+LastConversionIdx, 1246d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner Str+std::min(LastConversionIdx+2, StrLen)) 1247d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner << OrigFormatExpr->getSourceRange(); 124871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek return; 124971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 12501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 125171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek if (!HasVAListArg) { 125271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // CHECK: Does the number of format conversions exceed the number 125371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // of data arguments? 125471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek if (numConversions > numDataArgs) { 125560800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceLocation Loc = 125660800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner getLocationOfStringLiteralByte(FExpr, LastConversionIdx); 12571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1258dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner Diag(Loc, diag::warn_printf_insufficient_data_args) 1259dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner << OrigFormatExpr->getSourceRange(); 126071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 126171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // CHECK: Does the number of data arguments exceed the number of 126271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // format conversions in the format string? 126371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek else if (numConversions < numDataArgs) 1264925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner Diag(TheCall->getArg(format_idx+numConversions+1)->getLocStart(), 1265dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner diag::warn_printf_too_many_data_args) 1266dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner << OrigFormatExpr->getSourceRange(); 126771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 126871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek} 126906de276fff91264437fa75111ed76de43097e089Ted Kremenek 127006de276fff91264437fa75111ed76de43097e089Ted Kremenek//===--- CHECK: Return Address of Stack Variable --------------------------===// 127106de276fff91264437fa75111ed76de43097e089Ted Kremenek 127206de276fff91264437fa75111ed76de43097e089Ted Kremenekstatic DeclRefExpr* EvalVal(Expr *E); 127306de276fff91264437fa75111ed76de43097e089Ted Kremenekstatic DeclRefExpr* EvalAddr(Expr* E); 127406de276fff91264437fa75111ed76de43097e089Ted Kremenek 127506de276fff91264437fa75111ed76de43097e089Ted Kremenek/// CheckReturnStackAddr - Check if a return statement returns the address 127606de276fff91264437fa75111ed76de43097e089Ted Kremenek/// of a stack variable. 127706de276fff91264437fa75111ed76de43097e089Ted Kremenekvoid 127806de276fff91264437fa75111ed76de43097e089Ted KremenekSema::CheckReturnStackAddr(Expr *RetValExp, QualType lhsType, 127906de276fff91264437fa75111ed76de43097e089Ted Kremenek SourceLocation ReturnLoc) { 12801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 128106de276fff91264437fa75111ed76de43097e089Ted Kremenek // Perform checking for returned stack addresses. 1282dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff if (lhsType->isPointerType() || lhsType->isBlockPointerType()) { 128306de276fff91264437fa75111ed76de43097e089Ted Kremenek if (DeclRefExpr *DR = EvalAddr(RetValExp)) 12843c73c41cefcfe76f36b7bed72c9f1ec195490951Chris Lattner Diag(DR->getLocStart(), diag::warn_ret_stack_addr) 128508631c5fa053867146b5ee8be658c229f6bf127cChris Lattner << DR->getDecl()->getDeclName() << RetValExp->getSourceRange(); 12861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1287c50a4a5f2eac14ac4c631d50b0a55cadc87700ceSteve Naroff // Skip over implicit cast expressions when checking for block expressions. 12884ca606e898293ae58f1793f988500e2218c7a9beChris Lattner RetValExp = RetValExp->IgnoreParenCasts(); 1289c50a4a5f2eac14ac4c631d50b0a55cadc87700ceSteve Naroff 12909e6b37a9f1d499e7ca0950edacd0b6569e491d7fChris Lattner if (BlockExpr *C = dyn_cast<BlockExpr>(RetValExp)) 1291397195bf3077fb42789b326f69f7d417227a0588Mike Stump if (C->hasBlockDeclRefExprs()) 1292397195bf3077fb42789b326f69f7d417227a0588Mike Stump Diag(C->getLocStart(), diag::err_ret_local_block) 1293397195bf3077fb42789b326f69f7d417227a0588Mike Stump << C->getSourceRange(); 12949e6b37a9f1d499e7ca0950edacd0b6569e491d7fChris Lattner 12959e6b37a9f1d499e7ca0950edacd0b6569e491d7fChris Lattner if (AddrLabelExpr *ALE = dyn_cast<AddrLabelExpr>(RetValExp)) 12969e6b37a9f1d499e7ca0950edacd0b6569e491d7fChris Lattner Diag(ALE->getLocStart(), diag::warn_ret_addr_label) 12979e6b37a9f1d499e7ca0950edacd0b6569e491d7fChris Lattner << ALE->getSourceRange(); 12989e6b37a9f1d499e7ca0950edacd0b6569e491d7fChris Lattner 1299ac5fc7c6bcb494b60fee7ce615ac931c5db6135eMike Stump } else if (lhsType->isReferenceType()) { 1300ac5fc7c6bcb494b60fee7ce615ac931c5db6135eMike Stump // Perform checking for stack values returned by reference. 130149badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor // Check for a reference to the stack 130249badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor if (DeclRefExpr *DR = EvalVal(RetValExp)) 1303dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner Diag(DR->getLocStart(), diag::warn_ret_stack_ref) 130408631c5fa053867146b5ee8be658c229f6bf127cChris Lattner << DR->getDecl()->getDeclName() << RetValExp->getSourceRange(); 130506de276fff91264437fa75111ed76de43097e089Ted Kremenek } 130606de276fff91264437fa75111ed76de43097e089Ted Kremenek} 130706de276fff91264437fa75111ed76de43097e089Ted Kremenek 130806de276fff91264437fa75111ed76de43097e089Ted Kremenek/// EvalAddr - EvalAddr and EvalVal are mutually recursive functions that 130906de276fff91264437fa75111ed76de43097e089Ted Kremenek/// check if the expression in a return statement evaluates to an address 131006de276fff91264437fa75111ed76de43097e089Ted Kremenek/// to a location on the stack. The recursion is used to traverse the 131106de276fff91264437fa75111ed76de43097e089Ted Kremenek/// AST of the return expression, with recursion backtracking when we 131206de276fff91264437fa75111ed76de43097e089Ted Kremenek/// encounter a subexpression that (1) clearly does not lead to the address 131306de276fff91264437fa75111ed76de43097e089Ted Kremenek/// of a stack variable or (2) is something we cannot determine leads to 131406de276fff91264437fa75111ed76de43097e089Ted Kremenek/// the address of a stack variable based on such local checking. 131506de276fff91264437fa75111ed76de43097e089Ted Kremenek/// 1316e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek/// EvalAddr processes expressions that are pointers that are used as 1317e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek/// references (and not L-values). EvalVal handles all other values. 13181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// At the base case of the recursion is a check for a DeclRefExpr* in 131906de276fff91264437fa75111ed76de43097e089Ted Kremenek/// the refers to a stack variable. 132006de276fff91264437fa75111ed76de43097e089Ted Kremenek/// 132106de276fff91264437fa75111ed76de43097e089Ted Kremenek/// This implementation handles: 132206de276fff91264437fa75111ed76de43097e089Ted Kremenek/// 132306de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * pointer-to-pointer casts 132406de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * implicit conversions from array references to pointers 132506de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * taking the address of fields 132606de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * arbitrary interplay between "&" and "*" operators 132706de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * pointer arithmetic from an address of a stack variable 132806de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * taking the address of an array element where the array is on the stack 132906de276fff91264437fa75111ed76de43097e089Ted Kremenekstatic DeclRefExpr* EvalAddr(Expr *E) { 133006de276fff91264437fa75111ed76de43097e089Ted Kremenek // We should only be called for evaluating pointer expressions. 13310f436560640a1cff5b6d96f80f540770f139453fDavid Chisnall assert((E->getType()->isAnyPointerType() || 1332dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff E->getType()->isBlockPointerType() || 1333a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek E->getType()->isObjCQualifiedIdType()) && 1334fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner "EvalAddr only works on pointers"); 13351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 133606de276fff91264437fa75111ed76de43097e089Ted Kremenek // Our "symbolic interpreter" is just a dispatch off the currently 133706de276fff91264437fa75111ed76de43097e089Ted Kremenek // viewed AST node. We then recursively traverse the AST by calling 133806de276fff91264437fa75111ed76de43097e089Ted Kremenek // EvalAddr and EvalVal appropriately. 133906de276fff91264437fa75111ed76de43097e089Ted Kremenek switch (E->getStmtClass()) { 1340fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case Stmt::ParenExprClass: 1341fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Ignore parentheses. 1342fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return EvalAddr(cast<ParenExpr>(E)->getSubExpr()); 134306de276fff91264437fa75111ed76de43097e089Ted Kremenek 1344fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case Stmt::UnaryOperatorClass: { 1345fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // The only unary operator that make sense to handle here 1346fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // is AddrOf. All others don't make sense as pointers. 1347fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner UnaryOperator *U = cast<UnaryOperator>(E); 13481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1349fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner if (U->getOpcode() == UnaryOperator::AddrOf) 1350fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return EvalVal(U->getSubExpr()); 1351fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner else 1352fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return NULL; 1353fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 13541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1355fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case Stmt::BinaryOperatorClass: { 1356fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Handle pointer arithmetic. All other binary operators are not valid 1357fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // in this context. 1358fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner BinaryOperator *B = cast<BinaryOperator>(E); 1359fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner BinaryOperator::Opcode op = B->getOpcode(); 13601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1361fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner if (op != BinaryOperator::Add && op != BinaryOperator::Sub) 1362fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return NULL; 13631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1364fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner Expr *Base = B->getLHS(); 13653907323dd6665c0c4e383435cb145233f4533406Anders Carlsson 1366fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Determine which argument is the real pointer base. It could be 1367fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // the RHS argument instead of the LHS. 1368fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner if (!Base->getType()->isPointerType()) Base = B->getRHS(); 13691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1370fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner assert (Base->getType()->isPointerType()); 1371fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return EvalAddr(Base); 1372fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 137361f40a2b67fc2046768e14f66b617e564cbcc3d8Steve Naroff 1374fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // For conditional operators we need to see if either the LHS or RHS are 1375fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // valid DeclRefExpr*s. If one of them is valid, we return it. 1376fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case Stmt::ConditionalOperatorClass: { 1377fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner ConditionalOperator *C = cast<ConditionalOperator>(E); 13781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1379fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Handle the GNU extension for missing LHS. 1380fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner if (Expr *lhsExpr = C->getLHS()) 1381fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner if (DeclRefExpr* LHS = EvalAddr(lhsExpr)) 1382fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return LHS; 138306de276fff91264437fa75111ed76de43097e089Ted Kremenek 1384fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return EvalAddr(C->getRHS()); 1385fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 13861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 138754b5274f2c190331438375ad114dad12ae098b57Ted Kremenek // For casts, we need to handle conversions from arrays to 138854b5274f2c190331438375ad114dad12ae098b57Ted Kremenek // pointer values, and pointer-to-pointer conversions. 138949badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor case Stmt::ImplicitCastExprClass: 13906eec8e883de118b431e3ead5b1e604a6ac68ff6bDouglas Gregor case Stmt::CStyleCastExprClass: 139149badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor case Stmt::CXXFunctionalCastExprClass: { 13920835a3cdeefe714b4959d31127ea155e56393125Argyrios Kyrtzidis Expr* SubExpr = cast<CastExpr>(E)->getSubExpr(); 139354b5274f2c190331438375ad114dad12ae098b57Ted Kremenek QualType T = SubExpr->getType(); 13941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1395dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff if (SubExpr->getType()->isPointerType() || 1396dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff SubExpr->getType()->isBlockPointerType() || 1397dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff SubExpr->getType()->isObjCQualifiedIdType()) 1398fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return EvalAddr(SubExpr); 139954b5274f2c190331438375ad114dad12ae098b57Ted Kremenek else if (T->isArrayType()) 140054b5274f2c190331438375ad114dad12ae098b57Ted Kremenek return EvalVal(SubExpr); 1401fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner else 140254b5274f2c190331438375ad114dad12ae098b57Ted Kremenek return 0; 1403fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 14041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1405fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // C++ casts. For dynamic casts, static casts, and const casts, we 1406fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // are always converting from a pointer-to-pointer, so we just blow 140749badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor // through the cast. In the case the dynamic cast doesn't fail (and 140849badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor // return NULL), we take the conservative route and report cases 1409fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // where we return the address of a stack variable. For Reinterpre 141049badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor // FIXME: The comment about is wrong; we're not always converting 141149badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor // from pointer to pointer. I'm guessing that this code should also 14121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // handle references to objects. 14131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case Stmt::CXXStaticCastExprClass: 14141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case Stmt::CXXDynamicCastExprClass: 141549badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor case Stmt::CXXConstCastExprClass: 141649badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor case Stmt::CXXReinterpretCastExprClass: { 141749badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor Expr *S = cast<CXXNamedCastExpr>(E)->getSubExpr(); 1418dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff if (S->getType()->isPointerType() || S->getType()->isBlockPointerType()) 1419fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return EvalAddr(S); 142006de276fff91264437fa75111ed76de43097e089Ted Kremenek else 142106de276fff91264437fa75111ed76de43097e089Ted Kremenek return NULL; 1422fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 14231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1424fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Everything else: we simply don't reason about them. 1425fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner default: 1426fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return NULL; 142706de276fff91264437fa75111ed76de43097e089Ted Kremenek } 142806de276fff91264437fa75111ed76de43097e089Ted Kremenek} 14291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 143006de276fff91264437fa75111ed76de43097e089Ted Kremenek 143106de276fff91264437fa75111ed76de43097e089Ted Kremenek/// EvalVal - This function is complements EvalAddr in the mutual recursion. 143206de276fff91264437fa75111ed76de43097e089Ted Kremenek/// See the comments for EvalAddr for more details. 143306de276fff91264437fa75111ed76de43097e089Ted Kremenekstatic DeclRefExpr* EvalVal(Expr *E) { 14341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1435e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek // We should only be called for evaluating non-pointer expressions, or 1436e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek // expressions with a pointer type that are not used as references but instead 1437e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek // are l-values (e.g., DeclRefExpr with a pointer type). 14381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 143906de276fff91264437fa75111ed76de43097e089Ted Kremenek // Our "symbolic interpreter" is just a dispatch off the currently 144006de276fff91264437fa75111ed76de43097e089Ted Kremenek // viewed AST node. We then recursively traverse the AST by calling 144106de276fff91264437fa75111ed76de43097e089Ted Kremenek // EvalAddr and EvalVal appropriately. 144206de276fff91264437fa75111ed76de43097e089Ted Kremenek switch (E->getStmtClass()) { 1443a2813cec2605ce7878d1b13471d685f689b251afDouglas Gregor case Stmt::DeclRefExprClass: { 144406de276fff91264437fa75111ed76de43097e089Ted Kremenek // DeclRefExpr: the base case. When we hit a DeclRefExpr we are looking 144506de276fff91264437fa75111ed76de43097e089Ted Kremenek // at code that refers to a variable's name. We check if it has local 144606de276fff91264437fa75111ed76de43097e089Ted Kremenek // storage within the function, and if so, return the expression. 144706de276fff91264437fa75111ed76de43097e089Ted Kremenek DeclRefExpr *DR = cast<DeclRefExpr>(E); 14481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 144906de276fff91264437fa75111ed76de43097e089Ted Kremenek if (VarDecl *V = dyn_cast<VarDecl>(DR->getDecl())) 14501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (V->hasLocalStorage() && !V->getType()->isReferenceType()) return DR; 14511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 145206de276fff91264437fa75111ed76de43097e089Ted Kremenek return NULL; 145306de276fff91264437fa75111ed76de43097e089Ted Kremenek } 14541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 145506de276fff91264437fa75111ed76de43097e089Ted Kremenek case Stmt::ParenExprClass: 145606de276fff91264437fa75111ed76de43097e089Ted Kremenek // Ignore parentheses. 145706de276fff91264437fa75111ed76de43097e089Ted Kremenek return EvalVal(cast<ParenExpr>(E)->getSubExpr()); 14581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 145906de276fff91264437fa75111ed76de43097e089Ted Kremenek case Stmt::UnaryOperatorClass: { 146006de276fff91264437fa75111ed76de43097e089Ted Kremenek // The only unary operator that make sense to handle here 146106de276fff91264437fa75111ed76de43097e089Ted Kremenek // is Deref. All others don't resolve to a "name." This includes 146206de276fff91264437fa75111ed76de43097e089Ted Kremenek // handling all sorts of rvalues passed to a unary operator. 146306de276fff91264437fa75111ed76de43097e089Ted Kremenek UnaryOperator *U = cast<UnaryOperator>(E); 14641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 146506de276fff91264437fa75111ed76de43097e089Ted Kremenek if (U->getOpcode() == UnaryOperator::Deref) 146606de276fff91264437fa75111ed76de43097e089Ted Kremenek return EvalAddr(U->getSubExpr()); 146706de276fff91264437fa75111ed76de43097e089Ted Kremenek 146806de276fff91264437fa75111ed76de43097e089Ted Kremenek return NULL; 146906de276fff91264437fa75111ed76de43097e089Ted Kremenek } 14701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 147106de276fff91264437fa75111ed76de43097e089Ted Kremenek case Stmt::ArraySubscriptExprClass: { 147206de276fff91264437fa75111ed76de43097e089Ted Kremenek // Array subscripts are potential references to data on the stack. We 147306de276fff91264437fa75111ed76de43097e089Ted Kremenek // retrieve the DeclRefExpr* for the array variable if it indeed 147406de276fff91264437fa75111ed76de43097e089Ted Kremenek // has local storage. 14752324512285caac0332bbbc6e4cab6245d2a370a1Ted Kremenek return EvalAddr(cast<ArraySubscriptExpr>(E)->getBase()); 147606de276fff91264437fa75111ed76de43097e089Ted Kremenek } 14771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 147806de276fff91264437fa75111ed76de43097e089Ted Kremenek case Stmt::ConditionalOperatorClass: { 147906de276fff91264437fa75111ed76de43097e089Ted Kremenek // For conditional operators we need to see if either the LHS or RHS are 148006de276fff91264437fa75111ed76de43097e089Ted Kremenek // non-NULL DeclRefExpr's. If one is non-NULL, we return it. 148106de276fff91264437fa75111ed76de43097e089Ted Kremenek ConditionalOperator *C = cast<ConditionalOperator>(E); 148206de276fff91264437fa75111ed76de43097e089Ted Kremenek 14833907323dd6665c0c4e383435cb145233f4533406Anders Carlsson // Handle the GNU extension for missing LHS. 14843907323dd6665c0c4e383435cb145233f4533406Anders Carlsson if (Expr *lhsExpr = C->getLHS()) 14853907323dd6665c0c4e383435cb145233f4533406Anders Carlsson if (DeclRefExpr *LHS = EvalVal(lhsExpr)) 14863907323dd6665c0c4e383435cb145233f4533406Anders Carlsson return LHS; 14873907323dd6665c0c4e383435cb145233f4533406Anders Carlsson 14883907323dd6665c0c4e383435cb145233f4533406Anders Carlsson return EvalVal(C->getRHS()); 148906de276fff91264437fa75111ed76de43097e089Ted Kremenek } 14901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 149106de276fff91264437fa75111ed76de43097e089Ted Kremenek // Accesses to members are potential references to data on the stack. 149283f6faf37d9bf58986bedc9bc0ea897a56b4dbadDouglas Gregor case Stmt::MemberExprClass: { 149306de276fff91264437fa75111ed76de43097e089Ted Kremenek MemberExpr *M = cast<MemberExpr>(E); 14941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 149506de276fff91264437fa75111ed76de43097e089Ted Kremenek // Check for indirect access. We only want direct field accesses. 149606de276fff91264437fa75111ed76de43097e089Ted Kremenek if (!M->isArrow()) 149706de276fff91264437fa75111ed76de43097e089Ted Kremenek return EvalVal(M->getBase()); 149806de276fff91264437fa75111ed76de43097e089Ted Kremenek else 149906de276fff91264437fa75111ed76de43097e089Ted Kremenek return NULL; 150006de276fff91264437fa75111ed76de43097e089Ted Kremenek } 15011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 150206de276fff91264437fa75111ed76de43097e089Ted Kremenek // Everything else: we simply don't reason about them. 150306de276fff91264437fa75111ed76de43097e089Ted Kremenek default: 150406de276fff91264437fa75111ed76de43097e089Ted Kremenek return NULL; 150506de276fff91264437fa75111ed76de43097e089Ted Kremenek } 150606de276fff91264437fa75111ed76de43097e089Ted Kremenek} 1507588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek 1508588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek//===--- CHECK: Floating-Point comparisons (-Wfloat-equal) ---------------===// 1509588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek 1510588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek/// Check for comparisons of floating point operands using != and ==. 1511588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek/// Issue a warning if these are no self-comparisons, as they are not likely 1512588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek/// to do what the programmer intended. 1513588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenekvoid Sema::CheckFloatComparison(SourceLocation loc, Expr* lex, Expr *rex) { 1514588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek bool EmitWarning = true; 15151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15164e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek Expr* LeftExprSansParen = lex->IgnoreParens(); 151732e97b66bbce16c9e81c877794fb7a0aeeb66ccbTed Kremenek Expr* RightExprSansParen = rex->IgnoreParens(); 1518588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek 1519588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek // Special case: check for x == x (which is OK). 1520588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek // Do not emit warnings for such cases. 1521588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(LeftExprSansParen)) 1522588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(RightExprSansParen)) 1523588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (DRL->getDecl() == DRR->getDecl()) 1524588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek EmitWarning = false; 15251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15271b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek // Special case: check for comparisons against literals that can be exactly 15281b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek // represented by APFloat. In such cases, do not emit a warning. This 15291b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek // is a heuristic: often comparison against such literals are used to 15301b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek // detect if a value in a variable has not changed. This clearly can 15311b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek // lead to false negatives. 15321b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek if (EmitWarning) { 15331b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek if (FloatingLiteral* FLL = dyn_cast<FloatingLiteral>(LeftExprSansParen)) { 15341b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek if (FLL->isExact()) 15351b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek EmitWarning = false; 1536ac5fc7c6bcb494b60fee7ce615ac931c5db6135eMike Stump } else 15371b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek if (FloatingLiteral* FLR = dyn_cast<FloatingLiteral>(RightExprSansParen)){ 15381b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek if (FLR->isExact()) 15391b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek EmitWarning = false; 15401b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek } 15411b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek } 15421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1543588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek // Check for comparisons with builtin types. 15440eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (EmitWarning) 1545588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (CallExpr* CL = dyn_cast<CallExpr>(LeftExprSansParen)) 15463c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor if (CL->isBuiltinCall(Context)) 1547588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek EmitWarning = false; 15481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15490eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (EmitWarning) 1550588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (CallExpr* CR = dyn_cast<CallExpr>(RightExprSansParen)) 15513c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor if (CR->isBuiltinCall(Context)) 1552588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek EmitWarning = false; 15531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1554588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek // Emit the diagnostic. 1555588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (EmitWarning) 1556fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner Diag(loc, diag::warn_floatingpoint_eq) 1557fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << lex->getSourceRange() << rex->getSourceRange(); 1558588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek} 1559ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1560f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall//===--- CHECK: Integer mixed-sign comparisons (-Wsign-compare) --------===// 1561f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall//===--- CHECK: Lossy implicit conversions (-Wconversion) --------------===// 1562ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1563f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCallnamespace { 1564ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1565f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// Structure recording the 'active' range of an integer-valued 1566f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// expression. 1567f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCallstruct IntRange { 1568f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall /// The number of bits active in the int. 1569f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall unsigned Width; 1570ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1571f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall /// True if the int is known not to have negative values. 1572f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall bool NonNegative; 157351313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1574f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange() {} 1575f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange(unsigned Width, bool NonNegative) 1576f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall : Width(Width), NonNegative(NonNegative) 1577f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall {} 157851313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1579f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Returns the range of the bool type. 1580f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall static IntRange forBoolType() { 1581f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(1, true); 1582f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall } 158351313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1584f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Returns the range of an integral type. 1585f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall static IntRange forType(ASTContext &C, QualType T) { 1586f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return forCanonicalType(C, T->getCanonicalTypeInternal().getTypePtr()); 158751313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 158851313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1589f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Returns the range of an integeral type based on its canonical 1590f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // representation. 1591f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall static IntRange forCanonicalType(ASTContext &C, const Type *T) { 1592f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall assert(T->isCanonicalUnqualified()); 159351313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1594f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (const VectorType *VT = dyn_cast<VectorType>(T)) 1595f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall T = VT->getElementType().getTypePtr(); 1596f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (const ComplexType *CT = dyn_cast<ComplexType>(T)) 1597f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall T = CT->getElementType().getTypePtr(); 1598f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (const EnumType *ET = dyn_cast<EnumType>(T)) 1599f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall T = ET->getDecl()->getIntegerType().getTypePtr(); 160051313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1601f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall const BuiltinType *BT = cast<BuiltinType>(T); 1602f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall assert(BT->isInteger()); 160351313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1604f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(C.getIntWidth(QualType(T, 0)), BT->isUnsignedInteger()); 160551313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 160651313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1607f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Returns the supremum of two ranges: i.e. their conservative merge. 1608f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall static IntRange join(const IntRange &L, const IntRange &R) { 1609f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(std::max(L.Width, R.Width), 161060fad45739b764886f707bd204eae9ecce6db1f2John McCall L.NonNegative && R.NonNegative); 161160fad45739b764886f707bd204eae9ecce6db1f2John McCall } 161260fad45739b764886f707bd204eae9ecce6db1f2John McCall 161360fad45739b764886f707bd204eae9ecce6db1f2John McCall // Returns the infinum of two ranges: i.e. their aggressive merge. 161460fad45739b764886f707bd204eae9ecce6db1f2John McCall static IntRange meet(const IntRange &L, const IntRange &R) { 161560fad45739b764886f707bd204eae9ecce6db1f2John McCall return IntRange(std::min(L.Width, R.Width), 161660fad45739b764886f707bd204eae9ecce6db1f2John McCall L.NonNegative || R.NonNegative); 161751313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 1618f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall}; 161951313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1620f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCallIntRange GetValueRange(ASTContext &C, llvm::APSInt &value, unsigned MaxWidth) { 1621f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (value.isSigned() && value.isNegative()) 1622f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(value.getMinSignedBits(), false); 162351313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1624f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (value.getBitWidth() > MaxWidth) 1625f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall value.trunc(MaxWidth); 162651313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1627f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // isNonNegative() just checks the sign bit without considering 1628f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // signedness. 1629f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(value.getActiveBits(), true); 163051313c39c84407dd6a323be99a8c322bf8d052a9John McCall} 163151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1632f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCallIntRange GetValueRange(ASTContext &C, APValue &result, 1633f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall unsigned MaxWidth) { 1634f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (result.isInt()) 1635f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return GetValueRange(C, result.getInt(), MaxWidth); 163651313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1637f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (result.isVector()) { 1638f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange R = GetValueRange(C, result.getVectorElt(0), MaxWidth); 1639f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall for (unsigned i = 1, e = result.getVectorLength(); i != e; ++i) 1640f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall R = IntRange::join(R, GetValueRange(C, result.getVectorElt(i), MaxWidth)); 1641f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return R; 164251313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 164351313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1644f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (result.isComplexInt()) { 1645f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange R = GetValueRange(C, result.getComplexIntReal(), MaxWidth); 1646f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange I = GetValueRange(C, result.getComplexIntImag(), MaxWidth); 1647f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::join(R, I); 1648f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall } 1649f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1650f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // This can happen with lossless casts to intptr_t of "based" lvalues. 1651f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Assume it might use arbitrary bits. 1652f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall assert(result.isLValue()); 1653f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(MaxWidth, false); 165451313c39c84407dd6a323be99a8c322bf8d052a9John McCall} 165551313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1656f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// Pseudo-evaluate the given integer expression, estimating the 1657f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// range of values it might take. 1658f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// 1659f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// \param MaxWidth - the width to which the value will be truncated 1660f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCallIntRange GetExprRange(ASTContext &C, Expr *E, unsigned MaxWidth) { 166151313c39c84407dd6a323be99a8c322bf8d052a9John McCall E = E->IgnoreParens(); 166251313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1663f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Try a full evaluation first. 1664f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall Expr::EvalResult result; 1665f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (E->Evaluate(result, C)) 1666f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return GetValueRange(C, result.Val, MaxWidth); 166751313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1668f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // I think we only want to look through implicit casts here; if the 1669f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // user has an explicit widening cast, we should treat the value as 1670f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // being of the new, wider type. 1671f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E)) { 1672f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (CE->getCastKind() == CastExpr::CK_NoOp) 1673f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return GetExprRange(C, CE->getSubExpr(), MaxWidth); 167451313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1675f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange OutputTypeRange = IntRange::forType(C, CE->getType()); 167651313c39c84407dd6a323be99a8c322bf8d052a9John McCall 167760fad45739b764886f707bd204eae9ecce6db1f2John McCall bool isIntegerCast = (CE->getCastKind() == CastExpr::CK_IntegralCast); 167860fad45739b764886f707bd204eae9ecce6db1f2John McCall if (!isIntegerCast && CE->getCastKind() == CastExpr::CK_Unknown) 167960fad45739b764886f707bd204eae9ecce6db1f2John McCall isIntegerCast = CE->getSubExpr()->getType()->isIntegerType(); 168060fad45739b764886f707bd204eae9ecce6db1f2John McCall 1681f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Assume that non-integer casts can span the full range of the type. 168260fad45739b764886f707bd204eae9ecce6db1f2John McCall if (!isIntegerCast) 1683f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return OutputTypeRange; 168451313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1685f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange SubRange 1686f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall = GetExprRange(C, CE->getSubExpr(), 1687f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall std::min(MaxWidth, OutputTypeRange.Width)); 168851313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1689f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Bail out if the subexpr's range is as wide as the cast type. 1690f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (SubRange.Width >= OutputTypeRange.Width) 1691f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return OutputTypeRange; 169251313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1693f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Otherwise, we take the smaller width, and we're non-negative if 1694f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // either the output type or the subexpr is. 1695f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(SubRange.Width, 1696f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall SubRange.NonNegative || OutputTypeRange.NonNegative); 1697f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall } 1698f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1699f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) { 1700f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // If we can fold the condition, just take that operand. 1701f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall bool CondResult; 1702f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (CO->getCond()->EvaluateAsBooleanCondition(CondResult, C)) 1703f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return GetExprRange(C, CondResult ? CO->getTrueExpr() 1704f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall : CO->getFalseExpr(), 1705f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall MaxWidth); 1706f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1707f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Otherwise, conservatively merge. 1708f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange L = GetExprRange(C, CO->getTrueExpr(), MaxWidth); 1709f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange R = GetExprRange(C, CO->getFalseExpr(), MaxWidth); 1710f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::join(L, R); 171151313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 171251313c39c84407dd6a323be99a8c322bf8d052a9John McCall 171351313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 171451313c39c84407dd6a323be99a8c322bf8d052a9John McCall switch (BO->getOpcode()) { 171551313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1716f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Boolean-valued operations are single-bit and positive. 171751313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::LAnd: 171851313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::LOr: 171951313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::LT: 172051313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::GT: 172151313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::LE: 172251313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::GE: 172351313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::EQ: 172451313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::NE: 1725f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::forBoolType(); 172651313c39c84407dd6a323be99a8c322bf8d052a9John McCall 172751313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Operations with opaque sources are black-listed. 172851313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::PtrMemD: 172951313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::PtrMemI: 1730f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::forType(C, E->getType()); 173151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 173260fad45739b764886f707bd204eae9ecce6db1f2John McCall // Bitwise-and uses the *infinum* of the two source ranges. 173360fad45739b764886f707bd204eae9ecce6db1f2John McCall case BinaryOperator::And: 173460fad45739b764886f707bd204eae9ecce6db1f2John McCall return IntRange::meet(GetExprRange(C, BO->getLHS(), MaxWidth), 173560fad45739b764886f707bd204eae9ecce6db1f2John McCall GetExprRange(C, BO->getRHS(), MaxWidth)); 173660fad45739b764886f707bd204eae9ecce6db1f2John McCall 173751313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Left shift gets black-listed based on a judgement call. 173851313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::Shl: 1739f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::forType(C, E->getType()); 174051313c39c84407dd6a323be99a8c322bf8d052a9John McCall 174160fad45739b764886f707bd204eae9ecce6db1f2John McCall // Right shift by a constant can narrow its left argument. 174260fad45739b764886f707bd204eae9ecce6db1f2John McCall case BinaryOperator::Shr: { 174360fad45739b764886f707bd204eae9ecce6db1f2John McCall IntRange L = GetExprRange(C, BO->getLHS(), MaxWidth); 174460fad45739b764886f707bd204eae9ecce6db1f2John McCall 174560fad45739b764886f707bd204eae9ecce6db1f2John McCall // If the shift amount is a positive constant, drop the width by 174660fad45739b764886f707bd204eae9ecce6db1f2John McCall // that much. 174760fad45739b764886f707bd204eae9ecce6db1f2John McCall llvm::APSInt shift; 174860fad45739b764886f707bd204eae9ecce6db1f2John McCall if (BO->getRHS()->isIntegerConstantExpr(shift, C) && 174960fad45739b764886f707bd204eae9ecce6db1f2John McCall shift.isNonNegative()) { 175060fad45739b764886f707bd204eae9ecce6db1f2John McCall unsigned zext = shift.getZExtValue(); 175160fad45739b764886f707bd204eae9ecce6db1f2John McCall if (zext >= L.Width) 175260fad45739b764886f707bd204eae9ecce6db1f2John McCall L.Width = (L.NonNegative ? 0 : 1); 175360fad45739b764886f707bd204eae9ecce6db1f2John McCall else 175460fad45739b764886f707bd204eae9ecce6db1f2John McCall L.Width -= zext; 175560fad45739b764886f707bd204eae9ecce6db1f2John McCall } 175660fad45739b764886f707bd204eae9ecce6db1f2John McCall 175760fad45739b764886f707bd204eae9ecce6db1f2John McCall return L; 175860fad45739b764886f707bd204eae9ecce6db1f2John McCall } 175960fad45739b764886f707bd204eae9ecce6db1f2John McCall 176060fad45739b764886f707bd204eae9ecce6db1f2John McCall // Comma acts as its right operand. 176151313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::Comma: 1762f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return GetExprRange(C, BO->getRHS(), MaxWidth); 1763f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 176460fad45739b764886f707bd204eae9ecce6db1f2John McCall // Black-list pointer subtractions. 176551313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::Sub: 176651313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (BO->getLHS()->getType()->isPointerType()) 1767f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::forType(C, E->getType()); 176851313c39c84407dd6a323be99a8c322bf8d052a9John McCall // fallthrough 176951313c39c84407dd6a323be99a8c322bf8d052a9John McCall 177051313c39c84407dd6a323be99a8c322bf8d052a9John McCall default: 1771f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall break; 177251313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 1773f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1774f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Treat every other operator as if it were closed on the 1775f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // narrowest type that encompasses both operands. 1776f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange L = GetExprRange(C, BO->getLHS(), MaxWidth); 1777f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange R = GetExprRange(C, BO->getRHS(), MaxWidth); 1778f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::join(L, R); 177951313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 178051313c39c84407dd6a323be99a8c322bf8d052a9John McCall 178151313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) { 178251313c39c84407dd6a323be99a8c322bf8d052a9John McCall switch (UO->getOpcode()) { 178351313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Boolean-valued operations are white-listed. 178451313c39c84407dd6a323be99a8c322bf8d052a9John McCall case UnaryOperator::LNot: 1785f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::forBoolType(); 178651313c39c84407dd6a323be99a8c322bf8d052a9John McCall 178751313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Operations with opaque sources are black-listed. 178851313c39c84407dd6a323be99a8c322bf8d052a9John McCall case UnaryOperator::Deref: 178951313c39c84407dd6a323be99a8c322bf8d052a9John McCall case UnaryOperator::AddrOf: // should be impossible 179051313c39c84407dd6a323be99a8c322bf8d052a9John McCall case UnaryOperator::OffsetOf: 1791f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::forType(C, E->getType()); 179251313c39c84407dd6a323be99a8c322bf8d052a9John McCall 179351313c39c84407dd6a323be99a8c322bf8d052a9John McCall default: 1794f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return GetExprRange(C, UO->getSubExpr(), MaxWidth); 179551313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 179651313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 179751313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1798f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall FieldDecl *BitField = E->getBitField(); 1799f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (BitField) { 1800f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall llvm::APSInt BitWidthAP = BitField->getBitWidth()->EvaluateAsInt(C); 1801f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall unsigned BitWidth = BitWidthAP.getZExtValue(); 180251313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1803f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(BitWidth, BitField->getType()->isUnsignedIntegerType()); 1804f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall } 1805f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1806f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::forType(C, E->getType()); 1807f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall} 1808f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1809f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// Checks whether the given value, which currently has the given 1810f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// source semantics, has the same value when coerced through the 1811f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// target semantics. 1812f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCallbool IsSameFloatAfterCast(const llvm::APFloat &value, 1813f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall const llvm::fltSemantics &Src, 1814f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall const llvm::fltSemantics &Tgt) { 1815f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall llvm::APFloat truncated = value; 1816f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1817f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall bool ignored; 1818f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall truncated.convert(Src, llvm::APFloat::rmNearestTiesToEven, &ignored); 1819f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall truncated.convert(Tgt, llvm::APFloat::rmNearestTiesToEven, &ignored); 1820f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1821f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return truncated.bitwiseIsEqual(value); 182251313c39c84407dd6a323be99a8c322bf8d052a9John McCall} 182351313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1824f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// Checks whether the given value, which currently has the given 1825f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// source semantics, has the same value when coerced through the 1826f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// target semantics. 1827f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// 1828f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// The value might be a vector of floats (or a complex number). 1829f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCallbool IsSameFloatAfterCast(const APValue &value, 1830f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall const llvm::fltSemantics &Src, 1831f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall const llvm::fltSemantics &Tgt) { 1832f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (value.isFloat()) 1833f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IsSameFloatAfterCast(value.getFloat(), Src, Tgt); 1834f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1835f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (value.isVector()) { 1836f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall for (unsigned i = 0, e = value.getVectorLength(); i != e; ++i) 1837f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (!IsSameFloatAfterCast(value.getVectorElt(i), Src, Tgt)) 1838f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return false; 1839f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return true; 1840f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall } 1841f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1842f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall assert(value.isComplexFloat()); 1843f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return (IsSameFloatAfterCast(value.getComplexFloatReal(), Src, Tgt) && 1844f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IsSameFloatAfterCast(value.getComplexFloatImag(), Src, Tgt)); 1845f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall} 1846f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1847f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall} // end anonymous namespace 1848f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1849ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall/// \brief Implements -Wsign-compare. 1850ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall/// 1851ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall/// \param lex the left-hand expression 1852ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall/// \param rex the right-hand expression 1853ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall/// \param OpLoc the location of the joining operator 1854ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall/// \param Equality whether this is an "equality-like" join, which 1855ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall/// suppresses the warning in some cases 1856ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCallvoid Sema::CheckSignCompare(Expr *lex, Expr *rex, SourceLocation OpLoc, 1857ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall const PartialDiagnostic &PD, bool Equality) { 1858ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // Don't warn if we're in an unevaluated context. 1859ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall if (ExprEvalContexts.back().Context == Unevaluated) 1860ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall return; 1861ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1862f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // If either expression is value-dependent, don't warn. We'll get another 1863f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // chance at instantiation time. 1864f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (lex->isValueDependent() || rex->isValueDependent()) 1865f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return; 1866f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1867ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall QualType lt = lex->getType(), rt = rex->getType(); 1868ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1869ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // Only warn if both operands are integral. 1870ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall if (!lt->isIntegerType() || !rt->isIntegerType()) 1871ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall return; 1872ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1873f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // In C, the width of a bitfield determines its type, and the 1874f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // declared type only contributes the signedness. This duplicates 1875f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // the work that will later be done by UsualUnaryConversions. 1876f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Eventually, this check will be reorganized in a way that avoids 1877f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // this duplication. 1878f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (!getLangOptions().CPlusPlus) { 1879f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall QualType tmp; 1880f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall tmp = Context.isPromotableBitField(lex); 1881f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (!tmp.isNull()) lt = tmp; 1882f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall tmp = Context.isPromotableBitField(rex); 1883f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (!tmp.isNull()) rt = tmp; 1884f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall } 1885ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1886ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // The rule is that the signed operand becomes unsigned, so isolate the 1887ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // signed operand. 1888f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall Expr *signedOperand = lex, *unsignedOperand = rex; 1889f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall QualType signedType = lt, unsignedType = rt; 1890ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall if (lt->isSignedIntegerType()) { 1891ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall if (rt->isSignedIntegerType()) return; 1892ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall } else { 1893ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall if (!rt->isSignedIntegerType()) return; 1894f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall std::swap(signedOperand, unsignedOperand); 1895f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall std::swap(signedType, unsignedType); 1896ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall } 1897ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1898f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall unsigned unsignedWidth = Context.getIntWidth(unsignedType); 1899f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall unsigned signedWidth = Context.getIntWidth(signedType); 1900f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1901ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // If the unsigned type is strictly smaller than the signed type, 1902ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // then (1) the result type will be signed and (2) the unsigned 1903ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // value will fit fully within the signed type, and thus the result 1904ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // of the comparison will be exact. 1905f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (signedWidth > unsignedWidth) 1906ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall return; 1907ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1908f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Otherwise, calculate the effective ranges. 1909f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange signedRange = GetExprRange(Context, signedOperand, signedWidth); 1910f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange unsignedRange = GetExprRange(Context, unsignedOperand, unsignedWidth); 1911f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1912f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // We should never be unable to prove that the unsigned operand is 1913f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // non-negative. 1914f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall assert(unsignedRange.NonNegative && "unsigned range includes negative?"); 1915f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1916f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // If the signed operand is non-negative, then the signed->unsigned 1917f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // conversion won't change it. 1918f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (signedRange.NonNegative) 1919ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall return; 1920ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1921ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // For (in)equality comparisons, if the unsigned operand is a 1922ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // constant which cannot collide with a overflowed signed operand, 1923ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // then reinterpreting the signed operand as unsigned will not 1924ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // change the result of the comparison. 1925f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (Equality && unsignedRange.Width < unsignedWidth) 1926ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall return; 1927ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1928ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall Diag(OpLoc, PD) 1929f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall << lt << rt << lex->getSourceRange() << rex->getSourceRange(); 1930ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall} 1931ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 193251313c39c84407dd6a323be99a8c322bf8d052a9John McCall/// Diagnose an implicit cast; purely a helper for CheckImplicitConversion. 193351313c39c84407dd6a323be99a8c322bf8d052a9John McCallstatic void DiagnoseImpCast(Sema &S, Expr *E, QualType T, unsigned diag) { 193451313c39c84407dd6a323be99a8c322bf8d052a9John McCall S.Diag(E->getExprLoc(), diag) << E->getType() << T << E->getSourceRange(); 193551313c39c84407dd6a323be99a8c322bf8d052a9John McCall} 193651313c39c84407dd6a323be99a8c322bf8d052a9John McCall 193751313c39c84407dd6a323be99a8c322bf8d052a9John McCall/// Implements -Wconversion. 193851313c39c84407dd6a323be99a8c322bf8d052a9John McCallvoid Sema::CheckImplicitConversion(Expr *E, QualType T) { 193951313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Don't diagnose in unevaluated contexts. 194051313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (ExprEvalContexts.back().Context == Sema::Unevaluated) 194151313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 194251313c39c84407dd6a323be99a8c322bf8d052a9John McCall 194351313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Don't diagnose for value-dependent expressions. 194451313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (E->isValueDependent()) 194551313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 194651313c39c84407dd6a323be99a8c322bf8d052a9John McCall 194751313c39c84407dd6a323be99a8c322bf8d052a9John McCall const Type *Source = Context.getCanonicalType(E->getType()).getTypePtr(); 194851313c39c84407dd6a323be99a8c322bf8d052a9John McCall const Type *Target = Context.getCanonicalType(T).getTypePtr(); 194951313c39c84407dd6a323be99a8c322bf8d052a9John McCall 195051313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Never diagnose implicit casts to bool. 195151313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (Target->isSpecificBuiltinType(BuiltinType::Bool)) 195251313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 195351313c39c84407dd6a323be99a8c322bf8d052a9John McCall 195451313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Strip vector types. 195551313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (isa<VectorType>(Source)) { 195651313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (!isa<VectorType>(Target)) 195751313c39c84407dd6a323be99a8c322bf8d052a9John McCall return DiagnoseImpCast(*this, E, T, diag::warn_impcast_vector_scalar); 195851313c39c84407dd6a323be99a8c322bf8d052a9John McCall 195951313c39c84407dd6a323be99a8c322bf8d052a9John McCall Source = cast<VectorType>(Source)->getElementType().getTypePtr(); 196051313c39c84407dd6a323be99a8c322bf8d052a9John McCall Target = cast<VectorType>(Target)->getElementType().getTypePtr(); 196151313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 196251313c39c84407dd6a323be99a8c322bf8d052a9John McCall 196351313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Strip complex types. 196451313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (isa<ComplexType>(Source)) { 196551313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (!isa<ComplexType>(Target)) 196651313c39c84407dd6a323be99a8c322bf8d052a9John McCall return DiagnoseImpCast(*this, E, T, diag::warn_impcast_complex_scalar); 196751313c39c84407dd6a323be99a8c322bf8d052a9John McCall 196851313c39c84407dd6a323be99a8c322bf8d052a9John McCall Source = cast<ComplexType>(Source)->getElementType().getTypePtr(); 196951313c39c84407dd6a323be99a8c322bf8d052a9John McCall Target = cast<ComplexType>(Target)->getElementType().getTypePtr(); 197051313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 197151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 197251313c39c84407dd6a323be99a8c322bf8d052a9John McCall const BuiltinType *SourceBT = dyn_cast<BuiltinType>(Source); 197351313c39c84407dd6a323be99a8c322bf8d052a9John McCall const BuiltinType *TargetBT = dyn_cast<BuiltinType>(Target); 197451313c39c84407dd6a323be99a8c322bf8d052a9John McCall 197551313c39c84407dd6a323be99a8c322bf8d052a9John McCall // If the source is floating point... 197651313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (SourceBT && SourceBT->isFloatingPoint()) { 197751313c39c84407dd6a323be99a8c322bf8d052a9John McCall // ...and the target is floating point... 197851313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (TargetBT && TargetBT->isFloatingPoint()) { 197951313c39c84407dd6a323be99a8c322bf8d052a9John McCall // ...then warn if we're dropping FP rank. 198051313c39c84407dd6a323be99a8c322bf8d052a9John McCall 198151313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Builtin FP kinds are ordered by increasing FP rank. 198251313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (SourceBT->getKind() > TargetBT->getKind()) { 198351313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Don't warn about float constants that are precisely 198451313c39c84407dd6a323be99a8c322bf8d052a9John McCall // representable in the target type. 198551313c39c84407dd6a323be99a8c322bf8d052a9John McCall Expr::EvalResult result; 198651313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (E->Evaluate(result, Context)) { 198751313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Value might be a float, a float vector, or a float complex. 198851313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (IsSameFloatAfterCast(result.Val, 198951313c39c84407dd6a323be99a8c322bf8d052a9John McCall Context.getFloatTypeSemantics(QualType(TargetBT, 0)), 199051313c39c84407dd6a323be99a8c322bf8d052a9John McCall Context.getFloatTypeSemantics(QualType(SourceBT, 0)))) 199151313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 199251313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 199351313c39c84407dd6a323be99a8c322bf8d052a9John McCall 199451313c39c84407dd6a323be99a8c322bf8d052a9John McCall DiagnoseImpCast(*this, E, T, diag::warn_impcast_float_precision); 199551313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 199651313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 199751313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 199851313c39c84407dd6a323be99a8c322bf8d052a9John McCall 199951313c39c84407dd6a323be99a8c322bf8d052a9John McCall // If the target is integral, always warn. 200051313c39c84407dd6a323be99a8c322bf8d052a9John McCall if ((TargetBT && TargetBT->isInteger())) 200151313c39c84407dd6a323be99a8c322bf8d052a9John McCall // TODO: don't warn for integer values? 200251313c39c84407dd6a323be99a8c322bf8d052a9John McCall return DiagnoseImpCast(*this, E, T, diag::warn_impcast_float_integer); 200351313c39c84407dd6a323be99a8c322bf8d052a9John McCall 200451313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 200551313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 200651313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2007f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (!Source->isIntegerType() || !Target->isIntegerType()) 200851313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 200951313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2010f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange SourceRange = GetExprRange(Context, E, Context.getIntWidth(E->getType())); 2011f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange TargetRange = IntRange::forCanonicalType(Context, Target); 2012f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 2013f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // FIXME: also signed<->unsigned? 201451313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2015f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (SourceRange.Width > TargetRange.Width) { 201651313c39c84407dd6a323be99a8c322bf8d052a9John McCall // People want to build with -Wshorten-64-to-32 and not -Wconversion 201751313c39c84407dd6a323be99a8c322bf8d052a9John McCall // and by god we'll let them. 2018f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (SourceRange.Width == 64 && TargetRange.Width == 32) 201951313c39c84407dd6a323be99a8c322bf8d052a9John McCall return DiagnoseImpCast(*this, E, T, diag::warn_impcast_integer_64_32); 202051313c39c84407dd6a323be99a8c322bf8d052a9John McCall return DiagnoseImpCast(*this, E, T, diag::warn_impcast_integer_precision); 202151313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 202251313c39c84407dd6a323be99a8c322bf8d052a9John McCall 202351313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 202451313c39c84407dd6a323be99a8c322bf8d052a9John McCall} 202551313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2026