SemaChecking.cpp revision 22d4fed17df02f5fa07165a69228b0b0f1a73a28
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 15e737f5041a36d0befb39ffeed8d50ba15916d3daDouglas Gregor#include "clang/Sema/Sema.h" 162d88708cbe4e4ec5e04e4acb6bd7f5be68557379John McCall#include "clang/Sema/SemaInternal.h" 17781472fe99a120098c631b0cbe33c89f8cef5e70John McCall#include "clang/Sema/ScopeInfo.h" 18826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek#include "clang/Analysis/Analyses/FormatString.h" 1959907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner#include "clang/AST/ASTContext.h" 20199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck#include "clang/AST/CharUnits.h" 21384aff8b94bb0d1ad6c5667b90621e5699815bb2John McCall#include "clang/AST/DeclCXX.h" 22c4a1dea2dc56bd1357ec91b829a0b9e68229a13eDaniel Dunbar#include "clang/AST/DeclObjC.h" 232324512285caac0332bbbc6e4cab6245d2a370a1Ted Kremenek#include "clang/AST/ExprCXX.h" 247ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek#include "clang/AST/ExprObjC.h" 25f85e193739c953358c865005855253af4f68a497John McCall#include "clang/AST/EvaluatedExprVisitor.h" 26f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump#include "clang/AST/DeclObjC.h" 27f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump#include "clang/AST/StmtCXX.h" 28f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump#include "clang/AST/StmtObjC.h" 2959907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner#include "clang/Lex/Preprocessor.h" 30f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump#include "llvm/ADT/BitVector.h" 31f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump#include "llvm/ADT/STLExtras.h" 323bfc5f49e0e37e235bb0d33bcbcb36af9d1f84abTom Care#include "llvm/Support/raw_ostream.h" 33691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher#include "clang/Basic/TargetBuiltins.h" 3426a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman#include "clang/Basic/TargetInfo.h" 357da71020b97c69b95831bd03d35e8e8404bfdea0Fariborz Jahanian#include "clang/Basic/ConvertUTF.h" 36a1f3dba77b7418575c1ff539ffa74ebaa068280cZhongxing Xu#include <limits> 3759907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattnerusing namespace clang; 38781472fe99a120098c631b0cbe33c89f8cef5e70John McCallusing namespace sema; 3959907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner 4060800081361b0ffc114877b8abbc81cb57b4edf6Chris LattnerSourceLocation Sema::getLocationOfStringLiteralByte(const StringLiteral *SL, 4160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner unsigned ByteNo) const { 4208f92e3a5dead1f1ee656678a7f06e43279d6e50Chris Lattner return SL->getLocationOfByte(ByteNo, PP.getSourceManager(), 4308f92e3a5dead1f1ee656678a7f06e43279d6e50Chris Lattner PP.getLangOptions(), PP.getTargetInfo()); 4460800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner} 4508f92e3a5dead1f1ee656678a7f06e43279d6e50Chris Lattner 4660800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner 474403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn/// CheckablePrintfAttr - does a function call have a "printf" attribute 484403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn/// and arguments that merit checking? 494403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynnbool Sema::CheckablePrintfAttr(const FormatAttr *Format, CallExpr *TheCall) { 504403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn if (Format->getType() == "printf") return true; 514403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn if (Format->getType() == "printf0") { 524403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn // printf0 allows null "format" string; if so don't check format/args 534403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn unsigned format_idx = Format->getFormatIdx() - 1; 544a2614e94672c47395abcde60518776fbebec589Sebastian Redl // Does the index refer to the implicit object argument? 554a2614e94672c47395abcde60518776fbebec589Sebastian Redl if (isa<CXXMemberCallExpr>(TheCall)) { 564a2614e94672c47395abcde60518776fbebec589Sebastian Redl if (format_idx == 0) 574a2614e94672c47395abcde60518776fbebec589Sebastian Redl return false; 584a2614e94672c47395abcde60518776fbebec589Sebastian Redl --format_idx; 594a2614e94672c47395abcde60518776fbebec589Sebastian Redl } 604403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn if (format_idx < TheCall->getNumArgs()) { 614403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn Expr *Format = TheCall->getArg(format_idx)->IgnoreParenCasts(); 62efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek if (!Format->isNullPointerConstant(Context, 63efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek Expr::NPC_ValueDependentIsNull)) 644403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn return true; 654403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn } 664403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn } 674403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn return false; 684403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn} 6960800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner 708e10f3b9cc1db43645bbc2999eb163af8997d468John McCall/// Checks that a call expression's argument count is the desired number. 718e10f3b9cc1db43645bbc2999eb163af8997d468John McCall/// This is useful when doing custom type-checking. Returns true on error. 728e10f3b9cc1db43645bbc2999eb163af8997d468John McCallstatic bool checkArgCount(Sema &S, CallExpr *call, unsigned desiredArgCount) { 738e10f3b9cc1db43645bbc2999eb163af8997d468John McCall unsigned argCount = call->getNumArgs(); 748e10f3b9cc1db43645bbc2999eb163af8997d468John McCall if (argCount == desiredArgCount) return false; 758e10f3b9cc1db43645bbc2999eb163af8997d468John McCall 768e10f3b9cc1db43645bbc2999eb163af8997d468John McCall if (argCount < desiredArgCount) 778e10f3b9cc1db43645bbc2999eb163af8997d468John McCall return S.Diag(call->getLocEnd(), diag::err_typecheck_call_too_few_args) 788e10f3b9cc1db43645bbc2999eb163af8997d468John McCall << 0 /*function call*/ << desiredArgCount << argCount 798e10f3b9cc1db43645bbc2999eb163af8997d468John McCall << call->getSourceRange(); 808e10f3b9cc1db43645bbc2999eb163af8997d468John McCall 818e10f3b9cc1db43645bbc2999eb163af8997d468John McCall // Highlight all the excess arguments. 828e10f3b9cc1db43645bbc2999eb163af8997d468John McCall SourceRange range(call->getArg(desiredArgCount)->getLocStart(), 838e10f3b9cc1db43645bbc2999eb163af8997d468John McCall call->getArg(argCount - 1)->getLocEnd()); 848e10f3b9cc1db43645bbc2999eb163af8997d468John McCall 858e10f3b9cc1db43645bbc2999eb163af8997d468John McCall return S.Diag(range.getBegin(), diag::err_typecheck_call_too_many_args) 868e10f3b9cc1db43645bbc2999eb163af8997d468John McCall << 0 /*function call*/ << desiredArgCount << argCount 878e10f3b9cc1db43645bbc2999eb163af8997d468John McCall << call->getArg(1)->getSourceRange(); 888e10f3b9cc1db43645bbc2999eb163af8997d468John McCall} 898e10f3b9cc1db43645bbc2999eb163af8997d468John McCall 9060d7b3a319d84d688752be3870615ac0f111fb16John McCallExprResult 91d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders CarlssonSema::CheckBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { 9260d7b3a319d84d688752be3870615ac0f111fb16John McCall ExprResult TheCallResult(Owned(TheCall)); 932def48394f6d48bde0dec2b514193c2b533265b5Douglas Gregor 94946928f48c96bddf3cfa126862f5ab69c2d904a0Chris Lattner // Find out if any arguments are required to be integer constant expressions. 95946928f48c96bddf3cfa126862f5ab69c2d904a0Chris Lattner unsigned ICEArguments = 0; 96946928f48c96bddf3cfa126862f5ab69c2d904a0Chris Lattner ASTContext::GetBuiltinTypeError Error; 97946928f48c96bddf3cfa126862f5ab69c2d904a0Chris Lattner Context.GetBuiltinType(BuiltinID, Error, &ICEArguments); 98946928f48c96bddf3cfa126862f5ab69c2d904a0Chris Lattner if (Error != ASTContext::GE_None) 99946928f48c96bddf3cfa126862f5ab69c2d904a0Chris Lattner ICEArguments = 0; // Don't diagnose previously diagnosed errors. 100946928f48c96bddf3cfa126862f5ab69c2d904a0Chris Lattner 101946928f48c96bddf3cfa126862f5ab69c2d904a0Chris Lattner // If any arguments are required to be ICE's, check and diagnose. 102946928f48c96bddf3cfa126862f5ab69c2d904a0Chris Lattner for (unsigned ArgNo = 0; ICEArguments != 0; ++ArgNo) { 103946928f48c96bddf3cfa126862f5ab69c2d904a0Chris Lattner // Skip arguments not required to be ICE's. 104946928f48c96bddf3cfa126862f5ab69c2d904a0Chris Lattner if ((ICEArguments & (1 << ArgNo)) == 0) continue; 105946928f48c96bddf3cfa126862f5ab69c2d904a0Chris Lattner 106946928f48c96bddf3cfa126862f5ab69c2d904a0Chris Lattner llvm::APSInt Result; 107946928f48c96bddf3cfa126862f5ab69c2d904a0Chris Lattner if (SemaBuiltinConstantArg(TheCall, ArgNo, Result)) 108946928f48c96bddf3cfa126862f5ab69c2d904a0Chris Lattner return true; 109946928f48c96bddf3cfa126862f5ab69c2d904a0Chris Lattner ICEArguments &= ~(1 << ArgNo); 110946928f48c96bddf3cfa126862f5ab69c2d904a0Chris Lattner } 111946928f48c96bddf3cfa126862f5ab69c2d904a0Chris Lattner 112d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson switch (BuiltinID) { 11330ce344307f8a8b00054021307015571f83c7364Chris Lattner case Builtin::BI__builtin___CFStringMakeConstantString: 114925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner assert(TheCall->getNumArgs() == 1 && 1151b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner "Wrong # arguments to builtin CFStringMakeConstantString"); 116690398188ea5b428f06aa13c7d4ce6eb741ad4f9Chris Lattner if (CheckObjCString(TheCall->getArg(0))) 1170eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 118d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 11949ff7a1c8c67d56e62d3b4627463b705c0d5008cTed Kremenek case Builtin::BI__builtin_stdarg_start: 12030ce344307f8a8b00054021307015571f83c7364Chris Lattner case Builtin::BI__builtin_va_start: 1210eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (SemaBuiltinVAStart(TheCall)) 1220eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 123d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 1241b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_isgreater: 1251b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_isgreaterequal: 1261b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_isless: 1271b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_islessequal: 1281b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_islessgreater: 1291b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_isunordered: 1300eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (SemaBuiltinUnorderedCompare(TheCall)) 1310eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 132d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 133e771a7ac11fb27f0e734e5de4d858f2c268895e5Benjamin Kramer case Builtin::BI__builtin_fpclassify: 134e771a7ac11fb27f0e734e5de4d858f2c268895e5Benjamin Kramer if (SemaBuiltinFPClassification(TheCall, 6)) 135e771a7ac11fb27f0e734e5de4d858f2c268895e5Benjamin Kramer return ExprError(); 136e771a7ac11fb27f0e734e5de4d858f2c268895e5Benjamin Kramer break; 1379ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman case Builtin::BI__builtin_isfinite: 1389ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman case Builtin::BI__builtin_isinf: 1399ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman case Builtin::BI__builtin_isinf_sign: 1409ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman case Builtin::BI__builtin_isnan: 1419ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman case Builtin::BI__builtin_isnormal: 1423b1e26b708e8d00d4ba10ff857201bae2aff6baeBenjamin Kramer if (SemaBuiltinFPClassification(TheCall, 1)) 1439ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman return ExprError(); 1449ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman break; 145d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman case Builtin::BI__builtin_shufflevector: 1460eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return SemaBuiltinShuffleVector(TheCall); 1470eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl // TheCall will be freed by the smart pointer here, but that's fine, since 1480eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl // SemaBuiltinShuffleVector guts it, but then doesn't release it. 1494493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar case Builtin::BI__builtin_prefetch: 1500eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (SemaBuiltinPrefetch(TheCall)) 1510eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 152d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 153d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar case Builtin::BI__builtin_object_size: 1540eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (SemaBuiltinObjectSize(TheCall)) 1550eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 156d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 157d875fed28578835de89cd407e9db4be788596d7cEli Friedman case Builtin::BI__builtin_longjmp: 158d875fed28578835de89cd407e9db4be788596d7cEli Friedman if (SemaBuiltinLongjmp(TheCall)) 159d875fed28578835de89cd407e9db4be788596d7cEli Friedman return ExprError(); 160d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 1618e10f3b9cc1db43645bbc2999eb163af8997d468John McCall 1628e10f3b9cc1db43645bbc2999eb163af8997d468John McCall case Builtin::BI__builtin_classify_type: 1638e10f3b9cc1db43645bbc2999eb163af8997d468John McCall if (checkArgCount(*this, TheCall, 1)) return true; 1648e10f3b9cc1db43645bbc2999eb163af8997d468John McCall TheCall->setType(Context.IntTy); 1658e10f3b9cc1db43645bbc2999eb163af8997d468John McCall break; 16675c29a012793292ff4578015a9113bf086156d7fChris Lattner case Builtin::BI__builtin_constant_p: 1678e10f3b9cc1db43645bbc2999eb163af8997d468John McCall if (checkArgCount(*this, TheCall, 1)) return true; 1688e10f3b9cc1db43645bbc2999eb163af8997d468John McCall TheCall->setType(Context.IntTy); 16975c29a012793292ff4578015a9113bf086156d7fChris Lattner break; 1705caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_add: 1715caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_sub: 1725caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_or: 1735caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_and: 1745caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_xor: 1755caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_add_and_fetch: 1765caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_sub_and_fetch: 1775caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_and_and_fetch: 1785caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_or_and_fetch: 1795caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_xor_and_fetch: 1805caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_val_compare_and_swap: 1815caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_bool_compare_and_swap: 1825caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_lock_test_and_set: 1835caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_lock_release: 18423aa9c8ca0bc441aab2a38a4c9fc7a1c9e9ac16aChris Lattner case Builtin::BI__sync_swap: 185d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth return SemaBuiltinAtomicOverloaded(move(TheCallResult)); 18626a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman } 18726a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman 18826a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman // Since the target specific builtins for each arch overlap, only check those 18926a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman // of the arch we are compiling for. 19026a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman if (BuiltinID >= Builtin::FirstTSBuiltin) { 19126a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman switch (Context.Target.getTriple().getArch()) { 19226a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman case llvm::Triple::arm: 19326a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman case llvm::Triple::thumb: 19426a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman if (CheckARMBuiltinFunctionCall(BuiltinID, TheCall)) 19526a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman return ExprError(); 19626a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman break; 19726a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman default: 19826a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman break; 19926a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman } 20026a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman } 20126a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman 20226a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman return move(TheCallResult); 20326a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman} 20426a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman 20561eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman// Get the valid immediate range for the specified NEON type code. 20661eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begemanstatic unsigned RFT(unsigned t, bool shift = false) { 20761eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman bool quad = t & 0x10; 20861eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman 20961eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman switch (t & 0x7) { 21061eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman case 0: // i8 211d69ec16b1b03b4a97c571ff14f15769fe13c1e5aNate Begeman return shift ? 7 : (8 << (int)quad) - 1; 21261eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman case 1: // i16 213d69ec16b1b03b4a97c571ff14f15769fe13c1e5aNate Begeman return shift ? 15 : (4 << (int)quad) - 1; 21461eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman case 2: // i32 215d69ec16b1b03b4a97c571ff14f15769fe13c1e5aNate Begeman return shift ? 31 : (2 << (int)quad) - 1; 21661eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman case 3: // i64 217d69ec16b1b03b4a97c571ff14f15769fe13c1e5aNate Begeman return shift ? 63 : (1 << (int)quad) - 1; 21861eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman case 4: // f32 21961eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman assert(!shift && "cannot shift float types!"); 220d69ec16b1b03b4a97c571ff14f15769fe13c1e5aNate Begeman return (2 << (int)quad) - 1; 22161eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman case 5: // poly8 22242499f94069c73d7a9c82da98a4245ea9fe2c526Bob Wilson return shift ? 7 : (8 << (int)quad) - 1; 22361eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman case 6: // poly16 22442499f94069c73d7a9c82da98a4245ea9fe2c526Bob Wilson return shift ? 15 : (4 << (int)quad) - 1; 22561eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman case 7: // float16 22661eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman assert(!shift && "cannot shift float types!"); 227d69ec16b1b03b4a97c571ff14f15769fe13c1e5aNate Begeman return (4 << (int)quad) - 1; 22861eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman } 22961eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman return 0; 23061eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman} 23161eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman 23226a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begemanbool Sema::CheckARMBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { 2331c2a88cfaeb11227d3a6bf7204207e0c8cf6de6fNate Begeman llvm::APSInt Result; 2341c2a88cfaeb11227d3a6bf7204207e0c8cf6de6fNate Begeman 2350d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman unsigned mask = 0; 23661eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman unsigned TV = 0; 2371c2a88cfaeb11227d3a6bf7204207e0c8cf6de6fNate Begeman switch (BuiltinID) { 238a23326b5c244a03bf61ebb86db60a777ea26f926Nate Begeman#define GET_NEON_OVERLOAD_CHECK 239a23326b5c244a03bf61ebb86db60a777ea26f926Nate Begeman#include "clang/Basic/arm_neon.inc" 240a23326b5c244a03bf61ebb86db60a777ea26f926Nate Begeman#undef GET_NEON_OVERLOAD_CHECK 2411c2a88cfaeb11227d3a6bf7204207e0c8cf6de6fNate Begeman } 2421c2a88cfaeb11227d3a6bf7204207e0c8cf6de6fNate Begeman 2430d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman // For NEON intrinsics which are overloaded on vector element type, validate 2440d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman // the immediate which specifies which variant to emit. 2450d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman if (mask) { 2460d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman unsigned ArgNo = TheCall->getNumArgs()-1; 2470d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman if (SemaBuiltinConstantArg(TheCall, ArgNo, Result)) 2480d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman return true; 2490d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman 25061eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman TV = Result.getLimitedValue(32); 25161eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman if ((TV > 31) || (mask & (1 << TV)) == 0) 2520d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman return Diag(TheCall->getLocStart(), diag::err_invalid_neon_type_code) 2530d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman << TheCall->getArg(ArgNo)->getSourceRange(); 2540d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman } 2551c2a88cfaeb11227d3a6bf7204207e0c8cf6de6fNate Begeman 2560d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman // For NEON intrinsics which take an immediate value as part of the 2570d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman // instruction, range check them here. 25861eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman unsigned i = 0, l = 0, u = 0; 2590d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman switch (BuiltinID) { 2600d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman default: return false; 261bb37f50c2d0d72e1fa5b349d5f6a11fdc5acb86eNate Begeman case ARM::BI__builtin_arm_ssat: i = 1; l = 1; u = 31; break; 262bb37f50c2d0d72e1fa5b349d5f6a11fdc5acb86eNate Begeman case ARM::BI__builtin_arm_usat: i = 1; u = 31; break; 26399c40bb13b523d58d7aeb6446e4f486d6918ca58Nate Begeman case ARM::BI__builtin_arm_vcvtr_f: 26499c40bb13b523d58d7aeb6446e4f486d6918ca58Nate Begeman case ARM::BI__builtin_arm_vcvtr_d: i = 1; u = 1; break; 265a23326b5c244a03bf61ebb86db60a777ea26f926Nate Begeman#define GET_NEON_IMMEDIATE_CHECK 266a23326b5c244a03bf61ebb86db60a777ea26f926Nate Begeman#include "clang/Basic/arm_neon.inc" 267a23326b5c244a03bf61ebb86db60a777ea26f926Nate Begeman#undef GET_NEON_IMMEDIATE_CHECK 2680d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman }; 2690d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman 27061eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman // Check that the immediate argument is actually a constant. 2710d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman if (SemaBuiltinConstantArg(TheCall, i, Result)) 2720d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman return true; 2730d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman 27461eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman // Range check against the upper/lower values for this isntruction. 2750d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman unsigned Val = Result.getZExtValue(); 27661eecf5aea018ea65c9ab0bccacd2996b15c632dNate Begeman if (Val < l || Val > (u + l)) 2770d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range) 278476d8b863cb65b2b5833235d97315cdb46e6f5aaBenjamin Kramer << l << u+l << TheCall->getArg(i)->getSourceRange(); 2790d15c5321a11a5fee53b17ca8e9e0d72d6192b23Nate Begeman 28099c40bb13b523d58d7aeb6446e4f486d6918ca58Nate Begeman // FIXME: VFP Intrinsics should error if VFP not present. 28126a31428f130b66f61834d1b4d1cf72f590f70b9Nate Begeman return false; 282d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson} 283d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson 284d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson/// CheckFunctionCall - Check a direct function call for various correctness 285d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson/// and safety properties not strictly enforced by the C type system. 286d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlssonbool Sema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall) { 287d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson // Get the IdentifierInfo* for the called function. 288d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson IdentifierInfo *FnInfo = FDecl->getIdentifier(); 289de45428f923b38d80407dbb9ede0df504256f9f6Daniel Dunbar 290d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson // None of the checks below are needed for functions that don't have 291d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson // simple names (e.g., C++ conversion functions). 292d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson if (!FnInfo) 293d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 2941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 295de45428f923b38d80407dbb9ede0df504256f9f6Daniel Dunbar // FIXME: This mechanism should be abstracted to be less fragile and 296de45428f923b38d80407dbb9ede0df504256f9f6Daniel Dunbar // more efficient. For example, just map function ids to custom 297de45428f923b38d80407dbb9ede0df504256f9f6Daniel Dunbar // handlers. 298de45428f923b38d80407dbb9ede0df504256f9f6Daniel Dunbar 299c82faca0be59b072b38bed375e21bd24f1f72647Ted Kremenek // Printf and scanf checking. 300c82faca0be59b072b38bed375e21bd24f1f72647Ted Kremenek for (specific_attr_iterator<FormatAttr> 301c82faca0be59b072b38bed375e21bd24f1f72647Ted Kremenek i = FDecl->specific_attr_begin<FormatAttr>(), 302c82faca0be59b072b38bed375e21bd24f1f72647Ted Kremenek e = FDecl->specific_attr_end<FormatAttr>(); i != e ; ++i) { 303c82faca0be59b072b38bed375e21bd24f1f72647Ted Kremenek 304c82faca0be59b072b38bed375e21bd24f1f72647Ted Kremenek const FormatAttr *Format = *i; 305826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const bool b = Format->getType() == "scanf"; 306826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek if (b || CheckablePrintfAttr(Format, TheCall)) { 3073d692df4b9c58895f9843b03543ec57447c93679Ted Kremenek bool HasVAListArg = Format->getFirstArg() == 0; 308826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek CheckPrintfScanfArguments(TheCall, HasVAListArg, 309826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek Format->getFormatIdx() - 1, 310826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek HasVAListArg ? 0 : Format->getFirstArg() - 1, 311826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek !b); 3123c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor } 31359907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner } 3141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 315c82faca0be59b072b38bed375e21bd24f1f72647Ted Kremenek for (specific_attr_iterator<NonNullAttr> 316c82faca0be59b072b38bed375e21bd24f1f72647Ted Kremenek i = FDecl->specific_attr_begin<NonNullAttr>(), 317c82faca0be59b072b38bed375e21bd24f1f72647Ted Kremenek e = FDecl->specific_attr_end<NonNullAttr>(); i != e; ++i) { 318909a70d8a185f701c20bacc3c76f8f5979cbbc7cNick Lewycky CheckNonNullArguments(*i, TheCall->getArgs(), 319909a70d8a185f701c20bacc3c76f8f5979cbbc7cNick Lewycky TheCall->getCallee()->getLocStart()); 320c82faca0be59b072b38bed375e21bd24f1f72647Ted Kremenek } 3210eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl 322cc2f30c4ed7770b6005bd55b529a55c1fcc250fcMatt Beaumont-Gay // Memset/memcpy/memmove/memcmp handling 323707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor int CMF = -1; 324707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor switch (FDecl->getBuiltinID()) { 325707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor case Builtin::BI__builtin_memset: 326707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor case Builtin::BI__builtin___memset_chk: 327707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor case Builtin::BImemset: 328707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor CMF = CMF_Memset; 329707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor break; 330707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor 331707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor case Builtin::BI__builtin_memcpy: 332707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor case Builtin::BI__builtin___memcpy_chk: 333707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor case Builtin::BImemcpy: 334707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor CMF = CMF_Memcpy; 335707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor break; 336707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor 337707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor case Builtin::BI__builtin_memmove: 338707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor case Builtin::BI__builtin___memmove_chk: 339707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor case Builtin::BImemmove: 340707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor CMF = CMF_Memmove; 341707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor break; 342707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor 343cc2f30c4ed7770b6005bd55b529a55c1fcc250fcMatt Beaumont-Gay case Builtin::BI__builtin_memcmp: 344cc2f30c4ed7770b6005bd55b529a55c1fcc250fcMatt Beaumont-Gay CMF = CMF_Memcmp; 345cc2f30c4ed7770b6005bd55b529a55c1fcc250fcMatt Beaumont-Gay break; 346cc2f30c4ed7770b6005bd55b529a55c1fcc250fcMatt Beaumont-Gay 347707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor default: 348707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor if (FDecl->getLinkage() == ExternalLinkage && 349707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor (!getLangOptions().CPlusPlus || FDecl->isExternC())) { 350707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor if (FnInfo->isStr("memset")) 351707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor CMF = CMF_Memset; 352707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor else if (FnInfo->isStr("memcpy")) 353707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor CMF = CMF_Memcpy; 354707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor else if (FnInfo->isStr("memmove")) 355707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor CMF = CMF_Memmove; 356cc2f30c4ed7770b6005bd55b529a55c1fcc250fcMatt Beaumont-Gay else if (FnInfo->isStr("memcmp")) 357cc2f30c4ed7770b6005bd55b529a55c1fcc250fcMatt Beaumont-Gay CMF = CMF_Memcmp; 358707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor } 359707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor break; 36006bc9eb9908e42696775b395b290827bde468c8bDouglas Gregor } 361707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor 362707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor if (CMF != -1) 363cc2f30c4ed7770b6005bd55b529a55c1fcc250fcMatt Beaumont-Gay CheckMemaccessArguments(TheCall, CheckedMemoryFunction(CMF), FnInfo); 3647ccc95bceebb2d1c8fbe277c9e33bde7dc1ccbb1Chandler Carruth 365d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 36671993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson} 36771993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson 368d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlssonbool Sema::CheckBlockCall(NamedDecl *NDecl, CallExpr *TheCall) { 369725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian // Printf checking. 37040b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis const FormatAttr *Format = NDecl->getAttr<FormatAttr>(); 371725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian if (!Format) 372d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 3731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 374725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian const VarDecl *V = dyn_cast<VarDecl>(NDecl); 375725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian if (!V) 376d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 3771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 378725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian QualType Ty = V->getType(); 379725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian if (!Ty->isBlockPointerType()) 380d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 3811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 382826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const bool b = Format->getType() == "scanf"; 383826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek if (!b && !CheckablePrintfAttr(Format, TheCall)) 384d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 3851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 386d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson bool HasVAListArg = Format->getFirstArg() == 0; 387826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek CheckPrintfScanfArguments(TheCall, HasVAListArg, Format->getFormatIdx() - 1, 388826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek HasVAListArg ? 0 : Format->getFirstArg() - 1, !b); 389d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson 390d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 391725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian} 392725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian 3935caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// SemaBuiltinAtomicOverloaded - We have a call to a function like 3945caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// __sync_fetch_and_add, which is an overloaded function based on the pointer 3955caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// type of its first argument. The main ActOnCallExpr routines have already 3965caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// promoted the types of arguments because all of these calls are prototyped as 3975caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// void(...). 3985caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// 3995caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// This function goes through and does final semantic checking for these 4005caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// builtins, 40160d7b3a319d84d688752be3870615ac0f111fb16John McCallExprResult 40260d7b3a319d84d688752be3870615ac0f111fb16John McCallSema::SemaBuiltinAtomicOverloaded(ExprResult TheCallResult) { 403d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth CallExpr *TheCall = (CallExpr *)TheCallResult.get(); 4045caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts()); 4055caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner FunctionDecl *FDecl = cast<FunctionDecl>(DRE->getDecl()); 4065caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 4075caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Ensure that we have at least one argument to do type inference from. 408d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth if (TheCall->getNumArgs() < 1) { 409d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args_at_least) 410d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth << 0 << 1 << TheCall->getNumArgs() 411d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth << TheCall->getCallee()->getSourceRange(); 412d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth return ExprError(); 413d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth } 4141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4155caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Inspect the first argument of the atomic builtin. This should always be 4165caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // a pointer type, whose element is an integral scalar or pointer type. 4175caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Because it is a pointer type, we don't have to worry about any implicit 4185caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // casts here. 419d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth // FIXME: We don't allow floating point scalars as input. 4205caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner Expr *FirstArg = TheCall->getArg(0); 421f85e193739c953358c865005855253af4f68a497John McCall const PointerType *pointerType = FirstArg->getType()->getAs<PointerType>(); 422f85e193739c953358c865005855253af4f68a497John McCall if (!pointerType) { 423d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth Diag(DRE->getLocStart(), diag::err_atomic_builtin_must_be_pointer) 424d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth << FirstArg->getType() << FirstArg->getSourceRange(); 425d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth return ExprError(); 426d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth } 4271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 428f85e193739c953358c865005855253af4f68a497John McCall QualType ValType = pointerType->getPointeeType(); 429dd5fa7a21ca9db9d620001ca977681a1b724e3feChris Lattner if (!ValType->isIntegerType() && !ValType->isAnyPointerType() && 430d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth !ValType->isBlockPointerType()) { 431d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth Diag(DRE->getLocStart(), diag::err_atomic_builtin_must_be_pointer_intptr) 432d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth << FirstArg->getType() << FirstArg->getSourceRange(); 433d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth return ExprError(); 434d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth } 4355caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 436f85e193739c953358c865005855253af4f68a497John McCall switch (ValType.getObjCLifetime()) { 437f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_None: 438f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_ExplicitNone: 439f85e193739c953358c865005855253af4f68a497John McCall // okay 440f85e193739c953358c865005855253af4f68a497John McCall break; 441f85e193739c953358c865005855253af4f68a497John McCall 442f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_Weak: 443f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_Strong: 444f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_Autoreleasing: 445b8b0313e84700b5c6d597b3be4de41c97b7550f1Argyrios Kyrtzidis Diag(DRE->getLocStart(), diag::err_arc_atomic_ownership) 446f85e193739c953358c865005855253af4f68a497John McCall << ValType << FirstArg->getSourceRange(); 447f85e193739c953358c865005855253af4f68a497John McCall return ExprError(); 448f85e193739c953358c865005855253af4f68a497John McCall } 449f85e193739c953358c865005855253af4f68a497John McCall 4508d13d221cf7c1657404c611efaadf3ac19d899b3Chandler Carruth // The majority of builtins return a value, but a few have special return 4518d13d221cf7c1657404c611efaadf3ac19d899b3Chandler Carruth // types, so allow them to override appropriately below. 4528d13d221cf7c1657404c611efaadf3ac19d899b3Chandler Carruth QualType ResultType = ValType; 4538d13d221cf7c1657404c611efaadf3ac19d899b3Chandler Carruth 4545caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // We need to figure out which concrete builtin this maps onto. For example, 4555caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // __sync_fetch_and_add with a 2 byte object turns into 4565caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // __sync_fetch_and_add_2. 4575caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner#define BUILTIN_ROW(x) \ 4585caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner { Builtin::BI##x##_1, Builtin::BI##x##_2, Builtin::BI##x##_4, \ 4595caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner Builtin::BI##x##_8, Builtin::BI##x##_16 } 4601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4615caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner static const unsigned BuiltinIndices[][5] = { 4625caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_fetch_and_add), 4635caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_fetch_and_sub), 4645caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_fetch_and_or), 4655caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_fetch_and_and), 4665caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_fetch_and_xor), 4671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4685caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_add_and_fetch), 4695caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_sub_and_fetch), 4705caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_and_and_fetch), 4715caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_or_and_fetch), 4725caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_xor_and_fetch), 4731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4745caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_val_compare_and_swap), 4755caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_bool_compare_and_swap), 4765caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_lock_test_and_set), 47723aa9c8ca0bc441aab2a38a4c9fc7a1c9e9ac16aChris Lattner BUILTIN_ROW(__sync_lock_release), 47823aa9c8ca0bc441aab2a38a4c9fc7a1c9e9ac16aChris Lattner BUILTIN_ROW(__sync_swap) 4795caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner }; 4801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump#undef BUILTIN_ROW 4811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4825caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Determine the index of the size. 4835caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner unsigned SizeIndex; 484199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck switch (Context.getTypeSizeInChars(ValType).getQuantity()) { 4855caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case 1: SizeIndex = 0; break; 4865caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case 2: SizeIndex = 1; break; 4875caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case 4: SizeIndex = 2; break; 4885caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case 8: SizeIndex = 3; break; 4895caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case 16: SizeIndex = 4; break; 4905caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner default: 491d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth Diag(DRE->getLocStart(), diag::err_atomic_builtin_pointer_size) 492d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth << FirstArg->getType() << FirstArg->getSourceRange(); 493d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth return ExprError(); 4945caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner } 4951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4965caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Each of these builtins has one pointer argument, followed by some number of 4975caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // values (0, 1 or 2) followed by a potentially empty varags list of stuff 4985caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // that we ignore. Find out which row of BuiltinIndices to read from as well 4995caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // as the number of fixed args. 5007814e6d6645d587891293d59ecf6576defcfac92Douglas Gregor unsigned BuiltinID = FDecl->getBuiltinID(); 5015caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner unsigned BuiltinIndex, NumFixed = 1; 5025caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner switch (BuiltinID) { 5035caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner default: assert(0 && "Unknown overloaded atomic builtin!"); 5045caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_add: BuiltinIndex = 0; break; 5055caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_sub: BuiltinIndex = 1; break; 5065caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_or: BuiltinIndex = 2; break; 5075caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_and: BuiltinIndex = 3; break; 5085caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_xor: BuiltinIndex = 4; break; 5091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5107eff7c4153faf45b19b5919ef409ee5f6794eb25Daniel Dunbar case Builtin::BI__sync_add_and_fetch: BuiltinIndex = 5; break; 5117eff7c4153faf45b19b5919ef409ee5f6794eb25Daniel Dunbar case Builtin::BI__sync_sub_and_fetch: BuiltinIndex = 6; break; 5127eff7c4153faf45b19b5919ef409ee5f6794eb25Daniel Dunbar case Builtin::BI__sync_and_and_fetch: BuiltinIndex = 7; break; 5137eff7c4153faf45b19b5919ef409ee5f6794eb25Daniel Dunbar case Builtin::BI__sync_or_and_fetch: BuiltinIndex = 8; break; 5147eff7c4153faf45b19b5919ef409ee5f6794eb25Daniel Dunbar case Builtin::BI__sync_xor_and_fetch: BuiltinIndex = 9; break; 5151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5165caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_val_compare_and_swap: 5177eff7c4153faf45b19b5919ef409ee5f6794eb25Daniel Dunbar BuiltinIndex = 10; 5185caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner NumFixed = 2; 5195caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner break; 5205caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_bool_compare_and_swap: 5217eff7c4153faf45b19b5919ef409ee5f6794eb25Daniel Dunbar BuiltinIndex = 11; 5225caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner NumFixed = 2; 5238d13d221cf7c1657404c611efaadf3ac19d899b3Chandler Carruth ResultType = Context.BoolTy; 5245caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner break; 5257eff7c4153faf45b19b5919ef409ee5f6794eb25Daniel Dunbar case Builtin::BI__sync_lock_test_and_set: BuiltinIndex = 12; break; 5265caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_lock_release: 5277eff7c4153faf45b19b5919ef409ee5f6794eb25Daniel Dunbar BuiltinIndex = 13; 5285caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner NumFixed = 0; 5298d13d221cf7c1657404c611efaadf3ac19d899b3Chandler Carruth ResultType = Context.VoidTy; 5305caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner break; 53123aa9c8ca0bc441aab2a38a4c9fc7a1c9e9ac16aChris Lattner case Builtin::BI__sync_swap: BuiltinIndex = 14; break; 5325caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner } 5331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5345caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Now that we know how many fixed arguments we expect, first check that we 5355caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // have at least that many. 536d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth if (TheCall->getNumArgs() < 1+NumFixed) { 537d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args_at_least) 538d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth << 0 << 1+NumFixed << TheCall->getNumArgs() 539d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth << TheCall->getCallee()->getSourceRange(); 540d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth return ExprError(); 541d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth } 5421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 543e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner // Get the decl for the concrete builtin from this, we can tell what the 544e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner // concrete integer type we should convert to is. 545e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner unsigned NewBuiltinID = BuiltinIndices[BuiltinIndex][SizeIndex]; 546e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner const char *NewBuiltinName = Context.BuiltinInfo.GetName(NewBuiltinID); 547e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner IdentifierInfo *NewBuiltinII = PP.getIdentifierInfo(NewBuiltinName); 5481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump FunctionDecl *NewBuiltinDecl = 549e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner cast<FunctionDecl>(LazilyCreateBuiltin(NewBuiltinII, NewBuiltinID, 550e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner TUScope, false, DRE->getLocStart())); 551d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth 552f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall // The first argument --- the pointer --- has a fixed type; we 553f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall // deduce the types of the rest of the arguments accordingly. Walk 554f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall // the remaining arguments, converting them to the deduced value type. 5555caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner for (unsigned i = 0; i != NumFixed; ++i) { 556429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley ExprResult Arg = TheCall->getArg(i+1); 5571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5585caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // If the argument is an implicit cast, then there was a promotion due to 5595caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // "...", just remove it now. 560429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg.get())) { 5615caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner Arg = ICE->getSubExpr(); 5625caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner ICE->setSubExpr(0); 563429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley TheCall->setArg(i+1, Arg.get()); 5645caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner } 5651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5665caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // GCC does an implicit conversion to the pointer or integer ValType. This 5675caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // can fail in some cases (1i -> int**), check for this error case now. 568daa8e4e888758d55a7a759dd4a91b83921cef222John McCall CastKind Kind = CK_Invalid; 569f89e55ab1bfb3ea997f8b02997c611a02254eb2dJohn McCall ExprValueKind VK = VK_RValue; 570f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall CXXCastPath BasePath; 571f85e193739c953358c865005855253af4f68a497John McCall Arg = CheckCastTypes(Arg.get()->getLocStart(), Arg.get()->getSourceRange(), 572f85e193739c953358c865005855253af4f68a497John McCall ValType, Arg.take(), Kind, VK, BasePath); 573429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley if (Arg.isInvalid()) 574d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth return ExprError(); 5751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5765caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Okay, we have something that *can* be converted to the right type. Check 5775caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // to see if there is a potentially weird extension going on here. This can 5785caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // happen when you do an atomic operation on something like an char* and 5795caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // pass in 42. The 42 gets converted to char. This is even more strange 5805caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // for things like 45.123 -> char, etc. 5811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // FIXME: Do this check. 582429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley Arg = ImpCastExprToType(Arg.take(), ValType, Kind, VK, &BasePath); 583429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley TheCall->setArg(i+1, Arg.get()); 5845caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner } 5851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5865caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Switch the DeclRefExpr to refer to the new decl. 5875caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner DRE->setDecl(NewBuiltinDecl); 5885caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner DRE->setType(NewBuiltinDecl->getType()); 5891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5905caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Set the callee in the CallExpr. 5915caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // FIXME: This leaks the original parens and implicit casts. 592429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley ExprResult PromotedCall = UsualUnaryConversions(DRE); 593429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley if (PromotedCall.isInvalid()) 594429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley return ExprError(); 595429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley TheCall->setCallee(PromotedCall.take()); 5961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 597db4325b098eff5e9e660db19f0148423fb21f27fChandler Carruth // Change the result type of the call to match the original value type. This 598db4325b098eff5e9e660db19f0148423fb21f27fChandler Carruth // is arbitrary, but the codegen for these builtins ins design to handle it 599db4325b098eff5e9e660db19f0148423fb21f27fChandler Carruth // gracefully. 6008d13d221cf7c1657404c611efaadf3ac19d899b3Chandler Carruth TheCall->setType(ResultType); 601d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth 602d201457cc781f1b13d0f4b1268ff934e6004cbffChandler Carruth return move(TheCallResult); 6035caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner} 6045caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 6055caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 606690398188ea5b428f06aa13c7d4ce6eb741ad4f9Chris Lattner/// CheckObjCString - Checks that the argument to the builtin 60771993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson/// CFString constructor is correct 608fd942628abfe30e30427875db953222ae99b4325Steve Naroff/// Note: It might also make sense to do the UTF-16 conversion here (would 609fd942628abfe30e30427875db953222ae99b4325Steve Naroff/// simplify the backend). 610690398188ea5b428f06aa13c7d4ce6eb741ad4f9Chris Lattnerbool Sema::CheckObjCString(Expr *Arg) { 61156f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner Arg = Arg->IgnoreParenCasts(); 61271993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson StringLiteral *Literal = dyn_cast<StringLiteral>(Arg); 61371993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson 6145cee1195584fa8672253139c86e922daeda69b9eDouglas Gregor if (!Literal || !Literal->isAscii()) { 615fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner Diag(Arg->getLocStart(), diag::err_cfstring_literal_not_string_constant) 616fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << Arg->getSourceRange(); 6179cdc4d3834f203dcde3ff274b8928e4620a914d5Anders Carlsson return true; 61871993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson } 6191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6207da71020b97c69b95831bd03d35e8e8404bfdea0Fariborz Jahanian if (Literal->containsNonAsciiOrNull()) { 6215f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner StringRef String = Literal->getString(); 6227da71020b97c69b95831bd03d35e8e8404bfdea0Fariborz Jahanian unsigned NumBytes = String.size(); 6235f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<UTF16, 128> ToBuf(NumBytes); 6247da71020b97c69b95831bd03d35e8e8404bfdea0Fariborz Jahanian const UTF8 *FromPtr = (UTF8 *)String.data(); 6257da71020b97c69b95831bd03d35e8e8404bfdea0Fariborz Jahanian UTF16 *ToPtr = &ToBuf[0]; 6267da71020b97c69b95831bd03d35e8e8404bfdea0Fariborz Jahanian 6277da71020b97c69b95831bd03d35e8e8404bfdea0Fariborz Jahanian ConversionResult Result = ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, 6287da71020b97c69b95831bd03d35e8e8404bfdea0Fariborz Jahanian &ToPtr, ToPtr + NumBytes, 6297da71020b97c69b95831bd03d35e8e8404bfdea0Fariborz Jahanian strictConversion); 6307da71020b97c69b95831bd03d35e8e8404bfdea0Fariborz Jahanian // Check for conversion failure. 6317da71020b97c69b95831bd03d35e8e8404bfdea0Fariborz Jahanian if (Result != conversionOK) 6327da71020b97c69b95831bd03d35e8e8404bfdea0Fariborz Jahanian Diag(Arg->getLocStart(), 6337da71020b97c69b95831bd03d35e8e8404bfdea0Fariborz Jahanian diag::warn_cfstring_truncated) << Arg->getSourceRange(); 6347da71020b97c69b95831bd03d35e8e8404bfdea0Fariborz Jahanian } 6359cdc4d3834f203dcde3ff274b8928e4620a914d5Anders Carlsson return false; 63659907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner} 63759907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner 638c27c665c88b49dfb212aedc7bab8b9bf67658b9eChris Lattner/// SemaBuiltinVAStart - Check the arguments to __builtin_va_start for validity. 639c27c665c88b49dfb212aedc7bab8b9bf67658b9eChris Lattner/// Emit an error and return true on failure, return false on success. 640925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattnerbool Sema::SemaBuiltinVAStart(CallExpr *TheCall) { 641925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner Expr *Fn = TheCall->getCallee(); 642925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner if (TheCall->getNumArgs() > 2) { 6432c21a073525cdfa68e4439b7af551385dc2796abChris Lattner Diag(TheCall->getArg(2)->getLocStart(), 644fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner diag::err_typecheck_call_too_many_args) 645ccfa9639f8d09733bcf1c2572c5bd3daba5bd632Eric Christopher << 0 /*function call*/ << 2 << TheCall->getNumArgs() 646ccfa9639f8d09733bcf1c2572c5bd3daba5bd632Eric Christopher << Fn->getSourceRange() 6471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump << SourceRange(TheCall->getArg(2)->getLocStart(), 648fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner (*(TheCall->arg_end()-1))->getLocEnd()); 64930ce344307f8a8b00054021307015571f83c7364Chris Lattner return true; 65030ce344307f8a8b00054021307015571f83c7364Chris Lattner } 65156f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman 65256f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman if (TheCall->getNumArgs() < 2) { 653d77b9a29651d748f0e30a8dad8969635fc04f725Eric Christopher return Diag(TheCall->getLocEnd(), 654d77b9a29651d748f0e30a8dad8969635fc04f725Eric Christopher diag::err_typecheck_call_too_few_args_at_least) 655d77b9a29651d748f0e30a8dad8969635fc04f725Eric Christopher << 0 /*function call*/ << 2 << TheCall->getNumArgs(); 65656f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman } 65756f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman 658c27c665c88b49dfb212aedc7bab8b9bf67658b9eChris Lattner // Determine whether the current function is variadic or not. 6599ea9bdbc14374f7bacdb50d3e52c664ff12150ffDouglas Gregor BlockScopeInfo *CurBlock = getCurBlock(); 660c27c665c88b49dfb212aedc7bab8b9bf67658b9eChris Lattner bool isVariadic; 661cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff if (CurBlock) 662c71a4915ca216847599d03cab4ed1c5086b0eb43John McCall isVariadic = CurBlock->TheDecl->isVariadic(); 6639498d388810d284d3970aef0d69fa4d069fd6cafTed Kremenek else if (FunctionDecl *FD = getCurFunctionDecl()) 6649498d388810d284d3970aef0d69fa4d069fd6cafTed Kremenek isVariadic = FD->isVariadic(); 6659498d388810d284d3970aef0d69fa4d069fd6cafTed Kremenek else 66653d0ea5f5bfa647ec23418bf3a3b7c183b51e4bdArgyrios Kyrtzidis isVariadic = getCurMethodDecl()->isVariadic(); 6671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 668c27c665c88b49dfb212aedc7bab8b9bf67658b9eChris Lattner if (!isVariadic) { 66930ce344307f8a8b00054021307015571f83c7364Chris Lattner Diag(Fn->getLocStart(), diag::err_va_start_used_in_non_variadic_function); 67030ce344307f8a8b00054021307015571f83c7364Chris Lattner return true; 67130ce344307f8a8b00054021307015571f83c7364Chris Lattner } 6721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 67330ce344307f8a8b00054021307015571f83c7364Chris Lattner // Verify that the second argument to the builtin is the last argument of the 67430ce344307f8a8b00054021307015571f83c7364Chris Lattner // current function or method. 67530ce344307f8a8b00054021307015571f83c7364Chris Lattner bool SecondArgIsLastNamedArgument = false; 676e2c14103dec39cbd24dac9d7b3e91277b109c14fAnders Carlsson const Expr *Arg = TheCall->getArg(1)->IgnoreParenCasts(); 6771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 67888cf226caee50956ef47edd4d44cf7b80703a26cAnders Carlsson if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Arg)) { 67988cf226caee50956ef47edd4d44cf7b80703a26cAnders Carlsson if (const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(DR->getDecl())) { 68030ce344307f8a8b00054021307015571f83c7364Chris Lattner // FIXME: This isn't correct for methods (results in bogus warning). 68130ce344307f8a8b00054021307015571f83c7364Chris Lattner // Get the last formal in the current function. 68288cf226caee50956ef47edd4d44cf7b80703a26cAnders Carlsson const ParmVarDecl *LastArg; 683cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff if (CurBlock) 684cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff LastArg = *(CurBlock->TheDecl->param_end()-1); 685cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff else if (FunctionDecl *FD = getCurFunctionDecl()) 686371f258e61e1365b951b17931a3c5ac1530fd1a0Chris Lattner LastArg = *(FD->param_end()-1); 68730ce344307f8a8b00054021307015571f83c7364Chris Lattner else 68853d0ea5f5bfa647ec23418bf3a3b7c183b51e4bdArgyrios Kyrtzidis LastArg = *(getCurMethodDecl()->param_end()-1); 68930ce344307f8a8b00054021307015571f83c7364Chris Lattner SecondArgIsLastNamedArgument = PV == LastArg; 69030ce344307f8a8b00054021307015571f83c7364Chris Lattner } 69130ce344307f8a8b00054021307015571f83c7364Chris Lattner } 6921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 69330ce344307f8a8b00054021307015571f83c7364Chris Lattner if (!SecondArgIsLastNamedArgument) 6941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Diag(TheCall->getArg(1)->getLocStart(), 69530ce344307f8a8b00054021307015571f83c7364Chris Lattner diag::warn_second_parameter_of_va_start_not_last_named_argument); 69630ce344307f8a8b00054021307015571f83c7364Chris Lattner return false; 6976cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman} 69830ce344307f8a8b00054021307015571f83c7364Chris Lattner 6991b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner/// SemaBuiltinUnorderedCompare - Handle functions like __builtin_isgreater and 7001b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner/// friends. This is declared to take (...), so we have to check everything. 701925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattnerbool Sema::SemaBuiltinUnorderedCompare(CallExpr *TheCall) { 702925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner if (TheCall->getNumArgs() < 2) 7032c21a073525cdfa68e4439b7af551385dc2796abChris Lattner return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args) 704d77b9a29651d748f0e30a8dad8969635fc04f725Eric Christopher << 0 << 2 << TheCall->getNumArgs()/*function call*/; 705925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner if (TheCall->getNumArgs() > 2) 7061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Diag(TheCall->getArg(2)->getLocStart(), 707fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner diag::err_typecheck_call_too_many_args) 708ccfa9639f8d09733bcf1c2572c5bd3daba5bd632Eric Christopher << 0 /*function call*/ << 2 << TheCall->getNumArgs() 709fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << SourceRange(TheCall->getArg(2)->getLocStart(), 710fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner (*(TheCall->arg_end()-1))->getLocEnd()); 7111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 712429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley ExprResult OrigArg0 = TheCall->getArg(0); 713429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley ExprResult OrigArg1 = TheCall->getArg(1); 714cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 7151b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner // Do standard promotions between the two arguments, returning their common 7161b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner // type. 717925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner QualType Res = UsualArithmeticConversions(OrigArg0, OrigArg1, false); 718429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley if (OrigArg0.isInvalid() || OrigArg1.isInvalid()) 719429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley return true; 720403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar 721403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar // Make sure any conversions are pushed back into the call; this is 722403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar // type safe since unordered compare builtins are declared as "_Bool 723403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar // foo(...)". 724429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley TheCall->setArg(0, OrigArg0.get()); 725429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley TheCall->setArg(1, OrigArg1.get()); 7261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 727429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley if (OrigArg0.get()->isTypeDependent() || OrigArg1.get()->isTypeDependent()) 728cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return false; 729cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 7301b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner // If the common type isn't a real floating type, then the arguments were 7311b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner // invalid for this operation. 7321b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner if (!Res->isRealFloatingType()) 733429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley return Diag(OrigArg0.get()->getLocStart(), 734fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner diag::err_typecheck_call_invalid_ordered_compare) 735429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley << OrigArg0.get()->getType() << OrigArg1.get()->getType() 736429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley << SourceRange(OrigArg0.get()->getLocStart(), OrigArg1.get()->getLocEnd()); 7371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7381b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner return false; 7391b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner} 7401b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner 741e771a7ac11fb27f0e734e5de4d858f2c268895e5Benjamin Kramer/// SemaBuiltinSemaBuiltinFPClassification - Handle functions like 742e771a7ac11fb27f0e734e5de4d858f2c268895e5Benjamin Kramer/// __builtin_isnan and friends. This is declared to take (...), so we have 7433b1e26b708e8d00d4ba10ff857201bae2aff6baeBenjamin Kramer/// to check everything. We expect the last argument to be a floating point 7443b1e26b708e8d00d4ba10ff857201bae2aff6baeBenjamin Kramer/// value. 7453b1e26b708e8d00d4ba10ff857201bae2aff6baeBenjamin Kramerbool Sema::SemaBuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs) { 7463b1e26b708e8d00d4ba10ff857201bae2aff6baeBenjamin Kramer if (TheCall->getNumArgs() < NumArgs) 7479ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args) 748d77b9a29651d748f0e30a8dad8969635fc04f725Eric Christopher << 0 << NumArgs << TheCall->getNumArgs()/*function call*/; 7493b1e26b708e8d00d4ba10ff857201bae2aff6baeBenjamin Kramer if (TheCall->getNumArgs() > NumArgs) 7503b1e26b708e8d00d4ba10ff857201bae2aff6baeBenjamin Kramer return Diag(TheCall->getArg(NumArgs)->getLocStart(), 7519ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman diag::err_typecheck_call_too_many_args) 752ccfa9639f8d09733bcf1c2572c5bd3daba5bd632Eric Christopher << 0 /*function call*/ << NumArgs << TheCall->getNumArgs() 7533b1e26b708e8d00d4ba10ff857201bae2aff6baeBenjamin Kramer << SourceRange(TheCall->getArg(NumArgs)->getLocStart(), 7549ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman (*(TheCall->arg_end()-1))->getLocEnd()); 7559ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman 7563b1e26b708e8d00d4ba10ff857201bae2aff6baeBenjamin Kramer Expr *OrigArg = TheCall->getArg(NumArgs-1); 7571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7589ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman if (OrigArg->isTypeDependent()) 7599ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman return false; 7609ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman 76181368fbfd6d57150f66c993dc9041d62a7a32c4fChris Lattner // This operation requires a non-_Complex floating-point number. 7629ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman if (!OrigArg->getType()->isRealFloatingType()) 7631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Diag(OrigArg->getLocStart(), 7649ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman diag::err_typecheck_call_invalid_unary_fp) 7659ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman << OrigArg->getType() << OrigArg->getSourceRange(); 7661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 76781368fbfd6d57150f66c993dc9041d62a7a32c4fChris Lattner // If this is an implicit conversion from float -> double, remove it. 76881368fbfd6d57150f66c993dc9041d62a7a32c4fChris Lattner if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(OrigArg)) { 76981368fbfd6d57150f66c993dc9041d62a7a32c4fChris Lattner Expr *CastArg = Cast->getSubExpr(); 77081368fbfd6d57150f66c993dc9041d62a7a32c4fChris Lattner if (CastArg->getType()->isSpecificBuiltinType(BuiltinType::Float)) { 77181368fbfd6d57150f66c993dc9041d62a7a32c4fChris Lattner assert(Cast->getType()->isSpecificBuiltinType(BuiltinType::Double) && 77281368fbfd6d57150f66c993dc9041d62a7a32c4fChris Lattner "promotion from float to double is the only expected cast here"); 77381368fbfd6d57150f66c993dc9041d62a7a32c4fChris Lattner Cast->setSubExpr(0); 77481368fbfd6d57150f66c993dc9041d62a7a32c4fChris Lattner TheCall->setArg(NumArgs-1, CastArg); 77581368fbfd6d57150f66c993dc9041d62a7a32c4fChris Lattner OrigArg = CastArg; 77681368fbfd6d57150f66c993dc9041d62a7a32c4fChris Lattner } 77781368fbfd6d57150f66c993dc9041d62a7a32c4fChris Lattner } 77881368fbfd6d57150f66c993dc9041d62a7a32c4fChris Lattner 7799ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman return false; 7809ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman} 7819ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman 782d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman/// SemaBuiltinShuffleVector - Handle __builtin_shufflevector. 783d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman// This is declared to take (...), so we have to check everything. 78460d7b3a319d84d688752be3870615ac0f111fb16John McCallExprResult Sema::SemaBuiltinShuffleVector(CallExpr *TheCall) { 78537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (TheCall->getNumArgs() < 2) 7860eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(Diag(TheCall->getLocEnd(), 787d77b9a29651d748f0e30a8dad8969635fc04f725Eric Christopher diag::err_typecheck_call_too_few_args_at_least) 78837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman << 0 /*function call*/ << 2 << TheCall->getNumArgs() 789d77b9a29651d748f0e30a8dad8969635fc04f725Eric Christopher << TheCall->getSourceRange()); 790d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 79137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Determine which of the following types of shufflevector we're checking: 79237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // 1) unary, vector mask: (lhs, mask) 79337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // 2) binary, vector mask: (lhs, rhs, mask) 79437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // 3) binary, scalar mask: (lhs, rhs, index, ..., index) 79537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman QualType resType = TheCall->getArg(0)->getType(); 79637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman unsigned numElements = 0; 79737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 798cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (!TheCall->getArg(0)->isTypeDependent() && 799cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor !TheCall->getArg(1)->isTypeDependent()) { 80037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman QualType LHSType = TheCall->getArg(0)->getType(); 80137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman QualType RHSType = TheCall->getArg(1)->getType(); 80237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 80337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (!LHSType->isVectorType() || !RHSType->isVectorType()) { 804cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor Diag(TheCall->getLocStart(), diag::err_shufflevector_non_vector) 8051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump << SourceRange(TheCall->getArg(0)->getLocStart(), 806cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor TheCall->getArg(1)->getLocEnd()); 807cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return ExprError(); 808cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor } 80937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 81037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman numElements = LHSType->getAs<VectorType>()->getNumElements(); 81137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman unsigned numResElements = TheCall->getNumArgs() - 2; 81237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 81337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Check to see if we have a call with 2 vector arguments, the unary shuffle 81437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // with mask. If so, verify that RHS is an integer vector type with the 81537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // same number of elts as lhs. 81637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (TheCall->getNumArgs() == 2) { 817f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (!RHSType->hasIntegerRepresentation() || 81837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman RHSType->getAs<VectorType>()->getNumElements() != numElements) 81937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Diag(TheCall->getLocStart(), diag::err_shufflevector_incompatible_vector) 82037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman << SourceRange(TheCall->getArg(1)->getLocStart(), 82137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman TheCall->getArg(1)->getLocEnd()); 82237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman numResElements = numElements; 82337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 82437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman else if (!Context.hasSameUnqualifiedType(LHSType, RHSType)) { 825cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor Diag(TheCall->getLocStart(), diag::err_shufflevector_incompatible_vector) 8261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump << SourceRange(TheCall->getArg(0)->getLocStart(), 827cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor TheCall->getArg(1)->getLocEnd()); 828cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return ExprError(); 82937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } else if (numElements != numResElements) { 83037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman QualType eltType = LHSType->getAs<VectorType>()->getElementType(); 831788b0fd67e1992f23555454efcdb16a19dfefac3Chris Lattner resType = Context.getVectorType(eltType, numResElements, 832e86d78cf4754a6aef2cf9a33d847aa15338e276fBob Wilson VectorType::GenericVector); 833cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor } 834d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 835d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 836d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman for (unsigned i = 2; i < TheCall->getNumArgs(); i++) { 837cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (TheCall->getArg(i)->isTypeDependent() || 838cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor TheCall->getArg(i)->isValueDependent()) 839cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor continue; 840cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 84137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::APSInt Result(32); 84237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (!TheCall->getArg(i)->isIntegerConstantExpr(Result, Context)) 84337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman return ExprError(Diag(TheCall->getLocStart(), 84437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman diag::err_shufflevector_nonconstant_argument) 84537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman << TheCall->getArg(i)->getSourceRange()); 8460eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl 847d1a0b6d3dfb208f638d3d750b588d9c0daa49289Chris Lattner if (Result.getActiveBits() > 64 || Result.getZExtValue() >= numElements*2) 8480eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(Diag(TheCall->getLocStart(), 849fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner diag::err_shufflevector_argument_too_large) 8500eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl << TheCall->getArg(i)->getSourceRange()); 851d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 852d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 8535f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<Expr*, 32> exprs; 854d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 855d1a0b6d3dfb208f638d3d750b588d9c0daa49289Chris Lattner for (unsigned i = 0, e = TheCall->getNumArgs(); i != e; i++) { 856d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman exprs.push_back(TheCall->getArg(i)); 857d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman TheCall->setArg(i, 0); 858d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 859d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 860a88dc3079bedf70a5cfc39791727e43a10383006Nate Begeman return Owned(new (Context) ShuffleVectorExpr(Context, exprs.begin(), 86137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman exprs.size(), resType, 8628189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek TheCall->getCallee()->getLocStart(), 8638189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek TheCall->getRParenLoc())); 864d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 86530ce344307f8a8b00054021307015571f83c7364Chris Lattner 8664493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar/// SemaBuiltinPrefetch - Handle __builtin_prefetch. 8674493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar// This is declared to take (const void*, ...) and can take two 8684493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar// optional constant int args. 8694493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbarbool Sema::SemaBuiltinPrefetch(CallExpr *TheCall) { 870fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner unsigned NumArgs = TheCall->getNumArgs(); 8714493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar 872fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner if (NumArgs > 3) 873ccfa9639f8d09733bcf1c2572c5bd3daba5bd632Eric Christopher return Diag(TheCall->getLocEnd(), 874ccfa9639f8d09733bcf1c2572c5bd3daba5bd632Eric Christopher diag::err_typecheck_call_too_many_args_at_most) 875ccfa9639f8d09733bcf1c2572c5bd3daba5bd632Eric Christopher << 0 /*function call*/ << 3 << NumArgs 876ccfa9639f8d09733bcf1c2572c5bd3daba5bd632Eric Christopher << TheCall->getSourceRange(); 8774493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar 8784493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar // Argument 0 is checked for us and the remaining arguments must be 8794493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar // constant integers. 880fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner for (unsigned i = 1; i != NumArgs; ++i) { 8814493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar Expr *Arg = TheCall->getArg(i); 882691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher 8839aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman llvm::APSInt Result; 884691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher if (SemaBuiltinConstantArg(TheCall, i, Result)) 885691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher return true; 8861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 8874493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar // FIXME: gcc issues a warning and rewrites these to 0. These 8884493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar // seems especially odd for the third argument since the default 8894493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar // is 3. 890fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner if (i == 1) { 8919aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman if (Result.getLimitedValue() > 1) 892fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range) 89321fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner << "0" << "1" << Arg->getSourceRange(); 8944493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar } else { 8959aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman if (Result.getLimitedValue() > 3) 896fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range) 89721fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner << "0" << "3" << Arg->getSourceRange(); 8984493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar } 8994493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar } 9004493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar 901fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return false; 9024493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar} 9034493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar 904691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher/// SemaBuiltinConstantArg - Handle a check if argument ArgNum of CallExpr 905691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher/// TheCall is a constant expression. 906691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopherbool Sema::SemaBuiltinConstantArg(CallExpr *TheCall, int ArgNum, 907691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher llvm::APSInt &Result) { 908691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher Expr *Arg = TheCall->getArg(ArgNum); 909691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts()); 910691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher FunctionDecl *FDecl = cast<FunctionDecl>(DRE->getDecl()); 911691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher 912691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher if (Arg->isTypeDependent() || Arg->isValueDependent()) return false; 913691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher 914691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher if (!Arg->isIntegerConstantExpr(Result, Context)) 915691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher return Diag(TheCall->getLocStart(), diag::err_constant_integer_arg_type) 9165e8965525282a48fd34af05183b8c3705a5b00d5Eric Christopher << FDecl->getDeclName() << Arg->getSourceRange(); 917691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher 91821fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner return false; 91921fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner} 92021fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner 921d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar/// SemaBuiltinObjectSize - Handle __builtin_object_size(void *ptr, 922d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar/// int type). This simply type checks that type is one of the defined 923d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar/// constants (0-3). 924fc8f0e14ad142ed811e90fbd9a30e419e301c717Chris Lattner// For compatibility check 0-3, llvm only handles 0 and 2. 925d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbarbool Sema::SemaBuiltinObjectSize(CallExpr *TheCall) { 926691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher llvm::APSInt Result; 927691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher 928691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher // Check constant-ness first. 929691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher if (SemaBuiltinConstantArg(TheCall, 1, Result)) 930691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher return true; 931d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar 932691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher Expr *Arg = TheCall->getArg(1); 933d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar if (Result.getSExtValue() < 0 || Result.getSExtValue() > 3) { 934fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range) 935fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << "0" << "3" << SourceRange(Arg->getLocStart(), Arg->getLocEnd()); 936d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar } 937d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar 938d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar return false; 939d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar} 940d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar 941586d6a81428da2d1ce70bcb98df29d749361cbf3Eli Friedman/// SemaBuiltinLongjmp - Handle __builtin_longjmp(void *env[5], int val). 942d875fed28578835de89cd407e9db4be788596d7cEli Friedman/// This checks that val is a constant 1. 943d875fed28578835de89cd407e9db4be788596d7cEli Friedmanbool Sema::SemaBuiltinLongjmp(CallExpr *TheCall) { 944d875fed28578835de89cd407e9db4be788596d7cEli Friedman Expr *Arg = TheCall->getArg(1); 945691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher llvm::APSInt Result; 946cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 947691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher // TODO: This is less than ideal. Overload this to take a value. 948691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher if (SemaBuiltinConstantArg(TheCall, 1, Result)) 949691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher return true; 950691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher 951691ebc3f3225542e5abd85e107ebdbec907cf510Eric Christopher if (Result != 1) 952d875fed28578835de89cd407e9db4be788596d7cEli Friedman return Diag(TheCall->getLocStart(), diag::err_builtin_longjmp_invalid_val) 953d875fed28578835de89cd407e9db4be788596d7cEli Friedman << SourceRange(Arg->getLocStart(), Arg->getLocEnd()); 954d875fed28578835de89cd407e9db4be788596d7cEli Friedman 955d875fed28578835de89cd407e9db4be788596d7cEli Friedman return false; 956d875fed28578835de89cd407e9db4be788596d7cEli Friedman} 957d875fed28578835de89cd407e9db4be788596d7cEli Friedman 958b43e8ad893706a2499c4901b8f5cb289553d66b1Ted Kremenek// Handle i > 1 ? "x" : "y", recursively. 959082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenekbool Sema::SemaCheckStringLiteral(const Expr *E, const CallExpr *TheCall, 960082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek bool HasVAListArg, 961826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek unsigned format_idx, unsigned firstDataArg, 962826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek bool isPrintf) { 9634fe6441a558e471f2ad3c6bddf07c77332539f6bTed Kremenek tryAgain: 964cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (E->isTypeDependent() || E->isValueDependent()) 965cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return false; 966d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 967f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne E = E->IgnoreParens(); 968f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne 969d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek switch (E->getStmtClass()) { 97056ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall case Stmt::BinaryConditionalOperatorClass: 971d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek case Stmt::ConditionalOperatorClass: { 97256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall const AbstractConditionalOperator *C = cast<AbstractConditionalOperator>(E); 973826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek return SemaCheckStringLiteral(C->getTrueExpr(), TheCall, HasVAListArg, 974826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek format_idx, firstDataArg, isPrintf) 97556ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall && SemaCheckStringLiteral(C->getFalseExpr(), TheCall, HasVAListArg, 976826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek format_idx, firstDataArg, isPrintf); 977d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 978d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 97995355bb53ef3145e463b98c6fd26f8f95e26e26cTed Kremenek case Stmt::IntegerLiteralClass: 98095355bb53ef3145e463b98c6fd26f8f95e26e26cTed Kremenek // Technically -Wformat-nonliteral does not warn about this case. 98195355bb53ef3145e463b98c6fd26f8f95e26e26cTed Kremenek // The behavior of printf and friends in this case is implementation 98295355bb53ef3145e463b98c6fd26f8f95e26e26cTed Kremenek // dependent. Ideally if the format string cannot be null then 98395355bb53ef3145e463b98c6fd26f8f95e26e26cTed Kremenek // it should have a 'nonnull' attribute in the function prototype. 98495355bb53ef3145e463b98c6fd26f8f95e26e26cTed Kremenek return true; 98595355bb53ef3145e463b98c6fd26f8f95e26e26cTed Kremenek 986d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek case Stmt::ImplicitCastExprClass: { 9874fe6441a558e471f2ad3c6bddf07c77332539f6bTed Kremenek E = cast<ImplicitCastExpr>(E)->getSubExpr(); 9884fe6441a558e471f2ad3c6bddf07c77332539f6bTed Kremenek goto tryAgain; 989d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 990d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 99156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall case Stmt::OpaqueValueExprClass: 99256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall if (const Expr *src = cast<OpaqueValueExpr>(E)->getSourceExpr()) { 99356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall E = src; 99456ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall goto tryAgain; 99556ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall } 99656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall return false; 99756ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 998b43e8ad893706a2499c4901b8f5cb289553d66b1Ted Kremenek case Stmt::PredefinedExprClass: 999b43e8ad893706a2499c4901b8f5cb289553d66b1Ted Kremenek // While __func__, etc., are technically not string literals, they 1000b43e8ad893706a2499c4901b8f5cb289553d66b1Ted Kremenek // cannot contain format specifiers and thus are not a security 1001b43e8ad893706a2499c4901b8f5cb289553d66b1Ted Kremenek // liability. 1002b43e8ad893706a2499c4901b8f5cb289553d66b1Ted Kremenek return true; 1003b43e8ad893706a2499c4901b8f5cb289553d66b1Ted Kremenek 1004082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek case Stmt::DeclRefExprClass: { 1005082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const DeclRefExpr *DR = cast<DeclRefExpr>(E); 10061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1007082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek // As an exception, do not flag errors for variables binding to 1008082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek // const string literals. 1009082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek if (const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl())) { 1010082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek bool isConstant = false; 1011082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek QualType T = DR->getType(); 1012082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek 1013082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek if (const ArrayType *AT = Context.getAsArrayType(T)) { 1014082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek isConstant = AT->getElementType().isConstant(Context); 1015ac5fc7c6bcb494b60fee7ce615ac931c5db6135eMike Stump } else if (const PointerType *PT = T->getAs<PointerType>()) { 10161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump isConstant = T.isConstant(Context) && 1017082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek PT->getPointeeType().isConstant(Context); 1018082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek } 10191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1020082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek if (isConstant) { 102131310a21fb2a9f13950f864f681c86080b05d5b2Sebastian Redl if (const Expr *Init = VD->getAnyInitializer()) 1022082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek return SemaCheckStringLiteral(Init, TheCall, 1023826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek HasVAListArg, format_idx, firstDataArg, 1024826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek isPrintf); 1025082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek } 10261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1027d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // For vprintf* functions (i.e., HasVAListArg==true), we add a 1028d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // special check to see if the format string is a function parameter 1029d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // of the function calling the printf function. If the function 1030d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // has an attribute indicating it is a printf-like function, then we 1031d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // should suppress warnings concerning non-literals being used in a call 1032d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // to a vprintf function. For example: 1033d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // 1034d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // void 1035d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // logmessage(char const *fmt __attribute__ (format (printf, 1, 2)), ...){ 1036d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // va_list ap; 1037d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // va_start(ap, fmt); 1038d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // vprintf(fmt, ap); // Do NOT emit a warning about "fmt". 1039d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // ... 1040d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // 1041d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // 1042d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // FIXME: We don't have full attribute support yet, so just check to see 1043d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // if the argument is a DeclRefExpr that references a parameter. We'll 1044d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // add proper support for checking the attribute later. 1045d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson if (HasVAListArg) 1046d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson if (isa<ParmVarDecl>(VD)) 1047d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson return true; 1048082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek } 10491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1050082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek return false; 1051082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek } 1052d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 10538f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson case Stmt::CallExprClass: { 10548f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson const CallExpr *CE = cast<CallExpr>(E); 10551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const ImplicitCastExpr *ICE 10568f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson = dyn_cast<ImplicitCastExpr>(CE->getCallee())) { 10578f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) { 10588f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) { 105940b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis if (const FormatArgAttr *FA = FD->getAttr<FormatArgAttr>()) { 10608f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson unsigned ArgIndex = FA->getFormatIdx(); 10618f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson const Expr *Arg = CE->getArg(ArgIndex - 1); 10621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return SemaCheckStringLiteral(Arg, TheCall, HasVAListArg, 1064826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek format_idx, firstDataArg, isPrintf); 10658f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson } 10668f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson } 10678f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson } 10688f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson } 10691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10708f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson return false; 10718f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson } 1072082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek case Stmt::ObjCStringLiteralClass: 1073082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek case Stmt::StringLiteralClass: { 1074082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const StringLiteral *StrE = NULL; 10751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1076082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek if (const ObjCStringLiteral *ObjCFExpr = dyn_cast<ObjCStringLiteral>(E)) 1077d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek StrE = ObjCFExpr->getString(); 1078d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek else 1079082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek StrE = cast<StringLiteral>(E); 10801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1081d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek if (StrE) { 1082826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek CheckFormatString(StrE, E, TheCall, HasVAListArg, format_idx, 1083826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek firstDataArg, isPrintf); 1084d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek return true; 1085d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 10861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1087d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek return false; 1088d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 10891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1090082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek default: 1091082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek return false; 1092d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 1093d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek} 1094d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 1095e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanianvoid 10961eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpSema::CheckNonNullArguments(const NonNullAttr *NonNull, 1097909a70d8a185f701c20bacc3c76f8f5979cbbc7cNick Lewycky const Expr * const *ExprArgs, 1098909a70d8a185f701c20bacc3c76f8f5979cbbc7cNick Lewycky SourceLocation CallSiteLoc) { 1099cf807c4dfdb23e8fa3f400e0b24ef5b79db7a530Sean Hunt for (NonNullAttr::args_iterator i = NonNull->args_begin(), 1100cf807c4dfdb23e8fa3f400e0b24ef5b79db7a530Sean Hunt e = NonNull->args_end(); 1101e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanian i != e; ++i) { 1102909a70d8a185f701c20bacc3c76f8f5979cbbc7cNick Lewycky const Expr *ArgExpr = ExprArgs[*i]; 11034e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek if (ArgExpr->isNullPointerConstant(Context, 1104ce94049b69f75b44c18584fe79cd238978b6b0d5Douglas Gregor Expr::NPC_ValueDependentIsNotNull)) 1105909a70d8a185f701c20bacc3c76f8f5979cbbc7cNick Lewycky Diag(CallSiteLoc, diag::warn_null_arg) << ArgExpr->getSourceRange(); 1106e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanian } 1107e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanian} 1108d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 1109826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek/// CheckPrintfScanfArguments - Check calls to printf and scanf (and similar 1110826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek/// functions) for correct use of format strings. 111159907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattnervoid 1112826a3457f737f1fc45a22954fd1bfde38160c165Ted KremenekSema::CheckPrintfScanfArguments(const CallExpr *TheCall, bool HasVAListArg, 1113826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek unsigned format_idx, unsigned firstDataArg, 1114826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek bool isPrintf) { 1115826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1116082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const Expr *Fn = TheCall->getCallee(); 1117925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner 11184a2614e94672c47395abcde60518776fbebec589Sebastian Redl // The way the format attribute works in GCC, the implicit this argument 11194a2614e94672c47395abcde60518776fbebec589Sebastian Redl // of member functions is counted. However, it doesn't appear in our own 11204a2614e94672c47395abcde60518776fbebec589Sebastian Redl // lists, so decrement format_idx in that case. 11214a2614e94672c47395abcde60518776fbebec589Sebastian Redl if (isa<CXXMemberCallExpr>(TheCall)) { 11229263a3060087eb7b5954ec4ee1ff2c22227b422eChandler Carruth const CXXMethodDecl *method_decl = 11239263a3060087eb7b5954ec4ee1ff2c22227b422eChandler Carruth dyn_cast<CXXMethodDecl>(TheCall->getCalleeDecl()); 11249263a3060087eb7b5954ec4ee1ff2c22227b422eChandler Carruth if (method_decl && method_decl->isInstance()) { 11259263a3060087eb7b5954ec4ee1ff2c22227b422eChandler Carruth // Catch a format attribute mistakenly referring to the object argument. 11269263a3060087eb7b5954ec4ee1ff2c22227b422eChandler Carruth if (format_idx == 0) 11279263a3060087eb7b5954ec4ee1ff2c22227b422eChandler Carruth return; 11289263a3060087eb7b5954ec4ee1ff2c22227b422eChandler Carruth --format_idx; 11299263a3060087eb7b5954ec4ee1ff2c22227b422eChandler Carruth if(firstDataArg != 0) 11309263a3060087eb7b5954ec4ee1ff2c22227b422eChandler Carruth --firstDataArg; 11319263a3060087eb7b5954ec4ee1ff2c22227b422eChandler Carruth } 11324a2614e94672c47395abcde60518776fbebec589Sebastian Redl } 11334a2614e94672c47395abcde60518776fbebec589Sebastian Redl 1134826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek // CHECK: printf/scanf-like function is called with no format string. 1135925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner if (format_idx >= TheCall->getNumArgs()) { 1136826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek Diag(TheCall->getRParenLoc(), diag::warn_missing_format_string) 1137dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner << Fn->getSourceRange(); 113871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek return; 113971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 11401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1141082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const Expr *OrigFormatExpr = TheCall->getArg(format_idx)->IgnoreParenCasts(); 11421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 114359907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner // CHECK: format string is not a string literal. 11441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // 114571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // Dynamically generated format strings are difficult to 114671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // automatically vet at compile time. Requiring that format strings 114771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // are string literals: (1) permits the checking of format strings by 114871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // the compiler and thereby (2) can practically remove the source of 114971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // many format string exploits. 11507ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek 11511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Format string can be either ObjC string (e.g. @"%d") or 11527ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek // C string (e.g. "%d") 11531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // ObjC string uses the same format specifiers as C string, so we can use 11547ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek // the same format string checking logic for both ObjC and C strings. 11551cd3e1f72c3a1c256fb6a5c3d4512bca1f1b751dChris Lattner if (SemaCheckStringLiteral(OrigFormatExpr, TheCall, HasVAListArg, format_idx, 1156826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek firstDataArg, isPrintf)) 11571cd3e1f72c3a1c256fb6a5c3d4512bca1f1b751dChris Lattner return; // Literal format string found, check done! 11581cd3e1f72c3a1c256fb6a5c3d4512bca1f1b751dChris Lattner 1159655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner // If there are no arguments specified, warn with -Wformat-security, otherwise 1160655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner // warn only with -Wformat-nonliteral. 1161655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner if (TheCall->getNumArgs() == format_idx+1) 11621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Diag(TheCall->getArg(format_idx)->getLocStart(), 1163826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek diag::warn_format_nonliteral_noargs) 1164655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner << OrigFormatExpr->getSourceRange(); 1165655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner else 11661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Diag(TheCall->getArg(format_idx)->getLocStart(), 1167826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek diag::warn_format_nonliteral) 1168655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner << OrigFormatExpr->getSourceRange(); 1169d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek} 1170d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 1171e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremeneknamespace { 1172826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenekclass CheckFormatHandler : public analyze_format_string::FormatStringHandler { 1173826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenekprotected: 1174e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek Sema &S; 1175e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek const StringLiteral *FExpr; 1176e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek const Expr *OrigFormatExpr; 11776ee765348b2855c702fa593fb030ef6abe0d01f6Ted Kremenek const unsigned FirstDataArg; 1178e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek const unsigned NumDataArgs; 1179e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek const bool IsObjCLiteral; 1180e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek const char *Beg; // Start of format string. 11810d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek const bool HasVAListArg; 11820d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek const CallExpr *TheCall; 11830d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek unsigned FormatIdx; 11847f70dc85d5055c19c8003f43a59135de211ad1b9Ted Kremenek llvm::BitVector CoveredArgs; 1185efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek bool usesPositionalArgs; 1186efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek bool atFirstArg; 11874e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenekpublic: 1188826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek CheckFormatHandler(Sema &s, const StringLiteral *fexpr, 11896ee765348b2855c702fa593fb030ef6abe0d01f6Ted Kremenek const Expr *origFormatExpr, unsigned firstDataArg, 1190e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek unsigned numDataArgs, bool isObjCLiteral, 11910d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek const char *beg, bool hasVAListArg, 11920d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek const CallExpr *theCall, unsigned formatIdx) 1193e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek : S(s), FExpr(fexpr), OrigFormatExpr(origFormatExpr), 11946ee765348b2855c702fa593fb030ef6abe0d01f6Ted Kremenek FirstDataArg(firstDataArg), 11957f70dc85d5055c19c8003f43a59135de211ad1b9Ted Kremenek NumDataArgs(numDataArgs), 11960d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek IsObjCLiteral(isObjCLiteral), Beg(beg), 11970d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek HasVAListArg(hasVAListArg), 1198efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek TheCall(theCall), FormatIdx(formatIdx), 1199efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek usesPositionalArgs(false), atFirstArg(true) { 12007f70dc85d5055c19c8003f43a59135de211ad1b9Ted Kremenek CoveredArgs.resize(numDataArgs); 12017f70dc85d5055c19c8003f43a59135de211ad1b9Ted Kremenek CoveredArgs.reset(); 12027f70dc85d5055c19c8003f43a59135de211ad1b9Ted Kremenek } 12034e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek 120407d161f38e708a91486bf1c031d525faebbb249dTed Kremenek void DoneProcessing(); 12054e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek 1206826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek void HandleIncompleteSpecifier(const char *startSpecifier, 1207826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek unsigned specifierLen); 1208826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1209efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek virtual void HandleInvalidPosition(const char *startSpecifier, 1210efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek unsigned specifierLen, 1211826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek analyze_format_string::PositionContext p); 1212efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek 1213efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek virtual void HandleZeroPosition(const char *startPos, unsigned posLen); 1214efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek 1215e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek void HandleNullChar(const char *nullCharacter); 12164e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek 1217826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenekprotected: 1218c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek bool HandleInvalidConversionSpecifier(unsigned argIndex, SourceLocation Loc, 1219c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek const char *startSpec, 1220c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek unsigned specifierLen, 1221c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek const char *csStart, unsigned csLen); 1222c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek 1223f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek SourceRange getFormatStringRange(); 1224826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek CharSourceRange getSpecifierRange(const char *startSpecifier, 1225826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek unsigned specifierLen); 1226e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek SourceLocation getLocationOfByte(const char *x); 12274e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek 12280d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek const Expr *getDataArg(unsigned i) const; 1229666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek 1230666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek bool CheckNumArgs(const analyze_format_string::FormatSpecifier &FS, 1231666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek const analyze_format_string::ConversionSpecifier &CS, 1232666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek const char *startSpecifier, unsigned specifierLen, 1233666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek unsigned argIndex); 1234e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek}; 1235e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek} 1236e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 1237826a3457f737f1fc45a22954fd1bfde38160c165Ted KremenekSourceRange CheckFormatHandler::getFormatStringRange() { 1238e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek return OrigFormatExpr->getSourceRange(); 1239e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek} 1240e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 1241826a3457f737f1fc45a22954fd1bfde38160c165Ted KremenekCharSourceRange CheckFormatHandler:: 1242826a3457f737f1fc45a22954fd1bfde38160c165Ted KremenekgetSpecifierRange(const char *startSpecifier, unsigned specifierLen) { 124345f9b7e8f23072d662ee1cc758f4ecb0da5e3322Tom Care SourceLocation Start = getLocationOfByte(startSpecifier); 124445f9b7e8f23072d662ee1cc758f4ecb0da5e3322Tom Care SourceLocation End = getLocationOfByte(startSpecifier + specifierLen - 1); 124545f9b7e8f23072d662ee1cc758f4ecb0da5e3322Tom Care 124645f9b7e8f23072d662ee1cc758f4ecb0da5e3322Tom Care // Advance the end SourceLocation by one due to half-open ranges. 124745f9b7e8f23072d662ee1cc758f4ecb0da5e3322Tom Care End = End.getFileLocWithOffset(1); 124845f9b7e8f23072d662ee1cc758f4ecb0da5e3322Tom Care 124945f9b7e8f23072d662ee1cc758f4ecb0da5e3322Tom Care return CharSourceRange::getCharRange(Start, End); 1250f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek} 1251f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek 1252826a3457f737f1fc45a22954fd1bfde38160c165Ted KremenekSourceLocation CheckFormatHandler::getLocationOfByte(const char *x) { 12534e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek return S.getLocationOfStringLiteralByte(FExpr, x - Beg); 1254e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek} 1255e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 1256826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenekvoid CheckFormatHandler::HandleIncompleteSpecifier(const char *startSpecifier, 1257826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek unsigned specifierLen){ 1258808015a18bd97781ce437831a95a92fdfc8d5136Ted Kremenek SourceLocation Loc = getLocationOfByte(startSpecifier); 1259808015a18bd97781ce437831a95a92fdfc8d5136Ted Kremenek S.Diag(Loc, diag::warn_printf_incomplete_specifier) 1260826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek << getSpecifierRange(startSpecifier, specifierLen); 1261808015a18bd97781ce437831a95a92fdfc8d5136Ted Kremenek} 1262808015a18bd97781ce437831a95a92fdfc8d5136Ted Kremenek 1263efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenekvoid 1264826a3457f737f1fc45a22954fd1bfde38160c165Ted KremenekCheckFormatHandler::HandleInvalidPosition(const char *startPos, unsigned posLen, 1265826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek analyze_format_string::PositionContext p) { 1266efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek SourceLocation Loc = getLocationOfByte(startPos); 1267826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek S.Diag(Loc, diag::warn_format_invalid_positional_specifier) 1268826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek << (unsigned) p << getSpecifierRange(startPos, posLen); 1269efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek} 1270efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek 1271826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenekvoid CheckFormatHandler::HandleZeroPosition(const char *startPos, 1272efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek unsigned posLen) { 1273efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek SourceLocation Loc = getLocationOfByte(startPos); 1274826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek S.Diag(Loc, diag::warn_format_zero_positional_specifier) 1275826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek << getSpecifierRange(startPos, posLen); 1276efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek} 1277efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek 1278826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenekvoid CheckFormatHandler::HandleNullChar(const char *nullCharacter) { 12790c06944f5ef31cc6356e30da2971fa5439c4c8efTed Kremenek if (!IsObjCLiteral) { 12800c06944f5ef31cc6356e30da2971fa5439c4c8efTed Kremenek // The presence of a null character is likely an error. 12810c06944f5ef31cc6356e30da2971fa5439c4c8efTed Kremenek S.Diag(getLocationOfByte(nullCharacter), 12820c06944f5ef31cc6356e30da2971fa5439c4c8efTed Kremenek diag::warn_printf_format_string_contains_null_char) 12830c06944f5ef31cc6356e30da2971fa5439c4c8efTed Kremenek << getFormatStringRange(); 12840c06944f5ef31cc6356e30da2971fa5439c4c8efTed Kremenek } 1285826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek} 1286826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1287826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenekconst Expr *CheckFormatHandler::getDataArg(unsigned i) const { 1288826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek return TheCall->getArg(FirstDataArg + i); 1289826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek} 12904e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek 1291826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenekvoid CheckFormatHandler::DoneProcessing() { 1292826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek // Does the number of data arguments exceed the number of 1293826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek // format conversions in the format string? 1294826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek if (!HasVAListArg) { 1295826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek // Find any arguments that weren't covered. 1296826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek CoveredArgs.flip(); 1297826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek signed notCoveredArg = CoveredArgs.find_first(); 1298826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek if (notCoveredArg >= 0) { 1299826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek assert((unsigned)notCoveredArg < NumDataArgs); 1300826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek S.Diag(getDataArg((unsigned) notCoveredArg)->getLocStart(), 1301826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek diag::warn_printf_data_arg_not_used) 1302826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek << getFormatStringRange(); 1303826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek } 1304826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek } 1305826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek} 1306826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1307c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenekbool 1308c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted KremenekCheckFormatHandler::HandleInvalidConversionSpecifier(unsigned argIndex, 1309c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek SourceLocation Loc, 1310c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek const char *startSpec, 1311c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek unsigned specifierLen, 1312c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek const char *csStart, 1313c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek unsigned csLen) { 1314c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek 1315c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek bool keepGoing = true; 1316c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek if (argIndex < NumDataArgs) { 1317c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek // Consider the argument coverered, even though the specifier doesn't 1318c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek // make sense. 1319c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek CoveredArgs.set(argIndex); 1320c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek } 1321c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek else { 1322c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek // If argIndex exceeds the number of data arguments we 1323c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek // don't issue a warning because that is just a cascade of warnings (and 1324c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek // they may have intended '%%' anyway). We don't want to continue processing 1325c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek // the format string after this point, however, as we will like just get 1326c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek // gibberish when trying to match arguments. 1327c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek keepGoing = false; 1328c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek } 1329c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek 1330c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek S.Diag(Loc, diag::warn_format_invalid_conversion) 13315f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner << StringRef(csStart, csLen) 1332c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek << getSpecifierRange(startSpec, specifierLen); 1333c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek 1334c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek return keepGoing; 1335c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek} 1336c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek 1337666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenekbool 1338666a197deb75d95c78ddd39274af1a54240828d8Ted KremenekCheckFormatHandler::CheckNumArgs( 1339666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek const analyze_format_string::FormatSpecifier &FS, 1340666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek const analyze_format_string::ConversionSpecifier &CS, 1341666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek const char *startSpecifier, unsigned specifierLen, unsigned argIndex) { 1342666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek 1343666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek if (argIndex >= NumDataArgs) { 1344666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek if (FS.usesPositionalArg()) { 1345666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek S.Diag(getLocationOfByte(CS.getStart()), 1346666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek diag::warn_printf_positional_arg_exceeds_data_args) 1347666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek << (argIndex+1) << NumDataArgs 1348666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek << getSpecifierRange(startSpecifier, specifierLen); 1349666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek } 1350666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek else { 1351666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek S.Diag(getLocationOfByte(CS.getStart()), 1352666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek diag::warn_printf_insufficient_data_args) 1353666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek << getSpecifierRange(startSpecifier, specifierLen); 1354666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek } 1355666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek 1356666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek return false; 1357666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek } 1358666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek return true; 1359666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek} 1360666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek 1361826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek//===--- CHECK: Printf format string checking ------------------------------===// 1362826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1363826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremeneknamespace { 1364826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenekclass CheckPrintfHandler : public CheckFormatHandler { 1365826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenekpublic: 1366826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek CheckPrintfHandler(Sema &s, const StringLiteral *fexpr, 1367826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const Expr *origFormatExpr, unsigned firstDataArg, 1368826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek unsigned numDataArgs, bool isObjCLiteral, 1369826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const char *beg, bool hasVAListArg, 1370826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const CallExpr *theCall, unsigned formatIdx) 1371826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek : CheckFormatHandler(s, fexpr, origFormatExpr, firstDataArg, 1372826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek numDataArgs, isObjCLiteral, beg, hasVAListArg, 1373826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek theCall, formatIdx) {} 1374826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1375826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1376826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek bool HandleInvalidPrintfConversionSpecifier( 1377826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const analyze_printf::PrintfSpecifier &FS, 1378826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const char *startSpecifier, 1379826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek unsigned specifierLen); 1380826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1381826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek bool HandlePrintfSpecifier(const analyze_printf::PrintfSpecifier &FS, 1382826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const char *startSpecifier, 1383826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek unsigned specifierLen); 1384826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1385826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek bool HandleAmount(const analyze_format_string::OptionalAmount &Amt, unsigned k, 1386826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const char *startSpecifier, unsigned specifierLen); 1387826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek void HandleInvalidAmount(const analyze_printf::PrintfSpecifier &FS, 1388826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const analyze_printf::OptionalAmount &Amt, 1389826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek unsigned type, 1390826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const char *startSpecifier, unsigned specifierLen); 1391826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek void HandleFlag(const analyze_printf::PrintfSpecifier &FS, 1392826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const analyze_printf::OptionalFlag &flag, 1393826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const char *startSpecifier, unsigned specifierLen); 1394826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek void HandleIgnoredFlag(const analyze_printf::PrintfSpecifier &FS, 1395826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const analyze_printf::OptionalFlag &ignoredFlag, 1396826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const analyze_printf::OptionalFlag &flag, 1397826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const char *startSpecifier, unsigned specifierLen); 1398826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek}; 1399826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek} 1400826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1401826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenekbool CheckPrintfHandler::HandleInvalidPrintfConversionSpecifier( 1402826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const analyze_printf::PrintfSpecifier &FS, 1403826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const char *startSpecifier, 1404826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek unsigned specifierLen) { 14056ecb950c65329f8d6ce9ad0514632df35a5ab61fTed Kremenek const analyze_printf::PrintfConversionSpecifier &CS = 1406c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek FS.getConversionSpecifier(); 1407826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1408c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek return HandleInvalidConversionSpecifier(FS.getArgIndex(), 1409c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek getLocationOfByte(CS.getStart()), 1410c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek startSpecifier, specifierLen, 1411c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek CS.getStart(), CS.getLength()); 141226ac2e07b46bfb4d4f00752c96481c0a98c79c69Ted Kremenek} 141326ac2e07b46bfb4d4f00752c96481c0a98c79c69Ted Kremenek 1414826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenekbool CheckPrintfHandler::HandleAmount( 1415826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const analyze_format_string::OptionalAmount &Amt, 1416826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek unsigned k, const char *startSpecifier, 1417826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek unsigned specifierLen) { 14180d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek 14190d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek if (Amt.hasDataArgument()) { 14200d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek if (!HasVAListArg) { 14217f70dc85d5055c19c8003f43a59135de211ad1b9Ted Kremenek unsigned argIndex = Amt.getArgIndex(); 14227f70dc85d5055c19c8003f43a59135de211ad1b9Ted Kremenek if (argIndex >= NumDataArgs) { 1423efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek S.Diag(getLocationOfByte(Amt.getStart()), 1424efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek diag::warn_printf_asterisk_missing_arg) 1425826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek << k << getSpecifierRange(startSpecifier, specifierLen); 14260d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek // Don't do any more checking. We will just emit 14270d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek // spurious errors. 14280d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek return false; 14290d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek } 14304e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek 14310d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek // Type check the data argument. It should be an 'int'. 143231f8e32788adb299acad455363eb7fd244642c82Ted Kremenek // Although not in conformance with C99, we also allow the argument to be 143331f8e32788adb299acad455363eb7fd244642c82Ted Kremenek // an 'unsigned int' as that is a reasonably safe case. GCC also 143431f8e32788adb299acad455363eb7fd244642c82Ted Kremenek // doesn't emit a warning for that case. 14357f70dc85d5055c19c8003f43a59135de211ad1b9Ted Kremenek CoveredArgs.set(argIndex); 14367f70dc85d5055c19c8003f43a59135de211ad1b9Ted Kremenek const Expr *Arg = getDataArg(argIndex); 14370d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek QualType T = Arg->getType(); 14384e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek 14394e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek const analyze_printf::ArgTypeResult &ATR = Amt.getArgType(S.Context); 14404e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek assert(ATR.isValid()); 14414e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek 14424e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek if (!ATR.matchesType(S.Context, T)) { 1443efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek S.Diag(getLocationOfByte(Amt.getStart()), 1444efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek diag::warn_printf_asterisk_wrong_type) 1445efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek << k 14464e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek << ATR.getRepresentativeType(S.Context) << T 1447826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek << getSpecifierRange(startSpecifier, specifierLen) 1448d635c5fcc45c952b75743dd2f4c86d6950e4954eTed Kremenek << Arg->getSourceRange(); 14490d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek // Don't do any more checking. We will just emit 14500d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek // spurious errors. 14510d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek return false; 14520d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek } 14530d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek } 14540d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek } 14550d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek return true; 14560d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek} 14570d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek 1458e4ee9663168dfb2b4122c768091e30217328c9faTom Carevoid CheckPrintfHandler::HandleInvalidAmount( 1459826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const analyze_printf::PrintfSpecifier &FS, 1460e4ee9663168dfb2b4122c768091e30217328c9faTom Care const analyze_printf::OptionalAmount &Amt, 1461e4ee9663168dfb2b4122c768091e30217328c9faTom Care unsigned type, 1462e4ee9663168dfb2b4122c768091e30217328c9faTom Care const char *startSpecifier, 1463e4ee9663168dfb2b4122c768091e30217328c9faTom Care unsigned specifierLen) { 14646ecb950c65329f8d6ce9ad0514632df35a5ab61fTed Kremenek const analyze_printf::PrintfConversionSpecifier &CS = 14656ecb950c65329f8d6ce9ad0514632df35a5ab61fTed Kremenek FS.getConversionSpecifier(); 1466e4ee9663168dfb2b4122c768091e30217328c9faTom Care switch (Amt.getHowSpecified()) { 1467e4ee9663168dfb2b4122c768091e30217328c9faTom Care case analyze_printf::OptionalAmount::Constant: 1468e4ee9663168dfb2b4122c768091e30217328c9faTom Care S.Diag(getLocationOfByte(Amt.getStart()), 1469e4ee9663168dfb2b4122c768091e30217328c9faTom Care diag::warn_printf_nonsensical_optional_amount) 1470e4ee9663168dfb2b4122c768091e30217328c9faTom Care << type 1471e4ee9663168dfb2b4122c768091e30217328c9faTom Care << CS.toString() 1472826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek << getSpecifierRange(startSpecifier, specifierLen) 1473826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek << FixItHint::CreateRemoval(getSpecifierRange(Amt.getStart(), 1474e4ee9663168dfb2b4122c768091e30217328c9faTom Care Amt.getConstantLength())); 1475e4ee9663168dfb2b4122c768091e30217328c9faTom Care break; 1476e4ee9663168dfb2b4122c768091e30217328c9faTom Care 1477e4ee9663168dfb2b4122c768091e30217328c9faTom Care default: 1478e4ee9663168dfb2b4122c768091e30217328c9faTom Care S.Diag(getLocationOfByte(Amt.getStart()), 1479e4ee9663168dfb2b4122c768091e30217328c9faTom Care diag::warn_printf_nonsensical_optional_amount) 1480e4ee9663168dfb2b4122c768091e30217328c9faTom Care << type 1481e4ee9663168dfb2b4122c768091e30217328c9faTom Care << CS.toString() 1482826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek << getSpecifierRange(startSpecifier, specifierLen); 1483e4ee9663168dfb2b4122c768091e30217328c9faTom Care break; 1484e4ee9663168dfb2b4122c768091e30217328c9faTom Care } 1485e4ee9663168dfb2b4122c768091e30217328c9faTom Care} 1486e4ee9663168dfb2b4122c768091e30217328c9faTom Care 1487826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenekvoid CheckPrintfHandler::HandleFlag(const analyze_printf::PrintfSpecifier &FS, 1488e4ee9663168dfb2b4122c768091e30217328c9faTom Care const analyze_printf::OptionalFlag &flag, 1489e4ee9663168dfb2b4122c768091e30217328c9faTom Care const char *startSpecifier, 1490e4ee9663168dfb2b4122c768091e30217328c9faTom Care unsigned specifierLen) { 1491e4ee9663168dfb2b4122c768091e30217328c9faTom Care // Warn about pointless flag with a fixit removal. 14926ecb950c65329f8d6ce9ad0514632df35a5ab61fTed Kremenek const analyze_printf::PrintfConversionSpecifier &CS = 14936ecb950c65329f8d6ce9ad0514632df35a5ab61fTed Kremenek FS.getConversionSpecifier(); 1494e4ee9663168dfb2b4122c768091e30217328c9faTom Care S.Diag(getLocationOfByte(flag.getPosition()), 1495e4ee9663168dfb2b4122c768091e30217328c9faTom Care diag::warn_printf_nonsensical_flag) 1496e4ee9663168dfb2b4122c768091e30217328c9faTom Care << flag.toString() << CS.toString() 1497826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek << getSpecifierRange(startSpecifier, specifierLen) 1498826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek << FixItHint::CreateRemoval(getSpecifierRange(flag.getPosition(), 1)); 1499e4ee9663168dfb2b4122c768091e30217328c9faTom Care} 1500e4ee9663168dfb2b4122c768091e30217328c9faTom Care 1501e4ee9663168dfb2b4122c768091e30217328c9faTom Carevoid CheckPrintfHandler::HandleIgnoredFlag( 1502826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const analyze_printf::PrintfSpecifier &FS, 1503e4ee9663168dfb2b4122c768091e30217328c9faTom Care const analyze_printf::OptionalFlag &ignoredFlag, 1504e4ee9663168dfb2b4122c768091e30217328c9faTom Care const analyze_printf::OptionalFlag &flag, 1505e4ee9663168dfb2b4122c768091e30217328c9faTom Care const char *startSpecifier, 1506e4ee9663168dfb2b4122c768091e30217328c9faTom Care unsigned specifierLen) { 1507e4ee9663168dfb2b4122c768091e30217328c9faTom Care // Warn about ignored flag with a fixit removal. 1508e4ee9663168dfb2b4122c768091e30217328c9faTom Care S.Diag(getLocationOfByte(ignoredFlag.getPosition()), 1509e4ee9663168dfb2b4122c768091e30217328c9faTom Care diag::warn_printf_ignored_flag) 1510e4ee9663168dfb2b4122c768091e30217328c9faTom Care << ignoredFlag.toString() << flag.toString() 1511826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek << getSpecifierRange(startSpecifier, specifierLen) 1512826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek << FixItHint::CreateRemoval(getSpecifierRange( 1513e4ee9663168dfb2b4122c768091e30217328c9faTom Care ignoredFlag.getPosition(), 1)); 1514e4ee9663168dfb2b4122c768091e30217328c9faTom Care} 1515e4ee9663168dfb2b4122c768091e30217328c9faTom Care 1516e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenekbool 1517826a3457f737f1fc45a22954fd1bfde38160c165Ted KremenekCheckPrintfHandler::HandlePrintfSpecifier(const analyze_printf::PrintfSpecifier 15185c41ee8c49995fb4fd76d686b239c15cbab261eaTed Kremenek &FS, 1519e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek const char *startSpecifier, 1520e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek unsigned specifierLen) { 1521e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 15226ecb950c65329f8d6ce9ad0514632df35a5ab61fTed Kremenek using namespace analyze_format_string; 1523efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek using namespace analyze_printf; 15246ecb950c65329f8d6ce9ad0514632df35a5ab61fTed Kremenek const PrintfConversionSpecifier &CS = FS.getConversionSpecifier(); 1525e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 1526baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek if (FS.consumesDataArgument()) { 1527baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek if (atFirstArg) { 1528baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek atFirstArg = false; 1529baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek usesPositionalArgs = FS.usesPositionalArg(); 1530baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek } 1531baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek else if (usesPositionalArgs != FS.usesPositionalArg()) { 1532baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek // Cannot mix-and-match positional and non-positional arguments. 1533baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek S.Diag(getLocationOfByte(CS.getStart()), 1534baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek diag::warn_format_mix_positional_nonpositional_args) 1535baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek << getSpecifierRange(startSpecifier, specifierLen); 1536baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek return false; 1537baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek } 1538efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek } 1539efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek 15400d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek // First check if the field width, precision, and conversion specifier 15410d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek // have matching data arguments. 1542efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek if (!HandleAmount(FS.getFieldWidth(), /* field width */ 0, 1543efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek startSpecifier, specifierLen)) { 15440d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek return false; 15450d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek } 15464e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek 1547efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek if (!HandleAmount(FS.getPrecision(), /* precision */ 1, 1548efaff195ba1fa55b6fe0b0b2435b81451387d241Ted Kremenek startSpecifier, specifierLen)) { 15490d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek return false; 15500d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek } 15510d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek 1552f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek if (!CS.consumesDataArgument()) { 1553f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek // FIXME: Technically specifying a precision or field width here 1554f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek // makes no sense. Worth issuing a warning at some point. 15550e5675de2b67eeca754754ae8d3dacba425a38e8Ted Kremenek return true; 1556f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek } 15574e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek 15587f70dc85d5055c19c8003f43a59135de211ad1b9Ted Kremenek // Consume the argument. 15597f70dc85d5055c19c8003f43a59135de211ad1b9Ted Kremenek unsigned argIndex = FS.getArgIndex(); 1560e3fc54790250076e33ad25b14e5be293514fe5eaTed Kremenek if (argIndex < NumDataArgs) { 1561e3fc54790250076e33ad25b14e5be293514fe5eaTed Kremenek // The check to see if the argIndex is valid will come later. 1562e3fc54790250076e33ad25b14e5be293514fe5eaTed Kremenek // We set the bit here because we may exit early from this 1563e3fc54790250076e33ad25b14e5be293514fe5eaTed Kremenek // function if we encounter some other error. 1564e3fc54790250076e33ad25b14e5be293514fe5eaTed Kremenek CoveredArgs.set(argIndex); 1565e3fc54790250076e33ad25b14e5be293514fe5eaTed Kremenek } 15667f70dc85d5055c19c8003f43a59135de211ad1b9Ted Kremenek 15677f70dc85d5055c19c8003f43a59135de211ad1b9Ted Kremenek // Check for using an Objective-C specific conversion specifier 15687f70dc85d5055c19c8003f43a59135de211ad1b9Ted Kremenek // in a non-ObjC literal. 15697f70dc85d5055c19c8003f43a59135de211ad1b9Ted Kremenek if (!IsObjCLiteral && CS.isObjCArg()) { 1570826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek return HandleInvalidPrintfConversionSpecifier(FS, startSpecifier, 1571826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek specifierLen); 15727f70dc85d5055c19c8003f43a59135de211ad1b9Ted Kremenek } 15734e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek 1574e4ee9663168dfb2b4122c768091e30217328c9faTom Care // Check for invalid use of field width 1575e4ee9663168dfb2b4122c768091e30217328c9faTom Care if (!FS.hasValidFieldWidth()) { 157645f9b7e8f23072d662ee1cc758f4ecb0da5e3322Tom Care HandleInvalidAmount(FS, FS.getFieldWidth(), /* field width */ 0, 1577e4ee9663168dfb2b4122c768091e30217328c9faTom Care startSpecifier, specifierLen); 1578e4ee9663168dfb2b4122c768091e30217328c9faTom Care } 1579e4ee9663168dfb2b4122c768091e30217328c9faTom Care 1580e4ee9663168dfb2b4122c768091e30217328c9faTom Care // Check for invalid use of precision 1581e4ee9663168dfb2b4122c768091e30217328c9faTom Care if (!FS.hasValidPrecision()) { 1582e4ee9663168dfb2b4122c768091e30217328c9faTom Care HandleInvalidAmount(FS, FS.getPrecision(), /* precision */ 1, 1583e4ee9663168dfb2b4122c768091e30217328c9faTom Care startSpecifier, specifierLen); 1584e4ee9663168dfb2b4122c768091e30217328c9faTom Care } 1585e4ee9663168dfb2b4122c768091e30217328c9faTom Care 1586e4ee9663168dfb2b4122c768091e30217328c9faTom Care // Check each flag does not conflict with any other component. 158765197b4b0c55bb74af0450230d61ee9461223721Ted Kremenek if (!FS.hasValidThousandsGroupingPrefix()) 158865197b4b0c55bb74af0450230d61ee9461223721Ted Kremenek HandleFlag(FS, FS.hasThousandsGrouping(), startSpecifier, specifierLen); 1589e4ee9663168dfb2b4122c768091e30217328c9faTom Care if (!FS.hasValidLeadingZeros()) 1590e4ee9663168dfb2b4122c768091e30217328c9faTom Care HandleFlag(FS, FS.hasLeadingZeros(), startSpecifier, specifierLen); 1591e4ee9663168dfb2b4122c768091e30217328c9faTom Care if (!FS.hasValidPlusPrefix()) 1592e4ee9663168dfb2b4122c768091e30217328c9faTom Care HandleFlag(FS, FS.hasPlusPrefix(), startSpecifier, specifierLen); 159345f9b7e8f23072d662ee1cc758f4ecb0da5e3322Tom Care if (!FS.hasValidSpacePrefix()) 159445f9b7e8f23072d662ee1cc758f4ecb0da5e3322Tom Care HandleFlag(FS, FS.hasSpacePrefix(), startSpecifier, specifierLen); 1595e4ee9663168dfb2b4122c768091e30217328c9faTom Care if (!FS.hasValidAlternativeForm()) 1596e4ee9663168dfb2b4122c768091e30217328c9faTom Care HandleFlag(FS, FS.hasAlternativeForm(), startSpecifier, specifierLen); 1597e4ee9663168dfb2b4122c768091e30217328c9faTom Care if (!FS.hasValidLeftJustified()) 1598e4ee9663168dfb2b4122c768091e30217328c9faTom Care HandleFlag(FS, FS.isLeftJustified(), startSpecifier, specifierLen); 1599e4ee9663168dfb2b4122c768091e30217328c9faTom Care 1600e4ee9663168dfb2b4122c768091e30217328c9faTom Care // Check that flags are not ignored by another flag 160145f9b7e8f23072d662ee1cc758f4ecb0da5e3322Tom Care if (FS.hasSpacePrefix() && FS.hasPlusPrefix()) // ' ' ignored by '+' 160245f9b7e8f23072d662ee1cc758f4ecb0da5e3322Tom Care HandleIgnoredFlag(FS, FS.hasSpacePrefix(), FS.hasPlusPrefix(), 160345f9b7e8f23072d662ee1cc758f4ecb0da5e3322Tom Care startSpecifier, specifierLen); 1604e4ee9663168dfb2b4122c768091e30217328c9faTom Care if (FS.hasLeadingZeros() && FS.isLeftJustified()) // '0' ignored by '-' 1605e4ee9663168dfb2b4122c768091e30217328c9faTom Care HandleIgnoredFlag(FS, FS.hasLeadingZeros(), FS.isLeftJustified(), 1606e4ee9663168dfb2b4122c768091e30217328c9faTom Care startSpecifier, specifierLen); 1607e4ee9663168dfb2b4122c768091e30217328c9faTom Care 1608e4ee9663168dfb2b4122c768091e30217328c9faTom Care // Check the length modifier is valid with the given conversion specifier. 1609e4ee9663168dfb2b4122c768091e30217328c9faTom Care const LengthModifier &LM = FS.getLengthModifier(); 1610e4ee9663168dfb2b4122c768091e30217328c9faTom Care if (!FS.hasValidLengthModifier()) 1611e4ee9663168dfb2b4122c768091e30217328c9faTom Care S.Diag(getLocationOfByte(LM.getStart()), 1612649aecf55670682efb2a04a85810eef4d038c527Ted Kremenek diag::warn_format_nonsensical_length) 1613e4ee9663168dfb2b4122c768091e30217328c9faTom Care << LM.toString() << CS.toString() 1614826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek << getSpecifierRange(startSpecifier, specifierLen) 1615826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek << FixItHint::CreateRemoval(getSpecifierRange(LM.getStart(), 1616e4ee9663168dfb2b4122c768091e30217328c9faTom Care LM.getLength())); 1617e4ee9663168dfb2b4122c768091e30217328c9faTom Care 1618e4ee9663168dfb2b4122c768091e30217328c9faTom Care // Are we using '%n'? 161935d353b47bce29200b910371dd9b8ba7f3058ab8Ted Kremenek if (CS.getKind() == ConversionSpecifier::nArg) { 1620e4ee9663168dfb2b4122c768091e30217328c9faTom Care // Issue a warning about this being a possible security issue. 1621e82d804ee761006250543d6fe6e98ee7896cd756Ted Kremenek S.Diag(getLocationOfByte(CS.getStart()), diag::warn_printf_write_back) 1622826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek << getSpecifierRange(startSpecifier, specifierLen); 1623e82d804ee761006250543d6fe6e98ee7896cd756Ted Kremenek // Continue checking the other format specifiers. 1624e82d804ee761006250543d6fe6e98ee7896cd756Ted Kremenek return true; 1625e82d804ee761006250543d6fe6e98ee7896cd756Ted Kremenek } 16265c41ee8c49995fb4fd76d686b239c15cbab261eaTed Kremenek 1627da51f0d136df131a0137c0ec1069fb586d8a296aTed Kremenek // The remaining checks depend on the data arguments. 1628da51f0d136df131a0137c0ec1069fb586d8a296aTed Kremenek if (HasVAListArg) 1629da51f0d136df131a0137c0ec1069fb586d8a296aTed Kremenek return true; 16304e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek 1631666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex)) 1632da51f0d136df131a0137c0ec1069fb586d8a296aTed Kremenek return false; 16334e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek 163496827eb52405a71c65c200949f3e644368e86454Michael J. Spencer // Now type check the data expression that matches the 163596827eb52405a71c65c200949f3e644368e86454Michael J. Spencer // format specifier. 163696827eb52405a71c65c200949f3e644368e86454Michael J. Spencer const Expr *Ex = getDataArg(argIndex); 163796827eb52405a71c65c200949f3e644368e86454Michael J. Spencer const analyze_printf::ArgTypeResult &ATR = FS.getArgType(S.Context); 163896827eb52405a71c65c200949f3e644368e86454Michael J. Spencer if (ATR.isValid() && !ATR.matchesType(S.Context, Ex->getType())) { 163996827eb52405a71c65c200949f3e644368e86454Michael J. Spencer // Check if we didn't match because of an implicit cast from a 'char' 164096827eb52405a71c65c200949f3e644368e86454Michael J. Spencer // or 'short' to an 'int'. This is done because printf is a varargs 164196827eb52405a71c65c200949f3e644368e86454Michael J. Spencer // function. 164296827eb52405a71c65c200949f3e644368e86454Michael J. Spencer if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Ex)) 16434d8ae4d57ed18d60da4d3786fb740607aa7c3688Ted Kremenek if (ICE->getType() == S.Context.IntTy) { 16444d8ae4d57ed18d60da4d3786fb740607aa7c3688Ted Kremenek // All further checking is done on the subexpression. 16454d8ae4d57ed18d60da4d3786fb740607aa7c3688Ted Kremenek Ex = ICE->getSubExpr(); 16464d8ae4d57ed18d60da4d3786fb740607aa7c3688Ted Kremenek if (ATR.matchesType(S.Context, Ex->getType())) 164796827eb52405a71c65c200949f3e644368e86454Michael J. Spencer return true; 16484d8ae4d57ed18d60da4d3786fb740607aa7c3688Ted Kremenek } 164996827eb52405a71c65c200949f3e644368e86454Michael J. Spencer 165096827eb52405a71c65c200949f3e644368e86454Michael J. Spencer // We may be able to offer a FixItHint if it is a supported type. 165196827eb52405a71c65c200949f3e644368e86454Michael J. Spencer PrintfSpecifier fixedFS = FS; 165296827eb52405a71c65c200949f3e644368e86454Michael J. Spencer bool success = fixedFS.fixType(Ex->getType()); 165396827eb52405a71c65c200949f3e644368e86454Michael J. Spencer 165496827eb52405a71c65c200949f3e644368e86454Michael J. Spencer if (success) { 165596827eb52405a71c65c200949f3e644368e86454Michael J. Spencer // Get the fix string from the fixed format specifier 165696827eb52405a71c65c200949f3e644368e86454Michael J. Spencer llvm::SmallString<128> buf; 165796827eb52405a71c65c200949f3e644368e86454Michael J. Spencer llvm::raw_svector_ostream os(buf); 165896827eb52405a71c65c200949f3e644368e86454Michael J. Spencer fixedFS.toString(os); 165996827eb52405a71c65c200949f3e644368e86454Michael J. Spencer 16609325eaf08fcccbc0d038e703f570c64daacdaa31Ted Kremenek // FIXME: getRepresentativeType() perhaps should return a string 16619325eaf08fcccbc0d038e703f570c64daacdaa31Ted Kremenek // instead of a QualType to better handle when the representative 16629325eaf08fcccbc0d038e703f570c64daacdaa31Ted Kremenek // type is 'wint_t' (which is defined in the system headers). 166396827eb52405a71c65c200949f3e644368e86454Michael J. Spencer S.Diag(getLocationOfByte(CS.getStart()), 166496827eb52405a71c65c200949f3e644368e86454Michael J. Spencer diag::warn_printf_conversion_argument_type_mismatch) 166596827eb52405a71c65c200949f3e644368e86454Michael J. Spencer << ATR.getRepresentativeType(S.Context) << Ex->getType() 166696827eb52405a71c65c200949f3e644368e86454Michael J. Spencer << getSpecifierRange(startSpecifier, specifierLen) 166796827eb52405a71c65c200949f3e644368e86454Michael J. Spencer << Ex->getSourceRange() 166896827eb52405a71c65c200949f3e644368e86454Michael J. Spencer << FixItHint::CreateReplacement( 166996827eb52405a71c65c200949f3e644368e86454Michael J. Spencer getSpecifierRange(startSpecifier, specifierLen), 167096827eb52405a71c65c200949f3e644368e86454Michael J. Spencer os.str()); 167196827eb52405a71c65c200949f3e644368e86454Michael J. Spencer } 167296827eb52405a71c65c200949f3e644368e86454Michael J. Spencer else { 167396827eb52405a71c65c200949f3e644368e86454Michael J. Spencer S.Diag(getLocationOfByte(CS.getStart()), 167496827eb52405a71c65c200949f3e644368e86454Michael J. Spencer diag::warn_printf_conversion_argument_type_mismatch) 167596827eb52405a71c65c200949f3e644368e86454Michael J. Spencer << ATR.getRepresentativeType(S.Context) << Ex->getType() 167696827eb52405a71c65c200949f3e644368e86454Michael J. Spencer << getSpecifierRange(startSpecifier, specifierLen) 167796827eb52405a71c65c200949f3e644368e86454Michael J. Spencer << Ex->getSourceRange(); 167896827eb52405a71c65c200949f3e644368e86454Michael J. Spencer } 167996827eb52405a71c65c200949f3e644368e86454Michael J. Spencer } 168096827eb52405a71c65c200949f3e644368e86454Michael J. Spencer 1681e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek return true; 1682e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek} 1683e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 1684826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek//===--- CHECK: Scanf format string checking ------------------------------===// 1685826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1686826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremeneknamespace { 1687826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenekclass CheckScanfHandler : public CheckFormatHandler { 1688826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenekpublic: 1689826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek CheckScanfHandler(Sema &s, const StringLiteral *fexpr, 1690826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const Expr *origFormatExpr, unsigned firstDataArg, 1691826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek unsigned numDataArgs, bool isObjCLiteral, 1692826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const char *beg, bool hasVAListArg, 1693826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const CallExpr *theCall, unsigned formatIdx) 1694826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek : CheckFormatHandler(s, fexpr, origFormatExpr, firstDataArg, 1695826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek numDataArgs, isObjCLiteral, beg, hasVAListArg, 1696826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek theCall, formatIdx) {} 1697826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1698826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek bool HandleScanfSpecifier(const analyze_scanf::ScanfSpecifier &FS, 1699826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const char *startSpecifier, 1700826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek unsigned specifierLen); 1701c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek 1702c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek bool HandleInvalidScanfConversionSpecifier( 1703c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek const analyze_scanf::ScanfSpecifier &FS, 1704c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek const char *startSpecifier, 1705c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek unsigned specifierLen); 1706b7c21018ec1049580cf6df88db09e606550a7baaTed Kremenek 1707b7c21018ec1049580cf6df88db09e606550a7baaTed Kremenek void HandleIncompleteScanList(const char *start, const char *end); 1708826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek}; 1709826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek} 1710826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1711b7c21018ec1049580cf6df88db09e606550a7baaTed Kremenekvoid CheckScanfHandler::HandleIncompleteScanList(const char *start, 1712b7c21018ec1049580cf6df88db09e606550a7baaTed Kremenek const char *end) { 1713b7c21018ec1049580cf6df88db09e606550a7baaTed Kremenek S.Diag(getLocationOfByte(end), diag::warn_scanf_scanlist_incomplete) 1714b7c21018ec1049580cf6df88db09e606550a7baaTed Kremenek << getSpecifierRange(start, end - start); 1715b7c21018ec1049580cf6df88db09e606550a7baaTed Kremenek} 1716b7c21018ec1049580cf6df88db09e606550a7baaTed Kremenek 1717c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenekbool CheckScanfHandler::HandleInvalidScanfConversionSpecifier( 1718c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek const analyze_scanf::ScanfSpecifier &FS, 1719c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek const char *startSpecifier, 1720c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek unsigned specifierLen) { 1721c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek 17226ecb950c65329f8d6ce9ad0514632df35a5ab61fTed Kremenek const analyze_scanf::ScanfConversionSpecifier &CS = 1723c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek FS.getConversionSpecifier(); 1724c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek 1725c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek return HandleInvalidConversionSpecifier(FS.getArgIndex(), 1726c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek getLocationOfByte(CS.getStart()), 1727c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek startSpecifier, specifierLen, 1728c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek CS.getStart(), CS.getLength()); 1729c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek} 1730c09b6a59e02ae265fce51b8c11e2a045bcdaa888Ted Kremenek 1731826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenekbool CheckScanfHandler::HandleScanfSpecifier( 1732826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const analyze_scanf::ScanfSpecifier &FS, 1733826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const char *startSpecifier, 1734826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek unsigned specifierLen) { 1735826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1736826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek using namespace analyze_scanf; 1737826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek using namespace analyze_format_string; 1738826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 17396ecb950c65329f8d6ce9ad0514632df35a5ab61fTed Kremenek const ScanfConversionSpecifier &CS = FS.getConversionSpecifier(); 1740826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1741baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek // Handle case where '%' and '*' don't consume an argument. These shouldn't 1742baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek // be used to decide if we are using positional arguments consistently. 1743baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek if (FS.consumesDataArgument()) { 1744baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek if (atFirstArg) { 1745baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek atFirstArg = false; 1746baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek usesPositionalArgs = FS.usesPositionalArg(); 1747baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek } 1748baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek else if (usesPositionalArgs != FS.usesPositionalArg()) { 1749baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek // Cannot mix-and-match positional and non-positional arguments. 1750baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek S.Diag(getLocationOfByte(CS.getStart()), 1751baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek diag::warn_format_mix_positional_nonpositional_args) 1752baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek << getSpecifierRange(startSpecifier, specifierLen); 1753baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek return false; 1754baa400654bd6f8396f9a07188445ae7955b060a3Ted Kremenek } 1755826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek } 1756826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1757826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek // Check if the field with is non-zero. 1758826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const OptionalAmount &Amt = FS.getFieldWidth(); 1759826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek if (Amt.getHowSpecified() == OptionalAmount::Constant) { 1760826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek if (Amt.getConstantAmount() == 0) { 1761826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek const CharSourceRange &R = getSpecifierRange(Amt.getStart(), 1762826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek Amt.getConstantLength()); 1763826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek S.Diag(getLocationOfByte(Amt.getStart()), 1764826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek diag::warn_scanf_nonzero_width) 1765826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek << R << FixItHint::CreateRemoval(R); 17667f70dc85d5055c19c8003f43a59135de211ad1b9Ted Kremenek } 17677f70dc85d5055c19c8003f43a59135de211ad1b9Ted Kremenek } 1768826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1769826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek if (!FS.consumesDataArgument()) { 1770826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek // FIXME: Technically specifying a precision or field width here 1771826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek // makes no sense. Worth issuing a warning at some point. 1772826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek return true; 1773826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek } 1774826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1775826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek // Consume the argument. 1776826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek unsigned argIndex = FS.getArgIndex(); 1777826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek if (argIndex < NumDataArgs) { 1778826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek // The check to see if the argIndex is valid will come later. 1779826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek // We set the bit here because we may exit early from this 1780826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek // function if we encounter some other error. 1781826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek CoveredArgs.set(argIndex); 1782826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek } 1783826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 17841e51c200b17cb6b0238c10a8760ae04765688f16Ted Kremenek // Check the length modifier is valid with the given conversion specifier. 17851e51c200b17cb6b0238c10a8760ae04765688f16Ted Kremenek const LengthModifier &LM = FS.getLengthModifier(); 17861e51c200b17cb6b0238c10a8760ae04765688f16Ted Kremenek if (!FS.hasValidLengthModifier()) { 17871e51c200b17cb6b0238c10a8760ae04765688f16Ted Kremenek S.Diag(getLocationOfByte(LM.getStart()), 17881e51c200b17cb6b0238c10a8760ae04765688f16Ted Kremenek diag::warn_format_nonsensical_length) 17891e51c200b17cb6b0238c10a8760ae04765688f16Ted Kremenek << LM.toString() << CS.toString() 17901e51c200b17cb6b0238c10a8760ae04765688f16Ted Kremenek << getSpecifierRange(startSpecifier, specifierLen) 17911e51c200b17cb6b0238c10a8760ae04765688f16Ted Kremenek << FixItHint::CreateRemoval(getSpecifierRange(LM.getStart(), 17921e51c200b17cb6b0238c10a8760ae04765688f16Ted Kremenek LM.getLength())); 17931e51c200b17cb6b0238c10a8760ae04765688f16Ted Kremenek } 17941e51c200b17cb6b0238c10a8760ae04765688f16Ted Kremenek 1795826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek // The remaining checks depend on the data arguments. 1796826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek if (HasVAListArg) 1797826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek return true; 1798826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1799666a197deb75d95c78ddd39274af1a54240828d8Ted Kremenek if (!CheckNumArgs(FS, CS, startSpecifier, specifierLen, argIndex)) 1800826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek return false; 1801826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1802826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek // FIXME: Check that the argument type matches the format specifier. 1803826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1804826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek return true; 180507d161f38e708a91486bf1c031d525faebbb249dTed Kremenek} 1806e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 1807826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenekvoid Sema::CheckFormatString(const StringLiteral *FExpr, 18080e5675de2b67eeca754754ae8d3dacba425a38e8Ted Kremenek const Expr *OrigFormatExpr, 18090e5675de2b67eeca754754ae8d3dacba425a38e8Ted Kremenek const CallExpr *TheCall, bool HasVAListArg, 1810826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek unsigned format_idx, unsigned firstDataArg, 1811826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek bool isPrintf) { 1812826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1813e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek // CHECK: is the format string a wide literal? 18145cee1195584fa8672253139c86e922daeda69b9eDouglas Gregor if (!FExpr->isAscii()) { 1815e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek Diag(FExpr->getLocStart(), 1816826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek diag::warn_format_string_is_wide_literal) 1817e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek << OrigFormatExpr->getSourceRange(); 1818e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek return; 1819e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek } 1820826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1821e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek // Str - The format string. NOTE: this is NOT null-terminated! 18225f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner StringRef StrRef = FExpr->getString(); 18232f4eaef37476ae6891ede8ba215d0f6fd093629bBenjamin Kramer const char *Str = StrRef.data(); 18242f4eaef37476ae6891ede8ba215d0f6fd093629bBenjamin Kramer unsigned StrLen = StrRef.size(); 1825826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1826e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek // CHECK: empty format string? 1827e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek if (StrLen == 0) { 1828826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek Diag(FExpr->getLocStart(), diag::warn_empty_format_string) 1829e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek << OrigFormatExpr->getSourceRange(); 1830e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek return; 1831e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek } 1832826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1833826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek if (isPrintf) { 1834826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek CheckPrintfHandler H(*this, FExpr, OrigFormatExpr, firstDataArg, 1835826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek TheCall->getNumArgs() - firstDataArg, 1836826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek isa<ObjCStringLiteral>(OrigFormatExpr), Str, 1837826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek HasVAListArg, TheCall, format_idx); 1838826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1839826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek if (!analyze_format_string::ParsePrintfString(H, Str, Str + StrLen)) 1840826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek H.DoneProcessing(); 1841826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek } 1842826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek else { 1843826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek CheckScanfHandler H(*this, FExpr, OrigFormatExpr, firstDataArg, 1844826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek TheCall->getNumArgs() - firstDataArg, 1845826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek isa<ObjCStringLiteral>(OrigFormatExpr), Str, 1846826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek HasVAListArg, TheCall, format_idx); 1847826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek 1848826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek if (!analyze_format_string::ParseScanfString(H, Str, Str + StrLen)) 1849826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek H.DoneProcessing(); 1850826a3457f737f1fc45a22954fd1bfde38160c165Ted Kremenek } 1851ce7024e8a3793b05861a4904ecdb1272924ada14Ted Kremenek} 1852ce7024e8a3793b05861a4904ecdb1272924ada14Ted Kremenek 18537ccc95bceebb2d1c8fbe277c9e33bde7dc1ccbb1Chandler Carruth//===--- CHECK: Standard memory functions ---------------------------------===// 18547ccc95bceebb2d1c8fbe277c9e33bde7dc1ccbb1Chandler Carruth 18552a053a33707eba9e642adedb557b1a6aace103b5Douglas Gregor/// \brief Determine whether the given type is a dynamic class type (e.g., 18562a053a33707eba9e642adedb557b1a6aace103b5Douglas Gregor/// whether it has a vtable). 18572a053a33707eba9e642adedb557b1a6aace103b5Douglas Gregorstatic bool isDynamicClassType(QualType T) { 18582a053a33707eba9e642adedb557b1a6aace103b5Douglas Gregor if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) 18592a053a33707eba9e642adedb557b1a6aace103b5Douglas Gregor if (CXXRecordDecl *Definition = Record->getDefinition()) 18602a053a33707eba9e642adedb557b1a6aace103b5Douglas Gregor if (Definition->isDynamicClass()) 18612a053a33707eba9e642adedb557b1a6aace103b5Douglas Gregor return true; 18622a053a33707eba9e642adedb557b1a6aace103b5Douglas Gregor 18632a053a33707eba9e642adedb557b1a6aace103b5Douglas Gregor return false; 18642a053a33707eba9e642adedb557b1a6aace103b5Douglas Gregor} 18652a053a33707eba9e642adedb557b1a6aace103b5Douglas Gregor 1866a72a12f3baed07f2663e48c5fc3b670c68dffe0cChandler Carruth/// \brief If E is a sizeof expression, returns its argument expression, 1867000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth/// otherwise returns NULL. 1868000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruthstatic const Expr *getSizeOfExprArg(const Expr* E) { 1869e4a1c64700304459ac436fe29cb498f2da3b6194Nico Weber if (const UnaryExprOrTypeTraitExpr *SizeOf = 1870000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth dyn_cast<UnaryExprOrTypeTraitExpr>(E)) 1871000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth if (SizeOf->getKind() == clang::UETT_SizeOf && !SizeOf->isArgumentType()) 1872000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth return SizeOf->getArgumentExpr()->IgnoreParenImpCasts(); 1873e4a1c64700304459ac436fe29cb498f2da3b6194Nico Weber 1874000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth return 0; 1875000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth} 1876000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth 1877a72a12f3baed07f2663e48c5fc3b670c68dffe0cChandler Carruth/// \brief If E is a sizeof expression, returns its argument type. 1878000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruthstatic QualType getSizeOfArgType(const Expr* E) { 1879000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth if (const UnaryExprOrTypeTraitExpr *SizeOf = 1880000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth dyn_cast<UnaryExprOrTypeTraitExpr>(E)) 1881000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth if (SizeOf->getKind() == clang::UETT_SizeOf) 1882000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth return SizeOf->getTypeOfArgument(); 1883000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth 1884000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth return QualType(); 1885e4a1c64700304459ac436fe29cb498f2da3b6194Nico Weber} 1886e4a1c64700304459ac436fe29cb498f2da3b6194Nico Weber 18877ccc95bceebb2d1c8fbe277c9e33bde7dc1ccbb1Chandler Carruth/// \brief Check for dangerous or invalid arguments to memset(). 18887ccc95bceebb2d1c8fbe277c9e33bde7dc1ccbb1Chandler Carruth/// 1889929f0135ab60166202f52e0dd19835c0490d792aChandler Carruth/// This issues warnings on known problematic, dangerous or unspecified 1890cc2f30c4ed7770b6005bd55b529a55c1fcc250fcMatt Beaumont-Gay/// arguments to the standard 'memset', 'memcpy', 'memmove', and 'memcmp' 1891cc2f30c4ed7770b6005bd55b529a55c1fcc250fcMatt Beaumont-Gay/// function calls. 18927ccc95bceebb2d1c8fbe277c9e33bde7dc1ccbb1Chandler Carruth/// 18937ccc95bceebb2d1c8fbe277c9e33bde7dc1ccbb1Chandler Carruth/// \param Call The call expression to diagnose. 1894cc2f30c4ed7770b6005bd55b529a55c1fcc250fcMatt Beaumont-Gayvoid Sema::CheckMemaccessArguments(const CallExpr *Call, 1895cc2f30c4ed7770b6005bd55b529a55c1fcc250fcMatt Beaumont-Gay CheckedMemoryFunction CMF, 1896cc2f30c4ed7770b6005bd55b529a55c1fcc250fcMatt Beaumont-Gay IdentifierInfo *FnName) { 18971d59f7f8fb39fa44ddbb6e2abd321af863b1f55bTed Kremenek // It is possible to have a non-standard definition of memset. Validate 1898707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor // we have enough arguments, and if not, abort further checking. 1899707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor if (Call->getNumArgs() < 3) 19001d59f7f8fb39fa44ddbb6e2abd321af863b1f55bTed Kremenek return; 19011d59f7f8fb39fa44ddbb6e2abd321af863b1f55bTed Kremenek 1902707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor unsigned LastArg = (CMF == CMF_Memset? 1 : 2); 1903e4a1c64700304459ac436fe29cb498f2da3b6194Nico Weber const Expr *LenExpr = Call->getArg(2)->IgnoreParenImpCasts(); 1904000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth 1905000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth // We have special checking when the length is a sizeof expression. 1906000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth QualType SizeOfArgTy = getSizeOfArgType(LenExpr); 1907000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth const Expr *SizeOfArg = getSizeOfExprArg(LenExpr); 1908000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth llvm::FoldingSetNodeID SizeOfArgID; 1909000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth 191006bc9eb9908e42696775b395b290827bde468c8bDouglas Gregor for (unsigned ArgIdx = 0; ArgIdx != LastArg; ++ArgIdx) { 191106bc9eb9908e42696775b395b290827bde468c8bDouglas Gregor const Expr *Dest = Call->getArg(ArgIdx)->IgnoreParenImpCasts(); 1912e4a1c64700304459ac436fe29cb498f2da3b6194Nico Weber SourceRange ArgRange = Call->getArg(ArgIdx)->getSourceRange(); 191306bc9eb9908e42696775b395b290827bde468c8bDouglas Gregor 191406bc9eb9908e42696775b395b290827bde468c8bDouglas Gregor QualType DestTy = Dest->getType(); 191506bc9eb9908e42696775b395b290827bde468c8bDouglas Gregor if (const PointerType *DestPtrTy = DestTy->getAs<PointerType>()) { 191606bc9eb9908e42696775b395b290827bde468c8bDouglas Gregor QualType PointeeTy = DestPtrTy->getPointeeType(); 1917f85e193739c953358c865005855253af4f68a497John McCall 1918000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth // Never warn about void type pointers. This can be used to suppress 1919000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth // false positives. 1920000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth if (PointeeTy->isVoidType()) 192106bc9eb9908e42696775b395b290827bde468c8bDouglas Gregor continue; 192206bc9eb9908e42696775b395b290827bde468c8bDouglas Gregor 1923000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth // Catch "memset(p, 0, sizeof(p))" -- needs to be sizeof(*p). Do this by 1924000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth // actually comparing the expressions for equality. Because computing the 1925000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth // expression IDs can be expensive, we only do this if the diagnostic is 1926000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth // enabled. 1927000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth if (SizeOfArg && 1928000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth Diags.getDiagnosticLevel(diag::warn_sizeof_pointer_expr_memaccess, 1929000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth SizeOfArg->getExprLoc())) { 1930000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth // We only compute IDs for expressions if the warning is enabled, and 1931000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth // cache the sizeof arg's ID. 1932000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth if (SizeOfArgID == llvm::FoldingSetNodeID()) 1933000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth SizeOfArg->Profile(SizeOfArgID, Context, true); 1934000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth llvm::FoldingSetNodeID DestID; 1935000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth Dest->Profile(DestID, Context, true); 1936000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth if (DestID == SizeOfArgID) { 1937000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth unsigned ActionIdx = 0; // Default is to suggest dereferencing. 1938000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth if (const UnaryOperator *UnaryOp = dyn_cast<UnaryOperator>(Dest)) 1939000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth if (UnaryOp->getOpcode() == UO_AddrOf) 1940000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth ActionIdx = 1; // If its an address-of operator, just remove it. 1941000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth if (Context.getTypeSize(PointeeTy) == Context.getCharWidth()) 1942000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth ActionIdx = 2; // If the pointee's size is sizeof(char), 1943000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth // suggest an explicit length. 1944000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth DiagRuntimeBehavior(SizeOfArg->getExprLoc(), Dest, 1945000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth PDiag(diag::warn_sizeof_pointer_expr_memaccess) 1946000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth << FnName << ArgIdx << ActionIdx 1947000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth << Dest->getSourceRange() 1948000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth << SizeOfArg->getSourceRange()); 1949000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth break; 1950000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth } 1951000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth } 1952000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth 1953000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth // Also check for cases where the sizeof argument is the exact same 1954000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth // type as the memory argument, and where it points to a user-defined 1955000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth // record type. 1956000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth if (SizeOfArgTy != QualType()) { 1957000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth if (PointeeTy->isRecordType() && 1958000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth Context.typesAreCompatible(SizeOfArgTy, DestTy)) { 1959000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth DiagRuntimeBehavior(LenExpr->getExprLoc(), Dest, 1960000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth PDiag(diag::warn_sizeof_pointer_type_memaccess) 1961000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth << FnName << SizeOfArgTy << ArgIdx 1962000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth << PointeeTy << Dest->getSourceRange() 1963000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth << LenExpr->getSourceRange()); 1964000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth break; 1965000d428347f352979e0f6dffcf0a64e73af0a2b5Chandler Carruth } 1966e4a1c64700304459ac436fe29cb498f2da3b6194Nico Weber } 1967e4a1c64700304459ac436fe29cb498f2da3b6194Nico Weber 1968f85e193739c953358c865005855253af4f68a497John McCall unsigned DiagID; 1969f85e193739c953358c865005855253af4f68a497John McCall 197006bc9eb9908e42696775b395b290827bde468c8bDouglas Gregor // Always complain about dynamic classes. 1971f85e193739c953358c865005855253af4f68a497John McCall if (isDynamicClassType(PointeeTy)) 1972f85e193739c953358c865005855253af4f68a497John McCall DiagID = diag::warn_dyn_class_memaccess; 1973707a23e8b87410332b55bb4534fa1c799edef38aDouglas Gregor else if (PointeeTy.hasNonTrivialObjCLifetime() && CMF != CMF_Memset) 1974f85e193739c953358c865005855253af4f68a497John McCall DiagID = diag::warn_arc_object_memaccess; 1975f85e193739c953358c865005855253af4f68a497John McCall else 197606bc9eb9908e42696775b395b290827bde468c8bDouglas Gregor continue; 1977f85e193739c953358c865005855253af4f68a497John McCall 1978f85e193739c953358c865005855253af4f68a497John McCall DiagRuntimeBehavior( 1979f85e193739c953358c865005855253af4f68a497John McCall Dest->getExprLoc(), Dest, 1980f85e193739c953358c865005855253af4f68a497John McCall PDiag(DiagID) 1981f85e193739c953358c865005855253af4f68a497John McCall << ArgIdx << FnName << PointeeTy 1982f85e193739c953358c865005855253af4f68a497John McCall << Call->getCallee()->getSourceRange()); 198306bc9eb9908e42696775b395b290827bde468c8bDouglas Gregor 198406bc9eb9908e42696775b395b290827bde468c8bDouglas Gregor DiagRuntimeBehavior( 198506bc9eb9908e42696775b395b290827bde468c8bDouglas Gregor Dest->getExprLoc(), Dest, 1986929f0135ab60166202f52e0dd19835c0490d792aChandler Carruth PDiag(diag::note_bad_memaccess_silence) 198706bc9eb9908e42696775b395b290827bde468c8bDouglas Gregor << FixItHint::CreateInsertion(ArgRange.getBegin(), "(void*)")); 198806bc9eb9908e42696775b395b290827bde468c8bDouglas Gregor break; 198906bc9eb9908e42696775b395b290827bde468c8bDouglas Gregor } 19907ccc95bceebb2d1c8fbe277c9e33bde7dc1ccbb1Chandler Carruth } 19917ccc95bceebb2d1c8fbe277c9e33bde7dc1ccbb1Chandler Carruth} 19927ccc95bceebb2d1c8fbe277c9e33bde7dc1ccbb1Chandler Carruth 199306de276fff91264437fa75111ed76de43097e089Ted Kremenek//===--- CHECK: Return Address of Stack Variable --------------------------===// 199406de276fff91264437fa75111ed76de43097e089Ted Kremenek 19955f9e272e632e951b1efe824cd16acb4d96077930Chris Lattnerstatic Expr *EvalVal(Expr *E, SmallVectorImpl<DeclRefExpr *> &refVars); 19965f9e272e632e951b1efe824cd16acb4d96077930Chris Lattnerstatic Expr *EvalAddr(Expr* E, SmallVectorImpl<DeclRefExpr *> &refVars); 199706de276fff91264437fa75111ed76de43097e089Ted Kremenek 199806de276fff91264437fa75111ed76de43097e089Ted Kremenek/// CheckReturnStackAddr - Check if a return statement returns the address 199906de276fff91264437fa75111ed76de43097e089Ted Kremenek/// of a stack variable. 200006de276fff91264437fa75111ed76de43097e089Ted Kremenekvoid 200106de276fff91264437fa75111ed76de43097e089Ted KremenekSema::CheckReturnStackAddr(Expr *RetValExp, QualType lhsType, 200206de276fff91264437fa75111ed76de43097e089Ted Kremenek SourceLocation ReturnLoc) { 20031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 200426e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis Expr *stackE = 0; 20055f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<DeclRefExpr *, 8> refVars; 20064e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek 200726e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // Perform checking for returned stack addresses, local blocks, 200826e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // label addresses or references to temporaries. 2009f85e193739c953358c865005855253af4f68a497John McCall if (lhsType->isPointerType() || 2010f85e193739c953358c865005855253af4f68a497John McCall (!getLangOptions().ObjCAutoRefCount && lhsType->isBlockPointerType())) { 201126e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis stackE = EvalAddr(RetValExp, refVars); 2012ac5fc7c6bcb494b60fee7ce615ac931c5db6135eMike Stump } else if (lhsType->isReferenceType()) { 201326e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis stackE = EvalVal(RetValExp, refVars); 201426e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis } 201526e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis 201626e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis if (stackE == 0) 201726e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis return; // Nothing suspicious was found. 201826e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis 201926e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis SourceLocation diagLoc; 202026e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis SourceRange diagRange; 202126e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis if (refVars.empty()) { 202226e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis diagLoc = stackE->getLocStart(); 202326e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis diagRange = stackE->getSourceRange(); 202426e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis } else { 202526e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // We followed through a reference variable. 'stackE' contains the 202626e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // problematic expression but we will warn at the return statement pointing 202726e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // at the reference variable. We will later display the "trail" of 202826e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // reference variables using notes. 202926e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis diagLoc = refVars[0]->getLocStart(); 203026e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis diagRange = refVars[0]->getSourceRange(); 203126e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis } 203226e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis 203326e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis if (DeclRefExpr *DR = dyn_cast<DeclRefExpr>(stackE)) { //address of local var. 203426e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis Diag(diagLoc, lhsType->isReferenceType() ? diag::warn_ret_stack_ref 203526e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis : diag::warn_ret_stack_addr) 203626e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis << DR->getDecl()->getDeclName() << diagRange; 203726e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis } else if (isa<BlockExpr>(stackE)) { // local block. 203826e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis Diag(diagLoc, diag::err_ret_local_block) << diagRange; 203926e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis } else if (isa<AddrLabelExpr>(stackE)) { // address of label. 204026e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis Diag(diagLoc, diag::warn_ret_addr_label) << diagRange; 204126e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis } else { // local temporary. 204226e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis Diag(diagLoc, lhsType->isReferenceType() ? diag::warn_ret_local_temp_ref 204326e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis : diag::warn_ret_local_temp_addr) 204426e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis << diagRange; 204526e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis } 204626e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis 204726e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // Display the "trail" of reference variables that we followed until we 204826e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // found the problematic expression using notes. 204926e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis for (unsigned i = 0, e = refVars.size(); i != e; ++i) { 205026e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis VarDecl *VD = cast<VarDecl>(refVars[i]->getDecl()); 205126e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // If this var binds to another reference var, show the range of the next 205226e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // var, otherwise the var binds to the problematic expression, in which case 205326e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // show the range of the expression. 205426e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis SourceRange range = (i < e-1) ? refVars[i+1]->getSourceRange() 205526e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis : stackE->getSourceRange(); 205626e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis Diag(VD->getLocation(), diag::note_ref_var_local_bind) 205726e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis << VD->getDeclName() << range; 205806de276fff91264437fa75111ed76de43097e089Ted Kremenek } 205906de276fff91264437fa75111ed76de43097e089Ted Kremenek} 206006de276fff91264437fa75111ed76de43097e089Ted Kremenek 206106de276fff91264437fa75111ed76de43097e089Ted Kremenek/// EvalAddr - EvalAddr and EvalVal are mutually recursive functions that 206206de276fff91264437fa75111ed76de43097e089Ted Kremenek/// check if the expression in a return statement evaluates to an address 206326e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis/// to a location on the stack, a local block, an address of a label, or a 206426e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis/// reference to local temporary. The recursion is used to traverse the 206506de276fff91264437fa75111ed76de43097e089Ted Kremenek/// AST of the return expression, with recursion backtracking when we 206626e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis/// encounter a subexpression that (1) clearly does not lead to one of the 206726e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis/// above problematic expressions (2) is something we cannot determine leads to 206826e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis/// a problematic expression based on such local checking. 206926e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis/// 207026e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis/// Both EvalAddr and EvalVal follow through reference variables to evaluate 207126e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis/// the expression that they point to. Such variables are added to the 207226e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis/// 'refVars' vector so that we know what the reference variable "trail" was. 207306de276fff91264437fa75111ed76de43097e089Ted Kremenek/// 2074e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek/// EvalAddr processes expressions that are pointers that are used as 2075e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek/// references (and not L-values). EvalVal handles all other values. 207626e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis/// At the base case of the recursion is a check for the above problematic 207726e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis/// expressions. 207806de276fff91264437fa75111ed76de43097e089Ted Kremenek/// 207906de276fff91264437fa75111ed76de43097e089Ted Kremenek/// This implementation handles: 208006de276fff91264437fa75111ed76de43097e089Ted Kremenek/// 208106de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * pointer-to-pointer casts 208206de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * implicit conversions from array references to pointers 208306de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * taking the address of fields 208406de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * arbitrary interplay between "&" and "*" operators 208506de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * pointer arithmetic from an address of a stack variable 208606de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * taking the address of an array element where the array is on the stack 20875f9e272e632e951b1efe824cd16acb4d96077930Chris Lattnerstatic Expr *EvalAddr(Expr *E, SmallVectorImpl<DeclRefExpr *> &refVars) { 208826e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis if (E->isTypeDependent()) 208926e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis return NULL; 209026e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis 209106de276fff91264437fa75111ed76de43097e089Ted Kremenek // We should only be called for evaluating pointer expressions. 20920f436560640a1cff5b6d96f80f540770f139453fDavid Chisnall assert((E->getType()->isAnyPointerType() || 2093dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff E->getType()->isBlockPointerType() || 2094a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek E->getType()->isObjCQualifiedIdType()) && 2095fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner "EvalAddr only works on pointers"); 20961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2097f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne E = E->IgnoreParens(); 2098f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne 209906de276fff91264437fa75111ed76de43097e089Ted Kremenek // Our "symbolic interpreter" is just a dispatch off the currently 210006de276fff91264437fa75111ed76de43097e089Ted Kremenek // viewed AST node. We then recursively traverse the AST by calling 210106de276fff91264437fa75111ed76de43097e089Ted Kremenek // EvalAddr and EvalVal appropriately. 210206de276fff91264437fa75111ed76de43097e089Ted Kremenek switch (E->getStmtClass()) { 210326e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis case Stmt::DeclRefExprClass: { 210426e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis DeclRefExpr *DR = cast<DeclRefExpr>(E); 210526e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis 210626e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis if (VarDecl *V = dyn_cast<VarDecl>(DR->getDecl())) 210726e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // If this is a reference variable, follow through to the expression that 210826e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // it points to. 210926e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis if (V->hasLocalStorage() && 211026e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis V->getType()->isReferenceType() && V->hasInit()) { 211126e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // Add the reference variable to the "trail". 211226e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis refVars.push_back(DR); 211326e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis return EvalAddr(V->getInit(), refVars); 211426e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis } 211526e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis 211626e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis return NULL; 211726e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis } 211806de276fff91264437fa75111ed76de43097e089Ted Kremenek 2119fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case Stmt::UnaryOperatorClass: { 2120fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // The only unary operator that make sense to handle here 2121fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // is AddrOf. All others don't make sense as pointers. 2122fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner UnaryOperator *U = cast<UnaryOperator>(E); 21231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 21242de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (U->getOpcode() == UO_AddrOf) 212526e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis return EvalVal(U->getSubExpr(), refVars); 2126fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner else 2127fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return NULL; 2128fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 21291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2130fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case Stmt::BinaryOperatorClass: { 2131fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Handle pointer arithmetic. All other binary operators are not valid 2132fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // in this context. 2133fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner BinaryOperator *B = cast<BinaryOperator>(E); 21342de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall BinaryOperatorKind op = B->getOpcode(); 21351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 21362de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (op != BO_Add && op != BO_Sub) 2137fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return NULL; 21381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2139fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner Expr *Base = B->getLHS(); 21403907323dd6665c0c4e383435cb145233f4533406Anders Carlsson 2141fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Determine which argument is the real pointer base. It could be 2142fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // the RHS argument instead of the LHS. 2143fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner if (!Base->getType()->isPointerType()) Base = B->getRHS(); 21441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2145fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner assert (Base->getType()->isPointerType()); 214626e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis return EvalAddr(Base, refVars); 2147fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 214861f40a2b67fc2046768e14f66b617e564cbcc3d8Steve Naroff 2149fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // For conditional operators we need to see if either the LHS or RHS are 2150fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // valid DeclRefExpr*s. If one of them is valid, we return it. 2151fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case Stmt::ConditionalOperatorClass: { 2152fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner ConditionalOperator *C = cast<ConditionalOperator>(E); 21531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2154fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Handle the GNU extension for missing LHS. 21559ee5ee84f0ad8246bff105786a128c7a909fdf12Douglas Gregor if (Expr *lhsExpr = C->getLHS()) { 21569ee5ee84f0ad8246bff105786a128c7a909fdf12Douglas Gregor // In C++, we can have a throw-expression, which has 'void' type. 21579ee5ee84f0ad8246bff105786a128c7a909fdf12Douglas Gregor if (!lhsExpr->getType()->isVoidType()) 215826e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis if (Expr* LHS = EvalAddr(lhsExpr, refVars)) 21599ee5ee84f0ad8246bff105786a128c7a909fdf12Douglas Gregor return LHS; 21609ee5ee84f0ad8246bff105786a128c7a909fdf12Douglas Gregor } 21619ee5ee84f0ad8246bff105786a128c7a909fdf12Douglas Gregor 21629ee5ee84f0ad8246bff105786a128c7a909fdf12Douglas Gregor // In C++, we can have a throw-expression, which has 'void' type. 21639ee5ee84f0ad8246bff105786a128c7a909fdf12Douglas Gregor if (C->getRHS()->getType()->isVoidType()) 21649ee5ee84f0ad8246bff105786a128c7a909fdf12Douglas Gregor return NULL; 216506de276fff91264437fa75111ed76de43097e089Ted Kremenek 216626e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis return EvalAddr(C->getRHS(), refVars); 2167fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 216826e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis 216926e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis case Stmt::BlockExprClass: 2170469a1eb996e1cb0be54f9b210f836afbddcbb2ccJohn McCall if (cast<BlockExpr>(E)->getBlockDecl()->hasCaptures()) 217126e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis return E; // local block. 217226e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis return NULL; 217326e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis 217426e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis case Stmt::AddrLabelExprClass: 217526e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis return E; // address of label. 21761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 217754b5274f2c190331438375ad114dad12ae098b57Ted Kremenek // For casts, we need to handle conversions from arrays to 217854b5274f2c190331438375ad114dad12ae098b57Ted Kremenek // pointer values, and pointer-to-pointer conversions. 217949badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor case Stmt::ImplicitCastExprClass: 21806eec8e883de118b431e3ead5b1e604a6ac68ff6bDouglas Gregor case Stmt::CStyleCastExprClass: 2181f85e193739c953358c865005855253af4f68a497John McCall case Stmt::CXXFunctionalCastExprClass: 2182f85e193739c953358c865005855253af4f68a497John McCall case Stmt::ObjCBridgedCastExprClass: { 21830835a3cdeefe714b4959d31127ea155e56393125Argyrios Kyrtzidis Expr* SubExpr = cast<CastExpr>(E)->getSubExpr(); 218454b5274f2c190331438375ad114dad12ae098b57Ted Kremenek QualType T = SubExpr->getType(); 21851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2186dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff if (SubExpr->getType()->isPointerType() || 2187dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff SubExpr->getType()->isBlockPointerType() || 2188dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff SubExpr->getType()->isObjCQualifiedIdType()) 218926e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis return EvalAddr(SubExpr, refVars); 219054b5274f2c190331438375ad114dad12ae098b57Ted Kremenek else if (T->isArrayType()) 219126e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis return EvalVal(SubExpr, refVars); 2192fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner else 219354b5274f2c190331438375ad114dad12ae098b57Ted Kremenek return 0; 2194fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 21951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2196fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // C++ casts. For dynamic casts, static casts, and const casts, we 2197fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // are always converting from a pointer-to-pointer, so we just blow 219849badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor // through the cast. In the case the dynamic cast doesn't fail (and 219949badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor // return NULL), we take the conservative route and report cases 2200fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // where we return the address of a stack variable. For Reinterpre 220149badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor // FIXME: The comment about is wrong; we're not always converting 220249badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor // from pointer to pointer. I'm guessing that this code should also 22031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // handle references to objects. 22041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case Stmt::CXXStaticCastExprClass: 22051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case Stmt::CXXDynamicCastExprClass: 220649badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor case Stmt::CXXConstCastExprClass: 220749badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor case Stmt::CXXReinterpretCastExprClass: { 220849badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor Expr *S = cast<CXXNamedCastExpr>(E)->getSubExpr(); 2209dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff if (S->getType()->isPointerType() || S->getType()->isBlockPointerType()) 221026e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis return EvalAddr(S, refVars); 221106de276fff91264437fa75111ed76de43097e089Ted Kremenek else 221206de276fff91264437fa75111ed76de43097e089Ted Kremenek return NULL; 2213fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 22141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 221503e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor case Stmt::MaterializeTemporaryExprClass: 221603e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor if (Expr *Result = EvalAddr( 221703e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor cast<MaterializeTemporaryExpr>(E)->GetTemporaryExpr(), 221803e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor refVars)) 221903e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor return Result; 222003e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor 222103e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor return E; 222203e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor 2223fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Everything else: we simply don't reason about them. 2224fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner default: 2225fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return NULL; 222606de276fff91264437fa75111ed76de43097e089Ted Kremenek } 222706de276fff91264437fa75111ed76de43097e089Ted Kremenek} 22281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 222906de276fff91264437fa75111ed76de43097e089Ted Kremenek 223006de276fff91264437fa75111ed76de43097e089Ted Kremenek/// EvalVal - This function is complements EvalAddr in the mutual recursion. 223106de276fff91264437fa75111ed76de43097e089Ted Kremenek/// See the comments for EvalAddr for more details. 22325f9e272e632e951b1efe824cd16acb4d96077930Chris Lattnerstatic Expr *EvalVal(Expr *E, SmallVectorImpl<DeclRefExpr *> &refVars) { 223368957a919084ab8bbd1f01d534db1d6f31d0f459Ted Kremenekdo { 2234e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek // We should only be called for evaluating non-pointer expressions, or 2235e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek // expressions with a pointer type that are not used as references but instead 2236e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek // are l-values (e.g., DeclRefExpr with a pointer type). 22371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 223806de276fff91264437fa75111ed76de43097e089Ted Kremenek // Our "symbolic interpreter" is just a dispatch off the currently 223906de276fff91264437fa75111ed76de43097e089Ted Kremenek // viewed AST node. We then recursively traverse the AST by calling 224006de276fff91264437fa75111ed76de43097e089Ted Kremenek // EvalAddr and EvalVal appropriately. 2241f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne 2242f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne E = E->IgnoreParens(); 224306de276fff91264437fa75111ed76de43097e089Ted Kremenek switch (E->getStmtClass()) { 224468957a919084ab8bbd1f01d534db1d6f31d0f459Ted Kremenek case Stmt::ImplicitCastExprClass: { 224568957a919084ab8bbd1f01d534db1d6f31d0f459Ted Kremenek ImplicitCastExpr *IE = cast<ImplicitCastExpr>(E); 22465baba9d98364a3525d6afa15a04cdad82fd6dd30John McCall if (IE->getValueKind() == VK_LValue) { 224768957a919084ab8bbd1f01d534db1d6f31d0f459Ted Kremenek E = IE->getSubExpr(); 224868957a919084ab8bbd1f01d534db1d6f31d0f459Ted Kremenek continue; 224968957a919084ab8bbd1f01d534db1d6f31d0f459Ted Kremenek } 225068957a919084ab8bbd1f01d534db1d6f31d0f459Ted Kremenek return NULL; 225168957a919084ab8bbd1f01d534db1d6f31d0f459Ted Kremenek } 225268957a919084ab8bbd1f01d534db1d6f31d0f459Ted Kremenek 2253a2813cec2605ce7878d1b13471d685f689b251afDouglas Gregor case Stmt::DeclRefExprClass: { 225426e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // When we hit a DeclRefExpr we are looking at code that refers to a 225526e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // variable's name. If it's not a reference variable we check if it has 225626e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // local storage within the function, and if so, return the expression. 225706de276fff91264437fa75111ed76de43097e089Ted Kremenek DeclRefExpr *DR = cast<DeclRefExpr>(E); 22581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 225906de276fff91264437fa75111ed76de43097e089Ted Kremenek if (VarDecl *V = dyn_cast<VarDecl>(DR->getDecl())) 226026e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis if (V->hasLocalStorage()) { 226126e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis if (!V->getType()->isReferenceType()) 226226e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis return DR; 226326e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis 226426e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // Reference variable, follow through to the expression that 226526e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // it points to. 226626e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis if (V->hasInit()) { 226726e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // Add the reference variable to the "trail". 226826e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis refVars.push_back(DR); 226926e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis return EvalVal(V->getInit(), refVars); 227026e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis } 227126e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis } 22721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 227306de276fff91264437fa75111ed76de43097e089Ted Kremenek return NULL; 227406de276fff91264437fa75111ed76de43097e089Ted Kremenek } 22751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 227606de276fff91264437fa75111ed76de43097e089Ted Kremenek case Stmt::UnaryOperatorClass: { 227706de276fff91264437fa75111ed76de43097e089Ted Kremenek // The only unary operator that make sense to handle here 227806de276fff91264437fa75111ed76de43097e089Ted Kremenek // is Deref. All others don't resolve to a "name." This includes 227906de276fff91264437fa75111ed76de43097e089Ted Kremenek // handling all sorts of rvalues passed to a unary operator. 228006de276fff91264437fa75111ed76de43097e089Ted Kremenek UnaryOperator *U = cast<UnaryOperator>(E); 22811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 22822de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (U->getOpcode() == UO_Deref) 228326e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis return EvalAddr(U->getSubExpr(), refVars); 228406de276fff91264437fa75111ed76de43097e089Ted Kremenek 228506de276fff91264437fa75111ed76de43097e089Ted Kremenek return NULL; 228606de276fff91264437fa75111ed76de43097e089Ted Kremenek } 22871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 228806de276fff91264437fa75111ed76de43097e089Ted Kremenek case Stmt::ArraySubscriptExprClass: { 228906de276fff91264437fa75111ed76de43097e089Ted Kremenek // Array subscripts are potential references to data on the stack. We 229006de276fff91264437fa75111ed76de43097e089Ted Kremenek // retrieve the DeclRefExpr* for the array variable if it indeed 229106de276fff91264437fa75111ed76de43097e089Ted Kremenek // has local storage. 229226e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis return EvalAddr(cast<ArraySubscriptExpr>(E)->getBase(), refVars); 229306de276fff91264437fa75111ed76de43097e089Ted Kremenek } 22941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 229506de276fff91264437fa75111ed76de43097e089Ted Kremenek case Stmt::ConditionalOperatorClass: { 229606de276fff91264437fa75111ed76de43097e089Ted Kremenek // For conditional operators we need to see if either the LHS or RHS are 229726e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // non-NULL Expr's. If one is non-NULL, we return it. 229806de276fff91264437fa75111ed76de43097e089Ted Kremenek ConditionalOperator *C = cast<ConditionalOperator>(E); 229906de276fff91264437fa75111ed76de43097e089Ted Kremenek 23003907323dd6665c0c4e383435cb145233f4533406Anders Carlsson // Handle the GNU extension for missing LHS. 23013907323dd6665c0c4e383435cb145233f4533406Anders Carlsson if (Expr *lhsExpr = C->getLHS()) 230226e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis if (Expr *LHS = EvalVal(lhsExpr, refVars)) 23033907323dd6665c0c4e383435cb145233f4533406Anders Carlsson return LHS; 23043907323dd6665c0c4e383435cb145233f4533406Anders Carlsson 230526e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis return EvalVal(C->getRHS(), refVars); 230606de276fff91264437fa75111ed76de43097e089Ted Kremenek } 23071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 230806de276fff91264437fa75111ed76de43097e089Ted Kremenek // Accesses to members are potential references to data on the stack. 230983f6faf37d9bf58986bedc9bc0ea897a56b4dbadDouglas Gregor case Stmt::MemberExprClass: { 231006de276fff91264437fa75111ed76de43097e089Ted Kremenek MemberExpr *M = cast<MemberExpr>(E); 23111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 231206de276fff91264437fa75111ed76de43097e089Ted Kremenek // Check for indirect access. We only want direct field accesses. 2313a423e81a4d04b7c1882d2787d1189cbc14540c16Ted Kremenek if (M->isArrow()) 2314a423e81a4d04b7c1882d2787d1189cbc14540c16Ted Kremenek return NULL; 2315a423e81a4d04b7c1882d2787d1189cbc14540c16Ted Kremenek 2316a423e81a4d04b7c1882d2787d1189cbc14540c16Ted Kremenek // Check whether the member type is itself a reference, in which case 2317a423e81a4d04b7c1882d2787d1189cbc14540c16Ted Kremenek // we're not going to refer to the member, but to what the member refers to. 2318a423e81a4d04b7c1882d2787d1189cbc14540c16Ted Kremenek if (M->getMemberDecl()->getType()->isReferenceType()) 231906de276fff91264437fa75111ed76de43097e089Ted Kremenek return NULL; 2320a423e81a4d04b7c1882d2787d1189cbc14540c16Ted Kremenek 232126e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis return EvalVal(M->getBase(), refVars); 232206de276fff91264437fa75111ed76de43097e089Ted Kremenek } 23231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 232403e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor case Stmt::MaterializeTemporaryExprClass: 232503e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor if (Expr *Result = EvalVal( 232603e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor cast<MaterializeTemporaryExpr>(E)->GetTemporaryExpr(), 232703e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor refVars)) 232803e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor return Result; 232903e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor 233003e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor return E; 233103e80030515c800d1ab44125b9052dfffd1bd04cDouglas Gregor 233206de276fff91264437fa75111ed76de43097e089Ted Kremenek default: 233326e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // Check that we don't return or take the address of a reference to a 233426e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // temporary. This is only useful in C++. 233526e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis if (!E->isTypeDependent() && E->isRValue()) 233626e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis return E; 233726e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis 233826e10bea3d2e9d2979194890e51b98ecea165a96Argyrios Kyrtzidis // Everything else: we simply don't reason about them. 233906de276fff91264437fa75111ed76de43097e089Ted Kremenek return NULL; 234006de276fff91264437fa75111ed76de43097e089Ted Kremenek } 234168957a919084ab8bbd1f01d534db1d6f31d0f459Ted Kremenek} while (true); 234206de276fff91264437fa75111ed76de43097e089Ted Kremenek} 2343588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek 2344588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek//===--- CHECK: Floating-Point comparisons (-Wfloat-equal) ---------------===// 2345588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek 2346588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek/// Check for comparisons of floating point operands using != and ==. 2347588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek/// Issue a warning if these are no self-comparisons, as they are not likely 2348588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek/// to do what the programmer intended. 2349588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenekvoid Sema::CheckFloatComparison(SourceLocation loc, Expr* lex, Expr *rex) { 2350588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek bool EmitWarning = true; 23511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2352f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall Expr* LeftExprSansParen = lex->IgnoreParenImpCasts(); 2353f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall Expr* RightExprSansParen = rex->IgnoreParenImpCasts(); 2354588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek 2355588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek // Special case: check for x == x (which is OK). 2356588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek // Do not emit warnings for such cases. 2357588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(LeftExprSansParen)) 2358588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(RightExprSansParen)) 2359588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (DRL->getDecl() == DRR->getDecl()) 2360588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek EmitWarning = false; 23611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 23621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 23631b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek // Special case: check for comparisons against literals that can be exactly 23641b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek // represented by APFloat. In such cases, do not emit a warning. This 23651b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek // is a heuristic: often comparison against such literals are used to 23661b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek // detect if a value in a variable has not changed. This clearly can 23671b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek // lead to false negatives. 23681b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek if (EmitWarning) { 23691b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek if (FloatingLiteral* FLL = dyn_cast<FloatingLiteral>(LeftExprSansParen)) { 23701b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek if (FLL->isExact()) 23711b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek EmitWarning = false; 2372ac5fc7c6bcb494b60fee7ce615ac931c5db6135eMike Stump } else 23731b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek if (FloatingLiteral* FLR = dyn_cast<FloatingLiteral>(RightExprSansParen)){ 23741b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek if (FLR->isExact()) 23751b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek EmitWarning = false; 23761b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek } 23771b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek } 23781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2379588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek // Check for comparisons with builtin types. 23800eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (EmitWarning) 2381588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (CallExpr* CL = dyn_cast<CallExpr>(LeftExprSansParen)) 23823c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor if (CL->isBuiltinCall(Context)) 2383588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek EmitWarning = false; 23841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 23850eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (EmitWarning) 2386588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (CallExpr* CR = dyn_cast<CallExpr>(RightExprSansParen)) 23873c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor if (CR->isBuiltinCall(Context)) 2388588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek EmitWarning = false; 23891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2390588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek // Emit the diagnostic. 2391588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (EmitWarning) 2392fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner Diag(loc, diag::warn_floatingpoint_eq) 2393fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << lex->getSourceRange() << rex->getSourceRange(); 2394588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek} 2395ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 2396f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall//===--- CHECK: Integer mixed-sign comparisons (-Wsign-compare) --------===// 2397f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall//===--- CHECK: Lossy implicit conversions (-Wconversion) --------------===// 2398ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 2399f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCallnamespace { 2400ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 2401f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// Structure recording the 'active' range of an integer-valued 2402f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// expression. 2403f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCallstruct IntRange { 2404f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall /// The number of bits active in the int. 2405f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall unsigned Width; 2406ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 2407f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall /// True if the int is known not to have negative values. 2408f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall bool NonNegative; 240951313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2410f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange(unsigned Width, bool NonNegative) 2411f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall : Width(Width), NonNegative(NonNegative) 2412f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall {} 241351313c39c84407dd6a323be99a8c322bf8d052a9John McCall 24141844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall /// Returns the range of the bool type. 2415f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall static IntRange forBoolType() { 2416f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(1, true); 2417f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall } 241851313c39c84407dd6a323be99a8c322bf8d052a9John McCall 24191844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall /// Returns the range of an opaque value of the given integral type. 24201844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall static IntRange forValueOfType(ASTContext &C, QualType T) { 24211844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall return forValueOfCanonicalType(C, 24221844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall T->getCanonicalTypeInternal().getTypePtr()); 242351313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 242451313c39c84407dd6a323be99a8c322bf8d052a9John McCall 24251844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall /// Returns the range of an opaque value of a canonical integral type. 24261844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall static IntRange forValueOfCanonicalType(ASTContext &C, const Type *T) { 2427f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall assert(T->isCanonicalUnqualified()); 242851313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2429f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (const VectorType *VT = dyn_cast<VectorType>(T)) 2430f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall T = VT->getElementType().getTypePtr(); 2431f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (const ComplexType *CT = dyn_cast<ComplexType>(T)) 2432f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall T = CT->getElementType().getTypePtr(); 2433323ed74658bc8375278eabf074b4777458376540John McCall 2434091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall // For enum types, use the known bit width of the enumerators. 2435323ed74658bc8375278eabf074b4777458376540John McCall if (const EnumType *ET = dyn_cast<EnumType>(T)) { 2436323ed74658bc8375278eabf074b4777458376540John McCall EnumDecl *Enum = ET->getDecl(); 2437091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall if (!Enum->isDefinition()) 2438091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall return IntRange(C.getIntWidth(QualType(T, 0)), false); 2439091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall 2440323ed74658bc8375278eabf074b4777458376540John McCall unsigned NumPositive = Enum->getNumPositiveBits(); 2441323ed74658bc8375278eabf074b4777458376540John McCall unsigned NumNegative = Enum->getNumNegativeBits(); 2442323ed74658bc8375278eabf074b4777458376540John McCall 2443323ed74658bc8375278eabf074b4777458376540John McCall return IntRange(std::max(NumPositive, NumNegative), NumNegative == 0); 2444323ed74658bc8375278eabf074b4777458376540John McCall } 244551313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2446f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall const BuiltinType *BT = cast<BuiltinType>(T); 2447f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall assert(BT->isInteger()); 244851313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2449f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(C.getIntWidth(QualType(T, 0)), BT->isUnsignedInteger()); 245051313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 245151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 24521844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall /// Returns the "target" range of a canonical integral type, i.e. 24531844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall /// the range of values expressible in the type. 24541844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall /// 24551844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall /// This matches forValueOfCanonicalType except that enums have the 24561844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall /// full range of their type, not the range of their enumerators. 24571844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall static IntRange forTargetOfCanonicalType(ASTContext &C, const Type *T) { 24581844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall assert(T->isCanonicalUnqualified()); 24591844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall 24601844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall if (const VectorType *VT = dyn_cast<VectorType>(T)) 24611844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall T = VT->getElementType().getTypePtr(); 24621844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall if (const ComplexType *CT = dyn_cast<ComplexType>(T)) 24631844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall T = CT->getElementType().getTypePtr(); 24641844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall if (const EnumType *ET = dyn_cast<EnumType>(T)) 24651844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall T = ET->getDecl()->getIntegerType().getTypePtr(); 24661844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall 24671844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall const BuiltinType *BT = cast<BuiltinType>(T); 24681844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall assert(BT->isInteger()); 24691844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall 24701844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall return IntRange(C.getIntWidth(QualType(T, 0)), BT->isUnsignedInteger()); 24711844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall } 24721844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall 24731844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall /// Returns the supremum of two ranges: i.e. their conservative merge. 2474c0cd21d2a3301a7a88e0052aebdd09c2441f826dJohn McCall static IntRange join(IntRange L, IntRange R) { 2475f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(std::max(L.Width, R.Width), 247660fad45739b764886f707bd204eae9ecce6db1f2John McCall L.NonNegative && R.NonNegative); 247760fad45739b764886f707bd204eae9ecce6db1f2John McCall } 247860fad45739b764886f707bd204eae9ecce6db1f2John McCall 24791844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall /// Returns the infinum of two ranges: i.e. their aggressive merge. 2480c0cd21d2a3301a7a88e0052aebdd09c2441f826dJohn McCall static IntRange meet(IntRange L, IntRange R) { 248160fad45739b764886f707bd204eae9ecce6db1f2John McCall return IntRange(std::min(L.Width, R.Width), 248260fad45739b764886f707bd204eae9ecce6db1f2John McCall L.NonNegative || R.NonNegative); 248351313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 2484f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall}; 248551313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2486f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCallIntRange GetValueRange(ASTContext &C, llvm::APSInt &value, unsigned MaxWidth) { 2487f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (value.isSigned() && value.isNegative()) 2488f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(value.getMinSignedBits(), false); 248951313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2490f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (value.getBitWidth() > MaxWidth) 24919f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad value = value.trunc(MaxWidth); 249251313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2493f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // isNonNegative() just checks the sign bit without considering 2494f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // signedness. 2495f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(value.getActiveBits(), true); 249651313c39c84407dd6a323be99a8c322bf8d052a9John McCall} 249751313c39c84407dd6a323be99a8c322bf8d052a9John McCall 24980acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCallIntRange GetValueRange(ASTContext &C, APValue &result, QualType Ty, 2499f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall unsigned MaxWidth) { 2500f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (result.isInt()) 2501f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return GetValueRange(C, result.getInt(), MaxWidth); 250251313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2503f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (result.isVector()) { 25040acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCall IntRange R = GetValueRange(C, result.getVectorElt(0), Ty, MaxWidth); 25050acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCall for (unsigned i = 1, e = result.getVectorLength(); i != e; ++i) { 25060acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCall IntRange El = GetValueRange(C, result.getVectorElt(i), Ty, MaxWidth); 25070acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCall R = IntRange::join(R, El); 25080acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCall } 2509f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return R; 251051313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 251151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2512f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (result.isComplexInt()) { 2513f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange R = GetValueRange(C, result.getComplexIntReal(), MaxWidth); 2514f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange I = GetValueRange(C, result.getComplexIntImag(), MaxWidth); 2515f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::join(R, I); 2516f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall } 2517f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 2518f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // This can happen with lossless casts to intptr_t of "based" lvalues. 2519f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Assume it might use arbitrary bits. 25200acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCall // FIXME: The only reason we need to pass the type in here is to get 25210acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCall // the sign right on this one case. It would be nice if APValue 25220acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCall // preserved this. 2523f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall assert(result.isLValue()); 25245e9ebb3c0fb554d9285aa99c470abdf283272bd9Douglas Gregor return IntRange(MaxWidth, Ty->isUnsignedIntegerOrEnumerationType()); 252551313c39c84407dd6a323be99a8c322bf8d052a9John McCall} 252651313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2527f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// Pseudo-evaluate the given integer expression, estimating the 2528f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// range of values it might take. 2529f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// 2530f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// \param MaxWidth - the width to which the value will be truncated 2531f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCallIntRange GetExprRange(ASTContext &C, Expr *E, unsigned MaxWidth) { 253251313c39c84407dd6a323be99a8c322bf8d052a9John McCall E = E->IgnoreParens(); 253351313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2534f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Try a full evaluation first. 2535f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall Expr::EvalResult result; 2536f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (E->Evaluate(result, C)) 25370acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCall return GetValueRange(C, result.Val, E->getType(), MaxWidth); 253851313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2539f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // I think we only want to look through implicit casts here; if the 2540f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // user has an explicit widening cast, we should treat the value as 2541f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // being of the new, wider type. 2542f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E)) { 25432de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CE->getCastKind() == CK_NoOp) 2544f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return GetExprRange(C, CE->getSubExpr(), MaxWidth); 254551313c39c84407dd6a323be99a8c322bf8d052a9John McCall 25461844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall IntRange OutputTypeRange = IntRange::forValueOfType(C, CE->getType()); 254751313c39c84407dd6a323be99a8c322bf8d052a9John McCall 25482de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall bool isIntegerCast = (CE->getCastKind() == CK_IntegralCast); 254960fad45739b764886f707bd204eae9ecce6db1f2John McCall 2550f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Assume that non-integer casts can span the full range of the type. 255160fad45739b764886f707bd204eae9ecce6db1f2John McCall if (!isIntegerCast) 2552f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return OutputTypeRange; 255351313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2554f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange SubRange 2555f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall = GetExprRange(C, CE->getSubExpr(), 2556f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall std::min(MaxWidth, OutputTypeRange.Width)); 255751313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2558f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Bail out if the subexpr's range is as wide as the cast type. 2559f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (SubRange.Width >= OutputTypeRange.Width) 2560f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return OutputTypeRange; 256151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2562f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Otherwise, we take the smaller width, and we're non-negative if 2563f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // either the output type or the subexpr is. 2564f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(SubRange.Width, 2565f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall SubRange.NonNegative || OutputTypeRange.NonNegative); 2566f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall } 2567f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 2568f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) { 2569f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // If we can fold the condition, just take that operand. 2570f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall bool CondResult; 2571f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (CO->getCond()->EvaluateAsBooleanCondition(CondResult, C)) 2572f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return GetExprRange(C, CondResult ? CO->getTrueExpr() 2573f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall : CO->getFalseExpr(), 2574f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall MaxWidth); 2575f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 2576f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Otherwise, conservatively merge. 2577f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange L = GetExprRange(C, CO->getTrueExpr(), MaxWidth); 2578f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange R = GetExprRange(C, CO->getFalseExpr(), MaxWidth); 2579f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::join(L, R); 258051313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 258151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 258251313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 258351313c39c84407dd6a323be99a8c322bf8d052a9John McCall switch (BO->getOpcode()) { 258451313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2585f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Boolean-valued operations are single-bit and positive. 25862de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LAnd: 25872de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LOr: 25882de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LT: 25892de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_GT: 25902de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LE: 25912de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_GE: 25922de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_EQ: 25932de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_NE: 2594f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::forBoolType(); 259551313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2596862ff87c0d306af8dfdbe7ac59f181a5815546e5John McCall // The type of the assignments is the type of the LHS, so the RHS 2597862ff87c0d306af8dfdbe7ac59f181a5815546e5John McCall // is not necessarily the same type. 25982de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_MulAssign: 25992de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_DivAssign: 26002de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_RemAssign: 26012de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_AddAssign: 26022de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_SubAssign: 2603862ff87c0d306af8dfdbe7ac59f181a5815546e5John McCall case BO_XorAssign: 2604862ff87c0d306af8dfdbe7ac59f181a5815546e5John McCall case BO_OrAssign: 2605862ff87c0d306af8dfdbe7ac59f181a5815546e5John McCall // TODO: bitfields? 26061844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall return IntRange::forValueOfType(C, E->getType()); 2607c0cd21d2a3301a7a88e0052aebdd09c2441f826dJohn McCall 2608862ff87c0d306af8dfdbe7ac59f181a5815546e5John McCall // Simple assignments just pass through the RHS, which will have 2609862ff87c0d306af8dfdbe7ac59f181a5815546e5John McCall // been coerced to the LHS type. 2610862ff87c0d306af8dfdbe7ac59f181a5815546e5John McCall case BO_Assign: 2611862ff87c0d306af8dfdbe7ac59f181a5815546e5John McCall // TODO: bitfields? 2612862ff87c0d306af8dfdbe7ac59f181a5815546e5John McCall return GetExprRange(C, BO->getRHS(), MaxWidth); 2613862ff87c0d306af8dfdbe7ac59f181a5815546e5John McCall 261451313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Operations with opaque sources are black-listed. 26152de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_PtrMemD: 26162de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_PtrMemI: 26171844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall return IntRange::forValueOfType(C, E->getType()); 261851313c39c84407dd6a323be99a8c322bf8d052a9John McCall 261960fad45739b764886f707bd204eae9ecce6db1f2John McCall // Bitwise-and uses the *infinum* of the two source ranges. 26202de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_And: 26212de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_AndAssign: 262260fad45739b764886f707bd204eae9ecce6db1f2John McCall return IntRange::meet(GetExprRange(C, BO->getLHS(), MaxWidth), 262360fad45739b764886f707bd204eae9ecce6db1f2John McCall GetExprRange(C, BO->getRHS(), MaxWidth)); 262460fad45739b764886f707bd204eae9ecce6db1f2John McCall 262551313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Left shift gets black-listed based on a judgement call. 26262de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Shl: 26273aae6093dd8f3aecb66d7ff1f4b44e6a86765db4John McCall // ...except that we want to treat '1 << (blah)' as logically 26283aae6093dd8f3aecb66d7ff1f4b44e6a86765db4John McCall // positive. It's an important idiom. 26293aae6093dd8f3aecb66d7ff1f4b44e6a86765db4John McCall if (IntegerLiteral *I 26303aae6093dd8f3aecb66d7ff1f4b44e6a86765db4John McCall = dyn_cast<IntegerLiteral>(BO->getLHS()->IgnoreParenCasts())) { 26313aae6093dd8f3aecb66d7ff1f4b44e6a86765db4John McCall if (I->getValue() == 1) { 26321844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall IntRange R = IntRange::forValueOfType(C, E->getType()); 26333aae6093dd8f3aecb66d7ff1f4b44e6a86765db4John McCall return IntRange(R.Width, /*NonNegative*/ true); 26343aae6093dd8f3aecb66d7ff1f4b44e6a86765db4John McCall } 26353aae6093dd8f3aecb66d7ff1f4b44e6a86765db4John McCall } 26363aae6093dd8f3aecb66d7ff1f4b44e6a86765db4John McCall // fallthrough 26373aae6093dd8f3aecb66d7ff1f4b44e6a86765db4John McCall 26382de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_ShlAssign: 26391844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall return IntRange::forValueOfType(C, E->getType()); 264051313c39c84407dd6a323be99a8c322bf8d052a9John McCall 264160fad45739b764886f707bd204eae9ecce6db1f2John McCall // Right shift by a constant can narrow its left argument. 26422de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Shr: 26432de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_ShrAssign: { 264460fad45739b764886f707bd204eae9ecce6db1f2John McCall IntRange L = GetExprRange(C, BO->getLHS(), MaxWidth); 264560fad45739b764886f707bd204eae9ecce6db1f2John McCall 264660fad45739b764886f707bd204eae9ecce6db1f2John McCall // If the shift amount is a positive constant, drop the width by 264760fad45739b764886f707bd204eae9ecce6db1f2John McCall // that much. 264860fad45739b764886f707bd204eae9ecce6db1f2John McCall llvm::APSInt shift; 264960fad45739b764886f707bd204eae9ecce6db1f2John McCall if (BO->getRHS()->isIntegerConstantExpr(shift, C) && 265060fad45739b764886f707bd204eae9ecce6db1f2John McCall shift.isNonNegative()) { 265160fad45739b764886f707bd204eae9ecce6db1f2John McCall unsigned zext = shift.getZExtValue(); 265260fad45739b764886f707bd204eae9ecce6db1f2John McCall if (zext >= L.Width) 265360fad45739b764886f707bd204eae9ecce6db1f2John McCall L.Width = (L.NonNegative ? 0 : 1); 265460fad45739b764886f707bd204eae9ecce6db1f2John McCall else 265560fad45739b764886f707bd204eae9ecce6db1f2John McCall L.Width -= zext; 265660fad45739b764886f707bd204eae9ecce6db1f2John McCall } 265760fad45739b764886f707bd204eae9ecce6db1f2John McCall 265860fad45739b764886f707bd204eae9ecce6db1f2John McCall return L; 265960fad45739b764886f707bd204eae9ecce6db1f2John McCall } 266060fad45739b764886f707bd204eae9ecce6db1f2John McCall 266160fad45739b764886f707bd204eae9ecce6db1f2John McCall // Comma acts as its right operand. 26622de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Comma: 2663f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return GetExprRange(C, BO->getRHS(), MaxWidth); 2664f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 266560fad45739b764886f707bd204eae9ecce6db1f2John McCall // Black-list pointer subtractions. 26662de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Sub: 266751313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (BO->getLHS()->getType()->isPointerType()) 26681844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall return IntRange::forValueOfType(C, E->getType()); 266900fe761849278180b0d73f276e468cf4c54ff2adJohn McCall break; 267000fe761849278180b0d73f276e468cf4c54ff2adJohn McCall 267100fe761849278180b0d73f276e468cf4c54ff2adJohn McCall // The width of a division result is mostly determined by the size 267200fe761849278180b0d73f276e468cf4c54ff2adJohn McCall // of the LHS. 267300fe761849278180b0d73f276e468cf4c54ff2adJohn McCall case BO_Div: { 267400fe761849278180b0d73f276e468cf4c54ff2adJohn McCall // Don't 'pre-truncate' the operands. 267500fe761849278180b0d73f276e468cf4c54ff2adJohn McCall unsigned opWidth = C.getIntWidth(E->getType()); 267600fe761849278180b0d73f276e468cf4c54ff2adJohn McCall IntRange L = GetExprRange(C, BO->getLHS(), opWidth); 267700fe761849278180b0d73f276e468cf4c54ff2adJohn McCall 267800fe761849278180b0d73f276e468cf4c54ff2adJohn McCall // If the divisor is constant, use that. 267900fe761849278180b0d73f276e468cf4c54ff2adJohn McCall llvm::APSInt divisor; 268000fe761849278180b0d73f276e468cf4c54ff2adJohn McCall if (BO->getRHS()->isIntegerConstantExpr(divisor, C)) { 268100fe761849278180b0d73f276e468cf4c54ff2adJohn McCall unsigned log2 = divisor.logBase2(); // floor(log_2(divisor)) 268200fe761849278180b0d73f276e468cf4c54ff2adJohn McCall if (log2 >= L.Width) 268300fe761849278180b0d73f276e468cf4c54ff2adJohn McCall L.Width = (L.NonNegative ? 0 : 1); 268400fe761849278180b0d73f276e468cf4c54ff2adJohn McCall else 268500fe761849278180b0d73f276e468cf4c54ff2adJohn McCall L.Width = std::min(L.Width - log2, MaxWidth); 268600fe761849278180b0d73f276e468cf4c54ff2adJohn McCall return L; 268700fe761849278180b0d73f276e468cf4c54ff2adJohn McCall } 268800fe761849278180b0d73f276e468cf4c54ff2adJohn McCall 268900fe761849278180b0d73f276e468cf4c54ff2adJohn McCall // Otherwise, just use the LHS's width. 269000fe761849278180b0d73f276e468cf4c54ff2adJohn McCall IntRange R = GetExprRange(C, BO->getRHS(), opWidth); 269100fe761849278180b0d73f276e468cf4c54ff2adJohn McCall return IntRange(L.Width, L.NonNegative && R.NonNegative); 269200fe761849278180b0d73f276e468cf4c54ff2adJohn McCall } 269300fe761849278180b0d73f276e468cf4c54ff2adJohn McCall 269400fe761849278180b0d73f276e468cf4c54ff2adJohn McCall // The result of a remainder can't be larger than the result of 269500fe761849278180b0d73f276e468cf4c54ff2adJohn McCall // either side. 269600fe761849278180b0d73f276e468cf4c54ff2adJohn McCall case BO_Rem: { 269700fe761849278180b0d73f276e468cf4c54ff2adJohn McCall // Don't 'pre-truncate' the operands. 269800fe761849278180b0d73f276e468cf4c54ff2adJohn McCall unsigned opWidth = C.getIntWidth(E->getType()); 269900fe761849278180b0d73f276e468cf4c54ff2adJohn McCall IntRange L = GetExprRange(C, BO->getLHS(), opWidth); 270000fe761849278180b0d73f276e468cf4c54ff2adJohn McCall IntRange R = GetExprRange(C, BO->getRHS(), opWidth); 270100fe761849278180b0d73f276e468cf4c54ff2adJohn McCall 270200fe761849278180b0d73f276e468cf4c54ff2adJohn McCall IntRange meet = IntRange::meet(L, R); 270300fe761849278180b0d73f276e468cf4c54ff2adJohn McCall meet.Width = std::min(meet.Width, MaxWidth); 270400fe761849278180b0d73f276e468cf4c54ff2adJohn McCall return meet; 270500fe761849278180b0d73f276e468cf4c54ff2adJohn McCall } 27064e4b30ec62d78b24e6556fea2624855c193d0e3eTed Kremenek 270700fe761849278180b0d73f276e468cf4c54ff2adJohn McCall // The default behavior is okay for these. 270800fe761849278180b0d73f276e468cf4c54ff2adJohn McCall case BO_Mul: 270900fe761849278180b0d73f276e468cf4c54ff2adJohn McCall case BO_Add: 271000fe761849278180b0d73f276e468cf4c54ff2adJohn McCall case BO_Xor: 271100fe761849278180b0d73f276e468cf4c54ff2adJohn McCall case BO_Or: 2712f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall break; 271351313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 2714f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 271500fe761849278180b0d73f276e468cf4c54ff2adJohn McCall // The default case is to treat the operation as if it were closed 271600fe761849278180b0d73f276e468cf4c54ff2adJohn McCall // on the narrowest type that encompasses both operands. 2717f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange L = GetExprRange(C, BO->getLHS(), MaxWidth); 2718f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange R = GetExprRange(C, BO->getRHS(), MaxWidth); 2719f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::join(L, R); 272051313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 272151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 272251313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) { 272351313c39c84407dd6a323be99a8c322bf8d052a9John McCall switch (UO->getOpcode()) { 272451313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Boolean-valued operations are white-listed. 27252de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case UO_LNot: 2726f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::forBoolType(); 272751313c39c84407dd6a323be99a8c322bf8d052a9John McCall 272851313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Operations with opaque sources are black-listed. 27292de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case UO_Deref: 27302de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case UO_AddrOf: // should be impossible 27311844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall return IntRange::forValueOfType(C, E->getType()); 273251313c39c84407dd6a323be99a8c322bf8d052a9John McCall 273351313c39c84407dd6a323be99a8c322bf8d052a9John McCall default: 2734f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return GetExprRange(C, UO->getSubExpr(), MaxWidth); 273551313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 273651313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 27378ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 27388ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor if (dyn_cast<OffsetOfExpr>(E)) { 27391844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall IntRange::forValueOfType(C, E->getType()); 27408ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor } 274151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2742f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall FieldDecl *BitField = E->getBitField(); 2743f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (BitField) { 2744f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall llvm::APSInt BitWidthAP = BitField->getBitWidth()->EvaluateAsInt(C); 2745f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall unsigned BitWidth = BitWidthAP.getZExtValue(); 274651313c39c84407dd6a323be99a8c322bf8d052a9John McCall 27475e9ebb3c0fb554d9285aa99c470abdf283272bd9Douglas Gregor return IntRange(BitWidth, 27485e9ebb3c0fb554d9285aa99c470abdf283272bd9Douglas Gregor BitField->getType()->isUnsignedIntegerOrEnumerationType()); 2749f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall } 2750f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 27511844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall return IntRange::forValueOfType(C, E->getType()); 2752f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall} 2753f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 2754323ed74658bc8375278eabf074b4777458376540John McCallIntRange GetExprRange(ASTContext &C, Expr *E) { 2755323ed74658bc8375278eabf074b4777458376540John McCall return GetExprRange(C, E, C.getIntWidth(E->getType())); 2756323ed74658bc8375278eabf074b4777458376540John McCall} 2757323ed74658bc8375278eabf074b4777458376540John McCall 2758f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// Checks whether the given value, which currently has the given 2759f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// source semantics, has the same value when coerced through the 2760f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// target semantics. 2761f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCallbool IsSameFloatAfterCast(const llvm::APFloat &value, 2762f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall const llvm::fltSemantics &Src, 2763f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall const llvm::fltSemantics &Tgt) { 2764f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall llvm::APFloat truncated = value; 2765f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 2766f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall bool ignored; 2767f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall truncated.convert(Src, llvm::APFloat::rmNearestTiesToEven, &ignored); 2768f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall truncated.convert(Tgt, llvm::APFloat::rmNearestTiesToEven, &ignored); 2769f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 2770f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return truncated.bitwiseIsEqual(value); 277151313c39c84407dd6a323be99a8c322bf8d052a9John McCall} 277251313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2773f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// Checks whether the given value, which currently has the given 2774f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// source semantics, has the same value when coerced through the 2775f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// target semantics. 2776f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// 2777f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// The value might be a vector of floats (or a complex number). 2778f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCallbool IsSameFloatAfterCast(const APValue &value, 2779f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall const llvm::fltSemantics &Src, 2780f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall const llvm::fltSemantics &Tgt) { 2781f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (value.isFloat()) 2782f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IsSameFloatAfterCast(value.getFloat(), Src, Tgt); 2783f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 2784f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (value.isVector()) { 2785f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall for (unsigned i = 0, e = value.getVectorLength(); i != e; ++i) 2786f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (!IsSameFloatAfterCast(value.getVectorElt(i), Src, Tgt)) 2787f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return false; 2788f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return true; 2789f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall } 2790f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 2791f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall assert(value.isComplexFloat()); 2792f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return (IsSameFloatAfterCast(value.getComplexFloatReal(), Src, Tgt) && 2793f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IsSameFloatAfterCast(value.getComplexFloatImag(), Src, Tgt)); 2794f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall} 2795f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 2796b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCallvoid AnalyzeImplicitConversions(Sema &S, Expr *E, SourceLocation CC); 2797323ed74658bc8375278eabf074b4777458376540John McCall 2798e3b159c0d4a93db8586861ff011b5a10de4ae6efTed Kremenekstatic bool IsZero(Sema &S, Expr *E) { 2799e3b159c0d4a93db8586861ff011b5a10de4ae6efTed Kremenek // Suppress cases where we are comparing against an enum constant. 2800e3b159c0d4a93db8586861ff011b5a10de4ae6efTed Kremenek if (const DeclRefExpr *DR = 2801e3b159c0d4a93db8586861ff011b5a10de4ae6efTed Kremenek dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts())) 2802e3b159c0d4a93db8586861ff011b5a10de4ae6efTed Kremenek if (isa<EnumConstantDecl>(DR->getDecl())) 2803e3b159c0d4a93db8586861ff011b5a10de4ae6efTed Kremenek return false; 2804e3b159c0d4a93db8586861ff011b5a10de4ae6efTed Kremenek 2805e3b159c0d4a93db8586861ff011b5a10de4ae6efTed Kremenek // Suppress cases where the '0' value is expanded from a macro. 2806e3b159c0d4a93db8586861ff011b5a10de4ae6efTed Kremenek if (E->getLocStart().isMacroID()) 2807e3b159c0d4a93db8586861ff011b5a10de4ae6efTed Kremenek return false; 2808e3b159c0d4a93db8586861ff011b5a10de4ae6efTed Kremenek 2809323ed74658bc8375278eabf074b4777458376540John McCall llvm::APSInt Value; 2810323ed74658bc8375278eabf074b4777458376540John McCall return E->isIntegerConstantExpr(Value, S.Context) && Value == 0; 2811323ed74658bc8375278eabf074b4777458376540John McCall} 2812323ed74658bc8375278eabf074b4777458376540John McCall 2813372e103dab4239ec52b65b9eda69fd43c0b348d4John McCallstatic bool HasEnumType(Expr *E) { 2814372e103dab4239ec52b65b9eda69fd43c0b348d4John McCall // Strip off implicit integral promotions. 2815372e103dab4239ec52b65b9eda69fd43c0b348d4John McCall while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 281663b57aeeebb5bb758ecebf9b41b5131781f32bf3Argyrios Kyrtzidis if (ICE->getCastKind() != CK_IntegralCast && 281763b57aeeebb5bb758ecebf9b41b5131781f32bf3Argyrios Kyrtzidis ICE->getCastKind() != CK_NoOp) 2818372e103dab4239ec52b65b9eda69fd43c0b348d4John McCall break; 281963b57aeeebb5bb758ecebf9b41b5131781f32bf3Argyrios Kyrtzidis E = ICE->getSubExpr(); 2820372e103dab4239ec52b65b9eda69fd43c0b348d4John McCall } 2821372e103dab4239ec52b65b9eda69fd43c0b348d4John McCall 2822372e103dab4239ec52b65b9eda69fd43c0b348d4John McCall return E->getType()->isEnumeralType(); 2823372e103dab4239ec52b65b9eda69fd43c0b348d4John McCall} 2824372e103dab4239ec52b65b9eda69fd43c0b348d4John McCall 2825323ed74658bc8375278eabf074b4777458376540John McCallvoid CheckTrivialUnsignedComparison(Sema &S, BinaryOperator *E) { 28262de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall BinaryOperatorKind op = E->getOpcode(); 282714af91a38c8cf89f0a5e1835d7d8e0fa220e17a9Douglas Gregor if (E->isValueDependent()) 282814af91a38c8cf89f0a5e1835d7d8e0fa220e17a9Douglas Gregor return; 282914af91a38c8cf89f0a5e1835d7d8e0fa220e17a9Douglas Gregor 28302de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (op == BO_LT && IsZero(S, E->getRHS())) { 2831323ed74658bc8375278eabf074b4777458376540John McCall S.Diag(E->getOperatorLoc(), diag::warn_lunsigned_always_true_comparison) 2832372e103dab4239ec52b65b9eda69fd43c0b348d4John McCall << "< 0" << "false" << HasEnumType(E->getLHS()) 2833323ed74658bc8375278eabf074b4777458376540John McCall << E->getLHS()->getSourceRange() << E->getRHS()->getSourceRange(); 28342de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall } else if (op == BO_GE && IsZero(S, E->getRHS())) { 2835323ed74658bc8375278eabf074b4777458376540John McCall S.Diag(E->getOperatorLoc(), diag::warn_lunsigned_always_true_comparison) 2836372e103dab4239ec52b65b9eda69fd43c0b348d4John McCall << ">= 0" << "true" << HasEnumType(E->getLHS()) 2837323ed74658bc8375278eabf074b4777458376540John McCall << E->getLHS()->getSourceRange() << E->getRHS()->getSourceRange(); 28382de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall } else if (op == BO_GT && IsZero(S, E->getLHS())) { 2839323ed74658bc8375278eabf074b4777458376540John McCall S.Diag(E->getOperatorLoc(), diag::warn_runsigned_always_true_comparison) 2840372e103dab4239ec52b65b9eda69fd43c0b348d4John McCall << "0 >" << "false" << HasEnumType(E->getRHS()) 2841323ed74658bc8375278eabf074b4777458376540John McCall << E->getLHS()->getSourceRange() << E->getRHS()->getSourceRange(); 28422de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall } else if (op == BO_LE && IsZero(S, E->getLHS())) { 2843323ed74658bc8375278eabf074b4777458376540John McCall S.Diag(E->getOperatorLoc(), diag::warn_runsigned_always_true_comparison) 2844372e103dab4239ec52b65b9eda69fd43c0b348d4John McCall << "0 <=" << "true" << HasEnumType(E->getRHS()) 2845323ed74658bc8375278eabf074b4777458376540John McCall << E->getLHS()->getSourceRange() << E->getRHS()->getSourceRange(); 2846323ed74658bc8375278eabf074b4777458376540John McCall } 2847323ed74658bc8375278eabf074b4777458376540John McCall} 2848323ed74658bc8375278eabf074b4777458376540John McCall 2849323ed74658bc8375278eabf074b4777458376540John McCall/// Analyze the operands of the given comparison. Implements the 2850323ed74658bc8375278eabf074b4777458376540John McCall/// fallback case from AnalyzeComparison. 2851323ed74658bc8375278eabf074b4777458376540John McCallvoid AnalyzeImpConvsInComparison(Sema &S, BinaryOperator *E) { 2852b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall AnalyzeImplicitConversions(S, E->getLHS(), E->getOperatorLoc()); 2853b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall AnalyzeImplicitConversions(S, E->getRHS(), E->getOperatorLoc()); 2854323ed74658bc8375278eabf074b4777458376540John McCall} 2855f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 2856ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall/// \brief Implements -Wsign-compare. 2857ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall/// 2858ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall/// \param lex the left-hand expression 2859ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall/// \param rex the right-hand expression 2860ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall/// \param OpLoc the location of the joining operator 2861d1b47bf17fde73fac67d8664bd65273742c00ecdJohn McCall/// \param BinOpc binary opcode or 0 2862323ed74658bc8375278eabf074b4777458376540John McCallvoid AnalyzeComparison(Sema &S, BinaryOperator *E) { 2863323ed74658bc8375278eabf074b4777458376540John McCall // The type the comparison is being performed in. 2864323ed74658bc8375278eabf074b4777458376540John McCall QualType T = E->getLHS()->getType(); 2865323ed74658bc8375278eabf074b4777458376540John McCall assert(S.Context.hasSameUnqualifiedType(T, E->getRHS()->getType()) 2866323ed74658bc8375278eabf074b4777458376540John McCall && "comparison with mismatched types"); 2867323ed74658bc8375278eabf074b4777458376540John McCall 2868323ed74658bc8375278eabf074b4777458376540John McCall // We don't do anything special if this isn't an unsigned integral 2869323ed74658bc8375278eabf074b4777458376540John McCall // comparison: we're only interested in integral comparisons, and 2870323ed74658bc8375278eabf074b4777458376540John McCall // signed comparisons only happen in cases we don't care to warn about. 28713e026e323f1bd820fb9c880b1db951c87df94bb4Douglas Gregor // 28723e026e323f1bd820fb9c880b1db951c87df94bb4Douglas Gregor // We also don't care about value-dependent expressions or expressions 28733e026e323f1bd820fb9c880b1db951c87df94bb4Douglas Gregor // whose result is a constant. 28743e026e323f1bd820fb9c880b1db951c87df94bb4Douglas Gregor if (!T->hasUnsignedIntegerRepresentation() 28753e026e323f1bd820fb9c880b1db951c87df94bb4Douglas Gregor || E->isValueDependent() || E->isIntegerConstantExpr(S.Context)) 2876323ed74658bc8375278eabf074b4777458376540John McCall return AnalyzeImpConvsInComparison(S, E); 2877323ed74658bc8375278eabf074b4777458376540John McCall 2878323ed74658bc8375278eabf074b4777458376540John McCall Expr *lex = E->getLHS()->IgnoreParenImpCasts(); 2879323ed74658bc8375278eabf074b4777458376540John McCall Expr *rex = E->getRHS()->IgnoreParenImpCasts(); 2880323ed74658bc8375278eabf074b4777458376540John McCall 2881323ed74658bc8375278eabf074b4777458376540John McCall // Check to see if one of the (unmodified) operands is of different 2882323ed74658bc8375278eabf074b4777458376540John McCall // signedness. 2883323ed74658bc8375278eabf074b4777458376540John McCall Expr *signedOperand, *unsignedOperand; 2884f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (lex->getType()->hasSignedIntegerRepresentation()) { 2885f60946222721d9ba3c059563935c17b84703187aDouglas Gregor assert(!rex->getType()->hasSignedIntegerRepresentation() && 2886323ed74658bc8375278eabf074b4777458376540John McCall "unsigned comparison between two signed integer expressions?"); 2887323ed74658bc8375278eabf074b4777458376540John McCall signedOperand = lex; 2888323ed74658bc8375278eabf074b4777458376540John McCall unsignedOperand = rex; 2889f60946222721d9ba3c059563935c17b84703187aDouglas Gregor } else if (rex->getType()->hasSignedIntegerRepresentation()) { 2890323ed74658bc8375278eabf074b4777458376540John McCall signedOperand = rex; 2891323ed74658bc8375278eabf074b4777458376540John McCall unsignedOperand = lex; 2892ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall } else { 2893323ed74658bc8375278eabf074b4777458376540John McCall CheckTrivialUnsignedComparison(S, E); 2894323ed74658bc8375278eabf074b4777458376540John McCall return AnalyzeImpConvsInComparison(S, E); 2895ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall } 2896ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 2897323ed74658bc8375278eabf074b4777458376540John McCall // Otherwise, calculate the effective range of the signed operand. 2898323ed74658bc8375278eabf074b4777458376540John McCall IntRange signedRange = GetExprRange(S.Context, signedOperand); 2899f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 2900323ed74658bc8375278eabf074b4777458376540John McCall // Go ahead and analyze implicit conversions in the operands. Note 2901323ed74658bc8375278eabf074b4777458376540John McCall // that we skip the implicit conversions on both sides. 2902b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall AnalyzeImplicitConversions(S, lex, E->getOperatorLoc()); 2903b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall AnalyzeImplicitConversions(S, rex, E->getOperatorLoc()); 2904ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 2905323ed74658bc8375278eabf074b4777458376540John McCall // If the signed range is non-negative, -Wsign-compare won't fire, 2906323ed74658bc8375278eabf074b4777458376540John McCall // but we should still check for comparisons which are always true 2907323ed74658bc8375278eabf074b4777458376540John McCall // or false. 2908323ed74658bc8375278eabf074b4777458376540John McCall if (signedRange.NonNegative) 2909323ed74658bc8375278eabf074b4777458376540John McCall return CheckTrivialUnsignedComparison(S, E); 2910ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 2911ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // For (in)equality comparisons, if the unsigned operand is a 2912ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // constant which cannot collide with a overflowed signed operand, 2913ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // then reinterpreting the signed operand as unsigned will not 2914ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // change the result of the comparison. 2915323ed74658bc8375278eabf074b4777458376540John McCall if (E->isEqualityOp()) { 2916323ed74658bc8375278eabf074b4777458376540John McCall unsigned comparisonWidth = S.Context.getIntWidth(T); 2917323ed74658bc8375278eabf074b4777458376540John McCall IntRange unsignedRange = GetExprRange(S.Context, unsignedOperand); 2918323ed74658bc8375278eabf074b4777458376540John McCall 2919323ed74658bc8375278eabf074b4777458376540John McCall // We should never be unable to prove that the unsigned operand is 2920323ed74658bc8375278eabf074b4777458376540John McCall // non-negative. 2921323ed74658bc8375278eabf074b4777458376540John McCall assert(unsignedRange.NonNegative && "unsigned range includes negative?"); 2922ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 2923323ed74658bc8375278eabf074b4777458376540John McCall if (unsignedRange.Width < comparisonWidth) 2924323ed74658bc8375278eabf074b4777458376540John McCall return; 2925323ed74658bc8375278eabf074b4777458376540John McCall } 2926323ed74658bc8375278eabf074b4777458376540John McCall 2927323ed74658bc8375278eabf074b4777458376540John McCall S.Diag(E->getOperatorLoc(), diag::warn_mixed_sign_comparison) 2928323ed74658bc8375278eabf074b4777458376540John McCall << lex->getType() << rex->getType() 2929323ed74658bc8375278eabf074b4777458376540John McCall << lex->getSourceRange() << rex->getSourceRange(); 2930ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall} 2931ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 293215d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall/// Analyzes an attempt to assign the given value to a bitfield. 293315d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall/// 293415d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall/// Returns true if there was something fishy about the attempt. 293515d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCallbool AnalyzeBitFieldAssignment(Sema &S, FieldDecl *Bitfield, Expr *Init, 293615d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall SourceLocation InitLoc) { 293715d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall assert(Bitfield->isBitField()); 293815d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall if (Bitfield->isInvalidDecl()) 293915d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall return false; 294015d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall 294191b6014876e9186f968f74a8975ab8fc08ef1b68John McCall // White-list bool bitfields. 294291b6014876e9186f968f74a8975ab8fc08ef1b68John McCall if (Bitfield->getType()->isBooleanType()) 294391b6014876e9186f968f74a8975ab8fc08ef1b68John McCall return false; 294491b6014876e9186f968f74a8975ab8fc08ef1b68John McCall 294546ff3034d14aaa92b530e96480741f3d5d458cb8Douglas Gregor // Ignore value- or type-dependent expressions. 294646ff3034d14aaa92b530e96480741f3d5d458cb8Douglas Gregor if (Bitfield->getBitWidth()->isValueDependent() || 294746ff3034d14aaa92b530e96480741f3d5d458cb8Douglas Gregor Bitfield->getBitWidth()->isTypeDependent() || 294846ff3034d14aaa92b530e96480741f3d5d458cb8Douglas Gregor Init->isValueDependent() || 294946ff3034d14aaa92b530e96480741f3d5d458cb8Douglas Gregor Init->isTypeDependent()) 295046ff3034d14aaa92b530e96480741f3d5d458cb8Douglas Gregor return false; 295146ff3034d14aaa92b530e96480741f3d5d458cb8Douglas Gregor 295215d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall Expr *OriginalInit = Init->IgnoreParenImpCasts(); 295315d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall 295415d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall llvm::APSInt Width(32); 295515d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall Expr::EvalResult InitValue; 295615d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall if (!Bitfield->getBitWidth()->isIntegerConstantExpr(Width, S.Context) || 295791b6014876e9186f968f74a8975ab8fc08ef1b68John McCall !OriginalInit->Evaluate(InitValue, S.Context) || 295815d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall !InitValue.Val.isInt()) 295915d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall return false; 296015d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall 296115d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall const llvm::APSInt &Value = InitValue.Val.getInt(); 296215d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall unsigned OriginalWidth = Value.getBitWidth(); 296315d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall unsigned FieldWidth = Width.getZExtValue(); 296415d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall 296515d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall if (OriginalWidth <= FieldWidth) 296615d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall return false; 296715d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall 29689f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad llvm::APSInt TruncatedValue = Value.trunc(FieldWidth); 296915d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall 297015d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall // It's fairly common to write values into signed bitfields 297115d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall // that, if sign-extended, would end up becoming a different 297215d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall // value. We don't want to warn about that. 297315d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall if (Value.isSigned() && Value.isNegative()) 29749f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad TruncatedValue = TruncatedValue.sext(OriginalWidth); 297515d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall else 29769f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad TruncatedValue = TruncatedValue.zext(OriginalWidth); 297715d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall 297815d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall if (Value == TruncatedValue) 297915d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall return false; 298015d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall 298115d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall std::string PrettyValue = Value.toString(10); 298215d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall std::string PrettyTrunc = TruncatedValue.toString(10); 298315d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall 298415d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall S.Diag(InitLoc, diag::warn_impcast_bitfield_precision_constant) 298515d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall << PrettyValue << PrettyTrunc << OriginalInit->getType() 298615d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall << Init->getSourceRange(); 298715d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall 298815d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall return true; 298915d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall} 299015d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall 2991beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall/// Analyze the given simple or compound assignment for warning-worthy 2992beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall/// operations. 2993beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCallvoid AnalyzeAssignment(Sema &S, BinaryOperator *E) { 2994beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall // Just recurse on the LHS. 2995beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall AnalyzeImplicitConversions(S, E->getLHS(), E->getOperatorLoc()); 2996beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall 2997beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall // We want to recurse on the RHS as normal unless we're assigning to 2998beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall // a bitfield. 2999beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall if (FieldDecl *Bitfield = E->getLHS()->getBitField()) { 300015d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall if (AnalyzeBitFieldAssignment(S, Bitfield, E->getRHS(), 300115d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall E->getOperatorLoc())) { 300215d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall // Recurse, ignoring any implicit conversions on the RHS. 300315d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall return AnalyzeImplicitConversions(S, E->getRHS()->IgnoreParenImpCasts(), 300415d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall E->getOperatorLoc()); 3005beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall } 3006beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall } 3007beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall 3008beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall AnalyzeImplicitConversions(S, E->getRHS(), E->getOperatorLoc()); 3009beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall} 3010beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall 301151313c39c84407dd6a323be99a8c322bf8d052a9John McCall/// Diagnose an implicit cast; purely a helper for CheckImplicitConversion. 30125a5b38f4afaf4f203b96a11ba79890c7cd4cc4b8Douglas Gregorvoid DiagnoseImpCast(Sema &S, Expr *E, QualType SourceType, QualType T, 30135a5b38f4afaf4f203b96a11ba79890c7cd4cc4b8Douglas Gregor SourceLocation CContext, unsigned diag) { 30145a5b38f4afaf4f203b96a11ba79890c7cd4cc4b8Douglas Gregor S.Diag(E->getExprLoc(), diag) 30155a5b38f4afaf4f203b96a11ba79890c7cd4cc4b8Douglas Gregor << SourceType << T << E->getSourceRange() << SourceRange(CContext); 30165a5b38f4afaf4f203b96a11ba79890c7cd4cc4b8Douglas Gregor} 30175a5b38f4afaf4f203b96a11ba79890c7cd4cc4b8Douglas Gregor 3018e1b02e00d851389415a5b7a1398de26c382887c6Chandler Carruth/// Diagnose an implicit cast; purely a helper for CheckImplicitConversion. 3019e1b02e00d851389415a5b7a1398de26c382887c6Chandler Carruthvoid DiagnoseImpCast(Sema &S, Expr *E, QualType T, SourceLocation CContext, 3020e1b02e00d851389415a5b7a1398de26c382887c6Chandler Carruth unsigned diag) { 3021e1b02e00d851389415a5b7a1398de26c382887c6Chandler Carruth DiagnoseImpCast(S, E, E->getType(), T, CContext, diag); 3022e1b02e00d851389415a5b7a1398de26c382887c6Chandler Carruth} 3023e1b02e00d851389415a5b7a1398de26c382887c6Chandler Carruth 3024f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth/// Diagnose an implicit cast from a literal expression. Also attemps to supply 3025f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth/// fixit hints when the cast wouldn't lose information to simply write the 3026f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth/// expression with the expected type. 3027f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruthvoid DiagnoseFloatingLiteralImpCast(Sema &S, FloatingLiteral *FL, QualType T, 3028f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth SourceLocation CContext) { 3029f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth // Emit the primary warning first, then try to emit a fixit hint note if 3030f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth // reasonable. 3031f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth S.Diag(FL->getExprLoc(), diag::warn_impcast_literal_float_to_integer) 3032f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth << FL->getType() << T << FL->getSourceRange() << SourceRange(CContext); 3033f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth 3034f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth const llvm::APFloat &Value = FL->getValue(); 3035f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth 3036f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth // Don't attempt to fix PPC double double literals. 3037f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth if (&Value.getSemantics() == &llvm::APFloat::PPCDoubleDouble) 3038f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth return; 3039f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth 30403e1ef7849845a9e7bf79156bbb8a2c26d77a1d2eJeffrey Yasskin // Try to convert this exactly to an integer. 3041f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth bool isExact = false; 30423e1ef7849845a9e7bf79156bbb8a2c26d77a1d2eJeffrey Yasskin llvm::APSInt IntegerValue(S.Context.getIntWidth(T), 30433e1ef7849845a9e7bf79156bbb8a2c26d77a1d2eJeffrey Yasskin T->hasUnsignedIntegerRepresentation()); 30443e1ef7849845a9e7bf79156bbb8a2c26d77a1d2eJeffrey Yasskin if (Value.convertToInteger(IntegerValue, 3045f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth llvm::APFloat::rmTowardZero, &isExact) 3046f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth != llvm::APFloat::opOK || !isExact) 3047f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth return; 3048f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth 30493e1ef7849845a9e7bf79156bbb8a2c26d77a1d2eJeffrey Yasskin std::string LiteralValue = IntegerValue.toString(10); 3050f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth S.Diag(FL->getExprLoc(), diag::note_fix_integral_float_as_integer) 3051f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth << FixItHint::CreateReplacement(FL->getSourceRange(), LiteralValue); 3052f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth} 3053f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth 3054091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCallstd::string PrettyPrintInRange(const llvm::APSInt &Value, IntRange Range) { 3055091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall if (!Range.Width) return "0"; 3056091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall 3057091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall llvm::APSInt ValueInRange = Value; 3058091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall ValueInRange.setIsSigned(!Range.NonNegative); 30599f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad ValueInRange = ValueInRange.trunc(Range.Width); 3060091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall return ValueInRange.toString(10); 3061091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall} 3062091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall 3063ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenekstatic bool isFromSystemMacro(Sema &S, SourceLocation loc) { 3064ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek SourceManager &smgr = S.Context.getSourceManager(); 3065ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek return loc.isMacroID() && smgr.isInSystemHeader(smgr.getSpellingLoc(loc)); 3066ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek} 3067f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth 3068323ed74658bc8375278eabf074b4777458376540John McCallvoid CheckImplicitConversion(Sema &S, Expr *E, QualType T, 3069b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall SourceLocation CC, bool *ICContext = 0) { 3070323ed74658bc8375278eabf074b4777458376540John McCall if (E->isTypeDependent() || E->isValueDependent()) return; 307151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 3072323ed74658bc8375278eabf074b4777458376540John McCall const Type *Source = S.Context.getCanonicalType(E->getType()).getTypePtr(); 3073323ed74658bc8375278eabf074b4777458376540John McCall const Type *Target = S.Context.getCanonicalType(T).getTypePtr(); 3074323ed74658bc8375278eabf074b4777458376540John McCall if (Source == Target) return; 3075323ed74658bc8375278eabf074b4777458376540John McCall if (Target->isDependentType()) return; 307651313c39c84407dd6a323be99a8c322bf8d052a9John McCall 3077108f756bebd991eaa980cfb9994353612a2e5ff6Chandler Carruth // If the conversion context location is invalid don't complain. We also 3078108f756bebd991eaa980cfb9994353612a2e5ff6Chandler Carruth // don't want to emit a warning if the issue occurs from the expansion of 3079108f756bebd991eaa980cfb9994353612a2e5ff6Chandler Carruth // a system macro. The problem is that 'getSpellingLoc()' is slow, so we 3080108f756bebd991eaa980cfb9994353612a2e5ff6Chandler Carruth // delay this check as long as possible. Once we detect we are in that 3081108f756bebd991eaa980cfb9994353612a2e5ff6Chandler Carruth // scenario, we just return. 3082ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek if (CC.isInvalid()) 3083b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall return; 3084b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall 308551313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Never diagnose implicit casts to bool. 308651313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (Target->isSpecificBuiltinType(BuiltinType::Bool)) 308751313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 308851313c39c84407dd6a323be99a8c322bf8d052a9John McCall 308951313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Strip vector types. 309051313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (isa<VectorType>(Source)) { 3091ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek if (!isa<VectorType>(Target)) { 3092ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek if (isFromSystemMacro(S, CC)) 3093ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek return; 3094b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall return DiagnoseImpCast(S, E, T, CC, diag::warn_impcast_vector_scalar); 3095ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek } 3096b792b30ce3d31e3eb3cfee3321238cf3cc2165b0Chris Lattner 3097b792b30ce3d31e3eb3cfee3321238cf3cc2165b0Chris Lattner // If the vector cast is cast between two vectors of the same size, it is 3098b792b30ce3d31e3eb3cfee3321238cf3cc2165b0Chris Lattner // a bitcast, not a conversion. 3099b792b30ce3d31e3eb3cfee3321238cf3cc2165b0Chris Lattner if (S.Context.getTypeSize(Source) == S.Context.getTypeSize(Target)) 3100b792b30ce3d31e3eb3cfee3321238cf3cc2165b0Chris Lattner return; 310151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 310251313c39c84407dd6a323be99a8c322bf8d052a9John McCall Source = cast<VectorType>(Source)->getElementType().getTypePtr(); 310351313c39c84407dd6a323be99a8c322bf8d052a9John McCall Target = cast<VectorType>(Target)->getElementType().getTypePtr(); 310451313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 310551313c39c84407dd6a323be99a8c322bf8d052a9John McCall 310651313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Strip complex types. 310751313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (isa<ComplexType>(Source)) { 3108ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek if (!isa<ComplexType>(Target)) { 3109ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek if (isFromSystemMacro(S, CC)) 3110ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek return; 3111ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek 3112b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall return DiagnoseImpCast(S, E, T, CC, diag::warn_impcast_complex_scalar); 3113ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek } 311451313c39c84407dd6a323be99a8c322bf8d052a9John McCall 311551313c39c84407dd6a323be99a8c322bf8d052a9John McCall Source = cast<ComplexType>(Source)->getElementType().getTypePtr(); 311651313c39c84407dd6a323be99a8c322bf8d052a9John McCall Target = cast<ComplexType>(Target)->getElementType().getTypePtr(); 311751313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 311851313c39c84407dd6a323be99a8c322bf8d052a9John McCall 311951313c39c84407dd6a323be99a8c322bf8d052a9John McCall const BuiltinType *SourceBT = dyn_cast<BuiltinType>(Source); 312051313c39c84407dd6a323be99a8c322bf8d052a9John McCall const BuiltinType *TargetBT = dyn_cast<BuiltinType>(Target); 312151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 312251313c39c84407dd6a323be99a8c322bf8d052a9John McCall // If the source is floating point... 312351313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (SourceBT && SourceBT->isFloatingPoint()) { 312451313c39c84407dd6a323be99a8c322bf8d052a9John McCall // ...and the target is floating point... 312551313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (TargetBT && TargetBT->isFloatingPoint()) { 312651313c39c84407dd6a323be99a8c322bf8d052a9John McCall // ...then warn if we're dropping FP rank. 312751313c39c84407dd6a323be99a8c322bf8d052a9John McCall 312851313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Builtin FP kinds are ordered by increasing FP rank. 312951313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (SourceBT->getKind() > TargetBT->getKind()) { 313051313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Don't warn about float constants that are precisely 313151313c39c84407dd6a323be99a8c322bf8d052a9John McCall // representable in the target type. 313251313c39c84407dd6a323be99a8c322bf8d052a9John McCall Expr::EvalResult result; 3133323ed74658bc8375278eabf074b4777458376540John McCall if (E->Evaluate(result, S.Context)) { 313451313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Value might be a float, a float vector, or a float complex. 313551313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (IsSameFloatAfterCast(result.Val, 3136323ed74658bc8375278eabf074b4777458376540John McCall S.Context.getFloatTypeSemantics(QualType(TargetBT, 0)), 3137323ed74658bc8375278eabf074b4777458376540John McCall S.Context.getFloatTypeSemantics(QualType(SourceBT, 0)))) 313851313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 313951313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 314051313c39c84407dd6a323be99a8c322bf8d052a9John McCall 3141ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek if (isFromSystemMacro(S, CC)) 3142ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek return; 3143ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek 3144b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall DiagnoseImpCast(S, E, T, CC, diag::warn_impcast_float_precision); 314551313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 314651313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 314751313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 314851313c39c84407dd6a323be99a8c322bf8d052a9John McCall 3149ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek // If the target is integral, always warn. 3150a5b9332418f25338f118358e27303cd510d54107Chandler Carruth if ((TargetBT && TargetBT->isInteger())) { 3151ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek if (isFromSystemMacro(S, CC)) 3152ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek return; 3153ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek 3154a5b9332418f25338f118358e27303cd510d54107Chandler Carruth Expr *InnerE = E->IgnoreParenImpCasts(); 3155f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth if (FloatingLiteral *FL = dyn_cast<FloatingLiteral>(InnerE)) { 3156f65076ebf5e8bc5ae7b77fe3c3a65dc5db8d763fChandler Carruth DiagnoseFloatingLiteralImpCast(S, FL, T, CC); 3157a5b9332418f25338f118358e27303cd510d54107Chandler Carruth } else { 3158a5b9332418f25338f118358e27303cd510d54107Chandler Carruth DiagnoseImpCast(S, E, T, CC, diag::warn_impcast_float_integer); 3159a5b9332418f25338f118358e27303cd510d54107Chandler Carruth } 3160a5b9332418f25338f118358e27303cd510d54107Chandler Carruth } 316151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 316251313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 316351313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 316451313c39c84407dd6a323be99a8c322bf8d052a9John McCall 3165f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (!Source->isIntegerType() || !Target->isIntegerType()) 316651313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 316751313c39c84407dd6a323be99a8c322bf8d052a9John McCall 31681838ca5618bc6c84ca3d13d84717bf32d9862bb3Richard Trieu if ((E->isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull) 31691838ca5618bc6c84ca3d13d84717bf32d9862bb3Richard Trieu == Expr::NPCK_GNUNull) && Target->isIntegerType()) { 31701838ca5618bc6c84ca3d13d84717bf32d9862bb3Richard Trieu S.Diag(E->getExprLoc(), diag::warn_impcast_null_pointer_to_integer) 31711838ca5618bc6c84ca3d13d84717bf32d9862bb3Richard Trieu << E->getSourceRange() << clang::SourceRange(CC); 31721838ca5618bc6c84ca3d13d84717bf32d9862bb3Richard Trieu return; 31731838ca5618bc6c84ca3d13d84717bf32d9862bb3Richard Trieu } 31741838ca5618bc6c84ca3d13d84717bf32d9862bb3Richard Trieu 3175323ed74658bc8375278eabf074b4777458376540John McCall IntRange SourceRange = GetExprRange(S.Context, E); 31761844a6e1074a5c1fd8eadac7fc7317c3e29d4653John McCall IntRange TargetRange = IntRange::forTargetOfCanonicalType(S.Context, Target); 317751313c39c84407dd6a323be99a8c322bf8d052a9John McCall 3178f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (SourceRange.Width > TargetRange.Width) { 3179091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall // If the source is a constant, use a default-on diagnostic. 3180091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall // TODO: this should happen for bitfield stores, too. 3181091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall llvm::APSInt Value(32); 3182091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall if (E->isIntegerConstantExpr(Value, S.Context)) { 3183ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek if (isFromSystemMacro(S, CC)) 3184ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek return; 3185ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek 3186091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall std::string PrettySourceValue = Value.toString(10); 3187091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall std::string PrettyTargetValue = PrettyPrintInRange(Value, TargetRange); 3188091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall 3189091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall S.Diag(E->getExprLoc(), diag::warn_impcast_integer_precision_constant) 3190091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall << PrettySourceValue << PrettyTargetValue 3191091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall << E->getType() << T << E->getSourceRange() << clang::SourceRange(CC); 3192091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall return; 3193091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall } 3194091f23f1d6d4bcffd6641cda72a6831e08c02ea7John McCall 3195b792b30ce3d31e3eb3cfee3321238cf3cc2165b0Chris Lattner // People want to build with -Wshorten-64-to-32 and not -Wconversion. 3196ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek if (isFromSystemMacro(S, CC)) 3197ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek return; 3198ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek 3199f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (SourceRange.Width == 64 && TargetRange.Width == 32) 3200b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall return DiagnoseImpCast(S, E, T, CC, diag::warn_impcast_integer_64_32); 3201b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall return DiagnoseImpCast(S, E, T, CC, diag::warn_impcast_integer_precision); 3202323ed74658bc8375278eabf074b4777458376540John McCall } 3203323ed74658bc8375278eabf074b4777458376540John McCall 3204323ed74658bc8375278eabf074b4777458376540John McCall if ((TargetRange.NonNegative && !SourceRange.NonNegative) || 3205323ed74658bc8375278eabf074b4777458376540John McCall (!TargetRange.NonNegative && SourceRange.NonNegative && 3206323ed74658bc8375278eabf074b4777458376540John McCall SourceRange.Width == TargetRange.Width)) { 3207ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek 3208ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek if (isFromSystemMacro(S, CC)) 3209ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek return; 3210ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek 3211323ed74658bc8375278eabf074b4777458376540John McCall unsigned DiagID = diag::warn_impcast_integer_sign; 3212323ed74658bc8375278eabf074b4777458376540John McCall 3213323ed74658bc8375278eabf074b4777458376540John McCall // Traditionally, gcc has warned about this under -Wsign-compare. 3214323ed74658bc8375278eabf074b4777458376540John McCall // We also want to warn about it in -Wconversion. 3215323ed74658bc8375278eabf074b4777458376540John McCall // So if -Wconversion is off, use a completely identical diagnostic 3216323ed74658bc8375278eabf074b4777458376540John McCall // in the sign-compare group. 3217323ed74658bc8375278eabf074b4777458376540John McCall // The conditional-checking code will 3218323ed74658bc8375278eabf074b4777458376540John McCall if (ICContext) { 3219323ed74658bc8375278eabf074b4777458376540John McCall DiagID = diag::warn_impcast_integer_sign_conditional; 3220323ed74658bc8375278eabf074b4777458376540John McCall *ICContext = true; 3221323ed74658bc8375278eabf074b4777458376540John McCall } 3222323ed74658bc8375278eabf074b4777458376540John McCall 3223b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall return DiagnoseImpCast(S, E, T, CC, DiagID); 322451313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 322551313c39c84407dd6a323be99a8c322bf8d052a9John McCall 3226284cc8d8a90ae6558e0a4b60b7dc1ddcfd220758Douglas Gregor // Diagnose conversions between different enumeration types. 32275a5b38f4afaf4f203b96a11ba79890c7cd4cc4b8Douglas Gregor // In C, we pretend that the type of an EnumConstantDecl is its enumeration 32285a5b38f4afaf4f203b96a11ba79890c7cd4cc4b8Douglas Gregor // type, to give us better diagnostics. 32295a5b38f4afaf4f203b96a11ba79890c7cd4cc4b8Douglas Gregor QualType SourceType = E->getType(); 32305a5b38f4afaf4f203b96a11ba79890c7cd4cc4b8Douglas Gregor if (!S.getLangOptions().CPlusPlus) { 32315a5b38f4afaf4f203b96a11ba79890c7cd4cc4b8Douglas Gregor if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 32325a5b38f4afaf4f203b96a11ba79890c7cd4cc4b8Douglas Gregor if (EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(DRE->getDecl())) { 32335a5b38f4afaf4f203b96a11ba79890c7cd4cc4b8Douglas Gregor EnumDecl *Enum = cast<EnumDecl>(ECD->getDeclContext()); 32345a5b38f4afaf4f203b96a11ba79890c7cd4cc4b8Douglas Gregor SourceType = S.Context.getTypeDeclType(Enum); 32355a5b38f4afaf4f203b96a11ba79890c7cd4cc4b8Douglas Gregor Source = S.Context.getCanonicalType(SourceType).getTypePtr(); 32365a5b38f4afaf4f203b96a11ba79890c7cd4cc4b8Douglas Gregor } 32375a5b38f4afaf4f203b96a11ba79890c7cd4cc4b8Douglas Gregor } 32385a5b38f4afaf4f203b96a11ba79890c7cd4cc4b8Douglas Gregor 3239284cc8d8a90ae6558e0a4b60b7dc1ddcfd220758Douglas Gregor if (const EnumType *SourceEnum = Source->getAs<EnumType>()) 3240284cc8d8a90ae6558e0a4b60b7dc1ddcfd220758Douglas Gregor if (const EnumType *TargetEnum = Target->getAs<EnumType>()) 3241284cc8d8a90ae6558e0a4b60b7dc1ddcfd220758Douglas Gregor if ((SourceEnum->getDecl()->getIdentifier() || 3242162e1c1b487352434552147967c3dd296ebee2f7Richard Smith SourceEnum->getDecl()->getTypedefNameForAnonDecl()) && 3243284cc8d8a90ae6558e0a4b60b7dc1ddcfd220758Douglas Gregor (TargetEnum->getDecl()->getIdentifier() || 3244162e1c1b487352434552147967c3dd296ebee2f7Richard Smith TargetEnum->getDecl()->getTypedefNameForAnonDecl()) && 3245ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek SourceEnum != TargetEnum) { 3246ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek if (isFromSystemMacro(S, CC)) 3247ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek return; 3248ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek 32495a5b38f4afaf4f203b96a11ba79890c7cd4cc4b8Douglas Gregor return DiagnoseImpCast(S, E, SourceType, T, CC, 3250284cc8d8a90ae6558e0a4b60b7dc1ddcfd220758Douglas Gregor diag::warn_impcast_different_enum_types); 3251ef9ff88f54ff26ac9782d98a34b74aa424149be1Ted Kremenek } 3252284cc8d8a90ae6558e0a4b60b7dc1ddcfd220758Douglas Gregor 325351313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 325451313c39c84407dd6a323be99a8c322bf8d052a9John McCall} 325551313c39c84407dd6a323be99a8c322bf8d052a9John McCall 3256323ed74658bc8375278eabf074b4777458376540John McCallvoid CheckConditionalOperator(Sema &S, ConditionalOperator *E, QualType T); 3257323ed74658bc8375278eabf074b4777458376540John McCall 3258323ed74658bc8375278eabf074b4777458376540John McCallvoid CheckConditionalOperand(Sema &S, Expr *E, QualType T, 3259b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall SourceLocation CC, bool &ICContext) { 3260323ed74658bc8375278eabf074b4777458376540John McCall E = E->IgnoreParenImpCasts(); 3261323ed74658bc8375278eabf074b4777458376540John McCall 3262323ed74658bc8375278eabf074b4777458376540John McCall if (isa<ConditionalOperator>(E)) 3263323ed74658bc8375278eabf074b4777458376540John McCall return CheckConditionalOperator(S, cast<ConditionalOperator>(E), T); 3264323ed74658bc8375278eabf074b4777458376540John McCall 3265b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall AnalyzeImplicitConversions(S, E, CC); 3266323ed74658bc8375278eabf074b4777458376540John McCall if (E->getType() != T) 3267b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall return CheckImplicitConversion(S, E, T, CC, &ICContext); 3268323ed74658bc8375278eabf074b4777458376540John McCall return; 3269323ed74658bc8375278eabf074b4777458376540John McCall} 3270323ed74658bc8375278eabf074b4777458376540John McCall 3271323ed74658bc8375278eabf074b4777458376540John McCallvoid CheckConditionalOperator(Sema &S, ConditionalOperator *E, QualType T) { 3272b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall SourceLocation CC = E->getQuestionLoc(); 3273b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall 3274b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall AnalyzeImplicitConversions(S, E->getCond(), CC); 3275323ed74658bc8375278eabf074b4777458376540John McCall 3276323ed74658bc8375278eabf074b4777458376540John McCall bool Suspicious = false; 3277b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall CheckConditionalOperand(S, E->getTrueExpr(), T, CC, Suspicious); 3278b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall CheckConditionalOperand(S, E->getFalseExpr(), T, CC, Suspicious); 3279323ed74658bc8375278eabf074b4777458376540John McCall 3280323ed74658bc8375278eabf074b4777458376540John McCall // If -Wconversion would have warned about either of the candidates 3281323ed74658bc8375278eabf074b4777458376540John McCall // for a signedness conversion to the context type... 3282323ed74658bc8375278eabf074b4777458376540John McCall if (!Suspicious) return; 3283323ed74658bc8375278eabf074b4777458376540John McCall 3284323ed74658bc8375278eabf074b4777458376540John McCall // ...but it's currently ignored... 32850827408865e32789e0ec4b8113a302ccdc531423Argyrios Kyrtzidis if (S.Diags.getDiagnosticLevel(diag::warn_impcast_integer_sign_conditional, 32860827408865e32789e0ec4b8113a302ccdc531423Argyrios Kyrtzidis CC)) 3287323ed74658bc8375278eabf074b4777458376540John McCall return; 3288323ed74658bc8375278eabf074b4777458376540John McCall 3289323ed74658bc8375278eabf074b4777458376540John McCall // ...then check whether it would have warned about either of the 3290323ed74658bc8375278eabf074b4777458376540John McCall // candidates for a signedness conversion to the condition type. 32915254161b269829b74e7a9379b1bdfa27de72d7ccRichard Trieu if (E->getType() == T) return; 32925254161b269829b74e7a9379b1bdfa27de72d7ccRichard Trieu 32935254161b269829b74e7a9379b1bdfa27de72d7ccRichard Trieu Suspicious = false; 32945254161b269829b74e7a9379b1bdfa27de72d7ccRichard Trieu CheckImplicitConversion(S, E->getTrueExpr()->IgnoreParenImpCasts(), 32955254161b269829b74e7a9379b1bdfa27de72d7ccRichard Trieu E->getType(), CC, &Suspicious); 32965254161b269829b74e7a9379b1bdfa27de72d7ccRichard Trieu if (!Suspicious) 32975254161b269829b74e7a9379b1bdfa27de72d7ccRichard Trieu CheckImplicitConversion(S, E->getFalseExpr()->IgnoreParenImpCasts(), 3298b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall E->getType(), CC, &Suspicious); 3299323ed74658bc8375278eabf074b4777458376540John McCall} 3300323ed74658bc8375278eabf074b4777458376540John McCall 3301323ed74658bc8375278eabf074b4777458376540John McCall/// AnalyzeImplicitConversions - Find and report any interesting 3302323ed74658bc8375278eabf074b4777458376540John McCall/// implicit conversions in the given expression. There are a couple 3303323ed74658bc8375278eabf074b4777458376540John McCall/// of competing diagnostics here, -Wconversion and -Wsign-compare. 3304b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCallvoid AnalyzeImplicitConversions(Sema &S, Expr *OrigE, SourceLocation CC) { 3305323ed74658bc8375278eabf074b4777458376540John McCall QualType T = OrigE->getType(); 3306323ed74658bc8375278eabf074b4777458376540John McCall Expr *E = OrigE->IgnoreParenImpCasts(); 3307323ed74658bc8375278eabf074b4777458376540John McCall 3308323ed74658bc8375278eabf074b4777458376540John McCall // For conditional operators, we analyze the arguments as if they 3309323ed74658bc8375278eabf074b4777458376540John McCall // were being fed directly into the output. 3310323ed74658bc8375278eabf074b4777458376540John McCall if (isa<ConditionalOperator>(E)) { 3311323ed74658bc8375278eabf074b4777458376540John McCall ConditionalOperator *CO = cast<ConditionalOperator>(E); 3312323ed74658bc8375278eabf074b4777458376540John McCall CheckConditionalOperator(S, CO, T); 3313323ed74658bc8375278eabf074b4777458376540John McCall return; 3314323ed74658bc8375278eabf074b4777458376540John McCall } 3315323ed74658bc8375278eabf074b4777458376540John McCall 3316323ed74658bc8375278eabf074b4777458376540John McCall // Go ahead and check any implicit conversions we might have skipped. 3317323ed74658bc8375278eabf074b4777458376540John McCall // The non-canonical typecheck is just an optimization; 3318323ed74658bc8375278eabf074b4777458376540John McCall // CheckImplicitConversion will filter out dead implicit conversions. 3319323ed74658bc8375278eabf074b4777458376540John McCall if (E->getType() != T) 3320b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall CheckImplicitConversion(S, E, T, CC); 3321323ed74658bc8375278eabf074b4777458376540John McCall 3322323ed74658bc8375278eabf074b4777458376540John McCall // Now continue drilling into this expression. 3323323ed74658bc8375278eabf074b4777458376540John McCall 3324323ed74658bc8375278eabf074b4777458376540John McCall // Skip past explicit casts. 3325323ed74658bc8375278eabf074b4777458376540John McCall if (isa<ExplicitCastExpr>(E)) { 3326323ed74658bc8375278eabf074b4777458376540John McCall E = cast<ExplicitCastExpr>(E)->getSubExpr()->IgnoreParenImpCasts(); 3327b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall return AnalyzeImplicitConversions(S, E, CC); 3328323ed74658bc8375278eabf074b4777458376540John McCall } 3329323ed74658bc8375278eabf074b4777458376540John McCall 3330beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 3331beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall // Do a somewhat different check with comparison operators. 3332beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall if (BO->isComparisonOp()) 3333beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall return AnalyzeComparison(S, BO); 3334beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall 3335beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall // And with assignments and compound assignments. 3336beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall if (BO->isAssignmentOp()) 3337beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall return AnalyzeAssignment(S, BO); 3338beb22aaa22e255241d6a81e8b0a9239f5fa584f3John McCall } 3339323ed74658bc8375278eabf074b4777458376540John McCall 3340323ed74658bc8375278eabf074b4777458376540John McCall // These break the otherwise-useful invariant below. Fortunately, 3341323ed74658bc8375278eabf074b4777458376540John McCall // we don't really need to recurse into them, because any internal 3342323ed74658bc8375278eabf074b4777458376540John McCall // expressions should have been analyzed already when they were 3343323ed74658bc8375278eabf074b4777458376540John McCall // built into statements. 3344323ed74658bc8375278eabf074b4777458376540John McCall if (isa<StmtExpr>(E)) return; 3345323ed74658bc8375278eabf074b4777458376540John McCall 3346323ed74658bc8375278eabf074b4777458376540John McCall // Don't descend into unevaluated contexts. 3347f4e3cfbe8abd124be6341ef5d714819b4fbd9082Peter Collingbourne if (isa<UnaryExprOrTypeTraitExpr>(E)) return; 3348323ed74658bc8375278eabf074b4777458376540John McCall 3349323ed74658bc8375278eabf074b4777458376540John McCall // Now just recurse over the expression's children. 3350b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall CC = E->getExprLoc(); 33517502c1d3ce8bb97bcc4f7bebef507040bd93b26fJohn McCall for (Stmt::child_range I = E->children(); I; ++I) 3352b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall AnalyzeImplicitConversions(S, cast<Expr>(*I), CC); 3353323ed74658bc8375278eabf074b4777458376540John McCall} 3354323ed74658bc8375278eabf074b4777458376540John McCall 3355323ed74658bc8375278eabf074b4777458376540John McCall} // end anonymous namespace 3356323ed74658bc8375278eabf074b4777458376540John McCall 3357323ed74658bc8375278eabf074b4777458376540John McCall/// Diagnoses "dangerous" implicit conversions within the given 3358323ed74658bc8375278eabf074b4777458376540John McCall/// expression (which is a full expression). Implements -Wconversion 3359323ed74658bc8375278eabf074b4777458376540John McCall/// and -Wsign-compare. 3360b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall/// 3361b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall/// \param CC the "context" location of the implicit conversion, i.e. 3362b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall/// the most location of the syntactic entity requiring the implicit 3363b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall/// conversion 3364b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCallvoid Sema::CheckImplicitConversions(Expr *E, SourceLocation CC) { 3365323ed74658bc8375278eabf074b4777458376540John McCall // Don't diagnose in unevaluated contexts. 3366323ed74658bc8375278eabf074b4777458376540John McCall if (ExprEvalContexts.back().Context == Sema::Unevaluated) 3367323ed74658bc8375278eabf074b4777458376540John McCall return; 3368323ed74658bc8375278eabf074b4777458376540John McCall 3369323ed74658bc8375278eabf074b4777458376540John McCall // Don't diagnose for value- or type-dependent expressions. 3370323ed74658bc8375278eabf074b4777458376540John McCall if (E->isTypeDependent() || E->isValueDependent()) 3371323ed74658bc8375278eabf074b4777458376540John McCall return; 3372323ed74658bc8375278eabf074b4777458376540John McCall 3373d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain // Check for array bounds violations in cases where the check isn't triggered 3374d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain // elsewhere for other Expr types (like BinaryOperators), e.g. when an 3375d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain // ArraySubscriptExpr is on the RHS of a variable initialization. 3376d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain CheckArrayAccess(E); 3377d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain 3378b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall // This is not the right CC for (e.g.) a variable initialization. 3379b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall AnalyzeImplicitConversions(*this, E, CC); 3380323ed74658bc8375278eabf074b4777458376540John McCall} 3381323ed74658bc8375278eabf074b4777458376540John McCall 338215d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCallvoid Sema::CheckBitFieldInitialization(SourceLocation InitLoc, 338315d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall FieldDecl *BitField, 338415d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall Expr *Init) { 338515d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall (void) AnalyzeBitFieldAssignment(*this, BitField, Init, InitLoc); 338615d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall} 338715d7d12226f83de24f96f4bf4e27ebba30fef51eJohn McCall 3388f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// CheckParmsForFunctionDef - Check that the parameters of the given 3389f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// function are appropriate for the definition of a function. This 3390f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// takes care of any checks that cannot be performed on the 3391f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// declaration itself, e.g., that the types of each of the function 3392f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// parameters are complete. 339382aa713bcda99f388836c2a30bb868d9c9974817Douglas Gregorbool Sema::CheckParmsForFunctionDef(ParmVarDecl **P, ParmVarDecl **PEnd, 339482aa713bcda99f388836c2a30bb868d9c9974817Douglas Gregor bool CheckParameterNames) { 3395f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump bool HasInvalidParm = false; 339682aa713bcda99f388836c2a30bb868d9c9974817Douglas Gregor for (; P != PEnd; ++P) { 339782aa713bcda99f388836c2a30bb868d9c9974817Douglas Gregor ParmVarDecl *Param = *P; 339882aa713bcda99f388836c2a30bb868d9c9974817Douglas Gregor 3399f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // C99 6.7.5.3p4: the parameters in a parameter type list in a 3400f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // function declarator that is part of a function definition of 3401f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // that function shall not have incomplete type. 3402f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // 3403f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // This is also C++ [dcl.fct]p6. 3404f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (!Param->isInvalidDecl() && 3405f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump RequireCompleteType(Param->getLocation(), Param->getType(), 3406f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump diag::err_typecheck_decl_incomplete_type)) { 3407f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump Param->setInvalidDecl(); 3408f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump HasInvalidParm = true; 3409f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 3410f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 3411f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // C99 6.9.1p5: If the declarator includes a parameter type list, the 3412f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // declaration of each parameter shall include an identifier. 341382aa713bcda99f388836c2a30bb868d9c9974817Douglas Gregor if (CheckParameterNames && 341482aa713bcda99f388836c2a30bb868d9c9974817Douglas Gregor Param->getIdentifier() == 0 && 3415f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump !Param->isImplicit() && 3416f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump !getLangOptions().CPlusPlus) 3417f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump Diag(Param->getLocation(), diag::err_parameter_name_omitted); 3418d17e340e2d516139931768697bf080f60920ba9dSam Weinig 3419d17e340e2d516139931768697bf080f60920ba9dSam Weinig // C99 6.7.5.3p12: 3420d17e340e2d516139931768697bf080f60920ba9dSam Weinig // If the function declarator is not part of a definition of that 3421d17e340e2d516139931768697bf080f60920ba9dSam Weinig // function, parameters may have incomplete type and may use the [*] 3422d17e340e2d516139931768697bf080f60920ba9dSam Weinig // notation in their sequences of declarator specifiers to specify 3423d17e340e2d516139931768697bf080f60920ba9dSam Weinig // variable length array types. 3424d17e340e2d516139931768697bf080f60920ba9dSam Weinig QualType PType = Param->getOriginalType(); 3425d17e340e2d516139931768697bf080f60920ba9dSam Weinig if (const ArrayType *AT = Context.getAsArrayType(PType)) { 3426d17e340e2d516139931768697bf080f60920ba9dSam Weinig if (AT->getSizeModifier() == ArrayType::Star) { 3427d17e340e2d516139931768697bf080f60920ba9dSam Weinig // FIXME: This diagnosic should point the the '[*]' if source-location 3428d17e340e2d516139931768697bf080f60920ba9dSam Weinig // information is added for it. 3429d17e340e2d516139931768697bf080f60920ba9dSam Weinig Diag(Param->getLocation(), diag::err_array_star_in_function_definition); 3430d17e340e2d516139931768697bf080f60920ba9dSam Weinig } 3431d17e340e2d516139931768697bf080f60920ba9dSam Weinig } 3432f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 3433f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 3434f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return HasInvalidParm; 3435f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump} 3436b7f4ffe073fa419613946461a2583ba2fcb72280John McCall 3437b7f4ffe073fa419613946461a2583ba2fcb72280John McCall/// CheckCastAlign - Implements -Wcast-align, which warns when a 3438b7f4ffe073fa419613946461a2583ba2fcb72280John McCall/// pointer cast increases the alignment requirements. 3439b7f4ffe073fa419613946461a2583ba2fcb72280John McCallvoid Sema::CheckCastAlign(Expr *Op, QualType T, SourceRange TRange) { 3440b7f4ffe073fa419613946461a2583ba2fcb72280John McCall // This is actually a lot of work to potentially be doing on every 3441b7f4ffe073fa419613946461a2583ba2fcb72280John McCall // cast; don't do it if we're ignoring -Wcast_align (as is the default). 34420827408865e32789e0ec4b8113a302ccdc531423Argyrios Kyrtzidis if (getDiagnostics().getDiagnosticLevel(diag::warn_cast_align, 34430827408865e32789e0ec4b8113a302ccdc531423Argyrios Kyrtzidis TRange.getBegin()) 3444b7f4ffe073fa419613946461a2583ba2fcb72280John McCall == Diagnostic::Ignored) 3445b7f4ffe073fa419613946461a2583ba2fcb72280John McCall return; 3446b7f4ffe073fa419613946461a2583ba2fcb72280John McCall 3447b7f4ffe073fa419613946461a2583ba2fcb72280John McCall // Ignore dependent types. 3448b7f4ffe073fa419613946461a2583ba2fcb72280John McCall if (T->isDependentType() || Op->getType()->isDependentType()) 3449b7f4ffe073fa419613946461a2583ba2fcb72280John McCall return; 3450b7f4ffe073fa419613946461a2583ba2fcb72280John McCall 3451b7f4ffe073fa419613946461a2583ba2fcb72280John McCall // Require that the destination be a pointer type. 3452b7f4ffe073fa419613946461a2583ba2fcb72280John McCall const PointerType *DestPtr = T->getAs<PointerType>(); 3453b7f4ffe073fa419613946461a2583ba2fcb72280John McCall if (!DestPtr) return; 3454b7f4ffe073fa419613946461a2583ba2fcb72280John McCall 3455b7f4ffe073fa419613946461a2583ba2fcb72280John McCall // If the destination has alignment 1, we're done. 3456b7f4ffe073fa419613946461a2583ba2fcb72280John McCall QualType DestPointee = DestPtr->getPointeeType(); 3457b7f4ffe073fa419613946461a2583ba2fcb72280John McCall if (DestPointee->isIncompleteType()) return; 3458b7f4ffe073fa419613946461a2583ba2fcb72280John McCall CharUnits DestAlign = Context.getTypeAlignInChars(DestPointee); 3459b7f4ffe073fa419613946461a2583ba2fcb72280John McCall if (DestAlign.isOne()) return; 3460b7f4ffe073fa419613946461a2583ba2fcb72280John McCall 3461b7f4ffe073fa419613946461a2583ba2fcb72280John McCall // Require that the source be a pointer type. 3462b7f4ffe073fa419613946461a2583ba2fcb72280John McCall const PointerType *SrcPtr = Op->getType()->getAs<PointerType>(); 3463b7f4ffe073fa419613946461a2583ba2fcb72280John McCall if (!SrcPtr) return; 3464b7f4ffe073fa419613946461a2583ba2fcb72280John McCall QualType SrcPointee = SrcPtr->getPointeeType(); 3465b7f4ffe073fa419613946461a2583ba2fcb72280John McCall 3466b7f4ffe073fa419613946461a2583ba2fcb72280John McCall // Whitelist casts from cv void*. We already implicitly 3467b7f4ffe073fa419613946461a2583ba2fcb72280John McCall // whitelisted casts to cv void*, since they have alignment 1. 3468b7f4ffe073fa419613946461a2583ba2fcb72280John McCall // Also whitelist casts involving incomplete types, which implicitly 3469b7f4ffe073fa419613946461a2583ba2fcb72280John McCall // includes 'void'. 3470b7f4ffe073fa419613946461a2583ba2fcb72280John McCall if (SrcPointee->isIncompleteType()) return; 3471b7f4ffe073fa419613946461a2583ba2fcb72280John McCall 3472b7f4ffe073fa419613946461a2583ba2fcb72280John McCall CharUnits SrcAlign = Context.getTypeAlignInChars(SrcPointee); 3473b7f4ffe073fa419613946461a2583ba2fcb72280John McCall if (SrcAlign >= DestAlign) return; 3474b7f4ffe073fa419613946461a2583ba2fcb72280John McCall 3475b7f4ffe073fa419613946461a2583ba2fcb72280John McCall Diag(TRange.getBegin(), diag::warn_cast_align) 3476b7f4ffe073fa419613946461a2583ba2fcb72280John McCall << Op->getType() << T 3477b7f4ffe073fa419613946461a2583ba2fcb72280John McCall << static_cast<unsigned>(SrcAlign.getQuantity()) 3478b7f4ffe073fa419613946461a2583ba2fcb72280John McCall << static_cast<unsigned>(DestAlign.getQuantity()) 3479b7f4ffe073fa419613946461a2583ba2fcb72280John McCall << TRange << Op->getSourceRange(); 3480b7f4ffe073fa419613946461a2583ba2fcb72280John McCall} 3481b7f4ffe073fa419613946461a2583ba2fcb72280John McCall 3482d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrainstatic const Type* getElementType(const Expr *BaseExpr) { 3483d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain const Type* EltType = BaseExpr->getType().getTypePtr(); 3484d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain if (EltType->isAnyPointerType()) 3485d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain return EltType->getPointeeType().getTypePtr(); 3486d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain else if (EltType->isArrayType()) 3487d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain return EltType->getBaseElementTypeUnsafe(); 3488d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain return EltType; 3489d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain} 3490d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain 3491c268434b332bbe57950d977633369bf5822d9554Chandler Carruth/// \brief Check whether this array fits the idiom of a size-one tail padded 3492c268434b332bbe57950d977633369bf5822d9554Chandler Carruth/// array member of a struct. 3493c268434b332bbe57950d977633369bf5822d9554Chandler Carruth/// 3494c268434b332bbe57950d977633369bf5822d9554Chandler Carruth/// We avoid emitting out-of-bounds access warnings for such arrays as they are 3495c268434b332bbe57950d977633369bf5822d9554Chandler Carruth/// commonly used to emulate flexible arrays in C89 code. 3496c268434b332bbe57950d977633369bf5822d9554Chandler Carruthstatic bool IsTailPaddedMemberArray(Sema &S, llvm::APInt Size, 3497c268434b332bbe57950d977633369bf5822d9554Chandler Carruth const NamedDecl *ND) { 3498c268434b332bbe57950d977633369bf5822d9554Chandler Carruth if (Size != 1 || !ND) return false; 3499c268434b332bbe57950d977633369bf5822d9554Chandler Carruth 3500c268434b332bbe57950d977633369bf5822d9554Chandler Carruth const FieldDecl *FD = dyn_cast<FieldDecl>(ND); 3501c268434b332bbe57950d977633369bf5822d9554Chandler Carruth if (!FD) return false; 3502c268434b332bbe57950d977633369bf5822d9554Chandler Carruth 3503c268434b332bbe57950d977633369bf5822d9554Chandler Carruth // Don't consider sizes resulting from macro expansions or template argument 3504c268434b332bbe57950d977633369bf5822d9554Chandler Carruth // substitution to form C89 tail-padded arrays. 3505c268434b332bbe57950d977633369bf5822d9554Chandler Carruth ConstantArrayTypeLoc TL = 3506c268434b332bbe57950d977633369bf5822d9554Chandler Carruth cast<ConstantArrayTypeLoc>(FD->getTypeSourceInfo()->getTypeLoc()); 3507c268434b332bbe57950d977633369bf5822d9554Chandler Carruth const Expr *SizeExpr = dyn_cast<IntegerLiteral>(TL.getSizeExpr()); 3508c268434b332bbe57950d977633369bf5822d9554Chandler Carruth if (!SizeExpr || SizeExpr->getExprLoc().isMacroID()) 3509c268434b332bbe57950d977633369bf5822d9554Chandler Carruth return false; 3510c268434b332bbe57950d977633369bf5822d9554Chandler Carruth 3511c268434b332bbe57950d977633369bf5822d9554Chandler Carruth const RecordDecl *RD = dyn_cast<RecordDecl>(FD->getDeclContext()); 3512c268434b332bbe57950d977633369bf5822d9554Chandler Carruth if (!RD || !RD->isStruct()) 3513c268434b332bbe57950d977633369bf5822d9554Chandler Carruth return false; 3514c268434b332bbe57950d977633369bf5822d9554Chandler Carruth 351522d4fed17df02f5fa07165a69228b0b0f1a73a28Benjamin Kramer // See if this is the last field decl in the record. 351622d4fed17df02f5fa07165a69228b0b0f1a73a28Benjamin Kramer const Decl *D = FD; 351722d4fed17df02f5fa07165a69228b0b0f1a73a28Benjamin Kramer while ((D = D->getNextDeclInContext())) 351822d4fed17df02f5fa07165a69228b0b0f1a73a28Benjamin Kramer if (isa<FieldDecl>(D)) 351922d4fed17df02f5fa07165a69228b0b0f1a73a28Benjamin Kramer return false; 352022d4fed17df02f5fa07165a69228b0b0f1a73a28Benjamin Kramer return true; 3521c268434b332bbe57950d977633369bf5822d9554Chandler Carruth} 3522c268434b332bbe57950d977633369bf5822d9554Chandler Carruth 3523d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrainvoid Sema::CheckArrayAccess(const Expr *BaseExpr, const Expr *IndexExpr, 3524d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain bool isSubscript, bool AllowOnePastEnd) { 3525d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain const Type* EffectiveType = getElementType(BaseExpr); 3526d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain BaseExpr = BaseExpr->IgnoreParenCasts(); 3527d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain IndexExpr = IndexExpr->IgnoreParenCasts(); 3528d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain 35293406458512c3cdfe2076c46b9aedb4621297efd5Chandler Carruth const ConstantArrayType *ArrayTy = 3530d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain Context.getAsConstantArrayType(BaseExpr->getType()); 35313406458512c3cdfe2076c46b9aedb4621297efd5Chandler Carruth if (!ArrayTy) 3532a0125d8520f65aca581378c235384e7affefa1fcTed Kremenek return; 353335001ca261f895817916b468379b696d6d45959dChandler Carruth 35343406458512c3cdfe2076c46b9aedb4621297efd5Chandler Carruth if (IndexExpr->isValueDependent()) 3535a0125d8520f65aca581378c235384e7affefa1fcTed Kremenek return; 35363406458512c3cdfe2076c46b9aedb4621297efd5Chandler Carruth llvm::APSInt index; 3537d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain if (!IndexExpr->isIntegerConstantExpr(index, Context)) 3538a0125d8520f65aca581378c235384e7affefa1fcTed Kremenek return; 35398fd0a5dfb025a51f48b7931b95efbf35d3c5dfc3Ted Kremenek 3540ba44712b0e578a851751e199bb75dbbff5836fedChandler Carruth const NamedDecl *ND = NULL; 3541ba44712b0e578a851751e199bb75dbbff5836fedChandler Carruth if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(BaseExpr)) 3542ba44712b0e578a851751e199bb75dbbff5836fedChandler Carruth ND = dyn_cast<NamedDecl>(DRE->getDecl()); 3543c268434b332bbe57950d977633369bf5822d9554Chandler Carruth if (const MemberExpr *ME = dyn_cast<MemberExpr>(BaseExpr)) 3544ba44712b0e578a851751e199bb75dbbff5836fedChandler Carruth ND = dyn_cast<NamedDecl>(ME->getMemberDecl()); 3545ba44712b0e578a851751e199bb75dbbff5836fedChandler Carruth 35469e060ca641a1f845cecb3371b3a3018d306a5198Ted Kremenek if (index.isUnsigned() || !index.isNegative()) { 354725b3b849e3ad340b04442707038c86980035765bTed Kremenek llvm::APInt size = ArrayTy->getSize(); 354835001ca261f895817916b468379b696d6d45959dChandler Carruth if (!size.isStrictlyPositive()) 354935001ca261f895817916b468379b696d6d45959dChandler Carruth return; 3550d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain 3551d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain const Type* BaseType = getElementType(BaseExpr); 3552d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain if (!isSubscript && BaseType != EffectiveType) { 3553d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain // Make sure we're comparing apples to apples when comparing index to size 3554d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain uint64_t ptrarith_typesize = Context.getTypeSize(EffectiveType); 3555d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain uint64_t array_typesize = Context.getTypeSize(BaseType); 3556d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain if (ptrarith_typesize != array_typesize) { 3557d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain // There's a cast to a different size type involved 3558d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain uint64_t ratio = array_typesize / ptrarith_typesize; 3559d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain // TODO: Be smarter about handling cases where array_typesize is not a 3560d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain // multiple of ptrarith_typesize 3561d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain if (ptrarith_typesize * ratio == array_typesize) 3562d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain size *= llvm::APInt(size.getBitWidth(), ratio); 3563d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain } 3564d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain } 3565d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain 35663406458512c3cdfe2076c46b9aedb4621297efd5Chandler Carruth if (size.getBitWidth() > index.getBitWidth()) 35673406458512c3cdfe2076c46b9aedb4621297efd5Chandler Carruth index = index.sext(size.getBitWidth()); 356825b3b849e3ad340b04442707038c86980035765bTed Kremenek else if (size.getBitWidth() < index.getBitWidth()) 356925b3b849e3ad340b04442707038c86980035765bTed Kremenek size = size.sext(index.getBitWidth()); 357025b3b849e3ad340b04442707038c86980035765bTed Kremenek 3571d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain // For array subscripting the index must be less than size, but for pointer 3572d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain // arithmetic also allow the index (offset) to be equal to size since 3573d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain // computing the next address after the end of the array is legal and 3574d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain // commonly done e.g. in C++ iterators and range-based for loops. 3575d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain if (AllowOnePastEnd ? index.sle(size) : index.slt(size)) 3576ba44712b0e578a851751e199bb75dbbff5836fedChandler Carruth return; 3577ba44712b0e578a851751e199bb75dbbff5836fedChandler Carruth 3578ba44712b0e578a851751e199bb75dbbff5836fedChandler Carruth // Also don't warn for arrays of size 1 which are members of some 3579ba44712b0e578a851751e199bb75dbbff5836fedChandler Carruth // structure. These are often used to approximate flexible arrays in C89 3580ba44712b0e578a851751e199bb75dbbff5836fedChandler Carruth // code. 3581d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain if (IsTailPaddedMemberArray(*this, size, ND)) 35828fd0a5dfb025a51f48b7931b95efbf35d3c5dfc3Ted Kremenek return; 35833406458512c3cdfe2076c46b9aedb4621297efd5Chandler Carruth 3584d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain unsigned DiagID = diag::warn_ptr_arith_exceeds_bounds; 3585d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain if (isSubscript) 3586d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain DiagID = diag::warn_array_index_exceeds_bounds; 3587d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain 3588d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain DiagRuntimeBehavior(BaseExpr->getLocStart(), BaseExpr, 3589d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain PDiag(DiagID) << index.toString(10, true) 3590d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain << size.toString(10, true) 3591d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain << (unsigned)size.getLimitedValue(~0U) 3592d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain << IndexExpr->getSourceRange()); 35933406458512c3cdfe2076c46b9aedb4621297efd5Chandler Carruth } else { 3594d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain unsigned DiagID = diag::warn_array_index_precedes_bounds; 3595d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain if (!isSubscript) { 3596d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain DiagID = diag::warn_ptr_arith_precedes_bounds; 3597d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain if (index.isNegative()) index = -index; 3598d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain } 3599d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain 3600d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain DiagRuntimeBehavior(BaseExpr->getLocStart(), BaseExpr, 3601d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain PDiag(DiagID) << index.toString(10, true) 3602d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain << IndexExpr->getSourceRange()); 3603a0125d8520f65aca581378c235384e7affefa1fcTed Kremenek } 360435001ca261f895817916b468379b696d6d45959dChandler Carruth 360535001ca261f895817916b468379b696d6d45959dChandler Carruth if (ND) 3606d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain DiagRuntimeBehavior(ND->getLocStart(), BaseExpr, 3607d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain PDiag(diag::note_array_index_out_of_bounds) 3608d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain << ND->getDeclName()); 36093aea4dac830cb03d883a13ab30c28a3a53beca58Ted Kremenek} 36103aea4dac830cb03d883a13ab30c28a3a53beca58Ted Kremenek 36113aea4dac830cb03d883a13ab30c28a3a53beca58Ted Kremenekvoid Sema::CheckArrayAccess(const Expr *expr) { 3612d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain int AllowOnePastEnd = 0; 3613d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain while (expr) { 3614d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain expr = expr->IgnoreParenImpCasts(); 36153aea4dac830cb03d883a13ab30c28a3a53beca58Ted Kremenek switch (expr->getStmtClass()) { 3616d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain case Stmt::ArraySubscriptExprClass: { 3617d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain const ArraySubscriptExpr *ASE = cast<ArraySubscriptExpr>(expr); 3618d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain CheckArrayAccess(ASE->getBase(), ASE->getIdx(), true, 3619d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain AllowOnePastEnd > 0); 36203aea4dac830cb03d883a13ab30c28a3a53beca58Ted Kremenek return; 3621d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain } 3622d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain case Stmt::UnaryOperatorClass: { 3623d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain // Only unwrap the * and & unary operators 3624d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain const UnaryOperator *UO = cast<UnaryOperator>(expr); 3625d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain expr = UO->getSubExpr(); 3626d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain switch (UO->getOpcode()) { 3627d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain case UO_AddrOf: 3628d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain AllowOnePastEnd++; 3629d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain break; 3630d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain case UO_Deref: 3631d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain AllowOnePastEnd--; 3632d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain break; 3633d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain default: 3634d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain return; 3635d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain } 3636d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain break; 3637d6c8865e6f306556b7eef972ceec2cc8ba026a0dKaelyn Uhrain } 36383aea4dac830cb03d883a13ab30c28a3a53beca58Ted Kremenek case Stmt::ConditionalOperatorClass: { 36393aea4dac830cb03d883a13ab30c28a3a53beca58Ted Kremenek const ConditionalOperator *cond = cast<ConditionalOperator>(expr); 36403aea4dac830cb03d883a13ab30c28a3a53beca58Ted Kremenek if (const Expr *lhs = cond->getLHS()) 36413aea4dac830cb03d883a13ab30c28a3a53beca58Ted Kremenek CheckArrayAccess(lhs); 36423aea4dac830cb03d883a13ab30c28a3a53beca58Ted Kremenek if (const Expr *rhs = cond->getRHS()) 36433aea4dac830cb03d883a13ab30c28a3a53beca58Ted Kremenek CheckArrayAccess(rhs); 36443aea4dac830cb03d883a13ab30c28a3a53beca58Ted Kremenek return; 36453aea4dac830cb03d883a13ab30c28a3a53beca58Ted Kremenek } 36463aea4dac830cb03d883a13ab30c28a3a53beca58Ted Kremenek default: 36473aea4dac830cb03d883a13ab30c28a3a53beca58Ted Kremenek return; 36483aea4dac830cb03d883a13ab30c28a3a53beca58Ted Kremenek } 3649f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne } 3650a0125d8520f65aca581378c235384e7affefa1fcTed Kremenek} 3651f85e193739c953358c865005855253af4f68a497John McCall 3652f85e193739c953358c865005855253af4f68a497John McCall//===--- CHECK: Objective-C retain cycles ----------------------------------// 3653f85e193739c953358c865005855253af4f68a497John McCall 3654f85e193739c953358c865005855253af4f68a497John McCallnamespace { 3655f85e193739c953358c865005855253af4f68a497John McCall struct RetainCycleOwner { 3656f85e193739c953358c865005855253af4f68a497John McCall RetainCycleOwner() : Variable(0), Indirect(false) {} 3657f85e193739c953358c865005855253af4f68a497John McCall VarDecl *Variable; 3658f85e193739c953358c865005855253af4f68a497John McCall SourceRange Range; 3659f85e193739c953358c865005855253af4f68a497John McCall SourceLocation Loc; 3660f85e193739c953358c865005855253af4f68a497John McCall bool Indirect; 3661f85e193739c953358c865005855253af4f68a497John McCall 3662f85e193739c953358c865005855253af4f68a497John McCall void setLocsFrom(Expr *e) { 3663f85e193739c953358c865005855253af4f68a497John McCall Loc = e->getExprLoc(); 3664f85e193739c953358c865005855253af4f68a497John McCall Range = e->getSourceRange(); 3665f85e193739c953358c865005855253af4f68a497John McCall } 3666f85e193739c953358c865005855253af4f68a497John McCall }; 3667f85e193739c953358c865005855253af4f68a497John McCall} 3668f85e193739c953358c865005855253af4f68a497John McCall 3669f85e193739c953358c865005855253af4f68a497John McCall/// Consider whether capturing the given variable can possibly lead to 3670f85e193739c953358c865005855253af4f68a497John McCall/// a retain cycle. 3671f85e193739c953358c865005855253af4f68a497John McCallstatic bool considerVariable(VarDecl *var, Expr *ref, RetainCycleOwner &owner) { 3672f85e193739c953358c865005855253af4f68a497John McCall // In ARC, it's captured strongly iff the variable has __strong 3673f85e193739c953358c865005855253af4f68a497John McCall // lifetime. In MRR, it's captured strongly if the variable is 3674f85e193739c953358c865005855253af4f68a497John McCall // __block and has an appropriate type. 3675f85e193739c953358c865005855253af4f68a497John McCall if (var->getType().getObjCLifetime() != Qualifiers::OCL_Strong) 3676f85e193739c953358c865005855253af4f68a497John McCall return false; 3677f85e193739c953358c865005855253af4f68a497John McCall 3678f85e193739c953358c865005855253af4f68a497John McCall owner.Variable = var; 3679f85e193739c953358c865005855253af4f68a497John McCall owner.setLocsFrom(ref); 3680f85e193739c953358c865005855253af4f68a497John McCall return true; 3681f85e193739c953358c865005855253af4f68a497John McCall} 3682f85e193739c953358c865005855253af4f68a497John McCall 3683f85e193739c953358c865005855253af4f68a497John McCallstatic bool findRetainCycleOwner(Expr *e, RetainCycleOwner &owner) { 3684f85e193739c953358c865005855253af4f68a497John McCall while (true) { 3685f85e193739c953358c865005855253af4f68a497John McCall e = e->IgnoreParens(); 3686f85e193739c953358c865005855253af4f68a497John McCall if (CastExpr *cast = dyn_cast<CastExpr>(e)) { 3687f85e193739c953358c865005855253af4f68a497John McCall switch (cast->getCastKind()) { 3688f85e193739c953358c865005855253af4f68a497John McCall case CK_BitCast: 3689f85e193739c953358c865005855253af4f68a497John McCall case CK_LValueBitCast: 3690f85e193739c953358c865005855253af4f68a497John McCall case CK_LValueToRValue: 36917e5e5f4cc36fe50f46ad76dca7a266434c94f475John McCall case CK_ObjCReclaimReturnedObject: 3692f85e193739c953358c865005855253af4f68a497John McCall e = cast->getSubExpr(); 3693f85e193739c953358c865005855253af4f68a497John McCall continue; 3694f85e193739c953358c865005855253af4f68a497John McCall 3695f85e193739c953358c865005855253af4f68a497John McCall case CK_GetObjCProperty: { 3696f85e193739c953358c865005855253af4f68a497John McCall // Bail out if this isn't a strong explicit property. 3697f85e193739c953358c865005855253af4f68a497John McCall const ObjCPropertyRefExpr *pre = cast->getSubExpr()->getObjCProperty(); 3698f85e193739c953358c865005855253af4f68a497John McCall if (pre->isImplicitProperty()) return false; 3699f85e193739c953358c865005855253af4f68a497John McCall ObjCPropertyDecl *property = pre->getExplicitProperty(); 3700f85e193739c953358c865005855253af4f68a497John McCall if (!(property->getPropertyAttributes() & 3701f85e193739c953358c865005855253af4f68a497John McCall (ObjCPropertyDecl::OBJC_PR_retain | 3702f85e193739c953358c865005855253af4f68a497John McCall ObjCPropertyDecl::OBJC_PR_copy | 3703f85e193739c953358c865005855253af4f68a497John McCall ObjCPropertyDecl::OBJC_PR_strong)) && 3704f85e193739c953358c865005855253af4f68a497John McCall !(property->getPropertyIvarDecl() && 3705f85e193739c953358c865005855253af4f68a497John McCall property->getPropertyIvarDecl()->getType() 3706f85e193739c953358c865005855253af4f68a497John McCall .getObjCLifetime() == Qualifiers::OCL_Strong)) 3707f85e193739c953358c865005855253af4f68a497John McCall return false; 3708f85e193739c953358c865005855253af4f68a497John McCall 3709f85e193739c953358c865005855253af4f68a497John McCall owner.Indirect = true; 3710f85e193739c953358c865005855253af4f68a497John McCall e = const_cast<Expr*>(pre->getBase()); 3711f85e193739c953358c865005855253af4f68a497John McCall continue; 3712f85e193739c953358c865005855253af4f68a497John McCall } 3713f85e193739c953358c865005855253af4f68a497John McCall 3714f85e193739c953358c865005855253af4f68a497John McCall default: 3715f85e193739c953358c865005855253af4f68a497John McCall return false; 3716f85e193739c953358c865005855253af4f68a497John McCall } 3717f85e193739c953358c865005855253af4f68a497John McCall } 3718f85e193739c953358c865005855253af4f68a497John McCall 3719f85e193739c953358c865005855253af4f68a497John McCall if (ObjCIvarRefExpr *ref = dyn_cast<ObjCIvarRefExpr>(e)) { 3720f85e193739c953358c865005855253af4f68a497John McCall ObjCIvarDecl *ivar = ref->getDecl(); 3721f85e193739c953358c865005855253af4f68a497John McCall if (ivar->getType().getObjCLifetime() != Qualifiers::OCL_Strong) 3722f85e193739c953358c865005855253af4f68a497John McCall return false; 3723f85e193739c953358c865005855253af4f68a497John McCall 3724f85e193739c953358c865005855253af4f68a497John McCall // Try to find a retain cycle in the base. 3725f85e193739c953358c865005855253af4f68a497John McCall if (!findRetainCycleOwner(ref->getBase(), owner)) 3726f85e193739c953358c865005855253af4f68a497John McCall return false; 3727f85e193739c953358c865005855253af4f68a497John McCall 3728f85e193739c953358c865005855253af4f68a497John McCall if (ref->isFreeIvar()) owner.setLocsFrom(ref); 3729f85e193739c953358c865005855253af4f68a497John McCall owner.Indirect = true; 3730f85e193739c953358c865005855253af4f68a497John McCall return true; 3731f85e193739c953358c865005855253af4f68a497John McCall } 3732f85e193739c953358c865005855253af4f68a497John McCall 3733f85e193739c953358c865005855253af4f68a497John McCall if (DeclRefExpr *ref = dyn_cast<DeclRefExpr>(e)) { 3734f85e193739c953358c865005855253af4f68a497John McCall VarDecl *var = dyn_cast<VarDecl>(ref->getDecl()); 3735f85e193739c953358c865005855253af4f68a497John McCall if (!var) return false; 3736f85e193739c953358c865005855253af4f68a497John McCall return considerVariable(var, ref, owner); 3737f85e193739c953358c865005855253af4f68a497John McCall } 3738f85e193739c953358c865005855253af4f68a497John McCall 3739f85e193739c953358c865005855253af4f68a497John McCall if (BlockDeclRefExpr *ref = dyn_cast<BlockDeclRefExpr>(e)) { 3740f85e193739c953358c865005855253af4f68a497John McCall owner.Variable = ref->getDecl(); 3741f85e193739c953358c865005855253af4f68a497John McCall owner.setLocsFrom(ref); 3742f85e193739c953358c865005855253af4f68a497John McCall return true; 3743f85e193739c953358c865005855253af4f68a497John McCall } 3744f85e193739c953358c865005855253af4f68a497John McCall 3745f85e193739c953358c865005855253af4f68a497John McCall if (MemberExpr *member = dyn_cast<MemberExpr>(e)) { 3746f85e193739c953358c865005855253af4f68a497John McCall if (member->isArrow()) return false; 3747f85e193739c953358c865005855253af4f68a497John McCall 3748f85e193739c953358c865005855253af4f68a497John McCall // Don't count this as an indirect ownership. 3749f85e193739c953358c865005855253af4f68a497John McCall e = member->getBase(); 3750f85e193739c953358c865005855253af4f68a497John McCall continue; 3751f85e193739c953358c865005855253af4f68a497John McCall } 3752f85e193739c953358c865005855253af4f68a497John McCall 3753f85e193739c953358c865005855253af4f68a497John McCall // Array ivars? 3754f85e193739c953358c865005855253af4f68a497John McCall 3755f85e193739c953358c865005855253af4f68a497John McCall return false; 3756f85e193739c953358c865005855253af4f68a497John McCall } 3757f85e193739c953358c865005855253af4f68a497John McCall} 3758f85e193739c953358c865005855253af4f68a497John McCall 3759f85e193739c953358c865005855253af4f68a497John McCallnamespace { 3760f85e193739c953358c865005855253af4f68a497John McCall struct FindCaptureVisitor : EvaluatedExprVisitor<FindCaptureVisitor> { 3761f85e193739c953358c865005855253af4f68a497John McCall FindCaptureVisitor(ASTContext &Context, VarDecl *variable) 3762f85e193739c953358c865005855253af4f68a497John McCall : EvaluatedExprVisitor<FindCaptureVisitor>(Context), 3763f85e193739c953358c865005855253af4f68a497John McCall Variable(variable), Capturer(0) {} 3764f85e193739c953358c865005855253af4f68a497John McCall 3765f85e193739c953358c865005855253af4f68a497John McCall VarDecl *Variable; 3766f85e193739c953358c865005855253af4f68a497John McCall Expr *Capturer; 3767f85e193739c953358c865005855253af4f68a497John McCall 3768f85e193739c953358c865005855253af4f68a497John McCall void VisitDeclRefExpr(DeclRefExpr *ref) { 3769f85e193739c953358c865005855253af4f68a497John McCall if (ref->getDecl() == Variable && !Capturer) 3770f85e193739c953358c865005855253af4f68a497John McCall Capturer = ref; 3771f85e193739c953358c865005855253af4f68a497John McCall } 3772f85e193739c953358c865005855253af4f68a497John McCall 3773f85e193739c953358c865005855253af4f68a497John McCall void VisitBlockDeclRefExpr(BlockDeclRefExpr *ref) { 3774f85e193739c953358c865005855253af4f68a497John McCall if (ref->getDecl() == Variable && !Capturer) 3775f85e193739c953358c865005855253af4f68a497John McCall Capturer = ref; 3776f85e193739c953358c865005855253af4f68a497John McCall } 3777f85e193739c953358c865005855253af4f68a497John McCall 3778f85e193739c953358c865005855253af4f68a497John McCall void VisitObjCIvarRefExpr(ObjCIvarRefExpr *ref) { 3779f85e193739c953358c865005855253af4f68a497John McCall if (Capturer) return; 3780f85e193739c953358c865005855253af4f68a497John McCall Visit(ref->getBase()); 3781f85e193739c953358c865005855253af4f68a497John McCall if (Capturer && ref->isFreeIvar()) 3782f85e193739c953358c865005855253af4f68a497John McCall Capturer = ref; 3783f85e193739c953358c865005855253af4f68a497John McCall } 3784f85e193739c953358c865005855253af4f68a497John McCall 3785f85e193739c953358c865005855253af4f68a497John McCall void VisitBlockExpr(BlockExpr *block) { 3786f85e193739c953358c865005855253af4f68a497John McCall // Look inside nested blocks 3787f85e193739c953358c865005855253af4f68a497John McCall if (block->getBlockDecl()->capturesVariable(Variable)) 3788f85e193739c953358c865005855253af4f68a497John McCall Visit(block->getBlockDecl()->getBody()); 3789f85e193739c953358c865005855253af4f68a497John McCall } 3790f85e193739c953358c865005855253af4f68a497John McCall }; 3791f85e193739c953358c865005855253af4f68a497John McCall} 3792f85e193739c953358c865005855253af4f68a497John McCall 3793f85e193739c953358c865005855253af4f68a497John McCall/// Check whether the given argument is a block which captures a 3794f85e193739c953358c865005855253af4f68a497John McCall/// variable. 3795f85e193739c953358c865005855253af4f68a497John McCallstatic Expr *findCapturingExpr(Sema &S, Expr *e, RetainCycleOwner &owner) { 3796f85e193739c953358c865005855253af4f68a497John McCall assert(owner.Variable && owner.Loc.isValid()); 3797f85e193739c953358c865005855253af4f68a497John McCall 3798f85e193739c953358c865005855253af4f68a497John McCall e = e->IgnoreParenCasts(); 3799f85e193739c953358c865005855253af4f68a497John McCall BlockExpr *block = dyn_cast<BlockExpr>(e); 3800f85e193739c953358c865005855253af4f68a497John McCall if (!block || !block->getBlockDecl()->capturesVariable(owner.Variable)) 3801f85e193739c953358c865005855253af4f68a497John McCall return 0; 3802f85e193739c953358c865005855253af4f68a497John McCall 3803f85e193739c953358c865005855253af4f68a497John McCall FindCaptureVisitor visitor(S.Context, owner.Variable); 3804f85e193739c953358c865005855253af4f68a497John McCall visitor.Visit(block->getBlockDecl()->getBody()); 3805f85e193739c953358c865005855253af4f68a497John McCall return visitor.Capturer; 3806f85e193739c953358c865005855253af4f68a497John McCall} 3807f85e193739c953358c865005855253af4f68a497John McCall 3808f85e193739c953358c865005855253af4f68a497John McCallstatic void diagnoseRetainCycle(Sema &S, Expr *capturer, 3809f85e193739c953358c865005855253af4f68a497John McCall RetainCycleOwner &owner) { 3810f85e193739c953358c865005855253af4f68a497John McCall assert(capturer); 3811f85e193739c953358c865005855253af4f68a497John McCall assert(owner.Variable && owner.Loc.isValid()); 3812f85e193739c953358c865005855253af4f68a497John McCall 3813f85e193739c953358c865005855253af4f68a497John McCall S.Diag(capturer->getExprLoc(), diag::warn_arc_retain_cycle) 3814f85e193739c953358c865005855253af4f68a497John McCall << owner.Variable << capturer->getSourceRange(); 3815f85e193739c953358c865005855253af4f68a497John McCall S.Diag(owner.Loc, diag::note_arc_retain_cycle_owner) 3816f85e193739c953358c865005855253af4f68a497John McCall << owner.Indirect << owner.Range; 3817f85e193739c953358c865005855253af4f68a497John McCall} 3818f85e193739c953358c865005855253af4f68a497John McCall 3819f85e193739c953358c865005855253af4f68a497John McCall/// Check for a keyword selector that starts with the word 'add' or 3820f85e193739c953358c865005855253af4f68a497John McCall/// 'set'. 3821f85e193739c953358c865005855253af4f68a497John McCallstatic bool isSetterLikeSelector(Selector sel) { 3822f85e193739c953358c865005855253af4f68a497John McCall if (sel.isUnarySelector()) return false; 3823f85e193739c953358c865005855253af4f68a497John McCall 38245f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner StringRef str = sel.getNameForSlot(0); 3825f85e193739c953358c865005855253af4f68a497John McCall while (!str.empty() && str.front() == '_') str = str.substr(1); 3826f85e193739c953358c865005855253af4f68a497John McCall if (str.startswith("set") || str.startswith("add")) 3827f85e193739c953358c865005855253af4f68a497John McCall str = str.substr(3); 3828f85e193739c953358c865005855253af4f68a497John McCall else 3829f85e193739c953358c865005855253af4f68a497John McCall return false; 3830f85e193739c953358c865005855253af4f68a497John McCall 3831f85e193739c953358c865005855253af4f68a497John McCall if (str.empty()) return true; 3832f85e193739c953358c865005855253af4f68a497John McCall return !islower(str.front()); 3833f85e193739c953358c865005855253af4f68a497John McCall} 3834f85e193739c953358c865005855253af4f68a497John McCall 3835f85e193739c953358c865005855253af4f68a497John McCall/// Check a message send to see if it's likely to cause a retain cycle. 3836f85e193739c953358c865005855253af4f68a497John McCallvoid Sema::checkRetainCycles(ObjCMessageExpr *msg) { 3837f85e193739c953358c865005855253af4f68a497John McCall // Only check instance methods whose selector looks like a setter. 3838f85e193739c953358c865005855253af4f68a497John McCall if (!msg->isInstanceMessage() || !isSetterLikeSelector(msg->getSelector())) 3839f85e193739c953358c865005855253af4f68a497John McCall return; 3840f85e193739c953358c865005855253af4f68a497John McCall 3841f85e193739c953358c865005855253af4f68a497John McCall // Try to find a variable that the receiver is strongly owned by. 3842f85e193739c953358c865005855253af4f68a497John McCall RetainCycleOwner owner; 3843f85e193739c953358c865005855253af4f68a497John McCall if (msg->getReceiverKind() == ObjCMessageExpr::Instance) { 3844f85e193739c953358c865005855253af4f68a497John McCall if (!findRetainCycleOwner(msg->getInstanceReceiver(), owner)) 3845f85e193739c953358c865005855253af4f68a497John McCall return; 3846f85e193739c953358c865005855253af4f68a497John McCall } else { 3847f85e193739c953358c865005855253af4f68a497John McCall assert(msg->getReceiverKind() == ObjCMessageExpr::SuperInstance); 3848f85e193739c953358c865005855253af4f68a497John McCall owner.Variable = getCurMethodDecl()->getSelfDecl(); 3849f85e193739c953358c865005855253af4f68a497John McCall owner.Loc = msg->getSuperLoc(); 3850f85e193739c953358c865005855253af4f68a497John McCall owner.Range = msg->getSuperLoc(); 3851f85e193739c953358c865005855253af4f68a497John McCall } 3852f85e193739c953358c865005855253af4f68a497John McCall 3853f85e193739c953358c865005855253af4f68a497John McCall // Check whether the receiver is captured by any of the arguments. 3854f85e193739c953358c865005855253af4f68a497John McCall for (unsigned i = 0, e = msg->getNumArgs(); i != e; ++i) 3855f85e193739c953358c865005855253af4f68a497John McCall if (Expr *capturer = findCapturingExpr(*this, msg->getArg(i), owner)) 3856f85e193739c953358c865005855253af4f68a497John McCall return diagnoseRetainCycle(*this, capturer, owner); 3857f85e193739c953358c865005855253af4f68a497John McCall} 3858f85e193739c953358c865005855253af4f68a497John McCall 3859f85e193739c953358c865005855253af4f68a497John McCall/// Check a property assign to see if it's likely to cause a retain cycle. 3860f85e193739c953358c865005855253af4f68a497John McCallvoid Sema::checkRetainCycles(Expr *receiver, Expr *argument) { 3861f85e193739c953358c865005855253af4f68a497John McCall RetainCycleOwner owner; 3862f85e193739c953358c865005855253af4f68a497John McCall if (!findRetainCycleOwner(receiver, owner)) 3863f85e193739c953358c865005855253af4f68a497John McCall return; 3864f85e193739c953358c865005855253af4f68a497John McCall 3865f85e193739c953358c865005855253af4f68a497John McCall if (Expr *capturer = findCapturingExpr(*this, argument, owner)) 3866f85e193739c953358c865005855253af4f68a497John McCall diagnoseRetainCycle(*this, capturer, owner); 3867f85e193739c953358c865005855253af4f68a497John McCall} 3868f85e193739c953358c865005855253af4f68a497John McCall 3869921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanianbool Sema::checkUnsafeAssigns(SourceLocation Loc, 3870f85e193739c953358c865005855253af4f68a497John McCall QualType LHS, Expr *RHS) { 3871f85e193739c953358c865005855253af4f68a497John McCall Qualifiers::ObjCLifetime LT = LHS.getObjCLifetime(); 3872f85e193739c953358c865005855253af4f68a497John McCall if (LT != Qualifiers::OCL_Weak && LT != Qualifiers::OCL_ExplicitNone) 3873921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian return false; 3874921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian // strip off any implicit cast added to get to the one arc-specific 3875921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian while (ImplicitCastExpr *cast = dyn_cast<ImplicitCastExpr>(RHS)) { 3876921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian if (cast->getCastKind() == CK_ObjCConsumeObject) { 3877f85e193739c953358c865005855253af4f68a497John McCall Diag(Loc, diag::warn_arc_retained_assign) 3878f85e193739c953358c865005855253af4f68a497John McCall << (LT == Qualifiers::OCL_ExplicitNone) 3879f85e193739c953358c865005855253af4f68a497John McCall << RHS->getSourceRange(); 3880921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian return true; 3881921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian } 3882921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian RHS = cast->getSubExpr(); 3883921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian } 3884921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian return false; 3885f85e193739c953358c865005855253af4f68a497John McCall} 3886f85e193739c953358c865005855253af4f68a497John McCall 3887921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanianvoid Sema::checkUnsafeExprAssigns(SourceLocation Loc, 3888921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian Expr *LHS, Expr *RHS) { 3889921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian QualType LHSType = LHS->getType(); 3890921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian if (checkUnsafeAssigns(Loc, LHSType, RHS)) 3891921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian return; 3892921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian Qualifiers::ObjCLifetime LT = LHSType.getObjCLifetime(); 3893921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian // FIXME. Check for other life times. 3894921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian if (LT != Qualifiers::OCL_None) 3895921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian return; 3896921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian 3897921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian if (ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(LHS)) { 3898921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian if (PRE->isImplicitProperty()) 3899921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian return; 3900921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian const ObjCPropertyDecl *PD = PRE->getExplicitProperty(); 3901921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian if (!PD) 3902921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian return; 3903921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian 3904921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian unsigned Attributes = PD->getPropertyAttributes(); 3905921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian if (Attributes & ObjCPropertyDecl::OBJC_PR_assign) 3906921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian while (ImplicitCastExpr *cast = dyn_cast<ImplicitCastExpr>(RHS)) { 3907921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian if (cast->getCastKind() == CK_ObjCConsumeObject) { 3908921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian Diag(Loc, diag::warn_arc_retained_property_assign) 3909921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian << RHS->getSourceRange(); 3910921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian return; 3911921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian } 3912921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian RHS = cast->getSubExpr(); 3913921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian } 3914921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian } 3915921c14322977253a60dcb171f45e468c95fe41f8Fariborz Jahanian} 3916